@keq-request/cli 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/index.js

@@ -1,12 +1,7 @@
-// src/tasks/index.ts
-import { Listr } from "listr2";
-
-// src/tasks/setup/index.ts
-import * as R3 from "ramda";
-import fs3 from "fs-extra";
-import path2 from "path";
-import { Value } from "@sinclair/typebox/value";
-import { cosmiconfig } from "cosmiconfig";
+// src/define-keq-config.ts
+function defineKeqConfig(config) {
+  return config;
+}
 
 // src/types/runtime-config.ts
 import { Type as Type2 } from "@sinclair/typebox";
@@ -75,9 +70,21 @@ var RuntimeConfig = Type2.Object({
   /**
    * Whether to tolerate wrong swagger structure
    */
-  tolerant: Type2.Optional(Type2.Boolean({ default: false }))
+  tolerant: Type2.Optional(Type2.Boolean({ default: false })),
+  plugins: Type2.Optional(Type2.Array(Type2.Any(), { default: [] }))
 });
 
+// src/compiler/compiler.ts
+import { AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } from "tapable";
+import { Listr } from "listr2";
+
+// src/tasks/setup/index.ts
+import * as R3 from "ramda";
+import fs3 from "fs-extra";
+import path2 from "path";
+import { Value } from "@sinclair/typebox/value";
+import { cosmiconfig } from "cosmiconfig";
+
 // src/utils/ignore-matcher.ts
 import * as R from "ramda";
 import fs from "fs-extra";
