nestjs-openapi 0.1.1 → 0.1.3

package/dist/cli.mjs

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import 'tsx';
-import { g as generate, e as formatValidationResult } from './shared/nestjs-openapi.CCvQ3RSW.mjs';
+import { g as generate, e as formatValidationResult } from './shared/nestjs-openapi.D2c4bMP5.mjs';
 import minimist from 'minimist';
 import { relative } from 'node:path';
 import { createRequire } from 'node:module';
 import 'effect';
 import 'node:fs';
+import 'node:crypto';
 import 'ts-morph';
 import 'glob';
 import 'js-yaml';
-import './shared/nestjs-openapi.CzNt1duF.mjs';
+import './shared/nestjs-openapi.DRcy130f.mjs';
 import 'ts-json-schema-generator';
-import 'node:crypto';
 import 'node:url';
 import 'child_process';
 
@@ -117,7 +117,7 @@ const main = async () => {
         console.log(`  ${formatValidationResult(result.validation)}`);
       }
     }
-    process.exit(0);
+    process.exit(result.validation.valid ? 0 : 1);
   } catch (err) {
     const duration = performance.now() - startTime;
     const message = err instanceof Error ? err.message : String(err);

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { Effect, Context, Layer, Option } from 'effect';
-import { C as ConfigNotFoundError, O as OpenApiGeneratorConfig, a as ConfigError, R as ResolvedConfig, P as ProjectError, b as ProjectInitError, E as EntryNotFoundError, M as MethodInfo, c as OpenApiPaths$1 } from './shared/nestjs-openapi.BYUrTaMo.mjs';
-export { A as AnalysisError, i as ConfigLoadError, j as ConfigValidationError, G as GenerateOptions, k as GeneratorError, H as HttpMethod, I as InvalidMethodError, e as ParameterLocation, f as ResolvedParameter, h as ReturnTypeInfo, d as generateAsync, g as generateEffect } from './shared/nestjs-openapi.BYUrTaMo.mjs';
+import { C as ConfigNotFoundError, O as OpenApiGeneratorConfig, a as ConfigError, R as ResolvedConfig, P as ProjectError, b as ProjectInitError, E as EntryNotFoundError, M as MethodInfo, c as OpenApiPaths$1 } from './shared/nestjs-openapi.t3iwzrrT.mjs';
+export { A as AnalysisError, i as ConfigLoadError, j as ConfigValidationError, G as GenerateOptions, k as GeneratorError, H as HttpMethod, I as InvalidMethodError, e as ParameterLocation, f as ResolvedParameter, h as ReturnTypeInfo, d as generateAsync, g as generateEffect } from './shared/nestjs-openapi.t3iwzrrT.mjs';
 import { DynamicModule } from '@nestjs/common';
 import { Project, SourceFile, ClassDeclaration, MethodDeclaration, Decorator, Symbol, ObjectLiteralExpression, Expression } from 'ts-morph';
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Context, Layer, Option } from 'effect';
-import { C as ConfigNotFoundError, O as OpenApiGeneratorConfig, a as ConfigError, R as ResolvedConfig, P as ProjectError, b as ProjectInitError, E as EntryNotFoundError, M as MethodInfo, c as OpenApiPaths$1 } from './shared/nestjs-openapi.BYUrTaMo.js';
-export { A as AnalysisError, i as ConfigLoadError, j as ConfigValidationError, G as GenerateOptions, k as GeneratorError, H as HttpMethod, I as InvalidMethodError, e as ParameterLocation, f as ResolvedParameter, h as ReturnTypeInfo, d as generateAsync, g as generateEffect } from './shared/nestjs-openapi.BYUrTaMo.js';
+import { C as ConfigNotFoundError, O as OpenApiGeneratorConfig, a as ConfigError, R as ResolvedConfig, P as ProjectError, b as ProjectInitError, E as EntryNotFoundError, M as MethodInfo, c as OpenApiPaths$1 } from './shared/nestjs-openapi.t3iwzrrT.js';
+export { A as AnalysisError, i as ConfigLoadError, j as ConfigValidationError, G as GenerateOptions, k as GeneratorError, H as HttpMethod, I as InvalidMethodError, e as ParameterLocation, f as ResolvedParameter, h as ReturnTypeInfo, d as generateAsync, g as generateEffect } from './shared/nestjs-openapi.t3iwzrrT.js';
 import { DynamicModule } from '@nestjs/common';
 import { Project, SourceFile, ClassDeclaration, MethodDeclaration, Decorator, Symbol, ObjectLiteralExpression, Expression } from 'ts-morph';
 

package/dist/index.mjs

@@ -1,16 +1,16 @@
-export { c as categorizeBrokenRefs, d as defineConfig, f as findConfigFile, e as formatValidationResult, g as generate, b as loadAndResolveConfig, a as loadConfig, l as loadConfigFromFile, r as resolveConfig, v as validateSpec } from './shared/nestjs-openapi.CCvQ3RSW.mjs';
+export { c as categorizeBrokenRefs, d as defineConfig, f as findConfigFile, e as formatValidationResult, g as generate, b as loadAndResolveConfig, a as loadConfig, l as loadConfigFromFile, r as resolveConfig, v as validateSpec } from './shared/nestjs-openapi.D2c4bMP5.mjs';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Module } from '@nestjs/common';
 export { generateAsync, generate as generateEffect } from './internal.mjs';
