apigen-ts 1.2.0 → 1.3.0

package/dist/_template.ts

@@ -69,7 +69,7 @@ export class ApiClient {
     const headers = new Headers({ ...configHeaders, ...opts.headers })
     const ct = headers.get("content-type") ?? "application/json"
 
-    let body: FormData | URLSearchParams | string | undefined = undefined
+    let body: FormData | URLSearchParams | string | null = null
 
     if (ct === "multipart/form-data" || ct === "application/x-www-form-urlencoded") {
       // https://stackoverflow.com/a/61053359/3664464

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as apigen, g as getCliConfig } from './main-l0LIDQ3K.js';
+import { a as apigen, g as getCliConfig } from './main-B8jUVaQq.js';
 import 'fs/promises';
 import 'path';
 import 'url';

package/dist/{main-l0LIDQ3K.mjs → main-B8jUVaQq.js}

@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { cli } from 'cleye';
-import redocly, { BaseResolver } from '@redocly/openapi-core';
+import { bundle, BaseResolver, createConfig } from '@redocly/openapi-core';
 import { filterEmpty, filterNullable } from 'array-utils-ts';
 import { get, uniq, upperFirst, isArray, isBoolean, sortBy, isObject, lowerFirst, uniqBy } from 'lodash-es';
 import { convertObj } from 'swagger2openapi';
@@ -10,7 +10,7 @@ import ts from 'typescript';
 import path from 'node:path';
 
 var name = "apigen-ts";
-var version = "1.2.0";
+var version = "1.3.0";
 
 const initCtx = (config) => {
   return {
@@ -20,6 +20,7 @@ const initCtx = (config) => {
     doc: { openapi: "3.1.0" },
     parseDates: false,
     inlineEnums: false,
+    fetchOptions: false,
     headers: {},
     ...config,
     logTag: "",
@@ -55,21 +56,51 @@ const getCliConfig = () => {
         description: "Use inline enums instead of enum types",
         default: false
       },
+      fetchOptions: {
+        type: Boolean,
+        description: "Add fetch options (e.g. AbortSignal) as last argument to each method",
+        default: false
+      },
       header: {
         type: [String],
         alias: "H",
         description: 'HTTP header as key=value (e.g., -H "x-api-key: your-key"). Used only when generating code.',
         default: []
+      },
+      filterPaths: {
+        type: String,
+        description: "Filter endpoints by path regex (e.g., --filter-paths '^/accounts')"
+      },
+      includeTags: {
+        type: [String],
+        description: "Only include operations with these tags (comma-separated or repeated flag)",
+        default: []
+      },
+      excludeTags: {
+        type: [String],
+        description: "Exclude operations with these tags (comma-separated or repeated flag)",
+        default: []
       }
     }
   });
+  const parseTags = (items) => {
+    const tags = items.flatMap((x) => x.split(",")).map((x) => x.trim()).filter(Boolean);
+    return tags.length ? tags : void 0;
+  };
+  const filterPaths = argv.flags.filterPaths ? new RegExp(argv.flags.filterPaths) : void 0;
+  const includeTags = parseTags(argv.flags.includeTags);
+  const excludeTags = parseTags(argv.flags.excludeTags);
   const config = {
     source: argv._.source,
     output: argv._.output ?? null,
     name: argv.flags.name,
     parseDates: argv.flags.parseDates,
     inlineEnums: argv.flags.inlineEnums,
-    headers: parseHeaders(argv.flags.header)
+    fetchOptions: argv.flags.fetchOptions,
+    headers: parseHeaders(argv.flags.header),
+    ...filterPaths ? { filterPaths } : {},
+    ...includeTags ? { includeTags } : {},
+    ...excludeTags ? { excludeTags } : {}
   };
   return config;
 };
