fimo 0.7.0-experimental.1 → 0.7.0-experimental.11

package/dist/scripts/cms/example-content.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { generateExampleSeed } from './example-content.js';
+const blogPost = {
+    name: 'BlogPost',
+    label: 'Blog Post',
+    isSingleton: false,
+    localized: false,
+    fields: {
+        title: { type: 'string' },
+        content: { type: 'richtext' },
+        readTime: { type: 'number' },
+        featured: { type: 'boolean' },
+        publishedOn: { type: 'date' },
+        meta: { type: 'json' },
+        cover: { type: 'media' },
+        category: { type: 'reference', target: 'PostCategory' },
+        tags: { type: 'reference', target: 'PostTag', many: true },
+    },
+    sourceUid: 'api::blog-post.blog-post',
+    sourcePath: '/blog-posts',
+};
+describe('generateExampleSeed', () => {
+    it('generates typed rows with a slug per collection entry', () => {
+        const seed = generateExampleSeed(blogPost, { count: 2 });
+        expect(seed.rows).toHaveLength(2);
+        const [first, second] = seed.rows;
+        expect(first.slug).toBe('blog-post-example-1');
+        expect(first.title).toBe('Title example 1');
+        expect(first.content).toMatchObject({ type: 'doc' });
+        expect(first.readTime).toBe(1);
+        expect(first.featured).toBe(true);
+        expect(second.featured).toBe(false);
+        expect(first.publishedOn).toBe('2024-01-01');
+        expect(second.publishedOn).toBe('2024-01-02');
+        expect(first.meta).toEqual({});
+    });
+    it('seeds a self-contained placeholder for media fields', () => {
+        const seed = generateExampleSeed(blogPost, { count: 1 });
+        expect(seed.rows[0].cover).toMatchObject({ source: 'local', width: 1200, height: 630 });
+        expect(seed.rows[0].cover.url).toContain('data:image/svg+xml');
+    });
+    it('points references at the first example of the target, with a descriptor', () => {
+        const seed = generateExampleSeed(blogPost, { count: 1 });
+        expect(seed.rows[0].category).toBe('post-category-example-1');
+        expect(seed.rows[0].tags).toEqual(['post-tag-example-1']);
+        expect(seed.references.category).toEqual({ target: 'PostCategory', by: 'slug' });
+        expect(seed.references.tags).toEqual({ target: 'PostTag', by: 'slug', many: true });
+    });
+    it('gives a singleton exactly one slug-less row', () => {
+        const seed = generateExampleSeed({ ...blogPost, name: 'Global', isSingleton: true }, { count: 5 });
+        expect(seed.rows).toHaveLength(1);
+        expect(seed.rows[0].slug).toBeUndefined();
+    });
+    it('varies string values per locale so per-language editing is visible', () => {
+        const fr = generateExampleSeed(blogPost, { count: 1, locale: 'fr' });
+        expect(fr.rows[0].title).toBe('Title example 1 (fr)');
+    });
+    it('uses a connector-supplied example (dynamic-zone array) over the type default', () => {
+        const withExample = {
+            ...blogPost,
+            fields: { ...blogPost.fields, sections: { type: 'json' } },
+            examples: { sections: [] },
+        };
+        expect(generateExampleSeed(withExample, { count: 1 }).rows[0].sections).toEqual([]);
+    });
+});

package/dist/scripts/cms/strapi/detect.d.ts

@@ -0,0 +1,2 @@
+import type { CmsDetection } from '../types.js';
+export declare function detectStrapi(frontendDir: string): CmsDetection | null;

package/dist/scripts/cms/strapi/detect.js

