apigen-ts 1.2.1 → 1.3.0

package/dist/main.mjs

@@ -1,11 +1,573 @@
-import 'fs/promises';
-import 'path';
-import 'url';
-export { a as apigen } from './main-BZrWxHPM.mjs';
+import fs from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import 'cleye';
-import '@redocly/openapi-core';
-import 'array-utils-ts';
-import 'lodash-es';
-import 'swagger2openapi';
-import 'typescript';
-import 'node:path';
+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';
+import ts from 'typescript';
+import path from 'node:path';
+
+const initCtx = (config) => {
+  return {
+    source: "",
+    output: "",
+    name: "ApiClient",
+    doc: { openapi: "3.1.0" },
+    parseDates: false,
+    inlineEnums: false,
+    fetchOptions: false,
+    headers: {},
+    ...config,
+    logTag: "",
+    usedNames: /* @__PURE__ */ new Set()
+  };
+};
+
+const unref = (ctx, s) => {
+  if (!s) return void 0;
+  if ("$ref" in s && s.$ref) {
+    const parts = s.$ref.replace("#/", "").split("/");
+    const obj = parts.reduce(
+      // openapi encodes "/" in key as "~1"
+      (acc, x) => get(acc, x, get(acc, decodeURIComponent(x).replaceAll("~1", "/"))),
+      ctx.doc
+    );
+    if (obj) return obj;
+    console.warn(`${ctx.logTag} ref ${s.$ref} not found`);
+    return void 0;
+  }
+  return s;
+};
+const getReqSchema = (ctx, config) => {
+  const req = unref(ctx, config.requestBody);
+  if (!req) return void 0;
+  const cts = Object.entries(req.content ?? {}).map((x) => [x[0].split(";")[0], x[1].schema]).filter((x) => x[1]);
+  if (cts.length === 0) return void 0;
+  const pretenders = [
+    "application/json",
+    "text/",
+    "multipart/form-data",
+    "application/x-www-form-urlencoded"
+  ];
+  for (const p of pretenders) {
+    const ct = cts.find((x) => x[0].startsWith(p));
+    if (ct) return ct;
+  }
+  cts.map((x) => x[0]);
+  return void 0;
+};
+const getRepSchema = (ctx, config) => {
+  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;
+  const ctText = cts.find((x) => x[0].startsWith("text/"));
+  if (ctText) return { type: "string" };
+  cts.map((x) => x[0]).join(", ");
+  return void 0;
+};
+
+const f$2 = ts.factory;
+const Keywords = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  "any",
+  "boolean",
+  "number",
+  "string",
+  "symbol",
+  // "abstract", "as", "async", "await", "constructor", "declare", "from", "get", "is", "module", 
+  // "namespace", "of", "require", "set", "type",
+  "Record",
+  "Partial",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  // ts keywords
+  "Date",
+  "object",
+  "Response"
+  // ts type names
+]);
+const normalizeIdentifier = (val, asVar = false) => {
+  let name = val.replace("#/components/schemas/", "").replaceAll("'", "").replace(/[^a-zA-Z0-9]/g, "_");
+  if (name.match(/^\d/)) name = `$${name}`;
+  if (asVar && Keywords.has(name)) name = `$${name}`;
+  return name;
+};
+const makeInlineEnum = (s) => {
+  if (!s.enum) return void 0;
+  const values = filterEmpty(s.enum);
+  if (!values.length) return void 0;
+  if (!s.type) {
+    if (values.every((x) => typeof x === "string")) s.type = "string";
+    if (values.every((x) => typeof x === "number")) s.type = "number";
+    if (values.every((x) => typeof x === "boolean")) s.type = "boolean";
+  }
+  if (s.type === "string") {
+    const tokens = uniq(values).map((x) => f$2.createStringLiteral(x.toString()));
+    return f$2.createUnionTypeNode(tokens.map((x) => f$2.createLiteralTypeNode(x)));
+  }
+  if (s.type === "number") {
+    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 = [];
+    if (values.includes(true)) tokens.push(f$2.createToken(ts.SyntaxKind.TrueKeyword));
+    if (values.includes(false)) tokens.push(f$2.createToken(ts.SyntaxKind.FalseKeyword));
+    return f$2.createUnionTypeNode(tokens.map((x) => f$2.createLiteralTypeNode(x)));
+  }
+  console.warn(`enum with unknown type "${s.type}" in`, s);
+  return void 0;
+};
+const makeObject = (ctx, s) => {
+  if (s.type !== "object") throw new Error(`makeObject: not an object ${JSON.stringify(s)}`);
+  if (s.additionalProperties && !isBoolean(s.additionalProperties)) {
+    return f$2.createTypeReferenceNode("Record", [
+      f$2.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+      makeType(ctx, s.additionalProperties)
+    ]);
+  }
+  return f$2.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword);
+};
+const makeLiteralUnion = (ctx, types) => {
+  const tokens = types.map((x) => makeType(ctx, { type: x }));
+  const hasUnknown = tokens.some((x) => x.kind === ts.SyntaxKind.UnknownKeyword);
+  if (hasUnknown) return f$2.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+  return f$2.createUnionTypeNode(tokens);
+};
+const makeType = (ctx, s) => {
+  const mk = makeType.bind(null, ctx);
+  if (s === void 0) return f$2.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+  if (s === null) return f$2.createLiteralTypeNode(f$2.createNull());
+  if ("$ref" in s && s.$ref) {
+    const parts = s.$ref.replace("#/", "").split("/");
+    if (parts.length === 3 && parts[0] === "components" && parts[1] === "schemas") {
+      return f$2.createTypeReferenceNode(normalizeIdentifier(parts[2], true));
+    }
+    const t = unref(ctx, s);
+    if (!t) throw new Error(`makeTypeRef: ref not found ${JSON.stringify(s)}`);
+    return makeType(ctx, t);
+  }
+  if ("oneOf" in s && s.oneOf) return f$2.createUnionTypeNode(s.oneOf.map(mk));
+  if ("anyOf" in s && s.anyOf) return f$2.createUnionTypeNode(s.anyOf.map(mk));
+  if ("allOf" in s && s.allOf) return f$2.createIntersectionTypeNode(s.allOf.map(mk));
+  if ("type" in s && s.type === "integer") s.type = "number";
+  if ("enum" in s && s.enum && !Array.isArray(s.type)) {
+    const isArray2 = s.type === "array";
+    const t = makeInlineEnum(isArray2 ? { ...s, type: s.items?.type } : s);
+    if (t) return isArray2 ? f$2.createArrayTypeNode(t) : t;
+  }
+  if ("properties" in s && s.properties) {
+    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}"`);
+      return f$2.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+    }
+    if (s.type === "string") {
+      if (s.format === "binary") t = f$2.createTypeReferenceNode("File");
+      if (s.format === "date-time" && ctx.parseDates) t = f$2.createTypeReferenceNode("Date");
+    }
+    if ("nullable" in s && s.nullable) {
+      return f$2.createUnionTypeNode([t, f$2.createLiteralTypeNode(f$2.createNull())]);
+    }
+    return t;
+  }
+  return f$2.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+};
+const isStringEnum = (s) => {
+  if ("enum" in s && s.enum) {
+    return s.enum.every((x) => typeof x === "string");
+  }
+  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);
+    const tokens2 = filterEmpty(tokens1);
+    if (tokens1.length !== tokens2.length) {
+      console.warn(`enum ${name} has empty values`, s);
+    }
+    return f$2.createEnumDeclaration(
+      [f$2.createToken(ts.SyntaxKind.ExportKeyword)],
+      normalizeIdentifier(name, true),
+      tokens2.map(
+        (x) => f$2.createEnumMember(upperFirst(normalizeIdentifier(x)), f$2.createStringLiteral(x))
+      )
+    );
+  }
+  return f$2.createTypeAliasDeclaration(
+    [f$2.createToken(ts.SyntaxKind.ExportKeyword)],
+    f$2.createIdentifier(normalizeIdentifier(name, true)),
+    void 0,
+    makeType(ctx, s)
+  );
+};
+
+const f$1 = ts.factory;
+const HttpMethods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+const normalizeOpName = (val) => {
+  const articles = /* @__PURE__ */ new Set(["a", "an", "the"]);
+  const tmp = val.replace(/'/, "").replace(/[^a-zA-Z0-9]/g, "_").split("_").filter((x) => x !== "" && !articles.has(x)).map((x) => upperFirst(x));
+  tmp[0] = tmp[0].toUpperCase() === tmp[0] ? tmp[0].toLowerCase() : lowerFirst(tmp[0]);
+  return tmp.join("");
+};
+const getOpName = (ctx, op) => {
+  let ns = normalizeOpName(filterEmpty(op.tags ?? [])[0] ?? "general");
+  let fn = op.operationId ?? null;
+  if (!fn) {
+    fn = op.path.replace(/^(\/api)?(\/v?\d\.?\d?)?\/(.+)$/, "$3");
+    fn = `${op.method}/${fn}`.replace(/\/+/, "/");
+  }
+  fn = normalizeOpName(fn);
+  let nsr = ns.split("").map((x) => `[${x.toUpperCase()}${x.toLowerCase()}]`).join("");
+  if (nsr.endsWith("[Ss]")) nsr += "?";
+  fn = fn.replace(new RegExp(`^${nsr}([Cc]ontroller|[Ss]ervice)?([A-Z].*)$`), "$2");
+  fn = lowerFirst(fn);
+  const proposal = [ns, fn];
+  if (ctx.resolveName) {
+    const res = ctx.resolveName(ctx, op, proposal);
+    if (Array.isArray(res) && res.length === 2) return res;
+    if (res !== void 0) {
+      console.warn(`${ctx.logTag} resolveName should return [ns, fn] or undefined (skipping)`);
+    }
+  }
+  return proposal;
+};
+const prepareUrl = (url, rename) => {
+  for (const [k, v] of Object.entries(rename)) url = url.replaceAll(`{${k}}`, "${" + v + "}");
+  const parts = url.split("${");
+  if (parts.length === 1) return f$1.createStringLiteral(url);
+  return f$1.createTemplateExpression(
+    f$1.createTemplateHead(parts[0]),
+    parts.slice(1).map((x, i) => {
+      const [name, ...rest] = x.split("}");
+      const right = rest.join("}");
+      return f$1.createTemplateSpan(
+        f$1.createIdentifier(name),
+        // no normalization required
+        i === parts.length - 2 ? f$1.createTemplateTail(right) : f$1.createTemplateMiddle(right)
+      );
+    })
+  );
+};
+const prepareOp = (ctx, cfg, opName) => {
+  cfg.parameters = cfg.parameters ?? [];
+  const reqSchema = getReqSchema(ctx, cfg);
+  const repSchema = getRepSchema(ctx, cfg);
+  const allParams = filterNullable(cfg.parameters.map((x) => unref(ctx, x)));
+  const params = uniqBy(allParams.filter((x) => x.in === "path"), "name");
+  if (reqSchema) params.push({ name: "body", schema: reqSchema[1] });
+  const search = allParams.filter((x) => x.in === "query");
+  allParams.filter((x) => x.in === "header");
+  for (const [name, v] of Object.entries({ search })) {
+    if (!v.length) continue;
+    const properties = v.reduce((acc, x) => ({ ...acc, [x.name]: x.schema }), {});
+    params.push({ name, schema: { type: "object", properties } });
+  }
+  const urlReplacements = {};
+  const fnArgs = params.map((x) => {
+    const name = normalizeIdentifier(x.name, true);
+    const type = makeType(ctx, x.schema);
+    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(
+      "headers",
+      f$1.createObjectLiteralExpression([
+        f$1.createPropertyAssignment(
+          f$1.createStringLiteral("content-type"),
+          f$1.createStringLiteral(reqSchema[0])
+        )
+      ])
+    ) : void 0
+  ]);
+  return f$1.createPropertyAssignment(
+    f$1.createIdentifier(normalizeIdentifier(opName)),
+    f$1.createArrowFunction(
+      void 0,
+      void 0,
+      fnArgs,
+      void 0,
+      void 0,
+      f$1.createBlock([
+        f$1.createReturnStatement(
+          f$1.createCallExpression(
+            f$1.createIdentifier("this.Fetch"),
+            [makeType(ctx, repSchema)],
+            [
+              f$1.createStringLiteral(cfg.method),
+              // method
+              prepareUrl(cfg.path, urlReplacements),
+              // path
+              f$1.createObjectLiteralExpression(cbArgs)
+              // { query, body, headers }
+            ]
+          )
+        )
+      ])
+    )
+  );
+};
+const prepareNs = (ctx, name, handlers) => {
+  return f$1.createPropertyDeclaration(
+    void 0,
+    normalizeIdentifier(name),
+    void 0,
+    void 0,
+    f$1.createObjectLiteralExpression(handlers)
+  );
+};
+const prepareRoutes = async (ctx) => {
+  const routes = {};
+  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;
+    }
+    for (const method of HttpMethods) {
+      ctx.logTag = `${method.toUpperCase().padEnd(6, " ")} ${path}`;
+      const config = pathConfig[method];
+      if (!config) continue;
+      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(".");
+      if (ctx.usedNames.has(joined)) {
+        continue;
+      } else {
+        ctx.usedNames.add(joined);
+      }
+      try {
+        routes[ns].push(prepareOp(ctx, { ...config, method, path }, op));
+      } catch (e) {
+        console.error(`${ctx.logTag} - ${e}`, config);
+        throw e;
+      }
+    }
+  }
+  return routes;
+};
+const prepareTypes = async (ctx) => {
+  const types = [];
+  const typesConfig = sortBy(Object.entries(ctx.doc.components?.schemas ?? {}), ([k]) => k);
+  for (const [name, config] of typesConfig) {
+    try {
+      types.push(makeTypeAlias(ctx, name, config));
+    } catch (e) {
+      console.error(`${ctx.logTag} - ${e}`, name, config);
+      throw e;
+    }
+  }
+  return types;
+};
+const generateAst = async (ctx) => {
+  const types = await prepareTypes(ctx);
+  const routes = await prepareRoutes(ctx);
+  const modules = [];
+  for (const [k, v] of Object.entries(routes)) {
+    modules.push(prepareNs(ctx, k, v));
+  }
+  return { modules, types };
+};
+const loadSchema = async ({
+  url,
+  upgrade = true,
+  headers = {}
+}) => {
+  if (url.startsWith("file://")) url = url.substring(7);
+  const { bundle: bundle$1 } = await bundle({
+    ref: url,
+    config: await createConfig({}),
+    removeUnusedComponents: false,
+    externalRefResolver: new BaseResolver({
+      http: {
+        headers: Object.entries(headers).map(([name, value]) => {
+          return { name, value, matches: "**" };
+        })
+      }
+    })
+  });
+  const parsed = bundle$1.parsed;
+  if ("swagger" in parsed && upgrade) {
+    const { openapi } = await convertObj(parsed, { patch: true });
+    return openapi;
+  }
+  return parsed;
+};
+
+const f = ts.factory;
+const addNewLines = (nodes) => {
+  const result = [];
+  for (const node of nodes) {
+    result.push(node);
+    result.push(f.createIdentifier("\n"));
+  }
+  return result;
+};
+const printCode = (nodes) => {
+  return ts.createPrinter().printFile(
+    f.createSourceFile(
+      addNewLines(nodes),
+      f.createToken(ts.SyntaxKind.EndOfFileToken),
+      ts.NodeFlags.None
+    )
+  ).replaceAll("}, ", "},\n\n");
+};
+const formatCode = async (code) => {
+  try {
+    const prettier = await import('prettier');
+    const options = await prettier.resolveConfig(path.join(process.cwd(), "file"));
+    return prettier.format(code, { ...options, parser: "typescript" });
+  } catch (e) {
+    return code;
+  }
+};
+
+const apigen = async (config) => {
+  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");
+  const file = await fs.readFile(filepath, "utf-8");
+  let code = [
+    `// Auto-generated by https://github.com/vladkens/apigen-ts`,
+    `// Source: ${config.source}
+`,
+    // remove all comments expect which starts with "// apigen:"
+    ...file.split("\n").filter((x) => !/\s*\/\/\s(?!apigen:)/.test(x))
+  ].join("\n");
+  if (!ctx.parseDates) {
+    code = code.replace(/\s*ISO_FORMAT\s=.+$/gm, "");
+    code = code.replace(/PopulateDates.+?\n\s{2}\}/s, "");
+    code = code.replace(/this.PopulateDates\((.+)\)/, "$1");
+  }
+  code = code.replace("// apigen:modules", printCode(modules));
+  code = code.replace("// apigen:types", printCode(types));
+  code = code.replace("class ApiClient", `class ${ctx.name}`);
+  const result = await formatCode(code);
+  if (config.output === null) {
+    process.stdout.write(result);
+  } else {
+    await fs.mkdir(dirname(config.output), { recursive: true });
+    await fs.writeFile(config.output, result);
+  }
+};
+
+export { apigen };

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "apigen-ts",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "license": "MIT",
   "author": "vladkens <v.pronsky@gmail.com>",
   "repository": "vladkens/apigen-ts",
