@atomic-ehr/codegen 0.0.1-canary.20251006092200.fdb4a88 → 0.0.1-canary.20251006094042.7f0be72

package/dist/api/index.d.ts

@@ -1,51 +0,0 @@
-/**
- * High-Level API Module
- *
- * Main entry point for the atomic-codegen high-level API.
- * Provides convenient access to all generators and utilities.
- *
- * @packageDocumentation
- */
-export { TypeSchemaCache, TypeSchemaGenerator, TypeSchemaParser, } from "@typeschema/index";
-export type { Field as TypeSchemaField, Identifier as TypeSchemaIdentifier, PackageMeta as PackageInfo, TypeSchema, } from "@typeschema/types";
-export type { APIBuilderOptions, GenerationResult, ProgressCallback, } from "./builder";
-export { APIBuilder, createAPI, createAPIFromConfig, generateTypesFromFiles, generateTypesFromPackage, } from "./builder";
-export type { GeneratedFile } from "./generators/base/index";
-export type { TypeScriptGeneratorOptions } from "./generators/typescript";
-export { TypeScriptGenerator } from "./generators/typescript";
-/**
- * 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/api/index.js

@@ -1,50 +0,0 @@
-/**
- * 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";
-// Export main API builder and utilities
-export { APIBuilder, createAPI, createAPIFromConfig, generateTypesFromFiles, generateTypesFromPackage, } from "./builder";
-// Export generator classes for advanced usage
-export { TypeScriptGenerator } from "./generators/typescript";
-/**
- * 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

@@ -1,10 +0,0 @@
-/**
- * Generate TypeScript Command
- *
- * Generate TypeScript types from TypeSchema files using the new high-level API
- */
-import type { Config } from "../../../config";
-/**
- * Generate TypeScript types from TypeSchema using the high-level API
- */
-export declare function generateTypeScript(config: Config, inputPath?: string): Promise<void>;

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

@@ -1,52 +0,0 @@
-/**
- * Generate TypeScript Command
- *
- * Generate TypeScript types from TypeSchema files using the new high-level API
- */
-import { APIBuilder } from "../../../api/index";
-import { createLogger } from "../../utils/log";
-/**
- * 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,15 +0,0 @@
-/**
- * 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 type { CommandModule } from "yargs";
-import type { CLIArgv } from "./index";
-interface GenerateArgs extends CLIArgv {
-}
-/**
- * Main generate command - fully config-driven
- */
-export declare const generateCommand: CommandModule<Record<string, unknown>, GenerateArgs>;
-export {};

package/dist/cli/commands/generate.js

@@ -1,159 +0,0 @@
-/**
- * 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";
-import { CONFIG_FILE_NAMES, loadConfig } from "../../config";
-import { createLogger, error, step, success, warn } from "../utils/log";
-/**
- * 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 for old command syntax and provide helpful error
-        if (argv._.length > 1) {
-            const extraArgs = argv._.slice(1).join(" ");
-            error(`Invalid syntax: 'atomic-codegen generate ${extraArgs}'\n\n` +
-                `The CLI has been simplified and no longer uses subcommands.\n\n` +
-                `✅ Use: atomic-codegen generate\n` +
-                `❌ Old: atomic-codegen generate typescript\n\n` +
-                `All generation settings are now configured in your config file.\n` +
-                `Create an atomic-codegen.config.ts file to get started.`);
-            process.exit(1);
-        }
-        // 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"}`);
-            }
-            // 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);
-            }
-            // Check that at least one generator is configured
-            if (!config.typescript) {
-                throw new Error("No generators configured. Please enable 'typescript' 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

@@ -1,29 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Atomic Codegen CLI - New Command Structure
- *
- * Modern CLI with subcommands for typeschema and code generation
- */
-import yargs from "yargs";
-/**
- * CLI arguments interface
- */
-export interface CLIArgv {
-    config?: string;
-    verbose?: boolean;
-    debug?: boolean;
-}
-/**
- * Main CLI entry point with subcommands
- */
-export declare function createCLI(): yargs.Argv<{
-    verbose: boolean;
-} & {
-    debug: boolean;
-} & {
-    config: string | undefined;
-}>;
-/**
- * Run the CLI
- */
-export declare function runCLI(): Promise<void>;

package/dist/cli/commands/index.js

@@ -1,100 +0,0 @@
-#!/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";
-import { generateCommand } from "./generate";
-import { typeschemaCommand } from "./typeschema";
-/**
- * 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.d.ts

@@ -1,19 +0,0 @@
-/**
- * TypeSchema Generate Command
- *
- * Generate TypeSchema files from FHIR packages
- */
-import type { CommandModule } from "yargs";
-interface GenerateTypeschemaArgs {
-    packages: string[];
-    output?: string;
-    format?: "ndjson" | "json";
-    verbose?: boolean;
-    treeshake?: string[];
-    singleFile?: boolean;
-}
-/**
- * Generate TypeSchema from FHIR packages
- */
-export declare const generateTypeschemaCommand: CommandModule<Record<string, unknown>, GenerateTypeschemaArgs>;
-export {};

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

@@ -1,124 +0,0 @@
-/**
- * TypeSchema Generate Command
- *
- * Generate TypeSchema files from FHIR packages
- */
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { TypeSchemaGenerator } from "@typeschema/generator";
-import { loadConfig } from "../../../config";
-import { complete, createLogger, list } from "../../utils/log";
-/**
- * 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.d.ts

@@ -1,10 +0,0 @@
-/**
- * TypeSchema Commands
- *
- * Commands for validating and managing TypeSchema files
- */
-import type { CommandModule } from "yargs";
-/**
- * TypeSchema command group
- */
-export declare const typeschemaCommand: CommandModule;

package/dist/cli/commands/typeschema.js

@@ -1,47 +0,0 @@
-/**
- * TypeSchema Commands
- *
- * Commands for validating and managing TypeSchema files
- */
-import { error, info, list } from "../utils/log";
-import { generateTypeschemaCommand } from "./typeschema/generate";
-/**
- * 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);
-        }
-    },
-};