@@ -0,0 +1,186 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/**
+ * Detect a Strapi backend behind a wrapped frontend. Strapi is consumed via a
+ * hand-rolled fetch client against an env-var base URL (no SDK, no hardcoded
+ * URL), so the generic external-source scanner misses it entirely — detection
+ * keys on the distinctive local signals instead:
+ *   - a dependency whose name mentions strapi (`@repo/strapi-types`,
+ *     `@strapi/client`, generated types packages);
+ *   - a `strapi`-named client module under `src/lib`/`src`;
+ *   - Strapi's `api::x.y` content-type UID strings in the source;
+ *   - a `STRAPI`-flavored base-URL env var.
+ * The co-located Strapi app (monorepo) is located by walking up to the
+ * workspace root and finding the sibling that depends on `@strapi/strapi`; its
+ * path drives schema import. A decoupled Strapi (no co-located app) still
+ * surfaces as a source for the keep-live decision, with `appDir: null`.
+ */
+const UID_RE = /["'`]api::[a-z0-9-]+\.[a-z0-9-]+["'`]/;
+const STRAPI_ENV_RE = /STRAPI[A-Z0-9_]*_URL|NEXT_PUBLIC_STRAPI/;
+const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs)$/;
+const SKIP_DIRS = new Set(['node_modules', '.next', '.turbo', 'dist', 'build', '.git', 'coverage']);
+const MAX_FILES_SCANNED = 400;
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function readDeps(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+function strapiDependency(deps) {
+    for (const name of Object.keys(deps)) {
+        if (/strapi/i.test(name)) {
+            return name;
+        }
+    }
+    return null;
+}
+/** Shallow look for a `strapi`-named client module under src/lib or src. */
+function strapiLibModule(frontendDir) {
+    for (const base of [join(frontendDir, 'src', 'lib'), join(frontendDir, 'src'), join(frontendDir, 'lib')]) {
+        if (!existsSync(base)) {
+            continue;
+        }
+        try {
+            for (const entry of readdirSync(base, { withFileTypes: true })) {
+                if (/strapi/i.test(entry.name)) {
+                    return join(base, entry.name);
+                }
+            }
+        }
+        catch {
+            // unreadable dir — ignore
+        }
+    }
+    return null;
+}
+/** Bounded source scan for `api::x.y` UID strings or a STRAPI base-URL env. */
+function scanSourceSignals(frontendDir) {
+    const root = existsSync(join(frontendDir, 'src')) ? join(frontendDir, 'src') : frontendDir;
+    let scanned = 0;
+    let uid = false;
+    let env = false;
+    const walk = (dir) => {
+        if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
+            return;
+        }
+        for (const entry of safeReaddir(dir)) {
+            if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
+                return;
+            }
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                    walk(join(dir, entry.name));
+                }
+                continue;
+            }
+            if (!SOURCE_EXT_RE.test(entry.name)) {
+                continue;
+            }
+            scanned += 1;
+            try {
+                const text = readFileSync(join(dir, entry.name), 'utf8');
+                if (!uid && UID_RE.test(text)) {
+                    uid = true;
+                }
+                if (!env && STRAPI_ENV_RE.test(text)) {
+                    env = true;
+                }
+            }
+            catch {
+                // unreadable file — ignore
+            }
+        }
+    };
+    walk(root);
+    return { uid, env };
+}
+function findWorkspaceRoot(startDir) {
+    let dir = startDir;
+    for (let depth = 0; depth < 6; depth += 1) {
+        if (existsSync(join(dir, 'pnpm-workspace.yaml')) ||
+            existsSync(join(dir, 'turbo.json')) ||
+            existsSync(join(dir, 'lerna.json'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+}
+/** Find the sibling app that depends on `@strapi/strapi` (the CMS app). */
+function findStrapiApp(frontendDir) {
+    const root = findWorkspaceRoot(frontendDir);
+    if (!root) {
+        return null;
+    }
+    const searchRoots = [join(root, 'apps'), root, join(root, 'packages')];
+    for (const searchRoot of searchRoots) {
+        if (!existsSync(searchRoot)) {
+            continue;
+        }
+        for (const entry of safeReaddir(searchRoot)) {
+            if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
+                continue;
+            }
+            const candidate = join(searchRoot, entry.name);
+            const deps = readDeps(candidate);
+            if (deps['@strapi/strapi'] && existsSync(join(candidate, 'src', 'api'))) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+export function detectStrapi(frontendDir) {
+    if (!existsSync(frontendDir) || !statSync(frontendDir).isDirectory()) {
+        return null;
+    }
+    const evidence = [];
+    const dep = strapiDependency(readDeps(frontendDir));
+    if (dep) {
+        evidence.push(`dependency ${dep}`);
+    }
+    const libModule = strapiLibModule(frontendDir);
+    if (libModule) {
+        evidence.push(`client module ${libModule.slice(frontendDir.length + 1)}`);
+    }
+    // Only pay for the source scan when the cheap signals are inconclusive.
+    if (evidence.length === 0) {
+        const signals = scanSourceSignals(frontendDir);
+        if (signals.uid) {
+            evidence.push('api::* content-type UIDs in source');
+        }
+        if (signals.env) {
+            evidence.push('STRAPI base-URL env var');
+        }
+    }
+    if (evidence.length === 0) {
+        return null;
+    }
+    const appDir = findStrapiApp(frontendDir);
+    if (appDir) {
+        evidence.push(`schemas in ${appDir.slice(findWorkspaceRoot(frontendDir).length + 1)}`);
+    }
+    return {
+        cms: 'Strapi',
+        host: 'Strapi',
+        appDir,
+        clientDir: libModule,
+        evidence,
+        locales: [],
+    };
+}

package/dist/scripts/cms/strapi/detect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/cms/strapi/detect.test.js

@@ -0,0 +1,56 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { detectStrapi } from './detect.js';
+let root;
+function pkg(dir, deps) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 't', dependencies: deps }));
+}
+afterEach(() => {
+    if (root) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+describe('detectStrapi', () => {
+    it('detects Strapi in a monorepo via a types dep and locates the CMS app', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-'));
+        writeFileSync(join(root, 'pnpm-workspace.yaml'), 'packages:\n  - apps/*\n');
+        const frontend = join(root, 'apps', 'ui');
+        pkg(frontend, { next: '^16.0.0', '@repo/strapi-types': 'workspace:*' });
+        const cms = join(root, 'apps', 'strapi');
+        pkg(cms, { '@strapi/strapi': '5.48.1' });
+        mkdirSync(join(cms, 'src', 'api'), { recursive: true });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.cms).toBe('Strapi');
+        expect(detection.host).toBe('Strapi');
+        expect(detection.appDir).toBe(cms);
+        expect(detection.evidence.some((e) => e.includes('@repo/strapi-types'))).toBe(true);
+    });
+    it('detects Strapi via a strapi-named client module with no dependency', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-lib-'));
+        const frontend = join(root, 'app');
+        pkg(frontend, { next: '^16.0.0' });
+        mkdirSync(join(frontend, 'src', 'lib', 'strapi-api'), { recursive: true });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.evidence.some((e) => e.includes('strapi-api'))).toBe(true);
+    });
+    it('detects a decoupled Strapi (SDK dep, no co-located app) with a null appDir', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-decoupled-'));
+        const frontend = join(root, 'frontend');
+        pkg(frontend, { next: '^16.0.0', '@strapi/client': '^1.0.0' });
+        const detection = detectStrapi(frontend);
+        expect(detection).not.toBeNull();
+        expect(detection.appDir).toBeNull();
+    });
+    it('returns null when there is no Strapi signal', () => {
+        root = mkdtempSync(join(tmpdir(), 'strapi-detect-none-'));
+        const frontend = join(root, 'app');
+        pkg(frontend, { next: '^16.0.0', '@sanity/client': '^3.0.0' });
+        mkdirSync(join(frontend, 'src', 'components'), { recursive: true });
+        expect(detectStrapi(frontend)).toBeNull();
+    });
+});

