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

package/dist/runtime/strapi/client.d.ts

@@ -0,0 +1,26 @@
+import { type FimoServerOptions } from '../wrapped/server.js';
+export interface FimoStrapiFetchOptions extends FimoServerOptions {
+    /** Strapi REST path segment (pluralName) → Fimo type name. */
+    types: Record<string, string>;
+    /** Fimo type names that are single types (served as `{data:{}}`, not a list). */
+    singletons?: string[];
+    /** Path prefix before the content segment (Strapi default `/api`). */
+    apiPrefix?: string;
+}
+export interface ParsedStrapiUrl {
+    pluralName: string;
+    documentId?: string;
+    locale?: string;
+    pageSize?: number;
+    where?: Record<string, unknown>;
+}
+/**
+ * Parse a Strapi REST URL into the parts the Fimo read needs. Best-effort:
+ * pagination + locale + top-level `$eq` filters (enough for list, detail-by-slug,
+ * and singleton reads); richer `qs` filters are ignored (fake content tolerates
+ * an unfiltered set).
+ */
+export declare function parseStrapiUrl(rawUrl: string, apiPrefix?: string): ParsedStrapiUrl | null;
+/** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
+export declare function createFimoStrapiFetch(options: FimoStrapiFetchOptions, realFetch?: typeof fetch): typeof fetch;
+//# sourceMappingURL=client.d.ts.map

package/dist/runtime/strapi/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/runtime/strapi/client.ts"],"names":[],"mappings":"AASA,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG5E,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAUD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,SAAS,GAAG,eAAe,GAAG,IAAI,CAkCzF;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,OAAO,KAAK,CAiCpH"}

package/dist/runtime/strapi/client.js

@@ -0,0 +1,88 @@
+// Native `fimo/strapi` read adapter — the generic interception point. Every
+// Strapi client (hand-rolled or `@strapi/client`) ultimately does a single
+// `fetch(<strapiRestUrl>)`; this returns a `fetch`-compatible function that
+// serves that request from Fimo (via `fetchEntries` + the reshape) when the URL
+// maps to a scaffolded content type, and transparently falls through to the
+// real fetch (the live CMS) otherwise. Intercepting at the fetch boundary is
+// what makes "any Strapi project" work — the client's method surface is
+// irrelevant.
+import { fetchEntries } from '../wrapped/server.js';
+import { fimoEntriesToStrapiList, fimoEntryToStrapiSingle } from './reshape.js';
+function positiveInt(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+/**
+ * Parse a Strapi REST URL into the parts the Fimo read needs. Best-effort:
+ * pagination + locale + top-level `$eq` filters (enough for list, detail-by-slug,
+ * and singleton reads); richer `qs` filters are ignored (fake content tolerates
+ * an unfiltered set).
+ */
+export function parseStrapiUrl(rawUrl, apiPrefix = '/api') {
+    let url;
+    try {
+        url = new URL(rawUrl, 'http://fimo.local');
+    }
+    catch {
+        return null;
+    }
+    const marker = `${apiPrefix}/`;
+    const at = url.pathname.indexOf(marker);
+    if (at === -1) {
+        return null;
+    }
+    const segments = url.pathname
+        .slice(at + marker.length)
+        .split('/')
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return null;
+    }
+    const q = url.searchParams;
+    const where = {};
+    for (const [key, value] of q.entries()) {
+        const eq = key.match(/^filters\[([^\][]+)\]\[\$eq\]$/);
+        if (eq) {
+            where[eq[1]] = value;
+        }
+    }
+    return {
+        pluralName: segments[0],
+        documentId: segments[1],
+        locale: q.get('locale') ?? undefined,
+        pageSize: positiveInt(q.get('pagination[pageSize]') ?? q.get('pagination[limit]')),
+        where: Object.keys(where).length > 0 ? where : undefined,
+    };
+}
+/** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
+export function createFimoStrapiFetch(options, realFetch = fetch) {
+    const singletons = new Set(options.singletons ?? []);
+    const read = { apiUrl: options.apiUrl, rootDir: options.rootDir };
+    return (async (input, init) => {
+        const rawUrl = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        const parsed = parseStrapiUrl(rawUrl ?? '', options.apiPrefix);
+        const typeName = parsed ? options.types[parsed.pluralName] : undefined;
+        if (!parsed || !typeName) {
+            return realFetch(input, init); // not a mapped content read → real CMS
+        }
+        const entries = await fetchEntries(typeName, {
+            ...read,
+            ...(parsed.where ? { where: parsed.where } : {}),
+            ...(parsed.pageSize ? { limit: parsed.pageSize } : {}),
+        });
+        if (entries.length === 0) {
+            return realFetch(input, init); // nothing scaffolded → fall back to the CMS
+        }
+        const single = Boolean(parsed.documentId) || singletons.has(typeName);
+        const payload = single
+            ? fimoEntryToStrapiSingle(parsed.documentId ? (entries.find((e) => e.id === parsed.documentId) ?? entries[0]) : entries[0])
+            : fimoEntriesToStrapiList(entries, { pageSize: parsed.pageSize, total: entries.length });
+        return new Response(JSON.stringify(payload), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        });
+    });
+}

package/dist/runtime/strapi/client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.test.d.ts.map

package/dist/runtime/strapi/client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../../../src/runtime/strapi/client.test.ts"],"names":[],"mappings":""}

package/dist/runtime/strapi/client.test.js

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const fetchEntriesMock = vi.fn();
+vi.mock('../wrapped/server.js', () => ({
+    fetchEntries: (...args) => fetchEntriesMock(...args),
+}));
+import { createFimoStrapiFetch, parseStrapiUrl } from './client.js';
+describe('parseStrapiUrl', () => {
+    it('parses type, pagination, locale and $eq filters', () => {
+        const parsed = parseStrapiUrl('https://cms.example/api/blog-posts?locale=en&pagination[pageSize]=5&filters[slug][$eq]=hello');
+        expect(parsed).toMatchObject({ pluralName: 'blog-posts', locale: 'en', pageSize: 5, where: { slug: 'hello' } });
+    });
+    it('parses a documentId path', () => {
+        expect(parseStrapiUrl('https://cms.example/api/pages/abc123')).toMatchObject({
+            pluralName: 'pages',
+            documentId: 'abc123',
+        });
+    });
+    it('returns null for non-/api paths', () => {
+        expect(parseStrapiUrl('https://cms.example/health')).toBeNull();
+    });
+});
+describe('createFimoStrapiFetch', () => {
+    const realFetch = vi.fn(async () => new Response('REAL', { status: 200 }));
+    beforeEach(() => {
+        fetchEntriesMock.mockReset();
+        realFetch.mockClear();
+    });
+    it('serves a mapped collection from Fimo as a Strapi list envelope', async () => {
+        fetchEntriesMock.mockResolvedValue([
+            { id: '1', data: { title: 'A' } },
+            { id: '2', data: { title: 'B' } },
+        ]);
+        const fimoFetch = createFimoStrapiFetch({ types: { 'blog-posts': 'BlogPost' } }, realFetch);
+        const body = await (await fimoFetch('https://cms.example/api/blog-posts?pagination[pageSize]=10')).json();
+        expect(body.data).toHaveLength(2);
+        expect(body.data[0]).toMatchObject({ id: '1', documentId: '1', title: 'A' });
+        expect(body.meta.pagination.total).toBe(2);
+        expect(realFetch).not.toHaveBeenCalled();
+        expect(fetchEntriesMock).toHaveBeenCalledWith('BlogPost', expect.objectContaining({ limit: 10 }));
+    });
+    it('serves a singleton as a single envelope, not a list', async () => {
+        fetchEntriesMock.mockResolvedValue([{ id: 'g', data: { siteName: 'X' } }]);
+        const fimoFetch = createFimoStrapiFetch({ types: { global: 'Global' }, singletons: ['Global'] }, realFetch);
+        const body = await (await fimoFetch('https://cms.example/api/global')).json();
+        expect(Array.isArray(body.data)).toBe(false);
+        expect(body.data).toMatchObject({ id: 'g', siteName: 'X' });
+    });
+    it('passes a slug filter through to fetchEntries', async () => {
+        fetchEntriesMock.mockResolvedValue([{ id: '1', data: { slug: 'hello' } }]);
+        const fimoFetch = createFimoStrapiFetch({ types: { 'blog-posts': 'BlogPost' } }, realFetch);
+        await fimoFetch('https://cms.example/api/blog-posts?filters[slug][$eq]=hello');
+        expect(fetchEntriesMock).toHaveBeenCalledWith('BlogPost', expect.objectContaining({ where: { slug: 'hello' } }));
+    });
+    it('falls through to the real fetch for an unmapped path', async () => {
+        const fimoFetch = createFimoStrapiFetch({ types: { 'blog-posts': 'BlogPost' } }, realFetch);
+        expect(await (await fimoFetch('https://cms.example/api/users?filters[slug][$eq]=x')).text()).toBe('REAL');
+        expect(realFetch).toHaveBeenCalled();
+    });
+    it('falls through when Fimo has nothing scaffolded for the type', async () => {
+        fetchEntriesMock.mockResolvedValue([]);
+        const fimoFetch = createFimoStrapiFetch({ types: { 'blog-posts': 'BlogPost' } }, realFetch);
+        expect(await (await fimoFetch('https://cms.example/api/blog-posts')).text()).toBe('REAL');
+    });
+});

package/dist/runtime/strapi/index.d.ts

@@ -0,0 +1,5 @@
+export { createFimoStrapiFetch, parseStrapiUrl } from './client.js';
+export type { FimoStrapiFetchOptions, ParsedStrapiUrl } from './client.js';
+export { fimoEntriesToStrapiList, fimoEntryToStrapiItem, fimoEntryToStrapiSingle } from './reshape.js';
+export type { StrapiListEnvelope, StrapiPagination, StrapiSingleEnvelope } from './reshape.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/strapi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/strapi/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACpE,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvG,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/runtime/strapi/index.js

@@ -0,0 +1,6 @@
+// `fimo/strapi` — native read adapter that serves a wrapped Strapi frontend's
+// content from Fimo. Drop `createFimoStrapiFetch(...)` in at the CMS client's
+// single `fetch` and every read (list, detail, singleton) is served from Fimo,
+// falling through to the live CMS for anything not scaffolded.
+export { createFimoStrapiFetch, parseStrapiUrl } from './client.js';
+export { fimoEntriesToStrapiList, fimoEntryToStrapiItem, fimoEntryToStrapiSingle } from './reshape.js';

package/dist/runtime/strapi/reshape.d.ts

@@ -0,0 +1,28 @@
+import type { FimoEntry } from '../wrapped/server.js';
+export interface StrapiPagination {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+}
+export interface StrapiListEnvelope {
+    data: Record<string, unknown>[];
+    meta: {
+        pagination: StrapiPagination;
+    };
+}
+export interface StrapiSingleEnvelope {
+    data: Record<string, unknown> | null;
+    meta: Record<string, unknown>;
+}
+/** One Fimo entry → one Strapi-v5 item (flat fields, `id` + `documentId`). */
+export declare function fimoEntryToStrapiItem(entry: FimoEntry): Record<string, unknown>;
+/** Fimo entries → a Strapi-v5 collection envelope (`{ data, meta.pagination }`). */
+export declare function fimoEntriesToStrapiList(entries: FimoEntry[], options?: {
+    page?: number;
+    pageSize?: number;
+    total?: number;
+}): StrapiListEnvelope;
+/** Fimo entry → a Strapi-v5 single/singleton envelope (`{ data, meta }`). */
+export declare function fimoEntryToStrapiSingle(entry: FimoEntry | undefined): StrapiSingleEnvelope;
+//# sourceMappingURL=reshape.d.ts.map

