apigen-ts 0.0.2 → 0.1.0

package/dist/main-0ae61014.cjs

@@ -0,0 +1,582 @@
+'use strict';
+
+var fs = require('fs/promises');
+var path = 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 prettier = require('prettier');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var prettier__namespace = /*#__PURE__*/_interopNamespaceDefault(prettier);
+
+const initCtx = (config) => {
+  return {
+    source: "",
+    output: "",
+    name: "ApiClient",
+    parseDates: false,
+    doc: { openapi: "3.1.0" },
+    ...config,
+    logTag: "",
+    usedNames: /* @__PURE__ */ new Set()
+  };
+};
+const getCliConfig = () => {
+  const argv = cleye.cli({
+    name: "apigen",
+    // version: "0.0.1",
+    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
+      }
+    }
+  });
+  const config = {
+    source: argv._.source,
+    output: argv._.output,
+    name: argv.flags.name,
+    parseDates: argv.flags.parseDates
+  };
+  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"
+  // 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 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) {
+    if (Array.isArray(s.type)) {
+      const types = [];
+      for (const type of s.type) {
+        if (type === "null")
+          types.push({ type: "null" });
+        else
+          types.push({ ...s, type });
+      }
+      return mk({ oneOf: types });
+    }
+    let t;
+    if (s.type === "object")
+      t = f$2.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword);
+    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 === "array")
+      t = f$2.createArrayTypeNode(mk(s.items));
+    else if (s.type === "null")
+      t = f$2.createLiteralTypeNode(f$2.createNull());
+    else if (lodashEs.isArray(s.type))
+      t = f$2.createUnionTypeNode(s.type.map((x) => mk({ type: x })));
+    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");
+    }
+    return s.nullable ? f$2.createUnionTypeNode([t, f$2.createLiteralTypeNode(f$2.createNull())]) : 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)) {
+    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) => {
+  const { bundle } = await redocly.bundle({
+    ref: url,
+    config: await redocly.createConfig({}),
+    removeUnusedComponents: false
+  });
+  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) => {
+  const options = await prettier__namespace.resolveConfig((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('main-0ae61014.cjs', document.baseURI).href)));
+  return prettier__namespace.format(code, { ...options, parser: "typescript" });
+};
+
+const apigen = async (config) => {
+  const doc = await loadSchema(config.source);
+  const ctx = initCtx({ ...config, doc });
+  const { modules, types } = await generateAst(ctx);
+  const filepath = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('main-0ae61014.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}
+`,
+    ...file.split("\n").filter((x) => !x.startsWith("// Note: "))
+  ].join("\n");
+  if (!ctx.parseDates) {
+    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}`);
+  await fs.mkdir(path.dirname(config.output), { recursive: true });
+  await fs.writeFile(config.output, await formatCode(code));
+};
+
+exports.apigen = apigen;
+exports.getCliConfig = getCliConfig;