Skip to content

The open alternative to Salesforce, designed for AI.

Migrate existing Canvas tabs to vertical lists (#25511)

Thomas des Francse1eb3f6026e1
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.ts
new file mode 100644
index 00000000000..c9367cbb0d1
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.ts
@@ -0,0 +1,111 @@
+import { DataSource } from 'typeorm';
+
+import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';
+import { SlowInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/slow-instance-command.interface';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const NO_INCOMING_WIDGET_OVERRIDES_PREDICATE = `NOT EXISTS (
+ SELECT 1
+ FROM "core"."pageLayoutWidget" incoming_widget
+ WHERE incoming_widget."overrides"->>'pageLayoutTabId' = tab."id"::text
+ AND incoming_widget."pageLayoutTabId" <> tab."id"
+ AND incoming_widget."deletedAt" IS NULL
+)`;
+
+const ELIGIBLE_CANVAS_TABS_QUERY = `
+ SELECT tab."id"
+ FROM "core"."pageLayoutTab" tab
+ JOIN "core"."pageLayoutWidget" widget
+ ON widget."pageLayoutTabId" = tab."id"
+ WHERE tab."layoutMode" = 'CANVAS'
+ AND tab."deletedAt" IS NULL
+ AND tab."workspaceId" = $1
+ AND tab."applicationId" = $2
+ AND ${NO_INCOMING_WIDGET_OVERRIDES_PREDICATE}
+ GROUP BY tab."id"
+ HAVING COUNT(widget."id") FILTER (
+ WHERE widget."deletedAt" IS NULL
+ ) = 1
+ AND COUNT(widget."id") FILTER (
+ WHERE widget."deletedAt" IS NULL
+ AND widget."isActive" = true
+ AND widget."applicationId" = $2
+ AND (
+ widget."position" IS NULL
+ OR widget."position" = 'null'::jsonb
+ OR widget."position"->>'layoutMode' = 'CANVAS'
+ )
+ AND (
+ widget."overrides"->'position' IS NULL
+ OR widget."overrides"->'position' = 'null'::jsonb
+ OR widget."overrides"->'position'->>'layoutMode' = 'CANVAS'
+ )
+ AND (
+ NOT COALESCE(widget."overrides" ? 'pageLayoutTabId', false)
+ OR widget."overrides"->>'pageLayoutTabId' = tab."id"::text
+ )
+ ) = 1
+`;
+
+@RegisteredInstanceCommand('2.40.0', 1789139070588, { type: 'slow' })
+export class MigrateCanvasTabsToVerticalListSlowInstanceCommand implements SlowInstanceCommand {
+ constructor(private readonly workspaceCacheService: WorkspaceCacheService) {}
+
+ public async runDataMigration(dataSource: DataSource): Promise<void> {
+ // Manifest-owned tabs and widgets must stay compatible with future app syncs.
+ const workspaces = (await dataSource.query(`
+ SELECT "id", "workspaceCustomApplicationId"
+ FROM "core"."workspace"
+ WHERE "workspaceCustomApplicationId" IS NOT NULL
+ ORDER BY "id"
+ `)) as { id: string; workspaceCustomApplicationId: string }[];
+
+ for (const workspace of workspaces) {
+ await dataSource.query(
+ `
+ WITH eligible_tabs AS MATERIALIZED (
+ ${ELIGIBLE_CANVAS_TABS_QUERY}
+ ), migrated_widgets AS (
+ UPDATE "core"."pageLayoutWidget" widget
+ SET "position" = jsonb_build_object(
+ 'layoutMode', 'VERTICAL_LIST',
+ 'index', 0,
+ 'heightBehavior', 'TAB_VIEWPORT'
+ ),
+ "overrides" = CASE
+ WHEN widget."overrides" ? 'position' THEN jsonb_set(
+ widget."overrides",
+ '{position}',
+ jsonb_build_object(
+ 'layoutMode', 'VERTICAL_LIST',
+ 'index', 0,
+ 'heightBehavior', 'TAB_VIEWPORT'
+ )
+ )
+ ELSE widget."overrides"
+ END
+ FROM eligible_tabs
+ WHERE widget."pageLayoutTabId" = eligible_tabs."id"
+ AND widget."deletedAt" IS NULL
+ RETURNING widget."pageLayoutTabId"
+ )
+ UPDATE "core"."pageLayoutTab" tab
+ SET "layoutMode" = 'VERTICAL_LIST'
+ FROM migrated_widgets
+ WHERE tab."id" = migrated_widgets."pageLayoutTabId"
+ `,
+ [workspace.id, workspace.workspaceCustomApplicationId],
+ );
+
+ // Flush even without eligible rows, in case an earlier attempt committed before its cache flush failed.
+ await this.workspaceCacheService.flush(workspace.id, [
+ 'flatPageLayoutTabMaps',
+ 'flatPageLayoutWidgetMaps',
+ ]);
+ }
+ }
+
+ public async up(): Promise<void> {}
+
+ public async down(): Promise<void> {}
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-command-provider.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-command-provider.module.ts
index a526a911303..7f5230f6d1c 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-command-provider.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-command-provider.module.ts
@@ -5,9 +5,11 @@ import { JwtModule } from 'src/engine/core-modules/jwt/jwt.module';
import { SecretEncryptionModule } from 'src/engine/core-modules/secret-encryption/secret-encryption.module';
import { SimpleSecretEncryptionUtil } from 'src/engine/core-modules/two-factor-authentication/utils/simple-secret-encryption.util';
import { ConnectedAccountTokenEncryptionModule } from 'src/engine/metadata-modules/connected-account/services/connected-account-token-encryption.module';
+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@Module({
imports: [
+ WorkspaceCacheModule,
ConnectedAccountTokenEncryptionModule,
SecretEncryptionModule,
// JwtModule is required by SimpleSecretEncryptionUtil. Drop both once the
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
index 7f4b045e5c5..8c3ea347d04 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
@@ -187,6 +187,7 @@ import { AddCoreWorkflowIdToWorkflowVersionFastInstanceCommand } from 'src/datab
import { AddAiModelTiersToWorkspaceFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1789000000000-add-ai-model-tiers-to-workspace';
import { MigrateWorkspaceModelsToTiersSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789000000001-migrate-workspace-models-to-tiers';
import { AddIsSystemToSkillFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-fast-1789129759228-add-is-system-to-skill';
+import { MigrateCanvasTabsToVerticalListSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list';
export const INSTANCE_COMMANDS = [
AddViewFieldGroupIdIndexOnViewFieldFastInstanceCommand,
@@ -376,4 +377,5 @@ export const INSTANCE_COMMANDS = [
AddAiModelTiersToWorkspaceFastInstanceCommand,
MigrateWorkspaceModelsToTiersSlowInstanceCommand,
AddIsSystemToSkillFastInstanceCommand,
+ MigrateCanvasTabsToVerticalListSlowInstanceCommand,
];
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/successful-manifest-update-page-layout-tab.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/successful-manifest-update-page-layout-tab.integration-spec.ts
index 435a49605a9..9f05f103489 100644
--- a/packages/twenty-server/test/integration/metadata/suites/application/successful-manifest-update-page-layout-tab.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/application/successful-manifest-update-page-layout-tab.integration-spec.ts
@@ -4,11 +4,15 @@ import { setupApplicationForSync } from 'test/integration/metadata/suites/applic
import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
import { findPageLayoutTabs } from 'test/integration/metadata/suites/page-layout-tab/utils/find-page-layout-tabs.util';
import { findPageLayoutWidgets } from 'test/integration/metadata/suites/page-layout-widget/utils/find-page-layout-widgets.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
import { type Manifest } from 'twenty-shared/application';
import { STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS } from 'twenty-shared/metadata';
import { PageLayoutTabLayoutMode } from 'twenty-shared/types';
import { v4 as uuidv4 } from 'uuid';
+import { MigrateCanvasTabsToVerticalListSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
const TEST_APP_ID = uuidv4();
const TEST_ROLE_ID = uuidv4();
const TEST_TAB_ID = uuidv4();
@@ -257,7 +261,8 @@ describe('Manifest update - page layout tabs (standalone)', () => {
);
});
- it('should preserve a legacy Canvas tab without replacing its widget on subsequent sync', async () => {
+ it('should preserve a legacy Canvas manifest and position override through migration and sync', async () => {
+ const widgetOverrides = { position: { layoutMode: 'CANVAS' } };
const buildLegacyCanvasPageLayoutTab = () => ({
universalIdentifier: TEST_TAB_ID,
pageLayoutUniversalIdentifier: STANDARD_PERSON_PAGE_LAYOUT_UNIVERSAL_ID,
@@ -319,6 +324,19 @@ describe('Manifest update - page layout tabs (standalone)', () => {
},
});
+ await globalThis.testDataSource.query(
+ `UPDATE core."pageLayoutWidget" SET "overrides" = $1 WHERE "id" = $2`,
+ [JSON.stringify(widgetOverrides), widgetAfterFirstSync.id],
+ );
+
+ const workspaceCacheService =
+ getAppProviderByClassName<WorkspaceCacheService>('WorkspaceCacheService');
+ const command = new MigrateCanvasTabsToVerticalListSlowInstanceCommand(
+ workspaceCacheService,
+ );
+
+ await command.runDataMigration(globalThis.testDataSource);
+
await syncApplication({
manifest: buildManifest({
pageLayoutTabs: [buildLegacyCanvasPageLayoutTab()],
@@ -360,6 +378,12 @@ describe('Manifest update - page layout tabs (standalone)', () => {
},
}),
]);
+ const [widgetAfterMigrationAndSync] = await globalThis.testDataSource.query(
+ `SELECT "overrides" FROM core."pageLayoutWidget" WHERE "id" = $1`,
+ [widgetAfterFirstSync.id],
+ );
+
+ expect(widgetAfterMigrationAndSync.overrides).toEqual(widgetOverrides);
}, 60000);
it('should delete a standalone tab when removed from manifest on second sync', async () => {
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.integration-spec.ts
new file mode 100644
index 00000000000..7ac7293de2f
--- /dev/null
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list.integration-spec.ts
@@ -0,0 +1,493 @@
+import { isDefined } from 'twenty-shared/utils';
+import { DataSource, type QueryRunner } from 'typeorm';
+import { v4 } from 'uuid';
+
+import { MigrateCanvasTabsToVerticalListSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-40/2-40-instance-command-slow-1789139070588-migrate-canvas-tabs-to-vertical-list';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+jest.useRealTimers();
+
+type SeededTab = {
+ tabId: string;
+ widgetIds: string[];
+};
+
+type TabAndWidgetState = {
+ layoutMode: string;
+ overrides: Record<string, unknown> | null;
+ position: Record<string, unknown> | null;
+};
+
+describe('MigrateCanvasTabsToVerticalListSlowInstanceCommand (integration)', () => {
+ let dataSource: DataSource;
+ let queryRunner: QueryRunner;
+ let command: MigrateCanvasTabsToVerticalListSlowInstanceCommand;
+ let workspaceId: string;
+ let applicationId: string;
+ let pageLayoutId: string;
+
+ const workspaceCacheService = { flush: jest.fn() };
+
+ const seedTab = async ({
+ layoutMode,
+ widgetIsActiveValues,
+ widgetOverrides = null,
+ widgetPosition = { layoutMode },
+ }: {
+ layoutMode: 'CANVAS' | 'VERTICAL_LIST';
+ widgetIsActiveValues: boolean[];
+ widgetOverrides?: Record<string, unknown> | null;
+ widgetPosition?: Record<string, unknown> | null;
+ }): Promise<SeededTab> => {
+ const tabId = v4();
+
+ await dataSource.query(
+ `INSERT INTO "core"."pageLayoutTab" (
+ "id",
+ "workspaceId",
+ "applicationId",
+ "universalIdentifier",
+ "pageLayoutId",
+ "title",
+ "position",
+ "layoutMode",
+ "isActive"
+ ) VALUES ($1, $2, $3, $4, $5, 'Migration test tab', 0, $6, true)`,
+ [tabId, workspaceId, applicationId, v4(), pageLayoutId, layoutMode],
+ );
+
+ const widgetIds: string[] = [];
+
+ for (const [index, isActive] of widgetIsActiveValues.entries()) {
+ const widgetId = v4();
+
+ await dataSource.query(
+ `INSERT INTO "core"."pageLayoutWidget" (
+ "id",
+ "workspaceId",
+ "applicationId",
+ "universalIdentifier",
+ "pageLayoutTabId",
+ "title",
+ "type",
+ "gridPosition",
+ "position",
+ "overrides",
+ "configuration",
+ "isActive"
+ ) VALUES (
+ $1,
+ $2,
+ $3,
+ $4,
+ $5,
+ 'Migration test widget',
+ 'VIEW',
+ $6,
+ $7,
+ $8,
+ $9,
+ $10
+ )`,
+ [
+ widgetId,
+ workspaceId,
+ applicationId,
+ v4(),
+ tabId,
+ JSON.stringify({ row: index, column: 0, rowSpan: 1, columnSpan: 12 }),
+ JSON.stringify(widgetPosition),
+ JSON.stringify(widgetOverrides),
+ JSON.stringify({ configurationType: 'VIEW' }),
+ isActive,
+ ],
+ );
+
+ widgetIds.push(widgetId);
+ }
+
+ return { tabId, widgetIds };
+ };
+
+ const readTabAndWidgetState = async ({
+ tabId,
+ widgetId,
+ }: {
+ tabId: string;
+ widgetId: string;
+ }): Promise<TabAndWidgetState> => {
+ const [state] = (await dataSource.query(
+ `SELECT tab."layoutMode", widget."position", widget."overrides"
+ FROM "core"."pageLayoutTab" tab
+ JOIN "core"."pageLayoutWidget" widget
+ ON widget."pageLayoutTabId" = tab."id"
+ WHERE tab."id" = $1 AND widget."id" = $2`,
+ [tabId, widgetId],
+ )) as TabAndWidgetState[];
+
+ if (!isDefined(state)) {
+ throw new Error('Seeded page layout tab or widget was not found');
+ }
+
+ return state;
+ };
+
+ const readTabLayoutMode = async (tabId: string): Promise<string> => {
+ const [state] = (await dataSource.query(
+ `SELECT "layoutMode"
+ FROM "core"."pageLayoutTab"
+ WHERE "id" = $1`,
+ [tabId],
+ )) as { layoutMode: string }[];
+
+ if (!isDefined(state)) {
+ throw new Error('Seeded page layout tab was not found');
+ }
+
+ return state.layoutMode;
+ };
+
+ beforeAll(async () => {
+ dataSource = new DataSource({
+ type: 'postgres',
+ url: process.env.PG_DATABASE_URL,
+ schema: 'core',
+ entities: [],
+ synchronize: false,
+ });
+ await dataSource.initialize();
+
+ command = new MigrateCanvasTabsToVerticalListSlowInstanceCommand(
+ workspaceCacheService as unknown as WorkspaceCacheService,
+ );
+
+ const [source] = (await dataSource.query(
+ `SELECT "id" AS "workspaceId", "workspaceCustomApplicationId" AS "applicationId"
+ FROM "core"."workspace"
+ WHERE "workspaceCustomApplicationId" IS NOT NULL
+ ORDER BY "id"
+ LIMIT 1`,
+ )) as { workspaceId: string; applicationId: string }[];
+
+ if (!isDefined(source)) {
+ throw new Error(
+ 'No seeded workspace found; run database:reset before the integration suite.',
+ );
+ }
+
+ workspaceId = source.workspaceId;
+ applicationId = source.applicationId;
+ }, 30000);
+
+ beforeEach(async () => {
+ workspaceCacheService.flush.mockReset().mockResolvedValue(undefined);
+
+ queryRunner = dataSource.createQueryRunner();
+ await queryRunner.connect();
+ await queryRunner.startTransaction();
+
+ // Roll back changes to seeded layouts along with the test fixtures.
+ jest
+ .spyOn(dataSource, 'query')
+ .mockImplementation((query, parameters) =>
+ queryRunner.query(query, parameters),
+ );
+
+ pageLayoutId = v4();
+
+ await dataSource.query(
+ `INSERT INTO "core"."pageLayout" (
+ "id",
+ "workspaceId",
+ "applicationId",
+ "universalIdentifier",
+ "name",
+ "type"
+ ) VALUES ($1, $2, $3, $4, 'Canvas migration integration test', 'RECORD_PAGE')`,
+ [pageLayoutId, workspaceId, applicationId, v4()],
+ );
+ });
+
+ afterEach(async () => {
+ jest.restoreAllMocks();
+ await queryRunner.rollbackTransaction();
+ await queryRunner.release();
+ });
+
+ afterAll(async () => {
+ await dataSource?.destroy();
+ });
+
+ it.each([
+ { widgetPosition: { layoutMode: 'GRID', row: 2, column: 1 } },
+ { widgetPosition: { layoutMode: 'VERTICAL_LIST', index: 4 } },
+ {
+ widgetOverrides: { position: { layoutMode: 'GRID', row: 2, column: 1 } },
+ },
+ {
+ widgetOverrides: { position: { layoutMode: 'VERTICAL_LIST', index: 4 } },
+ },
+ ])('preserves authored non-Canvas positions %j', async (widgetOptions) => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ ...widgetOptions,
+ });
+ const originalState = await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ });
+
+ await command.runDataMigration(dataSource);
+
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ).toEqual(originalState);
+ });
+
+ it.each([false, true])(
+ 'preserves outgoing tab overrides with a position override: %s',
+ async (hasPositionOverride) => {
+ const destinationTab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ });
+ const sourceTab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ widgetOverrides: {
+ pageLayoutTabId: destinationTab.tabId,
+ ...(hasPositionOverride
+ ? { position: { layoutMode: 'CANVAS' } }
+ : {}),
+ },
+ });
+ const originalStates = await Promise.all(
+ [sourceTab, destinationTab].map((tab) =>
+ readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ),
+ );
+
+ await command.runDataMigration(dataSource);
+
+ for (const [index, tab] of [sourceTab, destinationTab].entries()) {
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ).toEqual(originalStates[index]);
+ }
+ },
+ );
+
+ it('retries cache invalidation after the rows have already been migrated', async () => {
+ const canvasTab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ });
+ const cacheError = new Error('Cache unavailable');
+
+ workspaceCacheService.flush.mockRejectedValueOnce(cacheError);
+
+ await expect(command.runDataMigration(dataSource)).rejects.toThrow(
+ cacheError,
+ );
+ expect(await readTabLayoutMode(canvasTab.tabId)).toBe('VERTICAL_LIST');
+
+ workspaceCacheService.flush.mockClear();
+
+ await command.runDataMigration(dataSource);
+
+ expect(workspaceCacheService.flush).toHaveBeenCalledWith(workspaceId, [
+ 'flatPageLayoutTabMaps',
+ 'flatPageLayoutWidgetMaps',
+ ]);
+ expect(
+ await readTabAndWidgetState({
+ tabId: canvasTab.tabId,
+ widgetId: canvasTab.widgetIds[0],
+ }),
+ ).toMatchObject({
+ layoutMode: 'VERTICAL_LIST',
+ position: {
+ layoutMode: 'VERTICAL_LIST',
+ index: 0,
+ heightBehavior: 'TAB_VIEWPORT',
+ },
+ });
+ });
+
+ it.each([
+ null,
+ { position: null },
+ { position: { layoutMode: 'CANVAS' }, title: 'Custom title' },
+ ])(
+ 'migrates a workspace Canvas tab and preserves unrelated overrides %j',
+ async (widgetOverrides) => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ widgetPosition: null,
+ widgetOverrides,
+ });
+ const position = {
+ layoutMode: 'VERTICAL_LIST',
+ index: 0,
+ heightBehavior: 'TAB_VIEWPORT',
+ };
+
+ await command.runDataMigration(dataSource);
+ await command.runDataMigration(dataSource);
+
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ).toEqual({
+ layoutMode: 'VERTICAL_LIST',
+ position,
+ overrides: isDefined(widgetOverrides)
+ ? { ...widgetOverrides, position }
+ : null,
+ });
+ },
+ );
+
+ it.each(
+ [[], [false], [true, true], [true, false]].map((widgetIsActiveValues) => ({
+ widgetIsActiveValues,
+ })),
+ )(
+ 'preserves Canvas tabs without exactly one active, undeleted widget: %j',
+ async ({ widgetIsActiveValues }) => {
+ const tab = await seedTab({ layoutMode: 'CANVAS', widgetIsActiveValues });
+
+ await command.runDataMigration(dataSource);
+
+ expect(await readTabLayoutMode(tab.tabId)).toBe('CANVAS');
+ },
+ );
+
+ it.each(['pageLayoutTab', 'pageLayoutWidget'] as const)(
+ 'preserves manifest-owned %s and its Canvas position override',
+ async (entity) => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ widgetOverrides: { position: { layoutMode: 'CANVAS' } },
+ });
+
+ await dataSource.query(
+ `UPDATE "core"."${entity}" SET "applicationId" = (
+ SELECT "applicationId" FROM "core"."pageLayout"
+ WHERE "workspaceId" = $1 AND "applicationId" <> $2 LIMIT 1
+ ) WHERE "id" = $3`,
+ [
+ workspaceId,
+ applicationId,
+ entity === 'pageLayoutTab' ? tab.tabId : tab.widgetIds[0],
+ ],
+ );
+ const originalState = await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ });
+
+ await command.runDataMigration(dataSource);
+
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ).toEqual(originalState);
+ },
+ );
+
+ it('preserves edits to an already migrated vertical-list position on retry', async () => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ });
+
+ await command.runDataMigration(dataSource);
+
+ const editedPosition = {
+ layoutMode: 'VERTICAL_LIST',
+ index: 0,
+ heightBehavior: 'FIT_CONTENT',
+ };
+
+ await dataSource.query(
+ `UPDATE "core"."pageLayoutWidget" SET "position" = $1 WHERE "id" = $2`,
+ [editedPosition, tab.widgetIds[0]],
+ );
+ await command.runDataMigration(dataSource);
+
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[0],
+ }),
+ ).toMatchObject({ position: editedPosition });
+ });
+ it('ignores deleted widgets when counting active Canvas contents', async () => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true, true],
+ });
+
+ await dataSource.query(
+ `UPDATE "core"."pageLayoutWidget" SET "deletedAt" = NOW() WHERE "id" = $1`,
+ [tab.widgetIds[1]],
+ );
+ await command.runDataMigration(dataSource);
+
+ expect(await readTabLayoutMode(tab.tabId)).toBe('VERTICAL_LIST');
+ expect(
+ await readTabAndWidgetState({
+ tabId: tab.tabId,
+ widgetId: tab.widgetIds[1],
+ }),
+ ).toMatchObject({ position: { layoutMode: 'CANVAS' } });
+ });
+
+ it('preserves deleted Canvas tabs', async () => {
+ const tab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ });
+
+ await dataSource.query(
+ `UPDATE "core"."pageLayoutTab" SET "deletedAt" = NOW() WHERE "id" = $1`,
+ [tab.tabId],
+ );
+ await command.runDataMigration(dataSource);
+
+ expect(await readTabLayoutMode(tab.tabId)).toBe('CANVAS');
+ });
+
+ it('preserves tabs receiving an inactive widget through an override', async () => {
+ const destinationTab = await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [true],
+ });
+
+ await seedTab({
+ layoutMode: 'CANVAS',
+ widgetIsActiveValues: [false],
+ widgetOverrides: { pageLayoutTabId: destinationTab.tabId },
+ });
+ await command.runDataMigration(dataSource);
+
+ expect(await readTabLayoutMode(destinationTab.tabId)).toBe('CANVAS');
+ });
+});