@@ -226,9 +233,8 @@ function getProjectModuleSystem(pkgInfo) {
 
 // src/tasks/setup/index.ts
 var explore = cosmiconfig("keq");
-function createSetupTask(options) {
+function main(compiler, options) {
   return {
-    title: "Setup",
     task: async (context, task) => {
       const result = options?.config ? await explore.load(options.config) : await explore.search();
       if (!result || "isEmpty" in result && result.isEmpty) {
@@ -253,13 +259,23 @@ function createSetupTask(options) {
         const moduleSystem = getProjectModuleSystem(packageJsonInfo);
         rc.esm = moduleSystem === "esm";
       }
-      let filter2 = new IgnoreMatcher([]);
+      let matcher = new IgnoreMatcher([]);
       if (result.filepath) {
         const ignoreFilepath = path2.resolve(path2.dirname(result.filepath), ".keqignore");
         if (await fs3.exists(ignoreFilepath)) {
-          filter2 = await IgnoreMatcher.read(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
+        });
+      }
       if (options?.modules && options.modules.length) {
         const notExistModules = options.modules.filter((moduleName) => !(moduleName in rc.modules));
         if (notExistModules.length) {
@@ -267,7 +283,7 @@ function createSetupTask(options) {
         }
         const ignoredModules = R3.difference(R3.keys(rc.modules), options.modules);
         for (const moduleName of ignoredModules) {
-          filter2.append({
+          matcher.append({
             persist: false,
             ignore: true,
             moduleName,
@@ -276,10 +292,33 @@ function createSetupTask(options) {
           });
         }
       }
-      context.setup = { rc, matcher: filter2 };
+      context.setup = { rc, matcher };
+      if (rc.plugins && rc.plugins.length) {
+        for (const plugin of rc.plugins) {
+          plugin.apply(compiler);
+        }
+      }
     }
   };
 }
+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/tasks/download/index.ts
 import { PRESET_TIMER } from "listr2";
@@ -492,7 +531,7 @@ var logger = {
 };
 
 // src/tasks/utils/api-document_v3_1.ts
-import OpenapiShaking from "@opendoc/openapi-shaking";
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
 var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   module;
   swagger;
@@ -548,7 +587,7 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
       });
       return filter2(operationDefinition);
     };
-    const sharkedSwagger = OpenapiShaking.openapiShakingSync(
+    const sharkedSwagger = openapiShakingSync(
       this.swagger,
       isAccepted,
       { tolerant: true }
@@ -742,8 +781,8 @@ function dereferenceDeep($ref, swagger) {
   const stack = [$ref];
   let value;
   while (true) {
-    const last = stack[stack.length - 1];
-    value = dereference(last, swagger);
+    const last2 = stack[stack.length - 1];
+    value = dereference(last2, swagger);
     if (JsonSchemaUtils.isRef(value)) {
       if (!stack.includes(value.$ref)) {
         stack.push(value.$ref);
@@ -854,11 +893,8 @@ var ApiDocument = class _ApiDocument {
 };
 
 // src/tasks/download/index.ts
-function createDownloadTask(options) {
+function main2(compiler, options) {
   return {
-    title: "Download",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: (context, task) => {
       if (!context.setup) {
         throw new Error("Please run setup task first.");
@@ -896,13 +932,28 @@ function createDownloadTask(options) {
     }
   };
 }
-
-// src/tasks/validate/index.ts
-function createValidateTask(options) {
+function createDownloadTask(compiler, options) {
   return {
-    title: "Validate",
+    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/tasks/validate/index.ts
+function main3() {
+  return {
     task: (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.downloaded) throw new Error("Please run download task first.");
@@ -939,13 +990,28 @@ ${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
     }
   };
 }
-
-// src/tasks/shaking/index.ts
-function createShakingTask(options) {
+function createValidateTask(compiler, options) {
   return {
-    title: "Shaking",
+    title: "Validate",
     enabled: options?.enabled,
     skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main3(),
+        {
+          task: (context2, task2) => compiler.hooks.afterValidate.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/tasks/shaking/index.ts
+function main4(compiler, options) {
+  return {
     task: (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.validated) throw new Error("Please run validate task first.");
@@ -983,15 +1049,31 @@ function createShakingTask(options) {
     }
   };
 }
+function createShakingTask(compiler, options) {
+  return {
+    title: "Shaking",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main4(compiler, options),
+        {
+          task: (context2, task2) => compiler.hooks.afterShaking.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
 // src/tasks/persist/index.ts
 import * as path6 from "path";
 import fs6 from "fs-extra";
-function createPersistArtifactTask(options) {
+function createPersistArtifactTask() {
   return {
     title: "Write files",
-    enabled: options?.persistArtifacts,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.compiled) throw new Error("Please run compile task first.");
@@ -1002,21 +1084,21 @@ function createPersistArtifactTask(options) {
       }
       const total = artifacts.length;
       let completed = 0;
-      await Promise.all(artifacts.map(async (artifact) => {
+      const files = await Promise.all(artifacts.map(async (artifact) => {
         const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
         await fs6.ensureFile(realpath);
         await fs6.writeFile(realpath, artifact.toCode({ esm: !!rc.esm }));
         completed += 1;
         task.output = `Persisted ${completed}/${total} files`;
+        return { path: path6.resolve(realpath) };
       }));
+      context.persisted = { files };
     }
   };
 }
-function createPersistIgnoreTask(options) {
+function createPersistIgnoreTask() {
   return {
     title: "Update .keqignore",
-    enabled: options?.persistIgnore,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       const matcher = context.setup.matcher;
@@ -1024,15 +1106,12 @@ function createPersistIgnoreTask(options) {
     }
   };
 }
-function createPersistTask(options) {
+function main5() {
   return {
-    title: "Persist",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: (context, task) => task.newListr(
       [
-        createPersistArtifactTask(options),
-        createPersistIgnoreTask(options)
+        createPersistArtifactTask(),
+        createPersistIgnoreTask()
       ],
       {
         concurrent: true,
@@ -1043,8 +1122,29 @@ function createPersistTask(options) {
     )
   };
 }
+function createPersistTask(compiler, options) {
+  return {
+    title: "Persist",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main5(),
+        {
+          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
 // src/tasks/compile/utils/compile-schema-definition.ts
+import * as R14 from "ramda";
+
+// src/renderer/json-schema/index.ts
 import * as R12 from "ramda";
 
 // src/renderer/utils/generate-schema.ts
@@ -1170,14 +1270,102 @@ async function jsonSchemaRenderer(schemaDefinition) {
   let $comment = generateComment(schemaDefinition.schema);
   if ($comment) $comment += "\n";
   if (typeof schemaDefinition.schema === "boolean") {
-    return `${$comment}type ${schemaDefinition.name} = unknown`;
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $comment || void 0,
+      `type ${schemaDefinition.name} = unknown`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R12.isNotNil).join("\n");
   }
   if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-    return `${$comment}export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`;
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $comment || void 0,
+      `export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R12.isNotNil).join("\n");
   }
-  return `${$comment}export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`;
+  return [
+    "/* @anchor:file:start */",
+    "",
+    $comment || void 0,
+    `export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`,
+    "",
+    "/* @anchor:file:end */"
+  ].filter(R12.isNotNil).join("\n");
 }
 
+// src/tasks/utils/anchor.ts
+var AnchorBlock = class {
+  constructor(artifact) {
+    this.artifact = artifact;
+  }
+  /**
+   * Append content to the end of the anchor block.
+   */
+  append(anchorName, content) {
+    const lines = this.artifact.content.split("\n");
+    const anchor = `@anchor:${anchorName}:end`;
+    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
+    if (anchorIndex === -1) {
+      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
+    }
+    lines.splice(anchorIndex, 0, content);
+    this.artifact.content = lines.join("\n");
+  }
+  prepend(anchorName, content) {
+    const lines = this.artifact.content.split("\n");
+    const anchor = `@anchor:${anchorName}:start`;
+    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
+    if (anchorIndex === -1) {
+      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
+    }
+    lines.splice(anchorIndex + 1, 0, content);
+    this.artifact.content = lines.join("\n");
+  }
+  replace(anchorName, content) {
+    const lines = this.artifact.content.split("\n");
+    const startIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:start */`));
+    const endIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:end */`));
+    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+      throw new Error(`"@anchor:${anchorName}:start" or "@anchor:${anchorName}:end" not found in artifact "${this.artifact.filepath}".`);
+    }
+    lines.splice(startIndex + 1, endIndex - startIndex - 1, content);
+    this.artifact.content = lines.join("\n");
+  }
+};
+var Anchor = class {
+  constructor(artifact) {
+    this.artifact = artifact;
+    this.block = new AnchorBlock(artifact);
+  }
+  block;
+  append(anchorName, content) {
+    const lines = this.artifact.content.split("\n");
+    const anchor = `@anchor:${anchorName}`;
+    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
+    if (anchorIndex === -1) {
+      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
+    }
+    lines.splice(anchorIndex + 1, 0, content);
+    this.artifact.content = lines.join("\n");
+  }
+  prepend(anchorName, content) {
+    const lines = this.artifact.content.split("\n");
+    const anchor = `@anchor:${anchorName}`;
+    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
+    if (anchorIndex === -1) {
+      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
+    }
+    lines.splice(anchorIndex, 0, content);
+    this.artifact.content = lines.join("\n");
+  }
+};
+
 // src/tasks/utils/artifact.ts
 import * as path8 from "path";
 import * as changeCase from "change-case";
@@ -1262,6 +1450,7 @@ var Artifact = class {
   warns = [];
   content;
   extensionName;
+  anchor = new Anchor(this);
   constructor(options) {
     this.id = options.id;
     this.filepath = options.filepath;
@@ -1318,6 +1507,10 @@ var Artifact = class {
   }
 };
 
+// src/tasks/utils/json-schema.ts
+import * as R13 from "ramda";
+import { JSONPath as JSONPath5 } from "jsonpath-plus";
+
 // src/tasks/compile/utils/compile-schema-definition.ts
 function genSchemaDefinitionFilepath(schemaDefinition) {
   const filename = `${schemaDefinition.name}.schema.ts`;
@@ -1342,17 +1535,18 @@ var isArtifactCompiledBy = function(schemaDefinition) {
   return (artifact) => artifact.id === genSchemaDefinitionFilepath(schemaDefinition);
 };
 async function compileSchemaDefinition(options) {
-  const { schemaDefinitions } = options;
+  const { task, compiler, schemaDefinitions } = options;
   const artifacts = await Promise.all(
     schemaDefinitions.map(async (schemaDefinition) => {
       const content = await jsonSchemaRenderer(schemaDefinition);
       const filepath = genSchemaDefinitionFilepath(schemaDefinition);
-      return new Artifact({
+      const artifact = new Artifact({
         id: filepath,
         filepath,
         content,
         extensionName: ".schema.ts"
       });
+      return await compiler.hooks.afterCompileSchema.promise(artifact, schemaDefinition, task);
     })
   );
   for (const schemaDefinition of schemaDefinitions) {
@@ -1368,7 +1562,7 @@ async function compileSchemaDefinition(options) {
       artifact.addDependence(dependentArtifact, [dependentSchemaDefinition.name]);
     }
   }
-  const schemaDefinitionsGroupByModuleName = R12.groupBy(
+  const schemaDefinitionsGroupByModuleName = R14.groupBy(
     (schemaDefinition) => schemaDefinition.module.name,
     schemaDefinitions
   );
@@ -1393,41 +1587,93 @@ async function compileSchemaDefinition(options) {
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
-import * as R15 from "ramda";
+import * as R17 from "ramda";
 
 // src/renderer/operation-type/index.ts
-import * as R13 from "ramda";
+import * as R15 from "ramda";
 import * as changeCase2 from "change-case";
 function typeNameFactory(operationDefinition) {
   const pascalCaseOperationId = changeCase2.pascalCase(operationDefinition.operationId);
   return (name) => `${pascalCaseOperationId}${name}`;
 }
-async function operationTypeRenderer(operationDefinition, alias = R13.identity) {
-  const { operation } = operationDefinition;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
+function responseBodies(operation, alias = R15.identity, typeName) {
+  if (!operation.responses || R15.isEmpty(operation.responses)) {
+    return `export interface ${typeName("ResponseBodies")} {}`;
+  }
   const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
     if (!JsonSchemaUtils.isRef(response)) {
       const $value = Object.values(response.content || {}).map((mediaTypeObject) => mediaTypeObject.schema).filter((schema) => !!schema).map((schema) => generateSchema(schema, alias)).join(" | ");
       return indent(2, `${statusCode}: ${$value || "void"}`);
     }
   }).join("\n");
-  let $requestBody = `export type ${typeName("RequestBody")} = {}`;
+  return [
+    `export interface ${typeName("ResponseBodies")} {`,
+    $responses,
+    "}"
+  ].join("\n");
+}
+function requestBodies(operation, alias = R15.identity, typeName) {
+  let $requestBodies = `export interface ${typeName("RequestBodies")} {}`;
+  if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
+    const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
+      if (!schema) return `${JSON.stringify(mediaType)}: unknown`;
+      return `${JSON.stringify(mediaType)}: ${generateSchema(schema, alias)}`;
+    }).map((pair) => indent(2, pair));
+    $requestBodies = [
+      `export interface ${typeName("RequestBodies")} {`,
+      ...$mediaTypes,
+      "}"
+    ].join("\n");
+  }
+  return $requestBodies;
+}
+function parameterBodies(operationDefinition, alias = R15.identity, typeName) {
+  const { operation } = operationDefinition;
+  let parameterBodies2 = "";
   if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-    const $value = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).filter(([, schema]) => !!schema).map(([mediaType, schema]) => {
-      if (mediaType === "multipart/form-data") {
-        return `FormData | ${generateSchema(schema, alias)}`;
-      } else if (mediaType === "application/x-www-form-urlencoded") {
-        return `URLSearchParams | ${generateSchema(schema, alias)}`;
+    const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schemaOrRef]) => {
+      if (!schemaOrRef) return `${JSON.stringify(mediaType)}: unknown`;
+      const schema = JsonSchemaUtils.isRef(schemaOrRef) ? SwaggerUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.swagger) : schemaOrRef;
+      if (schema.type === "object" || schema.properties) {
+        return `${JSON.stringify(mediaType)}: ${generateSchema(schemaOrRef, alias)} & { [key: string]: any }`;
       }
-      return generateSchema(schema, alias);
-    }).join(" | ");
-    $requestBody = `export type ${typeName("RequestBody")} = ${$value || "unknown"}`;
+      return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
+    }).map((pair) => indent(2, pair));
+    parameterBodies2 = [
+      `interface ${typeName("ParameterBodies")} {`,
+      ...$mediaTypes,
+      "}",
+      ""
+    ].join("\n");
+  }
+  return parameterBodies2;
+}
+function requestParameters(operation, alias = R15.identity, typeName) {
+  const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
+  const base = `${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")}`;
+  if (mediaTypes.length === 1) {
+    return `export type ${typeName("RequestParameters")} = ${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
+  }
+  if (mediaTypes.length > 1) {
+    const unions = mediaTypes.map((mediaType) => `(${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
+    return `export type ${typeName("RequestParameters")} = ${unions}`;
   }
+  return `export type ${typeName("RequestParameters")} = ${base}`;
+}
+async function operationTypeRenderer(operationDefinition, alias = R15.identity) {
+  const { operation } = operationDefinition;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const $responseBodies = responseBodies(operation, alias, typeName);
+  const $requestBodies = requestBodies(operation, alias, typeName);
+  const $parameterBodies = parameterBodies(operationDefinition, alias, typeName);
+  const $requestParameters = requestParameters(operation, alias, typeName);
   return [
-    `export interface ${typeName("ResponseBodies")} {`,
-    $responses,
-    "}",
+    "/* @anchor:file:start */",
+    "",
+    $responseBodies,
+    "",
+    $requestBodies,
     "",
     generateParameters(`${typeName("RequestQuery")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [], alias),
     "",
@@ -1435,18 +1681,19 @@ async function operationTypeRenderer(operationDefinition, alias = R13.identity)
     "",
     generateParameters(`${typeName("RequestHeaders")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [], alias),
     "",
-    $requestBody,
-    "",
-    `export type ${typeName("RequestParameters")} = ${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")} & ${typeName("RequestBody")}`,
+    $parameterBodies || void 0,
+    $requestParameters,
     "",
-    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}> extends KeqOperation {`,
-    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqParamValue }`,
-    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryValue }`,
+    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends keyof ${typeName("ParameterBodies")}> extends KeqOperation {`,
+    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqPathParameterInit }`,
+    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryInit }`,
     `  requestHeaders: ${typeName("RequestHeaders")} & { [key: string]: string | number }`,
-    `  requestBody: ${typeName("RequestBody")}`,
+    `  requestBody: ${$parameterBodies ? `${typeName("ParameterBodies")}[CONTENT_TYPE] | ` : "object | "}BodyInit`,
     `  responseBody: ${typeName("ResponseBodies")}[STATUS]`,
-    "}"
-  ].join("\n");
+    "}",
+    "",
+    "/* @anchor:file:end */"
+  ].filter(R15.isNotNil).join("\n");
 }
 function generateParameters(name, parameters, alias) {
   if (parameters.length === 0) {
@@ -1466,7 +1713,7 @@ function generateParameters(name, parameters, alias) {
 }
 
 // src/renderer/operation-request/index.ts
-import * as R14 from "ramda";
+import * as R16 from "ramda";
 function errorToComment(err, mediaType) {
   const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
   return [
@@ -1476,23 +1723,8 @@ function errorToComment(err, mediaType) {
     " */"
   ].join("\n");
 }
-async function operationRequestRenderer(operationDefinition, options) {
-  const { operation, operationId, method, pathname } = operationDefinition;
-  const { qs } = options;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
-  const moduleName = operationDefinition.module.name;
-  const parameters = operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p)) || [];
-  const queryParameters = parameters.filter((p) => p.in === "query");
-  const headersParameters = parameters.filter((p) => p.in === "header");
-  const pathParameters = parameters.filter((p) => p.in === "path");
-  const $queryParameters = queryParameters.map((p) => {
-    const option = qs(p);
-    const $option = !option || R14.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
-    return `  if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
-  }).concat("").join("\n");
-  const $headerParameters = headersParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
-  const $pathParameters = pathParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+function requestBodyRenderer(operationDefinition, typeName) {
+  const { operation } = operationDefinition;
   const requestBodyContent = operation.requestBody?.content || {};
   const $requestBody = Object.entries(requestBodyContent).map(([mediaType, mediaTypeObject]) => {
     if (!mediaTypeObject.schema) return;
@@ -1521,27 +1753,107 @@ async function operationRequestRenderer(operationDefinition, options) {
     } catch (err) {
       return indent(2, errorToComment(err, mediaType));
     }
-  }).filter(R14.isNotNil).join("\n");
+  }).filter(R16.isNotNil).join("\n");
+  return $requestBody;
+}
+function requestHeadersRenderer(operationDefinition, typeName) {
+  const { operation } = operationDefinition;
+  const $headers = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "header").map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+  return $headers;
+}
+function requestQueryRenderer(operationDefinition, qs, typeName) {
+  const { operation } = operationDefinition;
+  const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
+    const option = qs(p);
+    const $option = !option || R16.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
+    return `  if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
+  }).concat("").join("\n");
+  return $query;
+}
+function requestPathParametersRenderer(operationDefinition, typeName) {
+  const { operation } = operationDefinition;
+  const $pathParameters = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "path").map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+  return $pathParameters;
+}
+function getRequestMediaTypes(operationDefinition) {
+  const { operation } = operationDefinition;
+  const requestBodyContent = operation.requestBody?.content || {};
+  return Object.keys(requestBodyContent);
+}
+function mediaTypeRenderer(operationDefinition) {
+  const mediaTypes = getRequestMediaTypes(operationDefinition);
+  if (mediaTypes.length === 1 && !mediaTypes[0].endsWith("/*")) {
+    return `  req.type("${mediaTypes[0]}")
+`;
+  } else if (mediaTypes.some((mediaType) => mediaType === "*/*")) {
+  } else if (mediaTypes.some((mediaType) => mediaType.endsWith("/*"))) {
+    return '  if(args?.["content-type"]) req.type(args["content-type"])\n';
+  } else if (mediaTypes.length > 1) {
+    return '  if(args?.["content-type"]) req.type(args["content-type"])\n';
+  }
+  return "";
+}
+function operationDeclarationRenderer(operationDefinition, typeName) {
+  const { operationId } = operationDefinition;
+  const mediaTypes = getRequestMediaTypes(operationDefinition);
+  if (mediaTypes.length === 0) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, never>>`;
+  } else if (mediaTypes.length === 1) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, ${JSON.stringify(mediaTypes[0])}>>`;
+  } else if (mediaTypes.length > 1) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${typeName("RequestParameters")}["content-type"]>(args?: Extract<${typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<Operation<STATUS, CONTENT_TYPE>>`;
+  }
+  throw new Error("[operationDeclarationRenderer] Unreachable");
+}
+async function operationRequestRenderer(operationDefinition, options) {
+  const { operation, operationId, method, pathname } = operationDefinition;
+  const { qs } = options;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const moduleName = operationDefinition.module.name;
+  const $queryParameters = requestQueryRenderer(operationDefinition, qs, typeName);
+  const $headerParameters = requestHeadersRenderer(operationDefinition, typeName);
+  const $pathParameters = requestPathParametersRenderer(operationDefinition, typeName);
+  const $mediaType = mediaTypeRenderer(operationDefinition);
+  const $requestBody = requestBodyRenderer(operationDefinition, typeName);
+  const $operationDeclaration = operationDeclarationRenderer(operationDefinition, typeName);
   return [
+    "/* @anchor:file:start */",
+    "",
     `const moduleName = "${moduleName}"`,
     `const method = "${method}"`,
     `const pathname = "${pathname}"`,
     "",
-    `export function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS>> {`,
+    "/* @anchor:operation-declaration */",
+    `export ${$operationDeclaration} {`,
     `  const req = request.post<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
     "    .option('module', { name: moduleName, pathname, method })",
     "",
+    $mediaType || void 0,
+    "  /* @anchor:query:start */",
     $queryParameters || void 0,
+    "  /* @anchor:query:end */",
+    "",
+    "  /* @anchor:headers:start */",
     $headerParameters || void 0,
+    "  /* @anchor:headers:end */",
+    "",
+    "  /* @anchor:path-parameters:start */",
     $pathParameters || void 0,
-    $requestBody ? `${$requestBody}
-` : void 0,
-    "  return req",
+    "  /* @anchor:path-parameters:end */",
+    "",
+    "  /* @anchor:body:start */",
+    $requestBody || void 0,
+    "  /* @anchor:body:end */",
+    "",
+    "  /* @anchor:operation-return */",
+    `  return req as ReturnType<typeof ${operationId}>`,
     "}",
     "",
     `${operationId}.pathname = pathname`,
-    `${operationId}.method = method`
-  ].filter(R14.isNotNil).join("\n");
+    `${operationId}.method = method`,
+    "/* @anchor:file:end */"
+  ].filter(R16.isNotNil).join("\n");
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
@@ -1572,7 +1884,7 @@ function genEntrypointFilepath2(moduleName) {
   ].join("/");
 }
 async function compileOperationDefinition(options) {
-  const { rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
+  const { compiler, task, rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
   const alias = (name) => `${name}Schema`;
   const qs = (parameter) => {
     if (typeof rc.qs === "function") {
@@ -1606,7 +1918,7 @@ async function compileOperationDefinition(options) {
       content,
       extensionName: ".type.ts"
     });
-    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryValue", "KeqParamValue"]);
+    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryInit", "KeqPathParameterInit"]);
     const dependentSchemaDefinitions = operationDefinition.getDependencies();
     for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
       const dependentArtifact = schemaArtifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
@@ -1618,7 +1930,7 @@ async function compileOperationDefinition(options) {
         new DependencyIdentifier(dependentSchemaDefinition.name, alias(dependentSchemaDefinition.name))
       ]);
     }
-    return typeArtifact;
+    return await compiler.hooks.afterCompileOperationType.promise(typeArtifact, operationDefinition, task);
   }
   async function createRequestArtifact(operationDefinition, typeArtifact) {
     const typeName = typeNameFactory(operationDefinition);
@@ -1645,13 +1957,13 @@ async function compileOperationDefinition(options) {
       [
         `${typeName("RequestQuery")}`,
         `${typeName("RequestHeaders")}`,
-        `${typeName("RequestBody")}`
+        `${typeName("RequestBodies")}`
       ],
       { export: true }
     );
-    return artifact;
+    return await compiler.hooks.afterCompileOperationRequest.promise(artifact, operationDefinition, task);
   }
-  const artifacts = R15.unnest(
+  const artifacts = R17.unnest(
     await Promise.all(
       operationDefinitions.map(async (operationDefinition) => {
         const typeArtifact = await createTypeArtifact(operationDefinition);
@@ -1660,7 +1972,7 @@ async function compileOperationDefinition(options) {
       })
     )
   );
-  const operationDefinitionsGroupByModuleName = R15.groupBy(
+  const operationDefinitionsGroupByModuleName = R17.groupBy(
     (operationDefinition) => operationDefinition.module.name,
     operationDefinitions
   );
@@ -1688,32 +2000,38 @@ async function compileOperationDefinition(options) {
 async function requestRenderer() {
   return [
     "import { KeqRequest } from 'keq'",
-    "export const request = new KeqRequest()"
+    "",
+    "/* @anchor:file:start */",
+    "",
+    "/* @anchor:request-declaration */",
+    "export const request = new KeqRequest()",
+    "",
+    "/* @anchor:file:end"
   ].join("\n");
 }
 
 // src/tasks/compile/index.ts
-function createCompileTask(options) {
+function main6(compiler) {
   return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.shaken) throw new Error("Please run shaking task first.");
       const rc = context.setup.rc;
       const matcher = context.setup.matcher;
       const documents = context.shaken.documents.filter((document) => !matcher.isModuleIgnored(document.module));
-      const requestArtifact = new Artifact({
-        id: "request",
-        filepath: "request",
-        content: await requestRenderer(),
-        extensionName: ".ts"
-      });
+      const requestArtifact = await compiler.hooks.afterCompileKeqRequest.promise(
+        new Artifact({
+          id: "request",
+          filepath: "request",
+          content: await requestRenderer(),
+          extensionName: ".ts"
+        }),
+        task
+      );
       const schemaDefinitions = documents.flatMap((document) => document.schemas);
       const operationDefinitions = documents.flatMap((document) => document.operations);
-      const schemaArtifacts = await compileSchemaDefinition({ schemaDefinitions });
-      const operationArtifacts = await compileOperationDefinition({ rc, operationDefinitions, schemaArtifacts, requestArtifact });
+      const schemaArtifacts = await compileSchemaDefinition({ compiler, task, schemaDefinitions });
+      const operationArtifacts = await compileOperationDefinition({ compiler, task, rc, operationDefinitions, schemaArtifacts, requestArtifact });
       const artifacts = [requestArtifact, ...schemaArtifacts, ...operationArtifacts];
       context.compiled = {
         artifacts
@@ -1721,6 +2039,24 @@ function createCompileTask(options) {
     }
   };
 }
+function createCompileTask(compiler, options) {
+  return {
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main6(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
 // src/tasks/interactive/utils/select-operation-definitions.ts
 import { select } from "inquirer-select-pro";
@@ -1757,7 +2093,7 @@ function createInteractiveTask(options) {
       const documents = context.validated.documents;
       const operationDefinitions = documents.flatMap((document) => document.operations);
       const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
-      if (options.override) {
+      if (options.clear) {
         matcher.append({
           persist: false,
           ignore: true,
@@ -1768,7 +2104,7 @@ function createInteractiveTask(options) {
       }
       for (const op of selectedOperationDefinitions) {
         matcher.append({
-          persist: true,
+          persist: !!options.persist,
           ignore: options.mode === "add",
           moduleName: op.module.name,
           operationMethod: op.method,
@@ -1779,38 +2115,161 @@ function createInteractiveTask(options) {
   };
 }
 
-// src/tasks/index.ts
-async function build(options) {
-  const tasks = new Listr(
-    [
-      createSetupTask(options),
-      createDownloadTask({ skipIgnoredModules: !options.interactive }),
-      createValidateTask(),
-      createInteractiveTask({ mode: "except", override: true, enabled: !!options.interactive }),
-      createShakingTask({ skipIgnoredModules: true, skipEmptyDocuments: true }),
-      createCompileTask(),
-      createPersistTask({ persistIgnore: false })
-    ],
-    {
-      concurrent: false,
-      renderer: "default",
-      rendererOptions: {
-        suffixSkips: true,
-        collapseSubtasks: false,
-        collapseErrors: false
+// src/compiler/intercepter/perfect-error-message.ts
+import * as R18 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 = R18.last(args);
+          return fn(...R18.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
+          });
+        };
       }
+      return tap;
     }
-  );
-  await tasks.run({});
+  };
 }
 
-// src/define-keq-config.ts
-function defineKeqConfig(config) {
-  return config;
+// 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/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));
+  }
+  context = {};
+  hooks = {
+    // core
+    afterSetup: new AsyncSeriesHook(["task"]),
+    afterDownload: new AsyncSeriesHook(["task"]),
+    afterValidate: new AsyncSeriesHook(["task"]),
+    afterShaking: new AsyncSeriesHook(["task"]),
+    afterCompile: new AsyncSeriesHook(["task"]),
+    afterPersist: new AsyncSeriesHook(["task"]),
+    done: new SyncHook(),
+    // compile
+    afterCompileKeqRequest: new AsyncSeriesWaterfallHook(["artifact", "task"]),
+    afterCompileSchema: new AsyncSeriesWaterfallHook(["artifact", "schema", "task"]),
+    afterCompileOperationType: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"]),
+    afterCompileOperationRequest: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"])
+  };
+  async run() {
+    const options = this.options;
+    const tasks = new Listr(
+      [
+        createSetupTask(this, options),
+        createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
+        createValidateTask(this, { enabled: !!options.build }),
+        createInteractiveTask({ enabled: !!options.interactive, ...typeof options.interactive === "object" ? options.interactive : { mode: "except" } }),
+        createShakingTask(this, { enabled: !!options.build, ...typeof options.build === "object" ? options.build.shaking : void 0 }),
+        createCompileTask(this, { enabled: !!options.build }),
+        createPersistTask(this, { enabled: !!options.build })
+      ],
+      {
+        concurrent: false,
+        renderer: "default",
+        rendererOptions: {
+          suffixSkips: true,
+          collapseSubtasks: false,
+          collapseErrors: false
+        }
+      }
+    );
+    await tasks.run(this.context);
+    await this.hooks.done.promise();
+  }
+};
 export {
+  ApiDocument,
+  ApiDocumentV3_1,
+  Artifact,
+  Compiler,
   FileNamingStyle,
-  build,
+  ModuleDefinition,
+  OperationDefinition,
+  RuntimeConfig,
+  SchemaDefinition,
   defineKeqConfig
 };
 //# sourceMappingURL=index.js.map