klasik 1.0.25 → 1.0.26

package/.claude/settings.local.json

@@ -16,7 +16,8 @@
       "Bash(node dist/cli.js generate-crd:*)",
       "Bash(node test-programmatic-api.js:*)",
       "WebFetch(domain:www.schemastore.org)",
-      "WebFetch(domain:json.schemastore.org)"
+      "WebFetch(domain:json.schemastore.org)",
+      "Bash(node dist/cli.js:*)"
     ]
   }
 }

package/README.md

@@ -6,6 +6,7 @@ Download OpenAPI specifications from remote URLs and generate TypeScript clients
 
 - 📥 **Download OpenAPI specs** from remote URLs or local files
 - ☸️ **Kubernetes CRD support** - Generate TypeScript models from CustomResourceDefinitions
+- 📋 **JSON Schema support** - Generate models from JSON Schema files (SchemaStore.org and more)
 - 📁 **Multiple input formats** - HTTP/HTTPS URLs, file:// URLs, absolute/relative paths
 - 📄 **JSON and YAML support** - Automatically parse and handle both formats (YAML specs are converted to JSON for code generation)
 - 🔐 **Authentication support** - Custom headers including Bearer tokens and API keys
@@ -244,6 +245,129 @@ output/
 └── index.ts
 ```
 
+## JSON Schema Support
+
+Klasik can generate TypeScript models from JSON Schema files (like those from [SchemaStore.org](https://schemastore.org)). This is perfect for working with configuration files, data formats, and schema definitions.
+
+### Quick Start with JSON Schema
+
+Generate TypeScript models from a JSON Schema:
+
+```bash
+# From SchemaStore (kustomization.json schema)
+npx klasik generate-jsonschema \
+  -u https://json.schemastore.org/kustomization.json \
+  -o ./generated/kustomization
+
+# From multiple schemas (merged into single output)
+npx klasik generate-jsonschema \
+  -u https://json.schemastore.org/kustomization.json \
+  -u https://json.schemastore.org/package.json \
+  -o ./generated/models
+
+# From a local file
+npx klasik generate-jsonschema \
+  -u ./my-schema.json \
+  -o ./generated
+
+# With NestJS and validation decorators
+npx klasik generate-jsonschema \
+  -u ./schema.json \
+  -o ./src/generated \
+  --nestjs-swagger \
+  --class-validator
+```
+
+### JSON Schema Features
+
+- ✅ **All definitions generated** - Creates models for every definition in the schema
+- ✅ **Multiple URL support** - Merge models from multiple JSON Schema files
+- ✅ **Nested type extraction** - Complex nested objects become separate TypeScript interfaces
+- ✅ **Full decorator support** - Works with `--nestjs-swagger`, `--class-validator`, `--esm`
+- ✅ **Standards compliant** - Supports JSON Schema Draft 4 and Draft 7
+- ✅ **patternProperties handling** - Automatically converts to OpenAPI-compatible schemas
+
+### Generated Structure
+
+For a JSON Schema file with definitions:
+
+```
+output/
+├── models/
+│   ├── kustomization.ts
+│   ├── config-map-args.ts
+│   ├── helm-chart.ts
+│   └── ... (all definitions)
+└── index.ts
+```
+
+**Naming convention:**
+- `ConfigMapArgs` → `config-map-args.ts`
+- `HelmChart` → `helm-chart.ts`
+- `Kustomization` → `kustomization.ts`
+
+### Using Generated JSON Schema Models
+
+```typescript
+import { Kustomization, ConfigMapArgs } from './generated/kustomization';
+
+// Create a typed kustomization file
+const kustomization: Kustomization = {
+  apiVersion: 'kustomize.config.k8s.io/v1beta1',
+  kind: 'Kustomization',
+  resources: [
+    './deployment.yaml',
+    './service.yaml'
+  ],
+  configMapGenerator: [
+    {
+      name: 'my-config',
+      literals: ['key=value']
+    }
+  ]
+};
+
+// Full TypeScript intellisense and type checking!
+```
+
+### JSON Schema Programmatic API
+
+```typescript
+import { JSONSchemaGenerator } from 'klasik';
+
+const generator = new JSONSchemaGenerator();
+
+// Single URL
+await generator.generate({
+  urls: './schemas/my-schema.json',
+  outputDir: './generated',
+  nestJsSwagger: true,
+  classValidator: true
+});
+
+// Multiple URLs
+await generator.generate({
+  urls: [
+    'https://json.schemastore.org/kustomization.json',
+    './local-schema.json'
+  ],
+  outputDir: './generated',
+  keepSpec: true // Keep intermediate OpenAPI specs
+});
+```
+
+**JSONSchemaGeneratorOptions:**
+- `urls: string | string[]` - URL(s) or file path(s) to JSON Schema files (required)
+- `outputDir: string` - Output directory (required)
+- `headers?: Record<string, string>` - Custom HTTP headers
+- `timeout?: number` - Request timeout in milliseconds (default: 30000)
+- `fixEsmImports?: boolean` - Add .js extensions for ESM (default: false)
+- `nestJsSwagger?: boolean` - Include NestJS decorators (default: false)
+- `classValidator?: boolean` - Include validation decorators (default: false)
+- `skipJsExtensions?: boolean` - Skip .js extensions (default: false)
+- `templateDir?: string` - Custom template directory
+- `keepSpec?: boolean` - Keep intermediate OpenAPI specs (default: false)
+
 ## CLI Commands
 
 ### `generate`
@@ -454,6 +578,76 @@ output/
 └── index.ts
 ```
 
