@postxl/cli 1.8.1 → 1.8.3

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

@@ -1,5 +1,17 @@
 import { Command } from 'commander';
 import { ProjectSchema } from '@postxl/schema';
+/**
+ * Loads `postxl-schema.json` from the given project path and merges in any
+ * per-model / per-enum files under `schema/`. Returns the unvalidated merged
+ * JSON object — callers run their own `safeParse` so they can format errors
+ * however they like.
+ *
+ * Errors during file IO / JSON parsing call `program.error`, which exits.
+ */
+export declare function loadAndMergeRawSchema(params: {
+    projectPath: string;
+    program: Command;
+}): Promise<Record<string, unknown>>;
 /**
  * Loads `postxl-schema.json` from the given project path, merges in any
  * per-model / per-enum files under `schema/`, and validates the result

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

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAndMergeRawSchema = loadAndMergeRawSchema;
 exports.loadProjectSchema = loadProjectSchema;
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
@@ -40,14 +41,14 @@ 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`.
+ * Loads `postxl-schema.json` from the given project path and merges in any
+ * per-model / per-enum files under `schema/`. Returns the unvalidated merged
+ * JSON object — callers run their own `safeParse` so they can format errors
+ * however they like.
  *
- * On validation error, logs the formatted Zod error and exits the process —
- * preserves the behavior of the previous in-command schema loader.
+ * Errors during file IO / JSON parsing call `program.error`, which exits.
  */
-async function loadProjectSchema(params) {
+async function loadAndMergeRawSchema(params) {
     const { projectPath, program } = params;
     const schemaPath = path.join(projectPath, 'postxl-schema.json');
     try {
@@ -72,7 +73,7 @@ async function loadProjectSchema(params) {
         ...(modelFilesGlob ? { modelFilesGlob } : {}),
         ...(enumFilesGlob ? { enumFilesGlob } : {}),
     });
-    const mergedInput = {
+    return {
         ...rawJson,
         models: (0, schema_1.mergeSplitSchemaEntries)({
             inline: rawJson.models,
@@ -87,6 +88,17 @@ async function loadProjectSchema(params) {
             fromFilesPaths: toPathMap(split.enums),
         }),
     };
+}
+/**
+ * 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 mergedInput = await loadAndMergeRawSchema(params);
     const result = schema_1.zProjectSchema.safeParse(mergedInput);
     if (!result.success) {
         console.log('\nError parsing postxl-schema.json:\n');

package/dist/validate.command.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 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
@@ -52,40 +53,46 @@ This reads the schema from the specified file or from postxl-schema.json in the
         if (!path.isAbsolute(inputPath)) {
             inputPath = path.join(process.cwd(), inputPath);
         }
-        // Check if input path exists
-        let schemaPath;
+        // Check if input path exists and decide between project-directory and raw-file modes.
+        // For a directory or a `postxl-schema.json` file we go through `loadAndMergeRawSchema`
+        // so split files under `schema/*.model.json` / `schema/*.enum.json` are merged into
+        // the validated input — otherwise validate would disagree with `generate` on
+        // multi-file schemas. For any other file path we treat it as a raw schema JSON
+        // (the single-file escape hatch for validating arbitrary fragments).
+        let jsonSchema;
         try {
             const stats = await fs.stat(inputPath);
             if (stats.isDirectory()) {
-                // If it's a directory, look for postxl-schema.json
-                schemaPath = path.join(inputPath, 'postxl-schema.json');
+                jsonSchema = await (0, load_project_schema_1.loadAndMergeRawSchema)({ projectPath: inputPath, program });
             }
             else if (stats.isFile()) {
-                // If it's a file, use it directly
-                schemaPath = inputPath;
+                if (path.basename(inputPath) === 'postxl-schema.json') {
+                    jsonSchema = await (0, load_project_schema_1.loadAndMergeRawSchema)({ projectPath: path.dirname(inputPath), program });
+                }
+                else {
+                    try {
+                        const content = await fs.readFile(inputPath, 'utf-8');
+                        jsonSchema = JSON.parse(content);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        program.error(`Error reading or parsing JSON from ${inputPath}: ${message}`);
+                    }
+                }
             }
             else {
                 program.error(`Path ${inputPath} is neither a file nor a directory!`);
             }
         }
-        catch {
-            program.error(`Cannot find path ${inputPath}!`);
-        }
-        // Check if schema file exists
-        try {
-            await fs.access(schemaPath);
-        }
-        catch {
-            program.error(`Cannot find schema file at ${schemaPath}`);
-        }
-        // Read and parse JSON
-        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.message}`);
+            // Only mask the missing-path case here — real errors from `loadAndMergeRawSchema`
+            // (bad split-file casing, duplicate model names, etc.) must surface so users can
+            // act on them. validate is the command they reach for to debug schema problems.
+            const code = error?.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR') {
+                program.error(`Cannot find path ${inputPath}!`);
+            }
+            throw error;
         }
         // Validate schema
         const result = schema_1.zProjectSchema.safeParse(jsonSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/cli",
-  "version": "1.8.1",
+  "version": "1.8.3",
   "description": "Command-line interface for PostXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -42,12 +42,12 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "dotenv": "17.3.1",
+    "dotenv": "17.4.2",
     "zod-validation-error": "5.0.0",
-    "@postxl/generator": "^1.6.0",
-    "@postxl/generators": "^2.0.0",
-    "@postxl/schema": "^2.0.0",
-    "@postxl/utils": "^1.4.0"
+    "@postxl/generator": "^1.6.1",
+    "@postxl/generators": "^2.0.1",
+    "@postxl/schema": "^2.0.1",
+    "@postxl/utils": "^1.4.1"
   },
   "devDependencies": {},
   "wallaby": {