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

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

@@ -0,0 +1,91 @@
+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 { readStrapiSchemas } from './schema-map.js';
+let dir;
+function writeSchema(apiName, ctName, schema) {
+    const ctDir = join(dir, 'src', 'api', apiName, 'content-types', ctName);
+    mkdirSync(ctDir, { recursive: true });
+    writeFileSync(join(ctDir, 'schema.json'), JSON.stringify(schema));
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('readStrapiSchemas', () => {
+    it('maps Strapi attribute types to Fimo fields and resolves relations', () => {
+        dir = mkdtempSync(join(tmpdir(), 'strapi-schema-'));
+        writeSchema('blog-post', 'blog-post', {
+            kind: 'collectionType',
+            info: { singularName: 'blog-post', pluralName: 'blog-posts', displayName: 'Blog Post' },
+            pluginOptions: {},
+            attributes: {
+                title: { type: 'string', required: true },
+                slug: { type: 'uid', targetField: 'title' },
+                content: { type: 'richtext' },
+                readTime: { type: 'integer' },
+                featured: { type: 'boolean' },
+                publishedAt: { type: 'datetime' },
+                level: { type: 'enumeration', enum: ['a', 'b'] },
+                cover: { type: 'media' },
+                hero: { type: 'component', component: 'blocks.hero', repeatable: false },
+                sections: { type: 'dynamiczone', components: [] },
+                category: { type: 'relation', relation: 'manyToOne', target: 'api::post-category.post-category' },
+                tags: { type: 'relation', relation: 'manyToMany', target: 'api::post-tag.post-tag' },
+                author: { type: 'relation', relation: 'manyToOne', target: 'plugin::users-permissions.user' },
+            },
+        });
+        writeSchema('post-category', 'post-category', {
+            kind: 'collectionType',
+            info: { singularName: 'post-category', pluralName: 'post-categories', displayName: 'Post Category' },
+            attributes: { name: { type: 'string' }, slug: { type: 'uid' } },
+        });
+        writeSchema('post-tag', 'post-tag', {
+            kind: 'collectionType',
+            info: { singularName: 'post-tag', pluralName: 'post-tags', displayName: 'Post Tag' },
+            attributes: { name: { type: 'string' } },
+        });
+        writeSchema('global', 'global', {
+            kind: 'singleType',
+            info: { singularName: 'global', pluralName: 'globals', displayName: 'Global' },
+            pluginOptions: { i18n: { localized: true } },
+            attributes: { siteName: { type: 'string' } },
+        });
+        const schemas = readStrapiSchemas(dir);
+        expect(schemas.map((s) => s.name)).toEqual(['BlogPost', 'Global', 'PostCategory', 'PostTag']);
+        const blogPost = schemas.find((s) => s.name === 'BlogPost');
+        expect(blogPost.isSingleton).toBe(false);
+        expect(blogPost.localized).toBe(false);
+        expect(blogPost.sourceUid).toBe('api::blog-post.blog-post');
+        expect(blogPost.fields).toMatchObject({
+            title: { type: 'string' },
+            content: { type: 'richtext' },
+            readTime: { type: 'number' },
+            featured: { type: 'boolean' },
+            publishedAt: { type: 'date' },
+            level: { type: 'string' },
+            cover: { type: 'media' },
+            hero: { type: 'json' },
+            sections: { type: 'json' },
+            category: { type: 'reference', target: 'PostCategory' },
+            tags: { type: 'reference', target: 'PostTag', many: true },
+            author: { type: 'json' },
+        });
+        // slug is reserved entry metadata — never a schema field.
+        expect('slug' in blogPost.fields).toBe(false);
+        // Structural fields get the correct empty shape so pages render:
+        // dynamic zone → array, single component → object.
+        expect(blogPost.examples?.sections).toEqual([]);
+        expect(blogPost.examples?.hero).toEqual({});
+        const global = schemas.find((s) => s.name === 'Global');
+        expect(global.isSingleton).toBe(true);
+        expect(global.localized).toBe(true);
+    });
+    it('returns an empty list when the app has no content types', () => {
+        dir = mkdtempSync(join(tmpdir(), 'strapi-schema-empty-'));
+        mkdirSync(join(dir, 'src'), { recursive: true });
+        expect(readStrapiSchemas(dir)).toEqual([]);
+    });
+});

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

@@ -0,0 +1,31 @@
+export type StrapiCallReason = 'strapi-sdk-import' | 'env-ref' | 'uid-ref';
+export interface StrapiCallSite {
+    /** Path relative to the frontend directory. */
+    file: string;
+    line: number;
+    reason: StrapiCallReason;
+    snippet: string;
+}
+export interface StrapiTouchpoints {
+    /** Strapi SDK / client / generated-type packages still declared in package.json. */
+    dependencies: string[];
+    /** Source lines that still reach Strapi at runtime. */
+    callSites: StrapiCallSite[];
+    /** `STRAPI_*` keys still present in dotenv files (cleanup; low severity). */
+    envVars: string[];
+    /** No runtime Strapi coupling remains (no SDK deps, no call sites): the cutover is complete. */
+    clean: boolean;
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export declare function detectStrapiTouchpoints(frontendDir: string): StrapiTouchpoints;

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

@@ -0,0 +1,145 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs|astro|vue|svelte)$/;
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.vercel',
+    '.git',
+]);
+const MAX_FILES = 2000;
+/** A runtime reference to Strapi's base-URL / token env config. */
+const ENV_REF_RE = /\bSTRAPI[A-Z0-9_]*_URL\b|\bNEXT_PUBLIC_STRAPI[A-Z0-9_]*\b|\bSTRAPI[A-Z0-9_]*_TOKEN\b/;
+/** A Strapi content-type UID string (`api::article.article`). */
+const UID_REF_RE = /api::[a-z0-9-]+\.[a-z0-9-]+/;
+/** An import/require specifier — captured so a Strapi SDK can be told apart from `fimo/strapi`. */
+const IMPORT_RE = /(?:from\s+|require\(\s*|import\(\s*)['"`]([^'"`]+)['"`]/;
+/** A STRAPI env assignment in a dotenv file. */
+const ENV_KEY_RE = /^\s*([A-Z0-9_]*STRAPI[A-Z0-9_]*)\s*=/;
+function readDeps(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+function classifyLine(line) {
+    const importMatch = IMPORT_RE.exec(line);
+    // A Strapi SDK/client import — but NOT the `fimo/strapi` compat adapter.
+    if (importMatch && /strapi/i.test(importMatch[1]) && !/fimo/i.test(importMatch[1])) {
+        return 'strapi-sdk-import';
+    }
+    if (ENV_REF_RE.test(line)) {
+        return 'env-ref';
+    }
+    if (UID_REF_RE.test(line)) {
+        return 'uid-ref';
+    }
+    return null;
+}
+function scanCallSites(frontendDir) {
+    const sites = [];
+    let scanned = 0;
+    const walk = (dir) => {
+        if (scanned >= MAX_FILES) {
+            return;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (scanned >= MAX_FILES) {
+                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;
+            const full = join(dir, entry.name);
+            let text;
+            try {
+                text = readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length; i += 1) {
+                const reason = classifyLine(lines[i]);
+                if (reason) {
+                    sites.push({
+                        file: relative(frontendDir, full),
+                        line: i + 1,
+                        reason,
+                        snippet: lines[i].trim().slice(0, 200),
+                    });
+                }
+            }
+        }
+    };
+    walk(frontendDir);
+    return sites;
+}
+function scanEnvKeys(frontendDir) {
+    const keys = new Set();
+    for (const name of ['.env', '.env.local', '.env.development', '.env.production']) {
+        const file = join(frontendDir, name);
+        if (!existsSync(file)) {
+            continue;
+        }
+        try {
+            for (const line of readFileSync(file, 'utf8').split('\n')) {
+                const match = ENV_KEY_RE.exec(line);
+                if (match) {
+                    keys.add(match[1]);
+                }
+            }
+        }
+        catch {
+            // unreadable — ignore
+        }
+    }
+    return [...keys];
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export function detectStrapiTouchpoints(frontendDir) {
+    const dependencies = Object.keys(readDeps(frontendDir)).filter((name) => /strapi/i.test(name));
+    const callSites = scanCallSites(frontendDir);
+    const envVars = scanEnvKeys(frontendDir);
+    return {
+        dependencies,
+        callSites,
+        envVars,
+        clean: dependencies.length === 0 && callSites.length === 0,
+    };
+}

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

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

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

@@ -0,0 +1,62 @@
+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 { detectStrapiTouchpoints } from './touchpoints.js';
+let dir;
+function frontend(files) {
+    dir = mkdtempSync(join(tmpdir(), 'strapi-touchpoints-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('detectStrapiTouchpoints', () => {
+    it('enumerates deps, call sites, and env for a still-wired frontend', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({
+                dependencies: { '@strapi/client': '^1.0.0', next: '16.0.0' },
+                devDependencies: { '@repo/strapi-types': 'workspace:*' },
+            }),
+            'src/lib/strapi.ts': "import { strapi } from '@strapi/client';\nexport const client = strapi({ baseURL: process.env.STRAPI_URL });\n",
+            'src/app/page.tsx': "const data = await client.collection('api::article.article').find();\n",
+            '.env': 'STRAPI_URL=https://cms.example.com\nNEXT_PUBLIC_STRAPI_URL=https://cms.example.com\nOTHER=1\n',
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies.sort()).toEqual(['@repo/strapi-types', '@strapi/client']);
+        expect(result.envVars.sort()).toEqual(['NEXT_PUBLIC_STRAPI_URL', 'STRAPI_URL']);
+        expect(result.callSites.map((site) => site.reason).sort()).toEqual(['env-ref', 'strapi-sdk-import', 'uid-ref']);
+        expect(result.callSites.find((site) => site.reason === 'strapi-sdk-import')?.file).toBe('src/lib/strapi.ts');
+        expect(result.clean).toBe(false);
+    });
+    it('reads a rewired frontend as clean — a lib/strapi.ts calling Fimo is not a touchpoint', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({ dependencies: { fimo: '0.7.0', next: '16.0.0' } }),
+            // Same filename, but now Fimo-backed: no Strapi references.
+            'src/lib/strapi.ts': "import { fimoStrapiFetch } from 'fimo/strapi';\nexport const client = fimoStrapiFetch;\n",
+            'src/app/page.tsx': "const data = await client('/articles');\n",
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies).toEqual([]);
+        expect(result.callSites).toEqual([]);
+        expect(result.clean).toBe(true);
+    });
+    it('flags a lingering STRAPI env reference in config even when deps are gone', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({ dependencies: { next: '16.0.0' } }),
+            'next.config.mjs': 'export default { images: { domains: [process.env.STRAPI_MEDIA_URL] } };\n',
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies).toEqual([]);
+        expect(result.callSites).toHaveLength(1);
+        expect(result.callSites[0]).toMatchObject({ file: 'next.config.mjs', reason: 'env-ref' });
+        expect(result.clean).toBe(false);
+    });
+});

package/dist/scripts/cms/strapi/wire-client.d.ts

@@ -0,0 +1,15 @@
+import type { CmsCollectionSchema } from '../types.js';
+/**
+ * Machine-wire a Strapi frontend to read from Fimo: emit the `fimo-strapi`
+ * module in the CMS client dir, then swap every bare `fetch(...)` in that dir
+ * to `fimoStrapiFetch(...)`. Because every Strapi client funnels through one
+ * `fetch`, this makes the WHOLE site read scaffolded content from Fimo — no
+ * per-method or per-call-site knowledge, no agent step. Unscaffolded types fall
+ * through to the live CMS inside the shim.
+ */
+export interface StrapiWireResult {
+    changes: string[];
+    warnings: string[];
+    wired: boolean;
+}
+export declare function wireStrapiClient(cwd: string, clientDir: string, schemas: CmsCollectionSchema[]): StrapiWireResult;

package/dist/scripts/cms/strapi/wire-client.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+import { renderFimoStrapiModule } from './wiring.js';
+function walk(node, visit) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            walk(child, visit);
+        }
+        return;
+    }
+    const record = node;
+    if (typeof record.type === 'string') {
+        visit(record);
+    }
+    for (const [key, value] of Object.entries(record)) {
+        if (key !== 'type' && value && typeof value === 'object') {
+            walk(value, visit);
+        }
+    }
+}
+/** Callee spans of bare `fetch(...)` calls (not `x.fetch()` / `this.fetch()`). */
+function bareFetchCallees(filePath, code) {
+    let program;
+    try {
+        program = parseSync(filePath, code).program;
+    }
+    catch {
+        return [];
+    }
+    const spans = [];
+    walk(program, (n) => {
+        if (n.type === 'CallExpression' && n.callee?.type === 'Identifier' && n.callee.name === 'fetch') {
+            spans.push({ start: n.callee.start, end: n.callee.end });
+        }
+    });
+    return spans;
+}
+function applyReplacements(code, edits) {
+    let next = code;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+        next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+    }
+    return next;
+}
+function relativeImport(fromFile, toFile) {
+    const rel = path
+        .relative(path.dirname(fromFile), toFile)
+        .replace(/\.tsx?$/, '')
+        .split(path.sep)
+        .join('/');
+    return rel.startsWith('.') ? rel : `./${rel}`;
+}
+function sourceFiles(dir) {
+    const out = [];
+    const walkDir = (current) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                continue;
+            }
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                walkDir(full);
+            }
+            else if (/\.(tsx?|jsx?|mjs)$/.test(entry.name)) {
+                out.push(full);
+            }
+        }
+    };
+    if (fs.existsSync(dir)) {
+        walkDir(dir);
+    }
+    return out;
+}
+export function wireStrapiClient(cwd, clientDir, schemas) {
+    const changes = [];
+    const warnings = [];
+    if (!fs.existsSync(clientDir)) {
+        return { changes, warnings: [`CMS client directory not found: ${path.relative(cwd, clientDir)}`], wired: false };
+    }
+    const modulePath = path.join(clientDir, 'fimo-strapi.ts');
+    fs.writeFileSync(modulePath, renderFimoStrapiModule(schemas));
+    changes.push(`generated ${path.relative(cwd, modulePath)}`);
+    let swapped = 0;
+    for (const file of sourceFiles(clientDir)) {
+        if (path.resolve(file) === path.resolve(modulePath)) {
+            continue;
+        }
+        const code = fs.readFileSync(file, 'utf8');
+        const spans = bareFetchCallees(file, code);
+        if (spans.length === 0) {
+            continue;
+        }
+        let next = applyReplacements(code, spans.map((span) => ({ ...span, text: 'fimoStrapiFetch' })));
+        next = `import { fimoStrapiFetch } from '${relativeImport(file, modulePath)}';\n${next}`;
+        fs.writeFileSync(file, next);
+        swapped += spans.length;
+        changes.push(`rewired ${path.relative(cwd, file)}: ${spans.length} fetch call(s) → fimoStrapiFetch`);
+    }
+    if (swapped === 0) {
+        warnings.push(`No bare fetch() call found under ${path.relative(cwd, clientDir)} — wire fimoStrapiFetch into the client manually.`);
+    }
+    return { changes, warnings, wired: swapped > 0 };
+}

package/dist/scripts/cms/strapi/wire-client.test.d.ts

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

package/dist/scripts/cms/strapi/wire-client.test.js

@@ -0,0 +1,51 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { wireStrapiClient } from './wire-client.js';
+let dir;
+const schemas = [
+    {
+        name: 'BlogPost',
+        label: 'Blog Post',
+        isSingleton: false,
+        localized: false,
+        fields: {},
+        sourceUid: 'api::blog-post.blog-post',
+        sourcePath: '/blog-posts',
+    },
+];
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('wireStrapiClient', () => {
+    it('generates the fimo-strapi module and swaps bare fetch calls', () => {
+        dir = mkdtempSync(join(tmpdir(), 'wire-strapi-'));
+        const clientDir = join(dir, 'src', 'lib', 'strapi-api');
+        mkdirSync(clientDir, { recursive: true });
+        writeFileSync(join(clientDir, 'base.ts'), 'export async function req(url: string, init: RequestInit) {\n  const response = await fetch(url, init);\n  return response;\n}\n');
+        writeFileSync(join(clientDir, 'other.ts'), 'export const x = 1;\n');
+        const result = wireStrapiClient(dir, clientDir, schemas);
+        expect(result.wired).toBe(true);
+        const generated = readFileSync(join(clientDir, 'fimo-strapi.ts'), 'utf8');
+        expect(generated).toContain('createFimoStrapiFetch');
+        expect(generated).toContain("'blog-posts': 'BlogPost',");
+        const base = readFileSync(join(clientDir, 'base.ts'), 'utf8');
+        expect(base).toContain('await fimoStrapiFetch(url, init)');
+        expect(base).not.toContain('await fetch(');
+        expect(base).toContain("import { fimoStrapiFetch } from './fimo-strapi';");
+        // A file with no fetch stays untouched.
+        expect(readFileSync(join(clientDir, 'other.ts'), 'utf8')).not.toContain('fimoStrapiFetch');
+    });
+    it('warns when no bare fetch is found', () => {
+        dir = mkdtempSync(join(tmpdir(), 'wire-strapi-none-'));
+        const clientDir = join(dir, 'client');
+        mkdirSync(clientDir, { recursive: true });
+        writeFileSync(join(clientDir, 'base.ts'), 'export const x = 1;\n');
+        const result = wireStrapiClient(dir, clientDir, schemas);
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('No bare fetch()');
+    });
+});

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

@@ -0,0 +1,17 @@
+import type { CmsCollectionSchema } from '../types.js';
+/**
+ * Machine-wiring for the native `fimo/strapi` read adapter. From the scaffolded
+ * schemas it derives the Strapi-path → Fimo-type map (+ the singletons) and
+ * emits a tiny repo module that instantiates the Fimo-backed fetch. The
+ * migration then swaps the CMS client's `fetch` for `fimoStrapiFetch` — after
+ * which the whole site reads scaffolded content from Fimo, deterministically.
+ */
+export interface StrapiWiring {
+    /** Strapi REST path segment (pluralName) → Fimo type name. */
+    types: Record<string, string>;
+    /** Fimo type names that are single types. */
+    singletons: string[];
+}
+export declare function strapiWiring(schemas: CmsCollectionSchema[]): StrapiWiring;
+/** Emit the repo module (`fimo-strapi.ts`) that wires the fetch to Fimo. */
+export declare function renderFimoStrapiModule(schemas: CmsCollectionSchema[]): string;

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

@@ -0,0 +1,36 @@
+export function strapiWiring(schemas) {
+    const types = {};
+    const singletons = [];
+    for (const schema of schemas) {
+        const pluralName = schema.sourcePath.replace(/^\/+/, '');
+        if (pluralName) {
+            types[pluralName] = schema.name;
+        }
+        if (schema.isSingleton) {
+            singletons.push(schema.name);
+        }
+    }
+    return { types, singletons };
+}
+/** Emit the repo module (`fimo-strapi.ts`) that wires the fetch to Fimo. */
+export function renderFimoStrapiModule(schemas) {
+    const { types, singletons } = strapiWiring(schemas);
+    const typeEntries = Object.entries(types)
+        .map(([pluralName, typeName]) => `  '${pluralName}': '${typeName}',`)
+        .join('\n');
+    return `// AUTO-GENERATED by \`fimo migrate --scaffold-cms\`. Serves this site's Strapi
+// content reads from Fimo (scaffolded example content) through fimo/strapi.
+// The migration points the CMS client's fetch at \`fimoStrapiFetch\`; reads for
+// scaffolded types resolve from Fimo, everything else falls through to Strapi.
+import { createFimoStrapiFetch } from 'fimo/strapi';
+
+// Strapi REST path (pluralName) -> Fimo type name.
+const TYPES: Record<string, string> = {
+${typeEntries}
+};
+
+const SINGLETONS = [${singletons.map((name) => `'${name}'`).join(', ')}];
+
+export const fimoStrapiFetch = createFimoStrapiFetch({ types: TYPES, singletons: SINGLETONS });
+`;
+}

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

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

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

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { renderFimoStrapiModule, strapiWiring } from './wiring.js';
+const schema = (name, sourcePath, isSingleton = false) => ({
+    name,
+    label: name,
+    isSingleton,
+    localized: false,
+    fields: {},
+    sourceUid: `api::${name.toLowerCase()}.${name.toLowerCase()}`,
+    sourcePath,
+});
+describe('strapiWiring', () => {
+    it('maps pluralName paths to Fimo types and lists singletons', () => {
+        const wiring = strapiWiring([schema('BlogPost', '/blog-posts'), schema('Global', '/globals', true)]);
+        expect(wiring.types).toEqual({ 'blog-posts': 'BlogPost', globals: 'Global' });
+        expect(wiring.singletons).toEqual(['Global']);
+    });
+});
+describe('renderFimoStrapiModule', () => {
+    it('emits a module importing fimo/strapi with the type map + singletons', () => {
+        const src = renderFimoStrapiModule([schema('BlogPost', '/blog-posts'), schema('Global', '/globals', true)]);
+        expect(src).toContain("import { createFimoStrapiFetch } from 'fimo/strapi';");
+        expect(src).toContain("'blog-posts': 'BlogPost',");
+        expect(src).toContain("const SINGLETONS = ['Global'];");
+        expect(src).toContain('export const fimoStrapiFetch = createFimoStrapiFetch({ types: TYPES, singletons: SINGLETONS });');
+    });
+});