apigen-ts 0.0.3 → 0.1.0

package/dist/_template.ts

@@ -1,19 +1,20 @@
-// Use uppercase for names in ApiClient to avoid conflict with the generated code
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-namespace apigen {
-  export type Config = { baseUrl: string; headers: Record<string, string> }
-  export type Req = Omit<RequestInit, "body"> & {
-    search?: Record<string, unknown>
-    body?: unknown
-  }
+// Note: Use uppercase for names in ApiClient to avoid conflict with the generated code
+
+interface ApigenConfig {
+  baseUrl: string
+  headers: Record<string, string>
+}
+
+interface ApigenRequest extends Omit<RequestInit, "body"> {
+  search?: Record<string, unknown>
+  body?: unknown
 }
 
 export class ApiClient {
   ISO_FORMAT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d*)?(?:[-+]\d{2}:?\d{2}|Z)?$/
-  Config: apigen.Config
+  Config: ApigenConfig
 
-  constructor(config?: Partial<apigen.Config>) {
+  constructor(config?: Partial<ApigenConfig>) {
     this.Config = { baseUrl: "/", headers: {}, ...config }
   }
 
@@ -39,7 +40,7 @@ export class ApiClient {
     }
   }
 
-  async Fetch<T>(method: string, path: string, opts: apigen.Req = {}): Promise<T> {
+  async Fetch<T>(method: string, path: string, opts: ApigenRequest = {}): Promise<T> {
     let base = this.Config.baseUrl
     if (globalThis.location && (base === "" || base.startsWith("/"))) {
       base = `${globalThis.location.origin}${base.endsWith("/") ? base : `/${base}`}`
@@ -79,4 +80,8 @@ export class ApiClient {
       return rs as unknown as T
     }
   }
+
+  // apigen:modules
 }
+
+// apigen:types

package/dist/cli.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var main$1 = require('./main-0ae61014.cjs');
+require('fs/promises');
+require('path');
+require('url');
+require('cleye');
+require('@redocly/openapi-core');
+require('array-utils-ts');
+require('lodash-es');
+require('swagger2openapi');
+require('typescript');
+require('prettier');
+
+const main = async () => {
+  await main$1.apigen(main$1.getCliConfig());
+};
+main();

package/dist/cli.js

@@ -1,532 +1,17 @@
 #!/usr/bin/env node
-import { cli } from 'cleye';
-import redocly from '@redocly/openapi-core';
-import { filterNullable, filterEmpty } from 'array-utils-ts';
-import fs from 'fs/promises';
-import { isObject, sortBy, get, lowerFirst, upperFirst, uniqBy, isArray, uniq } from 'lodash-es';
-import { dirname, join } from 'path';
-import * as prettier from 'prettier';
-import { convertObj } from 'swagger2openapi';
-import ts from 'typescript';
-import { fileURLToPath } from 'url';
-
-const f = ts.factory;
-const HttpMethods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
-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 initCtx = (doc, cfg) => {
-  return { name: "ApiClient", ...cfg, doc, tag: "", opNames: /* @__PURE__ */ new Set() };
-};
-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 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, cfg) => {
-  let ns = normalizeOpName(filterEmpty(cfg.tags ?? [])[0] ?? "general");
-  let op = cfg.operationId ?? null;
-  if (!op) {
-    op = cfg.path.replace(/^(\/api)?(\/v?\d\.?\d?)?\/(.+)$/, "$3");
-    op = `${cfg.method}/${op}`.replace(/\/+/, "/");
-  }
-  op = normalizeOpName(op);
-  let nsr = ns.split("").map((x) => `[${x.toUpperCase()}${x.toLowerCase()}]`).join("");
-  if (nsr.endsWith("[Ss]"))
-    nsr += "?";
-  op = op.replace(new RegExp(`^${nsr}([Cc]ontroller|[Ss]ervice)?([A-Z].*)$`), "$2");
-  op = lowerFirst(op);
-  return [ns, op];
-};
-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.createStringLiteral(x.toString()));
-    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
-  }
-  if (s.type === "number") {
-    const tokens = uniq(values).map((x) => f.createNumericLiteral(x));
-    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
-  }
-  if (s.type === "boolean") {
-    const tokens = [];
-    if (values.includes(true))
-      tokens.push(f.createToken(ts.SyntaxKind.TrueKeyword));
-    if (values.includes(false))
-      tokens.push(f.createToken(ts.SyntaxKind.FalseKeyword));
-    return f.createUnionTypeNode(tokens.map((x) => f.createLiteralTypeNode(x)));
-  }
-  console.warn(`enum with unknown type ${s.type}`, s);
-  return void 0;
-};
-const makeType = (ctx, s) => {
-  const mk = makeType.bind(null, ctx);
-  if (s === void 0)
-    return f.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
-  if (s === null)
-    return f.createLiteralTypeNode(f.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.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.createUnionTypeNode(s.oneOf.map(mk));
-  if ("anyOf" in s && s.anyOf)
-    return f.createUnionTypeNode(s.anyOf.map(mk));
-  if ("allOf" in s && s.allOf)
-    return f.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.createArrayTypeNode(t) : t;
-  }
-  if ("properties" in s && s.properties) {
-    return f.createTypeLiteralNode(
-      Object.entries(s.properties).map(([k, v]) => {
-        const r = s.required ?? [];
-        const q = r.includes(k) ? void 0 : f.createToken(ts.SyntaxKind.QuestionToken);
-        return f.createPropertySignature(void 0, f.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.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword);
-    else if (s.type === "boolean")
-      t = f.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-    else if (s.type === "number")
-      t = f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-    else if (s.type === "string")
-      t = f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-    else if (s.type === "array")
-      t = f.createArrayTypeNode(mk(s.items));
-    else if (s.type === "null")
-      t = f.createLiteralTypeNode(f.createNull());
-    else if (isArray(s.type))
-      t = f.createUnionTypeNode(s.type.map((x) => mk({ type: x })));
-    else
-      throw new Error(`makeType: unknown type ${s.type}`);
-    if (s.type === "string") {
-      if (s.format === "binary")
-        t = f.createTypeReferenceNode("File");
-      if (s.format === "date-time")
-        t = f.createTypeReferenceNode("Date");
-    }
-    return s.nullable ? f.createUnionTypeNode([t, f.createLiteralTypeNode(f.createNull())]) : t;
-  }
-  return f.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 = s.enum;
-    const tokens2 = filterEmpty(s.enum);
-    if (tokens1.length !== tokens2.length) {
-      console.warn(`enum ${name} has empty values`, s);
-    }
-    return f.createEnumDeclaration(
-      [f.createToken(ts.SyntaxKind.ExportKeyword)],
-      normalizeIdentifier(name, true),
-      tokens2.map(
-        (x) => f.createEnumMember(upperFirst(normalizeIdentifier(x)), f.createStringLiteral(x))
-      )
-    );
-  }
-  return f.createTypeAliasDeclaration(
-    [f.createToken(ts.SyntaxKind.ExportKeyword)],
-    f.createIdentifier(normalizeIdentifier(name, true)),
-    void 0,
-    makeType(ctx, s)
-  );
-};
-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.tag} 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, "content"]));
-  const cts = Object.entries(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 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.createStringLiteral(url);
-  return f.createTemplateExpression(
-    f.createTemplateHead(parts[0]),
-    parts.slice(1).map((x, i) => {
-      const [name, ...rest] = x.split("}");
-      const right = rest.join("}");
-      return f.createTemplateSpan(
-        f.createIdentifier(name),
-        // no normalization required
-        i === parts.length - 2 ? f.createTemplateTail(right) : f.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.createParameterDeclaration(void 0, void 0, name, void 0, type);
-  });
-  const cbArgs = filterNullable([
-    search.length ? f.createShorthandPropertyAssignment("search") : void 0,
-    reqSchema && f.createShorthandPropertyAssignment("body"),
-    reqSchema && reqSchema[0] !== "application/json" ? f.createPropertyAssignment(
-      "headers",
-      f.createObjectLiteralExpression([
-        f.createPropertyAssignment(
-          f.createStringLiteral("content-type"),
-          f.createStringLiteral(reqSchema[0])
-        )
-      ])
-    ) : void 0
-  ]);
-  return f.createPropertyAssignment(
-    f.createIdentifier(normalizeIdentifier(opName)),
-    f.createArrowFunction(
-      void 0,
-      void 0,
-      fnArgs,
-      void 0,
-      void 0,
-      f.createBlock([
-        f.createReturnStatement(
-          f.createCallExpression(
-            f.createIdentifier("this.Fetch"),
-            [makeType(ctx, repSchema)],
-            [
-              f.createStringLiteral(cfg.method),
-              // method
-              prepareUrl(cfg.path, urlReplacements),
-              // path
-              f.createObjectLiteralExpression(cbArgs)
-              // { query, body, headers }
-            ]
-          )
-        )
-      ])
-    )
-  );
-};
-const prepareNs = (ctx, name, handlers) => {
-  return f.createPropertyDeclaration(
-    void 0,
-    normalizeIdentifier(name),
-    void 0,
-    void 0,
-    f.createObjectLiteralExpression(handlers)
-  );
-};
-const prepareRoutes = async (ctx) => {
-  const routes = {};
-  for (const [path, pathConfig] of Object.entries(ctx.doc.paths ?? {})) {
-    ctx.tag = `${"[ALL]".toUpperCase().padEnd(6, " ")} ${path}`;
-    if (!isObject(pathConfig))
-      continue;
-    if ("$ref" in pathConfig) {
-      console.warn(`${ctx.tag} $ref should be resolved before (skipping)`);
-      continue;
-    }
-    for (const method of HttpMethods) {
-      ctx.tag = `${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.opNames.has(joined)) {
-        continue;
-      } else {
-        ctx.opNames.add(joined);
-      }
-      try {
-        routes[ns].push(prepareOp(ctx, { ...config, method, path }, op));
-      } catch (e) {
-        console.error(`${ctx.tag} - ${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.tag} - ${e}`, name, config);
-      throw e;
-    }
-  }
-  return types;
-};
-const patchTemplate = async (ctx, modules) => {
-  const filepath = join(dirname(fileURLToPath(import.meta.url)), "_template.ts");
-  const file = await fs.readFile(filepath, "utf-8");
-  const root = ts.createSourceFile("tmpl.ts", file, ts.ScriptTarget.Latest);
-  return Array.from(root.statements).map((x) => {
-    if (x.kind === ts.SyntaxKind.ClassDeclaration) {
-      const name = get(x, "name.text");
-      if (name === "ApiClient") {
-        const t = x;
-        return f.updateClassDeclaration(
-          t,
-          t.modifiers,
-          f.createIdentifier(ctx.name),
-          t.typeParameters,
-          t.heritageClauses,
-          addNewLines([...t.members, ...modules])
-        );
-      }
-    }
-    return x;
-  });
-};
-const prepareAst = 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 filterNullable([...await patchTemplate(ctx, modules), ...types]);
-};
-const addNewLines = (nodes) => {
-  const result = [];
-  for (const node of nodes) {
-    result.push(node);
-    result.push(f.createIdentifier("\n"));
-  }
-  return result;
-};
-const loadSchema = async (url) => {
-  const { bundle } = await redocly.bundle({
-    ref: url,
-    config: await redocly.createConfig({}),
-    removeUnusedComponents: false
-  });
-  if (bundle.parsed.swagger) {
-    const { openapi } = await convertObj(bundle.parsed, { patch: true });
-    return openapi;
-  }
-  return bundle.parsed;
-};
-const printCode = async (nodes) => {
-  const code = ts.createPrinter().printFile(
-    f.createSourceFile(
-      addNewLines(nodes),
-      f.createToken(ts.SyntaxKind.EndOfFileToken),
-      ts.NodeFlags.None
-    )
-  ).replaceAll("}, ", "},\n\n");
-  const options = await prettier.resolveConfig(process.cwd());
-  return prettier.format(code, { ...options, parser: "typescript" });
-};
-const apigen = async (source, output, cfg) => {
-  const doc = await loadSchema(source);
-  const ast = await prepareAst(initCtx(doc, cfg));
-  const txt = [
-    `// Auto-generated by https://github.com/vladkens/apigen-ts`,
-    `// Source: ${source}
-`,
-    await printCode(ast)
-  ].join("\n");
-  await fs.mkdir(dirname(output), { recursive: true });
-  await fs.writeFile(output, txt);
-};
+import { a as apigen, g as getCliConfig } from './main-0c2fa229.js';
+import 'fs/promises';
+import 'path';
+import 'url';
+import 'cleye';
+import '@redocly/openapi-core';
+import 'array-utils-ts';
+import 'lodash-es';
+import 'swagger2openapi';
+import 'typescript';
+import 'prettier';
 
 const main = async () => {
-  const argv = cli({
-    name: "apigen",
-    // version: "0.0.1",
-    parameters: ["<source>", "<output>"],
-    flags: {
-      name: {
-        type: String,
-        description: "api class name to export",
-        default: "ApiClient"
-      }
-    }
-  });
-  await apigen(argv._.source, argv._.output, { name: argv.flags.name });
+  await apigen(getCliConfig());
 };
 main();

package/dist/cli.mjs

@@ -0,0 +1,16 @@
+import { a as apigen, g as getCliConfig } from './main-0c2fa229.mjs';
+import 'fs/promises';
+import 'path';
+import 'url';
+import 'cleye';
+import '@redocly/openapi-core';
+import 'array-utils-ts';
+import 'lodash-es';
+import 'swagger2openapi';
+import 'typescript';
+import 'prettier';
+
+const main = async () => {
+  await apigen(getCliConfig());
+};
+main();