+### `generate-jsonschema`
+
+Generate TypeScript models from JSON Schema files.
+
+**Options:**
+- `-u, --url <url...>` - URL(s) or file path(s) to JSON Schema files (required)
+  - Can be specified multiple times: `-u url1 -u url2 -u url3`
+  - All schemas from all URLs are merged into a single output directory
+  - Supports: `https://...`, `http://...`, `file://...`, `/absolute/path`, `./relative/path`
+- `-o, --output <dir>` - Output directory for generated models (required)
+- `--nestjs-swagger` - Include NestJS Swagger `@ApiProperty` decorators
+- `--class-validator` - Include class-validator decorators
+- `--esm` - Add `.js` extensions to imports for ESM compatibility
+- `-H, --header <header...>` - Custom headers for HTTP requests (format: "Key: Value")
+- `-t, --template <dir>` - Custom template directory
+- `-k, --keep-spec` - Keep the generated OpenAPI spec files (for debugging)
+- `--timeout <ms>` - Request timeout in milliseconds (default: 30000)
+
+**Examples:**
+
+```bash
+# Generate from SchemaStore
+klasik generate-jsonschema \
+  --url https://json.schemastore.org/kustomization.json \
+  --output ./generated/kustomization
+
+# Generate from multiple JSON Schema files (merged into single output)
+klasik generate-jsonschema \
+  -u https://json.schemastore.org/kustomization.json \
+  -u https://json.schemastore.org/package.json \
+  --output ./generated/schemas
+
+# Mix remote and local schemas
+klasik generate-jsonschema \
+  -u https://json.schemastore.org/kustomization.json \
+  -u ./schemas/my-schema.json \
+  -u ./schemas/another-schema.json \
+  --output ./src/generated
+
+# NestJS integration with validation
+klasik generate-jsonschema \
+  --url ./schemas/ \
+  --output ./src/generated/models \
+  --nestjs-swagger \
+  --class-validator
+
+# From local file with ESM support
+klasik generate-jsonschema \
+  --url ./local-schema.json \
+  --output ./generated \
+  --esm
+
+# Keep intermediate OpenAPI specs for debugging
+klasik generate-jsonschema \
+  --url https://json.schemastore.org/kustomization.json \
+  --output ./generated \
+  --keep-spec
+```
+
+**Output Structure:**
+
+```
+output/
+├── models/
+│   ├── type-a.ts
+│   ├── type-b.ts
+│   └── ... (all definitions from all schemas)
+└── index.ts
+```
+
 ## Programmatic API
 
 ### K8sClientGenerator

