@postxl/cli 1.6.0 → 1.7.0

package/dist/generate-types.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function register(program: Command): void;

package/dist/generate-types.command.js

@@ -0,0 +1,127 @@
+"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.register = register;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+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 log_schema_error_1 = require("./helpers/log-schema-error");
+function register(program) {
+    program
+        .command('generate-types')
+        .alias('types')
+        .argument('[path]', 'Path to project directory or schema file. Default is current directory', process.cwd())
+        .requiredOption('-o, --output <path>', 'Output directory for the generated type files')
+        .summary('Generates only the types from a PostXL schema.')
+        .description(`Generates only the types from a PostXL schema.
+
+This reads the schema and runs only the types generator. The generated type files are written to the specified output directory.`)
+        .option('-t, --skip-transform', 'skips formatting')
+        .action(async (inputPath, options) => {
+        if (!path.isAbsolute(inputPath)) {
+            inputPath = path.join(process.cwd(), inputPath);
+        }
+        // Resolve schema path
+        let schemaPath = '';
+        try {
+            const stats = await fs.stat(inputPath);
+            if (stats.isDirectory()) {
+                schemaPath = path.join(inputPath, 'postxl-schema.json');
+            }
+            else if (stats.isFile()) {
+                schemaPath = inputPath;
+            }
+            else {
+                program.error(`Path ${inputPath} is neither a file nor a directory!`);
+            }
+        }
+        catch {
+            program.error(`Cannot find path ${inputPath}!`);
+        }
+        try {
+            await fs.access(schemaPath);
+        }
+        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)}`);
+        }
+        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);
+        }
+        const schema = result.data;
+        // Resolve output path
+        let outputPath = options.output;
+        if (!path.isAbsolute(outputPath)) {
+            outputPath = path.resolve(process.cwd(), outputPath);
+        }
+        console.log(`Generating types from ${schemaPath}`);
+        console.log(`Output directory: ${outputPath}`);
+        // Run standalone types generation
+        const vfs = await (0, generators_1.generateTypesStandalone)(schema);
+        // Apply formatting if not skipped
+        if (!options.skipTransform) {
+            await vfs.transform(generator_1.format, {
+                onError: ({ path: filePath, error }) => {
+                    console.error((0, utils_1.yellow)(`Warning: Error formatting ${filePath}:`), error);
+                },
+            });
+        }
+        // Write VFS files to disk.
+        // generateTypesStandalone() returns a VFS with clean relative paths (prefix already stripped).
+        await fs.mkdir(outputPath, { recursive: true });
+        let fileCount = 0;
+        for (const [filePath, content] of vfs.files) {
+            const absolutePath = path.join(outputPath, filePath);
+            await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+            await fs.writeFile(absolutePath, content);
+            fileCount++;
+        }
+        console.log((0, utils_1.green)(`\n${fileCount} type files written to ${outputPath}`));
+    });
+}

package/dist/index.js

@@ -8,6 +8,7 @@ const commander_1 = require("commander");
 const node_path_1 = __importDefault(require("node:path"));
 const create_project_command_1 = require("./create-project.command");
 const generate_command_1 = require("./generate.command");
+const generate_types_command_1 = require("./generate-types.command");
 const validate_command_1 = require("./validate.command");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const { version } = require(node_path_1.default.join(__dirname, '..', 'package.json'));
@@ -19,6 +20,7 @@ program
     .version(version);
 // Adding all the commands
 (0, generate_command_1.register)(program);
+(0, generate_types_command_1.register)(program);
 (0, create_project_command_1.register)(program);
 (0, validate_command_1.register)(program);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Command-line interface for PostXL code generation framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -45,7 +45,7 @@
     "dotenv": "17.3.1",
     "zod-validation-error": "5.0.0",
     "@postxl/generator": "^1.3.7",
-    "@postxl/generators": "^1.23.1",
+    "@postxl/generators": "^1.24.0",
     "@postxl/schema": "^1.8.2",
     "@postxl/utils": "^1.4.0"
   },