package/dist/runtime/strapi/reshape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reshape.d.ts","sourceRoot":"","sources":["../../../src/runtime/strapi/reshape.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,IAAI,EAAE;QAAE,UAAU,EAAE,gBAAgB,CAAA;KAAE,CAAC;CACxC;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAqDD,8EAA8E;AAC9E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM/E;AAED,oFAAoF;AACpF,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAAE,EACpB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACjE,kBAAkB,CAepB;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,oBAAoB,CAE1F"}

package/dist/runtime/strapi/reshape.js

@@ -0,0 +1,79 @@
+// Native `fimo/strapi` read adapter — the generic reshape from Fimo entries
+// (as `fetchEntries` returns them) into the Strapi-v5 response shape a wrapped
+// Strapi frontend's components read. Value-inspection based, so it is generic:
+// no content-type or field names are hardcoded. Relation POPULATION (turning a
+// reference handle into a nested object) is resolved one level up in the client
+// — this module reshapes a single entry's own field values.
+/** ProseMirror/TipTap doc → plain text (Strapi richtext is a string; string
+ *  consumers like read-time estimates must never receive an object). */
+function docToText(node) {
+    if (!node || typeof node !== 'object') {
+        return '';
+    }
+    const record = node;
+    if (typeof record.text === 'string') {
+        return record.text;
+    }
+    if (Array.isArray(record.content)) {
+        return record.content.map(docToText).join(' ').trim();
+    }
+    return '';
+}
+function isRichTextDoc(value) {
+    return Boolean(value) && typeof value === 'object' && value.type === 'doc';
+}
+/** A Fimo media value (seeded/loaded as `{ url, alt, width, height, … }`). */
+function isMedia(value) {
+    return (Boolean(value) &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.url === 'string');
+}
+function reshapeMedia(value) {
+    return {
+        url: value.url,
+        alternativeText: value.alt ?? value.alternativeText ?? null,
+        ...(typeof value.width === 'number' ? { width: value.width } : {}),
+        ...(typeof value.height === 'number' ? { height: value.height } : {}),
+        ...(typeof value.name === 'string' ? { name: value.name } : {}),
+        ...(typeof value.mime === 'string' ? { mime: value.mime } : {}),
+    };
+}
+function reshapeValue(value) {
+    if (isRichTextDoc(value)) {
+        return docToText(value);
+    }
+    if (isMedia(value)) {
+        return reshapeMedia(value);
+    }
+    return value; // scalars, arrays, reference handles pass through
+}
+/** One Fimo entry → one Strapi-v5 item (flat fields, `id` + `documentId`). */
+export function fimoEntryToStrapiItem(entry) {
+    const item = { id: entry.id, documentId: entry.id };
+    for (const [field, value] of Object.entries(entry.data)) {
+        item[field] = reshapeValue(value);
+    }
+    return item;
+}
+/** Fimo entries → a Strapi-v5 collection envelope (`{ data, meta.pagination }`). */
+export function fimoEntriesToStrapiList(entries, options = {}) {
+    const data = entries.map(fimoEntryToStrapiItem);
+    const total = options.total ?? data.length;
+    const pageSize = options.pageSize ?? (data.length || 1);
+    return {
+        data,
+        meta: {
+            pagination: {
+                page: options.page ?? 1,
+                pageSize,
+                pageCount: pageSize > 0 ? Math.max(1, Math.ceil(total / pageSize)) : 1,
+                total,
+            },
+        },
+    };
+}
+/** Fimo entry → a Strapi-v5 single/singleton envelope (`{ data, meta }`). */
+export function fimoEntryToStrapiSingle(entry) {
+    return { data: entry ? fimoEntryToStrapiItem(entry) : null, meta: {} };
+}

