@sebspark/openapi-typegen 1.5.1 → 1.6.0

package/dist/index.js

@@ -336,7 +336,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 +344,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 +443,7 @@ var generate = (name, doc) => `
    APIServerDefinition,
    BaseClient,
    GenericRouteHandler,
+   LowerCaseHeaders,
    PartiallySerialized,
    RequestOptions,
    Serialized,
@@ -482,6 +491,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");
 };
 
@@ -670,13 +694,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 +710,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 +938,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 +1002,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.6.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",