@dbos-inc/dbos-sdk 0.8.32-preview → 0.8.35-preview

package/dist/src/dbos-runtime/openApi.d.ts

@@ -1,35 +0,0 @@
-import ts from 'typescript';
-import { DecoratorInfo, MethodInfo, ClassInfo, ParameterInfo } from './TypeParser';
-import { APITypes, ArgSources } from '../httpServer/handler';
-import { Schema } from 'ts-json-schema-generator';
-import { OpenAPIV3 as OpenApi3 } from 'openapi-types';
-interface HttpEndpointInfo {
-    verb: APITypes;
-    path: string;
-}
-export declare class OpenApiGenerator {
-    #private;
-    readonly program: ts.Program;
-    get diags(): readonly ts.Diagnostic[];
-    constructor(program: ts.Program);
-    generate(classes: readonly ClassInfo[], title: string, version: string): OpenApi3.Document | undefined;
-    generatePath(method: MethodInfo, { verb, path }: HttpEndpointInfo, defaultRoles: readonly string[], securityScheme: string | undefined): [string, OpenApi3.PathItemObject] | undefined;
-    getMethodReturnType(node: ts.MethodDeclaration): ts.Type | undefined;
-    generateResponse(method: MethodInfo): [string, OpenApi3.ResponseObject] | undefined;
-    generateParameters(sourcedParams: [ParameterInfo, ArgSources][]): OpenApi3.ParameterObject[];
-    generateParameter(parameter: ParameterInfo, argSource: ArgSources): OpenApi3.ParameterObject | undefined;
-    getLocation(parameter: ParameterInfo, argSource: ArgSources): "query" | "path" | undefined;
-    generateRequestBody(sourcedParams: [ParameterInfo, ArgSources][]): OpenApi3.RequestBodyObject | undefined;
-    generateSchema(node?: ts.Node): OpenApi3.SchemaObject | OpenApi3.ReferenceObject | undefined;
-    getDBOSDecorator(decorated: MethodInfo | ParameterInfo | ClassInfo, name: string): DecoratorInfo | undefined;
-    getHttpInfo(method: MethodInfo): HttpEndpointInfo | undefined;
-    getParamSource(parameter: ParameterInfo, verb: APITypes): ArgSources.BODY | ArgSources.QUERY | ArgSources.URL | undefined;
-    getParamName(parameter: ParameterInfo): string | undefined;
-    mapSchema(schema: Schema): OpenApi3.SchemaObject | OpenApi3.ReferenceObject | undefined;
-    parseStringLiteralArray(node: ts.Expression | undefined): string[] | undefined;
-    parseSecurityScheme(arg?: ts.Expression): SecurityScheme | undefined;
-}
-type SecurityScheme = Exclude<OpenApi3.SecuritySchemeObject, OpenApi3.OAuth2SecurityScheme>;
-export declare function generateOpenApi(entrypoint: string): Promise<OpenApi3.Document | undefined>;
-export {};
-//# sourceMappingURL=openApi.d.ts.map

package/dist/src/dbos-runtime/openApi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openApi.d.ts","sourceRoot":"","sources":["../../../src/dbos-runtime/openApi.ts"],"names":[],"mappings":"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"}

package/dist/src/dbos-runtime/openApi.js

