@keq-request/cli 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/index.js

@@ -1,11 +1,8 @@
-// src/define-keq-config.ts
-function defineKeqConfig(config) {
+// src/define-config.ts
+function defineConfig(config) {
   return config;
 }
 
-// src/types/runtime-config.ts
-import { Type } from "@sinclair/typebox";
-
 // src/constants/file-naming-style.ts
 var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
   FileNamingStyle2["camelCase"] = "camelCase";
@@ -22,39 +19,6 @@ var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
   return FileNamingStyle2;
 })(FileNamingStyle || {});
 
-// src/types/runtime-config.ts
-var RuntimeConfig = Type.Object({
-  mode: Type.Optional(
-    Type.Union([
-      Type.Literal("micro-function"),
-      Type.Literal("nestjs-module"),
-      Type.Literal("none")
-    ], { default: "micro-function" })
-  ),
-  /**
-   * 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: Type.Optional(Type.Boolean({ default: false })),
-  /**
-   * Output directory for generated files
-   */
-  outdir: Type.String({ default: `${process.cwd()}/api` }),
-  /**
-   * File naming style for generated files
-   */
-  fileNamingStyle: Type.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
-  modules: Type.Record(Type.String(), Type.String()),
-  debug: Type.Optional(Type.Boolean({ default: false })),
-  /**
-   * Whether to tolerate wrong openapi/swagger structure
-   */
-  tolerant: Type.Optional(Type.Boolean({ default: false })),
-  plugins: Type.Optional(Type.Array(Type.Any(), { default: [] }))
-});
-
 // src/constants/qs-array-format.ts
 var QsArrayFormat = /* @__PURE__ */ ((QsArrayFormat2) => {
   QsArrayFormat2["brackets"] = "brackets";
@@ -82,9 +46,8 @@ import { Listr } from "listr2";
 import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable";
 
 // src/compiler/tasks/setup/index.ts
-import fs3 from "fs-extra";
-import path2 from "path";
-import { Value } from "@sinclair/typebox/value";
+import fs4 from "fs-extra";
+import path10 from "path";
 import { cosmiconfig } from "cosmiconfig";
 
 // src/utils/ignore-matcher.ts
@@ -178,35 +141,6 @@ var IgnoreMatcher = class _IgnoreMatcher {
   }
 };
 
-// src/compiler/tasks/setup/utils/validate-modules.ts
-import * as R2 from "ramda";
-import validator from "validator";
-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 (validator.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/compiler/tasks/setup/utils/find-nearest-package-json.ts
 import fs2 from "fs";
 import path from "path";
@@ -233,80 +167,193 @@ function getProjectModuleSystem(pkgInfo) {
   return "cjs";
 }
 
-// src/compiler/tasks/setup/index.ts
-var explore = cosmiconfig("keq");
-function main(compiler, options) {
-  return {
-    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 (!Value.Check(RuntimeConfig, result.config)) {
-        const errors = [...Value.Errors(RuntimeConfig, result.config)];
-        const message = errors.map(({ path: path13, message: message2 }) => `${path13}: ${message2}`).join("\n");
-        throw new Error(`Invalid Config: ${message}`);
-      }
-      const rc = Value.Default(RuntimeConfig, result.config);
-      validateModules(rc.modules);
-      if (options?.debug) {
-        await fs3.ensureDir(".keq");
-        rc.debug = true;
-      }
-      rc.tolerant = Boolean(rc.tolerant);
-      const packageJsonInfo = findNearestPackageJson();
-      if (packageJsonInfo) {
-        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
-        rc.esm = moduleSystem === "esm";
-      }
-      context.rc = rc;
-      let matcher = new IgnoreMatcher([]);
-      if (result.filepath) {
-        const ignoreFilepath = path2.resolve(path2.dirname(result.filepath), ".keqignore");
-        if (await fs3.exists(ignoreFilepath)) {
-          matcher = await IgnoreMatcher.read(ignoreFilepath);
-        }
-      }
-      const ignoreRules = options.ignore === false ? [] : options.ignore?.rules || [];
-      for (const rule of ignoreRules) {
-        matcher.append({
-          persist: !!rule.persist,
-          ignore: rule.ignore,
-          moduleName: rule.moduleName,
-          operationMethod: rule.operationMethod,
-          operationPathname: rule.operationPathname
-        });
-      }
-      context.matcher = matcher;
-      await compiler.hooks.setup.promise(task);
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+import { Value } from "@sinclair/typebox/value";
+
+// src/types/address.ts
+import { Type } from "@sinclair/typebox";
+var Address = Type.Object({
+  url: Type.String(),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String(), { default: {} })),
+  encoding: Type.Optional(
+    Type.Union([
+      Type.Literal("utf8"),
+      Type.Literal("ascii")
+    ], { default: "utf8" })
+  )
+});
+
+// src/types/runtime-config.ts
+import * as R2 from "ramda";
+import { Type as Type2 } from "@sinclair/typebox";
+
+// src/utils/is-valid-url.ts
+var URL_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^\s@]+@)?[^\s/:?#]*(?::\d+)?(?:\/[^\s?#]*)?(?:\?[^\s#]*)?(?:#[^\s]*)?$/;
+function isValidURL(url) {
+  return URL_REGEX.test(url);
+}
+
+// src/types/runtime-config.ts
+var Modules = Type2.Transform(
+  Type2.Record(
+    Type2.String(),
+    Type2.Union([Type2.String(), Address])
+  )
+).Decode((value) => {
+  const keys2 = Object.keys(value);
+  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 value) {
+    const url = typeof value[key] === "string" ? value[key] : value[key].url;
+    if (isValidURL(url)) continue;
+    throw new Error(`The ${JSON.stringify(url)} of module "${key}" is not a valid URL.`);
+  }
+  return R2.map(
+    (item) => typeof item !== "string" ? item : { url: item, headers: {}, encoding: "utf8" },
+    value
+  );
+}).Encode((value) => value);
+var RawConfig = Type2.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: Type2.Optional(Type2.Boolean({ default: false })),
+  /**
+   * Output directory for generated files
+   */
+  outdir: Type2.String({ default: `${process.cwd()}/api` }),
+  /**
+   * File naming style for generated files
+   */
+  fileNamingStyle: Type2.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
+  /**
+   * OpenAPI/Swagger document sources
+   *
+   * A map of module names to their document URLs or Address objects.
+   * The module name must be a valid JavaScript identifier.
+   */
+  modules: Modules,
+  /**
+   * Enable debug mode to output detailed logs during compilation
+   */
+  debug: Type2.Optional(Type2.Boolean({ default: false })),
+  /**
+   * Whether to tolerate wrong openapi/swagger structure
+   */
+  tolerant: Type2.Optional(Type2.Boolean({ default: false })),
+  /**
+   * Translators to transform generated code
+   *
+   * Used to customize the code generation process for different frameworks or patterns.
+   * Can be a single translator or an array of translators.
+   */
+  translators: Type2.Optional(
+    Type2.Transform(
+      Type2.Union([
+        Type2.Unsafe(Type2.Any()),
+        Type2.Array(Type2.Unsafe(Type2.Any()))
+      ], { default: [] })
+    ).Decode((value) => {
+      if (value === void 0) return [];
+      if (Array.isArray(value)) return value;
+      return [value];
+    }).Encode((value) => value)
+  ),
+  /**
+   * Plugins to extend code generation functionality
+   *
+   * An array of plugin instances that can hook into various stages of the compilation process,
+   * such as code transformation, formatting, linting, or custom file generation.
+   */
+  plugins: Type2.Optional(Type2.Array(Type2.Unsafe(Type2.Any()), { default: [] }))
+});
+
+// src/compiler/tasks/setup/utils/parse-runtime-config.ts
+function parseRuntimeConfig(data) {
+  try {
+    const originalPlugins = typeof data === "object" && data !== null && "plugins" in data ? data.plugins : void 0;
+    const originTranslators = typeof data === "object" && data !== null && "translators" in data ? data.translators : void 0;
+    const parsed = Value.Parse(RawConfig, data);
+    if (originalPlugins !== void 0) {
+      parsed.plugins = originalPlugins;
+    }
+    if (originTranslators !== void 0) {
+      parsed.translators = originTranslators;
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      error.message = `Invalid Config: ${error.message}`;
+    }
+    throw error;
+  }
 }
