@atomic-ehr/codegen 0.0.1-canary.20250822114054.4ca1428 → 0.0.1-canary.20250822150706.c3b8669

package/dist/api/index.js

@@ -0,0 +1,51 @@
+/**
+ * High-Level API Module
+ *
+ * Main entry point for the atomic-codegen high-level API.
+ * Provides convenient access to all generators and utilities.
+ *
+ * @packageDocumentation
+ */
+// Re-export core utilities
+export { TypeSchemaCache, TypeSchemaGenerator, TypeSchemaParser, } from "../typeschema/index.js";
+// Export main API builder and utilities
+export { APIBuilder, createAPI, createAPIFromConfig, generateTypesFromFiles, generateTypesFromPackage, } from "./builder.js";
+export { RestClientGenerator } from "./generators/rest-client.js";
+// Export generator classes for advanced usage
+export { TypeScriptGenerator } from "./generators/typescript.js";
+/**
+ * Quick start examples:
+ *
+ * @example
+ * Generate TypeScript types from a FHIR package:
+ * ```typescript
+ * import { createAPI } from '@atomic-codegen/api';
+ *
+ * const result = await createAPI()
+ *   .fromPackage('hl7.fhir.r4.core')
+ *   .typescript()
+ *   .generate();
+ * ```
+ *
+ * @example
+ * Generate TypeScript types from TypeSchema files:
+ * ```typescript
+ * import { createAPI } from '@atomic-codegen/api';
+ *
+ * const result = await createAPI()
+ *   .fromFiles('./schemas/*.ndjson')
+ *   .typescript()
+ *   .generate();
+ * ```
+ *
+ * @example
+ * Build in-memory without writing files:
+ * ```typescript
+ * import { createAPI } from '@atomic-codegen/api';
+ *
+ * const results = await createAPI()
+ *   .fromPackage('hl7.fhir.r4.core')
+ *   .typescript()
+ *   .build();
+ * ```
+ */

package/dist/cli/commands/generate/typescript.d.ts

@@ -3,7 +3,7 @@
  *
  * Generate TypeScript types from TypeSchema files using the new high-level API
  */
-import type { Config } from "../../../config";
+import type { Config } from "../../../config.js";
 /**
  * Generate TypeScript types from TypeSchema using the high-level API
  */

package/dist/cli/commands/generate/typescript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate/typescript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAiC9C;;GAEG;AACH,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAmDf"}
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/generate/typescript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAiCjD;;GAEG;AACH,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAmDf"}

package/dist/cli/commands/generate/typescript.js

@@ -0,0 +1,52 @@
+/**
+ * Generate TypeScript Command
+ *
+ * Generate TypeScript types from TypeSchema files using the new high-level API
+ */
+import { APIBuilder } from "../../../api/index.js";
+import { createLogger } from "../../utils/log.js";
+/**
+ * Generate TypeScript types from TypeSchema using the high-level API
+ */
+export async function generateTypeScript(config, inputPath) {
+    const log = createLogger({
+        verbose: config.verbose,
+        prefix: "TypeScript",
+    });
+    log.step("Generating TypeScript types using high-level API");
+    // Create API builder with config options
+    const builder = new APIBuilder({
+        outputDir: config.outputDir,
+        verbose: config.verbose,
+        overwrite: config.overwrite,
+        validate: config.validate,
+        cache: config.cache,
+    });
+    // Load TypeSchema from input path if provided
+    if (inputPath) {
+        log.info(`Loading TypeSchema from: ${inputPath}`);
+        builder.fromFiles(inputPath);
+    }
+    // Configure TypeScript generation with options from config
+    builder.typescript(config.typescript || {});
+    // Add progress callback if verbose
+    if (config.verbose) {
+        builder.onProgress((phase, current, total, message) => {
+            const progress = Math.round((current / total) * 100);
+            log.progress(`[${phase}] ${progress}% - ${message || "Processing..."}`);
+        });
+    }
+    // Execute the generation
+    const result = await builder.generate();
+    if (result.success) {
+        log.success(`Generated ${result.filesGenerated.length} TypeScript files in ${result.duration.toFixed(2)}ms`);
+        if (result.warnings.length > 0) {
+            log.warn(`${result.warnings.length} warnings found`);
+            result.warnings.forEach((warning) => log.dim(`  ${warning}`));
+        }
+    }
+    else {
+        log.error(`TypeScript generation failed: ${result.errors.join(", ")}`);
+        throw new Error(`TypeScript generation failed: ${result.errors.join(", ")}`);
+    }
+}

