nestjs-openapi 0.1.2 → 0.1.4

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.yWMsjl_8.mjs';
+import { g as generate, e as formatValidationResult } from './shared/nestjs-openapi.CUKGdNSM.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.CBj9xHZ4.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.OhsaHu32.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.OhsaHu32.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.ClTIhsb-.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.ClTIhsb-.mjs';
 import { DynamicModule } from '@nestjs/common';
 import { Project, SourceFile, ClassDeclaration, MethodDeclaration, Decorator, Symbol, ObjectLiteralExpression, Expression } from 'ts-morph';
 
@@ -275,6 +275,23 @@ interface OptionsConfig {
      * Query parameter handling options.
      */
     readonly query?: QueryOptions;
+    /**
+     * Schema generation and normalization options.
+     */
+    readonly schemas?: SchemaOptions;
+}
+/**
+ * Schema generation and normalization options.
+ */
+interface SchemaOptions {
+    /**
+     * How to handle schema aliases that only redirect via `$ref`.
+     * - `"collapse"`: Rewrite refs to the final target schema and remove alias entries
+     * - `"preserve"`: Keep alias schemas as-is
+     *
+     * @default "collapse"
+     */
+    readonly aliasRefs?: 'collapse' | 'preserve';
 }
 /**
  * Query parameter handling options.

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.OhsaHu32.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.OhsaHu32.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.ClTIhsb-.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.ClTIhsb-.js';
 import { DynamicModule } from '@nestjs/common';
 import { Project, SourceFile, ClassDeclaration, MethodDeclaration, Decorator, Symbol, ObjectLiteralExpression, Expression } from 'ts-morph';
 
@@ -275,6 +275,23 @@ interface OptionsConfig {
      * Query parameter handling options.
      */
     readonly query?: QueryOptions;