package/dist/scripts/cms/strapi/index.d.ts

@@ -0,0 +1,3 @@
+import type { CmsConnector } from '../types.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export declare function strapiConnector(frontendDir: string): CmsConnector | null;

package/dist/scripts/cms/strapi/index.js

@@ -0,0 +1,25 @@
+import { detectStrapi } from './detect.js';
+import { renderStrapiListSource } from './list-source.js';
+import { readStrapiSchemas } from './schema-map.js';
+import { detectStrapiTouchpoints } from './touchpoints.js';
+import { wireStrapiClient } from './wire-client.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export function strapiConnector(frontendDir) {
+    const detection = detectStrapi(frontendDir);
+    if (!detection) {
+        return null;
+    }
+    return {
+        detection,
+        readSchemas: () => (detection.appDir ? readStrapiSchemas(detection.appDir) : []),
+        renderListSource: (schemas, serverImport) => schemas.length > 0 ? renderStrapiListSource(schemas, serverImport) : null,
+        wireClient: (cwd, schemas) => detection.clientDir
+            ? wireStrapiClient(cwd, detection.clientDir, schemas)
+            : {
+                changes: [],
+                warnings: ['No Strapi client directory detected — wire fimoStrapiFetch manually.'],
+                wired: false,
+            },
+        detectTouchpoints: (cwd) => detectStrapiTouchpoints(cwd),
+    };
+}