package/dist/cli/commands/generate.d.ts

@@ -1,22 +1,15 @@
 /**
- * Generate Command - High-Level API
+ * Generate Command - Config-Driven Generation
  *
- * Main generate command that uses the high-level API for end-to-end generation
+ * Main generate command that reads all configuration from the config file
+ * and executes generation based purely on config settings.
  */
 import type { CommandModule } from "yargs";
-import type { CLIArgv } from "./index";
+import type { CLIArgv } from "./index.js";
 interface GenerateArgs extends CLIArgv {
-    packages?: string[];
-    input?: string;
-    output?: string;
-    typescript?: boolean;
-    format?: "esm" | "cjs";
-    "generate-index"?: boolean;
-    "include-docs"?: boolean;
-    "naming-convention"?: "PascalCase" | "camelCase";
 }
 /**
- * Main generate command using high-level API
+ * Main generate command - fully config-driven
  */
 export declare const generateCommand: CommandModule<{}, GenerateArgs>;
 export {};

package/dist/cli/commands/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/generate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,UAAU,YAAa,SAAQ,OAAO;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mBAAmB,CAAC,EAAE,YAAY,GAAG,WAAW,CAAC;CACjD;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,EAAE,EAAE,YAAY,CA0N3D,CAAC"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/generate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAI3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,UAAU,YAAa,SAAQ,OAAO;CAErC;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,EAAE,EAAE,YAAY,CAgL3D,CAAC"}

package/dist/cli/commands/generate.js

