From 0f10fada1b03fcaaf2543cf0e660720fb55a1d4e Mon Sep 17 00:00:00 2001 From: Mark Kim Date: Thu, 9 Nov 2023 09:37:20 -0500 Subject: [PATCH] add unit tests --- .../src/sync/vcs/__tests__/database.mock.ts | 426 ++++++++++++++++++ ...migrate-projects-into-organizatino.test.ts | 261 ++++++++--- .../vcs/migrate-projects-into-organization.ts | 17 +- 3 files changed, 639 insertions(+), 65 deletions(-) create mode 100644 packages/insomnia/src/sync/vcs/__tests__/database.mock.ts diff --git a/packages/insomnia/src/sync/vcs/__tests__/database.mock.ts b/packages/insomnia/src/sync/vcs/__tests__/database.mock.ts new file mode 100644 index 0000000000..e85837a3a0 --- /dev/null +++ b/packages/insomnia/src/sync/vcs/__tests__/database.mock.ts @@ -0,0 +1,426 @@ +import { database as db } from '../../../common/database'; +import * as models from '../../../models'; +import { Project } from '../../../models/project'; +import { Request } from '../../../models/request'; +import { RequestGroup } from '../../../models/request-group'; +import { Workspace } from '../../../models/workspace'; +import { WorkspaceMeta } from '../../../models/workspace-meta'; + +type MockModel = Partial; +const mocksWithoutParentIdProjects: Record = { + [models.project.type]: [ + { + _id: 'proj_1', + name: 'Proj 1', + parentId: null, + remoteId: null, + } as unknown as Project, + { + _id: 'proj_2', + name: 'Proj 2', + parentId: null, + remoteId: null, + } as unknown as Project, + { + _id: 'proj_3', + name: 'Proj 3', + parentId: null, + remoteId: null, + } as unknown as Project, + ], + [models.workspace.type]: [ + { + _id: 'wrk_1', + name: 'Wrk 1', + parentId: null, + } as unknown as Workspace, + { + _id: 'wrk_2', + name: 'Wrk 2', + parentId: 'proj_3', + }, + { + _id: 'wrk_3', + name: 'Wrk 3', + parentId: 'proj_3', + }, + { + _id: 'wrk_4', + name: 'Wrk 4', + parentId: 'proj_3', + }, + ], + [models.requestGroup.type]: [ + { + _id: 'fld_1', + parentId: 'wrk_1', + name: 'Fld 1', + }, + { + _id: 'fld_2', + parentId: 'wrk_1', + name: 'Fld 2', + }, + { + _id: 'fld_3', + parentId: 'fld_1', + name: 'Fld 3', + }, + ], + [models.request.type]: [ + { + _id: 'req_1', + parentId: 'fld_1', + name: 'Req 1', + }, + { + _id: 'req_2', + parentId: 'fld_1', + name: 'Req 2', + }, + { + _id: 'req_3', + parentId: 'wrk_1', + name: 'Req 3', + }, + { + _id: 'req_4', + parentId: 'fld_3', + name: 'Req 4', + }, + { + _id: 'req_5', + parentId: 'wrk_1', + name: 'Req 5', + }, + ], +}; + +const mocksHiddenWorkspaces: Record = { + [models.project.type]: [ + { + _id: 'proj_1', + name: 'Proj 1', + parentId: 'org_1', + remoteId: 'team_1', + }, + ], + [models.workspace.type]: [ + { + _id: 'wrk_1', + name: 'Wrk 1', + parentId: 'proj_1', + }, + { + _id: 'wrk_2', + name: 'Wrk 2', + parentId: null, + } as unknown as Workspace, + { + _id: 'wrk_3', + name: 'Wrk 3', + parentId: null, + } as unknown as Workspace, + { + _id: 'wrk_4', + name: 'Wrk 4', + parentId: null, + } as unknown as Workspace, + ], + [models.requestGroup.type]: [ + { + _id: 'fld_1', + parentId: 'wrk_1', + name: 'Fld 1', + }, + { + _id: 'fld_2', + parentId: 'wrk_1', + name: 'Fld 2', + }, + { + _id: 'fld_3', + parentId: 'fld_1', + name: 'Fld 3', + }, + ], + [models.request.type]: [ + { + _id: 'req_1', + parentId: 'fld_1', + name: 'Req 1', + }, + { + _id: 'req_2', + parentId: 'fld_1', + name: 'Req 2', + }, + { + _id: 'req_3', + parentId: 'wrk_1', + name: 'Req 3', + }, + { + _id: 'req_4', + parentId: 'fld_3', + name: 'Req 4', + }, + { + _id: 'req_5', + parentId: 'wrk_1', + name: 'Req 5', + }, + ], +}; + +const mocksNoProblem: Record = { + [models.project.type]: [ + { + _id: 'proj_1', + name: 'Proj 1', + parentId: 'org_1', + remoteId: null, + }, + { + _id: 'proj_2', + name: 'Proj 2', + parentId: 'org_2', + remoteId: null, + }, + { + _id: 'proj_3', + name: 'Proj 3', + parentId: 'org_3', + remoteId: 'team_proj_3', + }, + ], + [models.workspace.type]: [ + { + _id: 'wrk_1', + name: 'Wrk 1', + parentId: 'proj_1', + }, + { + _id: 'wrk_2', + name: 'Wrk 2', + parentId: 'proj_3', + }, + ], + [models.requestGroup.type]: [ + { + _id: 'fld_1', + parentId: 'wrk_1', + name: 'Fld 1', + }, + { + _id: 'fld_2', + parentId: 'wrk_1', + name: 'Fld 2', + }, + { + _id: 'fld_3', + parentId: 'fld_1', + name: 'Fld 3', + }, + ], + [models.request.type]: [ + { + _id: 'req_1', + parentId: 'fld_1', + name: 'Req 1', + }, + { + _id: 'req_2', + parentId: 'fld_1', + name: 'Req 2', + }, + { + _id: 'req_3', + parentId: 'wrk_1', + name: 'Req 3', + }, + { + _id: 'req_4', + parentId: 'fld_3', + name: 'Req 4', + }, + { + _id: 'req_5', + parentId: 'wrk_1', + name: 'Req 5', + }, + ], +}; + +const mocksToBeRepaired: Record = { + [models.project.type]: [ + { + _id: 'proj_1', + name: 'Proj 1', + parentId: null, + remoteId: 'team_1', + } as unknown as Project, + { + _id: 'proj_2', + name: 'Proj 2', + parentId: null, + remoteId: 'team_2', + } as unknown as Project, + { + _id: 'proj_3', + name: 'Proj 3', + parentId: null, + remoteId: null, + } as unknown as Project, + ], + [models.workspace.type]: [ + { + _id: 'wrk_1', + name: 'Wrk 1', + parentId: null, + } as unknown as Workspace, + { + _id: 'wrk_2', + name: 'Wrk 2', + parentId: 'proj_3', + }, + { + _id: 'wrk_3', + name: 'Wrk 3', + parentId: 'proj_3', + }, + { + _id: 'wrk_4', + name: 'Wrk 4', + parentId: 'proj_3', + }, + ], + [models.requestGroup.type]: [ + { + _id: 'fld_1', + parentId: 'wrk_1', + name: 'Fld 1', + }, + { + _id: 'fld_2', + parentId: 'wrk_1', + name: 'Fld 2', + }, + { + _id: 'fld_3', + parentId: 'fld_1', + name: 'Fld 3', + }, + ], + [models.request.type]: [ + { + _id: 'req_1', + parentId: 'fld_1', + name: 'Req 1', + }, + { + _id: 'req_2', + parentId: 'fld_1', + name: 'Req 2', + }, + { + _id: 'req_3', + parentId: 'wrk_1', + name: 'Req 3', + }, + { + _id: 'req_4', + parentId: 'fld_3', + name: 'Req 4', + }, + { + _id: 'req_5', + parentId: 'wrk_1', + name: 'Req 5', + }, + ], +}; + +const mockRemoteBackgroundCheck = { + myWorkspaceId: 'org_my', + remoteFileSnapshot: { + 'org_my': { + ownedByMe: true, + isPersonal: true, + fileIdMap: { + 'wrk_1': 'team_1', + 'wrk_2': 'team_1', + 'wrk_3': 'team_2', + 'wrk_4': 'team_3', + }, + projectIds: ['team_1', 'team_2', 'team_3', 'team_4', 'team_5'], + }, + 'org_1': { + ownedByMe: false, + isPersonal: false, + fileIdMap: {}, + projectIds: [], + }, + }, + byRemoteProjectId: new Map([ + ['team_1', 'org_my'], + ['team_2', 'org_my'], + ['team_3', 'org_my'], + ['team_4', 'org_my'], + ['team_5', 'org_my'], + ['team_6', 'org_1'], + ]), + byRemoteFileId: new Map([ + ['wrk_1', { + remoteOrgId: 'org_my', + remoteProjectId: 'team_1', + }], + ['wrk_2', { + remoteOrgId: 'org_my', + remoteProjectId: 'team_1', + }], + ['wrk_3', { + remoteOrgId: 'org_my', + remoteProjectId: 'team_2', + }], + ['wrk_4', { + remoteOrgId: 'org_my', + remoteProjectId: 'team_2', + }], + ]), +}; + +const mockRemoteBackgroundCheckMessedUp = { + myWorkspaceId: 'org_my', + remoteFileSnapshot: { + 'org_my': { + ownedByMe: true, + isPersonal: true, + fileIdMap: { + }, + projectIds: [], + }, + 'org_1': { + ownedByMe: false, + isPersonal: false, + fileIdMap: {}, + projectIds: [], + }, + }, + byRemoteProjectId: new Map(), + byRemoteFileId: new Map(), +}; +export function fakeDatabase(data: Record) { + const promises: Promise[] = []; + for (const type of Object.keys(data)) { + for (const doc of data[type]) { + console.log(doc); + // @ts-expect-error -- TSCONVERSION + promises.push(db.insert({ ...doc, type })); + } + } + return Promise.all(promises); +} + +export { mocksWithoutParentIdProjects, mocksHiddenWorkspaces, mocksNoProblem, mocksToBeRepaired }; +export { mockRemoteBackgroundCheck, mockRemoteBackgroundCheckMessedUp }; diff --git a/packages/insomnia/src/sync/vcs/__tests__/migrate-projects-into-organizatino.test.ts b/packages/insomnia/src/sync/vcs/__tests__/migrate-projects-into-organizatino.test.ts index fcd9e1bd7b..8a77ba0157 100644 --- a/packages/insomnia/src/sync/vcs/__tests__/migrate-projects-into-organizatino.test.ts +++ b/packages/insomnia/src/sync/vcs/__tests__/migrate-projects-into-organizatino.test.ts @@ -1,73 +1,212 @@ -import { afterAll, beforeEach, describe, expect, it, jest } from '@jest/globals'; +import { beforeEach, describe, expect, it } from '@jest/globals'; import { globalBeforeEach } from '../../../__jest__/before-each'; import * as models from '../../../models'; -import MemoryDriver from '../../store/drivers/memory-driver'; -import { pushSnapshotOnInitialize } from '../initialize-backend-project'; -import { VCS } from '../vcs'; +import { _migrateToCloudSync, _migrateToLocalVault, _validateProjectsWithRemote, scanForMigration, shouldMigrate } from '../migrate-projects-into-organization'; +import { fakeDatabase, mockRemoteBackgroundCheck, mockRemoteBackgroundCheckMessedUp, mocksHiddenWorkspaces, mocksNoProblem, mocksToBeRepaired, mocksWithoutParentIdProjects } from './database.mock'; -describe('migrate-projects-into-organizatino', () => { - beforeEach(globalBeforeEach); +console.log({ + _migrateToCloudSync, _migrateToLocalVault, _validateProjectsWithRemote, +}); +describe('scanForMigration()', () => { + beforeEach(async () => { + await globalBeforeEach(); + }); + it('should scan all the untracked projects and files (both files under projects and un parent project files)', async () => { + await fakeDatabase(mocksWithoutParentIdProjects); - describe('pushSnapshotOnInitialize()', () => { - const vcs = new VCS(new MemoryDriver()); + const result = await scanForMigration(); + console.log(result.filesByProject.size); + expect(result.filesByProject.size).toBe(3); - const pushSpy = jest.spyOn(vcs, 'push'); + expect(result.filesByProject.has('wrk_2')); + expect(result.filesByProject.has('wrk_3')); + expect(result.filesByProject.has('wrk_4')); + expect(result.filesNoProject.size).toBe(1); + expect(result.filesNoProject.has('wrk_1')); + expect(result.projects.size).toBe(3); + expect(result.projects.has('proj_1')); + expect(result.projects.has('proj_2')); + expect(result.projects.has('proj_3')); + }); - beforeEach(() => { - jest.resetAllMocks(); - }); + it('should scan all the untracked files (only files)', async () => { + await fakeDatabase(mocksHiddenWorkspaces); - afterAll(() => { - pushSpy.mockClear(); - }); + const result = await scanForMigration(); + expect(result.filesByProject.size).toBe(0); + expect(result.filesNoProject.size).toBe(3); + expect(result.filesNoProject.has('wrk_2')); + expect(result.filesNoProject.has('wrk_3')); + expect(result.filesNoProject.has('wrk_4')); + expect(result.projects.size).toBe(0); + }); - it('should not push if no active project', async () => { - const project = await models.project.create({ remoteId: null }); - const workspace = await models.workspace.create({ parentId: project._id }); - const workspaceMeta = await models.workspaceMeta.create({ parentId: workspace._id }); - vcs.clearBackendProject(); + it('should scan when there are no untracked projects and files', async () => { + await fakeDatabase(mocksNoProblem); - await pushSnapshotOnInitialize({ vcs, project, workspace }); - - expect(pushSpy).not.toHaveBeenCalled(); - await expect(models.workspaceMeta.getByParentId(workspace._id)).resolves.toStrictEqual(workspaceMeta); - }); - - it('should not push snapshot if not remote project', async () => { - const project = await models.project.create({ remoteId: null }); - const workspace = await models.workspace.create({ parentId: project._id }); - const workspaceMeta = await models.workspaceMeta.create({ parentId: workspace._id }); - vcs.switchAndCreateBackendProjectIfNotExist(workspace._id, workspace.name); - - await pushSnapshotOnInitialize({ vcs, project, workspace }); - - expect(pushSpy).not.toHaveBeenCalled(); - await expect(models.workspaceMeta.getByParentId(workspace._id)).resolves.toStrictEqual(workspaceMeta); - }); - - it('should not push snapshot if workspace not in project', async () => { - const project = await models.project.create({ remoteId: 'abc' }); - const anotherProject = await models.project.create({ remoteId: 'def' }); - const workspace = await models.workspace.create({ parentId: anotherProject._id }); - vcs.switchAndCreateBackendProjectIfNotExist(workspace._id, workspace.name); - - await pushSnapshotOnInitialize({ vcs, project, workspace }); - - expect(pushSpy).not.toHaveBeenCalled(); - }); - - it('should push snapshot if conditions are met', async () => { - const project = await models.project.create({ remoteId: 'abc', parentId: 'team_abc' }); - const workspace = await models.workspace.create({ parentId: project._id }); - await models.workspaceMeta.create({ parentId: workspace._id, pushSnapshotOnInitialize: true }); - vcs.switchAndCreateBackendProjectIfNotExist(workspace._id, workspace.name); - - await pushSnapshotOnInitialize({ vcs, project, workspace }); - - expect(pushSpy).toHaveBeenCalledWith({ teamId: 'team_abc', teamProjectId: project.remoteId }); - const updatedMeta = await models.workspaceMeta.getByParentId(workspace._id); - expect(updatedMeta?.pushSnapshotOnInitialize).toBe(false); - }); + const result = await scanForMigration(); + expect(result.filesByProject.size).toBe(0); + expect(result.filesNoProject.size).toBe(0); + expect(result.projects.size).toBe(0); + }); +}); + +describe('shouldMigrate()', () => { + beforeEach(async () => { + await globalBeforeEach(); + }); + it('should return true with untracked projects and files (both files under projects and un parent project files)', async () => { + await fakeDatabase(mocksWithoutParentIdProjects); + + const queue = await scanForMigration(); + const result = await shouldMigrate(queue); + expect(result).toBeTruthy(); + }); + + it('should return true with untracked files (only files)', async () => { + await fakeDatabase(mocksHiddenWorkspaces); + + const queue = await scanForMigration(); + const result = await shouldMigrate(queue); + expect(result).toBeTruthy(); + }); + + it('should return false with no untracked files', async () => { + await fakeDatabase(mocksNoProblem); + + const queue = await scanForMigration(); + const result = await shouldMigrate(queue); + expect(result).not.toBeTruthy(); + }); +}); + +describe('_migrateToCloudSync()', () => { + beforeEach(async () => { + await globalBeforeEach(); + }); + + it('should fallback to local migration when there are no valid remote projects', async () => { + await fakeDatabase(mocksWithoutParentIdProjects); + + const queue = await scanForMigration(); + const records = await _migrateToCloudSync(queue, mockRemoteBackgroundCheckMessedUp); + + expect(records.filesForSync.length).toBe(0); + expect(records.projects.size).toBe(3); + expect(records.projects.has('proj_1')).toBeTruthy(); + expect(records.projects.has('proj_2')).toBeTruthy(); + expect(records.projects.has('proj_3')).toBeTruthy(); + const [proj1, proj2, proj3] = await Promise.all([ + models.project.getById(records.projects.get('proj_1')!), + models.project.getById(records.projects.get('proj_2')!), + models.project.getById(records.projects.get('proj_3')!), + ]); + expect(proj1).toBeTruthy(); + expect(proj1!.remoteId).toBeNull(); + expect(proj2).toBeTruthy(); + expect(proj2!.remoteId).toBeNull(); + expect(proj3).toBeTruthy(); + expect(proj3!.remoteId).toBeNull(); + + expect(records.files.size).toBe(4); + expect(records.files.has('wrk_1')).toBeTruthy(); + expect(records.files.has('wrk_2')).toBeTruthy(); // part of proj_3 + expect(records.files.has('wrk_3')).toBeTruthy(); // part of proj_3 + expect(records.files.has('wrk_4')).toBeTruthy(); // part of proj_3 + }); + + it('should repair projects with valid remote ids with personal workspace id if not linked correctly', async () => { + await fakeDatabase(mocksToBeRepaired); + + const beforeProj1 = await models.project.getById('proj_1'); + expect(beforeProj1!.parentId).toBeNull(); + + const beforeProj2 = await models.project.getById('proj_2'); + expect(beforeProj2!.parentId).toBeNull(); + + const queue = await scanForMigration(); + const records = await _migrateToCloudSync(queue, mockRemoteBackgroundCheck); + + expect(records.projects.size).toBe(1); + expect(records.files.size).toBe(4); // => we've duplicated the files because they are not in correct linking between the local and remote + + const repairedProj1 = await models.project.getById('proj_1'); + expect(repairedProj1!.parentId).toBe('org_my'); + + const repairedProj2 = await models.project.getById('proj_2'); + expect(repairedProj2!.parentId).toBe('org_my'); + + const [wrk1, wrk2, wrk3, wrk4] = await Promise.all([ + models.workspace.getById(records.files.get('wrk_1')!), + models.workspace.getById(records.files.get('wrk_2')!), + models.workspace.getById(records.files.get('wrk_3')!), + models.workspace.getById(records.files.get('wrk_4')!), + ]); + + expect(wrk1!.parentId).not.toBeNull(); // files without parent id (no project linking) => now corrected + expect(wrk2!.parentId).not.toBe('proj_3'); // files with the parent id that does not exist in the cloud => duplicated and linked to the existing remote project + expect(wrk3!.parentId).not.toBe('proj_3'); // files with the parent id that does not exist in the cloud => duplicated and linked to the existing remote project + expect(wrk4!.parentId).not.toBe('proj_3'); // files with the parent id that does not exist in the cloud => duplicated and linked to the existing remote project + + // these duplicated 4 files need to be synced now + expect(records.filesForSync.length).toBe(4); + }); +}); + +describe('_migrateToLocalVault()', () => { + beforeEach(async () => { + await globalBeforeEach(); + }); + + it('should duplicate all files and projects', async () => { + await fakeDatabase(mocksWithoutParentIdProjects); + + const queue = await scanForMigration(); + const records = await _migrateToLocalVault(queue, mockRemoteBackgroundCheck); + + // should never happen + expect(records).not.toHaveProperty('filesForSync'); + expect(records.projects.size).toBe(3); + expect(records.projects.has('proj_1')).toBeTruthy(); + expect(records.projects.has('proj_2')).toBeTruthy(); + expect(records.projects.has('proj_3')).toBeTruthy(); + expect(records.files.size).toBe(4); + expect(records.files.has('wrk_1')).toBeTruthy(); + expect(records.files.has('wrk_2')).toBeTruthy(); // part of proj_3 + expect(records.files.has('wrk_3')).toBeTruthy(); // part of proj_3 + expect(records.files.has('wrk_4')).toBeTruthy(); // part of proj_3 + }); + + it('should link untracked files to a newly created local vault', async () => { + await fakeDatabase(mocksHiddenWorkspaces); + + const queue = await scanForMigration(); + const records = await _migrateToLocalVault(queue, mockRemoteBackgroundCheck); + expect(records).not.toHaveProperty('filesForSync'); + expect(records.projects.size).toBe(0); + expect(records.projects.has('proj_1')).not.toBeTruthy(); + expect(records.files.size).toBe(3); + expect(records.files.has('wrk_1')).not.toBeTruthy(); // part of proj_1 + expect(records.files.has('wrk_2')).toBeTruthy(); + expect(records.files.has('wrk_3')).toBeTruthy(); + expect(records.files.has('wrk_4')).toBeTruthy(); + + const [wrk1, wrk2, wrk3, wrk4] = await Promise.all([ + models.workspace.getById('wrk_1'), + models.workspace.getById(records.files.get('wrk_2')), + models.workspace.getById(records.files.get('wrk_3')), + models.workspace.getById(records.files.get('wrk_4')), + ]); + + expect(wrk1).toMatchObject({}); + expect(wrk2).toBeTruthy(); + expect(wrk2?.parentId).not.toBeNull(); + + const { parentId: newVaultId } = wrk2!; + expect(wrk3).toBeTruthy(); + expect(wrk3?.parentId).toEqual(newVaultId); + expect(wrk4).toBeTruthy(); + expect(wrk4?.parentId).toEqual(newVaultId); }); }); diff --git a/packages/insomnia/src/sync/vcs/migrate-projects-into-organization.ts b/packages/insomnia/src/sync/vcs/migrate-projects-into-organization.ts index 1ebc868760..0ccac6627f 100644 --- a/packages/insomnia/src/sync/vcs/migrate-projects-into-organization.ts +++ b/packages/insomnia/src/sync/vcs/migrate-projects-into-organization.ts @@ -49,6 +49,8 @@ export const scanForMigration = async (): Promise => { parentId: null, }); + console.log({ legacyRemoteProjects }); + for (const project of legacyRemoteProjects) { console.log('[migration] found legacy remote project', project); queueLocalProjects.add(project._id); @@ -68,6 +70,7 @@ export const scanForMigration = async (): Promise => { _id: { $ne: models.project.SCRATCHPAD_PROJECT_ID }, }); + console.log({ localProjects }); for (const project of localProjects) { console.log('[migration] found local project', project._id); queueLocalProjects.add(project._id); @@ -85,6 +88,8 @@ export const scanForMigration = async (): Promise => { parentId: null, }); + console.log({ untrackedFiles }); + for (const file of untrackedFiles) { console.log('[migration] found an untracked file with no parents', file._id); queueLocalFilesNoProject.add(file._id); @@ -107,7 +112,7 @@ interface RemoteBackground { remoteProjectId: RemoteProjectId; }>; } -const remoteBackgroundCheck = async (sessionId: string): Promise => { +export const remoteBackgroundCheck = async (sessionId: string): Promise => { const response = await window.main.insomniaFetch({ method: 'GET', path: '/v1/user/file-snapshot', @@ -171,7 +176,8 @@ interface RecordsForMigration { projects: Map; files: Map; }; -const _migrateToLocalVault = async (queue: QueueForMigration, remoteBackground: RemoteBackground): Promise => { +/** @private */ +export const _migrateToLocalVault = async (queue: QueueForMigration, remoteBackground: RemoteBackground): Promise => { const recordsForProjectMigration = new Map(); const recordsForFileMigration = new Map(); @@ -232,7 +238,8 @@ const _migrateToLocalVault = async (queue: QueueForMigration, remoteBackground: }; }; -const _validateProjectsWithRemote = async (queue: QueueForMigration, remoteBackground: RemoteBackground) => { +/** @private */ +export const _validateProjectsWithRemote = async (queue: QueueForMigration, remoteBackground: RemoteBackground) => { console.log('[migration] validating projects against the remote'); const { myWorkspaceId } = remoteBackground; const myWorkspace = remoteBackground.remoteFileSnapshot[myWorkspaceId]; @@ -303,7 +310,8 @@ const _validateProjectsWithRemote = async (queue: QueueForMigration, remoteBackg type RecordsForCloudMigration = RecordsForMigration & { filesForSync: Workspace[]; }; -const _migrateToCloudSync = async ( +/** @private */ +export const _migrateToCloudSync = async ( queue: QueueForMigration, remoteBackground: RemoteBackground, ): Promise => { @@ -330,6 +338,7 @@ const _migrateToCloudSync = async ( for (const validProject of validProjects) { if (validProject.parentId !== myWorkspaceId) { console.log('[migration] repairing team-project to organization linking for local database'); + // TODO: update the array validProjects here await database.docUpdate(validProject, { parentId: myWorkspaceId, });