package/dist/runtime/strapi/reshape.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reshape.test.d.ts.map

package/dist/runtime/strapi/reshape.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reshape.test.d.ts","sourceRoot":"","sources":["../../../src/runtime/strapi/reshape.test.ts"],"names":[],"mappings":""}

package/dist/runtime/strapi/reshape.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { fimoEntriesToStrapiList, fimoEntryToStrapiItem, fimoEntryToStrapiSingle } from './reshape.js';
+const entry = {
+    id: 'abc',
+    data: {
+        title: 'Hello',
+        readTime: 3,
+        content: { type: 'doc', content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Body text' }] }] },
+        cover: { source: 'local', url: '/img/x.png', alt: 'Alt', width: 800, height: 600 },
+        category: 'post-category-example-1',
+    },
+};
+describe('reshape', () => {
+    it('flattens an entry to a Strapi-v5 item (id + documentId, richtext→text, media→strapi shape)', () => {
+        const item = fimoEntryToStrapiItem(entry);
+        expect(item.id).toBe('abc');
+        expect(item.documentId).toBe('abc');
+        expect(item.title).toBe('Hello');
+        expect(item.readTime).toBe(3);
+        expect(item.content).toBe('Body text');
+        expect(item.cover).toEqual({ url: '/img/x.png', alternativeText: 'Alt', width: 800, height: 600 });
+        expect(item.category).toBe('post-category-example-1'); // reference handle passes through
+    });
+    it('wraps a list in a Strapi envelope with correct pagination', () => {
+        const env = fimoEntriesToStrapiList([entry, entry], { total: 5, pageSize: 2 });
+        expect(env.data).toHaveLength(2);
+        expect(env.meta.pagination).toEqual({ page: 1, pageSize: 2, pageCount: 3, total: 5 });
+    });
+    it('wraps a single/singleton entry, or null when absent', () => {
+        expect(fimoEntryToStrapiSingle(entry).data).toMatchObject({ id: 'abc', title: 'Hello' });
+        expect(fimoEntryToStrapiSingle(undefined).data).toBeNull();
+    });
+});

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

@@ -18,6 +18,21 @@ function richTextDoc(text) {
         content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
     };
 }