@@ -0,0 +1,158 @@
+/**
+ * Generate Command - Config-Driven Generation
+ *
+ * Main generate command that reads all configuration from the config file
+ * and executes generation based purely on config settings.
+ */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { APIBuilder } from "../../api/index.js";
+import { CONFIG_FILE_NAMES, loadConfig } from "../../config.js";
+import { createLogger, error, step, success, warn } from "../utils/log.js";
+/**
+ * Main generate command - fully config-driven
+ */
+export const generateCommand = {
+    command: "generate",
+    describe: "Generate code based on configuration file settings",
+    builder: (yargs) => yargs
+        .option("verbose", {
+        alias: "v",
+        type: "boolean",
+        default: false,
+        description: "Enable verbose output",
+    })
+        .example("$0 generate", "Generate code using settings from config file")
+        .example("$0 generate --verbose", "Generate with verbose output"),
+    handler: async (argv) => {
+        // Check if config file exists first
+        const workingDir = process.cwd();
+        const configPath = await findConfigFile(workingDir);
+        if (!configPath) {
+            const configFilesList = CONFIG_FILE_NAMES.map((name) => `  - ${name}`).join("\n");
+            error(`No configuration file found. Please create one of the following files in your project root:\n${configFilesList}\n\nExample atomic-codegen.config.ts:\n\n` +
+                `import { defineConfig } from '@atomic-ehr/codegen';\n\n` +
+                `export default defineConfig({\n` +
+                `  packages: ['hl7.fhir.r4.core@4.0.1'],\n` +
+                `  typescript: {\n` +
+                `    generateIndex: true\n` +
+                `  }\n` +
+                `});`);
+            process.exit(1);
+        }
+        // Load config file
+        const config = await loadConfig(workingDir);
+        const verbose = argv.verbose ?? config.verbose ?? false;
+        // Create logger for CLI command
+        const logger = createLogger({
+            verbose,
+            prefix: "Generate",
+        });
+        try {
+            step("Starting generation from config");
+            if (verbose) {
+                logger.info(`Config file: ${configPath}`);
+                logger.info(`Output directory: ${config.outputDir || "./generated"}`);
+                logger.info(`Packages: ${config.packages?.length || 0}`);
+                logger.info(`Files: ${config.files?.length || 0}`);
+                logger.info(`TypeScript generation: ${config.typescript ? "enabled" : "disabled"}`);
+                logger.info(`REST Client generation: ${config.restClient ? "enabled" : "disabled"}`);
+            }
+            // Create API builder with config options
+            const builder = new APIBuilder({
+                outputDir: config.outputDir || "./generated",
+                verbose,
+                overwrite: config.overwrite ?? true,
+                validate: config.validate ?? true,
+                cache: config.cache ?? true,
+                typeSchemaConfig: config.typeSchema,
+                logger,
+            });
+            // Load data sources from config
+            if (config.packages && config.packages.length > 0) {
+                logger.info(`Loading packages from config: ${config.packages.join(", ")}`);
+                for (const packageSpec of config.packages) {
+                    const [name, version] = packageSpec.includes("@")
+                        ? packageSpec.split("@")
+                        : [packageSpec, undefined];
+                    builder.fromPackage(name, version);
+                }
+            }
+            else if (config.files && config.files.length > 0) {
+                logger.info(`Loading files from config: ${config.files.join(", ")}`);
+                for (const file of config.files) {
+                    builder.fromFiles(file);
+                }
+            }
+            else {
+                throw new Error("No data source specified in config. Please configure 'packages' or 'files' in your config file.");
+            }
+            // Configure generators from config
+            if (config.typescript) {
+                if (verbose) {
+                    logger.info("Configuring TypeScript generation from config");
+                    logger.debug(`Module format: ${config.typescript.moduleFormat || "esm"}`);
+                    logger.debug(`Generate index: ${config.typescript.generateIndex ?? true}`);
+                    logger.debug(`Include docs: ${config.typescript.includeDocuments ?? false}`);
+                    logger.debug(`Naming convention: ${config.typescript.namingConvention || "PascalCase"}`);
+                }
+                builder.typescript(config.typescript);
+            }
+            if (config.restClient) {
+                if (verbose) {
+                    logger.info("Configuring REST Client generation from config");
+                    logger.debug(`Client name: ${config.restClient.clientName || "FHIRClient"}`);
+                    logger.debug(`Include validation: ${config.restClient.includeValidation ?? false}`);
+                    logger.debug(`Enhanced search: ${config.restClient.enhancedSearch ?? false}`);
+                }
+                builder.restClient(config.restClient);
+            }
+            // Check that at least one generator is configured
+            if (!config.typescript && !config.restClient) {
+                throw new Error("No generators configured. Please enable 'typescript' or 'restClient' in your config file.");
+            }
+            // Add progress callback if verbose
+            if (verbose) {
+                builder.onProgress((phase, current, total, message) => {
+                    const progress = Math.round((current / total) * 100);
+                    logger.progress(`[${phase}] ${progress}% - ${message || "Processing..."}`);
+                });
+            }
+            // Execute generation
+            logger.step("Executing generation...");
+            const result = await builder.generate();
+            if (result.success) {
+                success(`Generated ${result.filesGenerated.length} files in ${result.duration.toFixed(2)}ms`);
+                logger.dim(`Output directory: ${result.outputDir}`);
+                if (result.warnings.length > 0) {
+                    for (const warning of result.warnings) {
+                        warn(warning);
+                    }
+                }
+            }
+            else {
+                error(`Generation failed with ${result.errors.length} errors`);
+                for (const err of result.errors) {
+                    logger.dim(`  ${err}`);
+                }
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            error("Generation failed with unexpected error", err instanceof Error ? err : new Error(String(err)));
+            process.exit(1);
+        }
+    },
+};
+/**
+ * Helper function to find config file in the given directory
+ */
+async function findConfigFile(startDir) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+        const configPath = resolve(startDir, fileName);
+        if (existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}

package/dist/cli/commands/index.d.ts

@@ -4,6 +4,7 @@
  *
  * Modern CLI with subcommands for typeschema and code generation
  */
+import yargs from "yargs";
 /**
  * CLI arguments interface
  */
@@ -15,7 +16,7 @@ export interface CLIArgv {
 /**
  * Main CLI entry point with subcommands
  */
-export declare function createCLI(): import("yargs").Argv<{
+export declare function createCLI(): yargs.Argv<{
     verbose: boolean;
 } & {
     debug: boolean;

package/dist/cli/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":";AAEA;;;;GAIG;AAQH;;GAEG;AACH,MAAM,WAAW,OAAO;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAaD;;GAEG;AACH,wBAAgB,SAAS;;;;;;GA6FxB;AAED;;GAEG;AACH,wBAAsB,MAAM,kBAG3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":";AAEA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;GAEG;AACH,MAAM,WAAW,OAAO;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAaD;;GAEG;AACH,wBAAgB,SAAS;;;;;;GA4ExB;AAED;;GAEG;AACH,wBAAsB,MAAM,kBAG3B"}

package/dist/cli/commands/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env bun
+/**
+ * Atomic Codegen CLI - New Command Structure
+ *
+ * Modern CLI with subcommands for typeschema and code generation
+ */
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { configure, error, header } from "../utils/log.js";
+import { generateCommand } from "./generate.js";
+import { typeschemaCommand } from "./typeschema.js";
+/**
+ * Middleware to setup logging
+ */
+async function setupLoggingMiddleware(argv) {
+    // Configure the CliLogger with user preferences
+    configure({
+        verbose: argv.verbose || argv.debug,
+        timestamp: argv.debug,
+    });
+}
+/**
+ * Main CLI entry point with subcommands
+ */
+export function createCLI() {
+    return yargs(hideBin(process.argv))
+        .scriptName("atomic-codegen")
+        .usage("$0 <command> [options]")
+        .middleware(setupLoggingMiddleware)
+        .command(typeschemaCommand)
+        .command(generateCommand)
+        .option("verbose", {
+        alias: "v",
+        type: "boolean",
+        description: "Enable verbose output",
+        default: false,
+        global: true,
+    })
+        .option("debug", {
+        alias: "d",
+        type: "boolean",
+        description: "Enable debug output with detailed logging",
+        default: false,
+        global: true,
+    })
+        .option("config", {
+        alias: "c",
+        type: "string",
+        description: "Path to configuration file (.atomic-codegen.json by default)",
+        global: true,
+    })
+        .demandCommand(0) // Allow 0 commands so we can handle it ourselves
+        .middleware((argv) => {
+        // Check if no command was provided (only the script name in argv._)
+        if (argv._.length === 0) {
+            // Show available commands instead of error
+            header("Welcome to Atomic Codegen!");
+            console.log("Available commands:");
+            console.log("  typeschema   Generate, validate and merge TypeSchema files");
+            console.log("  generate     Generate code based on configuration file");
+            console.log("\nUse 'atomic-codegen <command> --help' for more information about a command.");
+            console.log("\nQuick examples:");
+            console.log("  atomic-codegen typeschema generate hl7.fhir.r4.core@4.0.1 -o schemas.ndjson");
+            console.log("  atomic-codegen generate  # Uses atomic-codegen.config.ts");
+            console.log("\nUse 'atomic-codegen --help' to see all options.");
+            process.exit(0);
+        }
+    })
+        .help()
+        .version("0.1.0")
+        .example("$0 generate", "Generate code using atomic-codegen.config.ts")
+        .example("$0 generate --verbose", "Generate with detailed progress output")
+        .example("$0 --config custom-config.ts generate", "Use custom configuration file")
+        .example("$0 typeschema generate hl7.fhir.r4.core@4.0.1 -o schemas.ndjson", "Generate TypeSchemas from FHIR package")
+        .fail((msg, err, _yargs) => {
+        if (err) {
+            error(err.message, err);
+        }
+        else {
+            error(msg);
+        }
+        error("\nUse --help for usage information");
+        process.exit(1);
+    })
+        .wrap(Math.min(120, process.stdout.columns || 80));
+}
+/**
+ * Run the CLI
+ */
+export async function runCLI() {
+    const cli = createCLI();
+    await cli.parseAsync();
+}
+// Run CLI if this file is executed directly
+if (import.meta.main) {
+    runCLI().catch((error) => {
+        error("Unexpected error:", error);
+        process.exit(1);
+    });
+}

package/dist/cli/commands/typeschema/generate.js

@@ -0,0 +1,130 @@
+/**
+ * TypeSchema Generate Command
+ *
+ * Generate TypeSchema files from FHIR packages
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { loadConfig } from "../../../config.js";
+import { TypeSchemaGenerator } from "../../../typeschema/generator.js";
+import { complete, createLogger, list } from "../../utils/log.js";
+/**
+ * Generate TypeSchema from FHIR packages
+ */
+export const generateTypeschemaCommand = {
+    command: "generate <packages..>",
+    describe: "Generate TypeSchema files from FHIR packages",
+    builder: {
+        packages: {
+            type: "string",
+            array: true,
+            demandOption: true,
+            describe: "FHIR packages to process (e.g., hl7.fhir.r4.core@4.0.1)",
+        },
+        output: {
+            alias: "o",
+            type: "string",
+            describe: "Output file or directory",
+            default: "./schemas.ndjson",
+        },
+        format: {
+            alias: "f",
+            type: "string",
+            choices: ["ndjson", "json"],
+            default: "ndjson",
+            describe: "Output format for TypeSchema files",
+        },
+        treeshake: {
+            alias: "t",
+            type: "string",
+            array: true,
+            describe: "Only generate TypeSchemas for specific ResourceTypes (treeshaking)",
+        },
+        singleFile: {
+            alias: "s",
+            type: "boolean",
+            default: false,
+            describe: "Generate single TypeSchema file instead of multiple files (NDJSON format)",
+        },
+        verbose: {
+            alias: "v",
+            type: "boolean",
+            default: false,
+            describe: "Enable verbose output",
+        },
+    },
+    handler: async (argv) => {
+        const log = createLogger({
+            verbose: argv.verbose,
+            prefix: "TypeSchema",
+        });
+        try {
+            // Load configuration from file
+            const config = await loadConfig(process.cwd());
+            log.step("Generating TypeSchema from FHIR packages");
+            log.info(`Packages: ${argv.packages.join(", ")}`);
+            log.info(`Output: ${argv.output}`);
+            // Merge singleFile options: CLI args take precedence over config file
+            const singleFileOption = argv.singleFile !== undefined
+                ? argv.singleFile
+                : (config.typeSchema?.singleFile ?? false);
+            const outputFormat = singleFileOption ? "ndjson" : argv.format;
+            log.debug(`Format: ${outputFormat}${singleFileOption && argv.format === "json" ? " (forced from json due to singleFile)" : ""}`);
+            // Merge treeshake options: CLI args take precedence over config file
+            const treeshakeOptions = argv.treeshake && argv.treeshake.length > 0
+                ? argv.treeshake
+                : config.typeSchema?.treeshake;
+            if (treeshakeOptions && treeshakeOptions.length > 0) {
+                log.info(`Treeshaking enabled for ResourceTypes: ${treeshakeOptions.join(", ")}`);
+            }
+            if (singleFileOption) {
+                log.info("Single file output enabled (NDJSON format)");
+            }
+            const startTime = Date.now();
+            // Create TypeSchema generator
+            const generator = new TypeSchemaGenerator({
+                verbose: argv.verbose,
+                treeshake: treeshakeOptions,
+            });
+            // Generate schemas from all packages
+            const allSchemas = [];
+            for (const packageSpec of argv.packages) {
+                const [name, version] = packageSpec.includes("@")
+                    ? packageSpec.split("@")
+                    : [packageSpec, undefined];
+                log.progress(`Processing package: ${name}${version ? `@${version}` : ""}`);
+                const schemas = await generator.generateFromPackage(name, version);
+                allSchemas.push(...schemas);
+            }
+            if (allSchemas.length === 0) {
+                throw new Error("No schemas were generated from the specified packages");
+            }
+            // Use the output format determined earlier
+            // Ensure output directory exists
+            const outputPath = argv.output;
+            await mkdir(dirname(outputPath), { recursive: true });
+            // Format and write the schemas
+            let content;
+            if (outputFormat === "json") {
+                content = JSON.stringify(allSchemas, null, 2);
+            }
+            else {
+                // NDJSON format (default for single file)
+                content = allSchemas.map((schema) => JSON.stringify(schema)).join("\n");
+            }
+            await writeFile(outputPath, content, "utf-8");
+            const duration = Date.now() - startTime;
+            complete(`Generated ${allSchemas.length} TypeSchema definitions`, duration, { schemas: allSchemas.length });
+            log.dim(`Output: ${outputPath}`);
+            if (argv.verbose) {
+                log.debug("Generated schemas:");
+                const schemaNames = allSchemas.map((schema) => `${schema.identifier?.name || "Unknown"} (${schema.identifier?.kind || "unknown"})`);
+                list(schemaNames);
+            }
+        }
+        catch (error) {
+            log.error("Failed to generate TypeSchema", error instanceof Error ? error : new Error(String(error)));
+            process.exit(1);
+        }
+    },
+};

package/dist/cli/commands/typeschema.js

@@ -0,0 +1,48 @@
+/**
+ * TypeSchema Commands
+ *
+ * Commands for validating and managing TypeSchema files
+ */
+import { error, info, list } from "../utils/log.js";
+import { generateTypeschemaCommand } from "./typeschema/generate.js";
+/**
+ * TypeSchema command group
+ */
+export const typeschemaCommand = {
+    command: "typeschema [subcommand]",
+    describe: "TypeSchema operations - generate, validate and merge schemas",
+    builder: (yargs) => {
+        return yargs
+            .command(generateTypeschemaCommand)
+            .help()
+            .example("$0 typeschema generate hl7.fhir.r4.core@4.0.1", "Generate TypeSchema from FHIR R4 core package");
+    },
+    handler: (argv) => {
+        // If no subcommand provided, show available subcommands
+        if (!argv.subcommand && argv._.length === 1) {
+            info("Available typeschema subcommands:");
+            list(["generate    Generate TypeSchema files from FHIR packages"]);
+            console.log("\nUse 'atomic-codegen typeschema <subcommand> --help' for more information about a subcommand.");
+            console.log("\nExamples:");
+            list([
+                "atomic-codegen typeschema generate hl7.fhir.r4.core@4.0.1 -o schemas.ndjson",
+                "atomic-codegen typeschema validate schemas.ndjson",
+                "atomic-codegen typeschema merge schema1.ndjson schema2.ndjson -o merged.ndjson",
+            ]);
+            return;
+        }
+        // If unknown subcommand provided, show error and available commands
+        if (argv.subcommand &&
+            !["generate", "validate", "merge"].includes(argv.subcommand)) {
+            error(`Unknown typeschema subcommand: ${argv.subcommand}\n`);
+            info("Available typeschema subcommands:");
+            list([
+                "generate    Generate TypeSchema files from FHIR packages",
+                "validate    Validate TypeSchema files for correctness and consistency",
+                "merge       Merge multiple TypeSchema files into a single file",
+            ]);
+            console.log("\nUse 'atomic-codegen typeschema <subcommand> --help' for more information about a subcommand.");
+            process.exit(1);
+        }
+    },
+};