+    /**
+     * Schema generation and normalization options.
+     */
+    readonly schemas?: SchemaOptions;
+}
+/**
+ * Schema generation and normalization options.
+ */
+interface SchemaOptions {
+    /**
+     * How to handle schema aliases that only redirect via `$ref`.
+     * - `"collapse"`: Rewrite refs to the final target schema and remove alias entries
+     * - `"preserve"`: Keep alias schemas as-is
+     *
+     * @default "collapse"
+     */
+    readonly aliasRefs?: 'collapse' | 'preserve';
 }
 /**
  * Query parameter handling options.

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.yWMsjl_8.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.CUKGdNSM.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.CBj9xHZ4.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.CBj9xHZ4.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.OhsaHu32.mjs';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.ClTIhsb-.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.OhsaHu32.js';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.ClTIhsb-.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.CBj9xHZ4.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.yWMsjl_8.mjs → nestjs-openapi.CUKGdNSM.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.CBj9xHZ4.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';
 
@@ -450,6 +450,165 @@ const resolveNewSchemaName = (originalName, structureMapping) => {
   return originalName;
 };
 
+const COMPONENT_SCHEMA_REF_PREFIX = "#/components/schemas/";
+const ALIAS_SCHEMA_KEYS = /* @__PURE__ */ new Set(["$ref", "description"]);
+const extractSchemaRefName = (ref) => ref.startsWith(COMPONENT_SCHEMA_REF_PREFIX) ? ref.slice(COMPONENT_SCHEMA_REF_PREFIX.length) : null;
+const toSchemaRef = (name) => `${COMPONENT_SCHEMA_REF_PREFIX}${name}`;
+const isAliasSchema = (schema) => {
+  if (!schema.$ref) return false;
+  return Object.keys(schema).every(
+    (key) => ALIAS_SCHEMA_KEYS.has(key)
+  );
+};
+const rewriteSchemaRefs = (schema, rewriteRef) => {
+  const result = { ...schema };
+  if (typeof schema.$ref === "string") {
+    result["$ref"] = rewriteRef(schema.$ref);
+  }
+  if (schema.items) {
+    result["items"] = rewriteSchemaRefs(schema.items, rewriteRef);
+  }
+  if (schema.oneOf) {
+    result["oneOf"] = schema.oneOf.map(
+      (item) => rewriteSchemaRefs(item, rewriteRef)
+    );
+  }
+  if (schema.anyOf) {
+    result["anyOf"] = schema.anyOf.map(
+      (item) => rewriteSchemaRefs(item, rewriteRef)
+    );
+  }
+  if (schema.allOf) {
+    result["allOf"] = schema.allOf.map(
+      (item) => rewriteSchemaRefs(item, rewriteRef)
+    );
+  }
+  if (schema.properties) {
+    result["properties"] = Object.fromEntries(
+      Object.entries(schema.properties).map(([key, propertySchema]) => [
+        key,
+        rewriteSchemaRefs(propertySchema, rewriteRef)
+      ])
+    );
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    result["additionalProperties"] = rewriteSchemaRefs(
+      schema.additionalProperties,
+      rewriteRef
+    );
+  }
+  return result;
+};
+const rewritePathsRefs = (paths, rewriteRef) => Object.fromEntries(
+  Object.entries(paths).map(([path, methods]) => [
+    path,
+    Object.fromEntries(
+      Object.entries(methods).map(([method, operation]) => [
+        method,
+        {
+          ...operation,
+          ...operation.parameters && {
+            parameters: operation.parameters.map((parameter) => ({
+              ...parameter,
+              schema: rewriteSchemaRefs(parameter.schema, rewriteRef)
+            }))
+          },
+          ...operation.requestBody && {
+            requestBody: {
+              ...operation.requestBody,
+              content: Object.fromEntries(
+                Object.entries(operation.requestBody.content).map(
+                  ([contentType, content]) => [
+                    contentType,
+                    {
+                      ...content,
+                      schema: rewriteSchemaRefs(content.schema, rewriteRef)
+                    }
+                  ]
+                )
+              )
+            }
+          },
+          responses: Object.fromEntries(
+            Object.entries(operation.responses).map(([statusCode, response]) => [
+              statusCode,
+              response.content ? {
+                ...response,
+                content: Object.fromEntries(
+                  Object.entries(response.content).map(
+                    ([contentType, content]) => [
+                      contentType,
+                      {
+                        ...content,
+                        schema: rewriteSchemaRefs(content.schema, rewriteRef)
+                      }
+                    ]
+                  )
+                )
+              } : response
+            ])
+          )
+        }
+      ])
+    )
+  ])
+);
+const rewriteSchemasRefs = (schemas, rewriteRef) => Object.fromEntries(
+  Object.entries(schemas).map(([name, schema]) => [
+    name,
+    rewriteSchemaRefs(schema, rewriteRef)
+  ])
+);
+const resolveAliasTargets = (schemas) => {
+  const directAliases = /* @__PURE__ */ new Map();
+  for (const [name, schema] of Object.entries(schemas)) {
+    if (!isAliasSchema(schema) || !schema.$ref) continue;
+    const target = extractSchemaRefName(schema.$ref);
+    if (!target) continue;
+    directAliases.set(name, target);
+  }
+  const resolvedAliases = /* @__PURE__ */ new Map();
+  const resolveFinalTarget = (start) => {
+    const visited = /* @__PURE__ */ new Set([start]);
+    let current = start;
+    while (true) {
+      const next = directAliases.get(current);
+      if (!next) return current === start ? null : current;
+      if (!(next in schemas)) return null;
+      if (visited.has(next)) return null;
+      visited.add(next);
+      current = next;
+    }
+  };
+  for (const aliasName of directAliases.keys()) {
+    const finalTarget = resolveFinalTarget(aliasName);
+    if (!finalTarget || finalTarget === aliasName) continue;
+    resolvedAliases.set(aliasName, finalTarget);
+  }
+  return resolvedAliases;
+};
+const collapseAliasRefs = (paths, schemas) => {
+  const aliasTargets = resolveAliasTargets(schemas);
+  if (aliasTargets.size === 0) return { paths, schemas };
+  const rewriteRef = (ref) => {
+    const refName = extractSchemaRefName(ref);
+    if (!refName) return ref;
+    const finalTarget = aliasTargets.get(refName);
+    return finalTarget ? toSchemaRef(finalTarget) : ref;
+  };
+  const rewrittenPaths = rewritePathsRefs(paths, rewriteRef);
+  const rewrittenSchemas = rewriteSchemasRefs(schemas, rewriteRef);
+  const collapsedSchemas = Object.fromEntries(
+    Object.entries(rewrittenSchemas).filter(
+      ([name]) => !aliasTargets.has(name)
+    )
+  );
+  return {
+    paths: rewrittenPaths,
+    schemas: collapsedSchemas
+  };
+};
+
 const extractReferencedSchemas = (paths) => {
   const refs = /* @__PURE__ */ new Set();
   const extractFromSchema = (schema) => {
@@ -646,7 +805,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) {
@@ -678,6 +841,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);
@@ -689,19 +857,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;
@@ -966,22 +1151,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)
@@ -1013,6 +1235,9 @@ const OpenApiConfig = Schema.Struct({
 const QueryOptionsConfig = Schema.Struct({
   style: Schema.optional(Schema.Literal("inline", "ref"))
 });
+const SchemaOptionsConfig = Schema.Struct({
+  aliasRefs: Schema.optional(Schema.Literal("collapse", "preserve"))
+});
 const PathFilterFunction = Schema.declare(
   (input) => typeof input === "function",
   {
@@ -1029,6 +1254,7 @@ const OptionsConfig = Schema.Struct({
   extractValidation: Schema.optional(Schema.Boolean),
   excludeDecorators: Schema.optional(Schema.Array(Schema.String)),
   query: Schema.optional(QueryOptionsConfig),
+  schemas: Schema.optional(SchemaOptionsConfig),
   pathFilter: Schema.optional(PathFilter)
 });
 const OpenApiGeneratorConfig = Schema.Struct({
@@ -1047,6 +1273,7 @@ Schema.Struct({
   excludeDecorators: Schema.Array(Schema.String),
   dtoGlob: Schema.Array(Schema.String),
   extractValidation: Schema.Boolean,
+  aliasRefs: Schema.Literal("collapse", "preserve"),
   basePath: Schema.optional(Schema.String),
   pathFilter: Schema.optional(PathFilter),
   version: Schema.optional(Schema.String),
@@ -1088,7 +1315,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",
@@ -1101,7 +1328,10 @@ const DEFAULT_CONFIG = {
   },
   options: {
     excludeDecorators: ["ApiExcludeEndpoint", "ApiExcludeController"],
-    extractValidation: true
+    extractValidation: true,
+    schemas: {
+      aliasRefs: "collapse"
+    }
   },
   format: "json",
   openapi: {
@@ -1115,8 +1345,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)) {
@@ -1205,7 +1434,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");
@@ -1218,6 +1447,7 @@ const resolveConfig = (config) => {
     excludeDecorators: options.excludeDecorators ?? DEFAULT_CONFIG.options.excludeDecorators,
     dtoGlob,
     extractValidation: options.extractValidation ?? DEFAULT_CONFIG.options.extractValidation,
+    aliasRefs: options.schemas?.aliasRefs ?? DEFAULT_CONFIG.options.schemas.aliasRefs,
     basePath: options.basePath,
     version: openapi.version,
     info: openapi.info,
@@ -1484,6 +1714,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;
@@ -1493,23 +1739,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;
@@ -1573,6 +1813,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)
@@ -1619,8 +1984,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;
@@ -1708,6 +2072,7 @@ const generate = async (configPath, overrides) => {
   );
   const files = config.files ?? {};
   const options = config.options ?? {};
+  const aliasRefsMode = options.schemas?.aliasRefs ?? "collapse";
   const openapi = config.openapi;
   const security = openapi.security ?? {};
   const rawEntry = files.entry ?? DEFAULT_ENTRY;
@@ -1715,19 +2080,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(
@@ -1739,7 +2115,7 @@ const generate = async (configPath, overrides) => {
         Effect.mapError((error) => new Error(error.message))
       )
     ),
-    dtoGlobArray ? runEffect(
+    runEffect(
       generateSchemas({
         dtoGlob: dtoGlobArray,
         tsconfig,
@@ -1755,7 +2131,7 @@ const generate = async (configPath, overrides) => {
         ),
         Effect.mapError((error) => new Error(error.message))
       )
-    ) : Promise.resolve(null)
+    )
   ]);
   const filteredMethodInfos = filterMethods(extractedMethodInfos, {
     excludeDecorators: options.excludeDecorators,
@@ -1776,7 +2152,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) {
@@ -1828,6 +2204,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
@@ -1837,6 +2257,11 @@ const generate = async (configPath, overrides) => {
       }
     }
   }
+  if (aliasRefsMode === "collapse" && Object.keys(schemas).length > 0) {
+    const collapsed = collapseAliasRefs(paths, schemas);
+    paths = collapsed.paths;
+    schemas = collapsed.schemas;
+  }
   const securitySchemes = security.schemes && security.schemes.length > 0 ? buildSecuritySchemes(security.schemes) : void 0;
   const hasSchemas = Object.keys(schemas).length > 0;
   const hasSecuritySchemes = securitySchemes && Object.keys(securitySchemes).length > 0;

package/dist/shared/{nestjs-openapi.OhsaHu32.d.mts → nestjs-openapi.ClTIhsb-.d.mts}

@@ -252,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>>>>;
         }>>;
     }>;
@@ -271,6 +310,9 @@ declare const OpenApiGeneratorConfig: Schema.Struct<{
         query: Schema.optional<Schema.Struct<{
             style: Schema.optional<Schema.Literal<["inline", "ref"]>>;
         }>>;
+        schemas: Schema.optional<Schema.Struct<{
+            aliasRefs: Schema.optional<Schema.Literal<["collapse", "preserve"]>>;
+        }>>;
         pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
     }>>;
 }>;
@@ -283,6 +325,7 @@ declare const ResolvedConfig: Schema.Struct<{
     excludeDecorators: Schema.Array$<typeof Schema.String>;
     dtoGlob: Schema.Array$<typeof Schema.String>;
     extractValidation: typeof Schema.Boolean;
+    aliasRefs: Schema.Literal<["collapse", "preserve"]>;
     basePath: Schema.optional<typeof Schema.String>;
     pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
     version: Schema.optional<typeof Schema.String>;
@@ -304,15 +347,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.OhsaHu32.d.ts → nestjs-openapi.ClTIhsb-.d.ts}

@@ -252,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>>>>;
         }>>;
     }>;
@@ -271,6 +310,9 @@ declare const OpenApiGeneratorConfig: Schema.Struct<{
         query: Schema.optional<Schema.Struct<{
             style: Schema.optional<Schema.Literal<["inline", "ref"]>>;
         }>>;
+        schemas: Schema.optional<Schema.Struct<{
+            aliasRefs: Schema.optional<Schema.Literal<["collapse", "preserve"]>>;
+        }>>;
         pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
     }>>;
 }>;
@@ -283,6 +325,7 @@ declare const ResolvedConfig: Schema.Struct<{
     excludeDecorators: Schema.Array$<typeof Schema.String>;
     dtoGlob: Schema.Array$<typeof Schema.String>;
     extractValidation: typeof Schema.Boolean;
+    aliasRefs: Schema.Literal<["collapse", "preserve"]>;
     basePath: Schema.optional<typeof Schema.String>;
     pathFilter: Schema.optional<Schema.Union<[Schema.instanceOf<RegExp>, Schema.declare<(path: string) => boolean, (path: string) => boolean, readonly [], never>]>>;
     version: Schema.optional<typeof Schema.String>;
@@ -304,15 +347,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.CBj9xHZ4.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, "");

package/package.json

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