@xyd-js/opencli2go 0.1.0-build.0

package/dist/index.cjs

@@ -0,0 +1,630 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  opencli2go: () => opencli2go,
+  writeProject: () => writeProject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/golit.ts
+var TAB = "	";
+var pad = (n) => TAB.repeat(n);
+var lit = (s) => () => s;
+var goStr = (s) => () => JSON.stringify(s);
+var goBool = (b) => () => String(b);
+function goStruct(type, fields, pointer = false) {
+  return (indent) => {
+    const head = `${pointer ? "&" : ""}${type}{`;
+    if (fields.length === 0) return `${head}}`;
+    let out = `${head}
+`;
+    for (const [k, v] of fields) {
+      out += `${pad(indent + 1)}${k}: ${v(indent + 1)},
+`;
+    }
+    out += `${pad(indent)}}`;
+    return out;
+  };
+}
+function goSlice(elemType, elems) {
+  return (indent) => {
+    if (elems.length === 0) return `[]${elemType}{}`;
+    let out = `[]${elemType}{
+`;
+    for (const e of elems) {
+      out += `${pad(indent + 1)}${e(indent + 1)},
+`;
+    }
+    out += `${pad(indent)}}`;
+    return out;
+  };
+}
+var Imports = class {
+  constructor() {
+    this.paths = /* @__PURE__ */ new Set();
+  }
+  add(...importPaths) {
+    for (const p of importPaths) this.paths.add(p);
+    return this;
+  }
+  get size() {
+    return this.paths.size;
+  }
+  render() {
+    if (this.paths.size === 0) return "";
+    const all = [...this.paths];
+    const std = all.filter((p) => !p.split("/")[0].includes(".")).sort();
+    const ext = all.filter((p) => p.split("/")[0].includes(".")).sort();
+    const groups = [std, ext].filter((g) => g.length > 0);
+    const block = groups.map((g) => g.map((p) => `${TAB}${JSON.stringify(p)}`).join("\n")).join("\n\n");
+    return `import (
+${block}
+)`;
+  }
+};
+function goFile(pkg, imports, decls) {
+  const parts = [`package ${pkg}`];
+  if (imports.size > 0) parts.push(imports.render());
+  parts.push(...decls);
+  return `${parts.join("\n\n")}
+`;
+}
+
+// src/flags.ts
+var FLAG_TYPE = {
+  bool: "BoolFlag",
+  int: "IntFlag",
+  float: "FloatFlag",
+  slice: "StringSliceFlag",
+  string: "StringFlag",
+  json: "StringFlag",
+  file: "StringFlag"
+};
+function renderFlag(f) {
+  const type = `cli.${FLAG_TYPE[f.goType]}`;
+  const fields = [["Name", goStr(f.flagName)]];
+  if (f.aliases.length) fields.push(["Aliases", goSlice("string", f.aliases.map(goStr))]);
+  if (f.description) fields.push(["Usage", goStr(f.description)]);
+  if (f.required) fields.push(["Required", goBool(true)]);
+  if (f.hidden) fields.push(["Hidden", goBool(true)]);
+  return goStruct(type, fields, true);
+}
+function renderFlags(flags) {
+  return flags.map(renderFlag);
+}
+
+// src/naming.ts
+function splitWords(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s_\-./]+/).map((w) => w.trim().toLowerCase()).filter(Boolean);
+}
+function pascalCase(input) {
+  return splitWords(input).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function goVar(input) {
+  const pascal = pascalCase(input);
+  if (!pascal) return "arg";
+  let name = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  name = name.replace(/Id\b/g, "ID").replace(/Url\b/g, "URL").replace(/Api\b/g, "API");
+  if (GO_KEYWORDS.has(name)) name = `${name}_`;
+  return name;
+}
+function slug(input) {
+  return splitWords(input).join("-").replace(/[^a-z0-9-]/g, "");
+}
+function screamingSnakeCase(input) {
+  return splitWords(input).join("_").toUpperCase().replace(/[^A-Z0-9_]/g, "");
+}
+var GO_KEYWORDS = /* @__PURE__ */ new Set([
+  "break",
+  "case",
+  "chan",
+  "const",
+  "continue",
+  "default",
+  "defer",
+  "else",
+  "fallthrough",
+  "for",
+  "func",
+  "go",
+  "goto",
+  "if",
+  "import",
+  "interface",
+  "map",
+  "package",
+  "range",
+  "return",
+  "select",
+  "struct",
+  "switch",
+  "type",
+  "var"
+]);
+
+// src/model.ts
+function fromToken(from, kind) {
+  if (!from) return void 0;
+  const [k, ...rest] = from.split(":");
+  return k === kind ? rest.join(":") : void 0;
+}
+function encodingToGoType(encoding) {
+  switch (encoding) {
+    case "integer":
+      return "int";
+    case "number":
+      return "float";
+    case "boolean":
+      return "bool";
+    case "array":
+      return "slice";
+    case "json":
+      return "json";
+    case "file":
+      return "file";
+    case "string":
+      return "string";
+    default:
+      return void 0;
+  }
+}
+function optionGoType(opt, encoding) {
+  if (!opt.arguments || opt.arguments.length === 0) return "bool";
+  const fromEncoding = encodingToGoType(encoding);
+  if (fromEncoding) return fromEncoding;
+  const arg = opt.arguments[0];
+  if (arg.arity) return "slice";
+  switch (arg.name) {
+    case "integer":
+      return "int";
+    case "number":
+      return "float";
+    case "boolean":
+      return "bool";
+    case "json":
+      return "json";
+    default:
+      return "string";
+  }
+}
+function buildLeafModel(command) {
+  var _a;
+  const x = command["x-openapi"];
+  const params = x.params || [];
+  const body = x.body;
+  const pathArgs = (command.arguments || []).map((arg, idx) => {
+    const param = params.find((p) => p.in === "path" && fromToken(p.from, "argument") === arg.name);
+    return { goVar: goVar(arg.name), wireName: (param == null ? void 0 : param.name) ?? arg.name, idx };
+  });
+  const bodyPropByOption = /* @__PURE__ */ new Map();
+  const bodyWireByOption = /* @__PURE__ */ new Map();
+  for (const prop of (body == null ? void 0 : body.properties) || []) {
+    const flag = fromToken(prop.from, "option");
+    if (flag) {
+      bodyPropByOption.set(flag, prop.encoding || "string");
+      bodyWireByOption.set(flag, prop.name);
+    }
+  }
+  const flags = [];
+  for (const opt of command.options || []) {
+    const paramEntry = params.find((p) => fromToken(p.from, "option") === opt.name && p.in !== "path");
+    let location;
+    let wireName;
+    let encoding;
+    if (paramEntry) {
+      location = paramEntry.in;
+      wireName = paramEntry.name;
+    } else if (bodyPropByOption.has(opt.name)) {
+      location = "body";
+      wireName = bodyWireByOption.get(opt.name) ?? opt.name;
+      encoding = bodyPropByOption.get(opt.name);
+    } else {
+      location = "query";
+      wireName = opt.name;
+    }
+    flags.push({
+      flagName: opt.name,
+      wireName,
+      location,
+      goType: optionGoType(opt, encoding),
+      required: opt.required === true,
+      hidden: opt.hidden === true,
+      aliases: opt.aliases || [],
+      description: opt.description
+    });
+  }
+  const bodyStyle = body == null ? void 0 : body.style;
+  const bodyJsonOption = bodyStyle === "json" ? fromToken(body == null ? void 0 : body.from, "option") ?? ((_a = flags.find((f) => f.location === "body")) == null ? void 0 : _a.flagName) : void 0;
+  const hasBody = !!body && (bodyStyle === "json" || flags.some((f) => f.location === "body"));
+  return {
+    method: (x.method || "get").toUpperCase(),
+    path: x.path,
+    pathArgs,
+    flags,
+    hasBody,
+    bodyStyle,
+    bodyJsonOption
+  };
+}
+
+// src/handler.ts
+var CLI = "github.com/urfave/cli/v3";
+var q = (s) => JSON.stringify(s);
+function readExpr(flagName, t) {
+  switch (t) {
+    case "bool":
+      return `cmd.Bool(${q(flagName)})`;
+    case "int":
+      return `cmd.Int(${q(flagName)})`;
+    case "float":
+      return `cmd.Float(${q(flagName)})`;
+    case "slice":
+      return `cmd.StringSlice(${q(flagName)})`;
+    default:
+      return `cmd.String(${q(flagName)})`;
+  }
+}
+function pathExpr(model, imports) {
+  const segs = model.path.split(/(\{[^}]+\})/).filter((s) => s !== "");
+  const parts = [];
+  let lit2 = "";
+  for (const seg of segs) {
+    const m = seg.match(/^\{(.+)\}$/);
+    if (m) {
+      if (lit2) {
+        parts.push(q(lit2));
+        lit2 = "";
+      }
+      const a = model.pathArgs.find((p) => p.wireName === m[1]);
+      parts.push(`url.PathEscape(${a ? a.goVar : '""'})`);
+      imports.add("net/url");
+    } else {
+      lit2 += seg;
+    }
+  }
+  if (lit2) parts.push(q(lit2));
+  return parts.length ? parts.join(" + ") : '""';
+}
+function renderHandler(pathNames, command, module2, imports) {
+  const model = buildLeafModel(command);
+  const name = `handle${pathNames.map(pascalCase).join("")}`;
+  imports.add("context", CLI, `${module2}/internal/runtime`);
+  const lines = [];
+  const push = (s = "") => lines.push(s);
+  const pe = pathExpr(model, imports);
+  for (const a of model.pathArgs) {
+    if (pe.includes(`url.PathEscape(${a.goVar})`)) push(`${a.goVar} := cmd.Args().Get(${a.idx})`);
+  }
+  push(`path := ${pe}`);
+  const queryFlags = model.flags.filter((f) => f.location === "query");
+  if (queryFlags.length) {
+    imports.add("net/url");
+    push("query := url.Values{}");
+    for (const f of queryFlags) {
+      const read = readExpr(f.flagName, f.goType);
+      let val = read;
+      if (f.goType !== "string") {
+        val = `fmt.Sprint(${read})`;
+        imports.add("fmt");
+      }
+      push(`if cmd.IsSet(${q(f.flagName)}) {`);
+      push(`	query.Set(${q(f.wireName)}, ${val})`);
+      push("}");
+    }
+  }
+  const headerFlags = model.flags.filter((f) => f.location === "header" || f.location === "cookie");
+  if (headerFlags.length) {
+    imports.add("net/http");
+    push("headers := http.Header{}");
+    for (const f of headerFlags) {
+      const read = readExpr(f.flagName, f.goType);
+      let val = read;
+      if (f.goType !== "string") {
+        val = `fmt.Sprint(${read})`;
+        imports.add("fmt");
+      }
+      push(`if cmd.IsSet(${q(f.flagName)}) {`);
+      push(`	headers.Set(${q(f.wireName)}, ${val})`);
+      push("}");
+    }
+  }
+  if (model.hasBody) {
+    imports.add("encoding/json");
+    if (model.bodyStyle === "json" && model.bodyJsonOption) {
+      push("var bodyBytes []byte");
+      push(`if cmd.IsSet(${q(model.bodyJsonOption)}) {`);
+      push(`	bodyBytes = []byte(cmd.String(${q(model.bodyJsonOption)}))`);
+      push("}");
+    } else {
+      push("body := map[string]any{}");
+      for (const f of model.flags.filter((x) => x.location === "body")) {
+        push(`if cmd.IsSet(${q(f.flagName)}) {`);
+        if (f.goType === "json") {
+          push(`	raw := cmd.String(${q(f.flagName)})`);
+          push("	var v any");
+          push("	if err := json.Unmarshal([]byte(raw), &v); err != nil {");
+          push("		v = raw");
+          push("	}");
+          push(`	body[${q(f.wireName)}] = v`);
+        } else {
+          push(`	body[${q(f.wireName)}] = ${readExpr(f.flagName, f.goType)}`);
+        }
+        push("}");
+      }
+      push("bodyBytes, err := json.Marshal(body)");
+      push("if err != nil {");
+      push("	return err");
+      push("}");
+    }
+  }
+  push("req := runtime.Request{");
+  push(`	Method: ${q(model.method)},`);
+  push("	Path: path,");
+  if (queryFlags.length) push("	Query: query,");
+  if (headerFlags.length) push("	Headers: headers,");
+  if (model.hasBody) push("	Body: bodyBytes,");
+  push("}");
+  push("return runtime.Do(ctx, req)");
+  const body = lines.map((l) => `	${l}`).join("\n");
+  const code = `func ${name}(ctx context.Context, cmd *cli.Command) error {
+${body}
+}`;
+  return { name, code };
+}
+
+// src/command.ts
+var CLI2 = "github.com/urfave/cli/v3";
+function renderCommand(command, pathNames, module2, imports, handlers) {
+  var _a, _b;
+  imports.add(CLI2);
+  const fields = [["Name", goStr(command.name)]];
+  if ((_a = command.aliases) == null ? void 0 : _a.length) fields.push(["Aliases", goSlice("string", command.aliases.map(goStr))]);
+  if (command.description) fields.push(["Usage", goStr(command.description)]);
+  if (command.hidden) fields.push(["Hidden", goBool(true)]);
+  if ((_b = command.commands) == null ? void 0 : _b.length) {
+    const subs = command.commands.map(
+      (sub) => renderCommand(sub, [...pathNames, sub.name], module2, imports, handlers)
+    );
+    fields.push(["Commands", goSlice("*cli.Command", subs)]);
+  } else if (command["x-openapi"]) {
+    const flags = renderFlags(buildLeafModel(command).flags);
+    if (flags.length) fields.push(["Flags", goSlice("cli.Flag", flags)]);
+    const handler = renderHandler(pathNames, command, module2, imports);
+    fields.push(["Action", lit(handler.name)]);
+    handlers.push(handler.code);
+  }
+  return goStruct("cli.Command", fields, true);
+}
+function renderResourceFile(topCommand, module2) {
+  const imports = new Imports();
+  const handlers = [];
+  const struct = renderCommand(topCommand, [topCommand.name], module2, imports, handlers);
+  const ctorName = `New${pascalCase(topCommand.name)}Command`;
+  const ctor = `func ${ctorName}() *cli.Command {
+	return ${struct(1)}
+}`;
+  const content = goFile("cmd", imports, [ctor, ...handlers]);
+  const fileBase = splitWords(topCommand.name).join("") || "command";
+  return { path: `pkg/cmd/${fileBase}.go`, content, constructor: ctorName };
+}
+
+// src/main.ts
+var CLI3 = "github.com/urfave/cli/v3";
+function renderMain(spec, binName, module2, constructors) {
+  var _a, _b, _c;
+  const imports = new Imports().add("context", "log", "os", CLI3, `${module2}/pkg/cmd`);
+  const fields = [["Name", goStr(binName)]];
+  const usage = ((_a = spec.info) == null ? void 0 : _a.summary) || ((_b = spec.info) == null ? void 0 : _b.description);
+  if (usage) fields.push(["Usage", goStr(usage)]);
+  if ((_c = spec.info) == null ? void 0 : _c.version) fields.push(["Version", goStr(spec.info.version)]);
+  fields.push(["Commands", goSlice("*cli.Command", constructors.map((c) => lit(`cmd.${c}()`)))]);
+  const app = goStruct("cli.Command", fields, true);
+  const body = `	app := ${app(1)}
+	if err := app.Run(context.Background(), os.Args); err != nil {
+		log.Fatal(err)
+	}`;
+  const fn = `func main() {
+${body}
+}`;
+  return goFile("main", imports, [fn]);
+}
+
+// src/runtime.ts
+function runtimeGo() {
+  return `package runtime
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Request is a generic API request assembled by a generated command handler.
+type Request struct {
+	Method  string
+	Path    string
+	Query   url.Values
+	Headers http.Header
+	Body    []byte
+}
+
+// Do executes the request against the configured base URL (applying auth) and
+// prints the response body to stdout.
+func Do(ctx context.Context, req Request) error {
+	endpoint := strings.TrimRight(BaseURL(), "/") + req.Path
+	if len(req.Query) > 0 {
+		endpoint += "?" + req.Query.Encode()
+	}
+
+	var body io.Reader
+	if len(req.Body) > 0 {
+		body = bytes.NewReader(req.Body)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, endpoint, body)
+	if err != nil {
+		return err
+	}
+	for key, values := range req.Headers {
+		for _, value := range values {
+			httpReq.Header.Add(key, value)
+		}
+	}
+	if len(req.Body) > 0 && httpReq.Header.Get("Content-Type") == "" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+	applyAuth(httpReq)
+
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	out, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(out))
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("request failed: %s", resp.Status)
+	}
+	return nil
+}
+`;
+}
+function authBlock(scheme) {
+  const env = scheme.envVar || "API_KEY";
+  const name = scheme.name || "";
+  switch (scheme.kind) {
+    case "bearer":
+      return `	if v := os.Getenv(${JSON.stringify(env)}); v != "" {
+		req.Header.Set("Authorization", "Bearer "+v)
+	}`;
+    case "apiKey-header":
+      return `	if v := os.Getenv(${JSON.stringify(env)}); v != "" {
+		req.Header.Set(${JSON.stringify(name)}, v)
+	}`;
+    case "apiKey-query":
+      return `	if v := os.Getenv(${JSON.stringify(env)}); v != "" {
+		q := req.URL.Query()
+		q.Set(${JSON.stringify(name)}, v)
+		req.URL.RawQuery = q.Encode()
+	}`;
+    case "apiKey-cookie":
+      return `	if v := os.Getenv(${JSON.stringify(env)}); v != "" {
+		req.AddCookie(&http.Cookie{Name: ${JSON.stringify(name)}, Value: v})
+	}`;
+    case "basic":
+      return `	user := os.Getenv(${JSON.stringify(`${env}_USERNAME`)})
+	pass := os.Getenv(${JSON.stringify(`${env}_PASSWORD`)})
+	if user != "" || pass != "" {
+		req.SetBasicAuth(user, pass)
+	}`;
+    default:
+      return null;
+  }
+}
+function configGo(spec, binName, baseURL) {
+  var _a;
+  const prefix = screamingSnakeCase(binName);
+  const security = ((_a = spec["x-openapi"]) == null ? void 0 : _a.security) || [];
+  const blocks = security.map(authBlock).filter((b) => b !== null);
+  const authBody = blocks.length ? `
+${blocks.join("\n")}
+` : "";
+  return `package runtime
+
+import (
+	"net/http"
+	"os"
+)
+
+const defaultBaseURL = ${JSON.stringify(baseURL)}
+
+// BaseURL returns the API base URL, overridable via ${prefix}_BASE_URL.
+func BaseURL() string {
+	if v := os.Getenv(${JSON.stringify(`${prefix}_BASE_URL`)}); v != "" {
+		return v
+	}
+	return defaultBaseURL
+}
+
+// applyAuth attaches credentials read from the environment to the request.
+func applyAuth(req *http.Request) {${authBody}}
+`;
+}
+
+// src/project.ts
+function opencli2go(spec, options = {}) {
+  var _a, _b, _c;
+  const binName = options.binName ?? (slug(((_a = spec.info) == null ? void 0 : _a.title) || "cli") || "cli");
+  const module2 = options.modulePath ?? `example.com/${binName}`;
+  const goVersion = options.goVersion ?? "1.22";
+  const baseURL = options.baseURL ?? ((_c = (_b = spec["x-openapi"]) == null ? void 0 : _b.servers) == null ? void 0 : _c[0]) ?? "";
+  const files = {};
+  files["go.mod"] = `module ${module2}
+
+go ${goVersion}
+`;
+  const constructors = [];
+  for (const top of spec.commands || []) {
+    const resource = renderResourceFile(top, module2);
+    files[resource.path] = resource.content;
+    constructors.push(resource.constructor);
+  }
+  files[`cmd/${binName}/main.go`] = renderMain(spec, binName, module2, constructors);
+  files["internal/runtime/runtime.go"] = runtimeGo();
+  files["internal/runtime/config.go"] = configGo(spec, binName, baseURL);
+  return files;
+}
+
+// src/write.ts
+async function writeProject(files, outDir) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  for (const [rel, content] of Object.entries(files)) {
+    const full = path.join(outDir, rel);
+    await fs.mkdir(path.dirname(full), { recursive: true });
+    await fs.writeFile(full, content, "utf8");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  opencli2go,
+  writeProject
+});
+//# sourceMappingURL=index.cjs.map