package/dist/scripts/cms/strapi/list-source.d.ts

@@ -0,0 +1,17 @@
+import type { CmsCollectionSchema } from '../types.js';
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export declare function renderStrapiListSource(schemas: CmsCollectionSchema[], serverImport: string): string;

package/dist/scripts/cms/strapi/list-source.js

@@ -0,0 +1,90 @@
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export function renderStrapiListSource(schemas, serverImport) {
+    const entries = schemas
+        .filter((schema) => !schema.isSingleton)
+        .map((schema) => `  '${schema.sourceUid}': '${schema.name}',`)
+        .join('\n');
+    return `// AUTO-GENERATED by \`fimo migrate --scaffold-cms\`. Renders the CMS collections
+// scaffolded into Fimo (EXAMPLE content) for LIST views, so pages show the fake
+// content from Fimo while detail views and dynamic zones stay on your CMS.
+//
+// Wire your CMS client's list methods to this (see the migration prompt), e.g.
+// inside fetchMany/fetchAll:  const fimo = await fimoCmsList(uid, { limit });
+//                             if (fimo) return fimo;
+// Best-effort and generic by design — adjust per component as needed.
+import { fetchEntries } from '${serverImport}';
+
+// Strapi content-type UID -> Fimo type name (from the scaffold).
+const FIMO_TYPES: Record<string, string> = {
+${entries}
+};
+
+function docToText(node: unknown): string {
+  if (!node || typeof node !== 'object') {
+    return '';
+  }
+  const record = node as { text?: unknown; content?: unknown };
+  if (typeof record.text === 'string') {
+    return record.text;
+  }
+  if (Array.isArray(record.content)) {
+    return record.content.map(docToText).join(' ');
+  }
+  return '';
+}
+
+function reshapeValue(value: unknown): unknown {
+  // Richtext is a ProseMirror doc -> flatten to plain text so string consumers
+  // (excerpts, read-time) are safe. Media { url, ... } and scalars pass through.
+  if (value && typeof value === 'object' && (value as { type?: unknown }).type === 'doc') {
+    return docToText(value);
+  }
+  return value;
+}
+
+function reshape(data: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    out[key] = reshapeValue(value);
+  }
+  return out;
+}
+
+/**
+ * A Strapi-v5-shaped list envelope built from the scaffolded Fimo content, or
+ * null when nothing was scaffolded for this UID (fall back to the live CMS).
+ */
+export async function fimoCmsList(
+  uid: string,
+  options: { limit?: number } = {}
+): Promise<{ data: Record<string, unknown>[]; meta: { pagination: Record<string, number> } } | null> {
+  const typeName = FIMO_TYPES[uid];
+  if (!typeName) {
+    return null;
+  }
+  const entries = await fetchEntries(typeName, options.limit ? { limit: options.limit } : {});
+  if (entries.length === 0) {
+    return null;
+  }
+  const data = entries.map((entry) => ({ id: entry.id, documentId: entry.id, ...reshape(entry.data) }));
+  return {
+    data,
+    meta: { pagination: { page: 1, pageSize: data.length, pageCount: 1, total: data.length } },
+  };
+}
+`;
+}