-import { P as ProjectInitError, E as EntryNotFoundError } from './shared/nestjs-openapi.CzNt1duF.mjs';
-export { a as ConfigLoadError, C as ConfigNotFoundError, b as ConfigValidationError, I as InvalidMethodError, c as getAllControllers, q as getArrayInitializer, o as getControllerMethodInfos, e as getControllerName, d as getControllerPrefix, j as getControllerTags, h as getDecoratorName, k as getHttpDecorator, f as getHttpMethods, m as getMethodInfo, w as getModuleDecoratorArg, z as getModuleMetadata, g as getModules, s as getStringLiteralValue, u as getSymbolFromIdentifier, l as isHttpDecorator, i as isHttpMethod, v as isModuleClass, n as normalizePath, y as resolveArrayOfClasses, x as resolveClassFromExpression, r as resolveClassFromSymbol, t as transformMethod, p as transformMethods } from './shared/nestjs-openapi.CzNt1duF.mjs';
+import { P as ProjectInitError, E as EntryNotFoundError } from './shared/nestjs-openapi.DRcy130f.mjs';
+export { a as ConfigLoadError, C as ConfigNotFoundError, b as ConfigValidationError, I as InvalidMethodError, c as getAllControllers, q as getArrayInitializer, o as getControllerMethodInfos, e as getControllerName, d as getControllerPrefix, j as getControllerTags, h as getDecoratorName, k as getHttpDecorator, f as getHttpMethods, m as getMethodInfo, w as getModuleDecoratorArg, z as getModuleMetadata, g as getModules, s as getStringLiteralValue, u as getSymbolFromIdentifier, l as isHttpDecorator, i as isHttpMethod, v as isModuleClass, n as normalizePath, y as resolveArrayOfClasses, x as resolveClassFromExpression, r as resolveClassFromSymbol, t as transformMethod, p as transformMethods } from './shared/nestjs-openapi.DRcy130f.mjs';
 import { Context, Effect, Layer } from 'effect';
 import { Project } from 'ts-morph';
+import 'node:crypto';
 import 'glob';
 import 'js-yaml';
 import 'ts-json-schema-generator';
-import 'node:crypto';
 import 'node:url';
 import 'child_process';
 

package/dist/internal.d.mts

@@ -1,2 +1,2 @@
 import 'effect';
-export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.BYUrTaMo.mjs';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.t3iwzrrT.mjs';

package/dist/internal.d.ts

@@ -1,2 +1,2 @@
 import 'effect';
-export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.BYUrTaMo.js';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.t3iwzrrT.js';

package/dist/internal.mjs

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
 import { Project } from 'ts-morph';
