@alagoni97/cli 0.72.1

package/dist/browser/shims/swagger-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Browser shim for @apidevtools/swagger-parser.
+ * We don't actually use swagger-parser in the browser - we use @readme/openapi-parser.
+ * This shim prevents bundling issues from transitive dependencies.
+ */
+/**
+ * Stub SwaggerParser that does nothing
+ */
+export declare function SwaggerParser(): void;
+export declare namespace SwaggerParser {
+    var parse: (schema: any) => Promise<any>;
+    var resolve: (schema: any) => Promise<{
+        schema: any;
+        $refs: {};
+    }>;
+    var bundle: (schema: any) => Promise<any>;
+    var dereference: (schema: any) => Promise<any>;
+    var validate: (schema: any) => Promise<any>;
+}
+export default SwaggerParser;

package/dist/browser/shims/swagger-parser.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Browser shim for @apidevtools/swagger-parser.
+ * We don't actually use swagger-parser in the browser - we use @readme/openapi-parser.
+ * This shim prevents bundling issues from transitive dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerParser = void 0;
+/**
+ * Stub SwaggerParser that does nothing
+ */
+function SwaggerParser() {
+    // Empty constructor
+}
+exports.SwaggerParser = SwaggerParser;
+SwaggerParser.prototype = {
+    schema: {},
+    api: {},
+    $refs: {
+        circular: false,
+        paths: () => [],
+        values: () => ({}),
+        get: () => undefined
+    },
+    parse: async (schema) => schema,
+    async resolve() {
+        return this;
+    },
+    bundle: async (schema) => schema,
+    dereference: async (schema) => schema,
+    validate: async (schema) => schema
+};
+// Static methods
+SwaggerParser.parse = async (schema) => schema;
+SwaggerParser.resolve = async (schema) => ({ schema, $refs: {} });
+SwaggerParser.bundle = async (schema) => schema;
+SwaggerParser.dereference = async (schema) => schema;
+SwaggerParser.validate = async (schema) => schema;
+// Default export
+exports.default = SwaggerParser;

package/dist/codegen/configurationSchemaBuilder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Builds the public configuration JSON Schema from the Zod source of truth.
+ * Filters disabled presets out of every top-level configuration branch and
+ * keeps the schema's $ref graph internally consistent.
+ */
+import { type PostProcessCallback } from 'zod-to-json-schema';
+/**
+ * Note: removing entries from a `anyOf` array shifts the indices of the
+ * remaining entries, which would invalidate any sibling `$ref` that points to
+ * a later index. The current default `disabledPresets = ['custom']` is safe
+ * because `custom` sits at the highest index in every union (AsyncAPI 7,
+ * OpenAPI 6, JSON Schema 1) — there are no later indices to break. A future
+ * maintainer disabling a non-last preset must add index renumbering here.
+ */
+export declare function buildConfigurationSchema(postProcess: PostProcessCallback, disabledPresets?: readonly string[]): Record<string, unknown>;