@@ -16,30 +16,28 @@
   ],
   "scripts": {
     "build": "rm -rf dist && pkgroll && cp ./src/_template.ts ./dist && ls -lah dist",
-    "test": "uvu -r tsm test '\\.test\\.ts$'",
-    "test-cov": "c8 --include=src yarn test",
-    "format": "prettier --write .",
-    "ci": "tsc --noEmit && yarn test-cov && yarn build"
+    "test": "tsx --test --test-reporter=dot test/*.test.ts",
+    "test-cov": "tsx --experimental-test-coverage --test test/*.test.ts",
+    "format": "prettier --write --log-level warn .",
+    "ci": "tsc --noEmit && npm run test-cov && npm run build"
   },
   "dependencies": {
-    "@redocly/openapi-core": "1.34.3",
+    "@redocly/openapi-core": "2.21.1",
     "@types/lodash-es": "4.17.12",
     "@types/swagger2openapi": "7.0.4",
-    "array-utils-ts": "1.0.2",
-    "cleye": "1.3.4",
-    "lodash-es": "4.17.21",
+    "array-utils-ts": "1.1.0",
+    "cleye": "2.3.0",
+    "lodash-es": "4.17.23",
     "swagger2openapi": "7.0.8"
   },
   "devDependencies": {
-    "@types/node": "22.15.18",
-    "c8": "10.1.3",
-    "fetch-mock": "12.5.2",
-    "pkgroll": "2.12.2",
-    "prettier": "3.5.3",
-    "prettier-plugin-organize-imports": "4.1.0",
-    "tsm": "2.3.0",
-    "typescript": "5.8.3",
-    "uvu": "0.5.6"
+    "@types/node": "25.5.0",
+    "fetch-mock": "12.6.0",
+    "tsx": "4.21.0",
+    "pkgroll": "2.27.0",
+    "prettier": "3.8.1",
+    "prettier-plugin-organize-imports": "4.3.0",
+    "typescript": "5.9.3"
   },
   "peerDependencies": {
     "prettier": "^3.0.0",