@@ -108,8 +139,10 @@ const getReqSchema = (ctx, config) => {
   return void 0;
 };
 const getRepSchema = (ctx, config) => {
-  const successCodes = Object.keys(config.responses ?? {}).filter((x) => x.startsWith("2")).filter((x) => get(config, ["responses", x, "content"]));
-  const cts = Object.entries(get(config, ["responses", successCodes[0], "content"], {})).filter((x) => x[1].schema);
+  const successCodes = Object.keys(config.responses ?? {}).filter((x) => x.startsWith("2")).filter((x) => get(config, ["responses", x]));
+  const firstSuccess = unref(ctx, get(config, ["responses", successCodes[0]], {}));
+  if (!firstSuccess || !("content" in firstSuccess)) return void 0;
+  const cts = Object.entries(firstSuccess.content ?? {}).filter((x) => x[1].schema);
   if (cts.length === 0) return void 0;
   const ctJson = cts.find((x) => x[0].startsWith("application/json"));
   if (ctJson) return ctJson[1].schema;
@@ -205,8 +238,16 @@ const makeInlineEnum = (s) => {
     return f$2.createUnionTypeNode(tokens.map((x) => f$2.createLiteralTypeNode(x)));
   }
   if (s.type === "number") {
-    const tokens = uniq(values).map((x) => f$2.createNumericLiteral(x));
-    return f$2.createUnionTypeNode(tokens.map((x) => f$2.createLiteralTypeNode(x)));
+    const tokens = uniq(values).map((x) => {
+      const n = x;
+      if (n < 0) {
+        return f$2.createLiteralTypeNode(
+          f$2.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, f$2.createNumericLiteral(-n))
+        );
+      }
+      return f$2.createLiteralTypeNode(f$2.createNumericLiteral(n));
+    });
+    return f$2.createUnionTypeNode(tokens);
   }
   if (s.type === "boolean") {
     const tokens = [];
@@ -256,22 +297,29 @@ const makeType = (ctx, s) => {
     if (t) return isArray2 ? f$2.createArrayTypeNode(t) : t;
   }
   if ("properties" in s && s.properties) {
-    return f$2.createTypeLiteralNode(
+    let t = f$2.createTypeLiteralNode(
       Object.entries(s.properties).map(([k, v]) => {
         const r = s.required ?? [];
         const q = r.includes(k) ? void 0 : f$2.createToken(ts.SyntaxKind.QuestionToken);
         return f$2.createPropertySignature(void 0, f$2.createStringLiteral(k), q, mk(v));
       })
     );
+    if ("nullable" in s && s.nullable) {
+      return f$2.createUnionTypeNode([t, f$2.createLiteralTypeNode(f$2.createNull())]);
+    }
+    return t;
   }
   if ("type" in s) {
     let t;
     if (s.type === "object") t = makeObject(ctx, s);
     else if (s.type === "boolean") t = f$2.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
     else if (s.type === "number") t = f$2.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+    else if (isConstantString(s)) t = f$2.createLiteralTypeNode(f$2.createStringLiteral(s.const));
     else if (s.type === "string") t = f$2.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
     else if (s.type === "null") t = f$2.createLiteralTypeNode(f$2.createNull());
     else if (isArray(s.type)) t = makeLiteralUnion(ctx, s.type);
+    else if (s.type === "array" && isPrefixItems(s) && s.prefixItems && !s.items)
+      t = f$2.createTupleTypeNode(s.prefixItems.map(mk));
     else if (s.type === "array" && !isBoolean(s.items)) t = f$2.createArrayTypeNode(mk(s.items));
     else {
       console.warn(`makeType: unknown type "${s.type}"`);
@@ -294,6 +342,12 @@ const isStringEnum = (s) => {
   }
   return false;
 };
+const isPrefixItems = (s) => {
+  return s.prefixItems !== void 0;
+};
+const isConstantString = (s) => {
+  return s.type === "string" && s.const !== void 0;
+};
 const makeTypeAlias = (ctx, name, s) => {
   if (isStringEnum(s) && !ctx.inlineEnums) {
     const tokens1 = uniq(s.enum);
@@ -385,7 +439,19 @@ const prepareOp = (ctx, cfg, opName) => {
     urlReplacements[x.name] = name;
     return f$1.createParameterDeclaration(void 0, void 0, name, void 0, type);
   });
+  if (ctx.fetchOptions) {
+    fnArgs.push(
+      f$1.createParameterDeclaration(
+        void 0,
+        void 0,
+        "opts",
+        f$1.createToken(ts.SyntaxKind.QuestionToken),
+        f$1.createTypeReferenceNode(f$1.createIdentifier("ApigenRequest"), void 0)
+      )
+    );
+  }
   const cbArgs = filterNullable([
+    ctx.fetchOptions ? f$1.createSpreadAssignment(f$1.createIdentifier("opts")) : void 0,
     search.length ? f$1.createShorthandPropertyAssignment("search") : void 0,
     reqSchema && f$1.createShorthandPropertyAssignment("body"),
     reqSchema && reqSchema[0] !== "application/json" ? f$1.createPropertyAssignment(
@@ -439,6 +505,10 @@ const prepareRoutes = async (ctx) => {
   for (const [path, pathConfig] of Object.entries(ctx.doc.paths ?? {})) {
     ctx.logTag = `${"[ALL]".toUpperCase().padEnd(6, " ")} ${path}`;
     if (!isObject(pathConfig)) continue;
+    if (ctx.filterPaths) {
+      const match = ctx.filterPaths instanceof RegExp ? ctx.filterPaths.test(path) : ctx.filterPaths(path);
+      if (!match) continue;
+    }
     if ("$ref" in pathConfig) {
       console.warn(`${ctx.logTag} $ref should be resolved before (skipping)`);
       continue;
@@ -450,6 +520,9 @@ const prepareRoutes = async (ctx) => {
       if (pathConfig.parameters) {
         config.parameters = [...config.parameters ?? [], ...pathConfig.parameters];
       }
+      const opTags = config.tags ?? [];
+      if (ctx.includeTags?.length && !opTags.some((t) => ctx.includeTags.includes(t))) continue;
+      if (ctx.excludeTags?.length && opTags.some((t) => ctx.excludeTags.includes(t))) continue;
       const [ns, op] = getOpName(ctx, { ...config, method, path });
       if (!routes[ns]) routes[ns] = [];
       const joined = [ns, op].join(".");
@@ -496,9 +569,9 @@ const loadSchema = async ({
   headers = {}
 }) => {
   if (url.startsWith("file://")) url = url.substring(7);
-  const { bundle } = await redocly.bundle({
+  const { bundle: bundle$1 } = await bundle({
     ref: url,
-    config: await redocly.createConfig({}),
+    config: await createConfig({}),
     removeUnusedComponents: false,
     externalRefResolver: new BaseResolver({
       http: {
@@ -508,11 +581,12 @@ const loadSchema = async ({
       }
     })
   });
-  if (bundle.parsed.swagger && upgrade) {
-    const { openapi } = await convertObj(bundle.parsed, { patch: true });
+  const parsed = bundle$1.parsed;
+  if ("swagger" in parsed && upgrade) {
+    const { openapi } = await convertObj(parsed, { patch: true });
     return openapi;
   }
-  return bundle.parsed;
+  return parsed;
 };
 
 const f = ts.factory;
@@ -544,7 +618,10 @@ const formatCode = async (code) => {
 };
 
 const apigen = async (config) => {
-  const doc = await loadSchema({ url: config.source, headers: config.headers });
+  const doc = await loadSchema({
+    url: config.source,
+    ...config.headers ? { headers: config.headers } : {}
+  });
   const ctx = initCtx({ ...config, doc });
   const { modules, types } = await generateAst(ctx);
   const filepath = join(dirname(fileURLToPath(import.meta.url)), "_template.ts");