package/dist/codegen/configurationSchemaBuilder.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigurationSchema = void 0;
+/**
+ * Builds the public configuration JSON Schema from the Zod source of truth.
+ * Filters disabled presets out of every top-level configuration branch and
+ * keeps the schema's $ref graph internally consistent.
+ */
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const types_1 = require("./types");
+const DEFAULT_DISABLED_PRESETS = ['custom'];
+const ASYNCAPI_REF_PREFIX = '#/definitions/AsyncAPICodegenConfiguration/properties/generators/items/anyOf/';
+/**
+ * Note: removing entries from a `anyOf` array shifts the indices of the
+ * remaining entries, which would invalidate any sibling `$ref` that points to
+ * a later index. The current default `disabledPresets = ['custom']` is safe
+ * because `custom` sits at the highest index in every union (AsyncAPI 7,
+ * OpenAPI 6, JSON Schema 1) — there are no later indices to break. A future
+ * maintainer disabling a non-last preset must add index renumbering here.
+ */
+function buildConfigurationSchema(postProcess, disabledPresets = DEFAULT_DISABLED_PRESETS) {
+    const schema = (0, zod_to_json_schema_1.zodToJsonSchema)(types_1.zodTheCodegenConfiguration, {
+        definitions: {
+            AsyncAPICodegenConfiguration: types_1.zodAsyncAPICodegenConfiguration
+        },
+        postProcess
+    });
+    const asyncapiAnyOf = schema.definitions.AsyncAPICodegenConfiguration.properties.generators.items
+        .anyOf;
+    const disabledRefs = new Set();
+    asyncapiAnyOf.forEach((entry, i) => {
+        if (disabledPresets.includes(entry?.properties?.preset?.const)) {
+            disabledRefs.add(`${ASYNCAPI_REF_PREFIX}${i}`);
+        }
+    });
+    const isDisabled = (entry) => disabledPresets.includes(entry?.properties?.preset?.const) ||
+        (typeof entry?.$ref === 'string' && disabledRefs.has(entry.$ref));
+    for (const branch of schema.anyOf ?? []) {
+        const items = branch?.properties?.generators?.items;
+        if (Array.isArray(items?.anyOf)) {
+            items.anyOf = items.anyOf.filter((entry) => !isDisabled(entry));
+        }
+    }
+    schema.definitions.AsyncAPICodegenConfiguration.properties.generators.items.anyOf =
+        asyncapiAnyOf.filter((entry) => !isDisabled(entry));
+    return schema;
+}
+exports.buildConfigurationSchema = buildConfigurationSchema;

package/dist/codegen/configurations.d.ts

@@ -0,0 +1,29 @@
+import { TheCodegenConfiguration, TheCodegenConfigurationInternal, RunGeneratorContext, PresetTypes, SupportedLanguages, GeneratorsInternal } from './types';
+/**
+ * Load configuration from file.
+ */
+export declare function loadConfigFile(filePath?: string): Promise<{
+    config: TheCodegenConfiguration;
+    filePath: string;
+}>;
+/**
+ * Load the configuration file and realize it with default options if necessary.
+ */
+export declare function loadAndRealizeConfigFile(filePath?: string): Promise<{
+    config: TheCodegenConfigurationInternal;
+    filePath: string;
+}>;
+/**
+ * Ensure that each generator has the default options along side custom properties
+ */
+export declare function realizeConfiguration(config: TheCodegenConfiguration): TheCodegenConfigurationInternal;
+/**
+ * Returns the default generator for the preset of the language
+ */
+export declare function getDefaultConfiguration(preset: PresetTypes, language: SupportedLanguages): GeneratorsInternal | undefined;
+/**
+ * Load configuration and input document to create generator context
+ *
+ * @param configFile
+ */
+export declare function realizeGeneratorContext(configFile: string | undefined): Promise<RunGeneratorContext>;

