@intellegens/cornerstone-cli 0.0.0-experimental-upgrade-20260302-1

package/README.md

@@ -0,0 +1,92 @@
+# Cornerstone TypeScript CLI Tool(s)
+
+A command-line interface (CLI) with various utilities. The CLI is built using yargs and supports the following commands:
+
+## Getting started
+
+1. Install dependencies:
+
+```bash
+pnpm install
+```
+
+### Available scripts
+
+2. `build`: Compiles the TypeScript code
+
+```bash
+pnpm run build
+```
+
+3. `cli`: Runs the CLI in development mode using tsx
+
+```bash
+pnpm run cli <command> [options]
+```
+
+### Install and run
+
+```sh
+pnpm install -g @intellegens/cornerstone-cli
+cornerstone-ts <command> [options]
+```
+
+## API reference
+
+### Zod Schema Generator
+
+Generates Zod schemas from JSON schema files, preserving namespace structure.
+
+```bash
+# Development
+pnpm run cli zod-gen --input <input-dir> --output <output-dir>
+
+# After building
+./dist/utils/cli/index.js zod-gen --input <input-dir> --output <output-dir>
+```
+
+Options:
+
+- `--input, -i`: Path to the folder containing JSON schemas
+- `--output, -o`: Path to the folder where Zod schemas will be saved
+
+The command will:
+
+1. Read JSON schema files from the input directory
+2. Create a folder structure matching the type's namespace
+3. Generate Zod schemas with proper type names
+4. Save the generated schemas in their respective namespace folders
+
+For example, if you have a JSON schema file named `MyCompany.ModuleA.Models.UserDto.json`, it will:
+
+- Create directories: `output-dir/MyCompany/ModuleA/Models/`
+- Generate and save `UserDto.ts` in that directory with the Zod schema
+
+### OpenAPI Generator
+
+Generates client code from OpenAPI schema files using Orval.
+
+```bash
+# Development
+pnpm run cli openapi-gen --input <input-file> --output <output-dir> [options]
+
+# After building
+./dist/utils/cli/index.js openapi-gen --input <input-file> --output <output-dir> [options]
+```
+
+Options:
+
+- `--input, -i`: Path to the OPENAPI schema .json file
+- `--output, -o`: Path to the folder where client and types will be saved
+- `--prettier, -p`: Format generated code with Prettier (default: false)
+- `--fetchClient, -f`: Generate fetch client (default: false)
+- `--angularClient, -a`: Generate Angular client (default: false)
+- `--zod, -z`: Generate Zod schemas (default: false)
+- `--mock, -m`: Generate mock client (default: false)
+- `--clean, -c`: Clean output folder (default: true)
+- `--project, -pr`: Project name (default: 'my-project')
+- `--baseUrl, -b`: Base URL for the API (default: '')
+
+The command will generate client code based on the selected options. By default, it generates only types; additionally, you can generate fetch client, angular client or zod schemas.
+
+

package/dist/commands/openapi-generator.d.ts

@@ -0,0 +1,15 @@
+import { CommandModule } from 'yargs';
+interface OpenApiGeneratorArgs {
+    input: string;
+    output: string;
+    prettier: boolean;
+    zod: boolean;
+    fetchClient: boolean;
+    angularClient: boolean;
+    mock: boolean;
+    project: string;
+    baseUrl: string;
+    clean: boolean;
+}
+export declare const openApiGeneratorCommand: CommandModule<{}, OpenApiGeneratorArgs>;
+export {};

package/dist/commands/openapi-generator.js