package/dist/scripts/cms/strapi/list-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/cms/strapi/list-source.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { renderStrapiListSource } from './list-source.js';
+const schema = (name, sourceUid, isSingleton = false) => ({
+    name,
+    label: name,
+    isSingleton,
+    localized: false,
+    fields: {},
+    sourceUid,
+    sourcePath: `/${name.toLowerCase()}`,
+});
+describe('renderStrapiListSource', () => {
+    it('emits a helper importing fetchEntries with a uid→type map for collections only', () => {
+        const src = renderStrapiListSource([
+            schema('BlogPost', 'api::blog-post.blog-post'),
+            schema('PostTag', 'api::post-tag.post-tag'),
+            schema('Global', 'api::global.global', true),
+        ], 'fimo/next/server');
+        expect(src).toContain("import { fetchEntries } from 'fimo/next/server';");
+        expect(src).toContain("'api::blog-post.blog-post': 'BlogPost',");
+        expect(src).toContain("'api::post-tag.post-tag': 'PostTag',");
+        // Singletons have no list view — excluded from the map.
+        expect(src).not.toContain('api::global.global');
+        expect(src).toContain('export async function fimoCmsList(');
+        // Richtext flattening + fallback-to-CMS contract are present.
+        expect(src).toContain('docToText');
+        expect(src).toContain('return null');
+    });
+    it('threads the framework server import through', () => {
+        const src = renderStrapiListSource([schema('Cms', 'api::cms.cms')], 'fimo/astro/server');
+        expect(src).toContain("import { fetchEntries } from 'fimo/astro/server';");
+    });
+});

package/dist/scripts/cms/strapi/schema-map.d.ts

@@ -0,0 +1,9 @@
+import type { CmsCollectionSchema } from '../types.js';
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export declare function pascalCase(name: string): string;
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields.
+ */
+export declare function readStrapiSchemas(strapiAppDir: string): CmsCollectionSchema[];

package/dist/scripts/cms/strapi/schema-map.js

