@keq-request/cli 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/index.cjs

@@ -0,0 +1,1855 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileNamingStyle: () => FileNamingStyle,
+  build: () => build,
+  defineKeqConfig: () => defineKeqConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tasks/index.ts
+var import_listr22 = require("listr2");
+
+// src/tasks/setup/index.ts
+var R3 = __toESM(require("ramda"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_value = require("@sinclair/typebox/value");
+var import_cosmiconfig = require("cosmiconfig");
+
+// src/types/runtime-config.ts
+var import_typebox2 = require("@sinclair/typebox");
+
+// src/constants/file-naming-style.ts
+var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
+  FileNamingStyle2["camelCase"] = "camelCase";
+  FileNamingStyle2["capitalCase"] = "capitalCase";
+  FileNamingStyle2["constantCase"] = "constantCase";
+  FileNamingStyle2["dotCase"] = "dotCase";
+  FileNamingStyle2["headerCase"] = "headerCase";
+  FileNamingStyle2["noCase"] = "noCase";
+  FileNamingStyle2["paramCase"] = "paramCase";
+  FileNamingStyle2["pascalCase"] = "pascalCase";
+  FileNamingStyle2["pathCase"] = "pathCase";
+  FileNamingStyle2["sentenceCase"] = "sentenceCase";
+  FileNamingStyle2["snakeCase"] = "snakeCase";
+  return FileNamingStyle2;
+})(FileNamingStyle || {});
+
+// src/types/qs.ts
+var import_typebox = require("@sinclair/typebox");
+
+// src/constants/qs-array-format.ts
+var QsArrayFormat = /* @__PURE__ */ ((QsArrayFormat2) => {
+  QsArrayFormat2["brackets"] = "brackets";
+  QsArrayFormat2["indices"] = "indices";
+  QsArrayFormat2["repeat"] = "repeat";
+  QsArrayFormat2["comma"] = "comma";
+  QsArrayFormat2["space"] = "space";
+  QsArrayFormat2["pipe"] = "pipe";
+  return QsArrayFormat2;
+})(QsArrayFormat || {});
+
+// src/types/qs.ts
+var Qs = import_typebox.Type.Object({
+  indices: import_typebox.Type.Optional(import_typebox.Type.Boolean()),
+  arrayFormat: import_typebox.Type.Optional(import_typebox.Type.Enum(QsArrayFormat)),
+  allowDots: import_typebox.Type.Optional(import_typebox.Type.Boolean())
+});
+
+// src/types/runtime-config.ts
+var RuntimeConfig = import_typebox2.Type.Object({
+  /**
+   * Whether to generate ES Module code
+   *
+   * If not specified, the module system will be inferred from the nearest package.json "type" field
+   * or defaults to "cjs" if no package.json is found.
+   */
+  esm: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: false })),
+  /**
+   * Output directory for generated files
+   */
+  outdir: import_typebox2.Type.String({ default: `${process.cwd()}/api` }),
+  /**
+   * File naming style for generated files
+   */
+  fileNamingStyle: import_typebox2.Type.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
+  modules: import_typebox2.Type.Record(import_typebox2.Type.String(), import_typebox2.Type.String()),
+  operationIdFactory: import_typebox2.Type.Optional(import_typebox2.Type.Function([import_typebox2.Type.Any()], import_typebox2.Type.String())),
+  qs: import_typebox2.Type.Optional(import_typebox2.Type.Union([
+    Qs,
+    import_typebox2.Type.Function([import_typebox2.Type.Any()], Qs)
+  ])),
+  debug: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: false })),
+  /**
+   * Whether to tolerate wrong swagger structure
+   */
+  tolerant: import_typebox2.Type.Optional(import_typebox2.Type.Boolean({ default: false }))
+});
+
+// src/utils/ignore-matcher.ts
+var R = __toESM(require("ramda"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var IgnoreMatcher = class _IgnoreMatcher {
+  rules;
+  constructor(rules) {
+    this.rules = rules;
+  }
+  static async read(filepath) {
+    let content = await import_fs_extra.default.readFile(filepath, "utf-8");
+    content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/#.*$/gm, "").replace(/\n+/g, "\n").trim();
+    let rules = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+      const matched = line.match(/^(!)?\s*([^\s/]+)\s+([^\s/]+)\s+([^\s]+)$/);
+      if (!matched) throw new Error(`Invalid ignore rule: "${line}"`);
+      const [, flag, moduleName, operationMethod, operationPathname] = matched;
+      return {
+        persist: true,
+        ignore: !flag,
+        moduleName,
+        operationMethod: operationMethod.toLowerCase(),
+        operationPathname
+      };
+    });
+    rules = R.sortBy(
+      R.prop("ignore"),
+      rules
+    );
+    rules = R.uniqWith(
+      (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname,
+      rules
+    );
+    return new _IgnoreMatcher(rules);
+  }
+  async write(filepath) {
+    const ruleGroups = R.compose(
+      R.groupBy((rule) => rule.moduleName),
+      R.reverse,
+      R.uniqWith(
+        (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname
+      ),
+      R.filter((rule) => rule.persist)
+    )(this.rules);
+    const content = Object.entries(ruleGroups).sort((a, b) => {
+      const aModuleName = a[0];
+      const bModuleName = b[0];
+      if (aModuleName === "*") return -1;
+      if (bModuleName === "*") return 1;
+      return aModuleName.localeCompare(bModuleName);
+    }).map(([, rules]) => (rules || []).sort((a, b) => {
+      if (a.ignore !== b.ignore) return a.ignore ? -1 : 1;
+      if (a.operationMethod === "*") return -1;
+      if (b.operationMethod === "*") return 1;
+      if (a.operationPathname === "*") return -1;
+      if (b.operationPathname === "*") return 1;
+      if (a.operationMethod !== b.operationMethod) return a.operationMethod.localeCompare(b.operationMethod);
+      if (a.operationPathname !== b.operationPathname) return a.operationPathname.localeCompare(b.operationPathname);
+      return 0;
+    }).map((rule) => `${rule.ignore ? "" : "! "}${rule.moduleName} ${rule.operationMethod.toUpperCase()} ${rule.operationPathname}`).join("\n")).join("\n\n");
+    await import_fs_extra.default.writeFile(filepath, content, "utf-8");
+  }
+  append(rule) {
+    this.rules.unshift(rule);
+  }
+  // if operation is ignored, return true
+  isOperationIgnored(operationDefinition) {
+    const moduleName = operationDefinition.module.name;
+    const operationMethod = operationDefinition.method.toLowerCase();
+    const operationPathname = operationDefinition.pathname;
+    for (const rule of this.rules) {
+      if (rule.moduleName !== "*" && rule.moduleName !== moduleName) continue;
+      if (rule.operationMethod !== "*" && rule.operationMethod !== operationMethod) continue;
+      if (rule.operationPathname !== "*" && rule.operationPathname !== operationPathname) continue;
+      return rule.ignore;
+    }
+    return false;
+  }
+  isModuleIgnored(moduleDefinition) {
+    const moduleName = moduleDefinition.name;
+    for (const rule of this.rules) {
+      if (!rule.ignore) {
+        if (rule.moduleName === "*" || rule.moduleName === moduleName) return false;
+        continue;
+      }
+      if (rule.operationMethod !== "*") continue;
+      if (rule.operationPathname !== "*") continue;
+      if (rule.moduleName === "*" || rule.moduleName === moduleName) return true;
+    }
+    return false;
+  }
+};
+
+// src/tasks/setup/utils/validate-modules.ts
+var R2 = __toESM(require("ramda"), 1);
+var import_validator = __toESM(require("validator"), 1);
+function validateModules(modules) {
+  const keys2 = Object.keys(modules);
+  for (const key of keys2) {
+    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) {
+      throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
+    }
+  }
+  const keysGroupByLowerCase = R2.groupBy(R2.toLower, keys2);
+  for (const groupKey in keysGroupByLowerCase) {
+    const keys3 = keysGroupByLowerCase[groupKey] || [];
+    if (keys3.length > 1) {
+      throw new Error(`Module names ${keys3.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
+    }
+  }
+  for (const key in modules) {
+    const address = modules[key];
+    if (import_validator.default.isURL(address, { require_host: true, require_protocol: true, protocols: ["http", "https"] })) {
+      continue;
+    }
+    if (/^(\/|\.\/|\.\.\/)/.test(address)) {
+      continue;
+    }
+    throw new Error(`Module address "${address}" of module "${key}" is not valid. It must be a URL or a local path.`);
+  }
+}
+
+// src/tasks/setup/utils/find-nearest-package-json.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function findNearestPackageJson(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    const pkgPath = import_node_path.default.join(dir, "package.json");
+    if (import_node_fs.default.existsSync(pkgPath)) {
+      const json = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf8"));
+      return { json, path: pkgPath };
+    }
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/tasks/setup/utils/get-project-module-system.ts
+function getProjectModuleSystem(pkgInfo) {
+  if (!pkgInfo?.json) return "cjs";
+  const { json } = pkgInfo;
+  if (json.type === "module") return "esm";
+  return "cjs";
+}
+
+// src/tasks/setup/index.ts
+var explore = (0, import_cosmiconfig.cosmiconfig)("keq");
+function createSetupTask(options) {
+  return {
+    title: "Setup",
+    task: async (context, task) => {
+      const result = options?.config ? await explore.load(options.config) : await explore.search();
+      if (!result || "isEmpty" in result && result.isEmpty) {
+        throw new Error("Cannot find config file.");
+      }
+      if (!import_value.Value.Check(RuntimeConfig, result.config)) {
+        const errors = [...import_value.Value.Errors(RuntimeConfig, result.config)];
+        const message = errors.map(({ path: path9, message: message2 }) => `${path9}: ${message2}`).join("\n");
+        throw new Error(`Invalid Config: ${message}`);
+      }
+      const rc = import_value.Value.Default(RuntimeConfig, result.config);
+      validateModules(rc.modules);
+      if (options?.debug) {
+        await import_fs_extra2.default.ensureDir(".keq");
+        rc.debug = true;
+      }
+      if (options?.tolerant) {
+        rc.tolerant = true;
+      }
+      const packageJsonInfo = findNearestPackageJson();
+      if (packageJsonInfo) {
+        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
+        rc.esm = moduleSystem === "esm";
+      }
+      let filter2 = new IgnoreMatcher([]);
+      if (result.filepath) {
+        const ignoreFilepath = import_path.default.resolve(import_path.default.dirname(result.filepath), ".keqignore");
+        if (await import_fs_extra2.default.exists(ignoreFilepath)) {
+          filter2 = await IgnoreMatcher.read(ignoreFilepath);
+        }
+      }
+      if (options?.modules && options.modules.length) {
+        const notExistModules = options.modules.filter((moduleName) => !(moduleName in rc.modules));
+        if (notExistModules.length) {
+          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
+        }
+        const ignoredModules = R3.difference(R3.keys(rc.modules), options.modules);
+        for (const moduleName of ignoredModules) {
+          filter2.append({
+            persist: false,
+            ignore: true,
+            moduleName,
+            operationMethod: "*",
+            operationPathname: "*"
+          });
+        }
+      }
+      context.setup = { rc, matcher: filter2 };
+    }
+  };
+}
+
+// src/tasks/download/index.ts
+var import_listr2 = require("listr2");
+
+// src/tasks/utils/module-definition.ts
+var ModuleDefinition = class {
+  name;
+  address;
+  constructor(name, address) {
+    this.name = name;
+    this.address = address;
+  }
+};
+
+// src/tasks/utils/api-document.ts
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var path5 = __toESM(require("path"), 1);
+var yaml = __toESM(require("js-yaml"), 1);
+var validUrl = __toESM(require("valid-url"), 1);
+var import_keq = require("keq");
+var import_openapi_parser = require("@scalar/openapi-parser");
+
+// src/tasks/utils/api-document_v3_1.ts
+var R6 = __toESM(require("ramda"), 1);
+
+// src/constants/supported-methods.ts
+var SupportedMethods = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+
+// src/tasks/utils/operation-definition.ts
+var R5 = __toESM(require("ramda"), 1);
+
+// src/utils/is-keywords.ts
+var keywords = [
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with"
+];
+function isKeywords(str) {
+  return keywords.includes(str);
+}
+
+// src/utils/is-reserved-word.ts
+var reservedWords = [
+  "abstract",
+  "boolean",
+  "byte",
+  "char",
+  "class",
+  "const",
+  "debugger",
+  "double",
+  "enum",
+  "export",
+  "extends",
+  "final",
+  "float",
+  "goto",
+  "implements",
+  "import",
+  "int",
+  "interface",
+  "long",
+  "native",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "short",
+  "static",
+  "super",
+  "synchronized",
+  "throws",
+  "transient",
+  "volatile"
+];
+function isReservedWord(str) {
+  return reservedWords.includes(str);
+}
+
+// src/tasks/utils/operation-definition.ts
+var import_jsonpath_plus2 = require("jsonpath-plus");
+
+// src/tasks/utils/schema-definition.ts
+var R4 = __toESM(require("ramda"), 1);
+var import_jsonpath_plus = require("jsonpath-plus");
+var SchemaDefinition = class _SchemaDefinition {
+  id;
+  name;
+  schema;
+  module;
+  document;
+  constructor(args) {
+    this.module = args.module;
+    this.name = args.name;
+    this.id = args.id;
+    this.schema = args.schema;
+    this.document = args.document;
+  }
+  getDependencies() {
+    const refs = R4.uniq((0, import_jsonpath_plus.JSONPath)({
+      path: "$..*['$ref']",
+      json: this.schema
+    }));
+    return refs.filter((ref) => typeof ref === "string" && !!ref.trim()).map((ref) => {
+      const definition = this.document.dereference(ref);
+      if (definition) return definition;
+      return new _SchemaDefinition({
+        id: ref,
+        name: "unknown",
+        schema: {},
+        module: this.module,
+        document: this.document
+      });
+    });
+  }
+};
+
+// src/tasks/utils/operation-definition.ts
+var OperationDefinition = class {
+  module;
+  operationId;
+  method;
+  pathname;
+  operation;
+  document;
+  constructor(args) {
+    this.module = args.module;
+    this.method = args.method.toLowerCase();
+    this.pathname = args.pathname;
+    this.document = args.document;
+    this.operationId = this.formatOperationId(args.method, args.pathname, args.operation);
+    this.operation = {
+      ...args.operation,
+      operationId: this.operationId
+    };
+  }
+  formatOperationId(method, pathname, operation) {
+    const operationId = operation.operationId;
+    if (operationId && operationId !== "index" && !isKeywords(operationId) && !isReservedWord(operationId)) {
+      return operationId;
+    }
+    return `${method}_${pathname}`.replace(/\//g, "_").replace(/-/g, "_").replace(/:/g, "$$").replace(/{(.+)}/, "$$$1");
+  }
+  getDependencies() {
+    const refs = R5.uniq([
+      ...(0, import_jsonpath_plus2.JSONPath)({
+        path: "$.requestBody.content..schema..$ref",
+        json: this.operation
+      }),
+      ...(0, import_jsonpath_plus2.JSONPath)({
+        path: "$.responses..content..schema..$ref",
+        json: this.operation
+      }),
+      ...(0, import_jsonpath_plus2.JSONPath)({
+        path: "$.parameters..schema..$ref",
+        json: this.operation
+      })
+    ]);
+    const dependencies = refs.filter((ref) => typeof ref === "string" && ref).map((ref) => {
+      const schemaDefinition = this.document.dereference(ref);
+      if (schemaDefinition) return schemaDefinition;
+      return new SchemaDefinition({
+        id: ref,
+        name: "unknown",
+        schema: {},
+        module: this.module,
+        document: this.document
+      });
+    });
+    return dependencies;
+  }
+};
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var logger = {
+  log: (str) => console.log(import_chalk.default.green(str)),
+  warn: (str) => console.warn(import_chalk.default.yellow(str)),
+  error: (str) => console.error(import_chalk.default.red(str))
+};
+
+// src/tasks/utils/api-document_v3_1.ts
+var import_openapi_shaking = __toESM(require("@opendoc/openapi-shaking"), 1);
+var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
+  module;
+  swagger;
+  constructor(swagger, module2) {
+    this.module = module2;
+    this.swagger = swagger;
+  }
+  get schemas() {
+    const module2 = this.module;
+    return Object.entries(this.swagger.components?.schemas || {}).map(([name, schema]) => new SchemaDefinition({
+      id: `#/components/schemas/${name}`,
+      name,
+      schema,
+      module: module2,
+      document: this
+    }));
+  }
+  get operations() {
+    const module2 = this.module;
+    return Object.entries(this.swagger.paths || {}).flatMap(([pathname, pathItem]) => Object.entries(pathItem || {}).filter(([method]) => SupportedMethods.includes(method.toLowerCase())).map(([method, operation]) => new OperationDefinition({
+      method,
+      pathname,
+      operation,
+      module: module2,
+      document: this
+    })));
+  }
+  isEmpty() {
+    return R6.isEmpty(this.swagger.paths);
+  }
+  dereference($ref) {
+    if ($ref.startsWith("#/")) {
+      return this.schemas.find((schema) => schema.id === $ref);
+    }
+    logger.warn(`The $ref(${$ref}) is not defined in ${this.module.name} swagger.`);
+  }
+  isRefDefined($ref) {
+    if ($ref.startsWith("#/")) {
+      const path9 = $ref.replace("#/", "").split("/");
+      return R6.path(path9, this.swagger) !== void 0;
+    }
+    return false;
+  }
+  sharking(filter2) {
+    const isAccepted = (pathname, method, operation) => {
+      if (!SupportedMethods.includes(method)) return false;
+      const operationDefinition = new OperationDefinition({
+        method,
+        pathname,
+        operation,
+        module: this.module,
+        document: this
+      });
+      return filter2(operationDefinition);
+    };
+    const sharkedSwagger = import_openapi_shaking.default.openapiShakingSync(
+      this.swagger,
+      isAccepted,
+      { tolerant: true }
+    );
+    return new _ApiDocumentV3_1(
+      sharkedSwagger,
+      new ModuleDefinition(
+        this.module.name,
+        `file://${this.module.name}.v3_1.sharked.json`
+      )
+    );
+  }
+};
+
+// src/tasks/utils/api-document.ts
+var import_swagger_fix = require("swagger-fix");
+
+// src/utils/debugger.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var Debugger = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  writeSwagger(fullpath, swagger) {
+    if (this.rc?.debug) {
+      void import_fs_extra3.default.writeJSON(fullpath, swagger, { spaces: 2 });
+    }
+  }
+};
+
+// src/utils/swagger-utils/dereference.ts
+function dereference($ref, swagger) {
+  let value;
+  for (const key of $ref.split("/")) {
+    if (key === "#") {
+      value = swagger;
+    } else {
+      value = value[key];
+    }
+    if (!value) break;
+  }
+  return value;
+}
+
+// src/utils/swagger-utils/dereference-operation.ts
+var R9 = __toESM(require("ramda"), 1);
+var import_jsonpointer2 = __toESM(require("jsonpointer"), 1);
+var import_jsonpath_plus4 = require("jsonpath-plus");
+
+// src/utils/swagger-utils/remove-undefined-ref.ts
+var R8 = __toESM(require("ramda"), 1);
+var import_jsonpointer = __toESM(require("jsonpointer"), 1);
+var import_jsonpath_plus3 = require("jsonpath-plus");
+
+// src/utils/swagger-utils/is-ref-defined.ts
+var R7 = __toESM(require("ramda"), 1);
+function isRefDefined($ref, swagger) {
+  if ($ref.startsWith("#/")) {
+    const path9 = $ref.replace("#/", "").split("/");
+    return R7.path(path9, swagger) !== void 0;
+  }
+  return false;
+}
+
+// src/utils/swagger-utils/remove-undefined-ref.ts
+function removeUndefinedRef(swagger) {
+  const shadow = R8.clone(swagger);
+  const matches = (0, import_jsonpath_plus3.JSONPath)({
+    path: "$..*['$ref']^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
+      import_jsonpointer.default.set(shadow, match.pointer, R8.omit(["$ref"], match.value));
+    }
+  }
+  return shadow;
+}
+
+// src/utils/swagger-utils/dereference-operation.ts
+function dereferencePathObject(swagger) {
+  const matches = (0, import_jsonpath_plus4.JSONPath)({
+    path: "$.paths.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = SwaggerUtils.dereference(match.value.$ref, swagger);
+    import_jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceRequestBody(swagger) {
+  const matches = (0, import_jsonpath_plus4.JSONPath)({
+    path: "$.paths.*.*.requestBody.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = SwaggerUtils.dereference(match.value.$ref, swagger);
+    import_jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceResponses(swagger) {
+  const matches = [
+    ...(0, import_jsonpath_plus4.JSONPath)({
+      path: "$.paths.*.*.responses.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    }),
+    ...(0, import_jsonpath_plus4.JSONPath)({
+      path: "$.paths.*.*.responses.*.headers.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    })
+  ];
+  for (const match of matches) {
+    const value = SwaggerUtils.dereference(match.value.$ref, swagger);
+    import_jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceParameters(swagger) {
+  const matches = (0, import_jsonpath_plus4.JSONPath)({
+    path: "$.paths.*.*.parameters.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = SwaggerUtils.dereference(match.value.$ref, swagger);
+    import_jsonpointer2.default.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceOperation(swagger) {
+  const shadow = R9.clone(swagger);
+  dereferencePathObject(shadow);
+  dereferenceRequestBody(shadow);
+  dereferenceResponses(shadow);
+  dereferenceParameters(shadow);
+  return removeUndefinedRef(shadow);
+}
+
+// src/utils/swagger-utils/update-operation-id.ts
+var R10 = __toESM(require("ramda"), 1);
+function updateOperationId(swagger, fn) {
+  const shadow = R10.clone(swagger);
+  for (const [pathname, pathItem] of Object.entries(shadow.paths || {})) {
+    for (const m in pathItem) {
+      const method = m.toLowerCase();
+      if (!SupportedMethods.includes(method)) continue;
+      if (typeof pathItem[m] !== "object" || Array.isArray(pathItem[m]) || pathItem[m] === null) continue;
+      const operation = pathItem[m];
+      const operationId = fn(method, pathname, operation);
+      if (typeof operationId === "string" && operationId.length > 0) {
+        operation.operationId = operationId;
+      }
+    }
+  }
+  return shadow;
+}
+
+// src/utils/json-schema-utils/is-array.ts
+function isArray(schema) {
+  return schema.type === "array";
+}
+
+// src/utils/json-schema-utils/is-mixed.ts
+function isMixed(schema) {
+  return Array.isArray(schema.type);
+}
+
+// src/utils/json-schema-utils/is-non-array.ts
+function isNonArray(schema) {
+  return typeof schema.type === "string" && schema.type !== "array";
+}
+
+// src/utils/json-schema-utils/is-ref.ts
+function isRef(schema) {
+  return "$ref" in schema;
+}
+
+// src/utils/json-schema-utils/index.ts
+var JsonSchemaUtils = class {
+  static isRef = isRef;
+  static isArray = isArray;
+  static isNonArray = isNonArray;
+  static isMixed = isMixed;
+};
+
+// src/utils/swagger-utils/dereference-deep.ts
+function dereferenceDeep($ref, swagger) {
+  const stack = [$ref];
+  let value;
+  while (true) {
+    const last = stack[stack.length - 1];
+    value = dereference(last, swagger);
+    if (JsonSchemaUtils.isRef(value)) {
+      if (!stack.includes(value.$ref)) {
+        stack.push(value.$ref);
+        continue;
+      } else {
+        throw new Error(`Circular reference detected: ${stack.join(" -> ")} -> ${value.$ref}`);
+      }
+    }
+    break;
+  }
+  return value;
+}
+
+// src/utils/swagger-utils/index.ts
+var SwaggerUtils = class {
+  static isRefDefined = isRefDefined;
+  static dereference = dereference;
+  static dereferenceDeep = dereferenceDeep;
+  static removeUndefinedRef = removeUndefinedRef;
+  static dereferenceOperation = dereferenceOperation;
+  static updateOperationId = updateOperationId;
+};
+
+// src/tasks/utils/api-document.ts
+var ApiDocument = class _ApiDocument {
+  module;
+  swagger;
+  constructor(swagger, module2) {
+    this.module = module2;
+    this.swagger = swagger;
+  }
+  static cache = /* @__PURE__ */ new Map();
+  static async download(url) {
+    let content;
+    try {
+      const res = await import_keq.request.get(url).resolveWith("response");
+      if (res.status >= 400) throw new Error(`Request failed with status code ${res.status}`);
+      content = await res.text();
+    } catch (e) {
+      if (e instanceof Error) {
+        e.message = `Unable get the swagger file from ${url}: ${e.message}`;
+      }
+      throw e;
+    }
+    try {
+      return JSON.parse(content);
+    } catch (e) {
+      throw new Error(`The swagger file get from url isn't json: ${url}`);
+    }
+  }
+  static async read(filePath) {
+    const fileExt = path5.extname(filePath);
+    const content = await import_fs_extra4.default.readFile(filePath, "utf8");
+    if ([".yml", ".yaml"].includes(fileExt)) {
+      return yaml.load(content);
+    } else if (fileExt === ".json") {
+      return JSON.parse(content);
+    }
+    throw new Error(`File ${fileExt} not support.`);
+  }
+  static async create(moduleDefinition) {
+    const { address } = moduleDefinition;
+    if (this.cache.has(moduleDefinition.address)) {
+      return this.cache.get(moduleDefinition.address);
+    }
+    const swagger = validUrl.isUri(address) ? await this.download(address) : await this.read(address);
+    return new _ApiDocument(swagger, moduleDefinition);
+  }
+  async validate() {
+    return await (0, import_openapi_parser.validate)(this.swagger);
+  }
+  // remove chinese and special symbols
+  fix() {
+    const swagger = (0, import_swagger_fix.fixSwagger)(this.swagger);
+    return new _ApiDocument(
+      swagger,
+      new ModuleDefinition(
+        this.module.name,
+        `file://${this.module.name}.fixed.json`
+      )
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async toV3_1(rc) {
+    const debug = new Debugger(rc);
+    let swagger = this.swagger;
+    const { specification } = (0, import_openapi_parser.upgrade)(swagger);
+    swagger = specification;
+    debug.writeSwagger(`.keq/${this.module.name}.3_1.json`, swagger);
+    swagger = SwaggerUtils.dereferenceOperation(swagger);
+    debug.writeSwagger(`.keq/${this.module.name}.3_1.sharked.json`, swagger);
+    if (rc?.operationIdFactory) {
+      const operationIdFactory = rc.operationIdFactory;
+      swagger = SwaggerUtils.updateOperationId(
+        swagger,
+        (method, pathname, operation) => operationIdFactory({ method, pathname, operation, module: this.module })
+      );
+      debug.writeSwagger(`.keq/${this.module.name}.3_1.formatted.json`, swagger);
+    }
+    return new ApiDocumentV3_1(
+      swagger,
+      new ModuleDefinition(
+        this.module.name,
+        `file://${this.module.name}.v3_1.json`
+      )
+    );
+  }
+};
+
+// src/tasks/download/index.ts
+function createDownloadTask(options) {
+  return {
+    title: "Download",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => {
+      if (!context.setup) {
+        throw new Error("Please run setup task first.");
+      }
+      const rc = context.setup.rc;
+      const matcher = context.setup.matcher;
+      context.downloaded = {
+        documents: []
+      };
+      return task.newListr(
+        Object.entries(rc.modules).map(([moduleName, address]) => new ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
+          title: moduleDefinition.name,
+          task: async (ctx, task2) => {
+            if (options?.skipIgnoredModules && matcher.isModuleIgnored(moduleDefinition)) {
+              task2.skip(`(${moduleDefinition.name}) is ignored`);
+              return;
+            }
+            task2.output = `Downloaded from ${moduleDefinition.address}`;
+            const document = await ApiDocument.create(moduleDefinition);
+            ctx.downloaded.documents.push(document);
+          }
+        })),
+        {
+          concurrent: true,
+          exitOnError: false,
+          collectErrors: "minimal",
+          rendererOptions: {
+            collapseSubtasks: false,
+            // collapseSkips: false,
+            suffixSkips: true,
+            timer: import_listr2.PRESET_TIMER
+          }
+        }
+      );
+    }
+  };
+}
+
+// src/tasks/validate/index.ts
+function createValidateTask(options) {
+  return {
+    title: "Validate",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      if (!context.downloaded) throw new Error("Please run download task first.");
+      const rc = context.setup.rc;
+      const downloadedDocuments = context.downloaded.documents;
+      const debug = new Debugger(rc);
+      context.validated = {
+        documents: []
+      };
+      return task.newListr(
+        downloadedDocuments.map((document) => ({
+          title: document.module.name,
+          task: async (ctx, task2) => {
+            const { valid, errors } = await document.validate();
+            if (!valid) {
+              const message = `${document.module.name} module swagger file does not conform to the openapi@3.1 standard specifications or have grammatical errors, which may cause unexpected errors: 
+${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
+              task2.output = message;
+            }
+            const fixedDocument = document.fix();
+            debug.writeSwagger(`.keq/${document.module.name}.fixed.json`, fixedDocument.swagger);
+            const v3_1Document = await fixedDocument.toV3_1(rc);
+            ctx.validated.documents.push(v3_1Document);
+          }
+        })),
+        {
+          concurrent: true,
+          rendererOptions: {
+            collapseSubtasks: false,
+            persistentOutput: true
+          }
+        }
+      );
+    }
+  };
+}
+
+// src/tasks/shaking/index.ts
+function createShakingTask(options) {
+  return {
+    title: "Shaking",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      if (!context.validated) throw new Error("Please run validate task first.");
+      const matcher = context.setup.matcher;
+      const documents = context.validated.documents;
+      context.shaken = {
+        documents: []
+      };
+      return task.newListr(
+        documents.map((document) => ({
+          title: document.module.name,
+          task: (ctx, task2) => {
+            if (options?.skipIgnoredModules && matcher.isModuleIgnored(document.module)) {
+              task2.skip(`${document.module.name} module is ignored`);
+              return;
+            }
+            const shakenDocument = document.sharking(
+              (operationDefinition) => !matcher.isOperationIgnored(operationDefinition)
+            );
+            if (options?.skipEmptyDocuments && shakenDocument.isEmpty()) {
+              task2.skip(`${document.module.name} module is empty`);
+              return;
+            }
+            ctx.shaken.documents.push(shakenDocument);
+          }
+        })),
+        {
+          concurrent: true,
+          rendererOptions: {
+            collapseSubtasks: false,
+            suffixSkips: true
+          }
+        }
+      );
+    }
+  };
+}
+
+// src/tasks/persist/index.ts
+var path6 = __toESM(require("path"), 1);
+var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+function createPersistArtifactTask(options) {
+  return {
+    title: "Write files",
+    enabled: options?.persistArtifacts,
+    skip: options?.skip,
+    task: async (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      if (!context.compiled) throw new Error("Please run compile task first.");
+      const rc = context.setup.rc;
+      const artifacts = context.compiled.artifacts;
+      for (const artifact of artifacts) {
+        artifact.changeFileNameCase(rc.fileNamingStyle);
+      }
+      const total = artifacts.length;
+      let completed = 0;
+      await Promise.all(artifacts.map(async (artifact) => {
+        const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
+        await import_fs_extra5.default.ensureFile(realpath);
+        await import_fs_extra5.default.writeFile(realpath, artifact.toCode({ esm: !!rc.esm }));
+        completed += 1;
+        task.output = `Persisted ${completed}/${total} files`;
+      }));
+    }
+  };
+}
+function createPersistIgnoreTask(options) {
+  return {
+    title: "Update .keqignore",
+    enabled: options?.persistIgnore,
+    skip: options?.skip,
+    task: async (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      const matcher = context.setup.matcher;
+      await matcher.write(".keqignore");
+    }
+  };
+}
+function createPersistTask(options) {
+  return {
+    title: "Persist",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        createPersistArtifactTask(options),
+        createPersistIgnoreTask(options)
+      ],
+      {
+        concurrent: true,
+        rendererOptions: {
+          collapseSubtasks: true
+        }
+      }
+    )
+  };
+}
+
+// src/tasks/compile/utils/compile-schema-definition.ts
+var R12 = __toESM(require("ramda"), 1);
+
+// src/renderer/utils/generate-schema.ts
+var R11 = __toESM(require("ramda"), 1);
+function generateComment(schema) {
+  const lines = ["/**"];
+  if (schema.description) {
+    const description = schema.description.replace("*/", "*\\/");
+    lines.push(...description.split("\n").map((line) => ` * ${line}`));
+  }
+  if (schema.deprecated) {
+    lines.push(" * @deprecated");
+  }
+  if (schema.readOnly) {
+    lines.push(" * @readonly");
+  }
+  if (schema.format) {
+    lines.push(` * @format ${schema.format}`);
+  }
+  lines.push(" */");
+  if (lines.length === 2) return "";
+  return lines.join("\n");
+}
+function generateSchema(schema, alias = R11.identity) {
+  if (typeof schema === "boolean") return "unknown";
+  if (JsonSchemaUtils.isRef(schema)) return generateReference(schema, alias);
+  if (JsonSchemaUtils.isMixed(schema)) return generateMixed(schema, alias);
+  if (JsonSchemaUtils.isArray(schema)) return generateArray(schema, alias);
+  if (schema.type === "object") return generateObject(schema, alias);
+  if (schema.enum) return generateEnum(schema, alias);
+  if (schema.oneOf) return generateOneOf(schema, alias);
+  if (schema.anyOf) return generateAnyOf(schema, alias);
+  if (schema.allOf) return generateAllOf(schema, alias);
+  if (schema.type === "string") return generateString(schema, alias);
+  if (schema.type === "number") return generateNumber(schema, alias);
+  if (schema.type === "boolean") return generateBoolean(schema, alias);
+  if (schema.type === "null") return generateNull(schema, alias);
+  if (schema.type === "integer") return generateInteger(schema, alias);
+  return "unknown";
+}
+function generateMixed(schema, alias) {
+  if (Array.isArray(schema.type)) {
+    schema.type.map((type) => ({ ...schema, type })).map((schema2) => generateSchema(schema2, alias)).join(" | ");
+  }
+  return "unknown";
+}
+function generateReference(schema, alias) {
+  if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
+  const parts = schema.$ref.split("/");
+  return alias(parts[parts.length - 1]) || "unknown";
+}
+function generateArray(schema, alias) {
+  if (schema.items && Array.isArray(schema.items)) {
+    const items = schema.items.map((s) => generateSchema(s, alias)).join(", ");
+    return `[${items}]`;
+  }
+  if (schema.items && typeof schema.items === "object") {
+    return `${generateSchema(schema.items, alias)}[]`;
+  }
+  return "any[]";
+}
+function indent(space, text) {
+  const indentation = " ".repeat(space);
+  return text.split("\n").map((line) => `${indentation}${line}`).join("\n");
+}
+function generateObject(schema, alias) {
+  if (!schema.properties || !Object.keys(schema.properties).length) {
+    return "object";
+  }
+  const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
+    let $comment = generateComment(propertySchema);
+    if ($comment) $comment += "\n";
+    const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
+    const $value = generateSchema(propertySchema, alias);
+    return indent(2, `${$comment}${$key}: ${$value}`);
+  });
+  if (schema.additionalProperties) {
+    const $value = schema.additionalProperties === true ? "any" : generateSchema(schema.additionalProperties, alias);
+    $properties.push(indent(2, `[key: string]: ${$value}`));
+  }
+  return [
+    "{",
+    ...$properties,
+    "}"
+  ].join("\n");
+}
+function generateOneOf(schema, alias) {
+  if (!schema.oneOf) return "unknown";
+  return schema.oneOf.map((s) => generateSchema(s, alias)).join(" | ");
+}
+function generateAnyOf(schema, alias) {
+  if (!schema.anyOf) return "unknown";
+  return schema.anyOf.map((s) => generateSchema(s, alias)).join(" | ");
+}
+function generateAllOf(schema, alias) {
+  if (!schema.allOf) return "unknown";
+  return schema.allOf.map((s) => generateSchema(s, alias)).join(" & ");
+}
+function generateEnum(schema, alias) {
+  if (!schema.enum) return "unknown";
+  return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+}
+function generateString(schema, alias) {
+  if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
+  if (schema.format === "binary") return "Blob | Buffer";
+  return "string";
+}
+function generateNumber(schema, alias) {
+  return "number";
+}
+function generateBoolean(schema, alias) {
+  return "boolean";
+}
+function generateNull(schema, alias) {
+  return "null";
+}
+function generateInteger(schema, alias) {
+  return "number";
+}
+
+// src/renderer/json-schema/index.ts
+async function jsonSchemaRenderer(schemaDefinition) {
+  let $comment = generateComment(schemaDefinition.schema);
+  if ($comment) $comment += "\n";
+  if (typeof schemaDefinition.schema === "boolean") {
+    return `${$comment}type ${schemaDefinition.name} = unknown`;
+  }
+  if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
+    return `${$comment}export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`;
+  }
+  return `${$comment}export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`;
+}
+
+// src/tasks/utils/artifact.ts
+var path8 = __toESM(require("path"), 1);
+var changeCase = __toESM(require("change-case"), 1);
+
+// src/tasks/utils/dependency.ts
+var path7 = __toESM(require("path"), 1);
+
+// src/tasks/utils/to-comment.ts
+function toComment(msg) {
+  if (!msg) return "";
+  return msg.split("\n").map((str) => `// ${str}`).join("\n");
+}
+
+// src/tasks/utils/dependency.ts
+var DependencyIdentifier = class {
+  constructor(name, alias) {
+    this.name = name;
+    this.alias = alias;
+  }
+  toCode() {
+    if (this.alias) {
+      return `${this.name} as ${this.alias}`;
+    }
+    return this.name;
+  }
+};
+var Dependency = class {
+  source;
+  identifiers;
+  export;
+  belongTo;
+  constructor(source, identifiers, belongTo, options) {
+    this.source = source;
+    this.identifiers = identifiers.map((i) => typeof i === "string" ? new DependencyIdentifier(i) : i);
+    this.export = !!options?.export;
+    this.belongTo = belongTo;
+  }
+  get realSource() {
+    if (typeof this.source === "string") {
+      if (this.source.startsWith(".")) return path7.relative(this.belongTo.filepath, this.source);
+      return this.source;
+    }
+    return this.source.relativeTo(this.belongTo.dirname);
+  }
+  toCode(options) {
+    const { esm } = options;
+    try {
+      let fullpath = this.realSource;
+      if (fullpath.startsWith(".") && fullpath.endsWith(".ts")) {
+        if (esm) {
+          fullpath = fullpath.replace(/\.ts$/, ".js");
+        } else {
+          fullpath = fullpath.replace(/\.ts$/, "");
+        }
+      }
+      if (this.identifiers.length > 0) {
+        const $identifiers = this.identifiers.map((i) => i.toCode()).join(", ");
+        return `${this.export ? "export" : "import"} { ${$identifiers} } from '${fullpath}'`;
+      }
+      if (this.export) {
+        return `export * from '${fullpath}'`;
+      }
+      return `import '${fullpath}'`;
+    } catch (err) {
+      return toComment(String(err));
+    }
+  }
+};
+
+// src/tasks/utils/artifact.ts
+var HeaderComment = [
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "// Code generated by keq-cli. DO NOT EDIT.",
+  "",
+  ""
+].join("\n");
+var Artifact = class {
+  id;
+  filepath;
+  dependencies = [];
+  warns = [];
+  content;
+  extensionName;
+  constructor(options) {
+    this.id = options.id;
+    this.filepath = options.filepath;
+    this.extensionName = options.extensionName || path8.extname(options.filepath);
+    this.content = options.content;
+    if (options.dependencies) this.dependencies = options.dependencies;
+  }
+  get dirname() {
+    return path8.dirname(this.filepath);
+  }
+  changeFileNameCase(style) {
+    this.filepath = this.filepath.split("/").map((part, index, arr) => {
+      if (part === "." || part === "..") return part;
+      if (index !== arr.length - 1) {
+        return `${changeCase[style](part)}`;
+      }
+      const baesname = path8.basename(part, this.extensionName);
+      return `${changeCase[style](baesname)}${this.extensionName}`;
+    }).join("/");
+    return this;
+  }
+  relativeTo(filepath) {
+    const relativePath = path8.relative(filepath, this.filepath);
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  }
+  addDependence(source, identifiers, options) {
+    const dependence = new Dependency(
+      source,
+      identifiers,
+      this,
+      options
+    );
+    this.dependencies.push(dependence);
+    return dependence;
+  }
+  addWarn(message) {
+    this.warns.push(message);
+  }
+  toCode(options) {
+    let $dependencies = this.dependencies.map((dependency) => dependency.toCode(options)).filter((line) => line.trim() !== "").join("\n");
+    if ($dependencies) {
+      $dependencies += "\n\n";
+    }
+    let $warns = "";
+    if (this.warns.length) {
+      $warns = toComment([
+        "!!! Here is some Problems !!!",
+        "",
+        this.warns
+      ].join("\n"));
+      $warns += "\n\n";
+    }
+    return `${HeaderComment}${$warns}${$dependencies}${this.content}`;
+  }
+};
+
+// src/tasks/compile/utils/compile-schema-definition.ts
+function genSchemaDefinitionFilepath(schemaDefinition) {
+  const filename = `${schemaDefinition.name}.schema.ts`;
+  return [
+    ".",
+    schemaDefinition.module.name,
+    "components",
+    "schemas",
+    filename
+  ].join("/");
+}
+function genEntrypointFilepath(moduleName) {
+  return [
+    ".",
+    moduleName,
+    "components",
+    "schemas",
+    "index.ts"
+  ].join("/");
+}
+var isArtifactCompiledBy = function(schemaDefinition) {
+  return (artifact) => artifact.id === genSchemaDefinitionFilepath(schemaDefinition);
+};
+async function compileSchemaDefinition(options) {
+  const { schemaDefinitions } = options;
+  const artifacts = await Promise.all(
+    schemaDefinitions.map(async (schemaDefinition) => {
+      const content = await jsonSchemaRenderer(schemaDefinition);
+      const filepath = genSchemaDefinitionFilepath(schemaDefinition);
+      return new Artifact({
+        id: filepath,
+        filepath,
+        content,
+        extensionName: ".schema.ts"
+      });
+    })
+  );
+  for (const schemaDefinition of schemaDefinitions) {
+    const artifact = artifacts.find(isArtifactCompiledBy(schemaDefinition));
+    if (!artifact) continue;
+    const dependentSchemaDefinitions = schemaDefinition.getDependencies();
+    for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
+      const dependentArtifact = artifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
+      if (!dependentArtifact) {
+        artifact.addWarn(`Cannot find dependent $ref: ${dependentSchemaDefinition.id}`);
+        continue;
+      }
+      artifact.addDependence(dependentArtifact, [dependentSchemaDefinition.name]);
+    }
+  }
+  const schemaDefinitionsGroupByModuleName = R12.groupBy(
+    (schemaDefinition) => schemaDefinition.module.name,
+    schemaDefinitions
+  );
+  const entrypointArtifacts = Object.entries(schemaDefinitionsGroupByModuleName).map(([moduleName, schemaDefinitions2]) => {
+    const filepath = genEntrypointFilepath(moduleName);
+    const artifact = new Artifact({
+      id: filepath,
+      filepath,
+      content: ""
+    });
+    for (const schemaDefinition of schemaDefinitions2 || []) {
+      const dependentArtifact = artifacts.find(isArtifactCompiledBy(schemaDefinition));
+      if (!dependentArtifact) {
+        artifact.addWarn(`Cannot find dependent $ref: ${schemaDefinition.id}`);
+        continue;
+      }
+      artifact.addDependence(dependentArtifact, [], { export: true });
+    }
+    return artifact;
+  });
+  return [...artifacts, ...entrypointArtifacts];
+}
+
+// src/tasks/compile/utils/compile-operation-definition.ts
+var R15 = __toESM(require("ramda"), 1);
+
+// src/renderer/operation-type/index.ts
+var R13 = __toESM(require("ramda"), 1);
+var changeCase2 = __toESM(require("change-case"), 1);
+function typeNameFactory(operationDefinition) {
+  const pascalCaseOperationId = changeCase2.pascalCase(operationDefinition.operationId);
+  return (name) => `${pascalCaseOperationId}${name}`;
+}
+async function operationTypeRenderer(operationDefinition, alias = R13.identity) {
+  const { operation } = operationDefinition;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
+    if (!JsonSchemaUtils.isRef(response)) {
+      const $value = Object.values(response.content || {}).map((mediaTypeObject) => mediaTypeObject.schema).filter((schema) => !!schema).map((schema) => generateSchema(schema, alias)).join(" | ");
+      return indent(2, `${statusCode}: ${$value || "void"}`);
+    }
+  }).join("\n");
+  let $requestBody = `export type ${typeName("RequestBody")} = {}`;
+  if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
+    const $value = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).filter(([, schema]) => !!schema).map(([mediaType, schema]) => {
+      if (mediaType === "multipart/form-data") {
+        return `FormData | ${generateSchema(schema, alias)}`;
+      } else if (mediaType === "application/x-www-form-urlencoded") {
+        return `URLSearchParams | ${generateSchema(schema, alias)}`;
+      }
+      return generateSchema(schema, alias);
+    }).join(" | ");
+    $requestBody = `export type ${typeName("RequestBody")} = ${$value || "unknown"}`;
+  }
+  return [
+    `export interface ${typeName("ResponseBodies")} {`,
+    $responses,
+    "}",
+    "",
+    generateParameters(`${typeName("RequestQuery")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [], alias),
+    "",
+    generateParameters(`${typeName("RouteParameters")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "path") || [], alias),
+    "",
+    generateParameters(`${typeName("RequestHeaders")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [], alias),
+    "",
+    $requestBody,
+    "",
+    `export type ${typeName("RequestParameters")} = ${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")} & ${typeName("RequestBody")}`,
+    "",
+    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}> extends KeqOperation {`,
+    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqParamValue }`,
+    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryValue }`,
+    `  requestHeaders: ${typeName("RequestHeaders")} & { [key: string]: string | number }`,
+    `  requestBody: ${typeName("RequestBody")}`,
+    `  responseBody: ${typeName("ResponseBodies")}[STATUS]`,
+    "}"
+  ].join("\n");
+}
+function generateParameters(name, parameters, alias) {
+  if (parameters.length === 0) {
+    return `export type ${name} = {}`;
+  }
+  const $parameters = parameters.map((parameter) => {
+    const parameterName = `"${parameter.name}"`;
+    const $key = parameter.required ? parameterName : `${parameterName}?`;
+    const $value = generateSchema(parameter.schema || { type: "any" }, alias);
+    return indent(2, `${$key}: ${$value}`);
+  }).join("\n");
+  return [
+    `export type ${name} = {`,
+    $parameters,
+    "}"
+  ].filter(Boolean).join("\n");
+}
+
+// src/renderer/operation-request/index.ts
+var R14 = __toESM(require("ramda"), 1);
+function errorToComment(err, mediaType) {
+  const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
+  return [
+    "/**",
+    ` * Unable to dereference schema for media type ${mediaType}`,
+    $err,
+    " */"
+  ].join("\n");
+}
+async function operationRequestRenderer(operationDefinition, options) {
+  const { operation, operationId, method, pathname } = operationDefinition;
+  const { qs } = options;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const moduleName = operationDefinition.module.name;
+  const parameters = operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p)) || [];
+  const queryParameters = parameters.filter((p) => p.in === "query");
+  const headersParameters = parameters.filter((p) => p.in === "header");
+  const pathParameters = parameters.filter((p) => p.in === "path");
+  const $queryParameters = queryParameters.map((p) => {
+    const option = qs(p);
+    const $option = !option || R14.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
+    return `  if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
+  }).concat("").join("\n");
+  const $headerParameters = headersParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+  const $pathParameters = pathParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+  const requestBodyContent = operation.requestBody?.content || {};
+  const $requestBody = Object.entries(requestBodyContent).map(([mediaType, mediaTypeObject]) => {
+    if (!mediaTypeObject.schema) return;
+    try {
+      const schema = JsonSchemaUtils.isRef(mediaTypeObject.schema) ? SwaggerUtils.dereferenceDeep(mediaTypeObject.schema.$ref, operationDefinition.document.swagger) : mediaTypeObject.schema;
+      if (schema.type !== "object") return;
+      const properties = schema.properties || {};
+      return Object.entries(properties).map(([propertyName, propertySchema]) => {
+        const $propertyName = JSON.stringify(propertyName);
+        if (mediaType === "application/json") {
+          return `  if (args && ${$propertyName} in args) req.send({ ${$propertyName}: args[${$propertyName}] })`;
+        } else if (mediaType === "multipart/form-data") {
+          try {
+            const schema2 = JsonSchemaUtils.isRef(propertySchema) ? SwaggerUtils.dereferenceDeep(propertySchema.$ref, operationDefinition.document.swagger) : propertySchema;
+            if (schema2.type === "string" && schema2.format === "binary" || schema2.contentMediaType === "application/octet-stream") {
+              return `  if (args && ${$propertyName} in args && args[${$propertyName}]) req.attach(${$propertyName}, args[${$propertyName}])`;
+            }
+            return `  if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, args[${$propertyName}])`;
+          } catch (err) {
+            return indent(2, errorToComment(err, mediaType));
+          }
+        } else {
+          throw new Error(`Unsupported media type: ${mediaType}`);
+        }
+      }).join("\n");
+    } catch (err) {
+      return indent(2, errorToComment(err, mediaType));
+    }
+  }).filter(R14.isNotNil).join("\n");
+  return [
+    `const moduleName = "${moduleName}"`,
+    `const method = "${method}"`,
+    `const pathname = "${pathname}"`,
+    "",
+    `export function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS>> {`,
+    `  const req = request.post<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
+    "    .option('module', { name: moduleName, pathname, method })",
+    "",
+    $queryParameters || void 0,
+    $headerParameters || void 0,
+    $pathParameters || void 0,
+    $requestBody ? `${$requestBody}
+` : void 0,
+    "  return req",
+    "}",
+    "",
+    `${operationId}.pathname = pathname`,
+    `${operationId}.method = method`
+  ].filter(R14.isNotNil).join("\n");
+}
+
+// src/tasks/compile/utils/compile-operation-definition.ts
+function genOperationTypeFilepath(operationDefinition) {
+  const filename = `${operationDefinition.operationId}.type.ts`;
+  return [
+    ".",
+    operationDefinition.module.name,
+    "types",
+    filename
+  ].join("/");
+}
+function genOperationRequestFilepath(operationDefinition) {
+  const filename = `${operationDefinition.operationId}.request.ts`;
+  return [
+    ".",
+    operationDefinition.module.name,
+    "operations",
+    filename
+  ].join("/");
+}
+function genEntrypointFilepath2(moduleName) {
+  return [
+    ".",
+    moduleName,
+    "operations",
+    "index.ts"
+  ].join("/");
+}
+async function compileOperationDefinition(options) {
+  const { rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
+  const alias = (name) => `${name}Schema`;
+  const qs = (parameter) => {
+    if (typeof rc.qs === "function") {
+      return rc.qs(parameter);
+    } else if (typeof rc.qs === "object") {
+      return rc.qs;
+    }
+    const style = parameter.style || "form";
+    const explode = parameter.explode ?? true;
+    if (style === "deepObject") {
+      return { arrayFormat: "brackets" };
+    } else if (explode) {
+      return { arrayFormat: "repeat" };
+    } else {
+      if (style === "form") {
+        return { arrayFormat: "comma" };
+      } else if (style === "spaceDelimited") {
+        return { arrayFormat: "space" };
+      } else if (style === "pipeDelimited") {
+        return { arrayFormat: "pipe" };
+      }
+    }
+    return {};
+  };
+  async function createTypeArtifact(operationDefinition) {
+    const content = await operationTypeRenderer(operationDefinition, alias);
+    const filepath = genOperationTypeFilepath(operationDefinition);
+    const typeArtifact = new Artifact({
+      id: filepath,
+      filepath,
+      content,
+      extensionName: ".type.ts"
+    });
+    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryValue", "KeqParamValue"]);
+    const dependentSchemaDefinitions = operationDefinition.getDependencies();
+    for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
+      const dependentArtifact = schemaArtifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
+      if (!dependentArtifact) {
+        typeArtifact.addWarn(`Cannot find dependent $ref: ${dependentSchemaDefinition.id}`);
+        continue;
+      }
+      typeArtifact.addDependence(dependentArtifact, [
+        new DependencyIdentifier(dependentSchemaDefinition.name, alias(dependentSchemaDefinition.name))
+      ]);
+    }
+    return typeArtifact;
+  }
+  async function createRequestArtifact(operationDefinition, typeArtifact) {
+    const typeName = typeNameFactory(operationDefinition);
+    const content = await operationRequestRenderer(operationDefinition, { qs });
+    const filepath = genOperationRequestFilepath(operationDefinition);
+    const artifact = new Artifact({
+      id: filepath,
+      filepath,
+      content,
+      extensionName: ".request.ts"
+    });
+    artifact.addDependence("keq", ["Keq"]);
+    artifact.addDependence(requestArtifact, ["request"]);
+    artifact.addDependence(
+      typeArtifact,
+      [
+        "Operation",
+        typeName("ResponseBodies"),
+        typeName("RequestParameters")
+      ]
+    );
+    artifact.addDependence(
+      typeArtifact,
+      [
+        `${typeName("RequestQuery")}`,
+        `${typeName("RequestHeaders")}`,
+        `${typeName("RequestBody")}`
+      ],
+      { export: true }
+    );
+    return artifact;
+  }
+  const artifacts = R15.unnest(
+    await Promise.all(
+      operationDefinitions.map(async (operationDefinition) => {
+        const typeArtifact = await createTypeArtifact(operationDefinition);
+        const operationArtifact = await createRequestArtifact(operationDefinition, typeArtifact);
+        return [typeArtifact, operationArtifact];
+      })
+    )
+  );
+  const operationDefinitionsGroupByModuleName = R15.groupBy(
+    (operationDefinition) => operationDefinition.module.name,
+    operationDefinitions
+  );
+  const entrypointArtifacts = Object.entries(operationDefinitionsGroupByModuleName).map(([moduleName, operationDefinitions2]) => {
+    const filepath = genEntrypointFilepath2(moduleName);
+    const artifact = new Artifact({
+      id: filepath,
+      filepath,
+      content: ""
+    });
+    for (const operationDefinition of operationDefinitions2 || []) {
+      const dependentArtifact = artifacts.find((artifact2) => artifact2.filepath === genOperationRequestFilepath(operationDefinition));
+      if (!dependentArtifact) {
+        artifact.addWarn(`Cannot find operation: operation = ${operationDefinition.operationId}, pathname = ${operationDefinition.pathname}, method = ${operationDefinition.method}`);
+        continue;
+      }
+      artifact.addDependence(dependentArtifact, [], { export: true });
+    }
+    return artifact;
+  });
+  return [...artifacts, ...entrypointArtifacts];
+}
+
+// src/renderer/request/index.ts
+async function requestRenderer() {
+  return [
+    "import { KeqRequest } from 'keq'",
+    "export const request = new KeqRequest()"
+  ].join("\n");
+}
+
+// src/tasks/compile/index.ts
+function createCompileTask(options) {
+  return {
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: async (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      if (!context.shaken) throw new Error("Please run shaking task first.");
+      const rc = context.setup.rc;
+      const matcher = context.setup.matcher;
+      const documents = context.shaken.documents.filter((document) => !matcher.isModuleIgnored(document.module));
+      const requestArtifact = new Artifact({
+        id: "request",
+        filepath: "request",
+        content: await requestRenderer(),
+        extensionName: ".ts"
+      });
+      const schemaDefinitions = documents.flatMap((document) => document.schemas);
+      const operationDefinitions = documents.flatMap((document) => document.operations);
+      const schemaArtifacts = await compileSchemaDefinition({ schemaDefinitions });
+      const operationArtifacts = await compileOperationDefinition({ rc, operationDefinitions, schemaArtifacts, requestArtifact });
+      const artifacts = [requestArtifact, ...schemaArtifacts, ...operationArtifacts];
+      context.compiled = {
+        artifacts
+      };
+    }
+  };
+}
+
+// src/tasks/interactive/utils/select-operation-definitions.ts
+var import_inquirer_select_pro = require("inquirer-select-pro");
+var import_prompt_adapter_inquirer = require("@listr2/prompt-adapter-inquirer");
+async function selectOperationDefinitions(task, operationDefinitions) {
+  const selectedOperationDefinitions = await task.prompt(import_prompt_adapter_inquirer.ListrInquirerPromptAdapter).run(
+    import_inquirer_select_pro.select,
+    {
+      message: "Select Pathname",
+      defaultValue: [],
+      options: (input) => {
+        const items = operationDefinitions.map((op) => ({ name: `${op.module.name} ${op.method.toUpperCase()} ${op.pathname}`, value: op }));
+        if (!input) return items;
+        const keys2 = input.trim().toLowerCase().split(/\s+/);
+        return items.filter((i) => {
+          const name = i.name.toLowerCase();
+          return keys2.every((q) => name.includes(q));
+        });
+      }
+    }
+  );
+  return selectedOperationDefinitions;
+}
+
+// src/tasks/interactive/index.ts
+function createInteractiveTask(options) {
+  return {
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: async (context, task) => {
+      if (!context.setup) throw new Error("Please run setup task first.");
+      if (!context.validated) throw new Error("Please run validate task first.");
+      const matcher = context.setup.matcher;
+      const documents = context.validated.documents;
+      const operationDefinitions = documents.flatMap((document) => document.operations);
+      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
+      if (options.override) {
+        matcher.append({
+          persist: false,
+          ignore: true,
+          moduleName: "*",
+          operationMethod: "*",
+          operationPathname: "*"
+        });
+      }
+      for (const op of selectedOperationDefinitions) {
+        matcher.append({
+          persist: true,
+          ignore: options.mode === "add",
+          moduleName: op.module.name,
+          operationMethod: op.method,
+          operationPathname: op.pathname
+        });
+      }
+    }
+  };
+}
+
+// src/tasks/index.ts
+async function build(options) {
+  const tasks = new import_listr22.Listr(
+    [
+      createSetupTask(options),
+      createDownloadTask({ skipIgnoredModules: !options.interactive }),
+      createValidateTask(),
+      createInteractiveTask({ mode: "except", override: true, enabled: !!options.interactive }),
+      createShakingTask({ skipIgnoredModules: true, skipEmptyDocuments: true }),
+      createCompileTask(),
+      createPersistTask({ persistIgnore: false })
+    ],
+    {
+      concurrent: false,
+      renderer: "default",
+      rendererOptions: {
+        suffixSkips: true,
+        collapseSubtasks: false,
+        collapseErrors: false
+      }
+    }
+  );
+  await tasks.run({});
+}
+
+// src/define-keq-config.ts
+function defineKeqConfig(config) {
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileNamingStyle,
+  build,
+  defineKeqConfig
+});
+//# sourceMappingURL=index.cjs.map