@@ -0,0 +1,161 @@
+import { generate } from 'orval';
+import fs from 'fs';
+import path from 'path';
+export const openApiGeneratorCommand = {
+    command: 'openapi-gen',
+    describe: 'Generate Zod schemas from JSON schemas',
+    builder: {
+        input: {
+            alias: 'i',
+            type: 'string',
+            describe: 'Path to the OPENAPI schema .json file',
+            demandOption: true,
+        },
+        output: {
+            alias: 'o',
+            type: 'string',
+            describe: 'Path to the folder where client will be saved',
+            demandOption: true,
+        },
+        prettier: {
+            alias: 'p',
+            type: 'boolean',
+            describe: 'Format generated code with Prettier',
+            default: false,
+        },
+        fetchClient: {
+            alias: 'f',
+            type: 'boolean',
+            describe: 'Generate fetch client',
+            default: false,
+        },
+        angularClient: {
+            alias: 'a',
+            type: 'boolean',
+            describe: 'Generate Angular client',
+            default: false,
+        },
+        zod: {
+            alias: 'z',
+            type: 'boolean',
+            describe: 'Generate Zod schemas',
+            default: false,
+        },
+        mock: {
+            alias: 'm',
+            type: 'boolean',
+            describe: 'Generate mock client',
+            default: false,
+        },
+        clean: {
+            alias: 'c',
+            type: 'boolean',
+            describe: 'Clean output folder',
+            default: true,
+        },
+        project: {
+            alias: 'pr',
+            type: 'string',
+            describe: 'Project name',
+            default: 'my-project',
+        },
+        baseUrl: {
+            alias: 'b',
+            type: 'string',
+            describe: 'Base URL for the API',
+            default: '',
+        },
+    },
+    async handler(args) {
+        try {
+            const absoluteInputPath = path.resolve(args.input);
+            const absoluteOutputPath = path.resolve(args.output);
+            // Check if input file exists
+            if (!fs.existsSync(absoluteInputPath)) {
+                console.error('🔴 OpenAPI schema file not found:', absoluteInputPath);
+                process.exit(1);
+            }
+            let configs = [];
+            // Add configurations based on selected options
+            if ((!args.fetchClient && !args.angularClient) || args.zod) {
+                configs.push({
+                    input: absoluteInputPath,
+                    output: {
+                        mode: 'tags-split',
+                        target: './zod',
+                        schemas: './models',
+                        client: 'zod',
+                        mock: args.mock,
+                        prettier: args.prettier,
+                        clean: args.clean,
+                        override: {
+                            useTypeOverInterfaces: true,
+                            zod: {
+                                generate: {
+                                    param: false,
+                                    body: args.zod,
+                                    response: false,
+                                    query: false,
+                                    header: false,
+                                },
+                            },
+                        },
+                    },
+                });
+            }
+            if (args.fetchClient) {
+                configs.push({
+                    input: absoluteInputPath,
+                    output: {
+                        mode: 'tags-split',
+                        target: './endpoints',
+                        schemas: './models',
+                        client: 'fetch',
+                        httpClient: 'fetch',
+                        mock: args.mock,
+                        prettier: args.prettier,
+                        clean: args.clean,
+                        override: {
+                            useTypeOverInterfaces: true,
+                        },
+                    },
+                });
+            }
+            if (args.angularClient) {
+                configs.push({
+                    input: absoluteInputPath,
+                    output: {
+                        mode: 'tags-split',
+                        target: './endpoints',
+                        schemas: './models',
+                        client: 'angular',
+                        mock: args.mock,
+                        prettier: args.prettier,
+                        clean: args.clean,
+                        baseUrl: args.baseUrl,
+                        override: {
+                            useTypeOverInterfaces: true,
+                        },
+                    },
+                });
+            }
+            if (configs.length === 0) {
+                console.error('🔴 No options selected. Please select at least one option.');
+                process.exit(1);
+            }
+            // Generate
+            for (const config of configs) {
+                await generate(config, absoluteOutputPath, { projectName: args.project });
+            }
+            console.log('🟢 Schemas generated successfully!');
+        }
+        catch (error) {
+            console.error('🔴 Error generating schemas:', error);
+            if (error instanceof Error) {
+                console.error('🔴 Error message:', error.message);
+                console.error('🔴 Error stack:', error.stack);
+            }
+            process.exit(1);
+        }
+    },
+};

