@codeyam/codeyam-cli 0.1.0-staging.9574237 → 0.1.0-staging.a2f381a

package/codeyam-cli/src/utils/__tests__/editorScenarios.test.js

@@ -3,7 +3,7 @@ import os from 'os';
 import path from 'path';
 import Database from 'better-sqlite3';
 import { Kysely, SqliteDialect } from 'kysely';
-import { deduplicateByName, generateScenarioSlug, convertIsoToSqliteTimestamp, determineCaptureUrl, resolvePreviewNavPath, clearEditorState, clearEditorUserPrompt, readDefaultScreenSize, readScreenSizes, resolveScenarioViewport, resolveViewportWithProjectDefault, upsertEditorScenario, cleanupScenarioFiles, readPreservedConfigProperties, validateStepTransition, slugifyDimension, isRowInFeatureSession, backfillEntityShaOnScenarios, countScenariosNeedingEntityBackfill, validateEntityLinkageForAppScenario, } from "../editorScenarios.js";
+import { deduplicateByName, generateScenarioSlug, convertIsoToSqliteTimestamp, determineCaptureUrl, resolvePreviewNavPath, clearEditorState, clearEditorUserPrompt, readDefaultScreenSize, readScreenSizes, resolveScenarioViewport, resolveViewportWithProjectDefault, upsertEditorScenario, cleanupScenarioFiles, readPreservedConfigProperties, validateStepTransition, slugifyDimension, isRowInFeatureSession, backfillEntityShaOnScenarios, countScenariosNeedingEntityBackfill, validateEntityLinkageForAppScenario, validateScenarioCategorization, resolveSeedFrom, } from "../editorScenarios.js";
 describe('editorScenarios', () => {
     describe('deduplicateByName', () => {
         it('should keep only the last item for each key', () => {
@@ -1009,6 +1009,26 @@ describe('editorScenarios', () => {
             expect(err).not.toBeNull();
             expect(err).toContain('step 14');
         });
+        it('should reject rapid-fire advance when step started < 3s ago', () => {
+            const recentStart = new Date(Date.now() - 1000).toISOString(); // 1s ago
+            const err = validateStepTransition(4, 3, recentStart);
+            expect(err).not.toBeNull();
+            expect(err).toContain('only 1s ago');
+            expect(err).toContain('checklist');
+        });
+        it('should allow advance when step started > 3s ago', () => {
+            const oldStart = new Date(Date.now() - 5000).toISOString(); // 5s ago
+            expect(validateStepTransition(4, 3, oldStart)).toBeNull();
+        });
+        it('should not enforce time guard on step 1 → 2 transition', () => {
+            const recentStart = new Date(Date.now() - 2000).toISOString();
+            // currentStep=1, so guard only applies for currentStep >= 2
+            expect(validateStepTransition(2, 1, recentStart)).toBeNull();
+        });
+        it('should not enforce time guard when re-running the same step', () => {
+            const recentStart = new Date(Date.now() - 2000).toISOString();
+            expect(validateStepTransition(5, 5, recentStart)).toBeNull();
+        });
     });
     describe('isRowInFeatureSession', () => {
         const featureStart = '2026-03-12 14:01:31';
@@ -1238,24 +1258,41 @@ describe('editorScenarios', () => {
             // display_name derived from page_file_path via routeDisplayName(buildRoutePattern())
             expect(row.display_name).toBe('Feedback');
         });
-        it('should skip scenarios that already have entity_sha', async () => {
+        it('should update scenarios with stale entity_sha to latest', async () => {
+            // Margo bug: entity code changes create new versions with new SHAs,
+            // but scenarios still point to the old SHA. Since journals preserve
+            // screenshots and everything is in git, we always want scenarios
+            // pointing to the latest entity version.
             rawDb
                 .prepare(`INSERT INTO editor_scenarios (id, project_id, name, component_name, component_path, url, type, viewport_width, viewport_height, entity_sha, display_name)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run('sc-3', projectId, 'Header - Dark', 'Header', 'src/components/Header.tsx', '/isolated-components/Header', 'component', 1280, 720, 'existing-sha', 'Header');
+                .run('sc-3', projectId, 'Header - Dark', 'Header', 'src/components/Header.tsx', '/isolated-components/Header', 'component', 1280, 720, 'old-sha', 'Header');
             const result = await backfillEntityShaOnScenarios(db, [
                 {
-                    sha: 'new-sha',
+                    sha: 'latest-sha',
                     name: 'Header',
                     filePath: 'src/components/Header.tsx',
                 },
             ]);
-            expect(result.updated).toBe(0);
-            // Should not have changed the existing sha
+            expect(result.updated).toBe(1);
             const row = rawDb
                 .prepare('SELECT entity_sha FROM editor_scenarios WHERE id = ?')
                 .get('sc-3');
-            expect(row.entity_sha).toBe('existing-sha');
+            expect(row.entity_sha).toBe('latest-sha');
+        });
+        it('should not update scenarios already pointing to the latest SHA', async () => {
+            rawDb
+                .prepare(`INSERT INTO editor_scenarios (id, project_id, name, component_name, component_path, url, type, viewport_width, viewport_height, entity_sha, display_name)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run('sc-3b', projectId, 'Header - Dark', 'Header', 'src/components/Header.tsx', '/isolated-components/Header', 'component', 1280, 720, 'current-sha', 'Header');
+            const result = await backfillEntityShaOnScenarios(db, [
+                {
+                    sha: 'current-sha',
+                    name: 'Header',
+                    filePath: 'src/components/Header.tsx',
+                },
+            ]);
+            expect(result.updated).toBe(0);
         });
         it('should skip scenarios with no matching entity', async () => {
             rawDb
@@ -1276,6 +1313,117 @@ describe('editorScenarios', () => {
                 .get('sc-4');
             expect(row.entity_sha).toBeNull();
         });
+        it('should match component scenarios by name+path, not just path (multi-entity files)', async () => {
+            // A single file can export multiple components (e.g., FullPageLibrary.tsx
+            // exports FullPageLibrary, FullPageEmptyState, FullPageArticleCard).
+            // Each component scenario should get the SHA for its specific entity,
+            // not whichever entity happens to be last in the map.
+            rawDb
+                .prepare(`INSERT INTO editor_scenarios (id, project_id, name, component_name, component_path, url, type, viewport_width, viewport_height, entity_sha)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run('sc-fplib', projectId, 'FullPageLibrary - Default', 'FullPageLibrary', 'src/library/FullPageLibrary.tsx', '/isolated-components/FullPageLibrary', 'component', 1280, 720, 'old-fplib-sha');
+            rawDb
+                .prepare(`INSERT INTO editor_scenarios (id, project_id, name, component_name, component_path, url, type, viewport_width, viewport_height, entity_sha)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run('sc-fpempty', projectId, 'FullPageEmptyState - Default', 'FullPageEmptyState', 'src/library/FullPageLibrary.tsx', '/isolated-components/FullPageEmptyState', 'component', 1280, 720, 'old-fpempty-sha');
+            const result = await backfillEntityShaOnScenarios(db, [
+                {
+                    sha: 'new-fplib-sha',
+                    name: 'FullPageLibrary',
+                    filePath: 'src/library/FullPageLibrary.tsx',
+                },
+                {
+                    sha: 'new-fpempty-sha',
+                    name: 'FullPageEmptyState',
+                    filePath: 'src/library/FullPageLibrary.tsx',
+                },
+            ]);
+            expect(result.updated).toBe(2);
+            const fplib = rawDb
+                .prepare('SELECT entity_sha FROM editor_scenarios WHERE id = ?')
+                .get('sc-fplib');
+            expect(fplib.entity_sha).toBe('new-fplib-sha');
+            const fpempty = rawDb
+                .prepare('SELECT entity_sha FROM editor_scenarios WHERE id = ?')
+                .get('sc-fpempty');
+            expect(fpempty.entity_sha).toBe('new-fpempty-sha');
+        });
+        it('should prefer default export entity for page scenarios when file has multiple entities', async () => {
+            // Bug: src/popup/App.tsx has multiple entities (App visual, getInitialView library,
+            // View type). Page scenarios should link to the default export (App), not whichever
+            // entity happens to come first in the array.
+            rawDb
+                .prepare(`INSERT INTO editor_scenarios (id, project_id, name, page_file_path, url, type, viewport_width, viewport_height)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run('sc-page-1', projectId, 'Save View - First Time User', 'src/popup/App.tsx', '/', 'application', 400, 600);
+            // Pass multiple entities for the same file — default export should win
+            // regardless of order. Here the default export (App) appears first but
+            // gets overwritten by later non-default entities in the naive set() impl.
+            const result = await backfillEntityShaOnScenarios(db, [
+                {
+                    sha: 'app-sha',
+                    name: 'App',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: true,
+                },
+                {
+                    sha: 'get-initial-view-sha',
+                    name: 'getInitialView',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: false,
+                },
+                {
+                    sha: 'view-type-sha',
+                    name: 'View',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: false,
+                },
+            ]);
+            expect(result.updated).toBe(1);
+            const row = rawDb
+                .prepare('SELECT entity_sha FROM editor_scenarios WHERE id = ?')
+                .get('sc-page-1');
+            expect(row.entity_sha).toBe('app-sha');
+        });
+        it('should update page scenario to latest entity version when multiple versions exist', async () => {
+            // Real-world bug: App.tsx entity gets versioned (code changes create new SHAs).
+            // The scenario points to the oldest version's SHA. When sync receives all 3
+            // versions of the same default-export entity, it should update the scenario
+            // to the LATEST version, not keep it stuck on the oldest.
+            rawDb
+                .prepare(`INSERT INTO editor_scenarios (id, project_id, name, page_file_path, url, type, viewport_width, viewport_height, entity_sha, display_name)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run('sc-home', projectId, 'Welcome Screen — First Install', 'src/popup/App.tsx', '/', 'application', 400, 600, 'version-1-sha', // stale — points to oldest version
+            'Home');
+            // Pass all 3 versions — all default exports for the same file.
+            // The sync should pick the LAST one (latest) since callers pass
+            // entities in creation order.
+            const result = await backfillEntityShaOnScenarios(db, [
+                {
+                    sha: 'version-1-sha',
+                    name: 'App',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: true,
+                },
+                {
+                    sha: 'version-2-sha',
+                    name: 'App',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: true,
+                },
+                {
+                    sha: 'version-3-sha',
+                    name: 'App',
+                    filePath: 'src/popup/App.tsx',
+                    isDefaultExport: true,
+                },
+            ]);
+            expect(result.updated).toBe(1);
+            const row = rawDb
+                .prepare('SELECT entity_sha FROM editor_scenarios WHERE id = ?')
+                .get('sc-home');
+            expect(row.entity_sha).toBe('version-3-sha');
+        });
     });
     describe('countScenariosNeedingEntityBackfill', () => {
         let db;
@@ -1427,5 +1575,194 @@ describe('editorScenarios', () => {
             expect(result.error).toContain('No glossary entry found');
         });
     });
+    describe('validateScenarioCategorization', () => {
+        it('should reject componentName with non-isolation URL', () => {
+            const result = validateScenarioCategorization({
+                componentName: 'Library',
+                url: '/library',
+            });
+            expect(result.valid).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error).toContain('componentName');
+        });
+        it('should accept componentName with /isolated-components/ URL', () => {
+            const result = validateScenarioCategorization({
+                componentName: 'Library',
+                url: '/isolated-components/Library?s=Default',
+            });
+            expect(result.valid).toBe(true);
+        });
+        it('should accept componentName with /codeyam-isolate/ URL', () => {
+            const result = validateScenarioCategorization({
+                componentName: 'Library',
+                url: '/codeyam-isolate/Library?s=Default',
+            });
+            expect(result.valid).toBe(true);
+        });
+        it('should accept application scenario without componentName', () => {
+            const result = validateScenarioCategorization({
+                url: '/library',
+                type: 'application',
+            });
+            expect(result.valid).toBe(true);
+        });
+        it('should accept component with no URL', () => {
+            const result = validateScenarioCategorization({
+                componentName: 'Library',
+                url: null,
+            });
+            expect(result.valid).toBe(true);
+        });
+        it('should suggest both fixes in error message', () => {
+            const result = validateScenarioCategorization({
+                componentName: 'Library',
+                url: '/library',
+            });
+            expect(result.valid).toBe(false);
+            // Should suggest changing URL to isolation route
+            expect(result.error).toContain('/isolated-components/');
+            // Should suggest removing componentName
+            expect(result.error).toContain('remove');
+        });
+    });
+    describe('resolveSeedFrom', () => {
+        let tmpDir;
+        let db;
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'seedfrom-'));
+            fs.mkdirSync(path.join(tmpDir, '.codeyam', 'editor-scenarios'), {
+                recursive: true,
+            });
+            const raw = new Database(':memory:');
+            raw.exec(`
+        CREATE TABLE editor_scenarios (
+          id TEXT PRIMARY KEY,
+          project_id TEXT,
+          name TEXT,
+          description TEXT,
+          component_name TEXT,
+          component_path TEXT,
+          url TEXT,
+          type TEXT,
+          screenshot_path TEXT,
+          viewport_width INTEGER,
+          viewport_height INTEGER,
+          dimensions TEXT,
+          screenshot_paths TEXT,
+          page_file_path TEXT,
+          entity_sha TEXT,
+          display_name TEXT,
+          created_at TEXT DEFAULT (datetime('now')),
+          updated_at TEXT DEFAULT (datetime('now'))
+        )
+      `);
+            db = new Kysely({ dialect: new SqliteDialect({ database: raw }) });
+        });
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+        it('should resolve seed data by scenario ID', async () => {
+            const scenarioId = 'aaaa-bbbb-cccc-dddd';
+            const seedData = { article: [{ id: '1', title: 'Test' }] };
+            // Write the seed file
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.seed.json`), JSON.stringify(seedData));
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toEqual(seedData);
+        });
+        it('should resolve seed data by scenario name', async () => {
+            const scenarioId = 'eeee-ffff-1111-2222';
+            const seedData = { user: [{ id: '1', name: 'Alice' }] };
+            // Write the seed file
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.seed.json`), JSON.stringify(seedData));
+            // Insert scenario into DB so name lookup works
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: scenarioId,
+                project_id: 'proj-1',
+                name: 'Library - Rich Data',
+                viewport_width: 1280,
+                viewport_height: 720,
+            })
+                .execute();
+            const result = await resolveSeedFrom(tmpDir, db, 'Library - Rich Data');
+            expect(result).toEqual(seedData);
+        });
+        it('should fall back to seed from scenario data file when no .seed.json exists', async () => {
+            const scenarioId = 'cccc-dddd-eeee-ffff';
+            const seedData = { tag: [{ id: '1', name: 'AI' }] };
+            // Write the scenario data file (not the .seed.json)
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.json`), JSON.stringify({ seed: seedData, _metadata: { name: 'Test' } }));
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toEqual(seedData);
+        });
+        it('should return null when scenario not found', async () => {
+            const result = await resolveSeedFrom(tmpDir, db, 'nonexistent');
+            expect(result).toBeNull();
+        });
+        it('should return null when scenario exists but has no seed data', async () => {
+            const scenarioId = 'no-seed-1111-2222';
+            // Scenario data file with no seed
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.json`), JSON.stringify({ _metadata: { name: 'No Seed' } }));
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toBeNull();
+        });
+        it('should return null when seed.json contains invalid JSON', async () => {
+            const scenarioId = 'bad-json-1111';
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.seed.json`), '{ this is not valid json }}}');
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toBeNull();
+        });
+        it('should return null when scenario data file contains invalid JSON', async () => {
+            const scenarioId = 'bad-data-2222';
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.json`), 'not json at all');
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toBeNull();
+        });
+        it('should pick the most recent scenario when multiple share the same name', async () => {
+            const oldId = 'old-scenario-1111';
+            const newId = 'new-scenario-2222';
+            const oldSeed = { article: [{ id: '1', title: 'Old' }] };
+            const newSeed = { article: [{ id: '2', title: 'New' }] };
+            // Write seed files for both
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${oldId}.seed.json`), JSON.stringify(oldSeed));
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${newId}.seed.json`), JSON.stringify(newSeed));
+            // Insert both with the same name, different created_at
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: oldId,
+                project_id: 'proj-1',
+                name: 'Shared Name',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-01-01 00:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: newId,
+                project_id: 'proj-1',
+                name: 'Shared Name',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-03-01 00:00:00',
+            })
+                .execute();
+            const result = await resolveSeedFrom(tmpDir, db, 'Shared Name');
+            expect(result).toEqual(newSeed);
+        });
+        it('should prefer .seed.json over inline seed in data file', async () => {
+            const scenarioId = 'prefer-seed-file';
+            const seedFileData = { article: [{ id: '1', title: 'From seed file' }] };
+            const inlineData = { article: [{ id: '2', title: 'From inline' }] };
+            // Write both files
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.seed.json`), JSON.stringify(seedFileData));
+            fs.writeFileSync(path.join(tmpDir, '.codeyam', 'editor-scenarios', `${scenarioId}.json`), JSON.stringify({ seed: inlineData }));
+            const result = await resolveSeedFrom(tmpDir, db, scenarioId);
+            expect(result).toEqual(seedFileData);
+        });
+    });
 });
 //# sourceMappingURL=editorScenarios.test.js.map