apigen-ts 1.2.0 → 1.3.0

package/dist/main-C0qK6dZX.cjs

@@ -1,580 +0,0 @@
-'use strict';
-
-var fs = require('fs/promises');
-var path$1 = require('path');
-var url = require('url');
-var cleye = require('cleye');
-var redocly = require('@redocly/openapi-core');
-var arrayUtilsTs = require('array-utils-ts');
-var lodashEs = require('lodash-es');
-var swagger2openapi = require('swagger2openapi');
-var ts = require('typescript');
-var path = require('node:path');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-var name = "apigen-ts";
-var version = "1.2.0";
-
-const initCtx = (config) => {
-  return {
-    source: "",
-    output: "",
-    name: "ApiClient",
-    doc: { openapi: "3.1.0" },
-    parseDates: false,
-    inlineEnums: false,
-    headers: {},
-    ...config,
-    logTag: "",
-    usedNames: /* @__PURE__ */ new Set()
-  };
-};
-const parseHeaders = (items) => {
-  const headers = {};
-  for (const item of items) {
-    const [key, val] = item.split(":");
-    if (key && val) headers[key.trim()] = val.trim();
-  }
-  return headers;
-};
-const getCliConfig = () => {
-  const argv = cleye.cli({
-    name,
-    version,
-    parameters: ["<source>", "[output]"],
-    flags: {
-      name: {
-        type: String,
-        description: "API class name to export",
-        default: "ApiClient"
-      },
-      parseDates: {
-        type: Boolean,
-        description: "Parse dates as Date objects",
-        default: false
-      },
-      inlineEnums: {
-        type: Boolean,
-        description: "Use inline enums instead of enum types",
-        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: []
-      }
-    }
-  });
-  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)
-  };
-  return config;
-};
-
-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) => lodashEs.get(acc, x, lodashEs.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) => lodashEs.get(config, ["responses", x, "content"]));
-  const cts = Object.entries(lodashEs.get(config, ["responses", successCodes[0], "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 = arrayUtilsTs.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 = lodashEs.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 = lodashEs.uniq(values).map((x) => f$2.createNumericLiteral(x));
-    return f$2.createUnionTypeNode(tokens.map((x) => f$2.createLiteralTypeNode(x)));
-  }
-  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 && !lodashEs.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) {
-    return 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 ("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 (s.type === "string") t = f$2.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-    else if (s.type === "null") t = f$2.createLiteralTypeNode(f$2.createNull());
-    else if (lodashEs.isArray(s.type)) t = makeLiteralUnion(ctx, s.type);
-    else if (s.type === "array" && !lodashEs.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 makeTypeAlias = (ctx, name, s) => {
-  if (isStringEnum(s) && !ctx.inlineEnums) {
-    const tokens1 = lodashEs.uniq(s.enum);
-    const tokens2 = arrayUtilsTs.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(lodashEs.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) => lodashEs.upperFirst(x));
-  tmp[0] = tmp[0].toUpperCase() === tmp[0] ? tmp[0].toLowerCase() : lodashEs.lowerFirst(tmp[0]);
-  return tmp.join("");
-};
-const getOpName = (ctx, op) => {
-  let ns = normalizeOpName(arrayUtilsTs.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 = lodashEs.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 = arrayUtilsTs.filterNullable(cfg.parameters.map((x) => unref(ctx, x)));
-  const params = lodashEs.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);
-  });
-  const cbArgs = arrayUtilsTs.filterNullable([
-    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 (!lodashEs.isObject(pathConfig)) 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 [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 = lodashEs.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 } = await redocly.bundle({
-    ref: url,
-    config: await redocly.createConfig({}),
-    removeUnusedComponents: false,
-    externalRefResolver: new redocly.BaseResolver({
-      http: {
-        headers: Object.entries(headers).map(([name, value]) => {
-          return { name, value, matches: "**" };
-        })
-      }
-    })
-  });
-  if (bundle.parsed.swagger && upgrade) {
-    const { openapi } = await swagger2openapi.convertObj(bundle.parsed, { patch: true });
-    return openapi;
-  }
-  return bundle.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, headers: config.headers });
-  const ctx = initCtx({ ...config, doc });
-  const { modules, types } = await generateAst(ctx);
-  const filepath = path$1.join(path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('main-C0qK6dZX.cjs', document.baseURI).href)))), "_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(path$1.dirname(config.output), { recursive: true });
-    await fs.writeFile(config.output, result);
-  }
-};
-
-exports.apigen = apigen;
-exports.getCliConfig = getCliConfig;