fimo 0.6.0 → 0.7.0-experimental.2

package/dist/scripts/generated-types.test.js

@@ -1,212 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterAll, describe, expect, it } from 'vitest';
-import { syncSchemas } from './sync-schemas.js';
-/**
- * The generated-types gate: generate hooks + types from fixture schemas that
- * cover every field type and reference shape, add usage code written the way
- * an agent writes site code, and run the real TypeScript compiler over the
- * output. A template regression fails this test — never a user project.
- */
-const here = dirname(fileURLToPath(import.meta.url));
-const requireFromHere = createRequire(import.meta.url);
-const runtimeBarrel = resolve(here, '../runtime/index.ts');
-const tscBin = requireFromHere.resolve('typescript/bin/tsc');
-const fixtureRoot = mkdtempSync(join(tmpdir(), 'fimo-generated-types-'));
-const schemasDir = join(fixtureRoot, 'src', 'schemas');
-const SCHEMAS = {
-    Author: {
-        uid: 'Author',
-        name: 'Author',
-        i18n: { enabled: true },
-        fields: {
-            name: { type: 'string', required: true },
-            bio: { type: 'richtext' },
-            avatar: { type: 'media' },
-            active: { type: 'boolean' },
-            bornAt: { type: 'date' },
-            meta: { type: 'json' },
-            rating: { type: 'number' },
-        },
-    },
-    Video: {
-        uid: 'Video',
-        name: 'Video',
-        i18n: { enabled: false },
-        fields: {
-            title: { type: 'string', required: true },
-            clips: { type: 'media', multiple: true },
-        },
-    },
-    Post: {
-        uid: 'Post',
-        name: 'Post',
-        i18n: { enabled: true },
-        fields: {
-            title: { type: 'string', required: true },
-            author: { type: 'reference', target: 'Author' },
-            contributors: { type: 'reference', target: 'Author', many: true },
-            related: { type: 'reference', target: 'Post', many: true },
-        },
-    },
-    Page: {
-        uid: 'Page',
-        name: 'Page',
-        i18n: { enabled: true },
-        fields: {
-            title: { type: 'string' },
-            featured: { type: 'reference', targets: ['Post', 'Video'], many: true },
-            hero: { type: 'reference', targets: ['Author', 'Video'] },
-        },
-    },
-    SiteSettings: {
-        uid: 'SiteSettings',
-        name: 'SiteSettings',
-        isSingleton: true,
-        i18n: { enabled: false },
-        fields: {
-            siteName: { type: 'string', required: true },
-        },
-    },
-};
-const USAGE = `// Agent-style usage of the generated types — compile-time contract.
-import type { PageResult, PageWhere } from "./Page";
-import Post from "./Post";
-import type { PostResult } from "./Post";
-
-export function renderFeatured(page: PageResult<undefined, readonly ["featured", "hero"]>): string[] {
-  const out: string[] = [];
-  for (const item of page.featured) {
-    switch (item.$type) {
-      case "Post":
-        out.push(\`post \${String(item.title)} by \${item.author?.documentId ?? "nobody"}\`);
-        break;
-      case "Video":
-        out.push(\`video \${String(item.title)} with \${item.clips.length} clip(s)\`);
-        break;
-      default: {
-        const exhaustive: never = item;
-        return exhaustive;
-      }
-    }
-  }
-  const hero = page.hero;
-  if (hero && hero.$type === "Author") {
-    out.push(\`hero \${String(hero.name)}\`);
-  }
-  return out;
-}
-
-export function renderPost(post: PostResult<undefined, readonly ["author", "contributors"]>): string {
-  const contributors = post.contributors.map((author) => String(author.name)).join(", ");
-  return \`\${String(post.title)} — \${post.author ? String(post.author.name) : "anonymous"} (\${contributors})\`;
-}
-
-export function whereContract(): PageWhere {
-  return {
-    title: "Home",
-    // @ts-expect-error filtering on polymorphic reference fields is not supported
-    featured: "some-document-id",
-  };
-}
-
-export function paginatedPostContract(): void {
-  const legacy = Post.useGet({ limit: 3 });
-  const page = Post.useList({
-    fields: ["title", "author"] as const,
-    populate: ["author"] as const,
-    limit: 12,
-    offset: 24,
-  });
-  const infinite = Post.useInfiniteList({
-    fields: ["title", "author"] as const,
-    populate: ["author"] as const,
-    limit: 12,
-  });
-
-  const legacyPosts: PostResult[] = legacy.data ?? [];
-  const pagePosts: PostResult<readonly ["title", "author"], readonly ["author"]>[] = page.data?.items ?? [];
-  const total: number = page.data?.pageInfo.total ?? 0;
-  const nextOffset: number | null = page.data?.pageInfo.nextOffset ?? null;
-  const infinitePosts: PostResult<readonly ["title", "author"], readonly ["author"]>[] = infinite.items;
-  const firstAuthorName: string = infinitePosts[0]?.author ? String(infinitePosts[0].author.name) : "";
-  const hasMore: boolean = infinite.hasMore;
-  const isLoadingMore: boolean = infinite.isLoadingMore;
-
-  void infinite.loadMore();
-  // @ts-expect-error infinite lists own offset progression
-  Post.useInfiniteList({ offset: 12 });
-
-  void [legacyPosts, pagePosts, total, nextOffset, infinitePosts, firstAuthorName, hasMore, isLoadingMore];
-}
-
-export async function paginatedPostFetchContract(): Promise<void> {
-  const page = await Post.list({ limit: 12, offset: 24 });
-  const legacyPosts: PostResult[] = await Post.get({ limit: 3 });
-  const pagePosts: PostResult[] = page.items;
-  const hasMore: boolean = page.pageInfo.hasMore;
-
-  void [legacyPosts, pagePosts, hasMore];
-}
-`;
-const SHIMS = `declare module "virtual:fimo-config" {
-  const config: Record<string, unknown>;
-  export default config;
-}
-declare module "virtual:translations" {
-  export const dictionaries: Record<string, Record<string, string>>;
-  export const defaultLocale: string;
-  export const signature: string;
-  export const updatedAt: string;
-}
-declare module "*.css" {}
-`;
-afterAll(() => {
-    rmSync(fixtureRoot, { recursive: true, force: true });
-});
-describe('generated types gate', () => {
-    it('generates hooks + types for every field shape and the output typechecks with agent-style usage', () => {
-        mkdirSync(schemasDir, { recursive: true });
-        // Real react-query types: the fixture resolves them like a real project.
-        const reactQueryDir = dirname(requireFromHere.resolve('@tanstack/react-query/package.json'));
-        mkdirSync(join(fixtureRoot, 'node_modules', '@tanstack'), { recursive: true });
-        symlinkSync(reactQueryDir, join(fixtureRoot, 'node_modules', '@tanstack', 'react-query'));
-        for (const [uid, schema] of Object.entries(SCHEMAS)) {
-            writeFileSync(join(schemasDir, `${uid}.json`), JSON.stringify(schema, null, 2));
-        }
-        const result = syncSchemas({ cwd: fixtureRoot, verbose: false });
-        expect(result.created).toBeGreaterThanOrEqual(Object.keys(SCHEMAS).length * 2);
-        writeFileSync(join(schemasDir, 'usage.ts'), USAGE);
-        writeFileSync(join(fixtureRoot, 'shims.d.ts'), SHIMS);
-        writeFileSync(join(fixtureRoot, 'tsconfig.json'), JSON.stringify({
-            compilerOptions: {
-                strict: true,
-                noEmit: true,
-                skipLibCheck: true,
-                target: 'ES2022',
-                module: 'ESNext',
-                moduleResolution: 'bundler',
-                jsx: 'react-jsx',
-                allowImportingTsExtensions: true,
-                baseUrl: '.',
-                paths: {
-                    'fimo/ui': [runtimeBarrel],
-                },
-            },
-            include: ['src/**/*.ts', 'shims.d.ts'],
-        }, null, 2));
-        let output = '';
-        try {
-            output = execFileSync(process.execPath, [tscBin, '-p', fixtureRoot], { encoding: 'utf8' });
-        }
-        catch (error) {
-            const failure = error;
-            throw new Error(`generated types failed to typecheck:\n${failure.stdout ?? ''}${failure.stderr ?? ''}`);
-        }
-        expect(output.trim()).toBe('');
-    }, 120_000);
-});