-import { E as EntryNotFoundError, g as getModules, o as getControllerMethodInfos, p as transformMethods } from './shared/nestjs-openapi.CzNt1duF.mjs';
+import { E as EntryNotFoundError, g as getModules, o as getControllerMethodInfos, p as transformMethods } from './shared/nestjs-openapi.DRcy130f.mjs';
 
 const generate = (options) => Effect.gen(function* () {
   yield* Effect.logInfo("Starting OpenAPI generation").pipe(

package/dist/shared/{nestjs-openapi.CCvQ3RSW.mjs → nestjs-openapi.D2c4bMP5.mjs}

@@ -1,12 +1,12 @@
 import { Schema, Effect, Logger, Layer, LogLevel } from 'effect';
 import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
+import { join, dirname, resolve, relative } from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { Project } from 'ts-morph';
 import { globSync, glob } from 'glob';
 import yaml from 'js-yaml';
-import { C as ConfigNotFoundError, a as ConfigLoadError, b as ConfigValidationError, p as transformMethods, A as extractClassConstraints, B as getRequiredProperties, D as mergeValidationConstraints, E as EntryNotFoundError, g as getModules, o as getControllerMethodInfos } from './nestjs-openapi.CzNt1duF.mjs';
+import { C as ConfigNotFoundError, a as ConfigLoadError, b as ConfigValidationError, p as transformMethods, A as extractClassConstraints, B as getRequiredProperties, D as mergeValidationConstraints, E as EntryNotFoundError, g as getModules, o as getControllerMethodInfos } from './nestjs-openapi.DRcy130f.mjs';
 import { createGenerator } from 'ts-json-schema-generator';
-import { randomUUID } from 'node:crypto';
 import { pathToFileURL } from 'node:url';
 import { execSync } from 'child_process';
 
@@ -466,6 +466,12 @@ const extractReferencedSchemas = (paths) => {
     if (schema.oneOf) {
       schema.oneOf.forEach(extractFromSchema);
     }
+    if (schema.allOf) {
+      schema.allOf.forEach(extractFromSchema);
+    }
+    if (schema.anyOf) {
+      schema.anyOf.forEach(extractFromSchema);
+    }
     if (schema.properties) {
       Object.values(schema.properties).forEach(extractFromSchema);
     }
@@ -529,7 +535,14 @@ const extractNestedReferences = (schemas, knownSchemas) => {
 };
 const convertToOpenApiSchema = (schema) => {
   const result = {};
-  if (schema.type) result["type"] = schema.type;
+  if (Array.isArray(schema.type)) {
+    const nonNull = schema.type.filter((t) => t !== "null");
+    const isNullable = nonNull.length < schema.type.length;
+    result["type"] = nonNull.length === 1 ? nonNull[0] : schema.type;
+    if (isNullable && nonNull.length === 1) result["nullable"] = true;
+  } else if (schema.type) {
+    result["type"] = schema.type;
+  }
   if (schema.format) result["format"] = schema.format;
   if (schema.$ref) {
     result["$ref"] = schema.$ref.replace(
@@ -633,7 +646,11 @@ const createPathFilter = (pathFilter) => {
   if (typeof pathFilter === "function") {
     return (method) => pathFilter(method.path);
   }
-  return (method) => pathFilter.test(method.path);
+  const pattern = new RegExp(pathFilter.source, pathFilter.flags);
+  return (method) => {
+    pattern.lastIndex = 0;
+    return pattern.test(method.path);
+  };
 };
 const combineFilters = (filters) => {
   if (filters.length === 0) {
@@ -665,6 +682,11 @@ const filterMethods = (methods, options) => {
   return methods.filter(filter);
 };
 
+const NULL_SCHEMA = { type: "null" };
+const schemaIncludesNull = (schema) => {
+  if (schema.type === "null") return true;
+  return Array.isArray(schema.type) && schema.type.includes("null");
+};
 const transformSchemaToV31 = (schema) => {
   const transformedOneOf = schema.oneOf?.map(transformSchemaToV31);
   const transformedAnyOf = schema.anyOf?.map(transformSchemaToV31);
@@ -676,19 +698,36 @@ const transformSchemaToV31 = (schema) => {
       transformSchemaToV31(value)
     ])
   ) : void 0;
-  const hasNullable = schema.nullable && schema.type && typeof schema.type === "string";
-  const transformedType = hasNullable ? [schema.type, "null"] : schema.type;
-  const { nullable: _nullable, ...restWithoutNullable } = schema;
-  return {
+  const { nullable, ...restWithoutNullable } = schema;
+  const transformedType = nullable && typeof schema.type === "string" ? [schema.type, "null"] : schema.type;
+  const transformedSchema = {
     ...restWithoutNullable,
-    type: transformedType,
+    ...transformedType !== void 0 && { type: transformedType },
     ...transformedOneOf && { oneOf: transformedOneOf },
     ...transformedAnyOf && { anyOf: transformedAnyOf },
     ...transformedAllOf && { allOf: transformedAllOf },
     ...transformedItems && { items: transformedItems },
     ...transformedProperties && { properties: transformedProperties }
   };
+  if (!nullable) return transformedSchema;
+  if (schema.type && typeof schema.type === "string") {
+    return transformedSchema;
+  }
+  if (transformedSchema.oneOf) {
+    return {
+      ...transformedSchema,
+      oneOf: schemaIncludesNullInVariants(transformedSchema.oneOf) ? transformedSchema.oneOf : [...transformedSchema.oneOf, NULL_SCHEMA]
+    };
+  }
+  if (transformedSchema.anyOf) {
+    return {
+      ...transformedSchema,
+      anyOf: schemaIncludesNullInVariants(transformedSchema.anyOf) ? transformedSchema.anyOf : [...transformedSchema.anyOf, NULL_SCHEMA]
+    };
+  }
+  return { anyOf: [transformedSchema, NULL_SCHEMA] };
 };
+const schemaIncludesNullInVariants = (variants) => variants.some(schemaIncludesNull);
 const transformSchemasForVersion = (schemas, version) => {
   if (version === "3.0.3") {
     return schemas;
@@ -700,14 +739,81 @@ const transformSchemasForVersion = (schemas, version) => {
     ])
   );
 };
+const transformOperationToV31 = (operation) => {
+  const parameters = operation.parameters?.map((param) => ({
+    ...param,
+    schema: transformSchemaToV31(param.schema)
+  }));
+  const requestBody = operation.requestBody ? {
+    ...operation.requestBody,
+    content: Object.fromEntries(
+      Object.entries(operation.requestBody.content).map(
+        ([contentType, mediaType]) => [
+          contentType,
+          { ...mediaType, schema: transformSchemaToV31(mediaType.schema) }
+        ]
+      )
+    )
+  } : void 0;
+  const responses = Object.fromEntries(
+    Object.entries(operation.responses).map(([code, response]) => [
+      code,
+      response.content ? {
+        ...response,
+        content: Object.fromEntries(
+          Object.entries(response.content).map(
+            ([contentType, mediaType]) => [
+              contentType,
+              {
+                ...mediaType,
+                schema: transformSchemaToV31(mediaType.schema)
+              }
+            ]
+          )
+        )
+      } : response
+    ])
+  );
+  return {
+    ...operation,
+    ...parameters && { parameters },
+    ...requestBody && { requestBody },
+    responses
+  };
+};
+const HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace"
+]);
+const transformPathsForVersion = (paths, version) => {
+  if (version === "3.0.3") return paths;
+  return Object.fromEntries(
+    Object.entries(paths).map(([path, pathItem]) => [
+      path,
+      Object.fromEntries(
+        Object.entries(pathItem).map(
+          ([key, value]) => HTTP_METHODS.has(key) ? [key, transformOperationToV31(value)] : [key, value]
+        )
+      )
+    ])
+  );
+};
 const transformSpecForVersion = (spec, version) => {
   if (version === "3.0.3") {
     return { ...spec, openapi: version };
   }
   const transformedSchemas = spec.components?.schemas ? transformSchemasForVersion(spec.components.schemas, version) : void 0;
+  const transformedPaths = transformPathsForVersion(spec.paths, version);
   return {
     ...spec,
     openapi: version,
+    paths: transformedPaths,
     ...transformedSchemas && {
       components: {
         ...spec.components,
@@ -886,22 +992,59 @@ const OpenApiTagConfig = Schema.Struct({
   name: Schema.String,
   description: Schema.optional(Schema.String)
 });
-const SecuritySchemeType = Schema.Literal(
+Schema.Literal(
   "apiKey",
   "http",
   "oauth2",
   "openIdConnect"
 );
 const SecuritySchemeIn = Schema.Literal("query", "header", "cookie");
-const SecuritySchemeConfig = Schema.Struct({
+const OAuth2FlowConfig = Schema.Struct({
+  authorizationUrl: Schema.optional(Schema.String),
+  tokenUrl: Schema.optional(Schema.String),
+  refreshUrl: Schema.optional(Schema.String),
+  scopes: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.String })
+  )
+});
+const OAuth2FlowsConfig = Schema.Struct({
+  implicit: Schema.optional(OAuth2FlowConfig),
+  password: Schema.optional(OAuth2FlowConfig),
+  clientCredentials: Schema.optional(OAuth2FlowConfig),
+  authorizationCode: Schema.optional(OAuth2FlowConfig)
+});
+const HttpSecuritySchemeConfig = Schema.Struct({
   name: Schema.String,
-  type: SecuritySchemeType,
-  scheme: Schema.optional(Schema.String),
+  type: Schema.Literal("http"),
+  scheme: Schema.String,
   bearerFormat: Schema.optional(Schema.String),
-  in: Schema.optional(SecuritySchemeIn),
-  parameterName: Schema.optional(Schema.String),
   description: Schema.optional(Schema.String)
 });
+const ApiKeySecuritySchemeConfig = Schema.Struct({
+  name: Schema.String,
+  type: Schema.Literal("apiKey"),
+  in: SecuritySchemeIn,
+  parameterName: Schema.String,
+  description: Schema.optional(Schema.String)
+});
+const OAuth2SecuritySchemeConfig = Schema.Struct({
+  name: Schema.String,
+  type: Schema.Literal("oauth2"),
+  flows: OAuth2FlowsConfig,
+  description: Schema.optional(Schema.String)
+});
+const OpenIdConnectSecuritySchemeConfig = Schema.Struct({
+  name: Schema.String,
+  type: Schema.Literal("openIdConnect"),
+  openIdConnectUrl: Schema.String,
+  description: Schema.optional(Schema.String)
+});
+const SecuritySchemeConfig = Schema.Union(
+  HttpSecuritySchemeConfig,
+  ApiKeySecuritySchemeConfig,
+  OAuth2SecuritySchemeConfig,
+  OpenIdConnectSecuritySchemeConfig
+);
 const SecurityRequirement = Schema.Record({
   key: Schema.String,
   value: Schema.Array(Schema.String)
@@ -1008,7 +1151,7 @@ const CONFIG_FILE_NAMES = [
   "openapi.config.cjs"
 ];
 const DEFAULT_ENTRY$1 = "src/app.module.ts";
-const DEFAULT_DTO_GLOB = [
+const DEFAULT_DTO_GLOB$1 = [
   "**/*.dto.ts",
   "**/*.entity.ts",
   "**/*.model.ts",
@@ -1035,8 +1178,7 @@ const DEFAULT_CONFIG = {
 };
 const findConfigFile = (startDir = process.cwd()) => Effect.gen(function* () {
   let currentDir = resolve(startDir);
-  const root = dirname(currentDir);
-  while (currentDir !== root) {
+  while (true) {
     for (const fileName of CONFIG_FILE_NAMES) {
       const configPath = resolve(currentDir, fileName);
       if (existsSync(configPath)) {
@@ -1125,7 +1267,7 @@ const resolveConfig = (config) => {
   const rawEntry = files.entry ?? DEFAULT_ENTRY$1;
   const entry = Array.isArray(rawEntry) ? rawEntry : [rawEntry];
   const rawDtoGlob = files.dtoGlob;
-  const dtoGlob = rawDtoGlob ? Array.isArray(rawDtoGlob) ? rawDtoGlob : [rawDtoGlob] : [...DEFAULT_DTO_GLOB];
+  const dtoGlob = rawDtoGlob ? Array.isArray(rawDtoGlob) ? rawDtoGlob : [rawDtoGlob] : [...DEFAULT_DTO_GLOB$1];
   const tsconfig = files.tsconfig;
   if (!tsconfig) {
     throw new Error("tsconfig is required in files configuration");
@@ -1404,6 +1546,22 @@ function resolveTypeLocationsFast(baseDir, missingTypes) {
 }
 
 const DEFAULT_ENTRY = "src/app.module.ts";
+const DEFAULT_DTO_GLOB = [
+  "**/*.dto.ts",
+  "**/*.entity.ts",
+  "**/*.model.ts",
+  "**/*.schema.ts"
+];
+const mergeSingleSecurityRequirement = (left, right) => {
+  const merged = {};
+  for (const requirement of [left, right]) {
+    for (const [scheme, scopes] of Object.entries(requirement)) {
+      const existingScopes = merged[scheme] ?? [];
+      merged[scheme] = [.../* @__PURE__ */ new Set([...existingScopes, ...scopes])];
+    }
+  }
+  return merged;
+};
 const mergeSecurityWithGlobal = (paths, globalSecurity) => {
   if (!globalSecurity || globalSecurity.length === 0) {
     return paths;
@@ -1413,23 +1571,17 @@ const mergeSecurityWithGlobal = (paths, globalSecurity) => {
     const mergedMethods = {};
     for (const [method, operation] of Object.entries(methods)) {
       if (operation.security && operation.security.length > 0) {
-        const merged = {};
+        const mergedSecurity = [];
         for (const globalReq of globalSecurity) {
-          for (const [scheme, scopes] of Object.entries(globalReq)) {
-            merged[scheme] = [...merged[scheme] ?? [], ...scopes];
+          for (const operationReq of operation.security) {
+            mergedSecurity.push(
+              mergeSingleSecurityRequirement(globalReq, operationReq)
+            );
           }
         }
-        for (const decoratorReq of operation.security) {
-          for (const [scheme, scopes] of Object.entries(decoratorReq)) {
-            merged[scheme] = [...merged[scheme] ?? [], ...scopes];
-          }
-        }
-        for (const scheme of Object.keys(merged)) {
-          merged[scheme] = [...new Set(merged[scheme])];
-        }
         mergedMethods[method] = {
           ...operation,
-          security: [merged]
+          security: mergedSecurity
         };
       } else {
         mergedMethods[method] = operation;
@@ -1493,6 +1645,131 @@ const findMissingSchemaRefs = (paths, schemas) => {
   findRefs(paths);
   return missing;
 };
+const isGenericSchemaRef = (name) => name.includes("<") && name.endsWith(">");
+const NON_IMPORTABLE_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "undefined",
+  "void",
+  "unknown",
+  "any",
+  "never",
+  "object",
+  "true",
+  "false",
+  "Array",
+  "ReadonlyArray",
+  "Record",
+  "Promise",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "Readonly",
+  "keyof",
+  "infer",
+  "extends"
+]);
+const extractTypeIdentifiers = (typeRef) => {
+  const withoutStringLiterals = typeRef.replace(
+    /'[^']*'|"[^"]*"|`[^`]*`/g,
+    ""
+  );
+  const matches = withoutStringLiterals.match(/\b[A-Za-z_$][A-Za-z0-9_$]*\b/g) ?? [];
+  return new Set(
+    matches.filter((name) => !NON_IMPORTABLE_TYPE_NAMES.has(name))
+  );
+};
+const toModuleImportPath = (fromDir, filePath) => {
+  const importPath = relative(fromDir, filePath).replace(/\\/g, "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+};
+const resolveSymbolLocations = (tsconfig, symbolNames) => {
+  if (symbolNames.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const tsconfigDir = dirname(tsconfig);
+  const resolved = resolveTypeLocationsFast(tsconfigDir, symbolNames);
+  const unresolved = new Set(
+    [...symbolNames].filter((name) => !resolved.has(name))
+  );
+  if (unresolved.size > 0) {
+    const project = createTypeResolverProject(tsconfig);
+    const morphResolved = resolveTypeLocations(project, unresolved);
+    for (const [name, filePath] of morphResolved) {
+      resolved.set(name, filePath);
+    }
+  }
+  return resolved;
+};
+const generateMissingGenericSchemas = async (genericRefs, tsconfig, symbolLocations, runEffect) => {
+  if (genericRefs.length === 0) {
+    return { definitions: {} };
+  }
+  const importGroups = /* @__PURE__ */ new Map();
+  const aliases = [];
+  const aliasLines = [];
+  for (const [index, genericRef] of genericRefs.entries()) {
+    const identifiers = [...extractTypeIdentifiers(genericRef)];
+    if (identifiers.length === 0) {
+      continue;
+    }
+    const unresolved = identifiers.filter((name) => !symbolLocations.has(name));
+    if (unresolved.length > 0) {
+      continue;
+    }
+    for (const identifier of identifiers) {
+      const filePath = symbolLocations.get(identifier);
+      if (!filePath) continue;
+      const existing = importGroups.get(filePath) ?? /* @__PURE__ */ new Set();
+      existing.add(identifier);
+      importGroups.set(filePath, existing);
+    }
+    const aliasName = `__MissingGenericRef${index}`;
+    aliases.push({ aliasName, schemaName: genericRef });
+    aliasLines.push(`export type ${aliasName} = ${genericRef};`);
+  }
+  if (aliases.length === 0) {
+    return { definitions: {} };
+  }
+  const tempDir = dirname(tsconfig);
+  const tempFilePath = join(
+    tempDir,
+    `.openapi.missing-generic.${randomUUID()}.ts`
+  );
+  const importLines = [...importGroups.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([filePath, symbols]) => {
+    const importPath = toModuleImportPath(tempDir, filePath);
+    const names = [...symbols].sort().join(", ");
+    return `import type { ${names} } from '${importPath}';`;
+  });
+  writeFileSync(
+    tempFilePath,
+    [...importLines, "", ...aliasLines, ""].join("\n"),
+    "utf-8"
+  );
+  try {
+    const generated = await runEffect(
+      generateSchemasFromFiles([tempFilePath], tsconfig)
+    );
+    const definitions = { ...generated.definitions };
+    for (const { aliasName, schemaName } of aliases) {
+      const resolvedSchema = definitions[schemaName] ?? definitions[aliasName] ?? void 0;
+      if (resolvedSchema) {
+        definitions[schemaName] = resolvedSchema;
+      }
+      delete definitions[aliasName];
+    }
+    return { definitions };
+  } finally {
+    if (existsSync(tempFilePath)) {
+      unlinkSync(tempFilePath);
+    }
+  }
+};
 const extractValidationConstraints = async (dtoGlobPatterns, basePath, tsconfig, schemas) => {
   const absolutePatterns = dtoGlobPatterns.map(
     (pattern) => pattern.startsWith("/") ? pattern : join(basePath, pattern)
@@ -1539,8 +1816,7 @@ const extractValidationConstraints = async (dtoGlobPatterns, basePath, tsconfig,
 };
 const findTsConfig = (startDir) => {
   let currentDir = resolve(startDir);
-  const root = dirname(currentDir);
-  while (currentDir !== root) {
+  while (true) {
     const tsconfigPath = join(currentDir, "tsconfig.json");
     if (existsSync(tsconfigPath)) {
       return tsconfigPath;
@@ -1635,19 +1911,30 @@ const generate = async (configPath, overrides) => {
     (e) => resolve(configDir, e)
   );
   const output = resolve(configDir, config.output);
-  const tsconfig = files.tsconfig ? resolve(configDir, files.tsconfig) : findTsConfig(dirname(entries[0]));
-  if (!tsconfig) {
-    throw new Error(
-      `Could not find tsconfig.json. Please specify files.tsconfig in your config file.`
-    );
-  }
-  if (!existsSync(tsconfig)) {
-    throw new Error(`tsconfig.json not found at: ${tsconfig}`);
-  }
+  const tsconfig = await runEffect(
+    Effect.gen(function* () {
+      const discoveredTsconfig = files.tsconfig ? resolve(configDir, files.tsconfig) : findTsConfig(dirname(entries[0]));
+      if (!discoveredTsconfig) {
+        return yield* Effect.fail(
+          ConfigValidationError.fromIssues(absoluteConfigPath, [
+            "Could not find tsconfig.json. Please specify files.tsconfig in your config file."
+          ])
+        );
+      }
+      if (!existsSync(discoveredTsconfig)) {
+        return yield* Effect.fail(
+          ConfigValidationError.fromIssues(absoluteConfigPath, [
+            `tsconfig.json not found at: ${discoveredTsconfig}`
+          ])
+        );
+      }
+      return discoveredTsconfig;
+    }).pipe(Effect.mapError((error) => new Error(error.message)))
+  );
   const extractOptions = {
     query: options.query
   };
-  const dtoGlobArray = files.dtoGlob ? Array.isArray(files.dtoGlob) ? files.dtoGlob : [files.dtoGlob] : null;
+  const dtoGlobArray = files.dtoGlob === void 0 ? [...DEFAULT_DTO_GLOB] : Array.isArray(files.dtoGlob) ? files.dtoGlob : [files.dtoGlob];
   const [extractedMethodInfos, initialSchemas] = await Promise.all([
     runEffect(
       extractMethodInfosEffect(tsconfig, entries, extractOptions).pipe(
@@ -1659,7 +1946,7 @@ const generate = async (configPath, overrides) => {
         Effect.mapError((error) => new Error(error.message))
       )
     ),
-    dtoGlobArray ? runEffect(
+    runEffect(
       generateSchemas({
         dtoGlob: dtoGlobArray,
         tsconfig,
@@ -1675,7 +1962,7 @@ const generate = async (configPath, overrides) => {
         ),
         Effect.mapError((error) => new Error(error.message))
       )
-    ) : Promise.resolve(null)
+    )
   ]);
   const filteredMethodInfos = filterMethods(extractedMethodInfos, {
     excludeDecorators: options.excludeDecorators,
@@ -1696,7 +1983,7 @@ const generate = async (configPath, overrides) => {
     security.global
   );
   let schemas = {};
-  if (initialSchemas && dtoGlobArray) {
+  if (initialSchemas) {
     let generatedSchemas = initialSchemas;
     const shouldExtractValidation = options.extractValidation !== false;
     if (shouldExtractValidation) {
@@ -1748,6 +2035,50 @@ const generate = async (configPath, overrides) => {
               ...normalizedAdditional.definitions
             }
           };
+          generatedSchemas = combinedSchemas;
+          mergeResult = mergeSchemas(
+            paths,
+            combinedSchemas
+          );
+          schemas = mergeResult.schemas;
+        }
+      }
+      const unresolvedAfterFileResolution = findMissingSchemaRefs(
+        paths,
+        schemas
+      );
+      const unresolvedGenericRefs = [...unresolvedAfterFileResolution].filter(
+        isGenericSchemaRef
+      );
+      if (unresolvedGenericRefs.length > 0) {
+        const genericSymbols = /* @__PURE__ */ new Set();
+        for (const ref of unresolvedGenericRefs) {
+          for (const symbol of extractTypeIdentifiers(ref)) {
+            genericSymbols.add(symbol);
+          }
+        }
+        const resolvedGenericSymbols = resolveSymbolLocations(
+          tsconfig,
+          genericSymbols
+        );
+        for (const [name, filePath] of resolvedLocations) {
+          resolvedGenericSymbols.set(name, filePath);
+        }
+        const genericSchemas = await generateMissingGenericSchemas(
+          unresolvedGenericRefs,
+          tsconfig,
+          resolvedGenericSymbols,
+          runEffect
+        );
+        if (Object.keys(genericSchemas.definitions).length > 0) {
+          const normalizedGeneric = normalizeStructureRefs(genericSchemas);
+          const combinedSchemas = {
+            definitions: {
+              ...generatedSchemas.definitions,
+              ...normalizedGeneric.definitions
+            }
+          };
+          generatedSchemas = combinedSchemas;
           mergeResult = mergeSchemas(
             paths,
             combinedSchemas

package/dist/shared/{nestjs-openapi.CzNt1duF.mjs → nestjs-openapi.DRcy130f.mjs}

@@ -703,6 +703,22 @@ const parseTypeText = (text) => {
   const trimmed = text.trim();
   return trimmed.startsWith("{") && trimmed.endsWith("}") ? { type: Option.none(), inline: Option.some(trimmed) } : { type: Option.some(trimmed), inline: Option.none() };
 };
+const getGenericBaseType = (text) => {
+  const genericStart = text.indexOf("<");
+  return genericStart === -1 ? null : text.slice(0, genericStart).trim();
+};
+const hasAliasedImportCollision = (method, exportedName) => {
+  const localNames = /* @__PURE__ */ new Set();
+  for (const importDecl of method.getSourceFile().getImportDeclarations()) {
+    for (const namedImport of importDecl.getNamedImports()) {
+      const aliasNode = namedImport.getAliasNode();
+      if (!aliasNode) continue;
+      if (namedImport.getName() !== exportedName) continue;
+      localNames.add(aliasNode.getText());
+    }
+  }
+  return localNames.size > 1;
+};
 const getReturnTypeInfo = (method) => {
   const returnType = method.getReturnType();
   const awaited = returnType.getAwaitedType?.() ?? returnType;
@@ -717,6 +733,25 @@ const getReturnTypeInfo = (method) => {
     return null;
   };
   let text = getOriginalTypeName() ?? awaited.getText(method);
+  const compilerType = awaited.compilerType;
+  const aliasName = compilerType.aliasSymbol?.escapedName?.toString();
+  if (aliasName && !aliasName.startsWith("__")) {
+    const genericBase = getGenericBaseType(text);
+    const shouldPreserveLocalAlias = genericBase !== null && genericBase !== aliasName && hasAliasedImportCollision(method, aliasName);
+    if (!shouldPreserveLocalAlias) {
+      text = genericBase === null ? aliasName : `${aliasName}${text.slice(text.indexOf("<"))}`;
+    }
+  }
+  const symbolName = symbol?.getName();
+  if (symbolName && !symbolName.startsWith("__")) {
+    const genericBase = getGenericBaseType(text);
+    if (genericBase !== null) {
+      const shouldPreserveLocalAlias = genericBase !== symbolName && hasAliasedImportCollision(method, symbolName);
+      if (!shouldPreserveLocalAlias) {
+        text = `${symbolName}${text.slice(text.indexOf("<"))}`;
+      }
+    }
+  }
   const promiseMatch = text.match(/^Promise<(.+)>$/);
   if (promiseMatch) text = promiseMatch[1].trim();
   text = text.replace(/\bimport\([^)]*\)\./g, "");
@@ -1306,10 +1341,16 @@ const tsTypeToOpenApiSchema = (tsType) => {
     }
   }
   if (trimmed.includes(" | ")) {
-    const types = trimmed.split(" | ").map((t) => t.trim());
-    return {
-      oneOf: types.map((type) => tsTypeToOpenApiSchema(type))
-    };
+    const allMembers = trimmed.split(" | ").map((t) => t.trim());
+    const hasNull = allMembers.includes("null");
+    const types = allMembers.filter((t) => t !== "undefined" && t !== "null");
+    if (types.length === 0) return { type: "object" };
+    const schema = types.length === 1 ? tsTypeToOpenApiSchema(types[0]) : { oneOf: types.map((type) => tsTypeToOpenApiSchema(type)) };
+    if (!hasNull) return schema;
+    if (schema.$ref) {
+      return { allOf: [{ $ref: schema.$ref }], nullable: true };
+    }
+    return { ...schema, nullable: true };
   }
   switch (trimmed.toLowerCase()) {
     case "string":

package/dist/shared/{nestjs-openapi.BYUrTaMo.d.mts → nestjs-openapi.t3iwzrrT.d.mts}

@@ -173,9 +173,12 @@ interface OpenApiSchema {
     readonly format?: string;
     readonly $ref?: string;
     readonly oneOf?: readonly OpenApiSchema[];
+    readonly allOf?: readonly OpenApiSchema[];
     readonly items?: OpenApiSchema;
     readonly properties?: Record<string, OpenApiSchema>;
     readonly required?: readonly string[];
+    /** OpenAPI 3.0 nullable flag */
+    readonly nullable?: boolean;
 }
 declare const OpenApiOperation: Schema.Struct<{
     operationId: typeof Schema.String;
@@ -249,15 +252,54 @@ declare const OpenApiGeneratorConfig: Schema.Struct<{
             description: Schema.optional<typeof Schema.String>;
         }>>>;
         security: Schema.optional<Schema.Struct<{
-            schemes: Schema.optional<Schema.Array$<Schema.Struct<{
+            schemes: Schema.optional<Schema.Array$<Schema.Union<[Schema.Struct<{
                 name: typeof Schema.String;
-                type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
-                scheme: Schema.optional<typeof Schema.String>;
+                type: Schema.Literal<["http"]>;
+                scheme: typeof Schema.String;
                 bearerFormat: Schema.optional<typeof Schema.String>;
-                in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
-                parameterName: Schema.optional<typeof Schema.String>;
                 description: Schema.optional<typeof Schema.String>;
-            }>>>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["apiKey"]>;
+                in: Schema.Literal<["query", "header", "cookie"]>;
+                parameterName: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["oauth2"]>;
+                flows: Schema.Struct<{
+                    implicit: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    password: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    clientCredentials: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    authorizationCode: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                }>;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["openIdConnect"]>;
+                openIdConnectUrl: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>]>>>;
             global: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>>;
         }>>;
     }>;
@@ -301,15 +343,54 @@ declare const ResolvedConfig: Schema.Struct<{
         url: typeof Schema.String;
         description: Schema.optional<typeof Schema.String>;
     }>>;
-    securitySchemes: Schema.Array$<Schema.Struct<{
+    securitySchemes: Schema.Array$<Schema.Union<[Schema.Struct<{
         name: typeof Schema.String;
-        type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
-        scheme: Schema.optional<typeof Schema.String>;
+        type: Schema.Literal<["http"]>;
+        scheme: typeof Schema.String;
         bearerFormat: Schema.optional<typeof Schema.String>;
-        in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
-        parameterName: Schema.optional<typeof Schema.String>;
         description: Schema.optional<typeof Schema.String>;
-    }>>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["apiKey"]>;
+        in: Schema.Literal<["query", "header", "cookie"]>;
+        parameterName: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["oauth2"]>;
+        flows: Schema.Struct<{
+            implicit: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            password: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            clientCredentials: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            authorizationCode: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+        }>;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["openIdConnect"]>;
+        openIdConnectUrl: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>]>>;
     securityRequirements: Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
     tags: Schema.Array$<Schema.Struct<{
         name: typeof Schema.String;

package/dist/shared/{nestjs-openapi.BYUrTaMo.d.ts → nestjs-openapi.t3iwzrrT.d.ts}

@@ -173,9 +173,12 @@ interface OpenApiSchema {
     readonly format?: string;
     readonly $ref?: string;
     readonly oneOf?: readonly OpenApiSchema[];
+    readonly allOf?: readonly OpenApiSchema[];
     readonly items?: OpenApiSchema;
     readonly properties?: Record<string, OpenApiSchema>;
     readonly required?: readonly string[];
+    /** OpenAPI 3.0 nullable flag */
+    readonly nullable?: boolean;
 }
 declare const OpenApiOperation: Schema.Struct<{
     operationId: typeof Schema.String;
@@ -249,15 +252,54 @@ declare const OpenApiGeneratorConfig: Schema.Struct<{
             description: Schema.optional<typeof Schema.String>;
         }>>>;
         security: Schema.optional<Schema.Struct<{
-            schemes: Schema.optional<Schema.Array$<Schema.Struct<{
+            schemes: Schema.optional<Schema.Array$<Schema.Union<[Schema.Struct<{
                 name: typeof Schema.String;
-                type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
-                scheme: Schema.optional<typeof Schema.String>;
+                type: Schema.Literal<["http"]>;
+                scheme: typeof Schema.String;
                 bearerFormat: Schema.optional<typeof Schema.String>;
-                in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
-                parameterName: Schema.optional<typeof Schema.String>;
                 description: Schema.optional<typeof Schema.String>;
-            }>>>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["apiKey"]>;
+                in: Schema.Literal<["query", "header", "cookie"]>;
+                parameterName: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["oauth2"]>;
+                flows: Schema.Struct<{
+                    implicit: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    password: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    clientCredentials: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                    authorizationCode: Schema.optional<Schema.Struct<{
+                        authorizationUrl: Schema.optional<typeof Schema.String>;
+                        tokenUrl: Schema.optional<typeof Schema.String>;
+                        refreshUrl: Schema.optional<typeof Schema.String>;
+                        scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+                    }>>;
+                }>;
+                description: Schema.optional<typeof Schema.String>;
+            }>, Schema.Struct<{
+                name: typeof Schema.String;
+                type: Schema.Literal<["openIdConnect"]>;
+                openIdConnectUrl: typeof Schema.String;
+                description: Schema.optional<typeof Schema.String>;
+            }>]>>>;
             global: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>>;
         }>>;
     }>;
@@ -301,15 +343,54 @@ declare const ResolvedConfig: Schema.Struct<{
         url: typeof Schema.String;
         description: Schema.optional<typeof Schema.String>;
     }>>;
-    securitySchemes: Schema.Array$<Schema.Struct<{
+    securitySchemes: Schema.Array$<Schema.Union<[Schema.Struct<{
         name: typeof Schema.String;
-        type: Schema.Literal<["apiKey", "http", "oauth2", "openIdConnect"]>;
-        scheme: Schema.optional<typeof Schema.String>;
+        type: Schema.Literal<["http"]>;
+        scheme: typeof Schema.String;
         bearerFormat: Schema.optional<typeof Schema.String>;
-        in: Schema.optional<Schema.Literal<["query", "header", "cookie"]>>;
-        parameterName: Schema.optional<typeof Schema.String>;
         description: Schema.optional<typeof Schema.String>;
-    }>>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["apiKey"]>;
+        in: Schema.Literal<["query", "header", "cookie"]>;
+        parameterName: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["oauth2"]>;
+        flows: Schema.Struct<{
+            implicit: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            password: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            clientCredentials: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+            authorizationCode: Schema.optional<Schema.Struct<{
+                authorizationUrl: Schema.optional<typeof Schema.String>;
+                tokenUrl: Schema.optional<typeof Schema.String>;
+                refreshUrl: Schema.optional<typeof Schema.String>;
+                scopes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+            }>>;
+        }>;
+        description: Schema.optional<typeof Schema.String>;
+    }>, Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["openIdConnect"]>;
+        openIdConnectUrl: typeof Schema.String;
+        description: Schema.optional<typeof Schema.String>;
+    }>]>>;
     securityRequirements: Schema.Array$<Schema.Record$<typeof Schema.String, Schema.Array$<typeof Schema.String>>>;
     tags: Schema.Array$<Schema.Struct<{
         name: typeof Schema.String;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-openapi",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Static code analysis tool to generate OpenAPI specifications from NestJS applications",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",