@keq-request/cli 5.0.0-alpha.13 → 5.0.0-alpha.15

package/dist/cli.js

@@ -1077,7 +1077,10 @@ function createPersistArtifactTask() {
     title: "Write files",
     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.");
+      if (!context.compiled) {
+        task.skip("No compiled artifacts to persist.");
+        return;
+      }
       const rc = context.setup.rc;
       const artifacts = context.compiled.artifacts;
       for (const artifact of artifacts) {
@@ -1208,6 +1211,7 @@ function generateArray(schema, alias) {
   return "any[]";
 }
 function indent(space, text) {
+  if (text === "") return "";
   const indentation = " ".repeat(space);
   return text.split("\n").map((line) => `${indentation}${line}`).join("\n");
 }
@@ -1281,11 +1285,13 @@ async function jsonSchemaRenderer(schemaDefinition) {
     ].filter(R12.isNotNil).join("\n");
   }
   if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
+    const $schema = generateSchema(schemaDefinition.schema);
+    const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
     return [
       "/* @anchor:file:start */",
       "",
       $comment || void 0,
-      `export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`,
+      $declaration,
       "",
       "/* @anchor:file:end */"
     ].filter(R12.isNotNil).join("\n");
@@ -1382,15 +1388,17 @@ function toComment(msg) {
 
 // src/tasks/utils/dependency.ts
 var DependencyIdentifier = class {
-  constructor(name, alias) {
+  constructor(name, alias, type = false) {
     this.name = name;
     this.alias = alias;
+    this.type = type;
   }
   toCode() {
+    const $type = this.type ? "type " : "";
     if (this.alias) {
-      return `${this.name} as ${this.alias}`;
+      return `${$type}${this.name} as ${this.alias}`;
     }
-    return this.name;
+    return `${$type}${this.name}`;
   }
 };
 var Dependency = class {
@@ -1401,6 +1409,11 @@ var Dependency = class {
   constructor(source, identifiers, belongTo, options) {
     this.source = source;
     this.identifiers = identifiers.map((i) => typeof i === "string" ? new DependencyIdentifier(i) : i);
+    if (options?.type) {
+      for (const identifier of this.identifiers) {
+        identifier.type = true;
+      }
+    }
     this.export = !!options?.export;
     this.belongTo = belongTo;
   }
@@ -1591,7 +1604,7 @@ async function compileSchemaDefinition(options) {
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
-import * as R17 from "ramda";
+import * as R18 from "ramda";
 
 // src/renderer/operation-type/index.ts
 import * as R15 from "ramda";
@@ -1717,7 +1730,12 @@ function generateParameters(name, parameters, alias) {
 }
 
 // src/renderer/operation-request/index.ts
+import * as R17 from "ramda";
+
+// src/renderer/operation-request/request-body.ts
 import * as R16 from "ramda";
+
+// src/renderer/operation-request/error-to-comment.ts
 function errorToComment(err, mediaType) {
   const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
   return [
@@ -1727,6 +1745,34 @@ function errorToComment(err, mediaType) {
     " */"
   ].join("\n");
 }
+
+// src/renderer/operation-request/request-body.ts
+function requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition) {
+  try {
+    const $propertyName = JSON.stringify(propertyName);
+    const schema = JsonSchemaUtils.isRef(propertySchema) ? SwaggerUtils.dereferenceDeep(propertySchema.$ref, operationDefinition.document.swagger) : propertySchema;
+    if (schema.type === "string" && schema.format === "binary" || schema.contentMediaType === "application/octet-stream") {
+      return `if (args && ${$propertyName} in args && args[${$propertyName}]) req.attach(${$propertyName}, args[${$propertyName}])`;
+    } else if (schema.type === "string" || schema.type === "array" && schema.items && schema.items.type === "string") {
+      return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, args[${$propertyName}])`;
+    } else if (schema.type === "number" || schema.type === "integer") {
+      return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]))`;
+    }
+    return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]) /* type is non-string in schema; triggers type coercion here */)`;
+  } catch (err) {
+    return errorToComment(err, mediaType);
+  }
+}
+function requestBodyPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition) {
+  if (mediaType === "application/json") {
+    const $propertyName = JSON.stringify(propertyName);
+    return `if (args && ${$propertyName} in args) req.send({ ${$propertyName}: args[${$propertyName}] })`;
+  } else if (mediaType === "multipart/form-data") {
+    return requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition);
+  } else {
+    throw new Error(`Unsupported media type: ${mediaType}`);
+  }
+}
 function requestBodyRenderer(operationDefinition, typeName) {
   const { operation } = operationDefinition;
   const requestBodyContent = operation.requestBody?.content || {};
@@ -1737,22 +1783,10 @@ function requestBodyRenderer(operationDefinition, typeName) {
       if (schema.type !== "object") return;
       const properties = schema.properties || {};
       return Object.entries(properties).map(([propertyName, propertySchema]) => {
-        const $propertyName = JSON.stringify(propertyName);
-        if (mediaType === "application/json") {
-          return `  if (args && ${$propertyName} in args) req.send({ ${$propertyName}: args[${$propertyName}] })`;
-        } else if (mediaType === "multipart/form-data") {
-          try {
-            const schema2 = JsonSchemaUtils.isRef(propertySchema) ? SwaggerUtils.dereferenceDeep(propertySchema.$ref, operationDefinition.document.swagger) : propertySchema;
-            if (schema2.type === "string" && schema2.format === "binary" || schema2.contentMediaType === "application/octet-stream") {
-              return `  if (args && ${$propertyName} in args && args[${$propertyName}]) req.attach(${$propertyName}, args[${$propertyName}])`;
-            }
-            return `  if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, args[${$propertyName}])`;
-          } catch (err) {
-            return indent(2, errorToComment(err, mediaType));
-          }
-        } else {
-          throw new Error(`Unsupported media type: ${mediaType}`);
-        }
+        return indent(
+          2,
+          requestBodyPropertyRenderer(propertyName, propertySchema, mediaType, operationDefinition)
+        );
       }).join("\n");
     } catch (err) {
       return indent(2, errorToComment(err, mediaType));
@@ -1760,6 +1794,8 @@ function requestBodyRenderer(operationDefinition, typeName) {
   }).filter(R16.isNotNil).join("\n");
   return $requestBody;
 }
+
+// src/renderer/operation-request/index.ts
 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");
@@ -1769,7 +1805,7 @@ 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)}`;
+    const $option = !option || R17.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;
@@ -1801,9 +1837,9 @@ 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>>`;
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, CONTENT_TYPE>>`;
   } else if (mediaTypes.length === 1) {
-    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, ${JSON.stringify(mediaTypes[0])}>>`;
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, CONTENT_TYPE>>`;
   } 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>>`;
   }
@@ -1815,6 +1851,7 @@ async function operationRequestRenderer(operationDefinition, options) {
   if (!operation.responses) return "";
   const typeName = typeNameFactory(operationDefinition);
   const moduleName = operationDefinition.module.name;
+  const $method = method.toLowerCase();
   const $queryParameters = requestQueryRenderer(operationDefinition, qs, typeName);
   const $headerParameters = requestHeadersRenderer(operationDefinition, typeName);
   const $pathParameters = requestPathParametersRenderer(operationDefinition, typeName);
@@ -1830,7 +1867,7 @@ async function operationRequestRenderer(operationDefinition, options) {
     "",
     "/* @anchor:operation-declaration */",
     `export ${$operationDeclaration} {`,
-    `  const req = request.post<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
+    `  const req = request.${$method}<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
     "    .option('module', { name: moduleName, pathname, method })",
     "",
     $mediaType || void 0,
@@ -1851,13 +1888,13 @@ async function operationRequestRenderer(operationDefinition, options) {
     "  /* @anchor:body:end */",
     "",
     "  /* @anchor:operation-return */",
-    `  return req as ReturnType<typeof ${operationId}>`,
+    `  return req as ReturnType<typeof ${operationId}<STATUS${$operationDeclaration.includes("CONTENT_TYPE") ? ", CONTENT_TYPE" : ""}>>`,
     "}",
     "",
     `${operationId}.pathname = pathname`,
     `${operationId}.method = method`,
     "/* @anchor:file:end */"
-  ].filter(R16.isNotNil).join("\n");
+  ].filter(R17.isNotNil).join("\n");
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
@@ -1954,7 +1991,8 @@ async function compileOperationDefinition(options) {
         "Operation",
         typeName("ResponseBodies"),
         typeName("RequestParameters")
-      ]
+      ],
+      { type: true }
     );
     artifact.addDependence(
       typeArtifact,
@@ -1963,11 +2001,11 @@ async function compileOperationDefinition(options) {
         `${typeName("RequestHeaders")}`,
         `${typeName("RequestBodies")}`
       ],
-      { export: true }
+      { export: true, type: true }
     );
     return await compiler.hooks.afterCompileOperationRequest.promise(artifact, operationDefinition, task);
   }
-  const artifacts = R17.unnest(
+  const artifacts = R18.unnest(
     await Promise.all(
       operationDefinitions.map(async (operationDefinition) => {
         const typeArtifact = await createTypeArtifact(operationDefinition);
@@ -1976,7 +2014,7 @@ async function compileOperationDefinition(options) {
       })
     )
   );
-  const operationDefinitionsGroupByModuleName = R17.groupBy(
+  const operationDefinitionsGroupByModuleName = R18.groupBy(
     (operationDefinition) => operationDefinition.module.name,
     operationDefinitions
   );
@@ -2123,7 +2161,7 @@ function createInteractiveTask(options) {
 }
 
 // src/compiler/intercepter/perfect-error-message.ts
-import * as R18 from "ramda";
+import * as R19 from "ramda";
 function perfectErrorMessage() {
   return {
     register: (tap) => {
@@ -2155,8 +2193,8 @@ function perfectErrorMessage() {
       }
       if (tap.type === "async") {
         tap.fn = (...args) => {
-          const callback = R18.last(args);
-          return fn(...R18.init(args), (err, result) => {
+          const callback = R19.last(args);
+          return fn(...R19.init(args), (err, result) => {
             prefix(err);
             return callback(err, result);
           });
@@ -2247,11 +2285,11 @@ var Compiler = class {
       [
         createSetupTask(this, options),
         createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
-        createValidateTask(this, { enabled: !!options.build }),
+        createValidateTask(this),
         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 })
+        createPersistTask(this)
       ],
       {
         concurrent: false,
@@ -2337,8 +2375,8 @@ program.command("ignore").addArgument(
       }
     });
   } else {
-    if (!options.module && !options.method && !options.pathname) {
-      throw new Error("at least one of '--module', '--method' or '--pathname' must be specified");
+    if (!options.method && !options.pathname) {
+      throw new Error("at least one of '-i --interactive', '--method' or '--pathname' must be specified");
     }
     const moduleNames = options.module || ["*"];
     compiler = new Compiler({