+/** A self-contained placeholder image (inline SVG data-URI) in the media
+ *  envelope shape the wrap runtime already understands — no external host, no
+ *  CSP surprises, so cards/heroes render instead of showing broken images. */
+function placeholderMedia(label) {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630"><rect width="100%" height="100%" fill="#e5e7eb"/><text x="50%" y="50%" font-family="sans-serif" font-size="44" fill="#9ca3af" text-anchor="middle" dominant-baseline="middle">${label}</text></svg>`;
+    return {
+        source: 'local',
+        url: `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`,
+        alt: `${label} placeholder`,
+        width: 1200,
+        height: 630,
+        mime: 'image/svg+xml',
+        name: 'placeholder.svg',
+    };
+}
 /** Deterministic ISO date (no wall clock): 2024-01-01 + (n-1) days. */
 function exampleDate(n) {
     return new Date(Date.UTC(2024, 0, n)).toISOString().slice(0, 10);
@@ -42,6 +57,12 @@ export function generateExampleSeed(schema, options = {}) {
             row.slug = `${kebabCase(schema.name)}-example-${i}`;
         }
         for (const [field, def] of Object.entries(schema.fields)) {
+            // A connector-supplied example (dynamic zones, components) wins over the
+            // type-driven default — critical for dynamic zones, which must be arrays.
+            if (schema.examples && field in schema.examples) {
+                row[field] = schema.examples[field];
+                continue;
+            }
             switch (def.type) {
                 case 'string':
                     row[field] = `${humanize(field)} example ${i}${localeSuffix}`;
@@ -62,7 +83,7 @@ export function generateExampleSeed(schema, options = {}) {
                     row[field] = {};
                     break;
                 case 'media':
-                    // Omit: a placeholder URL would render as a broken image.
+                    row[field] = placeholderMedia(humanize(field));
                     break;
                 case 'reference': {
                     const value = exampleReferenceSlug(def);

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

@@ -34,9 +34,10 @@ describe('generateExampleSeed', () => {
         expect(second.publishedOn).toBe('2024-01-02');
         expect(first.meta).toEqual({});
     });
-    it('omits media fields (a fake URL would render broken)', () => {
+    it('seeds a self-contained placeholder for media fields', () => {
         const seed = generateExampleSeed(blogPost, { count: 1 });
-        expect('cover' in seed.rows[0]).toBe(false);
+        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 });
@@ -54,4 +55,12 @@ describe('generateExampleSeed', () => {
         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.js

@@ -179,6 +179,7 @@ export function detectStrapi(frontendDir) {
         cms: 'Strapi',
         host: 'Strapi',
         appDir,
+        clientDir: libModule,
         evidence,
         locales: [],
     };

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

@@ -1,6 +1,7 @@
 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);
@@ -11,5 +12,12 @@ export function strapiConnector(frontendDir) {
         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/schema-map.js

@@ -67,10 +67,20 @@ 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 {
@@ -79,6 +89,7 @@ function mapSchema(raw, uidToName) {
         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}`,
     };

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

@@ -75,6 +75,10 @@ describe('readStrapiSchemas', () => {
         });
         // 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);

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