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

package/dist/plugins.cjs

@@ -57,14 +57,21 @@ __export(plugins_exports, {
 });
 module.exports = __toCommonJS(plugins_exports);
 
-// src/plugins/eslint/index.ts
+// src/plugins/eslint/eslint.plugin.ts
 var import_eslint = require("eslint");
+
+// src/plugins/eslint/constants/metadata-storage.ts
+var MetadataStorage = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/eslint/eslint.plugin.ts
 var EslintPlugin = class _EslintPlugin {
   constructor(options = {}) {
     this.options = options;
   }
   apply(compiler) {
     if (!compiler.options.build) return;
+    if (MetadataStorage.has(compiler)) return;
+    _EslintPlugin.register(compiler);
     if (this.options.disable && this.options.disable.length > 0) {
       const $rules = [
         ...this.options.disable.map((rule) => `/* eslint-disable ${rule} */`)
@@ -84,15 +91,33 @@ var EslintPlugin = class _EslintPlugin {
       await import_eslint.ESLint.outputFixes(results);
     });
   }
+  static register(compiler) {
+    if (!MetadataStorage.has(compiler)) {
+      MetadataStorage.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
 // src/plugins/prettier/prettier.plugin.ts
 var import_child_process = require("child_process");
 var import_util = require("util");
+
+// src/plugins/prettier/constants/metadata-storage.ts
+var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/prettier/prettier.plugin.ts
 var execAsync = (0, import_util.promisify)(import_child_process.exec);
 var PrettierPlugin = class _PrettierPlugin {
   apply(compiler) {
     if (!compiler.options.build) return;
+    if (MetadataStorage2.has(compiler)) return;
+    _PrettierPlugin.register(compiler);
     compiler.hooks.afterPersist.tapPromise(_PrettierPlugin.name, async () => {
       const files = compiler.context.assets || [];
       if (files.length === 0) return;
@@ -100,6 +125,17 @@ var PrettierPlugin = class _PrettierPlugin {
       await execAsync(`prettier --write ${filePaths}`);
     });
   }
+  static register(compiler) {
+    if (!MetadataStorage2.has(compiler)) {
+      MetadataStorage2.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage2.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
 // src/plugins/body-fallback/index.ts
@@ -137,7 +173,7 @@ var JsonSchemaUtils = class {
 var import_tapable2 = require("tapable");
 
 // src/plugins/generate-micro-function/constants/metadata-storage.ts
-var MetadataStorage = /* @__PURE__ */ new WeakMap();
+var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
 
 // src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
 var R18 = __toESM(require("ramda"), 1);
@@ -251,10 +287,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" });
   }
 };
 
@@ -1565,14 +1605,14 @@ var path5 = __toESM(require("path"), 1);
 var changeCase4 = __toESM(require("change-case"), 1);
 
 // 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);
@@ -1645,7 +1685,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`;
@@ -1668,7 +1708,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);
@@ -1743,7 +1783,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}`;
   }
 };
 
@@ -1756,6 +1796,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(
@@ -1765,8 +1806,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 import_tapable.AsyncSeriesWaterfallHook(["artifact", "task"]),
           afterSchemaDeclarationArtifactGenerated: new import_tapable.AsyncSeriesWaterfallHook(["artifact", "schemaDefinition", "task"]),
@@ -1774,7 +1815,7 @@ var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
         }
       });
     }
-    return MetadataStorage2.get(compiler);
+    return MetadataStorage4.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
@@ -1819,7 +1860,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;
@@ -1922,6 +1963,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 = [
@@ -1932,24 +1974,29 @@ var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage.has(compiler)) {
-      MetadataStorage.set(compiler, {
+    if (!MetadataStorage3.has(compiler)) {
+      MetadataStorage3.set(compiler, {
         hooks: {
           afterEntrypointArtifactGenerated: new import_tapable2.AsyncSeriesWaterfallHook(["artifact", "task"]),
           afterMicroFunctionArtifactGenerated: new import_tapable2.AsyncSeriesWaterfallHook(["artifact", "operationDefinition", "task"])
         }
       });
     }
-    return MetadataStorage.get(compiler);
+    return MetadataStorage3.get(compiler);
   }
   static of(compiler) {
     return this.register(compiler);
   }
 };
 
+// src/plugins/body-fallback/constants/metadata-storage.ts
+var MetadataStorage5 = /* @__PURE__ */ new WeakMap();
+
 // src/plugins/body-fallback/index.ts
 var BodyFallbackPlugin = class _BodyFallbackPlugin {
   apply(compiler) {
+    if (MetadataStorage5.has(compiler)) return;
+    _BodyFallbackPlugin.register(compiler);
     compiler.hooks.setup.tap(_BodyFallbackPlugin.name, () => {
       const generateMicroFunctionPluginMetadata = GenerateMicroFunctionPlugin.of(compiler);
       if (!generateMicroFunctionPluginMetadata) {
@@ -1982,13 +2029,24 @@ var BodyFallbackPlugin = class _BodyFallbackPlugin {
       });
     });
   }
+  static register(compiler) {
+    if (!MetadataStorage5.has(compiler)) {
+      MetadataStorage5.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage5.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
 // src/plugins/generate-nestjs-module/generate-nestjs-module.ts
 var import_tapable3 = require("tapable");
 
 // src/plugins/generate-nestjs-module/constants/metadata-storage.ts
-var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
+var MetadataStorage6 = /* @__PURE__ */ new WeakMap();
 
 // src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
 var path8 = __toESM(require("path"), 1);
@@ -2034,7 +2092,7 @@ var NestjsModuleGenerator = class _NestjsModuleGenerator {
     return artifact;
   }
   async compile(compiler, task) {
-    const metadata = MetadataStorage3.get(compiler);
+    const metadata = MetadataStorage6.get(compiler);
     const rc = compiler.context.rc;
     const documents = compiler.context.documents;
     const nestjsModuleArtifacts = await Promise.all(
@@ -2083,6 +2141,7 @@ var NestjsModuleGenerator = class _NestjsModuleGenerator {
 var GenerateNestjsModulePlugin = class _GenerateNestjsModulePlugin {
   nestjsModuleGenerator = new NestjsModuleGenerator();
   apply(compiler) {
+    if (MetadataStorage6.has(compiler)) return;
     _GenerateNestjsModulePlugin.register(compiler);
     compiler.hooks.compile.tapPromise(_GenerateNestjsModulePlugin.name, async (task) => {
       const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
@@ -2090,24 +2149,31 @@ var GenerateNestjsModulePlugin = class _GenerateNestjsModulePlugin {
     });
   }
   static register(compiler) {
-    if (!MetadataStorage3.has(compiler)) {
-      MetadataStorage3.set(compiler, {
+    if (!MetadataStorage6.has(compiler)) {
+      MetadataStorage6.set(compiler, {
         hooks: {
           afterNestjsModuleArtifactGenerated: new import_tapable3.AsyncSeriesWaterfallHook(["artifact", "document", "task"])
         }
       });
     }
-    return MetadataStorage3.get(compiler);
+    return MetadataStorage6.get(compiler);
   }
   static of(compiler) {
-    return MetadataStorage3.get(compiler);
+    return MetadataStorage6.get(compiler);
   }
 };
 
 // src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
 var import_swagger_fix = require("swagger-fix");
+
+// src/plugins/chinese-to-pinyin/constants/metadata-storage.ts
+var MetadataStorage7 = /* @__PURE__ */ new WeakMap();
+
+// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
 var ChineseToPinyinPlugin = class _ChineseToPinyinPlugin {
   apply(compiler) {
+    if (MetadataStorage7.has(compiler)) return;
+    _ChineseToPinyinPlugin.register(compiler);
     compiler.hooks.afterDownload.tap(_ChineseToPinyinPlugin.name, (task) => {
       const documents = compiler.context.documents;
       compiler.context.documents = documents.map((doc) => {
@@ -2118,27 +2184,44 @@ var ChineseToPinyinPlugin = class _ChineseToPinyinPlugin {
       });
     });
   }
+  static register(compiler) {
+    if (!MetadataStorage7.has(compiler)) {
+      MetadataStorage7.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage7.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
+// 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 validUrl = __toESM(require("valid-url"), 1);
 var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
   apply(compiler) {
+    if (MetadataStorage8.has(compiler)) return;
+    _DownloadHttpFilePlugin.register(compiler);
     compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
-      if (!validUrl.isUri(address)) return void 0;
+      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);
     });
   }
   async download(address) {
+    const { url, headers } = address;
     try {
-      const res = await fetch(address);
+      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 ${address}: ${e.message}`;
+        e.message = `Unable get the openapi/swagger file from ${url}: ${e.message}`;
       }
       throw e;
     }
@@ -2148,32 +2231,72 @@ var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
     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
 var path9 = __toESM(require("path"), 1);
 var fs = __toESM(require("fs/promises"), 1);
 var yaml = __toESM(require("js-yaml"), 1);
+var import_url = require("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) => {
-      if (!address.startsWith("./") && !address.startsWith("/") && !address.startsWith("../")) return void 0;
-      const fileExt = path9.extname(address);
-      const content = await fs.readFile(address, "utf8");
+      const { url, encoding } = address;
+      if (!url.startsWith("file://")) return void 0;
+      const filepath = (0, import_url.fileURLToPath)(url);
+      const fileExt = path9.extname(filepath);
+      const content = await fs.readFile(filepath, encoding);
+      const str = typeof content === "string" ? content : content.toString(encoding);
       if ([".yml", ".yaml"].includes(fileExt)) {
-        const value = yaml.load(content);
+        const value = yaml.load(str);
         return JSON.stringify(OpenapiUtils.to3_1(value));
       } else if (fileExt === ".json") {
-        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(content)));
+        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(str)));
       }
     });
   }
+  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
 var import_openapi_shaking = require("@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;
@@ -2202,10 +2325,25 @@ var ShakingPlugin = class _ShakingPlugin {
       sharkedSwagger,
       new ModuleDefinition(
         document.module.name,
-        `file://${document.module.name}.v3_1.sharked.json`
+        {
+          url: `memory://${document.module.name}.v3_1.sharked.json`,
+          headers: {},
+          encoding: "utf8"
+        }
       )
     );
   }
+  static register(compiler) {
+    if (!MetadataStorage10.has(compiler)) {
+      MetadataStorage10.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage10.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
 // src/plugins/terminal-select/utils/select-operation-definitions.ts
@@ -2231,12 +2369,17 @@ async function selectOperationDefinitions(task, operationDefinitions) {
   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) {
+    if (MetadataStorage11.has(compiler)) return;
+    _TerminalSelectPlugin.register(compiler);
     compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
       const context = compiler.context;
       const matcher = context.matcher;
@@ -2263,6 +2406,17 @@ var TerminalSelectPlugin = class _TerminalSelectPlugin {
       }
     });
   }
+  static register(compiler) {
+    if (!MetadataStorage11.has(compiler)) {
+      MetadataStorage11.set(compiler, {
+        hooks: {}
+      });
+    }
+    return MetadataStorage11.get(compiler);
+  }
+  static of(compiler) {
+    return this.register(compiler);
+  }
 };
 
 // src/plugins/initialize/initialize.plugin.ts
@@ -2273,27 +2427,34 @@ var InitializePlugin = class _InitializePlugin {
   }
   apply(compiler) {
     compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
-      new DownloadHttpFilePlugin().apply(compiler);
-      new DownloadLocalFilePlugin().apply(compiler);
-      new GenerateDeclarationPlugin().apply(compiler);
+      const plugins = [
+        new DownloadHttpFilePlugin(),
+        new DownloadLocalFilePlugin()
+      ];
       if (this.options.build) {
-        new ShakingPlugin().apply(compiler);
+        plugins.push(new ShakingPlugin());
       }
       if (this.options.interactive) {
-        new TerminalSelectPlugin(
-          typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
-        ).apply(compiler);
+        plugins.push(
+          new TerminalSelectPlugin(
+            typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
+          )
+        );
       }
       const rc = compiler.context.rc;
-      if (rc.mode === "micro-function") {
-        new GenerateMicroFunctionPlugin().apply(compiler);
-      } else if (rc.mode === "nestjs-module") {
-        new GenerateNestjsModulePlugin().apply(compiler);
-      }
+      plugins.push(
+        ...R20.unnest(
+          (rc.translators || []).map((translator) => {
+            const plugins2 = translator.apply();
+            return plugins2;
+          })
+        )
+      );
       if (rc.plugins && rc.plugins.length) {
-        for (const plugin of rc.plugins) {
-          plugin.apply(compiler);
-        }
+        plugins.push(...rc.plugins);
+      }
+      for (const plugin of plugins) {
+        plugin.apply(compiler);
       }
     });
     if (this.options.includes && this.options.includes.length) {