package/dist/scripts/lint-translation-keys.test.d.ts

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

package/dist/scripts/lint-translation-keys.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { lintTranslationKeys } from './lint-translation-keys';
-describe('lintTranslationKeys', () => {
-    it('allows literal DB-owned label keys', () => {
-        const errors = lintTranslationKeys('src/pages/Index.tsx', "const title = t('hero.title');");
-        expect(errors).toEqual([]);
-    });
-    it('rejects inline fallback values', () => {
-        const errors = lintTranslationKeys('src/pages/Index.tsx', "const title = t('hero.title', 'Welcome');");
-        expect(errors).toEqual([expect.objectContaining({ rule: 'labels/no-inline-default' })]);
-    });
-    it('rejects dynamic keys', () => {
-        const errors = lintTranslationKeys('src/pages/Index.tsx', 'const title = t(heroKey);');
-        expect(errors).toEqual([expect.objectContaining({ rule: 'translation-keys' })]);
-    });
-});

package/dist/scripts/sync-schemas.test.d.ts

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

package/dist/scripts/sync-schemas.test.js

@@ -1,124 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { syncSchemas } from './sync-schemas.js';
-let scratch;
-beforeEach(() => {
-    scratch = mkdtempSync(join(tmpdir(), 'fimo-sync-schemas-'));
-    mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
-});
-afterEach(() => {
-    rmSync(scratch, { recursive: true, force: true });
-});
-function writeSchema(name, schema) {
-    writeFileSync(join(scratch, 'src/schemas', `${name}.json`), JSON.stringify(schema, null, 2));
-}
-describe('syncSchemas', () => {
-    it('generates raw references plus typed populated helpers', () => {
-        writeSchema('Author', {
-            uid: 'Author',
-            name: 'Authors',
-            fields: {
-                name: { type: 'string' },
-            },
-        });
-        writeSchema('Post', {
-            uid: 'Post',
-            name: 'Posts',
-            fields: {
-                title: { type: 'string' },
-                author: { type: 'reference', target: 'Author' },
-                contributors: { type: 'reference', target: 'Author', many: true },
-                relatedPosts: { type: 'reference', target: 'Post', many: true },
-            },
-        });
-        expect(syncSchemas({ cwd: scratch, verbose: false })).toEqual({ created: 4, updated: 0, deleted: 0 });
-        const post = readFileSync(join(scratch, 'src/schemas/Post.ts'), 'utf-8');
-        const postTypes = readFileSync(join(scratch, 'src/schemas/Post.types.ts'), 'utf-8');
-        expect(post).toContain('import { wrapWithSource as wrapAuthorWithSource } from "./Author";');
-        expect(post).toContain('import type { Post, PostInput, PostPopulate, PostResult, PostFields, PostQuery } from "./Post.types";');
-        expect(post).toContain('from "./Post.types";');
-        expect(post).not.toContain('import type { Author } from "./Author";');
-        expect(post).not.toContain('export interface Post extends WithReferences<PostReferences>');
-        expect(post).not.toContain('type FimoReference');
-        expect(post).toContain('Promise<PostResult<undefined, TPopulate>>');
-        expect(post).toContain('TPopulate extends PostPopulate | undefined');
-        expect(post).toContain('wrapAuthorWithSource(value)');
-        expect(post).toContain('wrapWithSource(value)');
-        expect(post).toContain('export async function create(payload: PostInput): Promise<Post>');
-        expect(post).toContain('return wrapWithSource(data.data);');
-        expect(postTypes).toContain('import type { Author } from "./Author.types";');
-        expect(postTypes).toContain('export interface Post extends WithReferences<PostReferences>');
-        expect(postTypes).toContain('type FimoReference');
-        expect(postTypes).toContain('author: FimoReference | null;');
-        expect(postTypes).toContain('contributors: FimoReference[];');
-        expect(postTypes).toContain('relatedPosts: FimoReference[];');
-        expect(postTypes).toContain('export interface PostReferences');
-        expect(postTypes).toContain('export interface PostInput');
-        expect(postTypes).toContain('author?: FimoReference | null;');
-        expect(postTypes).toContain('author: Author | null;');
-        expect(postTypes).toContain('contributors: Author[];');
-        expect(postTypes).toContain('relatedPosts: Post[];');
-        expect(postTypes).toContain('export type PostResult<');
-        expect(postTypes).not.toContain('PostPopulated');
-    });
-    it('generates locale-free shared types and locale-sensitive populated target keys', () => {
-        writeSchema('Homepage', {
-            uid: 'Homepage',
-            name: 'Homepages',
-            fields: { title: { type: 'string' } },
-        });
-        writeSchema('Category', {
-            uid: 'Category',
-            name: 'Categories',
-            i18n: { enabled: false },
-            fields: { name: { type: 'string' } },
-        });
-        writeSchema('Settings', {
-            uid: 'Settings',
-            name: 'Settings',
-            i18n: { enabled: false },
-            fields: {
-                homepage: { type: 'reference', target: 'Homepage' },
-                category: { type: 'reference', target: 'Category' },
-            },
-        });
-        syncSchemas({ cwd: scratch, verbose: false });
-        const settings = readFileSync(join(scratch, 'src/schemas/Settings.ts'), 'utf-8');
-        const settingsTypes = readFileSync(join(scratch, 'src/schemas/Settings.types.ts'), 'utf-8');
-        const homepageTypes = readFileSync(join(scratch, 'src/schemas/Homepage.types.ts'), 'utf-8');
-        expect(settingsTypes).not.toContain('locale: string;');
-        expect(settingsTypes).not.toContain('locale?: string;');
-        expect(homepageTypes).toContain('locale: string;');
-        expect(settings).toContain('const LOCALIZED_CONTENT = false;');
-        expect(settings).toContain('const LOCALIZED_REFERENCE_FIELDS = new Set<string>(["homepage"]);');
-        expect(settings).not.toContain('    locale: entry.locale,');
-        expect(settings).toContain('readLocale(params, LOCALIZED_CONTENT, useQueryLocale(params.locale))');
-        expect(settings.match(/readLocale\(params, LOCALIZED_CONTENT, useQueryLocale\(params\.locale\)\)/g)?.length).toBe(4);
-        expect(settings.match(/readLocale\(options, false, useQueryLocale\(options\.locale\)\)/g)?.length).toBe(2);
-    });
-    it('generates singleton document APIs without collection mutations', () => {
-        writeSchema('Settings', {
-            uid: 'Settings',
-            name: 'Settings',
-            isSingleton: true,
-            i18n: { enabled: false },
-            fields: { siteName: { type: 'string', required: true } },
-        });
-        syncSchemas({ cwd: scratch, verbose: false });
-        const settings = readFileSync(join(scratch, 'src/schemas/Settings.ts'), 'utf-8');
-        const settingsTypes = readFileSync(join(scratch, 'src/schemas/Settings.types.ts'), 'utf-8');
-        expect(settings).toContain('fetch(`${base}${withReadOptions(`/documents/Settings`, options)}`');
-        expect(settings).toContain('export async function update(payload: Partial<SettingsInput>)');
-        expect(settings).toContain('export function useSuspenseGet');
-        expect(settings).not.toContain('export async function create(');
-        expect(settings).not.toContain('export async function remove(');
-        expect(settings).not.toContain('export function useCreate(');
-        expect(settings).not.toContain('export function useList(');
-        expect(settings).not.toContain('export function useInfiniteList(');
-        expect(settings).not.toContain('useInfiniteQuery');
-        expect(settingsTypes).toContain('siteName: string;');
-        expect(settingsTypes).not.toContain('documentId?: string;');
-    });
-});

