fimo 0.7.0-experimental.4 → 0.7.0-experimental.6

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

package/dist/scripts/cms/types.d.ts

@@ -38,6 +38,10 @@ export interface CmsCollectionSchema {
     /** The CMS marks this type as localized → seed per configured locale. */
     readonly localized: boolean;
     readonly fields: Record<string, FimoFieldDef>;
+    /** Pre-computed example values for fields the generic generator can't shape
+     *  from the Fimo field type alone (dynamic zones must be arrays, components
+     *  objects). Keyed by field name; the generator uses these verbatim. */
+    readonly examples?: Record<string, unknown>;
     /** Source CMS uid for provenance (e.g. `api::blog-post.blog-post`). */
     readonly sourceUid: string;
     /** Source REST path (e.g. `/blog-posts`) — informational for later rewire. */
@@ -51,6 +55,9 @@ export interface CmsDetection {
     readonly host: string;
     /** Absolute path to the CMS app root when co-located (monorepo), else null. */
     readonly appDir: string | null;
+    /** Absolute path to the frontend's CMS client module dir (where the fetch
+     *  lives), for machine-wiring the reads to Fimo. Null if not found. */
+    readonly clientDir: string | null;
     /** Repo-relative files/signals that evidenced the detection. */
     readonly evidence: string[];
     /** Locales configured in the CMS, when discoverable (may be empty). */
@@ -73,4 +80,15 @@ export interface CmsConnector {
      * `fetchEntries` from.
      */
     renderListSource?(schemas: CmsCollectionSchema[], serverImport: string): string | null;
+    /**
+     * Machine-wire the frontend's CMS reads to Fimo: emit the adapter module and
+     * swap the client's fetch, so the whole site reads scaffolded content from
+     * Fimo. Deterministic — no agent step.
+     */
+    wireClient?(cwd: string, schemas: CmsCollectionSchema[]): CmsWireResult;
+}
+export interface CmsWireResult {
+    changes: string[];
+    warnings: string[];
+    wired: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.7.0-experimental.4",
+  "version": "0.7.0-experimental.6",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -52,6 +52,10 @@
       "types": "./dist/runtime/templates.d.ts",
       "import": "./dist/runtime/templates.js"
     },
+    "./strapi": {
+      "types": "./dist/runtime/strapi/index.d.ts",
+      "import": "./dist/runtime/strapi/index.js"
+    },
     "./remix": {
       "types": "./dist/runtime/remix/index.d.ts",
       "import": "./dist/runtime/remix/index.js"

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.7.0-experimental.4",
+    "fimo": "0.7.0-experimental.6",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",