package/dist/codegen/configurations.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realizeGeneratorContext = exports.getDefaultConfiguration = exports.realizeConfiguration = exports.loadAndRealizeConfigFile = exports.loadConfigFile = void 0;
+const types_1 = require("./types");
+const generators_1 = require("./generators");
+const LoggingInterface_1 = require("../LoggingInterface");
+const channels_1 = require("./generators/typescript/channels");
+const utils_1 = require("./utils");
+const cosmiconfig_1 = require("cosmiconfig");
+const client_1 = require("./generators/typescript/client");
+const path_1 = __importDefault(require("path"));
+const asyncapi_1 = require("./inputs/asyncapi");
+const openapi_1 = require("./inputs/openapi");
+const jsonschema_1 = require("./inputs/jsonschema");
+const typescript_1 = require("./generators/typescript");
+const models_1 = require("./generators/typescript/models");
+const errors_1 = require("./errors");
+const detection_1 = require("./detection");
+const inputSource_1 = require("../utils/inputSource");
+const moduleName = 'codegen';
+const explorer = (0, cosmiconfig_1.cosmiconfig)(moduleName, {
+    searchPlaces: [
+        `${moduleName}.json`,
+        `${moduleName}.yaml`,
+        `${moduleName}.yml`,
+        `${moduleName}.js`,
+        `${moduleName}.ts`,
+        `${moduleName}.mjs`,
+        `${moduleName}.cjs`
+    ],
+    mergeSearchPlaces: true
+});
+/**
+ * Load configuration from file.
+ */
+async function loadConfigFile(filePath) {
+    let cosmiConfig;
+    if (filePath) {
+        try {
+            cosmiConfig = await explorer.load(filePath);
+        }
+        catch (error) {
+            // Check if it's actually a file-not-found error
+            if (error.code === 'ENOENT' || error.message?.includes('ENOENT')) {
+                throw (0, errors_1.createConfigNotFoundError)({ filePath });
+            }
+            // For other errors (syntax, parse, permission, etc.), wrap in parse error
+            throw (0, errors_1.createConfigParseError)({ filePath, originalError: error });
+        }
+    }
+    else {
+        cosmiConfig = await explorer.search();
+        if (!cosmiConfig) {
+            const searchLocations = [
+                'codegen.json',
+                'codegen.yaml',
+                'codegen.yml',
+                'codegen.js',
+                'codegen.ts',
+                'codegen.mjs',
+                'codegen.cjs'
+            ];
+            throw (0, errors_1.createConfigNotFoundError)({ searchLocations });
+        }
+    }
+    let codegenConfig;
+    if (typeof cosmiConfig.config.default === 'function') {
+        codegenConfig = cosmiConfig.config.default();
+    }
+    else if (typeof cosmiConfig.config.default === 'object') {
+        codegenConfig = cosmiConfig.config.default;
+    }
+    else {
+        codegenConfig = cosmiConfig.config;
+    }
+    return {
+        config: codegenConfig,
+        filePath: cosmiConfig.filepath
+    };
+}
+exports.loadConfigFile = loadConfigFile;
+/**
+ * Load the configuration file and realize it with default options if necessary.
+ */
+async function loadAndRealizeConfigFile(filePath) {
+    const codegenConfig = await loadConfigFile(filePath);
+    const realizedConfiguration = realizeConfiguration(codegenConfig.config);
+    return {
+        config: realizedConfiguration,
+        filePath: codegenConfig.filePath
+    };
+}
+exports.loadAndRealizeConfigFile = loadAndRealizeConfigFile;
+/**
+ * Ensure that each generator has the default options along side custom properties
+ */
+function realizeConfiguration(config) {
+    config.generators = config.generators ?? [];
+    const generatorIds = [];
+    for (const [index, generator] of config.generators.entries()) {
+        const language = generator.language ?? config.language ?? 'typescript';
+        if (!generator?.preset) {
+            continue;
+        }
+        const defaultGenerator = getDefaultConfiguration(generator.preset, language);
+        if (!defaultGenerator) {
+            throw (0, errors_1.createInvalidPresetError)({ preset: generator.preset, language });
+        }
+        const generatorToUse = (0, utils_1.mergePartialAndDefault)(defaultGenerator, generator);
+        const oldId = generatorToUse.id;
+        // Make sure that each generator has unique ids if they dont explicit define one
+        if (generatorToUse.id === defaultGenerator.id) {
+            const duplicateGenerators = generatorIds.filter((generatorId) => generatorId === generatorToUse.id);
+            if (duplicateGenerators.length > 0) {
+                generatorToUse.id = `${generatorToUse.id}-${duplicateGenerators.length}`;
+            }
+        }
+        generatorIds.push(oldId);
+        // eslint-disable-next-line security/detect-object-injection
+        config.generators[index] = generatorToUse;
+    }
+    try {
+        types_1.zodTheCodegenConfiguration.parse(config);
+    }
+    catch (e) {
+        const errors = (0, errors_1.parseZodErrors)(e);
+        // Log each error for debugging
+        errors.forEach((error) => LoggingInterface_1.Logger.error(error));
+        throw (0, errors_1.createConfigValidationError)({ validationErrors: errors });
+    }
+    const newGenerators = ensureProperGenerators(config);
+    config.generators.push(...newGenerators);
+    return config;
+}
+exports.realizeConfiguration = realizeConfiguration;
+/**
+ * Ensure that all generators have their dependency default generators.
+ *
+ * For example, for typescript channels, include default payload and parameter generators if not explicitly sat.
+ *
+ * This is done recursively.
+ */
+function ensureProperGenerators(config) {
+    const iterateGenerators = (generators) => {
+        const newGenerators = [];
+        for (const generator of generators) {
+            const language = generator.language ?? config.language;
+            if (generator.preset === 'channels' && language === 'typescript') {
+                newGenerators.push(...(0, channels_1.includeTypeScriptChannelDependencies)(config, generator));
+            }
+            if (generator.preset === 'client' && language === 'typescript') {
+                newGenerators.push(...(0, client_1.includeTypeScriptClientDependencies)(config, generator));
+            }
+        }
+        if (newGenerators.length > 0) {
+            newGenerators.push(...iterateGenerators(newGenerators));
+        }
+        return newGenerators;
+    };
+    return iterateGenerators(Array.from(config.generators.values()));
+}
+/**
+ * Returns the default generator for the preset of the language
+ */
+function getDefaultConfiguration(preset, language) {
+    switch (preset) {
+        case 'payloads':
+            switch (language) {
+                case 'typescript':
+                    return generators_1.defaultTypeScriptPayloadGenerator;
+            }
+            break;
+        case 'headers':
+            switch (language) {
+                case 'typescript':
+                    return typescript_1.defaultTypeScriptHeadersOptions;
+            }
+            break;
+        case 'types':
+            switch (language) {
+                case 'typescript':
+                    return typescript_1.defaultTypeScriptTypesOptions;
+            }
+            break;
+        case 'models':
+            switch (language) {
+                case 'typescript':
+                    return models_1.defaultTypeScriptModelsOptions;
+            }
+            break;
+        case 'channels':
+            switch (language) {
+                case 'typescript':
+                    return channels_1.defaultTypeScriptChannelsGenerator;
+            }
+            break;
+        case 'client':
+            switch (language) {
+                case 'typescript':
+                    return client_1.defaultTypeScriptClientGenerator;
+            }
+            break;
+        case 'custom':
+            return generators_1.defaultCustomGenerator;
+        case 'parameters':
+            switch (language) {
+                case 'typescript':
+                    return generators_1.defaultTypeScriptParametersOptions;
+            }
+            break;
+    }
+    return undefined;
+}
+exports.getDefaultConfiguration = getDefaultConfiguration;
+/**
+ * Load configuration and input document to create generator context
+ *
+ * @param configFile
+ */
+async function realizeGeneratorContext(configFile) {
+    const { config, filePath } = await loadAndRealizeConfigFile(configFile);
+    // Apply automatic project detection if importExtension not explicitly set
+    if (config.importExtension === undefined) {
+        const projectDir = path_1.default.dirname(filePath);
+        const detected = await (0, detection_1.detectTypeScriptImportExtension)(projectDir);
+        if (detected !== null) {
+            config.importExtension = detected;
+            LoggingInterface_1.Logger.info(`Auto-detected importExtension: '${detected}'`);
+        }
+    }
+    LoggingInterface_1.Logger.debug(`Found configuration: ${JSON.stringify(config, null, 2)}`);
+    const documentPath = (0, inputSource_1.isRemoteUrl)(config.inputPath)
+        ? config.inputPath
+        : path_1.default.resolve(path_1.default.dirname(filePath), config.inputPath);
+    LoggingInterface_1.Logger.verbose(`Document path: ${documentPath}`);
+    LoggingInterface_1.Logger.verbose(`Input type: ${config.inputType}`);
+    const context = {
+        configuration: config,
+        documentPath,
+        inputAuth: config.auth,
+        configFilePath: filePath
+    };
+    if (config.inputType === 'asyncapi') {
+        const document = await (0, asyncapi_1.loadAsyncapi)(context);
+        context.asyncapiDocument = document;
+    }
+    else if (config.inputType === 'openapi') {
+        const document = await (0, openapi_1.loadOpenapi)(context);
+        context.openapiDocument = document;
+    }
+    else if (config.inputType === 'jsonschema') {
+        const document = await (0, jsonschema_1.loadJsonSchema)(context);
+        context.jsonSchemaDocument = document;
+    }
+    return context;
+}
+exports.realizeGeneratorContext = realizeGeneratorContext;