-function createSetupTask(compiler, options) {
-  return {
-    title: "Setup",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main(compiler, options),
-        {
-          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
+
+// src/plugins/eslint/eslint.plugin.ts
+import { ESLint } from "eslint";
+
+// src/plugins/prettier/prettier.plugin.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+// src/plugins/body-fallback/index.ts
+import * as R21 from "ramda";
+
+// src/utils/json-schema-utils/is-array.ts
+function isArray(schema) {
+  return schema.type === "array";
 }
 
-// src/compiler/tasks/download/index.ts
-import { PRESET_TIMER } from "listr2";
-import { validate } from "@scalar/openapi-parser";
+// 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/plugins/generate-micro-function/generate-micro-function.plugin.ts
+import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook2 } from "tapable";
+
+// src/plugins/generate-micro-function/constants/metadata-storage.ts
+var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
+import * as R20 from "ramda";
+import * as path8 from "path";
+import * as changeCase6 from "change-case";
 
 // src/models/artifact.ts
-import * as path3 from "path";
+import * as path2 from "path";
 
 // src/models/anchor.ts
 var AnchorBlock = class {
@@ -392,11 +439,11 @@ var Artifact = class {
   constructor(options) {
     this.id = options.id;
     this.filepath = options.filepath;
-    this.extensionName = options.extensionName || path3.extname(options.filepath);
+    this.extensionName = options.extensionName || path2.extname(options.filepath);
     this.content = options.content;
   }
   get dirname() {
-    return path3.dirname(this.filepath);
+    return path2.dirname(this.filepath);
   }
   renderer() {
     return `${HeaderComment}${this.content}`;
@@ -412,10 +459,14 @@ var ModuleDefinition = class _ModuleDefinition {
   address;
   constructor(name, address) {
     this.name = name;
-    this.address = address;
+    if (typeof address === "string") {
+      this.address = { url: address, headers: {}, encoding: "utf8" };
+    } else {
+      this.address = address;
+    }
   }
   static unknown() {
-    return new _ModuleDefinition("", "");
+    return new _ModuleDefinition("", { url: "", headers: {}, encoding: "utf8" });
   }
 };
 
@@ -635,8 +686,8 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   }
   isRefDefined($ref) {
     if ($ref.startsWith("#/")) {
-      const path13 = $ref.replace("#/", "").split("/");
-      return R5.path(path13, this.specification) !== void 0;
+      const path12 = $ref.replace("#/", "").split("/");
+      return R5.path(path12, this.specification) !== void 0;
     }
     return false;
   }
@@ -648,532 +699,22 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
 // src/models/asset.ts
 var Asset = class {
   path;
-  constructor(path13) {
-    this.path = path13;
+  constructor(path12) {
+    this.path = path12;
   }
 };
 
-// src/exception.ts
-import { CustomError } from "ts-custom-error";
-import wrap from "word-wrap";
-var Exception = class extends CustomError {
-  constructor(module, message) {
-    const moduleName = typeof module === "string" ? module : module.name;
-    const msg = wrap(message, { width: 60, indent: "    " });
-    super(`${moduleName} module failed to compile:
-${msg}`);
-    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
-  }
-};
-
-// src/utils/openapi-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/openapi-utils/dereference-operation.ts
-import * as R8 from "ramda";
-import jsonpointer2 from "jsonpointer";
-import { JSONPath as JSONPath4 } from "jsonpath-plus";
+// src/plugins/generate-declaration/generate-declaration.plugin.ts
+import { AsyncSeriesWaterfallHook } from "tapable";
 
-// src/utils/openapi-utils/remove-undefined-ref.ts
-import * as R7 from "ramda";
-import jsonpointer from "jsonpointer";
-import { JSONPath as JSONPath3 } from "jsonpath-plus";
+// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
+import * as path7 from "path";
+import * as changeCase5 from "change-case";
 
-// src/utils/openapi-utils/is-ref-defined.ts
-import * as R6 from "ramda";
-function isRefDefined($ref, swagger) {
-  if ($ref.startsWith("#/")) {
-    const path13 = $ref.replace("#/", "").split("/");
-    return R6.path(path13, swagger) !== void 0;
-  }
-  return false;
-}
-
-// src/utils/openapi-utils/remove-undefined-ref.ts
-function removeUndefinedRef(swagger) {
-  const shadow = R7.clone(swagger);
-  const matches = JSONPath3({
-    path: "$..*['$ref']^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
-      jsonpointer.set(shadow, match.pointer, R7.omit(["$ref"], match.value));
-    }
-  }
-  return shadow;
-}
-
-// src/utils/openapi-utils/dereference-operation.ts
-function dereferencePathObject(swagger) {
-  const matches = JSONPath4({
-    path: "$.paths.*.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    jsonpointer2.set(swagger, match.pointer, value);
-  }
-}
-function dereferenceRequestBody(swagger) {
-  const matches = JSONPath4({
-    path: "$.paths.*.*.requestBody.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    jsonpointer2.set(swagger, match.pointer, value);
-  }
-}
-function dereferenceResponses(swagger) {
-  const matches = [
-    ...JSONPath4({
-      path: "$.paths.*.*.responses.*.$ref^",
-      json: swagger,
-      resultType: "all"
-    }),
-    ...JSONPath4({
-      path: "$.paths.*.*.responses.*.headers.*.$ref^",
-      json: swagger,
-      resultType: "all"
-    })
-  ];
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    jsonpointer2.set(swagger, match.pointer, value);
-  }
-}
-function dereferenceParameters(swagger) {
-  const matches = JSONPath4({
-    path: "$.paths.*.*.parameters.*.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    jsonpointer2.set(swagger, match.pointer, value);
-  }
-}
-function dereferenceOperation(swagger) {
-  const shadow = R8.clone(swagger);
-  dereferencePathObject(shadow);
-  dereferenceRequestBody(shadow);
-  dereferenceResponses(shadow);
-  dereferenceParameters(shadow);
-  return removeUndefinedRef(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/openapi-utils/dereference-deep.ts
-function dereferenceDeep($ref, swagger) {
-  const stack = [$ref];
-  let value;
-  while (true) {
-    const last2 = stack[stack.length - 1];
-    value = dereference(last2, 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/openapi-utils/to-3_1.ts
-import { upgrade } from "@scalar/openapi-parser";
-function To3_1(openapi) {
-  const { specification } = upgrade(openapi);
-  return specification;
-}
-
-// src/utils/openapi-utils/map-operation.ts
-import * as R9 from "ramda";
-function mapOperation(specification, mapper) {
-  const shadow = R9.clone(specification);
-  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];
-      pathItem[m] = mapper(method, pathname, operation);
-    }
-  }
-  return shadow;
-}
-
-// src/utils/openapi-utils/map-parameter.ts
-function mapParameter(specification, mapper) {
-  return mapOperation(specification, (method, pathname, operation) => {
-    if (!operation.parameters) return operation;
-    operation.parameters = operation.parameters.map((parameter) => mapper(method, pathname, operation, parameter));
-    return operation;
-  });
-}
-
-// src/utils/openapi-utils/index.ts
-var OpenapiUtils = class {
-  static isRefDefined = isRefDefined;
-  static dereference = dereference;
-  static dereferenceDeep = dereferenceDeep;
-  static removeUndefinedRef = removeUndefinedRef;
-  static dereferenceOperation = dereferenceOperation;
-  static mapOperation = mapOperation;
-  static mapParameter = mapParameter;
-  // static updateOperationId = updateOperationId
-  static to3_1 = To3_1;
-};
-
-// src/compiler/tasks/download/index.ts
-function main2(compiler, options) {
-  return {
-    task: (context, task) => {
-      if (!context.rc || !context.matcher) {
-        throw new Error("Please run setup task first.");
-      }
-      const rc = context.rc;
-      const matcher = context.matcher;
-      context.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 content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
-            if (!content) {
-              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address}`);
-            }
-            const spec = JSON.parse(content);
-            const { valid, errors } = await validate(spec);
-            if (!valid) {
-              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
-${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
-              task2.output = message;
-            }
-            OpenapiUtils.dereferenceOperation(spec);
-            const document = new ApiDocumentV3_1(
-              spec,
-              moduleDefinition
-            );
-            ctx.documents?.push(document);
-          }
-        })),
-        {
-          concurrent: true,
-          exitOnError: false,
-          collectErrors: "minimal",
-          rendererOptions: {
-            collapseSubtasks: false,
-            // collapseSkips: false,
-            suffixSkips: true,
-            timer: PRESET_TIMER
-          }
-        }
-      );
-    }
-  };
-}
-function createDownloadTask(compiler, options) {
-  return {
-    title: "Download",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (_, task) => task.newListr(
-      [
-        main2(compiler, options),
-        {
-          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/persist/index.ts
-import * as path6 from "path";
-import fs4 from "fs-extra";
-function createPersistArtifactTask() {
-  return {
-    title: "Write files",
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.artifacts || context.artifacts.length === 0) {
-        task.skip("No compiled artifacts to persist.");
-        return;
-      }
-      const rc = context.rc;
-      const artifacts = context.artifacts;
-      const total = artifacts.length;
-      let completed = 0;
-      const files = await Promise.all(artifacts.map(async (artifact) => {
-        const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
-        await fs4.ensureFile(realpath);
-        await fs4.writeFile(realpath, artifact.renderer());
-        completed += 1;
-        task.output = `Persisted ${completed}/${total} files`;
-        return new Asset(path6.resolve(realpath));
-      }));
-      context.assets = files;
-    }
-  };
-}
-function createPersistIgnoreTask() {
-  return {
-    title: "Update .keqignore",
-    task: async (context, task) => {
-      if (!context.matcher) throw new Error("Please run setup task first.");
-      const matcher = context.matcher;
-      await matcher.write(".keqignore");
-    }
-  };
-}
-function main3() {
-  return {
-    task: (context, task) => task.newListr(
-      [
-        createPersistArtifactTask(),
-        createPersistIgnoreTask()
-      ],
-      {
-        concurrent: true,
-        rendererOptions: {
-          collapseSubtasks: true
-        }
-      }
-    )
-  };
-}
-function createPersistTask(compiler, options) {
-  return {
-    title: "Persist",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main3(),
-        {
-          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/compile/index.ts
-function main4(compiler) {
-  return {
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.documents) throw new Error("Please run shaking task first.");
-      context.artifacts = [];
-      await compiler.hooks.compile.promise(task);
-    }
-  };
-}
-function createCompileTask(compiler, options) {
-  return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        {
-          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
-        },
-        main4(compiler),
-        {
-          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/intercepter/print-information.ts
-function proxyTaskWrapper(pluginName, task) {
-  return new Proxy(task, {
-    set(target, prop2, value) {
-      if (prop2 !== "output") {
-        return Reflect.set(target, prop2, value);
-      }
-      target.output = `[Plugin: ${pluginName}] ${value}`;
-      return true;
-    }
-  });
-}
-function printInformation(taskIndex) {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      if (tap.type === "promise") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      return tap;
-    }
-  };
-}
-
-// src/compiler/intercepter/perfect-error-message.ts
-import * as R10 from "ramda";
-function perfectErrorMessage() {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      function prefix(err) {
-        if (err instanceof Error) {
-          err.message = `[Plugin: ${tap.name}] ${err.message}`;
-        }
-      }
-      if (tap.type === "promise") {
-        tap.fn = async (...args) => {
-          try {
-            return await fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          try {
-            return fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const callback = R10.last(args);
-          return fn(...R10.init(args), (err, result) => {
-            prefix(err);
-            return callback(err, result);
-          });
-        };
-      }
-      return tap;
-    }
-  };
-}
-
-// src/plugins/eslint/index.ts
-import { ESLint } from "eslint";
-
-// src/plugins/prettier/prettier.plugin.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-
-// src/plugins/body-fallback/index.ts
-import * as R22 from "ramda";
-
-// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
-import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook2 } from "tapable";
-
-// src/plugins/generate-micro-function/constants/metadata-storage.ts
-var MetadataStorage = /* @__PURE__ */ new WeakMap();
-
-// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
-import * as R21 from "ramda";
-import * as path10 from "path";
-import * as changeCase6 from "change-case";
-
-// src/plugins/generate-declaration/generate-declaration.plugin.ts
-import { AsyncSeriesWaterfallHook } from "tapable";
-
-// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
-import * as path9 from "path";
-import * as changeCase5 from "change-case";
-
-// src/transformers/json-schema/comment.renderer.ts
-var CommentRenderer = class {
-  constructor(schema) {
-    this.schema = schema;
+// src/transformers/json-schema/comment.renderer.ts
+var CommentRenderer = class {
+  constructor(schema) {
+    this.schema = schema;
   }
   render() {
     const schema = this.schema;
@@ -1198,7 +739,7 @@ var CommentRenderer = class {
 };
 
 // src/transformers/json-schema/declaration.renderer.ts
-import * as R12 from "ramda";
+import * as R7 from "ramda";
 
 // src/utils/indent.ts
 function indent(space, text) {
@@ -1208,9 +749,9 @@ function indent(space, text) {
 }
 
 // src/transformers/json-schema/reference.transformer.ts
-import * as R11 from "ramda";
+import * as R6 from "ramda";
 var ReferenceTransformer = class {
-  static toDeclaration(schema, alias2 = R11.identity) {
+  static toDeclaration(schema, alias2 = R6.identity) {
     if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
     const parts = schema.$ref.split("/");
     return alias2(parts[parts.length - 1]) || "unknown";
@@ -1266,7 +807,7 @@ var DeclarationRenderer = class {
     return "any[]";
   }
   renderObject(schema) {
-    if ((!schema.properties || R12.isEmpty(schema.properties)) && (!schema.additionalProperties || R12.isEmpty(schema.additionalProperties))) {
+    if ((!schema.properties || R7.isEmpty(schema.properties)) && (!schema.additionalProperties || R7.isEmpty(schema.additionalProperties))) {
       return "object";
     }
     const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
@@ -1332,7 +873,7 @@ var JsonSchemaTransformer = class {
 };
 
 // src/transformers/schema-definition/schema-definition.transformer.ts
-import * as R13 from "ramda";
+import * as R8 from "ramda";
 var SchemaDefinitionTransformer = class {
   static toDeclaration(schemaDefinition, options) {
     const dependencies = schemaDefinition.getDependencies();
@@ -1352,7 +893,7 @@ var SchemaDefinitionTransformer = class {
         `type ${schemaDefinition.name} = unknown`,
         "",
         "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
+      ].filter(R8.isNotNil).join("\n");
     }
     if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
       const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema);
@@ -1365,7 +906,7 @@ var SchemaDefinitionTransformer = class {
         $declaration,
         "",
         "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
+      ].filter(R8.isNotNil).join("\n");
     }
     return [
       "/* @anchor:file:start */",
@@ -1375,12 +916,12 @@ var SchemaDefinitionTransformer = class {
       `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
       "",
       "/* @anchor:file:end */"
-    ].filter(R13.isNotNil).join("\n");
+    ].filter(R8.isNotNil).join("\n");
   }
 };
 
 // src/transformers/operation-definition/comment.renderer.ts
-import * as R14 from "ramda";
+import * as R9 from "ramda";
 var CommentRenderer2 = class {
   constructor(operationDefinition) {
     this.operationDefinition = operationDefinition;
@@ -1390,11 +931,11 @@ var CommentRenderer2 = class {
     if (!operation.summary && !operation.description) return "";
     const lines = ["/**"];
     if (operation.summary && typeof operation.summary === "string") {
-      lines.push(` * ${R14.trim(operation.summary)}`);
+      lines.push(` * ${R9.trim(operation.summary)}`);
       lines.push(" *");
     }
     if (operation.description && typeof operation.description === "string") {
-      lines.push(` * @description ${R14.trim(operation.description)}`);
+      lines.push(` * @description ${R9.trim(operation.description)}`);
     }
     lines.push(" */");
     return lines.join("\n");
@@ -1402,7 +943,7 @@ var CommentRenderer2 = class {
 };
 
 // src/transformers/operation-definition/declaration.renderer.ts
-import * as R15 from "ramda";
+import * as R14 from "ramda";
 
 // src/transformers/operation-definition/utils/type-name-factory.ts
 import * as changeCase from "change-case";
@@ -1411,6 +952,182 @@ function typeNameFactory(operationDefinition) {
   return (name) => `${pascalCaseOperationId}${name}`;
 }
 
+// src/utils/openapi-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/openapi-utils/dereference-operation.ts
+import * as R12 from "ramda";
+import jsonpointer2 from "jsonpointer";
+import { JSONPath as JSONPath4 } from "jsonpath-plus";
+
+// src/utils/openapi-utils/remove-undefined-ref.ts
+import * as R11 from "ramda";
+import jsonpointer from "jsonpointer";
+import { JSONPath as JSONPath3 } from "jsonpath-plus";
+
+// src/utils/openapi-utils/is-ref-defined.ts
+import * as R10 from "ramda";
+function isRefDefined($ref, swagger) {
+  if ($ref.startsWith("#/")) {
+    const path12 = $ref.replace("#/", "").split("/");
+    return R10.path(path12, swagger) !== void 0;
+  }
+  return false;
+}
+
+// src/utils/openapi-utils/remove-undefined-ref.ts
+function removeUndefinedRef(swagger) {
+  const shadow = R11.clone(swagger);
+  const matches = JSONPath3({
+    path: "$..*['$ref']^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
+      jsonpointer.set(shadow, match.pointer, R11.omit(["$ref"], match.value));
+    }
+  }
+  return shadow;
+}
+
+// src/utils/openapi-utils/dereference-operation.ts
+function dereferencePathObject(swagger) {
+  const matches = JSONPath4({
+    path: "$.paths.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    jsonpointer2.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceRequestBody(swagger) {
+  const matches = JSONPath4({
+    path: "$.paths.*.*.requestBody.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    jsonpointer2.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceResponses(swagger) {
+  const matches = [
+    ...JSONPath4({
+      path: "$.paths.*.*.responses.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    }),
+    ...JSONPath4({
+      path: "$.paths.*.*.responses.*.headers.*.$ref^",
+      json: swagger,
+      resultType: "all"
+    })
+  ];
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    jsonpointer2.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceParameters(swagger) {
+  const matches = JSONPath4({
+    path: "$.paths.*.*.parameters.*.$ref^",
+    json: swagger,
+    resultType: "all"
+  });
+  for (const match of matches) {
+    const value = dereference(match.value.$ref, swagger);
+    jsonpointer2.set(swagger, match.pointer, value);
+  }
+}
+function dereferenceOperation(swagger) {
+  const shadow = R12.clone(swagger);
+  dereferencePathObject(shadow);
+  dereferenceRequestBody(shadow);
+  dereferenceResponses(shadow);
+  dereferenceParameters(shadow);
+  return removeUndefinedRef(shadow);
+}
+
+// src/utils/openapi-utils/dereference-deep.ts
+function dereferenceDeep($ref, swagger) {
+  const stack = [$ref];
+  let value;
+  while (true) {
+    const last2 = stack[stack.length - 1];
+    value = dereference(last2, 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/openapi-utils/to-3_1.ts
+import { upgrade } from "@scalar/openapi-parser";
+function To3_1(openapi) {
+  const { specification } = upgrade(openapi);
+  return specification;
+}
+
+// src/utils/openapi-utils/map-operation.ts
+import * as R13 from "ramda";
+function mapOperation(specification, mapper) {
+  const shadow = R13.clone(specification);
+  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];
+      pathItem[m] = mapper(method, pathname, operation);
+    }
+  }
+  return shadow;
+}
+
+// src/utils/openapi-utils/map-parameter.ts
+function mapParameter(specification, mapper) {
+  return mapOperation(specification, (method, pathname, operation) => {
+    if (!operation.parameters) return operation;
+    operation.parameters = operation.parameters.map((parameter) => mapper(method, pathname, operation, parameter));
+    return operation;
+  });
+}
+
+// src/utils/openapi-utils/index.ts
+var OpenapiUtils = class {
+  static isRefDefined = isRefDefined;
+  static dereference = dereference;
+  static dereferenceDeep = dereferenceDeep;
+  static removeUndefinedRef = removeUndefinedRef;
+  static dereferenceOperation = dereferenceOperation;
+  static mapOperation = mapOperation;
+  static mapParameter = mapParameter;
+  // static updateOperationId = updateOperationId
+  static to3_1 = To3_1;
+};
+
 // src/transformers/operation-definition/declaration.renderer.ts
 var alias = (name) => `${name}Schema`;
 var DeclarationRenderer2 = class {
@@ -1421,7 +1138,7 @@ var DeclarationRenderer2 = class {
   }
   typeName;
   renderResponseBodies(operation, options) {
-    if (!operation.responses || R15.isEmpty(operation.responses)) {
+    if (!operation.responses || R14.isEmpty(operation.responses)) {
       return `export interface ${this.typeName("ResponseBodies")} {}`;
     }
     const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
@@ -1572,15 +1289,28 @@ var DeclarationRenderer2 = class {
       "}",
       "",
       "/* @anchor:file:end */"
-    ].filter(R15.isNotNil).join("\n");
+    ].filter(R14.isNotNil).join("\n");
   }
 };
 
 // src/transformers/operation-definition/micro-function.renderer.ts
-import * as R17 from "ramda";
+import * as R16 from "ramda";
+
+// src/exception.ts
+import { CustomError } from "ts-custom-error";
+import wrap from "word-wrap";
+var Exception = class extends CustomError {
+  constructor(module, message) {
+    const moduleName = typeof module === "string" ? module : module.name;
+    const msg = wrap(message, { width: 60, indent: "    " });
+    super(`${moduleName} module failed to compile:
+${msg}`);
+    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
+  }
+};
 
 // src/transformers/operation-definition/typescript-snippet.ts
-import * as R16 from "ramda";
+import * as R15 from "ramda";
 var OperationDefinitionSnippet = class {
   constructor(operationDefinition, options) {
     this.operationDefinition = operationDefinition;
@@ -1637,7 +1367,7 @@ var OperationDefinitionSnippet = class {
     const { operation } = this.operationDefinition;
     const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
       const option = this.getQsParameters(p);
-      const $option = !option || R16.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
+      const $option = !option || R15.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})`;
     }).join("\n");
     return $query;
@@ -1707,7 +1437,7 @@ var OperationDefinitionSnippet = class {
       } catch (err) {
         return this.renderErrorComment(err, mediaType);
       }
-    }).filter(R16.isNotNil).join("\n");
+    }).filter(R15.isNotNil).join("\n");
     return $requestBody;
   }
   renderErrorComment(err, mediaType) {
@@ -1782,7 +1512,7 @@ var OperationDefinitionMicroFunctionRenderer = class {
       `${operationId}.pathname = pathname`,
       `${operationId}.method = method`,
       "/* @anchor:file:end */"
-    ].filter(R17.isNotNil).join("\n");
+    ].filter(R16.isNotNil).join("\n");
   }
   renderDependencies() {
     const declarationFilepath = this.options.getOperationDefinitionDeclarationFilepath(this.operationDefinition);
@@ -1809,7 +1539,7 @@ var OperationDefinitionMicroFunctionRenderer = class {
 };
 
 // src/transformers/operation-definition/nestjs-method.renderer.ts
-import * as R18 from "ramda";
+import * as R17 from "ramda";
 var OperationDefinitionNestjsMethodRenderer = class {
   constructor(operationDefinition, options) {
     this.operationDefinition = operationDefinition;
@@ -1862,7 +1592,7 @@ var OperationDefinitionNestjsMethodRenderer = class {
       "",
       "  return req",
       "}"
-    ].filter(R18.isNotNil).join("\n");
+    ].filter(R17.isNotNil).join("\n");
   }
   renderOperationDeclaration(operationDefinition) {
     const { operationId } = operationDefinition;
@@ -1896,11 +1626,11 @@ var OperationDefinitionTransformer = class {
 };
 
 // src/transformers/entrypoint/entrypoint.transformer.ts
-import * as path7 from "path";
+import * as path5 from "path";
 var EntrypointTransformer = class {
   static toTypescript(exports, options) {
     const $exports = exports.map((exportArtifact) => {
-      const relativePath = path7.relative(
+      const relativePath = path5.relative(
         options.dirpath,
         exportArtifact.filepath
       ).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, options.esm ? ".js" : "");
@@ -1917,128 +1647,26 @@ var EntrypointTransformer = class {
 };
 
 // src/transformers/api-document/nestjs-client.renderer.ts
-import * as R19 from "ramda";
+import * as R18 from "ramda";
 import * as changeCase2 from "change-case";
-var NestjsClientRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  renderDependencies() {
-    const $operations = this.document.operations.map((operationDefinition) => {
-      const filepath = this.options.getOperationDefinitionDeclarationFilepath(operationDefinition);
-      const typeName = typeNameFactory(operationDefinition);
-      return `import type { ${typeName("Operation")}, ${typeName("ResponseBodies")}, ${typeName("RequestParameters")} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? ' from "$1.js"' : ' from "$1"'));
-    return [
-      'import { Injectable, Logger } from "@nestjs/common"',
-      'import { Keq, KeqRequest } from "keq"',
-      ...$operations
-    ].join("\n");
-  }
-  render() {
-    const moduleName = changeCase2.pascalCase(this.document.module.name);
-    const $dependencies = this.renderDependencies();
-    const $operations = this.document.operations.map((operation) => OperationDefinitionTransformer.toNestjsMethod(operation, {
-      esm: this.options.esm
-    })).join("\n\n");
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      "",
-      "@Injectable()",
-      `export class ${moduleName}Client {`,
-      `  private readonly logger = new Logger(${moduleName}Client.name)`,
-      "",
-      "  constructor(",
-      "    // @anchor:client-constructor-parameters:start",
-      "    private readonly request: KeqRequest,",
-      "    // @anchor:client-constructor-parameters:end",
-      "  ) {}",
-      "",
-      indent(2, $operations),
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R19.isNotNil).join("\n");
-  }
-};
 
 // src/transformers/api-document/nestjs-module.renderer.ts
 import * as changeCase3 from "change-case";
-var NestjsModuleRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  render() {
-    const moduleName = changeCase3.pascalCase(this.document.module.name);
-    const clientFilepath = this.options.getNestjsClientFilepath(this.document).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, this.options.esm ? ".js" : "");
-    return [
-      "/* @anchor:file:start */",
-      'import { Module, Inject, ConfigurableModuleBuilder, Global } from "@nestjs/common"',
-      'import { KeqRequest } from "keq"',
-      'import { KeqModuleOptions } from "@keq-request/nestjs"',
-      `import { ${moduleName}Client } from "${clientFilepath}"`,
-      "",
-      "",
-      "const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder<KeqModuleOptions>().build()",
-      "",
-      "@Global()",
-      "@Module({",
-      "  imports: [],",
-      "  controllers: [],",
-      `  providers: [${moduleName}Client],`,
-      `  exports: [${moduleName}Client],`,
-      "})",
-      `export class ${moduleName}Module extends ConfigurableModuleClass {`,
-      "",
-      "  constructor(",
-      "    @Inject(MODULE_OPTIONS_TOKEN) private readonly options: KeqModuleOptions,",
-      "    private readonly request: KeqRequest,",
-      "  ) {",
-      "    super()",
-      "  }",
-      "",
-      "  onModuleInit() {",
-      "    if (this.options.middlewares) {",
-      "      for (const middleware of this.options.middlewares) {",
-      "        this.request.use(middleware)",
-      "      }",
-      "    }",
-      "  }",
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].join("\n");
-  }
-};
-
-// src/transformers/api-document/api-document.transformer.ts
-var ApiDocumentTransformer = class {
-  static toNestjsModule(document, options) {
-    return new NestjsModuleRenderer(document, options).render();
-  }
-  static toNestjsClient(document, options) {
-    return new NestjsClientRenderer(document, options).render();
-  }
-};
 
 // src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
-import * as R20 from "ramda";
-import * as path8 from "path";
+import * as R19 from "ramda";
+import * as path6 from "path";
 import * as changeCase4 from "change-case";
 
 // src/plugins/generate-declaration/constants/metadata-storage.ts
-var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
+var MetadataStorage4 = /* @__PURE__ */ new WeakMap();
 
 // src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
 var SCHEMA_GENERATOR = "schemaGenerator";
 var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   async compile(compiler, task) {
     const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
+    const metadata = MetadataStorage4.get(compiler);
     const rc = context.rc;
     const documents = context.documents;
     const schemaDefinitions = documents.flatMap((document) => document.schemas);
@@ -2054,7 +1682,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
         ])
       )
     );
-    const entrypoints = R20.collectBy(
+    const entrypoints = R19.collectBy(
       (schemaDefinition) => schemaDefinition.module.name,
       schemaDefinitions
     ).map((schemaDefinitions2) => [
@@ -2069,7 +1697,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   }
   generateSchemaDefinitionsArtifact(schemaDefinition, rc) {
     const filepath = _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(schemaDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
+    const dirpath = path6.dirname(filepath);
     const artifact = new Artifact({
       id: _SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
       filepath,
@@ -2078,7 +1706,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
         {
           esm: rc.esm,
           getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path8.relative(
+            const relativePath = path6.relative(
               dirpath,
               _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
             );
@@ -2092,7 +1720,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
   }
   generateEntrypointArtifact(moduleDefinition, exports, rc) {
     const filepath = _SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
+    const dirpath = path6.dirname(filepath);
     const artifact = new Artifact({
       id: _SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
       filepath,
@@ -2111,7 +1739,7 @@ var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
     ].join("/");
   }
   static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
+    return `${moduleDefinition.address.url}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
   }
   static getSchemaDefinitionArtifactFilepath(schemaDefinition, fileNamingStyle) {
     const filename = `${changeCase4[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
@@ -2134,7 +1762,7 @@ var OPERATION_GENERATOR = "operationDeclarationGenerator";
 var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   async compile(compiler, task) {
     const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
+    const metadata = MetadataStorage4.get(compiler);
     const rc = context.rc;
     const documents = context.documents;
     const operationDefinitions = documents.flatMap((document) => document.operations);
@@ -2154,7 +1782,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   }
   generateOperationDefinitionArtifact(operationDefinition, rc) {
     const filepath = _OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
+    const dirpath = path7.dirname(filepath);
     const artifact = new Artifact({
       id: _OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
       filepath,
@@ -2163,7 +1791,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
         {
           esm: rc.esm,
           getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path9.relative(
+            const relativePath = path7.relative(
               dirpath,
               SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
             );
@@ -2177,7 +1805,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
   }
   generateEntrypointArtifact(moduleDefinition, exports, rc) {
     const filepath = _OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
+    const dirpath = path7.dirname(filepath);
     const artifact = new Artifact({
       id: _OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
       filepath,
@@ -2209,7 +1837,7 @@ var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
     ].join("/");
   }
   static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
+    return `${moduleDefinition.address.url}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
   }
 };
 
@@ -2222,6 +1850,7 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
   constructor() {
   }
   apply(compiler) {
+    if (MetadataStorage4.has(compiler)) return;
     _GenerateDeclarationPlugin.register(compiler);
     compiler.hooks.compile.tapPromise(_GenerateDeclarationPlugin.name, async (task) => {
       compiler.context.artifacts?.push(
@@ -2231,8 +1860,8 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage2.has(compiler)) {
-      MetadataStorage2.set(compiler, {
+    if (!MetadataStorage4.has(compiler)) {
+      MetadataStorage4.set(compiler, {
         hooks: {
           afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "task"]),
           afterSchemaDeclarationArtifactGenerated: new AsyncSeriesWaterfallHook(["artifact", "schemaDefinition", "task"]),
@@ -2240,7 +1869,7 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
         }
       });
     }
-    return MetadataStorage2.get(compiler);
+    return MetadataStorage4.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
@@ -2285,7 +1914,7 @@ var RequestGenerator = class _RequestGenerator {
 var MICRO_FUNCTION_GENERATOR = "microFunctionGenerator";
 var MicroFunctionGenerator = class _MicroFunctionGenerator {
   async compile(compiler, task) {
-    const metadata = MetadataStorage.get(compiler);
+    const metadata = MetadataStorage3.get(compiler);
     const context = compiler.context;
     const rc = context.rc;
     const documents = context.documents;
@@ -2303,7 +1932,7 @@ var MicroFunctionGenerator = class _MicroFunctionGenerator {
       )
     );
     const entrypoints = await Promise.all(
-      R21.collectBy(
+      R20.collectBy(
         (operationDefinition) => operationDefinition.module.name,
         operationDefinitions
       ).map((operationDefinitions2) => [
@@ -2322,21 +1951,21 @@ var MicroFunctionGenerator = class _MicroFunctionGenerator {
   }
   generateOperationDefinitionArtifact(operationDefinition, rc) {
     const filepath = _MicroFunctionGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path10.dirname(filepath);
+    const dirpath = path8.dirname(filepath);
     const artifact = new Artifact({
       id: _MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
       filepath,
       content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
         esm: rc.esm,
         getOperationDefinitionDeclarationFilepath(operationDefinition2) {
-          const relativePath = path10.relative(
+          const relativePath = path8.relative(
             dirpath,
             OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition2, rc.fileNamingStyle)
           );
           return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
         },
         getRequestFilepath() {
-          const relativePath = path10.relative(
+          const relativePath = path8.relative(
             dirpath,
             RequestGenerator.getRequestArtifactFilepath()
           );
@@ -2388,6 +2017,7 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
   microFunctionGenerator = new MicroFunctionGenerator();
   requestGenerator = new RequestGenerator();
   apply(compiler) {
+    if (MetadataStorage3.has(compiler)) return;
     _GenerateMicroFunctionPlugin.register(compiler);
     compiler.hooks.compile.tapPromise(_GenerateMicroFunctionPlugin.name, async (task) => {
       const artifacts = [
@@ -2398,15 +2028,15 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage.has(compiler)) {
-      MetadataStorage.set(compiler, {
+    if (!MetadataStorage3.has(compiler)) {
+      MetadataStorage3.set(compiler, {
         hooks: {
           afterEntrypointArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "task"]),
           afterMicroFunctionArtifactGenerated: new AsyncSeriesWaterfallHook2(["artifact", "operationDefinition", "task"])
         }
       });
     }
-    return MetadataStorage.get(compiler);
+    return MetadataStorage3.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
@@ -2416,328 +2046,646 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
 // src/plugins/generate-nestjs-module/generate-nestjs-module.ts
 import { AsyncSeriesWaterfallHook as AsyncSeriesWaterfallHook3 } from "tapable";
 
-// src/plugins/generate-nestjs-module/constants/metadata-storage.ts
-var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
-
 // src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
-import * as path11 from "path";
 import * as changeCase7 from "change-case";
-var NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
-var NestjsModuleGenerator = class _NestjsModuleGenerator {
-  generateNestjsModuleArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.fileNamingStyle);
-    const dirname6 = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsModuleArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsModule(document, {
-        esm: rc.esm,
-        getNestjsClientFilepath(document2) {
-          const relativePath = path11.relative(
-            dirname6,
-            _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document2, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
+
+// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
+import { fixSwagger } from "swagger-fix";
+
+// src/plugins/download-http-file/constants/metadata-storage.ts
+var MetadataStorage8 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/download-http-file/download-http-file.plugin.ts
+var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
+  apply(compiler) {
+    if (MetadataStorage8.has(compiler)) return;
+    _DownloadHttpFilePlugin.register(compiler);
+    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
+      const { url } = address;
+      if (!url.startsWith("http://") && !url.startsWith("https://")) return void 0;
+      const content = await this.download(address);
+      const spec = this.deserialize(content);
+      return JSON.stringify(spec);
     });
-    return artifact;
   }
-  generateNestjsClientArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.fileNamingStyle);
-    const dirpath = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsClientArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsClient(document, {
-        esm: rc.esm,
-        getOperationDefinitionDeclarationFilepath(operationDefinition) {
-          const relativePath = path11.relative(
-            dirpath,
-            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
+  async download(address) {
+    const { url, headers } = address;
+    try {
+      const res = await fetch(url, { headers });
+      if (res.status >= 400) throw new Error(`failed with status code ${res.status}`);
+      return await res.text();
+    } catch (e) {
+      if (e instanceof Error) {
+        e.message = `Unable get the openapi/swagger file from ${url}: ${e.message}`;
+      }
+      throw e;
+    }
+  }
+  deserialize(content) {
+    const json = JSON.parse(content);
+    const spec = OpenapiUtils.to3_1(json);
+    return spec;
+  }
+  static register(compiler) {
+    if (!MetadataStorage8.has(compiler)) {
+      MetadataStorage8.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage8.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+import * as path9 from "path";
+import * as fs3 from "fs/promises";
+import * as yaml from "js-yaml";
+import { fileURLToPath } from "url";
+
+// src/plugins/download-local-file/constants/metadata-storage.ts
+var MetadataStorage9 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/download-local-file/download-local-file.plugin.ts
+var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
+  apply(compiler) {
+    if (MetadataStorage9.has(compiler)) return;
+    _DownloadLocalFilePlugin.register(compiler);
+    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
+      const { url, encoding } = address;
+      if (!url.startsWith("file://")) return void 0;
+      const filepath = fileURLToPath(url);
+      const fileExt = path9.extname(filepath);
+      const content = await fs3.readFile(filepath, encoding);
+      const str = typeof content === "string" ? content : content.toString(encoding);
+      if ([".yml", ".yaml"].includes(fileExt)) {
+        const value = yaml.load(str);
+        return JSON.stringify(OpenapiUtils.to3_1(value));
+      } else if (fileExt === ".json") {
+        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(str)));
+      }
     });
-    return artifact;
   }
-  async compile(compiler, task) {
-    const metadata = MetadataStorage3.get(compiler);
+  static register(compiler) {
+    if (!MetadataStorage9.has(compiler)) {
+      MetadataStorage9.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage9.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
+};
+
+// src/plugins/shaking/shaking.plugin.ts
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
+
+// src/plugins/shaking/constants/metadata-storage.ts
+var MetadataStorage10 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/shaking/shaking.plugin.ts
+var ShakingPlugin = class _ShakingPlugin {
+  apply(compiler) {
+    if (MetadataStorage10.has(compiler)) return;
+    _ShakingPlugin.register(compiler);
+    compiler.hooks.beforeCompile.tap(_ShakingPlugin.name, (task) => {
+      const matcher = compiler.context.matcher;
+      const documents = compiler.context.documents;
+      compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleIgnored(document.module));
+    });
+  }
+  shaking(compiler, document) {
     const rc = compiler.context.rc;
-    const documents = compiler.context.documents;
-    const nestjsModuleArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsModuleArtifact(document, rc),
-        document,
-        task
-      ))
+    const matcher = compiler.context.matcher;
+    const isAccepted = (pathname, method, operation) => {
+      if (!SupportedMethods.includes(method)) return false;
+      return !matcher.isOperationIgnored(new OperationDefinition({
+        method,
+        pathname,
+        operation,
+        module: document.module,
+        document
+      }));
+    };
+    const sharkedSwagger = openapiShakingSync(
+      document.specification,
+      isAccepted,
+      { tolerant: rc.tolerant }
     );
-    const nestjsClientArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsClientArtifact(document, rc),
-        document,
-        task
-      ))
+    return new ApiDocumentV3_1(
+      sharkedSwagger,
+      new ModuleDefinition(
+        document.module.name,
+        {
+          url: `memory://${document.module.name}.v3_1.sharked.json`,
+          headers: {},
+          encoding: "utf8"
+        }
+      )
     );
-    return [...nestjsModuleArtifacts, ...nestjsClientArtifacts];
-  }
-  static getNestjsModuleArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.module.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
   }
-  static getNestjsModuleArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
-  }
-  static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.client.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
+  static register(compiler) {
+    if (!MetadataStorage10.has(compiler)) {
+      MetadataStorage10.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage10.get(compiler);
   }
-  static getNestjsClientArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}-client`;
+  static of(compiler) {
+    return this.register(compiler);
   }
 };
 
-// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
-var GenerateNestjsModulePlugin = class _GenerateNestjsModulePlugin {
-  nestjsModuleGenerator = new NestjsModuleGenerator();
+// src/plugins/terminal-select/utils/select-operation-definitions.ts
+import { select } from "inquirer-select-pro";
+import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
+async function selectOperationDefinitions(task, operationDefinitions) {
+  const selectedOperationDefinitions = await task.prompt(ListrInquirerPromptAdapter).run(
+    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/plugins/terminal-select/constants/metadata-storage.ts
+var MetadataStorage11 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/terminal-select/terminal-select.plugin.ts
+var TerminalSelectPlugin = class _TerminalSelectPlugin {
+  constructor(options) {
+    this.options = options;
+  }
   apply(compiler) {
-    _GenerateNestjsModulePlugin.register(compiler);
-    compiler.hooks.compile.tapPromise(_GenerateNestjsModulePlugin.name, async (task) => {
-      const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
-      compiler.context.artifacts.push(...artifacts);
+    if (MetadataStorage11.has(compiler)) return;
+    _TerminalSelectPlugin.register(compiler);
+    compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
+      const context = compiler.context;
+      const matcher = context.matcher;
+      const documents = context.documents;
+      const operationDefinitions = documents.flatMap((document) => document.operations);
+      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
+      if (this.options.clear) {
+        matcher.append({
+          persist: false,
+          ignore: true,
+          moduleName: "*",
+          operationMethod: "*",
+          operationPathname: "*"
+        });
+      }
+      for (const op of selectedOperationDefinitions) {
+        matcher.append({
+          persist: !!this.options.persist,
+          ignore: this.options.mode === "add",
+          moduleName: op.module.name,
+          operationMethod: op.method,
+          operationPathname: op.pathname
+        });
+      }
     });
   }
-  static register(compiler) {
-    if (!MetadataStorage3.has(compiler)) {
-      MetadataStorage3.set(compiler, {
-        hooks: {
-          afterNestjsModuleArtifactGenerated: new AsyncSeriesWaterfallHook3(["artifact", "document", "task"])
-        }
+  static register(compiler) {
+    if (!MetadataStorage11.has(compiler)) {
+      MetadataStorage11.set(compiler, {
+        hooks: {}
       });
     }
-    return MetadataStorage3.get(compiler);
+    return MetadataStorage11.get(compiler);
   }
   static of(compiler) {
-    return MetadataStorage3.get(compiler);
+    return this.register(compiler);
   }
 };
 
-// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
-import { fixSwagger } from "swagger-fix";
-
-// src/plugins/download-http-file/download-http-file.plugin.ts
-import * as validUrl from "valid-url";
-var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
-      if (!validUrl.isUri(address)) return void 0;
-      const content = await this.download(address);
-      const spec = this.deserialize(content);
-      return JSON.stringify(spec);
-    });
+// src/plugins/initialize/initialize.plugin.ts
+import * as R22 from "ramda";
+var InitializePlugin = class _InitializePlugin {
+  constructor(options) {
+    this.options = options;
   }
-  async download(address) {
-    try {
-      const res = await fetch(address);
-      if (res.status >= 400) throw new Error(`failed with status code ${res.status}`);
-      return await res.text();
-    } catch (e) {
-      if (e instanceof Error) {
-        e.message = `Unable get the openapi/swagger file from ${address}: ${e.message}`;
+  apply(compiler) {
+    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
+      const plugins = [
+        new DownloadHttpFilePlugin(),
+        new DownloadLocalFilePlugin()
+      ];
+      if (this.options.build) {
+        plugins.push(new ShakingPlugin());
       }
-      throw e;
+      if (this.options.interactive) {
+        plugins.push(
+          new TerminalSelectPlugin(
+            typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
+          )
+        );
+      }
+      const rc = compiler.context.rc;
+      plugins.push(
+        ...R22.unnest(
+          (rc.translators || []).map((translator) => {
+            const plugins2 = translator.apply();
+            return plugins2;
+          })
+        )
+      );
+      if (rc.plugins && rc.plugins.length) {
+        plugins.push(...rc.plugins);
+      }
+      for (const plugin of plugins) {
+        plugin.apply(compiler);
+      }
+    });
+    if (this.options.includes && this.options.includes.length) {
+      const modulesIncludes = this.options.includes;
+      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
+        const rc = compiler.context.rc;
+        const matcher = compiler.context.matcher;
+        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
+        if (notExistModules.length) {
+          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
+        }
+        const ignoredModules = R22.difference(R22.keys(rc.modules), modulesIncludes);
+        for (const moduleName of ignoredModules) {
+          matcher.append({
+            persist: false,
+            ignore: true,
+            moduleName,
+            operationMethod: "*",
+            operationPathname: "*"
+          });
+        }
+      });
     }
   }
-  deserialize(content) {
-    const json = JSON.parse(content);
-    const spec = OpenapiUtils.to3_1(json);
-    return spec;
+};
+
+// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
+var QsArrayFormatUnion = Object.values(QsArrayFormat);
+
+// src/translators/micro-function.translator.ts
+var MicroFunctionTranslator = class {
+  apply() {
+    return [
+      new GenerateDeclarationPlugin(),
+      new GenerateMicroFunctionPlugin()
+    ];
   }
 };
 
-// src/plugins/download-local-file/download-local-file.plugin.ts
-import * as path12 from "path";
-import * as fs5 from "fs/promises";
-import * as yaml from "js-yaml";
-var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
-      if (!address.startsWith("./") && !address.startsWith("/") && !address.startsWith("../")) return void 0;
-      const fileExt = path12.extname(address);
-      const content = await fs5.readFile(address, "utf8");
-      if ([".yml", ".yaml"].includes(fileExt)) {
-        const value = yaml.load(content);
-        return JSON.stringify(OpenapiUtils.to3_1(value));
-      } else if (fileExt === ".json") {
-        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(content)));
+// src/compiler/tasks/setup/index.ts
+var explore = cosmiconfig("keq");
+function main(compiler, options) {
+  return {
+    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.");
+      }
+      const rc = parseRuntimeConfig(result.config);
+      if (options?.debug) {
+        await fs4.ensureDir(".keq");
+        rc.debug = true;
+      }
+      rc.tolerant = Boolean(rc.tolerant);
+      if (!rc.translators || !rc.translators.length) {
+        rc.translators = [new MicroFunctionTranslator()];
+      }
+      const packageJsonInfo = findNearestPackageJson();
+      if (packageJsonInfo) {
+        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
+        rc.esm = moduleSystem === "esm";
+      }
+      context.rc = rc;
+      let matcher = new IgnoreMatcher([]);
+      if (result.filepath) {
+        const ignoreFilepath = path10.resolve(path10.dirname(result.filepath), ".keqignore");
+        if (await fs4.exists(ignoreFilepath)) {
+          matcher = await IgnoreMatcher.read(ignoreFilepath);
+        }
+      }
+      const ignoreRules = options.ignore === false ? [] : options.ignore?.rules || [];
+      for (const rule of ignoreRules) {
+        matcher.append({
+          persist: !!rule.persist,
+          ignore: rule.ignore,
+          moduleName: rule.moduleName,
+          operationMethod: rule.operationMethod,
+          operationPathname: rule.operationPathname
+        });
+      }
+      context.matcher = matcher;
+      await compiler.hooks.setup.promise(task);
+    }
+  };
+}
+function createSetupTask(compiler, options) {
+  return {
+    title: "Setup",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main(compiler, options),
+        {
+          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/download/index.ts
+import { PRESET_TIMER } from "listr2";
+import { validate } from "@scalar/openapi-parser";
+function main2(compiler, options) {
+  return {
+    task: (context, task) => {
+      if (!context.rc || !context.matcher) {
+        throw new Error("Please run setup task first.");
+      }
+      const rc = context.rc;
+      const matcher = context.matcher;
+      context.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.url}`;
+            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
+            if (!content) {
+              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address.url}`);
+            }
+            const spec = JSON.parse(content);
+            const { valid, errors } = await validate(spec);
+            if (!valid) {
+              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
+${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
+              task2.output = message;
+            }
+            OpenapiUtils.dereferenceOperation(spec);
+            const document = new ApiDocumentV3_1(
+              spec,
+              moduleDefinition
+            );
+            ctx.documents?.push(document);
+          }
+        })),
+        {
+          concurrent: true,
+          exitOnError: false,
+          collectErrors: "minimal",
+          rendererOptions: {
+            collapseSubtasks: false,
+            // collapseSkips: false,
+            suffixSkips: true,
+            timer: PRESET_TIMER
+          }
+        }
+      );
+    }
+  };
+}
+function createDownloadTask(compiler, options) {
+  return {
+    title: "Download",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (_, task) => task.newListr(
+      [
+        main2(compiler, options),
+        {
+          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/compiler/tasks/persist/index.ts
+import * as path11 from "path";
+import fs5 from "fs-extra";
+function createPersistArtifactTask() {
+  return {
+    title: "Write files",
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.artifacts || context.artifacts.length === 0) {
+        task.skip("No compiled artifacts to persist.");
+        return;
+      }
+      const rc = context.rc;
+      const artifacts = context.artifacts;
+      const total = artifacts.length;
+      let completed = 0;
+      const files = await Promise.all(artifacts.map(async (artifact) => {
+        const realpath = `./${path11.join(rc.outdir, artifact.filepath)}`;
+        await fs5.ensureFile(realpath);
+        await fs5.writeFile(realpath, artifact.renderer());
+        completed += 1;
+        task.output = `Persisted ${completed}/${total} files`;
+        return new Asset(path11.resolve(realpath));
+      }));
+      context.assets = files;
+    }
+  };
+}
+function createPersistIgnoreTask() {
+  return {
+    title: "Update .keqignore",
+    task: async (context, task) => {
+      if (!context.matcher) throw new Error("Please run setup task first.");
+      const matcher = context.matcher;
+      await matcher.write(".keqignore");
+    }
+  };
+}
+function main3() {
+  return {
+    task: (context, task) => task.newListr(
+      [
+        createPersistArtifactTask(),
+        createPersistIgnoreTask()
+      ],
+      {
+        concurrent: true,
+        rendererOptions: {
+          collapseSubtasks: true
+        }
+      }
+    )
+  };
+}
+function createPersistTask(compiler, options) {
+  return {
+    title: "Persist",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main3(),
+        {
+          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
       }
-    });
-  }
-};
+    )
+  };
+}
 
-// src/plugins/shaking/shaking.plugin.ts
-import { openapiShakingSync } from "@opendoc/openapi-shaking";
-var ShakingPlugin = class _ShakingPlugin {
-  apply(compiler) {
-    compiler.hooks.beforeCompile.tap(_ShakingPlugin.name, (task) => {
-      const matcher = compiler.context.matcher;
-      const documents = compiler.context.documents;
-      compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleIgnored(document.module));
-    });
-  }
-  shaking(compiler, document) {
-    const rc = compiler.context.rc;
-    const matcher = compiler.context.matcher;
-    const isAccepted = (pathname, method, operation) => {
-      if (!SupportedMethods.includes(method)) return false;
-      return !matcher.isOperationIgnored(new OperationDefinition({
-        method,
-        pathname,
-        operation,
-        module: document.module,
-        document
-      }));
-    };
-    const sharkedSwagger = openapiShakingSync(
-      document.specification,
-      isAccepted,
-      { tolerant: rc.tolerant }
-    );
-    return new ApiDocumentV3_1(
-      sharkedSwagger,
-      new ModuleDefinition(
-        document.module.name,
-        `file://${document.module.name}.v3_1.sharked.json`
-      )
-    );
-  }
-};
+// src/compiler/tasks/compile/index.ts
+function main4(compiler) {
+  return {
+    task: async (context, task) => {
+      if (!context.rc) throw new Error("Please run setup task first.");
+      if (!context.documents) throw new Error("Please run shaking task first.");
+      context.artifacts = [];
+      await compiler.hooks.compile.promise(task);
+    }
+  };
+}
+function createCompileTask(compiler, options) {
+  return {
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        {
+          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
+        },
+        main4(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
-// src/plugins/terminal-select/utils/select-operation-definitions.ts
-import { select } from "inquirer-select-pro";
-import { ListrInquirerPromptAdapter } from "@listr2/prompt-adapter-inquirer";
-async function selectOperationDefinitions(task, operationDefinitions) {
-  const selectedOperationDefinitions = await task.prompt(ListrInquirerPromptAdapter).run(
-    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));
-        });
+// src/compiler/intercepter/print-information.ts
+function proxyTaskWrapper(pluginName, task) {
+  return new Proxy(task, {
+    set(target, prop2, value) {
+      if (prop2 !== "output") {
+        return Reflect.set(target, prop2, value);
       }
+      target.output = `[Plugin: ${pluginName}] ${value}`;
+      return true;
     }
-  );
-  return selectedOperationDefinitions;
+  });
 }
-
-// src/plugins/terminal-select/terminal-select.plugin.ts
-var TerminalSelectPlugin = class _TerminalSelectPlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
-      const context = compiler.context;
-      const matcher = context.matcher;
-      const documents = context.documents;
-      const operationDefinitions = documents.flatMap((document) => document.operations);
-      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
-      if (this.options.clear) {
-        matcher.append({
-          persist: false,
-          ignore: true,
-          moduleName: "*",
-          operationMethod: "*",
-          operationPathname: "*"
-        });
+function printInformation(taskIndex) {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      if (tap.type === "promise") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
       }
-      for (const op of selectedOperationDefinitions) {
-        matcher.append({
-          persist: !!this.options.persist,
-          ignore: this.options.mode === "add",
-          moduleName: op.module.name,
-          operationMethod: op.method,
-          operationPathname: op.pathname
-        });
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
       }
-    });
-  }
-};
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const task = args[taskIndex];
+          const proxyTask = proxyTaskWrapper(tap.name, task);
+          args[taskIndex] = proxyTask;
+          proxyTask.output = "Processing...";
+          return fn(...args);
+        };
+      }
+      return tap;
+    }
+  };
+}
 
-// src/plugins/initialize/initialize.plugin.ts
+// src/compiler/intercepter/perfect-error-message.ts
 import * as R23 from "ramda";
-var InitializePlugin = class _InitializePlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
-      new DownloadHttpFilePlugin().apply(compiler);
-      new DownloadLocalFilePlugin().apply(compiler);
-      new GenerateDeclarationPlugin().apply(compiler);
-      if (this.options.build) {
-        new ShakingPlugin().apply(compiler);
-      }
-      if (this.options.interactive) {
-        new TerminalSelectPlugin(
-          typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
-        ).apply(compiler);
+function perfectErrorMessage() {
+  return {
+    register: (tap) => {
+      const fn = tap.fn;
+      function prefix(err) {
+        if (err instanceof Error) {
+          err.message = `[Plugin: ${tap.name}] ${err.message}`;
+        }
       }
-      const rc = compiler.context.rc;
-      if (rc.mode === "micro-function") {
-        new GenerateMicroFunctionPlugin().apply(compiler);
-      } else if (rc.mode === "nestjs-module") {
-        new GenerateNestjsModulePlugin().apply(compiler);
+      if (tap.type === "promise") {
+        tap.fn = async (...args) => {
+          try {
+            return await fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
       }
-      if (rc.plugins && rc.plugins.length) {
-        for (const plugin of rc.plugins) {
-          plugin.apply(compiler);
-        }
+      if (tap.type === "sync") {
+        tap.fn = (...args) => {
+          try {
+            return fn(...args);
+          } catch (err) {
+            prefix(err);
+            throw err;
+          }
+        };
       }
-    });
-    if (this.options.includes && this.options.includes.length) {
-      const modulesIncludes = this.options.includes;
-      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
-        const rc = compiler.context.rc;
-        const matcher = compiler.context.matcher;
-        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
-        if (notExistModules.length) {
-          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
-        }
-        const ignoredModules = R23.difference(R23.keys(rc.modules), modulesIncludes);
-        for (const moduleName of ignoredModules) {
-          matcher.append({
-            persist: false,
-            ignore: true,
-            moduleName,
-            operationMethod: "*",
-            operationPathname: "*"
+      if (tap.type === "async") {
+        tap.fn = (...args) => {
+          const callback = R23.last(args);
+          return fn(...R23.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
           });
-        }
-      });
+        };
+      }
+      return tap;
     }
-  }
-};
-
-// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
-var QsArrayFormatUnion = Object.values(QsArrayFormat);
+  };
+}
 
 // src/compiler/compiler.ts
 var Compiler = class {
@@ -2801,8 +2749,7 @@ export {
   ModuleDefinition,
   OperationDefinition,
   QsArrayFormat,
-  RuntimeConfig,
   SchemaDefinition,
-  defineKeqConfig
+  defineConfig
 };
 //# sourceMappingURL=index.js.map