fimo 0.7.0 → 0.8.0-staging.1

package/dist/scripts/sync-schemas.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 /**
  * Sync schema files — ensure all `.json` schemas have corresponding `.ts`
  * hook files generated from the hooks template.
@@ -10,8 +10,17 @@ import { dirname, join, resolve } from 'node:path';
  */
 import { pascalCase } from 'change-case';
 import { Eta } from 'eta';
+import { z } from 'zod';
 import { assetPath } from './utils/assets.js';
 const SCHEMAS_REL = 'src/schemas';
+const MINIMUM_THIN_CONTENT_CLIENT_RUNTIME_VERSION = '0.7.0';
+const CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND = 'npm install fimo@latest';
+const SCHEMA_DEFINITION_SCHEMA = z.object({
+    uid: z.string().min(1),
+    isSingleton: z.boolean().optional(),
+    i18n: z.object({ enabled: z.boolean().optional() }).optional(),
+    fields: z.record(z.string(), z.unknown()).optional(),
+});
 function getSchemaFiles(schemasDir) {
     if (!existsSync(schemasDir)) {
         return [];
@@ -20,13 +29,113 @@ function getSchemaFiles(schemasDir) {
         .filter((f) => f.endsWith('.json'))
         .map((f) => join(schemasDir, f));
 }
-function readSchema(path) {
+function getGeneratedFiles(schemasDir) {
+    if (!existsSync(schemasDir)) {
+        return [];
+    }
+    return readdirSync(schemasDir)
+        .filter((f) => f.endsWith('.ts') && f !== 'index.ts')
+        .map((f) => join(schemasDir, f));
+}
+function parseVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(version);
+    if (!match) {
+        return null;
+    }
+    return {
+        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] !== undefined,
+    };
+}
+function isVersionAtLeast(version, minimum) {
+    const parsed = parseVersion(version);
+    const parsedMinimum = parseVersion(minimum);
+    if (!parsed || !parsedMinimum) {
+        return false;
+    }
+    for (let index = 0; index < parsed.parts.length; index++) {
+        if (parsed.parts[index] !== parsedMinimum.parts[index]) {
+            return parsed.parts[index] > parsedMinimum.parts[index];
+        }
+    }
+    return !parsed.prerelease || parsedMinimum.prerelease;
+}
+function resolveProjectRuntime(cwd) {
+    const packagePath = join(cwd, 'node_modules', 'fimo', 'package.json');
+    if (!existsSync(packagePath)) {
+        throw new Error(`Cannot generate schema clients because the project-local fimo package could not be resolved from ${cwd}. ` +
+            `Run \`${CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND}\` in the project, then run \`npx fimo@latest validate\` again. ` +
+            'No generated files were changed.');
+    }
+    let version;
     try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
+        version = JSON.parse(readFileSync(packagePath, 'utf-8')).version;
     }
     catch {
-        return null;
+        version = null;
+    }
+    if (typeof version !== 'string' || !parseVersion(version)) {
+        throw new Error(`Cannot generate schema clients with project-local fimo@${typeof version === 'string' ? version : 'unknown'}. ` +
+            `Run \`${CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND}\` in the project, then run \`npx fimo@latest validate\` again. ` +
+            'No generated files were changed.');
+    }
+    return { packageRoot: dirname(packagePath), version };
+}
+function templatePath(runtime, fileName) {
+    if (runtime && !isVersionAtLeast(runtime.version, MINIMUM_THIN_CONTENT_CLIENT_RUNTIME_VERSION)) {
+        return join(runtime.packageRoot, 'assets', 'content-templates', fileName);
+    }
+    return assetPath('content-templates', fileName);
+}
+function loadSchemas(schemaFiles) {
+    const errors = [];
+    const schemas = [];
+    const outputOwners = new Map();
+    for (const path of schemaFiles) {
+        const fileUid = basename(path, '.json');
+        const pascal = pascalCase(fileUid);
+        const existingOwner = outputOwners.get(pascal);
+        if (existingOwner && existingOwner !== fileUid) {
+            errors.push(`${basename(path)} and ${existingOwner}.json both generate ${pascal}.ts. Rename one schema to keep generated module names unique.`);
+        }
+        else {
+            outputOwners.set(pascal, fileUid);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch (error) {
+            errors.push(`${basename(path)} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            errors.push(`${basename(path)} must contain a JSON object.`);
+            continue;
+        }
+        const candidate = parsed;
+        if (typeof candidate.uid !== 'string' || candidate.uid.length === 0) {
+            errors.push(`${basename(path)} is missing \"uid\". Set it to \"${fileUid}\".`);
+            continue;
+        }
+        if (candidate.uid !== fileUid) {
+            errors.push(`${basename(path)} declares uid \"${candidate.uid}\". It must match the file name \"${fileUid}\".`);
+            continue;
+        }
+        const validation = SCHEMA_DEFINITION_SCHEMA.safeParse(candidate);
+        if (!validation.success) {
+            const details = validation.error.issues
+                .map((issue) => `${issue.path.join('.') || 'schema'}: ${issue.message}`)
+                .join('; ');
+            errors.push(`${basename(path)} has an invalid schema shape: ${details}`);
+            continue;
+        }
+        schemas.push({ pascal, schema: validation.data });
+    }
+    if (errors.length > 0) {
+        throw new Error(`Cannot generate schema clients:\n- ${errors.join('\n- ')}\nNo generated files were changed.`);
     }
+    return schemas;
 }
 function normalizeFields(fields) {
     return Object.fromEntries(Object.entries(fields).map(([key, value]) => {
@@ -99,87 +208,64 @@ export function syncSchemas(options = {}) {
         }
     };
     const schemasDir = resolve(cwd, SCHEMAS_REL);
+    const schemaFiles = getSchemaFiles(schemasDir);
+    const schemas = loadSchemas(schemaFiles);
+    const generatedFilesOnDisk = getGeneratedFiles(schemasDir);
+    const runtime = schemas.length > 0 || generatedFilesOnDisk.length > 0 ? resolveProjectRuntime(cwd) : null;
     const templates = [
         {
             suffix: '.types.ts',
-            path: assetPath('content-templates', 'types-template.eta'),
+            path: templatePath(runtime, 'types-template.eta'),
         },
         {
             suffix: '.ts',
-            path: assetPath('content-templates', 'hooks-template.eta'),
+            path: templatePath(runtime, 'hooks-template.eta'),
         },
     ].map((template) => ({
         ...template,
         source: readFileSync(template.path, 'utf-8'),
     }));
     const eta = new Eta({ views: undefined, useWith: true, varName: 'it', autoEscape: false });
-    const schemaFiles = getSchemaFiles(schemasDir);
-    const schemasByPath = new Map(schemaFiles.flatMap((schemaPath) => {
-        const schema = readSchema(schemaPath);
-        return schema ? [[schemaPath, schema]] : [];
-    }));
-    const localizedByUid = new Map([...schemasByPath.values()].map((schema) => [schema.uid, schema.i18n?.enabled !== false]));
+    const localizedByUid = new Map(schemas.map(({ schema }) => [schema.uid, schema.i18n?.enabled !== false]));
     const expectedTsFiles = new Set();
+    const generatedFiles = new Map();
     let created = 0;
     let updated = 0;
     let deleted = 0;
-    for (const jsonPath of schemaFiles) {
-        const uid = jsonPath
-            .split('/')
-            .pop()
-            .replace(/\.json$/, '');
-        const pascal = pascalCase(uid);
-        const schema = schemasByPath.get(jsonPath);
-        if (!schema) {
-            console.error(`Failed to parse schema: ${jsonPath}`);
-            continue;
-        }
-        if (!schema.uid) {
-            schema.uid = uid;
-        }
+    for (const { pascal, schema } of schemas) {
         const model = schemaToModel(schema, localizedByUid);
         for (const template of templates) {
             const tsPath = join(schemasDir, `${pascal}${template.suffix}`);
             expectedTsFiles.add(tsPath);
+            generatedFiles.set(tsPath, eta.renderString(template.source, { model }));
+        }
+    }
+    for (const [tsPath, content] of generatedFiles) {
+        const dir = dirname(tsPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        if (!existsSync(tsPath)) {
+            writeFileSync(tsPath, content, 'utf-8');
+            created++;
+            log(`Created: ${tsPath}`);
+            continue;
+        }
+        if (readFileSync(tsPath, 'utf-8') !== content) {
+            writeFileSync(tsPath, content, 'utf-8');
+            updated++;
+            log(`Updated: ${tsPath}`);
+        }
+    }
+    for (const tsFile of generatedFilesOnDisk) {
+        if (!expectedTsFiles.has(tsFile)) {
             try {
-                const content = eta.renderString(template.source, {
-                    model,
-                });
-                const dir = dirname(tsPath);
-                if (!existsSync(dir)) {
-                    mkdirSync(dir, { recursive: true });
-                }
-                if (!existsSync(tsPath)) {
-                    writeFileSync(tsPath, content, 'utf-8');
-                    created++;
-                    log(`Created: ${tsPath}`);
-                    continue;
-                }
-                if (readFileSync(tsPath, 'utf-8') !== content) {
-                    writeFileSync(tsPath, content, 'utf-8');
-                    updated++;
-                    log(`Updated: ${tsPath}`);
-                }
+                unlinkSync(tsFile);
+                deleted++;
+                log(`Deleted orphaned: ${tsFile}`);
             }
             catch (error) {
-                console.error(`Failed to generate ${tsPath}:`, error);
-            }
-        }
-    }
-    if (existsSync(schemasDir)) {
-        const allTsFiles = readdirSync(schemasDir)
-            .filter((f) => f.endsWith('.ts') && f !== 'index.ts')
-            .map((f) => join(schemasDir, f));
-        for (const tsFile of allTsFiles) {
-            if (!expectedTsFiles.has(tsFile)) {
-                try {
-                    unlinkSync(tsFile);
-                    deleted++;
-                    log(`Deleted orphaned: ${tsFile}`);
-                }
-                catch (error) {
-                    console.error(`Failed to delete orphaned ${tsFile}:`, error);
-                }
+                console.error(`Failed to delete orphaned ${tsFile}:`, error);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.7.0",
+  "version": "0.8.0-staging.1",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"

package/release.json

@@ -1,5 +1,5 @@
 {
   "source": "npm",
-  "apiUrl": "https://api.fimo.ai",
-  "webUrl": "https://fimo.ai"
+  "apiUrl": "https://api.staging.fimo.team",
+  "webUrl": "https://staging.fimo.team"
 }

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