fimo 0.7.0-experimental.2 → 0.7.0-staging.1

package/scripts/migration-qa-gate.test.ts

@@ -0,0 +1,155 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.resolve(__dirname, '../assets/skills/fimo-migration/scripts/write-migration-report.mjs');
+
+interface GateResult {
+  status: number | null;
+  report: string;
+}
+
+let dir: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(path.join(tmpdir(), 'fimo-qa-gate-'));
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function runGate(manifest: unknown, opts: { withBuildArtifact?: boolean } = {}): GateResult {
+  mkdirSync(path.join(dir, '.fimo', 'migration'), { recursive: true });
+  writeFileSync(path.join(dir, '.fimo', 'migration', 'manifest.json'), JSON.stringify(manifest, null, 2));
+  if (opts.withBuildArtifact) {
+    mkdirSync(path.join(dir, 'dist', 'client'), { recursive: true });
+    writeFileSync(path.join(dir, 'dist', 'client', 'index.html'), '<html></html>');
+  }
+  const reportPath = path.join(dir, 'report.md');
+  const child = spawnSync(process.execPath, [SCRIPT, dir, '--no-update-manifest', '--output', reportPath], {
+    encoding: 'utf8',
+  });
+  return { status: child.status, report: readFileSync(reportPath, 'utf8') };
+}
+
+function statusLine(report: string): string {
+  const lines = report.split('\n');
+  const idx = lines.findIndex((line) => line.trim() === '## Status');
+  return lines[idx + 2]?.trim() ?? '';
+}
+
+function checkFailed(report: string, id: string): boolean {
+  return report.includes(`- [ ] `) && new RegExp(`- \\[ \\] .*\\(${id}\\)`).test(report);
+}
+
+describe('migration QA gate (write-migration-report.mjs)', () => {
+  it('fails generated-only entries even when seed JSON exists (no silent pass)', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [{ name: 'game', status: 'generated' }],
+      entries: [{ contentType: 'game', sourceCount: 11, generatedCount: 11, importedCount: 0 }],
+      media: [],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(statusLine(report)).toBe('draft-only');
+    expect(checkFailed(report, 'cms-counts')).toBe(true);
+    expect(checkFailed(report, 'schemas-pushed')).toBe(true);
+  });
+
+  it('fails referenced media that is only bundled locally under public/', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [],
+      entries: [],
+      media: [{ id: 'm1', referencedBy: ['/'], status: 'imported', targetUrl: '/assets/thepark/hero.webp' }],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(statusLine(report)).toBe('draft-only');
+    expect(checkFailed(report, 'media-covered')).toBe(true);
+    expect(report).toContain('Uploaded to Fimo: 0');
+    expect(report).toContain('Bundled locally (not uploaded): 1');
+  });
+
+  it('passes when entries are imported, schemas pushed, and media uploaded to Fimo', () => {
+    const { status, report } = runGate(
+      {
+        source: { mode: 'url-only', platform: 'wix' },
+        routes: [{ route: '/', status: 'verified' }],
+        contentTypes: [{ name: 'game', status: 'imported' }],
+        entries: [{ contentType: 'game', sourceCount: 3, generatedCount: 3, importedCount: 3, status: 'imported' }],
+        media: [
+          { id: 'm1', referencedBy: ['/'], targetAssetId: '11111111-1111-1111-1111-111111111111' },
+          {
+            id: 'm2',
+            referencedBy: ['/'],
+            targetUrl: 'https://assets.fimo.team/abc/hero.webp',
+            sourceUrl: 'https://static.wixstatic.com/hero.webp',
+          },
+        ],
+        forms: [],
+        unresolved: [],
+      },
+      { withBuildArtifact: true }
+    );
+    expect(status).toBe(0);
+    expect(statusLine(report)).toBe('complete');
+    expect(report).toContain('Uploaded to Fimo: 2');
+  });
+
+  it('rejects a target URL that merely echoes the source URL (nothing uploaded)', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [],
+      entries: [],
+      media: [
+        {
+          id: 'm1',
+          referencedBy: ['/'],
+          sourceUrl: 'https://static.wixstatic.com/hero.webp',
+          targetUrl: 'https://static.wixstatic.com/hero.webp',
+        },
+      ],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(checkFailed(report, 'media-covered')).toBe(true);
+  });
+
+  it('allows complete-with-unresolved when gaps are explicit, owner-visible unresolved items', () => {
+    const { status, report } = runGate(
+      {
+        source: { mode: 'url-only', platform: 'wix' },
+        routes: [{ route: '/', status: 'verified' }],
+        contentTypes: [{ name: 'game', status: 'unresolved' }],
+        entries: [{ contentType: 'game', sourceCount: 5, generatedCount: 5, importedCount: 0, status: 'unresolved' }],
+        media: [{ id: 'm1', referencedBy: ['/'], status: 'unresolved' }],
+        forms: [],
+        unresolved: [
+          {
+            severity: 'high',
+            area: 'cms',
+            message: 'Game entries need a source export before import.',
+            suggestedAction: 'Provide the Wix CMS export and re-run import.',
+          },
+        ],
+      },
+      { withBuildArtifact: true }
+    );
+    expect(status).toBe(0);
+    expect(statusLine(report)).toBe('complete-with-unresolved');
+  });
+});

