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

package/dist/chunk-XRZLO2PB.js

@@ -0,0 +1,670 @@
+import {
+  MicroFunctionTranslator
+} from "./chunk-HN7ZZFKC.js";
+import {
+  ApiDocumentV3_1,
+  Asset,
+  Exception,
+  FileNamingStyle,
+  InitializePlugin,
+  ModuleDefinition,
+  OpenapiUtils
+} from "./chunk-DZ2SC5HL.js";
+
+// src/compiler/compiler.ts
+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 { cosmiconfig } from "cosmiconfig";
+
+// src/utils/ignore-matcher.ts
+import * as R from "ramda";
+import fs from "fs-extra";
+var IgnoreMatcher = class _IgnoreMatcher {
+  rules;
+  constructor(rules) {
+    this.rules = rules;
+  }
+  static async read(filepath) {
+    let content = await fs.readFile(filepath, "utf-8");
+    content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/#.*$/gm, "").replace(/\n+/g, "\n").trim();
+    let rules = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+      const matched = line.match(/^(!)?\s*([^\s/]+)\s+([^\s/]+)\s+([^\s]+)$/);
+      if (!matched) throw new Error(`Invalid ignore rule: "${line}"`);
+      const [, flag, moduleName, operationMethod, operationPathname] = matched;
+      return {
+        persist: true,
+        ignore: !flag,
+        moduleName,
+        operationMethod: operationMethod.toLowerCase(),
+        operationPathname
+      };
+    });
+    rules = R.sortBy(
+      R.prop("ignore"),
+      rules
+    );
+    rules = R.uniqWith(
+      (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname,
+      rules
+    );
+    return new _IgnoreMatcher(rules);
+  }
+  async write(filepath) {
+    const ruleGroups = R.compose(
+      R.groupBy((rule) => rule.moduleName),
+      R.reverse,
+      R.uniqWith(
+        (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname
+      ),
+      R.filter((rule) => rule.persist)
+    )(this.rules);
+    const content = Object.entries(ruleGroups).sort((a, b) => {
+      const aModuleName = a[0];
+      const bModuleName = b[0];
+      if (aModuleName === "*") return -1;
+      if (bModuleName === "*") return 1;
+      return aModuleName.localeCompare(bModuleName);
+    }).map(([, rules]) => (rules || []).sort((a, b) => {
+      if (a.ignore !== b.ignore) return a.ignore ? -1 : 1;
+      if (a.operationMethod === "*") return -1;
+      if (b.operationMethod === "*") return 1;
+      if (a.operationPathname === "*") return -1;
+      if (b.operationPathname === "*") return 1;
+      if (a.operationMethod !== b.operationMethod) return a.operationMethod.localeCompare(b.operationMethod);
+      if (a.operationPathname !== b.operationPathname) return a.operationPathname.localeCompare(b.operationPathname);
+      return 0;
+    }).map((rule) => `${rule.ignore ? "" : "! "}${rule.moduleName} ${rule.operationMethod.toUpperCase()} ${rule.operationPathname}`).join("\n")).join("\n\n");
+    await fs.writeFile(filepath, content, "utf-8");
+  }
+  append(rule) {
+    this.rules.unshift(rule);
+  }
+  // if operation is ignored, return true
+  isOperationIgnored(operationDefinition) {
+    const moduleName = operationDefinition.module.name;
+    const operationMethod = operationDefinition.method.toLowerCase();
+    const operationPathname = operationDefinition.pathname;
+    for (const rule of this.rules) {
+      if (rule.moduleName !== "*" && rule.moduleName !== moduleName) continue;
+      if (rule.operationMethod !== "*" && rule.operationMethod !== operationMethod) continue;
+      if (rule.operationPathname !== "*" && rule.operationPathname !== operationPathname) continue;
+      return rule.ignore;
+    }
+    return false;
+  }
+  isModuleIgnored(moduleDefinition) {
+    const moduleName = moduleDefinition.name;
+    for (const rule of this.rules) {
+      if (!rule.ignore) {
+        if (rule.moduleName === "*" || rule.moduleName === moduleName) return false;
+        continue;
+      }
+      if (rule.operationMethod !== "*") continue;
+      if (rule.operationPathname !== "*") continue;
+      if (rule.moduleName === "*" || rule.moduleName === moduleName) return true;
+    }
+    return false;
+  }
+};
+
+// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
+import fs2 from "fs";
+import path from "path";
+function findNearestPackageJson(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs2.existsSync(pkgPath)) {
+      const json = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      return { json, path: pkgPath };
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/compiler/tasks/setup/utils/get-project-module-system.ts
+function getProjectModuleSystem(pkgInfo) {
+  if (!pkgInfo?.json) return "cjs";
+  const { json } = pkgInfo;
+  if (json.type === "module") return "esm";
+  return "cjs";
+}
+
+// src/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 keys = Object.keys(value);
+  for (const key of keys) {
+    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, keys);
+  for (const groupKey in keysGroupByLowerCase) {
+    const keys2 = keysGroupByLowerCase[groupKey] || [];
+    if (keys2.length > 1) {
+      throw new Error(`Module names ${keys2.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;
+  }
+}
+
+// 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 fs3.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 = 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);
+    }
+  };
+}
+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 path3 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 = `./${path3.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(path3.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 R3 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 = R3.last(args);
+          return fn(...R3.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
+          });
+        };
+      }
+      return tap;
+    }
+  };
+}
+
+// src/compiler/compiler.ts
+var Compiler = class {
+  constructor(options) {
+    this.options = options;
+    for (const hook of Object.values(this.hooks)) {
+      hook.intercept(perfectErrorMessage());
+    }
+    this.hooks.afterSetup.intercept(printInformation(0));
+    this.hooks.afterPersist.intercept(printInformation(0));
+    new InitializePlugin({
+      build: options.build,
+      interactive: options.interactive,
+      includes: options.includes
+    }).apply(this);
+  }
+  context = {};
+  hooks = {
+    setup: new AsyncParallelHook(["task"]),
+    afterSetup: new AsyncSeriesHook(["task"]),
+    beforeDownload: new AsyncSeriesHook(["task"]),
+    download: new AsyncSeriesBailHook(["address", "moduleDefinition", "task"]),
+    afterDownload: new AsyncSeriesHook(["task"]),
+    beforeCompile: new AsyncSeriesHook(["task"]),
+    compile: new AsyncParallelHook(["task"]),
+    afterCompile: new AsyncSeriesHook(["task"]),
+    beforePersist: new AsyncSeriesHook(["task"]),
+    persist: new AsyncParallelHook(["task"]),
+    afterPersist: new AsyncSeriesHook(["task"]),
+    done: new SyncHook()
+  };
+  async run() {
+    const options = this.options;
+    const tasks = new Listr(
+      [
+        createSetupTask(this, options),
+        createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
+        createCompileTask(this, { enabled: !!options.build }),
+        createPersistTask(this, { enabled: !!options.persist })
+      ],
+      {
+        concurrent: false,
+        renderer: options.silent ? "silent" : "default",
+        rendererOptions: {
+          suffixSkips: true,
+          collapseSubtasks: false,
+          collapseErrors: false
+        }
+      }
+    );
+    await tasks.run(this.context);
+    await this.hooks.done.promise();
+  }
+};
+
+export {
+  Compiler
+};
+//# sourceMappingURL=chunk-XRZLO2PB.js.map