@@ -1,595 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateOpenApi = exports.OpenApiGenerator = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const TypeParser_1 = require("./TypeParser");
-const handler_1 = require("../httpServer/handler");
-const ts_json_schema_generator_1 = require("ts-json-schema-generator");
-const node_path_1 = __importDefault(require("node:path"));
-const promises_1 = __importDefault(require("node:fs/promises"));
-const tsDiagUtil_1 = require("./tsDiagUtil");
-function isValid(value) { return value !== undefined; }
-// ts-json-schema-generator does not support BigInt, so OpenApiGenerator needs a custom type, formatter and parser for it
-class BigIntType extends ts_json_schema_generator_1.PrimitiveType {
-    getId() { return "integer"; }
-}
-class BigIntKeywordParser {
-    supportsNode(node) {
-        return node.kind === typescript_1.default.SyntaxKind.BigIntKeyword;
-    }
-    createType(_node, _context, _reference) {
-        return new BigIntType();
-    }
-}
-class BigIntTypeFormatter {
-    supportsType(type) {
-        return type instanceof BigIntType;
-    }
-    getDefinition(_type) {
-        // Note, JSON Schema integer type is not constrained to a specific size, so it is a valid type for BigInt
-        return { type: "integer", description: "bigint" };
-    }
-    getChildren(_type) {
-        return [];
-    }
-}
-// type guard functions for ts.Type/TypeNode
-function isNodeWithTypeArguments(node) {
-    return "typeArguments" in node;
-}
-function isObjectType(node) {
-    return !!(node.flags & typescript_1.default.TypeFlags.Object);
-}
-function isTypeReference(node) {
-    return isObjectType(node) && !!(node.objectFlags & typescript_1.default.ObjectFlags.Reference);
-}
-// workflow UUID header parameter info which is added to every generated endpoint
-const workflowUuidParamName = "dbosWorkflowUUID";
-const workflowUuidRef = { $ref: `#/components/parameters/${workflowUuidParamName}` };
-const workflowUuidParam = [workflowUuidParamName, {
-        name: 'dbos-workflowuuid',
-        in: 'header',
-        required: false,
-        description: "Caller specified [workflow idempotency key](https://docs.dbos.dev/tutorials/idempotency-tutorial#setting-idempotency-keys)",
-        schema: { type: 'string' },
-    }];
-class OpenApiGenerator {
-    program;
-    #checker;
-    #schemaGenerator;
-    #schemaMap = new Map();
-    #securitySchemeMap = new Map();
-    #diags = new tsDiagUtil_1.DiagnosticsCollector();
-    get diags() { return this.#diags.diags; }
-    constructor(program) {
-        this.program = program;
-        this.#checker = program.getTypeChecker();
-        const config = {
-            discriminatorType: 'open-api',
-            encodeRefs: false
-        };
-        const parser = (0, ts_json_schema_generator_1.createParser)(program, config, aug => aug.addNodeParser(new BigIntKeywordParser()));
-        const formatter = (0, ts_json_schema_generator_1.createFormatter)(config, (fmt) => fmt.addTypeFormatter(new BigIntTypeFormatter()));
-        this.#schemaGenerator = new ts_json_schema_generator_1.SchemaGenerator(program, parser, formatter, {});
-    }
-    generate(classes, title, version) {
-        const paths = new Array();
-        classes.forEach((cls, index) => {
-            // if the class name is not specified, manufacture a name using the class index as the prefix
-            // JS class identifiers cannot start with a digit but OpenApi security scheme names can
-            const securitySchemeName = cls.name ? `${cls.name}Auth` : `${index}ClassAuth`;
-            const securitySchemeDecorator = this.getDBOSDecorator(cls, 'OpenApiSecurityScheme');
-            const securityScheme = this.parseSecurityScheme(securitySchemeDecorator?.args[0]);
-            const defaultRoles = this.parseStringLiteralArray(this.getDBOSDecorator(cls, 'DefaultRequiredRole')?.args[0]) ?? [];
-            if (securityScheme) {
-                this.#securitySchemeMap.set(securitySchemeName, securityScheme);
-            }
-            for (const method of cls.methods) {
-                const http = this.getHttpInfo(method);
-                if (!http)
-                    continue;
-                const path = this.generatePath(method, http, defaultRoles, securityScheme ? securitySchemeName : undefined);
-                if (path)
-                    paths.push(path);
-            }
-        });
-        const openApi = {
-            openapi: "3.0.3",
-            info: { title, version },
-            paths: Object.fromEntries(paths),
-            components: {
-                parameters: Object.fromEntries([workflowUuidParam]),
-                schemas: Object.fromEntries(this.#schemaMap),
-                securitySchemes: Object.fromEntries(this.#securitySchemeMap)
-            }
-        };
-        return (0, tsDiagUtil_1.diagResult)(openApi, this.diags);
-    }
-    generatePath(method, { verb, path }, defaultRoles, securityScheme) {
-        const sourcedParams = method.parameters
-            // The first parameter of a handle method must be an DBOSContext, which is not exposed via the API
-            .slice(1)
-            .map(p => [p, this.getParamSource(p, verb)]);
-        const parameters = this.generateParameters(sourcedParams);
-        // add optional parameter for workflow UUID header
-        parameters.push(workflowUuidRef);
-        const requestBody = this.generateRequestBody(sourcedParams);
-        const response = this.generateResponse(method);
-        if (!response)
-            return;
-        // if there is a security scheme specified, create a security requirement for it
-        // unless the method has no required roles
-        const security = new Array();
-        if (securityScheme) {
-            const roles = this.parseStringLiteralArray(this.getDBOSDecorator(method, 'RequiredRole')?.args[0]) ?? defaultRoles;
-            if (roles.length > 0) {
-                security.push({ [securityScheme]: [] });
-            }
-        }
-        const operation = {
-            operationId: method.name,
-            responses: Object.fromEntries([response]),
-            parameters,
-            requestBody,
-            security: security.length > 0 ? security : undefined,
-        };
-        // validate all path parameters have matching parameters with URL ArgSource
-        const pathParams = path.split('/')
-            .filter(p => p.startsWith(':'))
-            .map(p => p.substring(1));
-        for (const pathParam of pathParams) {
-            const param = sourcedParams.find(([parameter, _]) => parameter.name === pathParam);
-            if (!param) {
-                this.#diags.raise(`Missing path parameter ${pathParam} for ${method.name}`, method.node);
-                return;
-            }
-            if (param[1] !== handler_1.ArgSources.URL) {
-                this.#diags.raise(`Path parameter ${pathParam} must be a URL parameter: ${method.name}`, param[0].node);
-                return;
-            }
-        }
-        // OpenAPI indicates path parameters with curly braces, but DBOS uses colons
-        const $path = path.split('/')
-            .map(p => p.startsWith(':') ? `{${p.substring(1)}}` : p)
-            .join('/');
-        switch (verb) {
-            case handler_1.APITypes.GET: return [$path, { get: operation }];
-            case handler_1.APITypes.POST: return [$path, { post: operation }];
-        }
-    }
-    getMethodReturnType(node) {
-        // if the method has a declared return type, try to use that
-        if (node.type) {
-            if (!isNodeWithTypeArguments(node.type)) {
-                this.#diags.warn(`Unexpected type node kind ${typescript_1.default.SyntaxKind[node.type.kind]}`, node.type);
-            }
-            else {
-                // return type must be a Promise<T>, so take the first type argument
-                const typeArg = node.type.typeArguments?.[0];
-                if (typeArg)
-                    return this.#checker.getTypeFromTypeNode(typeArg);
-                const printer = typescript_1.default.createPrinter();
-                const text = printer.printNode(typescript_1.default.EmitHint.Unspecified, node.type, node.getSourceFile());
-                this.#diags.warn(`Unexpected return type without at least one type argument ${text}`, node.type);
-            }
-        }
-        // if the return type is inferred or the Promise type argument could not be determined,
-        // infer the return type via the type checker
-        const signature = this.#checker.getSignatureFromDeclaration(node);
-        const returnType = signature?.getReturnType();
-        if (!returnType || !isTypeReference(returnType))
-            return undefined;
-        // again, return type must be a Promise<T>, so take the first type argument
-        return returnType.typeArguments?.[0];
-    }
-    generateResponse(method) {
-        const returnType = this.getMethodReturnType(method.node);
-        if (!returnType) {
-            this.#diags.raise(`Could not determine return type of ${method.name}`, method.node);
-            return;
-        }
-        if (returnType.flags & typescript_1.default.TypeFlags.VoidLike) {
-            return ["204", { description: "No Content" }];
-        }
-        const typeNode = this.#checker.typeToTypeNode(returnType, undefined, undefined);
-        if (!typeNode) {
-            this.#diags.warn(`Could not determine return type node of ${method.name}`, method.node);
-        }
-        return ["200", {
-                description: "Ok",
-                content: {
-                    "application/json": {
-                        schema: this.generateSchema(typeNode)
-                    }
-                }
-            }];
-    }
-    generateParameters(sourcedParams) {
-        if (sourcedParams.length === 0)
-            return [];
-        return sourcedParams
-            // QUERY and URL parameters are specified in the Operation.parameters field
-            .filter(([_, source]) => source === handler_1.ArgSources.QUERY || source === handler_1.ArgSources.URL)
-            .map(([parameter, argSource]) => this.generateParameter(parameter, argSource))
-            .filter(isValid);
-    }
-    generateParameter(parameter, argSource) {
-        if (argSource === handler_1.ArgSources.BODY) {
-            this.#diags.raise(`BODY parameters must be specified in the Operation.requestBody field: ${parameter.name}`, parameter.node);
-            return;
-        }
-        if (argSource === handler_1.ArgSources.URL && !parameter.required) {
-            this.#diags.raise(`URL parameters must be required: ${parameter.name}`, parameter.node);
-            return;
-        }
-        const schema = this.generateSchema(parameter.node);
-        const name = this.getParamName(parameter);
-        const location = this.getLocation(parameter, argSource);
-        if (!name || !location)
-            return;
-        return {
-            name,
-            in: location,
-            required: parameter.required,
-            schema
-        };
-    }
-    getLocation(parameter, argSource) {
-        switch (argSource) {
-            case handler_1.ArgSources.QUERY: return 'query';
-            case handler_1.ArgSources.URL: return 'path';
-            default:
-                this.#diags.raise(`Unsupported Parameter ArgSource: ${argSource}`, parameter.node);
-                return;
-        }
-    }
-    generateRequestBody(sourcedParams) {
-        // BODY parameters are specified in the Operation.requestBody field
-        const parameters = sourcedParams
-            .filter(([_, source]) => source === handler_1.ArgSources.BODY)
-            .map(([parameter, _]) => [this.getParamName(parameter), parameter]);
-        if (parameters.length === 0)
-            return undefined;
-        const properties = parameters.map(([name, parameter]) => [name, this.generateSchema(parameter.node)]);
-        const schema = {
-            type: 'object',
-            properties: Object.fromEntries(properties),
-            required: parameters.filter(([_, parameter]) => parameter.required).map(([name, _]) => name),
-        };
-        return {
-            required: true,
-            content: {
-                "application/json": { schema }
-            }
-        };
-    }
-    generateSchema(node) {
-        if (!node)
-            return { description: "Undefined Node" };
-        const schema = this.#schemaGenerator.createSchemaFromNodes([node]);
-        if (!schema.$ref)
-            return { description: "No $ref" };
-        const slashIndex = schema.$ref.lastIndexOf('/');
-        if (slashIndex === -1)
-            return { description: `Invalid $ref ${schema.$ref}` };
-        const name = schema.$ref.substring(slashIndex + 1);
-        const defs = new Map(Object.entries(schema.definitions ?? {}));
-        if (defs.size === 0)
-            return { description: "No definitions" };
-        const def = defs.get(name);
-        if (!def)
-            return { description: `No definition ${name}` };
-        if (typeof def === 'boolean')
-            return { description: `Definition ${name} is a boolean` };
-        if (defs.size > 1) {
-            defs.delete(name);
-            for (const [$name, $def] of defs) {
-                if (typeof $def === 'boolean')
-                    continue;
-                const $schema = this.mapSchema($def);
-                if ($schema)
-                    this.#schemaMap.set($name, $schema);
-            }
-        }
-        return this.mapSchema(def);
-    }
-    getDBOSDecorator(decorated, name) {
-        const filtered = decorated.decorators.filter(d => d.module === '@dbos-inc/dbos-sdk' && d.name === name);
-        if (filtered.length === 0)
-            return undefined;
-        if (filtered.length > 1) {
-            this.#diags.raise(`Multiple ${JSON.stringify(name)} decorators found on ${decorated.name ?? "<unknown>"}`, decorated.node);
-        }
-        return filtered[0];
-    }
-    getHttpInfo(method) {
-        const getApiDecorator = this.getDBOSDecorator(method, 'GetApi');
-        const postApiDecorator = this.getDBOSDecorator(method, 'PostApi');
-        if (getApiDecorator && postApiDecorator) {
-            this.#diags.raise(`Method ${method.name} has both GetApi and PostApi decorators`);
-            return;
-        }
-        if (!getApiDecorator && !postApiDecorator)
-            return undefined;
-        const verb = getApiDecorator ? handler_1.APITypes.GET : handler_1.APITypes.POST;
-        const arg = getApiDecorator ? getApiDecorator.args[0] : postApiDecorator?.args[0];
-        if (!arg) {
-            this.#diags.raise(`Missing path argument for ${verb}Api decorator`, method.node);
-            return;
-        }
-        if (!typescript_1.default.isStringLiteral(arg)) {
-            this.#diags.raise(`Unexpected path argument type: ${typescript_1.default.SyntaxKind[arg.kind]}`, method.node);
-            return;
-        }
-        return { verb, path: arg.text };
-    }
-    getParamSource(parameter, verb) {
-        const argSource = this.getDBOSDecorator(parameter, 'ArgSource');
-        if (!argSource)
-            return getDefaultArgSource(verb);
-        if (!typescript_1.default.isPropertyAccessExpression(argSource.args[0])) {
-            this.#diags.raise(`Unexpected ArgSource argument type: ${typescript_1.default.SyntaxKind[argSource.args[0].kind]}`, parameter.node);
-            return;
-        }
-        switch (argSource.args[0].name.text) {
-            case "BODY": return handler_1.ArgSources.BODY;
-            case "QUERY": return handler_1.ArgSources.QUERY;
-            case "URL": return handler_1.ArgSources.URL;
-            case "DEFAULT": return getDefaultArgSource(verb);
-            default:
-                this.#diags.raise(`Unexpected ArgSource argument: ${argSource.args[0].name.text}`, parameter.node);
-                return;
-        }
-        function getDefaultArgSource(verb) {
-            switch (verb) {
-                case handler_1.APITypes.GET: return handler_1.ArgSources.QUERY;
-                case handler_1.APITypes.POST: return handler_1.ArgSources.BODY;
-            }
-        }
-    }
-    getParamName(parameter) {
-        const argName = this.getDBOSDecorator(parameter, 'ArgName');
-        if (!argName)
-            return parameter.name;
-        const nameParam = argName.args[0];
-        if (nameParam && typescript_1.default.isStringLiteral(nameParam))
-            return nameParam.text;
-        this.#diags.raise(`Unexpected ArgName argument type: ${typescript_1.default.SyntaxKind[nameParam.kind]}`, parameter.node);
-    }
-    mapSchema(schema) {
-        if (Array.isArray(schema.type)) {
-            this.#diags.raise(`OpenApi 3.0.x doesn't support type arrays: ${JSON.stringify(schema.type)}`);
-            return;
-        }
-        if (schema.$ref) {
-            const $ref = schema.$ref.replace("#/definitions/", "#/components/schemas/");
-            return { $ref };
-        }
-        const [maximum, exclusiveMaximum] = getMaxes();
-        const [minimum, exclusiveMinimum] = getMins();
-        const base = {
-            title: schema.title,
-            multipleOf: schema.multipleOf,
-            maximum,
-            exclusiveMaximum,
-            minimum,
-            exclusiveMinimum,
-            maxLength: schema.maxLength,
-            minLength: schema.minLength,
-            pattern: schema.pattern,
-            maxItems: schema.maxItems,
-            minItems: schema.minItems,
-            uniqueItems: schema.uniqueItems,
-            maxProperties: schema.maxProperties,
-            minProperties: schema.minProperties,
-            required: schema.required,
-            enum: schema.enum,
-            description: schema.description,
-            format: schema.format,
-            default: schema.default,
-            // OpenApi 3.0.x doesn't support boolean schema types, so filter those out when mapping these fields
-            allOf: schema.allOf?.filter(isSchema).map(s => this.mapSchema(s)).filter(isValid),
-            oneOf: schema.oneOf?.filter(isSchema).map(s => this.mapSchema(s)).filter(isValid),
-            anyOf: schema.anyOf?.filter(isSchema).map(s => this.mapSchema(s)).filter(isValid),
-            not: schema.not
-                ? isSchema(schema.not) ? this.mapSchema(schema.not) : undefined
-                : undefined,
-            properties: schema.properties
-                ? Object.fromEntries(Object.entries(schema.properties)
-                    .filter((entry) => isSchema(entry[1]))
-                    .map(([name, prop]) => [name, this.mapSchema(prop)])
-                    .filter((entry) => isValid(entry[1])))
-                : undefined,
-            additionalProperties: typeof schema.additionalProperties === 'object'
-                ? this.mapSchema(schema.additionalProperties)
-                : schema.additionalProperties,
-        };
-        if (schema.type === 'array') {
-            if (schema.items === undefined) {
-                this.#diags.raise(`Array schema has no items`);
-                return;
-            }
-            if (Array.isArray(schema.items)) {
-                this.#diags.raise(`OpenApi 3.0.x doesn't support array items arrays: ${JSON.stringify(schema.items)}`);
-                return;
-            }
-            if (typeof schema.items === 'boolean') {
-                this.#diags.raise(`OpenApi 3.0.x doesn't support array items booleans: ${JSON.stringify(schema.items)}`);
-                return;
-            }
-            return {
-                type: schema.type,
-                items: this.mapSchema(schema.items),
-                ...base,
-            };
-        }
-        return {
-            // OpenApi 3.0.x doesn't support null type value, so map null type to undefined and add nullable: true property
-            type: schema.type === 'null' ? undefined : schema.type,
-            ...base,
-            nullable: schema.type === 'null' ? true : undefined,
-        };
-        function isSchema(schema) {
-            return typeof schema === "object";
-        }
-        // Convert JSON Schema Draft 7 (used by ts-json-schema-generator) max/min and exclusive max/min values to JSON Schema Draft 5 (used by OpenAPI).
-        // In Draft 5, exclusive max/min values are booleans
-        // In Draft 7, exclusive max/min values are numbers
-        function getMaxes() {
-            const { maximum: max, exclusiveMaximum: xMax } = schema;
-            if (max) {
-                if (xMax) {
-                    return (xMax < max) ? [xMax, true] : [max, false];
-                }
-                else {
-                    return [max, false];
-                }
-            }
-            else {
-                return xMax ? [xMax, true] : [undefined, undefined];
-            }
-        }
-        function getMins() {
-            const { minimum: min, exclusiveMinimum: xMin } = schema;
-            if (min) {
-                if (xMin) {
-                    return (xMin > min) ? [xMin, true] : [min, false];
-                }
-                else {
-                    return [min, false];
-                }
-            }
-            else {
-                return xMin ? [xMin, true] : [undefined, undefined];
-            }
-        }
-    }
-    parseStringLiteralArray(node) {
-        if (!node)
-            return undefined;
-        if (!typescript_1.default.isArrayLiteralExpression(node)) {
-            this.#diags.raise(`Expected Array Literal node, received: ${typescript_1.default.SyntaxKind[node.kind]}`, node);
-            return;
-        }
-        const values = new Array();
-        for (const exp of node.elements) {
-            if (typescript_1.default.isStringLiteral(exp)) {
-                values.push(exp.getText());
-            }
-            else {
-                this.#diags.raise(`Expected String Literal node, received: ${typescript_1.default.SyntaxKind[exp.kind]}`, exp);
-            }
-        }
-        return values;
-    }
-    parseSecurityScheme(arg) {
-        if (!arg)
-            return undefined;
-        if (!typescript_1.default.isObjectLiteralExpression(arg)) {
-            this.#diags.raise(`Expected Object Literal node, received: ${typescript_1.default.SyntaxKind[arg.kind]}`, arg);
-            return undefined;
-        }
-        const map = new Map();
-        for (const prop of arg.properties) {
-            if (!typescript_1.default.isPropertyAssignment(prop)) {
-                this.#diags.raise(`Expected Property Assignment node, received: ${typescript_1.default.SyntaxKind[prop.kind]}`, prop);
-                continue;
-            }
-            if (!typescript_1.default.isStringLiteral(prop.initializer)) {
-                this.#diags.raise(`Expected String Literal node, received: ${typescript_1.default.SyntaxKind[prop.initializer.kind]}`, prop.initializer);
-                continue;
-            }
-            map.set(prop.name.getText(), prop.initializer.text);
-        }
-        const type = map.get("type");
-        const description = map.get("description");
-        if (!type) {
-            this.#diags.raise(`missing type property`, arg);
-            return;
-        }
-        if (type === 'http') {
-            const scheme = map.get("scheme");
-            if (!scheme) {
-                this.#diags.raise(`missing scheme property`, arg);
-                return;
-            }
-            const bearerFormat = map.get("bearerFormat");
-            return { type, scheme, bearerFormat, description };
-        }
-        if (type === 'apiKey') {
-            const name = map.get("name");
-            if (!name) {
-                this.#diags.raise(`missing name property`, arg);
-                return;
-            }
-            const $in = map.get("id");
-            if (!$in) {
-                this.#diags.raise(`missing in property`, arg);
-                return;
-            }
-            return { type, name, in: $in, description };
-        }
-        if (type === "openIdConnect") {
-            const openIdConnectUrl = map.get("openIdConnectUrl");
-            if (!openIdConnectUrl) {
-                this.#diags.raise(`missing openIdConnectUrl property`, arg);
-                return;
-            }
-            return { type, openIdConnectUrl, description };
-        }
-        if (type === 'oauth2') {
-            this.#diags.raise(`OAuth2 Security Scheme not supported`, arg);
-        }
-        else {
-            this.#diags.raise(`unrecognized Security Scheme type ${type}`, arg);
-        }
-        return;
-    }
-}
-exports.OpenApiGenerator = OpenApiGenerator;
-async function findPackageInfo(entrypoint) {
-    let dirname = node_path_1.default.dirname(entrypoint);
-    while (dirname !== '/') {
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const packageJson = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dirname, 'package.json'), { encoding: 'utf-8' }));
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            const name = packageJson.name ?? "unknown";
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            const version = packageJson.version;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            const isPrivate = packageJson.private ?? false;
-            return {
-                name,
-                version: version
-                    ? version
-                    : isPrivate ? "private" : "unknown"
-            };
-        }
-        catch (error) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        dirname = node_path_1.default.dirname(dirname);
-    }
-    return { name: "unknown", version: "unknown" };
-}
-async function generateOpenApi(entrypoint) {
-    const program = typescript_1.default.createProgram([entrypoint], {});
-    const parser = new TypeParser_1.TypeParser(program);
-    const classes = parser.parse();
-    (0, tsDiagUtil_1.logDiagnostics)(parser.diags);
-    if (!classes || classes.length === 0)
-        return undefined;
-    const { name, version } = await findPackageInfo(entrypoint);
-    const generator = new OpenApiGenerator(program);
-    const openapi = generator.generate(classes, name, version);
-    (0, tsDiagUtil_1.logDiagnostics)(generator.diags);
-    return openapi;
-}
-exports.generateOpenApi = generateOpenApi;
-//# sourceMappingURL=openApi.js.map