package/scripts/publish-npm.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+// Publish the fimo CLI to npm on a channel.
+//
+// Usage:
+//   node scripts/publish-npm.mjs --channel experimental [--dry-run]
+//   node scripts/publish-npm.mjs --channel staging      [--dry-run]
+//   node scripts/publish-npm.mjs --channel latest       (CI only; --bootstrap for the first publish)
+//   node scripts/publish-npm.mjs --channel experimental --plan   (print the plan, touch nothing)
+//
+// What it does:
+//   1. Resolves the channel from the shared table (lib/channels.mjs).
+//   2. Guards: @latest refuses to publish outside CI unless --bootstrap.
+//   3. Builds in place (clean → build → build:bundle) with the workspace
+//      manifest UNTOUCHED, then `npm pack`s straight into a temp stage dir.
+//   4. Mutates ONLY the extracted stage copy: synthesized X.Y.Z-<tag>.<n>
+//      version, template fimo pin, channel release.json (allowlist-enforced —
+//      staging URLs for experimental/staging, prod for latest, never a tunnel).
+//   5. Runs `npm publish --tag <distTag>` from the stage (no --provenance —
+//      strapi/fimo is private).
+//   6. On real experimental publishes, records the exact version in repo-root
+//      .fimo/dev.json for local source-checkout deploys.
+//
+// The workspace is never mutated: no transient package.json version, no
+// release.json, no template rewrites — a crash or a long OTP prompt can't
+// leave the repo dirty (it used to sit mutated for the whole multi-minute
+// build + 2FA window).
+
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveChannel } from './lib/channels.mjs';
+import { writeDevReleaseState } from './lib/dev-release-state.mjs';
+import {
+  computePublishVersion,
+  nextVersionFromChangesets,
+  parsePublishedVersions,
+  pinTemplateFimo,
+  stripTemplateLockfile,
+  writeReleaseJson,
+} from './lib/release-core.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = resolve(HERE, '..');
+const PKG_PATH = resolve(CLI_ROOT, 'package.json');
+
+function parseArgs(argv) {
+  const args = { channel: null, dryRun: false, bootstrap: false, plan: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--channel') {
+      args.channel = argv[++i];
+    } else if (arg === '--dry-run') {
+      args.dryRun = true;
+    } else if (arg === '--bootstrap') {
+      args.bootstrap = true;
+    } else if (arg === '--plan') {
+      args.plan = true;
+    }
+  }
+  return args;
+}
+
+function run(cmd, args, cwd) {
+  console.log(`[publish-npm] $ ${cmd} ${args.join(' ')}`);
+  const result = spawnSync(cmd, args, { cwd, stdio: 'inherit' });
+  if (result.status !== 0) {
+    console.error(`[publish-npm] ${cmd} ${args[0]} failed (exit ${result.status}).`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+// All published versions of the package, or null when the registry can't be
+// reached (offline, first-ever publish) or the output shape is unrecognized —
+// callers fall back to the run-number/timestamp counter.
+function fetchPublishedVersions(name) {
+  const result = spawnSync('npm', ['view', name, 'versions', '--json'], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    return null;
+  }
+  return parsePublishedVersions(result.stdout);
+}
+
+const { channel: channelName, dryRun, bootstrap, plan } = parseArgs(process.argv.slice(2));
+
+if (!channelName) {
+  console.error('[publish-npm] missing --channel <experimental|staging|latest>');
+  process.exit(1);
+}
+
+const channel = resolveChannel(channelName);
+const isCI = !!process.env.CI;
+
+// Prod guard (D11): @latest never originates on a laptop.
+if (channel.distTag === 'latest' && !isCI && !bootstrap) {
+  console.error(
+    '[publish-npm] refusing to publish @latest outside CI.\n' +
+      '  Latest ships from CI on the production branch. For the first-ever publish, pass --bootstrap.'
+  );
+  process.exit(1);
+}
+
+const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf8'));
+// Prerelease channels base off the version the pending changesets will
+// produce at the next production release, so a staging build advertises the
+// version prod will actually ship.
+const baseVersion = channel.prerelease
+  ? nextVersionFromChangesets(pkg.version, resolve(CLI_ROOT, '../../.changeset'))
+  : pkg.version;
+const runId = process.env.GITHUB_RUN_NUMBER;
+let existingVersions;
+if (channel.prerelease) {
+  existingVersions = fetchPublishedVersions(pkg.name) ?? undefined;
+  if (!existingVersions) {
+    console.warn('[publish-npm] could not fetch published versions from npm — using run/timestamp counter.');
+  }
+}
+const publishVersion = computePublishVersion(baseVersion, channel, { runId, existingVersions });
+
+console.log(`[publish-npm] channel:   ${channelName}  (dist-tag: ${channel.distTag})`);
+console.log(
+  `[publish-npm] version:   ${publishVersion}${publishVersion !== baseVersion ? ` (from ${baseVersion})` : ''}`
+);
+console.log(`[publish-npm] apiUrl:    ${channel.apiUrl}`);
+console.log(`[publish-npm] webUrl:    ${channel.webUrl}`);
+
+if (plan) {
+  console.log('[publish-npm] --plan: nothing written, nothing published.');
+  process.exit(0);
+}
+
+const stageRoot = mkdtempSync(join(tmpdir(), 'fimo-publish-'));
+try {
+  // 1. Build in place — the build output doesn't depend on the version, so
+  //    the workspace manifest stays untouched.
+  run('pnpm', ['run', 'prepublishOnly'], CLI_ROOT);
+
+  // 2. Pack the workspace tarball (honors the `files` whitelist) directly
+  //    into the stage dir; --ignore-scripts because we just built.
+  run('npm', ['pack', '--ignore-scripts', '--pack-destination', stageRoot], CLI_ROOT);
+  const tarball = readdirSync(stageRoot).find((name) => name.endsWith('.tgz'));
+  if (!tarball) {
+    console.error(`[publish-npm] npm pack produced no tarball in ${stageRoot}.`);
+    process.exit(1);
+  }
+  run('tar', ['-xzf', join(stageRoot, tarball), '-C', stageRoot], stageRoot);
+  const stage = join(stageRoot, 'package');
+
+  // 3. Mutate ONLY the stage copy: synthesized version, template pin,
+  //    channel release.json.
+  const stagePkg = JSON.parse(readFileSync(join(stage, 'package.json'), 'utf8'));
+  writeFileSync(join(stage, 'package.json'), JSON.stringify({ ...stagePkg, version: publishVersion }, null, 2) + '\n');
+  pinTemplateFimo(stage, publishVersion);
+  stripTemplateLockfile(stage);
+  writeReleaseJson(stage, channel);
+
+  // 4. Publish from the stage. No --provenance: sigstore provenance requires
+  //    a PUBLIC source repo, and strapi/fimo is private (npm returns 422
+  //    otherwise). Trusted Publishing (OIDC auth) works regardless of repo
+  //    visibility — it's only the attestation that's public-only.
+  const publishArgs = ['publish', '--access', 'public', '--tag', channel.distTag, '--ignore-scripts'];
+  if (dryRun) {
+    publishArgs.push('--dry-run');
+  }
+  run('npm', publishArgs, stage);
+
+  if (!dryRun && channel.distTag === 'experimental') {
+    const devStatePath = writeDevReleaseState(CLI_ROOT, {
+      version: publishVersion,
+      channel: channel.distTag,
+    });
+    console.log(`[publish-npm] wrote ${devStatePath}`);
+  }
+} finally {
+  rmSync(stageRoot, { recursive: true, force: true });
+}
+
+console.log(`[publish-npm] done${dryRun ? ' (dry-run — nothing published)' : ''}.`);

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.2",
+    "fimo": "0.7.0-staging.1",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

package/templates/react-router/src/pages/Index.tsx

@@ -29,7 +29,7 @@ const Index = () => {
               <a href="https://fimo.ai" target="_blank" rel="noreferrer">
                 Fimo.ai
               </a>
-              <a href="https://fimo.ai/docs" target="_blank" rel="noreferrer">
+              <a href="https://docs.fimo.ai" target="_blank" rel="noreferrer">
                 Documentation
               </a>
               <a href="https://blog.fimo.ai" target="_blank" rel="noreferrer">

package/dist/runtime/content/client/createContentClient.d.ts

@@ -1,5 +0,0 @@
-import type { CollectionContentClient, ContentClientConfig } from './types.js';
-export declare function createContentClient<T extends {
-    id: string;
-}, TInput extends object>(config: ContentClientConfig): CollectionContentClient<T, TInput>;
-//# sourceMappingURL=createContentClient.d.ts.map

package/dist/runtime/content/client/createContentClient.js

@@ -1,300 +0,0 @@
-import { useInfiniteQuery, useMutation, useQuery, useQueryClient, useSuspenseQuery } from '@tanstack/react-query';
-import { parseCollectionResponse } from '../parseCollectionResponse.js';
-import { apiBase, buildReadPath, fimoHeaders, interpretSchema, readCollectionLocale, resolveClientHandle, splitWritePayload, validateReferences, withMutationLocale, wrapEntry, } from './internal.js';
-import { useQueryLocale } from './useQueryLocale.js';
-export function createContentClient(config) {
-    const references = config.references ?? {};
-    const info = interpretSchema(config.schema);
-    if (info.isSingleton) {
-        throw new Error(`Schema "${info.uid}" is a singleton — use createSingletonClient instead.`);
-    }
-    validateReferences(info, references);
-    const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
-    const self = { wrapWithSource, meta };
-    const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
-    function wrapWithSource(entry) {
-        return wrapEntry(info, entry, { alwaysIncludeLocale: true, resolve });
-    }
-    function readPath(url, options) {
-        return buildReadPath(url, readCollectionLocale(options), options.populate, options.localeFallbacks);
-    }
-    async function getById(id, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/${id}`, options)}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function getBySlug(slug, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/slug/${encodeURIComponent(slug)}`, options)}`, { headers: fimoHeaders() });
-        if (res.status === 404) {
-            return null;
-        }
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function getByField(fieldName, value, options = {}) {
-        const res = await fetch(`${apiBase()}${readPath(`/entries/${info.uid}/field/${encodeURIComponent(fieldName)}/${encodeURIComponent(value)}`, options)}`, { headers: fimoHeaders() });
-        if (res.status === 404) {
-            return null;
-        }
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    function toQueryString(params) {
-        const { where, sort, fields, populate, locale: requestedLocale, ...flat } = params;
-        const query = new URLSearchParams();
-        for (const [key, value] of Object.entries(flat)) {
-            if (value == null) {
-                continue;
-            }
-            query.set(key, String(value));
-        }
-        if (sort != null) {
-            query.set('sort', Array.isArray(sort) ? sort.join(',') : String(sort));
-        }
-        if (fields != null) {
-            query.set('fields', typeof fields === 'string' ? fields : fields.join(','));
-        }
-        if (populate != null) {
-            query.set('populate', typeof populate === 'string' ? populate : populate.join(','));
-        }
-        if (where && Object.keys(where).length > 0) {
-            query.set('where', JSON.stringify(where));
-        }
-        const locale = readCollectionLocale({ locale: requestedLocale });
-        if (locale) {
-            query.set('locale', locale);
-        }
-        return query.toString();
-    }
-    async function list(params = {}) {
-        const qs = toQueryString(params);
-        const res = await fetch(`${apiBase()}/entries/${info.uid}${qs ? '?' + qs : ''}`, {
-            headers: fimoHeaders(),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = parseCollectionResponse(await res.json());
-        const items = data.data.map(wrapWithSource);
-        const pageInfo = {
-            limit: data.meta.limit,
-            offset: data.meta.offset,
-            total: data.meta.total,
-            hasMore: data.meta.hasMore,
-            nextOffset: data.meta.hasMore ? data.meta.offset + data.meta.limit : null,
-        };
-        return { items, pageInfo };
-    }
-    async function get(params = {}) {
-        return (await list(params)).items;
-    }
-    async function create(payload) {
-        const res = await fetch(`${apiBase()}/entries/${info.uid}`, {
-            method: 'POST',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify(splitWritePayload(payload)),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function update(id, payload) {
-        const write = splitWritePayload(payload);
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }), undefined);
-        const res = await fetch(`${apiBase()}${url}`, {
-            method: 'PUT',
-            headers: fimoHeaders({ 'Content-Type': 'application/json' }),
-            body: JSON.stringify({ data: write.data }),
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        const data = await res.json();
-        return wrapWithSource(data.data);
-    }
-    async function remove(id, options = {}) {
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options), undefined);
-        const res = await fetch(`${apiBase()}${url}`, { method: 'DELETE', headers: fimoHeaders() });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-    }
-    const qk = {
-        root: [info.pascal],
-        byId: (id, options = {}) => [info.pascal, 'id', id, options.locale, options.populate],
-        bySlug: (slug, options = {}) => [info.pascal, 'slug', slug, options.locale, options.populate],
-        byField: (field, value, options = {}) => [info.pascal, field, value, options.locale, options.populate],
-        list: (params) => [info.pascal, params],
-        infiniteList: (params) => [info.pascal, 'infinite', params],
-    };
-    function useGetById(id, options = {}) {
-        const locale = useQueryLocale(options.locale);
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.byId(id, localizedOptions),
-            queryFn: () => getById(id, localizedOptions),
-        });
-    }
-    function useGetBySlug(slug, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.bySlug(slug, localizedOptions),
-            queryFn: () => getBySlug(slug, localizedOptions),
-            enabled: !!slug,
-        });
-    }
-    function useGetByField(fieldName, value, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useQuery({
-            queryKey: qk.byField(fieldName, value, localizedOptions),
-            queryFn: () => getByField(fieldName, value, localizedOptions),
-            enabled: !!value,
-        });
-    }
-    function useGet(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-            select: (page) => page.items,
-        });
-    }
-    function useList(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-        });
-    }
-    function useInfiniteList(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        const query = useInfiniteQuery({
-            queryKey: qk.infiniteList(localizedParams),
-            queryFn: ({ pageParam }) => list({ ...localizedParams, offset: pageParam }),
-            initialPageParam: 0,
-            getNextPageParam: (lastPage) => lastPage.pageInfo.nextOffset ?? undefined,
-        });
-        return {
-            ...query,
-            items: query.data?.pages.flatMap((page) => page.items) ?? [],
-            total: query.data?.pages[0]?.pageInfo.total ?? 0,
-            hasMore: query.hasNextPage,
-            loadMore: () => query.fetchNextPage(),
-            isLoadingMore: query.isFetchingNextPage,
-        };
-    }
-    function useSuspenseGetById(id, options = {}) {
-        const locale = useQueryLocale(options.locale);
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.byId(id, localizedOptions),
-            queryFn: () => getById(id, localizedOptions),
-        });
-    }
-    function useSuspenseGetBySlug(slug, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.bySlug(slug, localizedOptions),
-            queryFn: () => getBySlug(slug, localizedOptions),
-        });
-    }
-    function useSuspenseGetByField(fieldName, value, options = {}) {
-        const locale = readCollectionLocale(options, useQueryLocale(options.locale));
-        const localizedOptions = { ...options, locale };
-        return useSuspenseQuery({
-            queryKey: qk.byField(fieldName, value, localizedOptions),
-            queryFn: () => getByField(fieldName, value, localizedOptions),
-        });
-    }
-    function useSuspenseGet(params = {}) {
-        const locale = readCollectionLocale(params, useQueryLocale(params.locale));
-        const localizedParams = { ...params, locale };
-        return useSuspenseQuery({
-            queryKey: qk.list(localizedParams),
-            queryFn: () => list(localizedParams),
-            select: (page) => page.items,
-        });
-    }
-    function useCreate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (payload) => create(withMutationLocale(payload, activeLocale)),
-            onSuccess: () => qc.invalidateQueries({ queryKey: qk.root }),
-        });
-    }
-    function useUpdate() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: ({ id, ...patch }) => update(id, withMutationLocale(patch, activeLocale)),
-            onSuccess: (_data, vars) => {
-                qc.invalidateQueries({ queryKey: qk.root });
-                qc.invalidateQueries({ queryKey: qk.byId(vars.id, { locale: vars.locale ?? activeLocale }) });
-            },
-        });
-    }
-    function useRemove() {
-        const qc = useQueryClient();
-        const activeLocale = useQueryLocale();
-        return useMutation({
-            mutationFn: (value) => {
-                const { id, locale } = typeof value === 'string'
-                    ? { id: value, locale: activeLocale }
-                    : { ...value, locale: value.locale ?? activeLocale };
-                return remove(id, { locale });
-            },
-            onSuccess: (_data, value) => {
-                const { id, locale } = typeof value === 'string'
-                    ? { id: value, locale: activeLocale }
-                    : { ...value, locale: value.locale ?? activeLocale };
-                qc.invalidateQueries({ queryKey: qk.root });
-                qc.removeQueries({ queryKey: qk.byId(id, { locale }), exact: false });
-            },
-        });
-    }
-    return {
-        meta,
-        wrapWithSource,
-        getById,
-        getBySlug,
-        getByField,
-        list,
-        get,
-        create,
-        update,
-        remove,
-        useGetById,
-        useGetBySlug,
-        useGetByField,
-        useGet,
-        useList,
-        useInfiniteList,
-        useSuspenseGetById,
-        useSuspenseGetBySlug,
-        useSuspenseGetByField,
-        useSuspenseGet,
-        useCreate,
-        useUpdate,
-        useRemove,
-    };
-}

package/dist/runtime/content/client/createSingletonClient.d.ts

@@ -1,5 +0,0 @@
-import type { ContentClientConfig, SingletonContentClient } from './types.js';
-export declare function createSingletonClient<T extends {
-    id: string;
-}, TInput extends object>(config: ContentClientConfig): SingletonContentClient<T, TInput>;
-//# sourceMappingURL=createSingletonClient.d.ts.map