package/dist/scripts/validate-route-metadata.test.d.ts

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

package/dist/scripts/validate-route-metadata.test.js

@@ -1,116 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { validateRouteMetadata } from './validate-route-metadata';
-describe('validateRouteMetadata i18n checks', () => {
-    let scratch = null;
-    afterEach(() => {
-        if (scratch) {
-            rmSync(scratch, { recursive: true, force: true });
-            scratch = null;
-        }
-    });
-    it('accepts fimoRoutes() with canonical routes and multi-locale path prefixes', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    home: { path: '/', label: 'Home' },
-                    pricing: { path: '/pricing', label: 'Pricing' },
-                },
-            },
-            routesSource: `import type { RouteConfig } from '@react-router/dev/routes';
-import { index, route } from '@react-router/dev/routes';
-import { fimoRoutes } from 'fimo/react-router/routes';
-
-const routes = [
-  index('./pages/Index.tsx', { id: 'home' }),
-  route('pricing', './pages/Pricing.tsx', { id: 'pricing' }),
-] satisfies RouteConfig;
-
-export default fimoRoutes(routes) satisfies RouteConfig;
-`,
-            files: ['src/pages/Index.tsx', 'src/pages/Pricing.tsx'],
-        });
-        expect(validateRouteMetadata({ cwd }).errors).toEqual([]);
-    });
-    it('rejects invalid locale config', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en--US',
-                    locales: ['es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    home: { path: '/', label: 'Home' },
-                },
-            },
-            routesSource: `import { index } from '@react-router/dev/routes';
-export default [index('./pages/Index.tsx')];
-`,
-            files: ['src/pages/Index.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('Invalid i18n.defaultLocale "en--US"');
-        expect(errors).toContain('i18n.locales must include i18n.defaultLocale');
-    });
-    it('rejects canonical routes that claim locale prefixes', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    spanish: { path: '/es', label: 'Spanish' },
-                },
-            },
-            routesSource: `import { route } from '@react-router/dev/routes';
-export default [route('es', './pages/Spanish.tsx')];
-`,
-            files: ['src/pages/Spanish.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('uses reserved locale prefix "es"');
-    });
-    it('warns as an error when top-level dynamic routes can capture locale URLs without fimoRoutes()', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    page: { path: '/:slug', label: 'Page', params: { slug: { schema: 'Page', queryField: 'slug' } } },
-                },
-            },
-            routesSource: `import { route } from '@react-router/dev/routes';
-export default [route(':slug', './pages/Page.tsx')];
-`,
-            files: ['src/pages/Page.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('top-level dynamic route');
-        expect(errors).toContain('fimoRoutes(routes)');
-    });
-    function writeProject(args) {
-        scratch = mkdtempSync(join(tmpdir(), 'fimo-route-metadata-'));
-        mkdirSync(join(scratch, 'src'), { recursive: true });
-        writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify(args.config, null, 2));
-        writeFileSync(join(scratch, 'src', 'routes.ts'), args.routesSource);
-        for (const file of args.files) {
-            mkdirSync(join(scratch, file, '..'), { recursive: true });
-            writeFileSync(join(scratch, file), 'export default function Page() { return null; }\n');
-        }
-        return scratch;
-    }
-});

package/dist/scripts/validate-schemas.test.d.ts

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