@sebspark/openapi-typegen 1.5.1 → 1.7.0

package/dist/index.js

@@ -257,7 +257,10 @@ var generateDiscriminator = (discriminator, name) => {
 };
 var generateArray = (parsed) => {
   const lines = [];
-  const items = generateType(parsed.items);
+  let items = generateType(parsed.items);
+  if (parsed.items.type === "enum") {
+    items = `(${items})`;
+  }
   lines.push(`${preamble(parsed)}${items}[]`);
   return lines.join("\n");
 };
@@ -336,7 +339,7 @@ var serializeValue = (value) => {
 var generateClientArgs = (args) => generateArgs(args, false);
 var generateServerArgs = (args) => args ? generateArgs(args, true) : "args: Req";
 var parts = ["body", "header", "path", "query"];
-var generateArgs = (args, extendsReq) => {
+var generateArgs = (args, isServer) => {
   if (args) {
     const tokens = [];
     for (const part of parts) {
@@ -344,17 +347,25 @@ var generateArgs = (args, extendsReq) => {
       if (arg) {
         const partName = part === "path" ? "params" : part === "header" ? "headers" : part;
         tokens.push(
-          `${partName}${arg.optional ? "?" : ""}: ${generateType(arg)}`
+          `${partName}${arg.optional ? "?" : ""}: ${wrapArgs(
+            generateType(arg),
+            isServer && part === "header"
+          )}`
         );
       }
     }
     if (!tokens.length)
       return "";
     const optional = argsOptional(args);
-    return `args${optional ? "?" : ""}: ${extendsReq ? "Req & " : ""}{ ${tokens.join(", ")} }, `;
+    return `args${optional ? "?" : ""}: ${isServer ? "Req & " : ""}{ ${tokens.join(", ")} }, `;
   }
   return "";
 };
+var wrapArgs = (args, wrap) => {
+  if (!wrap)
+    return args;
+  return `LowerCaseHeaders<${args}>`;
+};
 var argsOptional = (args) => (
   // biome-ignore lint/style/noNonNullAssertion: <explanation>
   parts.reduce((o, p) => o && (!args[p] || args[p].optional), true)
@@ -435,6 +446,7 @@ var generate = (name, doc) => `
    APIServerDefinition,
    BaseClient,
    GenericRouteHandler,
+   LowerCaseHeaders,
    PartiallySerialized,
    RequestOptions,
    Serialized,
@@ -482,6 +494,21 @@ var generateComponents = (components) => {
   for (const res of components.responseBodies) {
     tokens.push(generateResponseBody(res));
   }
+  for (const param2 of components.securitySchemes) {
+    tokens.push(
+      generateType({
+        type: "object",
+        name: param2.name,
+        properties: [
+          {
+            name: param2.parameterName,
+            type: [param2.type],
+            optional: param2.optional
+          }
+        ]
+      })
+    );
+  }
   return tokens.join("\n\n");
 };
 
@@ -571,12 +598,12 @@ var parseObjectSchema = (name, schema) => {
   return type;
 };
 var parseArraySchema = (name, schema) => {
-  if (schema.type !== "array" || !schema.items)
+  if (schema.type !== "array")
     throw new Error("Not an array");
   return {
     name,
     type: "array",
-    items: parsePropertyType(schema.items)[0],
+    items: schema.items ? parsePropertyType(schema.items)[0] : { type: "unknown" },
     ...parseDocumentation(schema)
   };
 };
@@ -595,6 +622,14 @@ var parsePropertyType = (property) => {
     return [{ type: parseRef(ref) }];
   }
   const schemaObject = property;
+  if (schemaObject.enum) {
+    const enumType = {
+      type: "enum",
+      values: schemaObject.enum,
+      ...parseDocumentation(schemaObject)
+    };
+    return [enumType];
+  }
   if (schemaObject.type) {
     return (Array.isArray(schemaObject.type) ? schemaObject.type : [schemaObject.type]).map((type) => {
       switch (type) {
@@ -670,13 +705,14 @@ var parseParameter = (name, schema) => {
 
 // src/parser/args.ts
 var parseArgs = (path, components) => {
-  var _a;
-  if (!((_a = path.parameters) == null ? void 0 : _a.length) && !path.requestBody)
+  var _a, _b;
+  if (!((_a = path.parameters) == null ? void 0 : _a.length) && !((_b = path.security) == null ? void 0 : _b.length) && !path.requestBody)
     return void 0;
-  const args = {
-    ...parseParameters2(path.parameters, components),
-    ...parseRequestBody(path.requestBody, components)
-  };
+  const args = joinArgs([
+    parseParameters2(path.parameters, components),
+    parseSecurity(path.security, components),
+    parseRequestBody(path.requestBody, components)
+  ]);
   return args;
 };
 var createArgs = (initializer = {}) => ({
@@ -685,6 +721,56 @@ var createArgs = (initializer = {}) => ({
   optional: true,
   ...initializer
 });
+var joinArgs = (args) => {
+  const reqArg = {};
+  for (const arg of args) {
+    for (const [prop, val] of Object.entries(arg)) {
+      const key = prop;
+      if (reqArg[key]) {
+        reqArg[key] = joinArg(reqArg[key], val);
+      } else {
+        reqArg[key] = val;
+      }
+    }
+  }
+  return reqArg;
+};
+var joinArg = (arg1, arg2) => {
+  const arg = {
+    type: "object",
+    optional: arg1.optional && arg2.optional,
+    properties: arg1.properties.concat(arg2.properties)
+  };
+  if (arg1.allOf || arg2.allOf)
+    arg.allOf = (arg1.allOf || []).concat(arg2.allOf || []);
+  if (arg1.anyOf || arg2.anyOf)
+    arg.anyOf = (arg1.anyOf || []).concat(arg2.anyOf || []);
+  if (arg1.oneOf || arg2.oneOf)
+    arg.oneOf = (arg1.oneOf || []).concat(arg2.oneOf || []);
+  if (arg1.description || arg2.description)
+    arg.description = arg1.description || arg2.description;
+  if (arg1.title || arg2.title)
+    arg.title = arg1.title || arg2.title;
+  return arg;
+};
+var parseSecurity = (security = [], components = {}) => {
+  const args = {};
+  for (const secReq of security) {
+    for (const [name, claims] of Object.entries(secReq)) {
+      const param2 = findRef(
+        components,
+        `#/components/securitySchemes/${name}`
+      );
+      const arg = args.header || createArgs({ ...parseDocumentation(param2) });
+      arg.optional = false;
+      if (!arg.allOf)
+        arg.allOf = [];
+      arg.allOf.push({ type: parseRef(name) });
+      args.header = arg;
+    }
+  }
+  return args;
+};
 var parseParameters2 = (parameters = [], components = {}) => {
   const args = {};
   for (const p of parameters) {
@@ -863,6 +949,60 @@ var parseRequestBodies = (requestBodies = {}) => {
   return definitions;
 };
 
+// src/parser/securitySchemes.ts
+var parseSecuritySchemes = (schemes = {}) => {
+  const parameters = [];
+  for (const [name, scheme] of Object.entries(schemes)) {
+    parameters.push(parseSecurityScheme(name, scheme));
+  }
+  return parameters;
+};
+var parseSecurityScheme = (name, scheme) => {
+  switch (scheme.type) {
+    case "apiKey":
+      return parseApiKey(name, scheme);
+    case "http":
+      return parseHttpSecurity(name, scheme);
+    case "oauth2":
+      return parseOAuth(name, scheme);
+    case "openIdConnect":
+      return parseOpenIdConnect(name, scheme);
+  }
+  throw new Error(`Unknown security scheme '${scheme.type}'`);
+};
+var parseApiKey = (name, scheme) => {
+  const _in = scheme.in || "header";
+  const parameterName = scheme.name;
+  return {
+    name,
+    parameterName,
+    in: _in,
+    optional: false,
+    type: { type: "string" }
+  };
+};
+var parseHttpSecurity = (name, _scheme) => ({
+  name,
+  in: "header",
+  parameterName: "Authorization",
+  optional: false,
+  type: { type: "string" }
+});
+var parseOAuth = (name, _scheme) => ({
+  name,
+  in: "header",
+  parameterName: "Authorization",
+  optional: false,
+  type: { type: "string" }
+});
+var parseOpenIdConnect = (name, _scheme) => ({
+  name,
+  in: "header",
+  parameterName: "Authorization",
+  optional: false,
+  type: { type: "string" }
+});
+
 // src/parser/index.ts
 var parseDocument = (schema) => ({
   paths: parsePaths(schema),
@@ -873,7 +1013,8 @@ var parseComponents = (components = {}) => ({
   headers: parseHeaders(components.headers),
   parameters: parseParameters(components.parameters),
   requestBodies: parseRequestBodies(components.requestBodies),
-  responseBodies: parseResponseBodies(components.responses)
+  responseBodies: parseResponseBodies(components.responses),
+  securitySchemes: parseSecuritySchemes(components.securitySchemes)
 });
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/openapi-typegen",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "chalk": "<5",
     "change-case": "4.1.2",
     "prettier": "3.2.5",
-    "yaml": "2.3.4",
+    "yaml": "2.4.0",
     "yargs": "17.7.2",
     "yarn": "1.22.21"
   }