package/dist/cli.js

@@ -185,4 +185,53 @@ program
         process.exit(1);
     }
 });
+program
+    .command('generate-jsonschema')
+    .description('Generate TypeScript models from JSON Schema files')
+    .requiredOption('-u, --url <url...>', 'URL(s) or file path(s) to JSON Schema files (can be specified multiple times)')
+    .requiredOption('-o, --output <dir>', 'Output directory for generated models')
+    .option('--nestjs-swagger', 'Include NestJS Swagger @ApiProperty decorators in generated models', false)
+    .option('--class-validator', 'Include class-validator decorators in generated models', false)
+    .option('--esm', 'Add .js extensions to imports for ESM compatibility', false)
+    .option('-H, --header <header...>', 'Custom headers for the request (format: "Key: Value")')
+    .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
+    .option('-t, --template <dir>', 'Custom template directory')
+    .option('-k, --keep-spec', 'Keep the generated OpenAPI spec files', false)
+    .action(async (options) => {
+    try {
+        // Parse headers if provided
+        const headers = {};
+        if (options.header) {
+            for (const header of options.header) {
+                const [key, ...valueParts] = header.split(':');
+                const value = valueParts.join(':').trim();
+                if (key && value) {
+                    headers[key.trim()] = value;
+                }
+            }
+        }
+        // Resolve output directory to absolute path
+        const outputDir = path.resolve(options.output);
+        const { JSONSchemaGenerator } = await Promise.resolve().then(() => __importStar(require('./jsonschema/jsonschema-generator')));
+        const generator = new JSONSchemaGenerator();
+        // Handle both single URL (backwards compat) and multiple URLs
+        const urls = Array.isArray(options.url) ? options.url : [options.url];
+        await generator.generate({
+            urls,
+            outputDir,
+            headers: Object.keys(headers).length > 0 ? headers : undefined,
+            timeout: parseInt(options.timeout, 10),
+            fixEsmImports: options.esm,
+            nestJsSwagger: options.nestjsSwagger,
+            classValidator: options.classValidator,
+            templateDir: options.template,
+            keepSpec: options.keepSpec,
+        });
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/index.d.ts

@@ -5,3 +5,7 @@ export { CRDGenerator, CRDGeneratorOptions } from './crd/crd-generator';
 export { CRDParser } from './crd/crd-parser';
 export { CRDToOpenAPIConverter, ConversionOptions } from './crd/crd-to-openapi';
 export { ParsedCRD, ParsedCRDResult, CRDVersion, CRDMetadata, ExtractedSchema, CRDParserOptions, } from './crd/types';
+export { JSONSchemaGenerator, JSONSchemaGeneratorOptions } from './jsonschema/jsonschema-generator';
+export { JSONSchemaParser } from './jsonschema/jsonschema-parser';
+export { JSONSchemaToOpenAPIConverter, JSONSchemaConversionOptions } from './jsonschema/jsonschema-to-openapi';
+export { ParsedJSONSchema, ParsedJSONSchemaResult, JSONSchemaMetadata, JSONSchemaParserOptions, } from './jsonschema/types';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CRDToOpenAPIConverter = exports.CRDParser = exports.CRDGenerator = exports.EsmFixer = exports.SpecDownloader = exports.K8sClientGenerator = void 0;
+exports.JSONSchemaToOpenAPIConverter = exports.JSONSchemaParser = exports.JSONSchemaGenerator = exports.CRDToOpenAPIConverter = exports.CRDParser = exports.CRDGenerator = exports.EsmFixer = exports.SpecDownloader = exports.K8sClientGenerator = void 0;
 var k8s_client_generator_1 = require("./k8s-client-generator");
 Object.defineProperty(exports, "K8sClientGenerator", { enumerable: true, get: function () { return k8s_client_generator_1.K8sClientGenerator; } });
 var spec_downloader_1 = require("./spec-downloader");
@@ -14,3 +14,10 @@ var crd_parser_1 = require("./crd/crd-parser");
 Object.defineProperty(exports, "CRDParser", { enumerable: true, get: function () { return crd_parser_1.CRDParser; } });
 var crd_to_openapi_1 = require("./crd/crd-to-openapi");
 Object.defineProperty(exports, "CRDToOpenAPIConverter", { enumerable: true, get: function () { return crd_to_openapi_1.CRDToOpenAPIConverter; } });
+// JSON Schema generation exports
+var jsonschema_generator_1 = require("./jsonschema/jsonschema-generator");
+Object.defineProperty(exports, "JSONSchemaGenerator", { enumerable: true, get: function () { return jsonschema_generator_1.JSONSchemaGenerator; } });
+var jsonschema_parser_1 = require("./jsonschema/jsonschema-parser");
+Object.defineProperty(exports, "JSONSchemaParser", { enumerable: true, get: function () { return jsonschema_parser_1.JSONSchemaParser; } });
+var jsonschema_to_openapi_1 = require("./jsonschema/jsonschema-to-openapi");
+Object.defineProperty(exports, "JSONSchemaToOpenAPIConverter", { enumerable: true, get: function () { return jsonschema_to_openapi_1.JSONSchemaToOpenAPIConverter; } });

package/dist/jsonschema/jsonschema-generator.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Options for JSON Schema client generation
+ */
+export interface JSONSchemaGeneratorOptions {
+    /**
+     * URL(s) or file path(s) to JSON Schema file(s)
+     * Can be a single URL string or array of URLs
+     */
+    urls: string | string[];
+    /**
+     * Output directory for generated models
+     */
+    outputDir: string;
+    /**
+     * Custom headers for downloading schemas from URLs
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout for downloading specs in milliseconds
+     * @default 30000
+     */
+    timeout?: number;
+    /**
+     * Whether to fix ESM imports by adding .js extensions
+     * @default false
+     */
+    fixEsmImports?: boolean;
+    /**
+     * Include NestJS Swagger @ApiProperty decorators
+     * @default false
+     */
+    nestJsSwagger?: boolean;
+    /**
+     * Include class-validator decorators
+     * @default false
+     */
+    classValidator?: boolean;
+    /**
+     * Skip adding .js extensions to imports/exports
+     * @default false
+     */
+    skipJsExtensions?: boolean;
+    /**
+     * Custom template directory
+     */
+    templateDir?: string;
+    /**
+     * Whether to keep the intermediate OpenAPI specs
+     * @default false
+     */
+    keepSpec?: boolean;
+}
+/**
+ * Main orchestrator for generating TypeScript models from JSON Schema files
+ */
+export declare class JSONSchemaGenerator {
+    private parser;
+    private converter;
+    private k8sGenerator;
+    constructor();
+    /**
+     * Main generation workflow
+     * @param options Generation options
+     */
+    generate(options: JSONSchemaGeneratorOptions): Promise<void>;
+    /**
+     * Load JSON Schema file from URL or local path
+     * @param url URL or file path
+     * @param headers Optional HTTP headers
+     * @param timeout Optional timeout in milliseconds
+     * @returns Schema file content as string
+     */
+    private loadSchemaFile;
+    /**
+     * Check if the URL is a local file path
+     */
+    private isLocalFile;
+    /**
+     * Load JSON Schema from local file
+     */
+    private loadLocalSchemaFile;
+    /**
+     * Generate index file for all definitions
+     * @param outputDir Output directory
+     * @param definitions List of definition names
+     */
+    private generateIndex;
+    /**
+     * Convert definition name to file name
+     * ConfigMapArgs → config-map-args
+     * @param definitionName Definition name
+     * @returns File name (without .ts extension)
+     */
+    private toFileName;
+    /**
+     * Extract filename from source path/URL
+     * @param source Source path or URL
+     * @returns Filename without extension
+     */
+    private extractFilename;
+}