@@ -0,0 +1,149 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const TO_MANY = new Set(['oneToMany', 'manyToMany']);
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export function pascalCase(name) {
+    return name
+        .replace(/[^a-zA-Z0-9]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (c) => c.toUpperCase());
+}
+/**
+ * Map one Strapi attribute to a Fimo field. Returns `null` for fields Fimo does
+ * not model as content (the slug uid, passwords). Relations to imported types
+ * become references; relations to non-imported targets (users, plugins) and
+ * structural fields (components, dynamic zones) fall back to `json` so example
+ * content round-trips and never dangles.
+ */
+function mapAttribute(field, attr, uidToName) {
+    if (field === 'slug') {
+        // Fimo reserves `slug` as entry metadata (set inside the row data).
+        return null;
+    }
+    switch (attr.type) {
+        case 'password':
+            return null;
+        case 'string':
+        case 'text':
+        case 'email':
+        case 'uid':
+        case 'enumeration':
+            return { type: 'string' };
+        case 'richtext':
+        case 'blocks':
+            return { type: 'richtext' };
+        case 'integer':
+        case 'biginteger':
+        case 'decimal':
+        case 'float':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'date':
+        case 'datetime':
+        case 'time':
+        case 'timestamp':
+            return { type: 'date' };
+        case 'media':
+            return { type: 'media' };
+        case 'json':
+        case 'component':
+        case 'dynamiczone':
+            return { type: 'json' };
+        case 'relation': {
+            const targetName = attr.target ? uidToName.get(attr.target) : undefined;
+            if (!targetName) {
+                // Relation to a non-imported target (users-permissions, other plugins).
+                return { type: 'json' };
+            }
+            const many = attr.relation ? TO_MANY.has(attr.relation) : false;
+            return many ? { type: 'reference', target: targetName, many: true } : { type: 'reference', target: targetName };
+        }
+        default:
+            // Unknown/custom attribute — never crash; keep the value verbatim.
+            return { type: 'json' };
+    }
+}
+function mapSchema(raw, uidToName) {
+    const info = raw.schema.info ?? {};
+    const name = uidToName.get(raw.uid);
+    const fields = {};
+    const examples = {};
+    for (const [field, attr] of Object.entries(raw.schema.attributes ?? {})) {
+        const mapped = mapAttribute(field, attr, uidToName);
+        if (mapped) {
+            fields[field] = mapped;
+            // Dynamic zones (and repeatable components) render as ARRAYS a page
+            // builder maps over; a single component as an OBJECT. Seed the correct
+            // empty shape so pages render instead of crashing on `{}.map(...)`.
+            if (attr.type === 'dynamiczone' || (attr.type === 'component' && attr.repeatable)) {
+                examples[field] = [];
+            }
+            else if (attr.type === 'component') {
+                examples[field] = {};
+            }
+        }
+    }
+    return {
+        name,
+        label: info.displayName || name,
+        isSingleton: raw.schema.kind === 'singleType',
+        localized: raw.schema.pluginOptions?.i18n?.localized === true,
+        fields,
+        ...(Object.keys(examples).length > 0 ? { examples } : {}),
+        sourceUid: raw.uid,
+        sourcePath: `/${info.pluralName ?? raw.contentTypeName}`,
+    };
+}
+/** Walk `<strapiAppDir>/src/api/<api>/content-types/<ct>/schema.json`. */
+function collectRawSchemas(strapiAppDir) {
+    const apiDir = join(strapiAppDir, 'src', 'api');
+    if (!existsSync(apiDir)) {
+        return [];
+    }
+    const raws = [];
+    for (const apiEntry of readdirSync(apiDir, { withFileTypes: true })) {
+        if (!apiEntry.isDirectory()) {
+            continue;
+        }
+        const ctRoot = join(apiDir, apiEntry.name, 'content-types');
+        if (!existsSync(ctRoot)) {
+            continue;
+        }
+        for (const ctEntry of readdirSync(ctRoot, { withFileTypes: true })) {
+            if (!ctEntry.isDirectory()) {
+                continue;
+            }
+            const schemaPath = join(ctRoot, ctEntry.name, 'schema.json');
+            if (!existsSync(schemaPath)) {
+                continue;
+            }
+            try {
+                const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+                raws.push({
+                    uid: `api::${apiEntry.name}.${ctEntry.name}`,
+                    apiName: apiEntry.name,
+                    contentTypeName: ctEntry.name,
+                    schema,
+                });
+            }
+            catch {
+                // Malformed schema.json — skip, never abort the whole import.
+            }
+        }
+    }
+    return raws;
+}
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields.
+ */
+export function readStrapiSchemas(strapiAppDir) {
+    const raws = collectRawSchemas(strapiAppDir);
+    const uidToName = new Map();
+    for (const raw of raws) {
+        const singular = raw.schema.info?.singularName ?? raw.contentTypeName;
+        uidToName.set(raw.uid, pascalCase(singular));
+    }
+    return raws.map((raw) => mapSchema(raw, uidToName)).sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/scripts/cms/strapi/schema-map.test.d.ts

@@ -0,0 +1 @@
+export {};