@postxl/cli 1.7.1 → 1.8.1

package/dist/generate-types.command.js

@@ -40,6 +40,7 @@ const generator_1 = require("@postxl/generator");
 const generators_1 = require("@postxl/generators");
 const schema_1 = require("@postxl/schema");
 const utils_1 = require("@postxl/utils");
+const load_project_schema_1 = require("./helpers/load-project-schema");
 const log_schema_error_1 = require("./helpers/log-schema-error");
 function register(program) {
     program
@@ -56,12 +57,14 @@ This reads the schema and runs only the types generator. The generated type file
         if (!path.isAbsolute(inputPath)) {
             inputPath = path.join(process.cwd(), inputPath);
         }
-        // Resolve schema path
+        // Resolve schema path / project path
         let schemaPath = '';
+        let projectPath;
         try {
             const stats = await fs.stat(inputPath);
             if (stats.isDirectory()) {
                 schemaPath = path.join(inputPath, 'postxl-schema.json');
+                projectPath = inputPath;
             }
             else if (stats.isFile()) {
                 schemaPath = inputPath;
@@ -79,22 +82,29 @@ This reads the schema and runs only the types generator. The generated type file
         catch {
             program.error(`Cannot find schema file at ${schemaPath}`);
         }
-        // Parse and validate schema
-        let jsonSchema;
-        try {
-            const content = await fs.readFile(schemaPath, 'utf-8');
-            jsonSchema = JSON.parse(content);
-        }
-        catch (error) {
-            program.error(`Error reading or parsing JSON from ${schemaPath}: ${error instanceof Error ? error.message : String(error)}`);
+        let schema;
+        if (projectPath !== undefined) {
+            // Directory input: use the shared loader (picks up schema/*.model.json etc.)
+            schema = await (0, load_project_schema_1.loadProjectSchema)({ program, projectPath });
         }
-        const result = schema_1.zProjectSchema.safeParse(jsonSchema);
-        if (!result.success) {
-            console.log('\nError parsing schema:\n');
-            (0, log_schema_error_1.logSchemaValidationError)(result.error);
-            process.exit(1);
+        else {
+            // Single schema file input: parse as-is, no split-file discovery.
+            let jsonSchema;
+            try {
+                const content = await fs.readFile(schemaPath, 'utf-8');
+                jsonSchema = JSON.parse(content);
+            }
+            catch (error) {
+                program.error(`Error reading or parsing JSON from ${schemaPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const result = schema_1.zProjectSchema.safeParse(jsonSchema);
+            if (!result.success) {
+                console.log('\nError parsing schema:\n');
+                (0, log_schema_error_1.logSchemaValidationError)(result.error);
+                process.exit(1);
+            }
+            schema = result.data;
         }
-        const schema = result.data;
         // Resolve output path
         let outputPath = options.output;
         if (!path.isAbsolute(outputPath)) {

package/dist/generate.command.js

@@ -43,9 +43,8 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const generator_1 = require("@postxl/generator");
-const schema_1 = require("@postxl/schema");
 const utils_1 = require("@postxl/utils");
-const log_schema_error_1 = require("./helpers/log-schema-error");
+const load_project_schema_1 = require("./helpers/load-project-schema");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 function register(program) {
     program
@@ -60,6 +59,7 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
         .option('-e, --ejected', 'lists ejected files')
         .option('-f, --force', 'overwrites ejected files')
         .option('-i, --ignore-errors', 'ignores errors during generation')
+        .option('-m, --model <names...>', 'regenerate only for the given models (accepts multiple, e.g. -m Country City)')
         .option('-n, --no-fix', 'does not attempt to fix linting errors')
         .option('-p, --pattern <glob>', 'filters files by glob pattern (e.g., "**/*.ts" or "backend/libs/**")')
         .option('-q, --quiet', 'does not print errors')
@@ -78,7 +78,7 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
         }
         const envConfig = dotenv_1.default.config({ path: path.join(projectPath, '.env') });
         const localGenerators = await getLocalGenerators({ program, projectPath });
-        const schema = await getSchema({ program, projectPath });
+        const schema = await (0, load_project_schema_1.loadProjectSchema)({ program, projectPath });
         targetPath = await resolveTargetPath({
             projectPath,
             targetPath,
@@ -94,10 +94,15 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
         if (options.pattern) {
             console.log(`Filtering files by pattern: ${options.pattern}`);
         }
+        const targetModelNames = resolveTargetModelNames({ program, schema, names: options.model });
+        if (targetModelNames) {
+            console.log(`Restricting generation to models: ${[...targetModelNames].join(', ')}`);
+        }
         const manager = new generator_1.GeneratorManager(localGenerators);
         const baseContext = (0, generator_1.prepareBaseContext)(schema, {
             ...options,
             ...(options.pattern ? { filePattern: options.pattern } : {}),
+            ...(targetModelNames ? { targetModelNames } : {}),
         });
         const generatedContext = await manager.generate(baseContext);
         return (new generator_1.Generator(generatedContext)
@@ -126,6 +131,7 @@ This reads the schema from ${(0, utils_1.yellow)('schema.json')} and runs the ge
                 lockFilePath: path.join(targetPath, 'postxl-lock.json'),
                 diskFilePath: targetPath,
                 force: options.force ?? false,
+                ...(targetModelNames ? { selectiveGeneration: true } : {}),
             });
             (0, generator_1.logSyncResult)(result, {
                 showEjectedStats: options.ejected ?? false,
@@ -223,24 +229,6 @@ async function getLocalGenerators(params) {
     }
     return localGenerate();
 }
-async function getSchema(params) {
-    const { projectPath } = params;
-    const schemaPath = path.join(projectPath, 'postxl-schema.json');
-    try {
-        await fs.access(schemaPath);
-    }
-    catch {
-        params.program.error(`Cannot find file "postxl-schema.json" found at ${schemaPath}`);
-    }
-    const jsonSchema = JSON.parse((await fs.readFile(schemaPath)).toString());
-    const schema = schema_1.zProjectSchema.safeParse(jsonSchema);
-    if (!schema.success) {
-        console.log('\nError parsing postxl-schema.json:\n');
-        (0, log_schema_error_1.logSchemaValidationError)(schema.error);
-        process.exit(1);
-    }
-    return schema.data;
-}
 /**
  * Checks if the current projectPath is within the PostXL monorepo workspace
  * by verifying if '../../packages/cli' exists relative to the project path.
@@ -255,6 +243,19 @@ async function isInPostxlWorkspace(projectPath) {
         return false;
     }
 }
+function resolveTargetModelNames(params) {
+    const { program, schema, names } = params;
+    if (!names || names.length === 0) {
+        return undefined;
+    }
+    const available = [...schema.models.keys()];
+    const availableSet = new Set(available);
+    const unknown = names.filter((n) => !availableSet.has(n));
+    if (unknown.length > 0) {
+        program.error(`Model${unknown.length > 1 ? 's' : ''} ${unknown.map((n) => `"${n}"`).join(', ')} ${unknown.length > 1 ? 'are' : 'is'} not defined in this schema. Available models: ${available.join(', ')}`);
+    }
+    return new Set(names);
+}
 async function resolveTargetPath({ projectPath, targetPath, envTargetPath, schemaSlug, projectType, }) {
     let resolved = targetPath ?? envTargetPath;
     if (!resolved) {

package/dist/helpers/load-project-schema.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { ProjectSchema } from '@postxl/schema';
+/**
+ * Loads `postxl-schema.json` from the given project path, merges in any
+ * per-model / per-enum files under `schema/`, and validates the result
+ * against `zProjectSchema`.
+ *
+ * On validation error, logs the formatted Zod error and exits the process —
+ * preserves the behavior of the previous in-command schema loader.
+ */
+export declare function loadProjectSchema(params: {
+    projectPath: string;
+    program: Command;
+}): Promise<ProjectSchema>;

package/dist/helpers/load-project-schema.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProjectSchema = loadProjectSchema;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const schema_1 = require("@postxl/schema");
+const load_split_schema_files_1 = require("./load-split-schema-files");
+const log_schema_error_1 = require("./log-schema-error");
+/**
+ * Loads `postxl-schema.json` from the given project path, merges in any
+ * per-model / per-enum files under `schema/`, and validates the result
+ * against `zProjectSchema`.
+ *
+ * On validation error, logs the formatted Zod error and exits the process —
+ * preserves the behavior of the previous in-command schema loader.
+ */
+async function loadProjectSchema(params) {
+    const { projectPath, program } = params;
+    const schemaPath = path.join(projectPath, 'postxl-schema.json');
+    try {
+        await fs.access(schemaPath);
+    }
+    catch {
+        program.error(`Cannot find file "postxl-schema.json" at ${schemaPath}`);
+    }
+    let rawJson;
+    try {
+        const content = await fs.readFile(schemaPath, 'utf-8');
+        rawJson = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return program.error(`Error reading or parsing JSON from ${schemaPath}: ${message}`);
+    }
+    const modelFilesGlob = asStringArray(rawJson.modelFiles);
+    const enumFilesGlob = asStringArray(rawJson.enumFiles);
+    const split = await (0, load_split_schema_files_1.loadSplitSchemaFiles)({
+        projectPath,
+        ...(modelFilesGlob ? { modelFilesGlob } : {}),
+        ...(enumFilesGlob ? { enumFilesGlob } : {}),
+    });
+    const mergedInput = {
+        ...rawJson,
+        models: (0, schema_1.mergeSplitSchemaEntries)({
+            inline: rawJson.models,
+            fromFiles: toDefinitionMap(split.models),
+            kind: 'model',
+            fromFilesPaths: toPathMap(split.models),
+        }),
+        enums: (0, schema_1.mergeSplitSchemaEntries)({
+            inline: rawJson.enums,
+            fromFiles: toDefinitionMap(split.enums),
+            kind: 'enum',
+            fromFilesPaths: toPathMap(split.enums),
+        }),
+    };
+    const result = schema_1.zProjectSchema.safeParse(mergedInput);
+    if (!result.success) {
+        console.log('\nError parsing postxl-schema.json:\n');
+        (0, log_schema_error_1.logSchemaValidationError)(result.error);
+        process.exit(1);
+    }
+    return result.data;
+}
+function toDefinitionMap(entries) {
+    const out = {};
+    for (const [name, { definition }] of Object.entries(entries)) {
+        out[name] = definition;
+    }
+    return out;
+}
+function toPathMap(entries) {
+    const out = {};
+    for (const [name, { filePath }] of Object.entries(entries)) {
+        out[name] = filePath;
+    }
+    return out;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.every((item) => typeof item === 'string') ? value : undefined;
+}

package/dist/helpers/load-split-schema-files.d.ts

@@ -0,0 +1,19 @@
+export type LoadedEntry = {
+    definition: unknown;
+    filePath: string;
+};
+/**
+ * Globs the project directory for per-model / per-enum JSON files and returns
+ * their parsed contents keyed by name (derived from the filename basename).
+ *
+ * Returns empty maps when no `schema/` directory exists or nothing matches —
+ * existing single-file schemas are unaffected.
+ */
+export declare function loadSplitSchemaFiles(params: {
+    projectPath: string;
+    modelFilesGlob?: string[];
+    enumFilesGlob?: string[];
+}): Promise<{
+    models: Record<string, LoadedEntry>;
+    enums: Record<string, LoadedEntry>;
+}>;

package/dist/helpers/load-split-schema-files.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSplitSchemaFiles = loadSplitSchemaFiles;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const DEFAULT_MODEL_GLOBS = ['schema/*.model.json'];
+const DEFAULT_ENUM_GLOBS = ['schema/*.enum.json'];
+const MODEL_SUFFIX = '.model.json';
+const ENUM_SUFFIX = '.enum.json';
+const FILE_BASENAME_REGEX = /^[a-z][A-Za-z0-9_]*$/;
+/**
+ * Globs the project directory for per-model / per-enum JSON files and returns
+ * their parsed contents keyed by name (derived from the filename basename).
+ *
+ * Returns empty maps when no `schema/` directory exists or nothing matches —
+ * existing single-file schemas are unaffected.
+ */
+async function loadSplitSchemaFiles(params) {
+    const { projectPath } = params;
+    const modelGlobs = params.modelFilesGlob ?? DEFAULT_MODEL_GLOBS;
+    const enumGlobs = params.enumFilesGlob ?? DEFAULT_ENUM_GLOBS;
+    const [models, enums] = await Promise.all([
+        loadEntries(projectPath, modelGlobs, MODEL_SUFFIX, 'model'),
+        loadEntries(projectPath, enumGlobs, ENUM_SUFFIX, 'enum'),
+    ]);
+    return { models, enums };
+}
+async function loadEntries(projectPath, globs, suffix, kind) {
+    const matched = new Set();
+    for (const pattern of globs) {
+        const iterator = fs.glob(pattern, { cwd: projectPath });
+        for await (const relPath of iterator) {
+            matched.add(relPath);
+        }
+    }
+    const sorted = [...matched].sort((a, b) => a.localeCompare(b));
+    const result = {};
+    for (const relPath of sorted) {
+        const basename = path.basename(relPath);
+        if (!basename.endsWith(suffix)) {
+            continue;
+        }
+        const fileBasename = basename.slice(0, -suffix.length);
+        if (!FILE_BASENAME_REGEX.test(fileBasename)) {
+            throw new Error(`Invalid ${kind} filename "${basename}" in "${relPath}". ${kind === 'model' ? 'Model' : 'Enum'} files must use camelCase basenames matching [a-z][A-Za-z0-9_]* (e.g. ${kind === 'model' ? 'country.model.json' : 'role.enum.json'}).`);
+        }
+        const name = fileBasename.charAt(0).toUpperCase() + fileBasename.slice(1);
+        const absPath = path.join(projectPath, relPath);
+        let raw;
+        try {
+            raw = await fs.readFile(absPath, 'utf-8');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to read ${kind} file "${relPath}": ${message}`);
+        }
+        let definition;
+        try {
+            definition = JSON.parse(raw);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse JSON in ${kind} file "${relPath}": ${message}`);
+        }
+        if (definition && typeof definition === 'object' && !Array.isArray(definition)) {
+            const obj = definition;
+            if ('name' in obj) {
+                if (typeof obj.name === 'string' && obj.name !== name) {
+                    throw new Error(`${kind === 'model' ? 'Model' : 'Enum'} file "${relPath}" has "name": "${obj.name}" but the filename implies "${name}". Remove the "name" field or rename the file.`);
+                }
+                const { name: _stripped, ...rest } = obj;
+                definition = rest;
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(result, name)) {
+            throw new Error(`Duplicate ${kind} name "${name}" — matched by more than one file (last seen: "${relPath}"). Rename one of the files.`);
+        }
+        result[name] = { definition, filePath: relPath };
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/cli",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "Command-line interface for PostXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -44,9 +44,9 @@
     "commander": "14.0.3",
     "dotenv": "17.3.1",
     "zod-validation-error": "5.0.0",
-    "@postxl/generator": "^1.4.1",
-    "@postxl/generators": "^1.30.1",
-    "@postxl/schema": "^1.10.1",
+    "@postxl/generator": "^1.6.0",
+    "@postxl/generators": "^2.0.0",
+    "@postxl/schema": "^2.0.0",
     "@postxl/utils": "^1.4.0"
   },
   "devDependencies": {},