next-openapi-gen 1.3.0 → 1.4.1

package/dist/next/index.js

@@ -737,96 +737,100 @@ function typeToOpenApiSchema(type, checker, seen) {
     return { type: "object" };
   }
   seen.add(seenKey);
-  if (type.isStringLiteral()) {
-    return { type: "string", enum: [type.value] };
-  }
-  if (type.isNumberLiteral()) {
-    return { type: "number", enum: [type.value] };
-  }
-  if (type.flags & ts2.TypeFlags.BooleanLiteral) {
-    return {
-      type: "boolean",
-      enum: [checker.typeToString(type) === "true"]
-    };
-  }
-  if (type.flags & ts2.TypeFlags.TemplateLiteral) {
-    return { type: "string" };
-  }
-  if (type.flags & ts2.TypeFlags.StringLike) {
-    return { type: "string" };
-  }
-  if (type.flags & ts2.TypeFlags.NumberLike) {
-    return { type: "number" };
-  }
-  if (type.flags & ts2.TypeFlags.BooleanLike) {
-    return { type: "boolean" };
-  }
-  if (type.flags & ts2.TypeFlags.Null) {
-    return { type: "null" };
-  }
-  if (type.isUnion()) {
-    const nullable2 = type.types.some((member) => member.flags & ts2.TypeFlags.Null);
-    const nonNullTypes = type.types.filter((member) => !(member.flags & ts2.TypeFlags.Null));
-    const soleNonNullType = nonNullTypes[0];
-    if (nullable2 && soleNonNullType && nonNullTypes.length === 1) {
+  try {
+    if (type.isStringLiteral()) {
+      return { type: "string", enum: [type.value] };
+    }
+    if (type.isNumberLiteral()) {
+      return { type: "number", enum: [type.value] };
+    }
+    if (type.flags & ts2.TypeFlags.BooleanLiteral) {
       return {
-        ...typeToOpenApiSchema(soleNonNullType, checker, seen),
-        nullable: true
+        type: "boolean",
+        enum: [checker.typeToString(type) === "true"]
       };
     }
-    return {
-      oneOf: nonNullTypes.map((member) => typeToOpenApiSchema(member, checker, seen))
-    };
-  }
-  if (checker.isTupleType(type)) {
-    const itemTypes = checker.getTypeArguments(type);
-    return {
-      type: "array",
-      prefixItems: itemTypes.map((itemType) => typeToOpenApiSchema(itemType, checker, seen)),
-      items: false,
-      minItems: itemTypes.length,
-      maxItems: itemTypes.length
-    };
-  }
-  if (checker.isArrayType(type)) {
-    const elementType = checker.getTypeArguments(type)[0];
-    return {
-      type: "array",
-      items: elementType ? typeToOpenApiSchema(elementType, checker, seen) : { type: "object" }
-    };
-  }
-  const properties = checker.getPropertiesOfType(type);
-  if (properties.length > 0) {
-    const schemaProperties = {};
-    const required2 = [];
-    properties.forEach((property) => {
-      const propertyDeclaration = property.valueDeclaration || property.declarations?.[0];
-      if (!propertyDeclaration) {
-        return;
-      }
-      const propertyType = checker.getTypeOfSymbolAtLocation(property, propertyDeclaration);
-      schemaProperties[property.getName()] = typeToOpenApiSchema(propertyType, checker, seen);
-      if (!(property.flags & ts2.SymbolFlags.Optional)) {
-        required2.push(property.getName());
+    if (type.flags & ts2.TypeFlags.TemplateLiteral) {
+      return { type: "string" };
+    }
+    if (type.flags & ts2.TypeFlags.StringLike) {
+      return { type: "string" };
+    }
+    if (type.flags & ts2.TypeFlags.NumberLike) {
+      return { type: "number" };
+    }
+    if (type.flags & ts2.TypeFlags.BooleanLike) {
+      return { type: "boolean" };
+    }
+    if (type.flags & ts2.TypeFlags.Null) {
+      return { type: "null" };
+    }
+    if (type.isUnion()) {
+      const nullable2 = type.types.some((member) => member.flags & ts2.TypeFlags.Null);
+      const nonNullTypes = type.types.filter((member) => !(member.flags & ts2.TypeFlags.Null));
+      const soleNonNullType = nonNullTypes[0];
+      if (nullable2 && soleNonNullType && nonNullTypes.length === 1) {
+        return {
+          ...typeToOpenApiSchema(soleNonNullType, checker, seen),
+          nullable: true
+        };
       }
-    });
-    return required2.length > 0 ? {
-      type: "object",
-      properties: schemaProperties,
-      required: required2
-    } : {
-      type: "object",
-      properties: schemaProperties
-    };
-  }
-  const stringIndexType = type.getStringIndexType();
-  if (stringIndexType) {
-    return {
-      type: "object",
-      additionalProperties: typeToOpenApiSchema(stringIndexType, checker, seen)
-    };
+      return {
+        oneOf: nonNullTypes.map((member) => typeToOpenApiSchema(member, checker, seen))
+      };
+    }
+    if (checker.isTupleType(type)) {
+      const itemTypes = checker.getTypeArguments(type);
+      return {
+        type: "array",
+        prefixItems: itemTypes.map((itemType) => typeToOpenApiSchema(itemType, checker, seen)),
+        items: false,
+        minItems: itemTypes.length,
+        maxItems: itemTypes.length
+      };
+    }
+    if (checker.isArrayType(type)) {
+      const elementType = checker.getTypeArguments(type)[0];
+      return {
+        type: "array",
+        items: elementType ? typeToOpenApiSchema(elementType, checker, seen) : { type: "object" }
+      };
+    }
+    const properties = checker.getPropertiesOfType(type);
+    if (properties.length > 0) {
+      const schemaProperties = {};
+      const required2 = [];
+      properties.forEach((property) => {
+        const propertyDeclaration = property.valueDeclaration || property.declarations?.[0];
+        if (!propertyDeclaration) {
+          return;
+        }
+        const propertyType = checker.getTypeOfSymbolAtLocation(property, propertyDeclaration);
+        schemaProperties[property.getName()] = typeToOpenApiSchema(propertyType, checker, seen);
+        if (!(property.flags & ts2.SymbolFlags.Optional)) {
+          required2.push(property.getName());
+        }
+      });
+      return required2.length > 0 ? {
+        type: "object",
+        properties: schemaProperties,
+        required: required2
+      } : {
+        type: "object",
+        properties: schemaProperties
+      };
+    }
+    const stringIndexType = type.getStringIndexType();
+    if (stringIndexType) {
+      return {
+        type: "object",
+        additionalProperties: typeToOpenApiSchema(stringIndexType, checker, seen)
+      };
+    }
+    return { type: "object" };
+  } finally {
+    seen.delete(seenKey);
   }
-  return { type: "object" };
 }
 function unwrapPromiseType(type, checker) {
   const symbolName = type.getSymbol()?.getName();
@@ -938,7 +942,7 @@ function parseJSDocBlock(commentValue, filePath) {
   result.cookieType = extractTypeFromComment(normalizedComment, "@cookie");
   const authValue = extractLineValue(normalizedComment, "@auth");
   if (authValue) {
-    result.auth = performAuthPresetReplacements(authValue);
+    result.auth = authValue;
   }
   const querystring = parseQuerystringTag(normalizedComment);
   if (querystring) {
@@ -1614,16 +1618,17 @@ var INTERNAL_OPENAPI_CONFIG_KEYS = [
   "next",
   "diagnostics",
   "debug",
+  "authPresets",
   "excludeSchemas"
 ];
-var AUTH_PRESET_REPLACEMENTS = {
+var DEFAULT_AUTH_PRESET_REPLACEMENTS = {
   bearer: "BearerAuth",
   basic: "BasicAuth",
   apikey: "ApiKeyAuth"
 };
-function performAuthPresetReplacements(authValue) {
+function performAuthPresetReplacements(authValue, presets = DEFAULT_AUTH_PRESET_REPLACEMENTS) {
   const authParts = authValue.split(",").map((part) => part.trim());
-  const mappedParts = authParts.map((part) => AUTH_PRESET_REPLACEMENTS[part.toLowerCase()] || part);
+  const mappedParts = authParts.map((part) => presets[part.toLowerCase()] || part);
   return mappedParts.join(",");
 }
 function getOperationId(routePath, method) {
@@ -2342,6 +2347,7 @@ function normalizeOpenApiConfig(template) {
       adapterPath: template.next?.adapterPath
     },
     diagnostics: template.diagnostics ?? { enabled: DEFAULT_DIAGNOSTICS_ENABLED },
+    authPresets: { ...DEFAULT_AUTH_PRESET_REPLACEMENTS, ...template.authPresets },
     debug: template.debug ?? DEFAULT_DEBUG
   };
 }
@@ -2823,8 +2829,10 @@ function downgradeSchemaForOpenApi30(schema, mediaTypeName) {
     const nullableBranch = nextSchema.anyOf.find((item) => item.type === "null");
     const baseBranch = nextSchema.anyOf.find((item) => item.type !== "null");
     if (nullableBranch && baseBranch) {
+      const { anyOf: _anyOf, ...outerMeta } = nextSchema;
       nextSchema = {
         ...structuredClone(baseBranch),
+        ...outerMeta,
         nullable: true
       };
     }
@@ -4699,7 +4707,7 @@ function processZodLiteral(node, context) {
     return { type: "string", enum: [arg.value] };
   }
   if (t9.isNumericLiteral(arg)) {
-    return { type: "number", enum: [arg.value] };
+    return { type: Number.isInteger(arg.value) ? "integer" : "number", enum: [arg.value] };
   }
   if (t9.isBooleanLiteral(arg)) {
     return { type: "boolean", enum: [arg.value] };
@@ -4715,7 +4723,7 @@ function processZodLiteral(node, context) {
     if (typeof value === "string")
       return { type: "string", enum: [value] };
     if (typeof value === "number")
-      return { type: "number", enum: [value] };
+      return { type: Number.isInteger(value) ? "integer" : "number", enum: [value] };
     if (typeof value === "boolean")
       return { type: "boolean", enum: [value] };
     if (value === null)
@@ -4810,7 +4818,7 @@ function processZodTuple(node, processNode, context) {
     if (t9.isIdentifier(node.arguments[0]) && context?.resolveConstArrayValues) {
       const values = context.resolveConstArrayValues(node.arguments[0].name);
       if (values && values.length > 0) {
-        const prefixItems = values.map((value) => typeof value === "number" ? { type: "number", enum: [value] } : { type: "string", enum: [value] });
+        const prefixItems = values.map((value) => typeof value === "number" ? { type: Number.isInteger(value) ? "integer" : "number", enum: [value] } : { type: "string", enum: [value] });
         return {
           type: "array",
           prefixItems,
@@ -4854,7 +4862,7 @@ function processZodUnion(node, processNode, context) {
     if (t9.isIdentifier(node.arguments[0]) && context?.resolveConstArrayValues) {
       const values = context.resolveConstArrayValues(node.arguments[0].name);
       if (values && values.length > 0) {
-        const type = typeof values[0] === "number" ? "number" : "string";
+        const type = typeof values[0] === "number" ? Number.isInteger(values[0]) ? "integer" : "number" : "string";
         return { type, enum: values };
       }
     }
@@ -12301,8 +12309,17 @@ var ZodRuntimeExporter = class {
         return node.arguments[0] ? literal(this.buildLiteralValue(node.arguments[0])) : null;
       case "enum":
         return this.buildEnum(node);
-      case "array":
-        return node.arguments[0] && isProcessableNode(node.arguments[0]) ? array(this.buildSchema(node.arguments[0]) ?? unknown()) : array(unknown());
+      case "array": {
+        const arg = node.arguments[0];
+        if (!arg || !isProcessableNode(arg)) {
+          return array(unknown());
+        }
+        const itemSchema = this.buildSchema(arg);
+        if (!itemSchema) {
+          return null;
+        }
+        return array(itemSchema);
+      }
       case "strictObject": {
         const base = this.buildObject(node);
         return base && typeof base.strict === "function" ? base.strict() : base;
@@ -12434,13 +12451,17 @@ var ZodRuntimeExporter = class {
     if (node.arguments.length === 0 || !t10.isArrayExpression(node.arguments[0])) {
       return tuple([]);
     }
-    const items = node.arguments[0].elements.flatMap((element) => {
+    const items = [];
+    for (const element of node.arguments[0].elements) {
       if (!isProcessableNode(element)) {
-        return [];
+        return null;
       }
       const schema = this.buildSchema(element);
-      return schema ? [schema] : [];
-    });
+      if (!schema) {
+        return null;
+      }
+      items.push(schema);
+    }
     return tuple(items);
   }
   buildTemplateLiteral(node) {
@@ -13052,7 +13073,12 @@ var ZodSchemaConverter = class {
             if (this.isZodSchema(path19.node.init)) {
               const schema = this.processZodNode(path19.node.init);
               if (schema) {
-                this.storeResolvedSchema(schemaName, schema);
+                const overrideId = this.extractMetaIdFromNode(path19.node.init);
+                if (overrideId) {
+                  this.applyMetaIdOverride(schemaName, schema, overrideId, filePath);
+                } else {
+                  this.storeResolvedSchema(schemaName, schema);
+                }
               }
               return;
             }
@@ -13395,8 +13421,15 @@ var ZodSchemaConverter = class {
         };
         switch (methodName) {
           case "optional":
+            break;
           case "nullable":
           case "nullish":
+            schema = {
+              anyOf: [
+                { $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}` },
+                { type: "null" }
+              ]
+            };
             break;
           case "describe":
             if (node.arguments.length > 0 && t11.isStringLiteral(node.arguments[0])) {
@@ -13891,7 +13924,7 @@ var ZodSchemaConverter = class {
       return helperName.startsWith("coerce.") || helperName === "templateLiteral" || helperName === "stringbool";
     }
     if (t11.isMemberExpression(node.callee) && t11.isIdentifier(node.callee.property)) {
-      const runtimeMethods = /* @__PURE__ */ new Set(["pipe", "meta"]);
+      const runtimeMethods = /* @__PURE__ */ new Set(["pipe"]);
       if (runtimeMethods.has(node.callee.property.name)) {
         return true;
       }
@@ -13914,12 +13947,16 @@ var ZodSchemaConverter = class {
       case "optional":
         break;
       case "nullable":
-        if (!schema.allOf) {
+        if (schema.allOf) {
+          schema = { anyOf: [...schema.allOf, { type: "null" }] };
+        } else {
           schema.nullable = true;
         }
         break;
       case "nullish":
-        if (!schema.allOf) {
+        if (schema.allOf) {
+          schema = { anyOf: [...schema.allOf, { type: "null" }] };
+        } else {
           schema.nullable = true;
         }
         break;
@@ -14064,15 +14101,13 @@ var ZodSchemaConverter = class {
         schema.type = "integer";
         break;
       case "positive":
-        schema.minimum = 0;
-        schema.exclusiveMinimum = true;
+        schema.exclusiveMinimum = 0;
         break;
       case "nonnegative":
         schema.minimum = 0;
         break;
       case "negative":
-        schema.maximum = 0;
-        schema.exclusiveMaximum = true;
+        schema.exclusiveMaximum = 0;
         break;
       case "nonpositive":
         schema.maximum = 0;
@@ -14434,6 +14469,9 @@ var ZodSchemaConverter = class {
                   if (!this.getStoredSchema(schemaName)) {
                     logger.debug(`Pre-processing Zod schema: ${schemaName}`);
                     this.processingSchemas.add(schemaName);
+                    this.currentFilePath = filePath;
+                    this.currentAST = ast;
+                    this.currentImports = importedModules;
                     const schema = this.processZodNode(declaration.init);
                     this.processingSchemas.delete(schemaName);
                     if (schema) {
@@ -14466,6 +14504,9 @@ var ZodSchemaConverter = class {
                 if (!this.getStoredSchema(schemaName) && !this.processingSchemas.has(schemaName)) {
                   logger.debug(`Pre-processing Zod schema: ${schemaName}`);
                   this.processingSchemas.add(schemaName);
+                  this.currentFilePath = filePath;
+                  this.currentAST = ast;
+                  this.currentImports = importedModules;
                   const schema = this.processZodNode(declaration.init);
                   this.processingSchemas.delete(schemaName);
                   if (schema) {
@@ -17336,11 +17377,16 @@ var ResponseProcessor = class {
 var OperationProcessor = class {
   schemaProcessor;
   responseProcessor;
+  authPresets;
   performanceProfile;
-  constructor(schemaProcessor, responseProcessor, performanceProfile) {
+  constructor(schemaProcessor, responseProcessor, options = {}) {
     this.schemaProcessor = schemaProcessor;
     this.responseProcessor = responseProcessor;
-    this.performanceProfile = performanceProfile;
+    this.authPresets = {
+      ...DEFAULT_AUTH_PRESET_REPLACEMENTS,
+      ...options.authPresets
+    };
+    this.performanceProfile = options.performanceProfile;
   }
   processOperation(varName, routePath, dataTypes, pathParamNames = []) {
     const method = varName.toLowerCase();
@@ -17365,9 +17411,10 @@ var OperationProcessor = class {
       definition.deprecated = true;
     }
     if (explicitSecurity && explicitSecurity.length > 0) {
-      definition.security = explicitSecurity;
+      definition.security = explicitSecurity.map((req) => Object.fromEntries(Object.entries(req).map(([scheme, scopes]) => [this.applyPreset(scheme), scopes])));
     } else if (auth) {
-      const authItems = auth.split(",").map((item) => item.trim());
+      const mapped = performAuthPresetReplacements(auth, this.authPresets);
+      const authItems = mapped.split(",").map((item) => item.trim());
       definition.security = authItems.map((authItem) => ({
         [authItem]: []
       }));
@@ -17580,6 +17627,9 @@ ${suffix}`;
       response.links[link.name] = linkObject;
     }
   }
+  applyPreset(scheme) {
+    return this.authPresets[scheme.toLowerCase()] ?? scheme;
+  }
   createQuerystringParameter(dataTypes) {
     if (!dataTypes.querystringType) {
       return void 0;
@@ -17668,7 +17718,10 @@ var RouteProcessor = class {
       return new RegExp(`^${regexPattern}$`);
     });
     this.responseProcessor = new ResponseProcessor(this.config, this.schemaProcessor);
-    this.operationProcessor = new OperationProcessor(this.schemaProcessor, this.responseProcessor, this.performanceProfile);
+    this.operationProcessor = new OperationProcessor(this.schemaProcessor, this.responseProcessor, {
+      authPresets: this.config.authPresets,
+      performanceProfile: this.performanceProfile
+    });
   }
   processResponsesFromConfig(dataTypes, method) {
     return this.responseProcessor.processResponses(dataTypes, method);
@@ -17910,6 +17963,7 @@ function applyExcludeSchemas(document, mergedSchemas, excludedSchemas) {
   if (excludedNames.size === 0)
     return;
   walkAndInline(document, excludedSchemas, excludedNames, /* @__PURE__ */ new Set());
+  walkAndInline(mergedSchemas, excludedSchemas, excludedNames, /* @__PURE__ */ new Set());
   for (const name of excludedNames) {
     delete mergedSchemas[name];
   }