@abapify/ts-xsd 0.4.0 → 0.4.3

package/README.md

@@ -1,37 +1,32 @@
 # ts-xsd
 
-[![version](https://img.shields.io/github/package-json/v/abapify/adt-cli?filename=packages/ts-xsd/package.json)](https://github.com/abapify/adt-cli/pkgs/npm/%40abapify%2Fts-xsd)
+[![npm version](https://img.shields.io/npm/v/@abapify/ts-xsd)](https://www.npmjs.com/package/@abapify/ts-xsd)
+[![license](https://img.shields.io/npm/l/@abapify/ts-xsd)](https://github.com/abapify/adt-cli/blob/main/LICENSE)
 
-**Core XSD parser, builder, and type inference** with **1:1 TypeScript representation** of W3C XML Schema Definition (XSD) 1.1.
+**W3C XSD 1.1 parser, builder, and TypeScript type inference** — a 1:1 TypeScript representation of XML Schema Definition.
 
-## Overview
+## Why
 
-`ts-xsd` is a comprehensive TypeScript library for working with W3C XSD schemas. It provides:
+Working with XSD schemas in TypeScript usually means hand-maintaining types that drift from the source of truth. `ts-xsd` closes that gap:
 
-| Module      | Purpose                                                             |
-| ----------- | ------------------------------------------------------------------- |
-| **xsd**     | Parse XSD files into typed `Schema` objects, build XSD from objects |
-| **infer**   | Compile-time TypeScript type inference from schema literals         |
-| **xml**     | Parse/build XML documents using schema definitions                  |
-| **codegen** | Generate TypeScript schema literals from XSD files                  |
-
-### Key Features
-
-- **Pure W3C XSD 1.1** - Types match the official [XMLSchema.xsd](https://www.w3.org/TR/xmlschema11-1/XMLSchema.xsd) exactly
-- **Full roundtrip** - `XSD → Schema → XSD` with semantic preservation
-- **Type inference** - `InferSchema<T>` extracts TypeScript types from schema literals
-- **Shared types** - Cross-schema type resolution via `$imports`
-- **Tree-shakeable** - Only import what you need
-- **Zero runtime dependencies** - Only `@xmldom/xmldom` for DOM parsing
+- **Parse** any W3C XSD 1.1 schema into a typed `Schema` object — no invented properties, no shortcuts.
+- **Infer** TypeScript types at compile time from schema literals via `InferSchema<T>`.
+- **Generate** TypeScript interfaces at build time when schemas are too complex for compile-time inference.
+- **Round-trip** `XSD → Schema → XSD` with semantic preservation.
+- **Parse/build XML** documents against a schema definition.
 
 ## Installation
 
 ```bash
 npm install @abapify/ts-xsd
 # or
+pnpm add @abapify/ts-xsd
+# or
 bun add @abapify/ts-xsd
 ```
 
+> **Runtime dependency:** `@xmldom/xmldom` (DOM parsing). `ts-morph` and `zod` are required for codegen features.
+
 ## Quick Start
 
 ### Parse and Build XSD
@@ -61,7 +56,6 @@ const xsd = buildXsd(schema, { pretty: true });
 ```typescript
 import type { InferSchema } from '@abapify/ts-xsd';
 
-// Define schema as const literal
 const personSchema = {
   element: [{ name: 'person', type: 'PersonType' }],
   complexType: [
@@ -77,22 +71,38 @@ const personSchema = {
   ],
 } as const;
 
-// Infer TypeScript type at compile time
+// Infer TypeScript type at compile time — no runtime cost
 type Person = InferSchema<typeof personSchema>;
-// Result: { name: string; age?: number }
+// => { name: string; age?: number }
 ```
 
-### Parse XML with Schema
+### Parse and Build XML with a Schema
 
 ```typescript
 import { parseXml, buildXml } from '@abapify/ts-xsd';
 
 const xml = `<person><name>John</name><age>30</age></person>`;
 const data = parseXml(personSchema, xml);
-// data: { name: 'John', age: 30 }
+// => { person: { name: 'John', age: 30 } }
+
+const rebuilt = buildXml(personSchema, data, { xmlDecl: false });
+// => <person><name>John</name><age>30</age></person>
+```
+
+### Generate TypeScript Interfaces from XSD
+
+```typescript
+import { parseXsd, generateInterfaces } from '@abapify/ts-xsd';
+
+const schema = parseXsd(xsdContent);
+const { code } = generateInterfaces(schema, {
+  flatten: true, // Inline all nested types into one
+  addJsDoc: true, // Add JSDoc comments
+  rootTypeName: 'MySchema',
+});
 
-const rebuilt = buildXml(personSchema, data);
-// rebuilt: <person><name>John</name><age>30</age></person>
+// code is a ready-to-write .ts file:
+// export type MySchema = { person: { name: string; age?: number } };
 ```
 
 ## API Reference
@@ -100,39 +110,49 @@ const rebuilt = buildXml(personSchema, data);
 ### XSD Module
 
 ```typescript
-import { parseXsd, buildXsd, type Schema } from '@abapify/ts-xsd';
+import {
+  parseXsd,
+  buildXsd,
+  resolveImports,
+  loadSchema,
+  type Schema,
+} from '@abapify/ts-xsd';
 ```
 
 #### `parseXsd(xsd: string): Schema`
 
-Parse an XSD XML string into a typed Schema object.
-
-```typescript
-const schema = parseXsd(xsdString);
-console.log(schema.targetNamespace);
-console.log(schema.element?.[0].name);
-```
+Parse an XSD XML string into a typed `Schema` object.
 
 #### `buildXsd(schema: Schema, options?: BuildOptions): string`
 
-Build an XSD XML string from a Schema object.
+Build an XSD XML string from a `Schema` object.
 
 ```typescript
 const xsd = buildXsd(schema, {
-  prefix: 'xsd', // Namespace prefix (default: 'xs')
+  prefix: 'xs', // Namespace prefix (default: 'xs')
   pretty: true, // Pretty print (default: true)
-  indent: '  ', // Indentation (default: '  ')
+  indent: '  ', // Indentation string
 });
 ```
 
-#### `resolveImports(schema: Schema, resolver: (location: string) => Schema): Schema`
+#### `resolveImports(schema, availableSchemas): Schema`
 
-Resolve and link imported schemas for cross-schema type resolution.
+Resolve and link imported schemas by matching `import.schemaLocation` to `$filename`. Returns a new schema with `$imports` populated.
 
 ```typescript
-const linkedSchema = resolveImports(schema, (location) => {
-  return parseXsd(fs.readFileSync(location, 'utf-8'));
-});
+const base = { ...parseXsd(baseXsd), $filename: 'base.xsd' };
+const orders = { ...parseXsd(ordersXsd), $filename: 'orders.xsd' };
+
+const linked = resolveImports(orders, [base]);
+// linked.$imports = [base]
+```
+
+#### `loadSchema(schemaPath: string, options?: LoaderOptions): Schema`
+
+Load and parse an XSD file from disk. Synchronous. Set `autoLink: true` to automatically resolve imports, or `autoResolve: true` to merge everything into one schema.
+
+```typescript
+const schema = loadSchema('/path/to/schema.xsd', { autoLink: true });
 ```
 
 ### Infer Module
@@ -143,15 +163,11 @@ import type { InferSchema, InferElement, SchemaLike } from '@abapify/ts-xsd';
 
 #### `InferSchema<T>`
 
-Infer TypeScript type from a schema literal. Returns union of all root element types.
-
-```typescript
-type Data = InferSchema<typeof mySchema>;
-```
+Infer a TypeScript type from a schema literal (`as const`). Returns a union of all root element types.
 
-#### `InferElement<T, ElementName>`
+#### `InferElement<T, Name>`
 
-Infer type for a specific element by name.
+Infer the type for a specific root element by name.
 
 ```typescript
 type Person = InferElement<typeof schema, 'person'>;
@@ -174,13 +190,13 @@ type Person = InferElement<typeof schema, 'person'>;
 import { parseXml, buildXml } from '@abapify/ts-xsd';
 ```
 
-#### `parseXml<T>(schema: SchemaLike, xml: string): T`
+#### `parseXml<T>(schema, xml: string): T`
 
-Parse XML string using schema definition.
+Parse an XML string into a typed object using a schema definition.
 
-#### `buildXml<T>(schema: SchemaLike, data: T): string`
+#### `buildXml<T>(schema, data: T, options?: XmlBuildOptions): string`
 
-Build XML string from data using schema definition.
+Build an XML string from a typed object using a schema definition. Defaults to `xmlDecl: true` (includes `<?xml ...?>` declaration); pass `{ xmlDecl: false }` for bare output.
 
 ### Codegen Module
 
@@ -188,41 +204,88 @@ Build XML string from data using schema definition.
 import { generateSchemaLiteral, generateInterfaces } from '@abapify/ts-xsd';
 ```
 
-#### `generateSchemaLiteral(xsd: string, options?: GenerateOptions): string`
+#### `generateSchemaLiteral(xsd: string, options?): string`
 
-Generate TypeScript schema literal from XSD content.
+Generate a TypeScript `as const` schema literal from XSD content — for use with `InferSchema<T>`.
 
 ```typescript
 const code = generateSchemaLiteral(xsdContent, {
   name: 'PersonSchema',
-  features: { $xmlns: true, $imports: true },
+  features: { $xmlns: true, $filename: true },
   exclude: ['annotation'],
 });
-// export default { ... } as const;
+// export const PersonSchema = { ... } as const;
 ```
 
-#### `generateInterfaces(schema: Schema, options?: GenerateInterfacesOptions): GenerateInterfacesResult`
+#### `generateInterfaces(schema: Schema, options?): { code: string }`
 
-Generate TypeScript interfaces from parsed schema. Returns an object with `code` property containing the generated TypeScript code.
+Generate TypeScript interfaces from a parsed schema. Useful when schemas are too complex for compile-time `InferSchema<T>` (TypeScript TS2589 recursion limits).
 
 ```typescript
 const { code } = generateInterfaces(schema, {
   flatten: true, // Inline all nested types (default: false)
-  addJsDoc: true, // Add JSDoc comments
-  rootTypeName: 'MySchema', // Custom root type name
+  addJsDoc: true, // JSDoc comments
+  rootTypeName: 'MySchema',
+});
+```
+
+| Option         | Type      | Default | Description                      |
+| -------------- | --------- | ------- | -------------------------------- |
+| `flatten`      | `boolean` | `false` | Inline all nested types into one |
+| `addJsDoc`     | `boolean` | `false` | Add JSDoc comments               |
+| `rootTypeName` | `string`  | auto    | Custom name for the root type    |
+
+### CLI
+
+The package ships a CLI for code generation:
+
+```bash
+# Config-based (recommended) — uses ts-xsd.config.ts in cwd
+npx ts-xsd codegen
+
+# Single-file mode
+npx ts-xsd codegen person.xsd
+npx ts-xsd codegen person.xsd ./generated/person-schema.ts
+npx ts-xsd codegen person.xsd --name=PersonSchema
+```
+
+### Config-Based Generation
+
+For multi-schema projects, use the composable generator system:
+
+```typescript
+import {
+  defineConfig,
+  rawSchema,
+  interfaces,
+} from '@abapify/ts-xsd/generators';
+
+export default defineConfig({
+  sources: {
+    base: {
+      xsdDir: 'schemas',
+      outputDir: 'src/generated',
+      schemas: ['base'],
+    },
+    orders: {
+      xsdDir: 'schemas',
+      outputDir: 'src/generated',
+      schemas: ['orders'],
+      autoLink: true,
+    },
+  },
+  generators: [rawSchema(), interfaces({ flatten: true })],
 });
 ```
 
 ## Schema Structure
 
-The `Schema` type is a 1:1 TypeScript representation of W3C XSD:
+The `Schema` type is a 1:1 TypeScript representation of W3C XSD. Non-W3C extension properties are prefixed with `$`:
 
 ```typescript
 interface Schema {
-  // Namespace
   targetNamespace?: string;
   elementFormDefault?: 'qualified' | 'unqualified';
-  attributeFormDefault?: 'qualified' | 'unqualified';
 
   // Composition
   import?: Import[];
@@ -236,171 +299,40 @@ interface Schema {
   attributeGroup?: NamedAttributeGroup[];
 
   // Extensions (non-W3C, prefixed with $)
-  $xmlns?: { [prefix: string]: string };
-  $imports?: Schema[]; // Resolved imported schemas
-  $filename?: string; // Source filename
+  $xmlns?: { [prefix: string]: string }; // Namespace prefix mappings
+  $imports?: Schema[]; // Linked imported schemas
+  $filename?: string; // Source filename (for round-trip)
 }
 ```
 
 ### Cross-Schema Type Resolution
 
-Link schemas together for cross-schema type resolution:
-
-```typescript
-const adtcore = parseXsd(adtcoreXsd);
-const classes = parseXsd(classesXsd);
-
-// Link schemas via $imports
-const linkedClasses = {
-  ...classes,
-  $imports: [adtcore],
-};
-
-// Now InferSchema can resolve types from adtcore
-type AbapClass = InferSchema<typeof linkedClasses>;
-```
-
-## Type Inference Deep Dive
-
-### How It Works
-
-The type inference system uses TypeScript's conditional types to:
-
-1. **Find root elements** - Extract element declarations from schema
-2. **Resolve type references** - Look up `complexType` and `simpleType` by name
-3. **Handle inheritance** - Process `complexContent/extension` for type inheritance
-4. **Map XSD to TS** - Convert XSD types to TypeScript equivalents
-5. **Handle optionality** - `minOccurs="0"` → optional property
-6. **Handle arrays** - `maxOccurs="unbounded"` → array type
-
-### Example: Complex Schema
+Link schemas via `$imports` to resolve types across schema boundaries:
 
 ```typescript
-const schema = {
-  $imports: [baseSchema],
-  element: [{ name: 'order', type: 'OrderType' }],
-  complexType: [
-    {
-      name: 'OrderType',
-      complexContent: {
-        extension: {
-          base: 'base:BaseEntity', // Inherits from imported schema
-          sequence: {
-            element: [
-              { name: 'items', type: 'ItemType', maxOccurs: 'unbounded' },
-              { name: 'total', type: 'xs:decimal' },
-            ],
-          },
-        },
-      },
-    },
-    {
-      name: 'ItemType',
-      sequence: {
-        element: [
-          { name: 'sku', type: 'xs:string' },
-          { name: 'quantity', type: 'xs:int' },
-        ],
-      },
-    },
-  ],
-} as const;
-
-type Order = InferSchema<typeof schema>;
-// Result:
-// {
-//   ...BaseEntity,  // Inherited properties
-//   items: { sku: string; quantity: number }[];
-//   total: number;
-// }
-```
+const base = { ...parseXsd(baseXsd), $filename: 'base.xsd' };
+const orders = { ...parseXsd(ordersXsd), $filename: 'orders.xsd' };
 
-## Architecture
+const linked = resolveImports(orders, [base]);
 
+// InferSchema can now resolve types from `base`
+type OrderData = InferSchema<typeof linked>;
 ```
-@abapify/ts-xsd
-├── src/
-│   ├── index.ts           # Main exports
-│   ├── xsd/               # XSD parsing, building, resolution
-│   │   ├── types.ts       # W3C 1:1 type definitions
-│   │   ├── parse.ts       # XSD XML → Schema parser
-│   │   ├── build.ts       # Schema → XSD XML builder
-│   │   ├── resolve.ts     # Schema resolver (merges imports, expands inheritance)
-│   │   ├── traverser.ts   # OO schema traversal with W3C types
-│   │   ├── loader.ts      # XSD file loading with import resolution
-│   │   ├── schema-like.ts # Runtime schema type guards
-│   │   └── helpers.ts     # Utility functions
-│   ├── infer/             # Compile-time type inference
-│   │   └── types.ts       # InferSchema<T>, InferElement<T>
-│   ├── xml/               # XML parsing/building with schemas
-│   │   ├── parse.ts       # XML → Object parser
-│   │   ├── build.ts       # Object → XML builder
-│   │   ├── typed.ts       # Typed schema wrapper
-│   │   └── dom-utils.ts   # DOM manipulation utilities
-│   ├── walker/            # Schema traversal utilities
-│   │   └── index.ts       # walkElements, walkComplexTypes, findSubstitutes
-│   ├── codegen/           # Code generation
-│   │   ├── generate.ts    # Schema literal generator
-│   │   ├── interface-generator.ts  # Interface generator API
-│   │   ├── ts-morph.ts    # TypeScript AST manipulation
-│   │   ├── runner.ts      # Config-based codegen runner
-│   │   └── cli.ts         # CLI interface
-│   └── generators/        # Generator plugins
-│       ├── raw-schema.ts  # Schema literal generator
-│       ├── interfaces.ts  # TypeScript interfaces generator
-│       ├── typed-schemas.ts # Typed schema exports
-│       └── index-barrel.ts # Index file generator
-```
-
-### Key Components
-
-| Component     | Purpose                                                                            |
-| ------------- | ---------------------------------------------------------------------------------- |
-| **Resolver**  | Merges `$imports`, expands `complexContent/extension`, handles `substitutionGroup` |
-| **Traverser** | OO traversal with real W3C XSD types (SchemaTraverser class)                       |
-| **Walker**    | Functional iteration over schema elements, types, groups                           |
-| **Loader**    | File-based XSD loading with automatic import resolution                            |
 
 ## Design Principles
 
-1. **Pure W3C XSD** - No invented properties or conveniences
-2. **Type safety** - Full TypeScript support with inference
-3. **Minimal dependencies** - Only `@xmldom/xmldom`
-4. **Tree-shakeable** - Import only what you need
-5. **Tested against W3C** - Verified with official XMLSchema.xsd
-
-## Testing
-
-```bash
-# Run all tests
-npx nx test ts-xsd
-
-# Run with coverage
-npx nx test:coverage ts-xsd
-```
-
-Tests include:
-
-- Unit tests for parser, builder, and inference
-- Integration tests with real XSD files
-- W3C XMLSchema.xsd roundtrip verification
-
-## Related Packages
-
-- **[@abapify/adt-schemas](../adt-schemas)** - SAP ADT schemas using ts-xsd
-- **[@abapify/adt-contracts](../adt-contracts)** - REST contracts for SAP ADT APIs
-- **[@abapify/adt-plugin-abapgit](../adt-plugin-abapgit)** - abapGit plugin schemas
-
-## Documentation
-
-- **[Codegen Guide](./docs/codegen.md)** - Comprehensive code generation documentation
-- **[AGENTS.md](./AGENTS.md)** - AI agent guidelines
+1. **Pure W3C XSD 1.1** — types match the official [XMLSchema.xsd](https://www.w3.org/TR/xmlschema11-1/XMLSchema.xsd) exactly; no invented properties.
+2. **Type-safe** — full TypeScript support with compile-time inference.
+3. **Minimal dependencies** — `@xmldom/xmldom` for DOM parsing, `ts-morph` and `zod` for codegen.
+4. **Tree-shakeable** — import only what you need.
+5. **Round-trip verified** — tested against the official W3C XMLSchema.xsd.
 
 ## References
 
 - [W3C XML Schema 1.1 Part 1: Structures](https://www.w3.org/TR/xmlschema11-1/)
 - [XMLSchema.xsd](https://www.w3.org/TR/xmlschema11-1/XMLSchema.xsd)
+- [Codegen Guide](https://github.com/abapify/adt-cli/tree/main/packages/ts-xsd/docs/codegen.md)
 
 ## License
 
-MIT
+[MIT](https://github.com/abapify/adt-cli/blob/main/LICENSE)

package/dist/codegen/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/codegen/cli.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { t as runCodegen } from "../runner-BSGqj8LM.mjs";
+import { t as generateSchemaFile } from "../generate-Br6rW6sE.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region src/codegen/cli.ts
+/**
+* ts-xsd Codegen CLI
+*
+* Usage:
+*   ts-xsd codegen [--config=ts-xsd.config.ts] [--verbose]
+*   ts-xsd codegen <input.xsd> [output.ts] [--name=SchemaName]
+*
+* Config-based (recommended):
+*   ts-xsd codegen                          # Uses ts-xsd.config.ts in cwd
+*   ts-xsd codegen --config=my-config.ts    # Uses custom config
+*   ts-xsd codegen --verbose                # Verbose output
+*
+* Single-file (legacy):
+*   ts-xsd codegen person.xsd
+*   ts-xsd codegen person.xsd ./generated/person-schema.ts
+*   ts-xsd codegen person.xsd --name=PersonSchema
+*/
+function parseArgs(args) {
+	const positional = [];
+	let config;
+	let verbose = false;
+	let name;
+	for (const arg of args) if (arg.startsWith("--config=")) config = arg.slice(9);
+	else if (arg === "--verbose" || arg === "-v") verbose = true;
+	else if (arg.startsWith("--name=")) name = arg.slice(7);
+	else if (!arg.startsWith("-")) positional.push(arg);
+	if (positional[0]?.endsWith(".xsd")) {
+		const input = positional[0];
+		const defaultOutput = input.replace(/\.xsd$/i, "-schema.ts");
+		const output = positional[1] || defaultOutput;
+		const defaultName = basename(input, ".xsd").replaceAll(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (s) => s.toLowerCase()) + "Schema";
+		return {
+			mode: "single",
+			input: resolve(input),
+			output: resolve(output),
+			name: name || defaultName,
+			verbose
+		};
+	}
+	return {
+		mode: "config",
+		config: config || "ts-xsd.config.ts",
+		verbose
+	};
+}
+async function runConfigMode(options) {
+	const configPath = resolve(options.config);
+	if (!existsSync(configPath)) {
+		console.error(`❌ Config file not found: ${configPath}`);
+		console.error("\nCreate a ts-xsd.config.ts file or specify --config=path/to/config.ts");
+		process.exit(1);
+	}
+	console.log(`📦 Loading config: ${configPath}\n`);
+	const config = (await import(pathToFileURL(configPath).href)).default;
+	const result = await runCodegen(config, {
+		rootDir: dirname(configPath),
+		verbose: options.verbose
+	});
+	console.log(`\n📊 Summary:`);
+	console.log(`  - Schemas processed: ${result.schemas.length}`);
+	console.log(`  - Files generated: ${result.files.length}`);
+	console.log(`  - Errors: ${result.errors.length}`);
+	if (result.errors.length > 0) {
+		console.error("\n❌ Errors:");
+		for (const err of result.errors) console.error(`  - ${err.schema || "unknown"}: ${err.error.message}`);
+		process.exit(1);
+	}
+	console.log("\n✅ Codegen complete!");
+}
+function runSingleFileMode(options) {
+	console.log(`Reading: ${options.input}`);
+	const xsdContent = readFileSync(options.input, "utf-8");
+	console.log(`Generating schema: ${options.name}`);
+	const tsContent = generateSchemaFile(xsdContent, {
+		name: options.name,
+		comment: `Source: ${basename(options.input)}`
+	});
+	mkdirSync(dirname(options.output), { recursive: true });
+	console.log(`Writing: ${options.output}`);
+	writeFileSync(options.output, tsContent);
+	console.log(`Done! Generated ${tsContent.length} characters`);
+	console.log(`\nUsage in TypeScript:`);
+	console.log(`  import { ${options.name} } from './${basename(options.output, ".ts")}';`);
+	console.log(`  import type { InferSchema } from '@abapify/ts-xsd';`);
+	console.log(`  type MyType = InferSchema<typeof ${options.name}>;`);
+}
+function showHelp() {
+	console.log(`
+ts-xsd Codegen CLI
+
+Usage:
+  ts-xsd codegen [options]              Config-based generation (recommended)
+  ts-xsd codegen <input.xsd> [output]   Single-file generation (legacy)
+
+Options:
+  --config=FILE   Config file path (default: ts-xsd.config.ts)
+  --verbose, -v   Verbose output
+  --name=NAME     Schema variable name (single-file mode only)
+  --help, -h      Show this help
+
+Examples:
+  # Config-based (recommended)
+  ts-xsd codegen                          # Uses ts-xsd.config.ts
+  ts-xsd codegen --config=my-config.ts    # Custom config
+  ts-xsd codegen --verbose                # With verbose output
+
+  # Single-file (legacy)
+  ts-xsd codegen person.xsd
+  ts-xsd codegen person.xsd ./out/person.ts --name=PersonSchema
+`);
+}
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.includes("--help") || args.includes("-h")) {
+		showHelp();
+		process.exit(0);
+	}
+	const options = parseArgs(args);
+	if (options.mode === "config") await runConfigMode(options);
+	else runSingleFileMode(options);
+}
+main().catch((err) => {
+	console.error("Fatal error:", err);
+	process.exit(1);
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map

package/dist/codegen/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../../src/codegen/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * ts-xsd Codegen CLI\n *\n * Usage:\n *   ts-xsd codegen [--config=ts-xsd.config.ts] [--verbose]\n *   ts-xsd codegen <input.xsd> [output.ts] [--name=SchemaName]\n *\n * Config-based (recommended):\n *   ts-xsd codegen                          # Uses ts-xsd.config.ts in cwd\n *   ts-xsd codegen --config=my-config.ts    # Uses custom config\n *   ts-xsd codegen --verbose                # Verbose output\n *\n * Single-file (legacy):\n *   ts-xsd codegen person.xsd\n *   ts-xsd codegen person.xsd ./generated/person-schema.ts\n *   ts-xsd codegen person.xsd --name=PersonSchema\n */\n\nimport { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';\nimport { dirname, basename, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { generateSchemaFile } from './generate';\nimport { runCodegen } from './runner';\nimport type { CodegenConfig } from './types';\n\ninterface ConfigModeOptions {\n  mode: 'config';\n  config: string;\n  verbose?: boolean;\n}\n\ninterface SingleFileModeOptions {\n  mode: 'single';\n  input: string;\n  output: string;\n  name: string;\n  verbose?: boolean;\n}\n\ntype CliOptions = ConfigModeOptions | SingleFileModeOptions;\n\nfunction parseArgs(args: string[]): CliOptions {\n  const positional: string[] = [];\n  let config: string | undefined;\n  let verbose = false;\n  let name: string | undefined;\n\n  for (const arg of args) {\n    if (arg.startsWith('--config=')) {\n      config = arg.slice(9);\n    } else if (arg === '--verbose' || arg === '-v') {\n      verbose = true;\n    } else if (arg.startsWith('--name=')) {\n      name = arg.slice(7);\n    } else if (!arg.startsWith('-')) {\n      positional.push(arg);\n    }\n  }\n\n  // If first positional arg is an XSD file, use single-file mode\n  if (positional[0]?.endsWith('.xsd')) {\n    const input = positional[0];\n    const defaultOutput = input.replace(/\\.xsd$/i, '-schema.ts');\n    const output = positional[1] || defaultOutput;\n    const defaultName =\n      basename(input, '.xsd')\n        .replaceAll(/[-_\\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))\n        .replace(/^./, (s) => s.toLowerCase()) + 'Schema';\n\n    return {\n      mode: 'single',\n      input: resolve(input),\n      output: resolve(output),\n      name: name || defaultName,\n      verbose,\n    };\n  }\n\n  // Config-based mode\n  return {\n    mode: 'config',\n    config: config || 'ts-xsd.config.ts',\n    verbose,\n  };\n}\n\nasync function runConfigMode(options: ConfigModeOptions) {\n  const configPath = resolve(options.config);\n\n  if (!existsSync(configPath)) {\n    console.error(`❌ Config file not found: ${configPath}`);\n    console.error(\n      '\\nCreate a ts-xsd.config.ts file or specify --config=path/to/config.ts',\n    );\n    process.exit(1);\n  }\n\n  console.log(`📦 Loading config: ${configPath}\\n`);\n\n  // Dynamic import of config file\n  const configUrl = pathToFileURL(configPath).href;\n  const configModule = await import(configUrl);\n  const config: CodegenConfig = configModule.default;\n\n  const result = await runCodegen(config, {\n    rootDir: dirname(configPath),\n    verbose: options.verbose,\n  });\n\n  console.log(`\\n📊 Summary:`);\n  console.log(`  - Schemas processed: ${result.schemas.length}`);\n  console.log(`  - Files generated: ${result.files.length}`);\n  console.log(`  - Errors: ${result.errors.length}`);\n\n  if (result.errors.length > 0) {\n    console.error('\\n❌ Errors:');\n    for (const err of result.errors) {\n      console.error(`  - ${err.schema || 'unknown'}: ${err.error.message}`);\n    }\n    process.exit(1);\n  }\n\n  console.log('\\n✅ Codegen complete!');\n}\n\nfunction runSingleFileMode(options: SingleFileModeOptions) {\n  console.log(`Reading: ${options.input}`);\n  const xsdContent = readFileSync(options.input, 'utf-8');\n\n  console.log(`Generating schema: ${options.name}`);\n  const tsContent = generateSchemaFile(xsdContent, {\n    name: options.name,\n    comment: `Source: ${basename(options.input)}`,\n  });\n\n  mkdirSync(dirname(options.output), { recursive: true });\n\n  console.log(`Writing: ${options.output}`);\n  writeFileSync(options.output, tsContent);\n\n  console.log(`Done! Generated ${tsContent.length} characters`);\n  console.log(`\\nUsage in TypeScript:`);\n  console.log(\n    `  import { ${options.name} } from './${basename(options.output, '.ts')}';`,\n  );\n  console.log(`  import type { InferSchema } from '@abapify/ts-xsd';`);\n  console.log(`  type MyType = InferSchema<typeof ${options.name}>;`);\n}\n\nfunction showHelp() {\n  console.log(`\nts-xsd Codegen CLI\n\nUsage:\n  ts-xsd codegen [options]              Config-based generation (recommended)\n  ts-xsd codegen <input.xsd> [output]   Single-file generation (legacy)\n\nOptions:\n  --config=FILE   Config file path (default: ts-xsd.config.ts)\n  --verbose, -v   Verbose output\n  --name=NAME     Schema variable name (single-file mode only)\n  --help, -h      Show this help\n\nExamples:\n  # Config-based (recommended)\n  ts-xsd codegen                          # Uses ts-xsd.config.ts\n  ts-xsd codegen --config=my-config.ts    # Custom config\n  ts-xsd codegen --verbose                # With verbose output\n\n  # Single-file (legacy)\n  ts-xsd codegen person.xsd\n  ts-xsd codegen person.xsd ./out/person.ts --name=PersonSchema\n`);\n}\n\nasync function main() {\n  const args = process.argv.slice(2);\n\n  if (args.includes('--help') || args.includes('-h')) {\n    showHelp();\n    process.exit(0);\n  }\n\n  const options = parseArgs(args);\n\n  if (options.mode === 'config') {\n    await runConfigMode(options);\n  } else {\n    runSingleFileMode(options);\n  }\n}\n\nmain().catch((err) => {\n  console.error('Fatal error:', err);\n  process.exit(1);\n});\n"],"mappings":"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"}