fimo 0.7.0-experimental.3 → 0.7.0-experimental.5

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,23 @@
+import { detectStrapi } from './detect.js';
+import { renderStrapiListSource } from './list-source.js';
+import { readStrapiSchemas } from './schema-map.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,
+            },
+    };
+}

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 {};

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/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()');
+    });
+});