package/dist/commands/zod-schema-generator.d.ts

@@ -0,0 +1,7 @@
+import { CommandModule } from 'yargs';
+interface ZodSchemaGeneratorArgs {
+    input: string;
+    output: string;
+}
+export declare const zodSchemaGeneratorCommand: CommandModule<{}, ZodSchemaGeneratorArgs>;
+export {};

package/dist/commands/zod-schema-generator.js

@@ -0,0 +1,88 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { jsonSchemaToZod } from 'json-schema-to-zod';
+import { resolveRefs } from 'json-refs';
+export const zodSchemaGeneratorCommand = {
+    command: 'zod-gen',
+    describe: 'Generate Zod schemas from JSON schemas',
+    builder: {
+        input: {
+            alias: 'i',
+            type: 'string',
+            describe: 'Path to the folder containing JSON schemas',
+            demandOption: true,
+        },
+        output: {
+            alias: 'o',
+            type: 'string',
+            describe: 'Path to the folder where Zod schemas will be saved',
+            demandOption: true,
+        },
+    },
+    async handler(args) {
+        try {
+            const { input: inputPath, output: outputPath } = args;
+            if (!fs.existsSync(inputPath)) {
+                console.warn('🟡 Input directory not found.');
+                process.exit(0);
+            }
+            const files = fs
+                .readdirSync(inputPath)
+                .filter((file) => file.endsWith('.json'));
+            if (files.length === 0) {
+                console.warn('🟡 No JSON schema files found in the input directory.');
+                process.exit(0);
+            }
+            if (!fs.existsSync(outputPath)) {
+                fs.emptyDirSync(outputPath);
+            }
+            else {
+                fs.mkdirSync(outputPath, { recursive: true });
+            }
+            var exports = {};
+            for (const file of files) {
+                const filePath = path.join(inputPath, file);
+                const schemaContent = fs.readFileSync(filePath, 'utf-8');
+                const schema = JSON.parse(schemaContent);
+                const fullName = path.basename(file, '.json');
+                const parts = fullName.split('.');
+                // Last part is the type name, everything before is namespace
+                const typeName = parts[parts.length - 1];
+                const namespaceParts = parts.slice(0, -1);
+                // Create the namespace folder structure
+                const namespaceDir = path.join(outputPath, ...namespaceParts);
+                fs.mkdirSync(namespaceDir, { recursive: true });
+                const { resolved } = await resolveRefs(schema);
+                // Convert JSON Schema to Zod
+                const zodSchema = jsonSchemaToZod(resolved, {
+                    withJsdocs: true,
+                    module: 'esm',
+                    type: true,
+                    name: typeName,
+                    depth: 5,
+                });
+                // Generate TypeScript file
+                const fileName = `${typeName}.ts`;
+                const outputFilePath = path.join(namespaceDir, fileName);
+                const outputTypePath = path.join(namespaceDir, typeName);
+                fs.writeFileSync(outputFilePath, zodSchema, 'utf-8');
+                console.log(`- Generated Zod schema: ${outputFilePath}`);
+                // Register for (re)export
+                exports[typeName] = path.relative(outputPath, outputTypePath);
+            }
+            // Write (re)export file
+            let exportFileContent = '';
+            for (const typeName in exports) {
+                const typePath = `./${exports[typeName]}`.replace(/\\/g, '/');
+                exportFileContent += `export * from '${typePath}'; // .NET ${typeName} class\n`;
+            }
+            fs.writeFileSync(path.join(outputPath, './index.ts'), exportFileContent, 'utf-8');
+            // Prompt done
+            console.log('🟢 Zod schemas generated successfully!');
+        }
+        catch (error) {
+            console.error('🔴 Error generating Zod schemas:', error);
+            process.exit(1);
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { zodSchemaGeneratorCommand } from './commands/zod-schema-generator.js';
+import { openApiGeneratorCommand } from './commands/openapi-generator.js';
+yargs(hideBin(process.argv))
+    .scriptName('cornerstone-ts')
+    .command(zodSchemaGeneratorCommand)
+    .command(openApiGeneratorCommand)
+    .demandCommand(1, 'You need to specify a command')
+    .strict()
+    .alias('h', 'help')
+    .parse();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@intellegens/cornerstone-cli",
+  "version": "0.0.0-experimental-upgrade-20260302-1",
+  "private": false,
+  "publishable": true,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "author": "Intellegens",
+  "license": "MIT",
+  "description": "",
+  "keywords": [
+    "intellegens",
+    "cornerstone"
+  ],
+  "bin": {
+    "cornerstone-ts": "./dist/index.js"
+  },
+  "dependencies": {
+    "@orval/core": "^7.21.0",
+    "fs-extra": "^11.3.3",
+    "json-refs": "^3.0.15",
+    "json-schema-to-zod": "^2.7.0",
+    "orval": "^7.21.0",
+    "typescript": "~5.9.3",
+    "yargs": "^17.7.2",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.3.1",
+    "@types/yargs": "^17.0.35",
+    "tsc-alias": "^1.8.16",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "clean": "pnpx rimraf '{dist}'",
+    "test": "vitest run --passWithNoTests",
+    "test:unit": "vitest run --project unit --passWithNoTests",
+    "test:integration": "vitest run --project integration --passWithNoTests",
+    "coverage": "vitest run --coverage",
+    "build": "pnpm run clean && tsc && tsc-alias",
+    "start": "tsx ./src/index.ts"
+  }
+}

package/src/commands/openapi-generator.ts

@@ -0,0 +1,185 @@
+import { generate } from 'orval';
+import { CommandModule } from 'yargs';
+import fs from 'fs';
+import path from 'path';
+import { OptionsExport } from '@orval/core';
+
+interface OpenApiGeneratorArgs {
+  input: string;
+  output: string;
+  prettier: boolean;
+  zod: boolean;
+  fetchClient: boolean;
+  angularClient: boolean;
+  mock: boolean;
+  project: string;
+  baseUrl: string;
+  clean: boolean;
+}
+
+export const openApiGeneratorCommand: CommandModule<{}, OpenApiGeneratorArgs> = {
+  command: 'openapi-gen',
+  describe: 'Generate Zod schemas from JSON schemas',
+
+  builder: {
+    input: {
+      alias: 'i',
+      type: 'string',
+      describe: 'Path to the OPENAPI schema .json file',
+      demandOption: true,
+    },
+    output: {
+      alias: 'o',
+      type: 'string',
+      describe: 'Path to the folder where client will be saved',
+      demandOption: true,
+    },
+    prettier: {
+      alias: 'p',
+      type: 'boolean',
+      describe: 'Format generated code with Prettier',
+      default: false,
+    },
+    fetchClient: {
+      alias: 'f',
+      type: 'boolean',
+      describe: 'Generate fetch client',
+      default: false,
+    },
+    angularClient: {
+      alias: 'a',
+      type: 'boolean',
+      describe: 'Generate Angular client',
+      default: false,
+    },
+    zod: {
+      alias: 'z',
+      type: 'boolean',
+      describe: 'Generate Zod schemas',
+      default: false,
+    },
+    mock: {
+      alias: 'm',
+      type: 'boolean',
+      describe: 'Generate mock client',
+      default: false,
+    },
+    clean: {
+      alias: 'c',
+      type: 'boolean',
+      describe: 'Clean output folder',
+      default: true,
+    },
+    project: {
+      alias: 'pr',
+      type: 'string',
+      describe: 'Project name',
+      default: 'my-project',
+    },
+    baseUrl: {
+      alias: 'b',
+      type: 'string',
+      describe: 'Base URL for the API',
+      default: '',
+    },
+  },
+
+  async handler(args: OpenApiGeneratorArgs) {
+    try {
+      const absoluteInputPath = path.resolve(args.input);
+      const absoluteOutputPath = path.resolve(args.output);
+      // Check if input file exists
+      if (!fs.existsSync(absoluteInputPath)) {
+        console.error('🔴 OpenAPI schema file not found:', absoluteInputPath);
+        process.exit(1);
+      }
+
+      let configs: OptionsExport[] = [];
+
+      // Add configurations based on selected options
+      if ((!args.fetchClient && !args.angularClient) || args.zod) {
+        configs.push({
+          input: absoluteInputPath,
+          output: {
+            mode: 'tags-split',
+            target: './zod',
+            schemas: './models',
+            client: 'zod',
+            mock: args.mock,
+            prettier: args.prettier,
+            clean: args.clean,
+            override: {
+              useTypeOverInterfaces: true,
+              zod: {
+                generate: {
+                  param: false,
+                  body: args.zod,
+                  response: false,
+                  query: false,
+                  header: false,
+                },
+              },
+            },
+          },
+        });
+      }
+
+      if (args.fetchClient) {
+        configs.push({
+          input: absoluteInputPath,
+          output: {
+            mode: 'tags-split',
+            target: './endpoints',
+            schemas: './models',
+            client: 'fetch',
+            httpClient: 'fetch',
+            mock: args.mock,
+            prettier: args.prettier,
+            clean: args.clean,
+            override: {
+              useTypeOverInterfaces: true,
+            },
+          },
+        });
+      }
+
+      if (args.angularClient) {
+        configs.push({
+          input: absoluteInputPath,
+          output: {
+            mode: 'tags-split',
+            target: './endpoints',
+            schemas: './models',
+            client: 'angular',
+            mock: args.mock,
+            prettier: args.prettier,
+            clean: args.clean,
+            baseUrl: args.baseUrl,
+            override: {
+              useTypeOverInterfaces: true,
+            },
+          },
+        });
+      }
+
+      if (configs.length === 0) {
+        console.error('🔴 No options selected. Please select at least one option.');
+        process.exit(1);
+      }
+
+      // Generate
+      for (const config of configs) {
+        await generate(config, absoluteOutputPath, { projectName: args.project });
+      }
+
+      console.log('🟢 Schemas generated successfully!');
+    } catch (error) {
+      console.error('🔴 Error generating schemas:', error);
+      if (error instanceof Error) {
+        console.error('🔴 Error message:', error.message);
+        console.error('🔴 Error stack:', error.stack);
+      }
+      process.exit(1);
+    }
+  },
+};

package/src/commands/zod-schema-generator.ts

@@ -0,0 +1,116 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { jsonSchemaToZod } from 'json-schema-to-zod';
+import { resolveRefs } from 'json-refs';
+import { CommandModule } from 'yargs';
+
+interface ZodSchemaGeneratorArgs {
+  input: string;
+  output: string;
+}
+
+export const zodSchemaGeneratorCommand: CommandModule<
+  {},
+  ZodSchemaGeneratorArgs
+> = {
+  command: 'zod-gen',
+  describe: 'Generate Zod schemas from JSON schemas',
+
+  builder: {
+    input: {
+      alias: 'i',
+      type: 'string',
+      describe: 'Path to the folder containing JSON schemas',
+      demandOption: true,
+    },
+    output: {
+      alias: 'o',
+      type: 'string',
+      describe: 'Path to the folder where Zod schemas will be saved',
+      demandOption: true,
+    },
+  },
+
+  async handler(args: ZodSchemaGeneratorArgs) {
+    try {
+      const { input: inputPath, output: outputPath } = args;
+
+      if (!fs.existsSync(inputPath)) {
+        console.warn('🟡 Input directory not found.');
+        process.exit(0);
+      }
+
+      const files = fs
+        .readdirSync(inputPath)
+        .filter((file) => file.endsWith('.json'));
+
+      if (files.length === 0) {
+        console.warn('🟡 No JSON schema files found in the input directory.');
+        process.exit(0);
+      }
+
+      if (!fs.existsSync(outputPath)) {
+        fs.emptyDirSync(outputPath);
+      } else {
+        fs.mkdirSync(outputPath, { recursive: true });
+      }
+
+      var exports: Record<string, string> = {};
+      for (const file of files) {
+        const filePath = path.join(inputPath, file);
+        const schemaContent = fs.readFileSync(filePath, 'utf-8');
+        const schema = JSON.parse(schemaContent);
+
+        const fullName = path.basename(file, '.json');
+        const parts = fullName.split('.');
+
+        // Last part is the type name, everything before is namespace
+        const typeName = parts[parts.length - 1];
+        const namespaceParts = parts.slice(0, -1);
+
+        // Create the namespace folder structure
+        const namespaceDir = path.join(outputPath, ...namespaceParts);
+        fs.mkdirSync(namespaceDir, { recursive: true });
+
+        const { resolved } = await resolveRefs(schema);
+        // Convert JSON Schema to Zod
+        const zodSchema = jsonSchemaToZod(resolved, {
+          withJsdocs: true,
+          module: 'esm',
+          type: true,
+          name: typeName,
+          depth: 5,
+        });
+
+        // Generate TypeScript file
+        const fileName = `${typeName}.ts`;
+        const outputFilePath = path.join(namespaceDir, fileName);
+        const outputTypePath = path.join(namespaceDir, typeName);
+
+        fs.writeFileSync(outputFilePath, zodSchema, 'utf-8');
+        console.log(`- Generated Zod schema: ${outputFilePath}`);
+
+        // Register for (re)export
+        exports[typeName] = path.relative(outputPath, outputTypePath);
+      }
+
+      // Write (re)export file
+      let exportFileContent = '';
+      for (const typeName in exports) {
+        const typePath = `./${exports[typeName]}`.replace(/\\/g, '/');
+        exportFileContent += `export * from '${typePath}'; // .NET ${typeName} class\n`;
+      }
+      fs.writeFileSync(
+        path.join(outputPath, './index.ts'),
+        exportFileContent,
+        'utf-8',
+      );
+
+      // Prompt done
+      console.log('🟢 Zod schemas generated successfully!');
+    } catch (error) {
+      console.error('🔴 Error generating Zod schemas:', error);
+      process.exit(1);
+    }
+  },
+};

package/src/index.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { zodSchemaGeneratorCommand } from './commands/zod-schema-generator.js';
+import { openApiGeneratorCommand } from './commands/openapi-generator.js';
+
+yargs(hideBin(process.argv))
+  .scriptName('cornerstone-ts')
+  .command(zodSchemaGeneratorCommand)
+  .command(openApiGeneratorCommand)
+  .demandCommand(1, 'You need to specify a command')
+  .strict()
+  .alias('h', 'help')
+  .parse();

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,37 @@
+import path from 'path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: 'unit',
+          environment: 'jsdom',
+          testTimeout: 60000,
+          include: ['./**/*.unit.test.{ts,tsx,js}', './**/*.unit.test.{ts,tsx,js}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+      {
+        test: {
+          name: 'integration',
+          environment: 'jsdom',
+          testTimeout: 60000,
+          globalSetup: [path.resolve(__dirname, '../../vitest-setup-integration.ts')],
+          include: ['./**/*.integration.test.{ts,tsx,js}', './**/*.integration.test.{ts,tsx,js}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+      {
+        test: {
+          name: 'debug',
+          testTimeout: 60000,
+          globalSetup: [path.resolve(__dirname, '../../vitest-setup-integration.ts')],
+          include: ['./**/*.{test,spec,debug}.{js,ts}'],
+          exclude: ['**/node_modules/**', '**/dist/**'],
+        },
+      },
+    ],
+  },
+});