package/dist/codegen/detection.d.ts

@@ -0,0 +1,19 @@
+import type { ImportExtension } from './utils';
+/**
+ * Detects appropriate import extension based on project configuration.
+ *
+ * Detection priority:
+ * 1. Bundler config files present → 'none'
+ * 2. Bundler in dependencies → 'none'
+ * 3. moduleResolution: 'bundler' → 'none'
+ * 4. moduleResolution: 'node16'/'nodenext' (or inferred from module) + allowImportingTsExtensions → '.ts'
+ * 5. moduleResolution: 'node16'/'nodenext' (or inferred from module) → '.js'
+ * 6. Otherwise → null (use default)
+ *
+ * Note: If moduleResolution is not set but module is 'Node16' or 'NodeNext',
+ * moduleResolution is inferred per TypeScript's behavior.
+ *
+ * @param projectDir - Directory to analyze (where package.json/tsconfig.json are)
+ * @returns Detected import extension or null if no detection could be made
+ */
+export declare function detectTypeScriptImportExtension(projectDir: string): Promise<ImportExtension | null>;

package/dist/codegen/detection.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTypeScriptImportExtension = void 0;
+/**
+ * Project settings detection for automatic configuration.
+ * Detects TypeScript module resolution settings and bundler presence
+ * to set intelligent defaults for importExtension.
+ */
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const comment_json_1 = require("comment-json");
+const LoggingInterface_1 = require("../LoggingInterface");
+/** Bundler packages that indicate no extension is needed */
+const BUNDLER_DEPS = new Set([
+    'webpack',
+    'vite',
+    'esbuild',
+    'rollup',
+    'parcel',
+    'turbopack',
+    'next',
+    '@rspack/core'
+]);
+/** Bundler config files that indicate no extension is needed */
+const BUNDLER_CONFIGS = [
+    'vite.config.ts',
+    'vite.config.js',
+    'vite.config.mjs',
+    'webpack.config.js',
+    'webpack.config.ts',
+    'webpack.config.mjs',
+    'rollup.config.js',
+    'rollup.config.ts',
+    'rollup.config.mjs',
+    'next.config.js',
+    'next.config.ts',
+    'next.config.mjs',
+    'esbuild.config.js',
+    'esbuild.config.mjs',
+    'rspack.config.js',
+    'rspack.config.ts',
+    'rspack.config.mjs'
+];
+/**
+ * Safely read and parse JSON file, returning null on any error.
+ * For tsconfig.json, uses JSONC parsing (via comment-json) to handle comments and trailing commas.
+ */
+function readJsonFile(filePath, allowJsonc = false) {
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+        if (allowJsonc) {
+            return (0, comment_json_1.parse)(content);
+        }
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check for bundler config files in the project directory.
+ */
+function detectBundlerConfigFile(projectDir) {
+    for (const configFile of BUNDLER_CONFIGS) {
+        const configPath = path_1.default.join(projectDir, configFile);
+        if ((0, fs_1.existsSync)(configPath)) {
+            return configFile;
+        }
+    }
+    return null;
+}
+/**
+ * Check for bundler dependencies in package.json.
+ */
+function detectBundlerDependency(packageJson) {
+    const allDeps = Object.keys({
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+    });
+    for (const dep of allDeps) {
+        if (BUNDLER_DEPS.has(dep)) {
+            return dep;
+        }
+    }
+    return null;
+}
+/**
+ * Determine import extension from tsconfig moduleResolution setting.
+ * If moduleResolution is undefined, infers it from the module setting per TypeScript rules.
+ */
+function detectFromModuleResolution(moduleRes, module, allowTsExtensions) {
+    // Infer moduleResolution from module if not explicitly set
+    // TypeScript infers: "Node16" → "node16", "NodeNext" → "nodenext"
+    let resolution = moduleRes?.toLowerCase();
+    if (!resolution && module) {
+        const moduleLower = module.toLowerCase();
+        if (moduleLower === 'node16' || moduleLower === 'nodenext') {
+            resolution = moduleLower;
+            LoggingInterface_1.Logger.verbose(`Inferred moduleResolution: ${resolution} from module: ${module}`);
+        }
+    }
+    if (resolution === 'bundler') {
+        LoggingInterface_1.Logger.verbose(`Auto-detected moduleResolution: bundler → importExtension: 'none'`);
+        return 'none';
+    }
+    if (resolution === 'node16' || resolution === 'nodenext') {
+        if (allowTsExtensions) {
+            LoggingInterface_1.Logger.verbose(`Auto-detected moduleResolution: ${resolution} with allowImportingTsExtensions → importExtension: '.ts'`);
+            return '.ts';
+        }
+        LoggingInterface_1.Logger.verbose(`Auto-detected moduleResolution: ${resolution} → importExtension: '.js'`);
+        return '.js';
+    }
+    return null;
+}
+/**
+ * Detects appropriate import extension based on project configuration.
+ *
+ * Detection priority:
+ * 1. Bundler config files present → 'none'
+ * 2. Bundler in dependencies → 'none'
+ * 3. moduleResolution: 'bundler' → 'none'
+ * 4. moduleResolution: 'node16'/'nodenext' (or inferred from module) + allowImportingTsExtensions → '.ts'
+ * 5. moduleResolution: 'node16'/'nodenext' (or inferred from module) → '.js'
+ * 6. Otherwise → null (use default)
+ *
+ * Note: If moduleResolution is not set but module is 'Node16' or 'NodeNext',
+ * moduleResolution is inferred per TypeScript's behavior.
+ *
+ * @param projectDir - Directory to analyze (where package.json/tsconfig.json are)
+ * @returns Detected import extension or null if no detection could be made
+ */
+async function detectTypeScriptImportExtension(projectDir) {
+    try {
+        // Step 1: Check for bundler config files
+        const bundlerConfig = detectBundlerConfigFile(projectDir);
+        if (bundlerConfig) {
+            LoggingInterface_1.Logger.verbose(`Auto-detected bundler config: ${bundlerConfig} → importExtension: 'none'`);
+            return 'none';
+        }
+        // Step 2: Check package.json for bundler dependencies
+        const packageJsonPath = path_1.default.join(projectDir, 'package.json');
+        const packageJson = readJsonFile(packageJsonPath);
+        if (packageJson) {
+            const bundlerDep = detectBundlerDependency(packageJson);
+            if (bundlerDep) {
+                LoggingInterface_1.Logger.verbose(`Auto-detected bundler dependency: ${bundlerDep} → importExtension: 'none'`);
+                return 'none';
+            }
+        }
+        // Step 3: Read tsconfig.json for moduleResolution (use JSONC parser)
+        const tsconfigPath = path_1.default.join(projectDir, 'tsconfig.json');
+        const tsconfig = readJsonFile(tsconfigPath, true);
+        if (!tsconfig) {
+            LoggingInterface_1.Logger.verbose('Could not read tsconfig.json, skipping import extension detection');
+            return null;
+        }
+        const options = tsconfig.compilerOptions;
+        if (!options) {
+            LoggingInterface_1.Logger.verbose('No compilerOptions in tsconfig.json');
+            return null;
+        }
+        // Step 4: Check moduleResolution (with inference from module if needed)
+        return detectFromModuleResolution(options.moduleResolution, options.module, options.allowImportingTsExtensions);
+    }
+    catch (error) {
+        LoggingInterface_1.Logger.verbose(`Project detection failed: ${error}`);
+        return null;
+    }
+}
+exports.detectTypeScriptImportExtension = detectTypeScriptImportExtension;