@hyper-fetch/cli 7.2.5 → 7.3.0

package/src/codegen/openapi/generator.ts

@@ -1,10 +1,10 @@
 import DtsGenerator, { ExportedType } from "@anttiviljami/dtsgenerator/dist/core/dtsGenerator";
 import RefParser from "@apidevtools/json-schema-ref-parser";
 import { parseSchema } from "@anttiviljami/dtsgenerator/dist/core/type";
-import { find, chain, isEmpty } from "lodash";
+import * as lodash from "lodash";
 import * as prettier from "prettier";
 import * as fs from "fs-extra";
-import * as path from "path";
+import * as path from "node:path";
 import { createClient } from "@hyper-fetch/core";
 
 import { Document, Operation, GeneratedTypes } from "./openapi.types";
@@ -138,7 +138,7 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
   };
 
   static generateRequestInstanceType(
-    { id, path: endpoint }: { id: string; path: string },
+    { id, path: endpoint, queryParamsRequired }: { id: string; path: string; queryParamsRequired?: boolean },
     types: Record<string, string>,
   ) {
     const Response = types[`${createTypeBaseName(id)}ResponseType`]
@@ -150,11 +150,19 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
       ? `${createTypeBaseName(id)}QueryParams`
       : undefined;
 
-    return `Request<${Response}, ${Payload}, ${QueryParams}, ${LocalError}, "${endpoint}", Client>`;
+    const QueryParamsGeneric =
+      QueryParams && queryParamsRequired === false ? `${QueryParams} | undefined` : QueryParams;
+
+    return `Request<${Response}, ${Payload}, ${QueryParamsGeneric}, ${LocalError}, "${endpoint}", Client>`;
   }
 
   static generateHyperFetchRequest(
-    { id, path: relPath, method }: { id: string; path: string; method: string },
+    {
+      id,
+      path: relPath,
+      method,
+      queryParamsRequired,
+    }: { id: string; path: string; method: string; queryParamsRequired?: boolean },
     types: Record<string, string>,
   ) {
     const Response = types[`${createTypeBaseName(id)}ResponseType`]
@@ -186,7 +194,8 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
       addToGenericType("error", LocalError);
     }
     if (QueryParams) {
-      addToGenericType("query", QueryParams);
+      const key = queryParamsRequired === false ? "queryParams?" : "queryParams";
+      addToGenericType(key, QueryParams);
     }
 
     if (genericType) {
@@ -239,18 +248,22 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
   ) {
     const { operationId, method, path: relPath } = operation;
     const normalizedOperationId = normalizeOperationId(operationId);
-    const pathParametersType = find(exportTypes, {
+    const pathParametersType = lodash.find(exportTypes, {
       schemaRef: `#/paths/${normalizedOperationId}/pathParameters`,
     })?.path;
-    const queryParametersType = find(exportTypes, {
+    const queryParametersType = lodash.find(exportTypes, {
       schemaRef: `#/paths/${normalizedOperationId}/queryParameters`,
     })?.path;
-    const requestBodyType = find(exportTypes, { schemaRef: `#/paths/${normalizedOperationId}/requestBody` })?.path;
-    const responseTypePaths = chain(exportTypes)
+    const requestBodyType = lodash.find(exportTypes, {
+      schemaRef: `#/paths/${normalizedOperationId}/requestBody`,
+    })?.path;
+    const responseTypePaths = lodash
+      .chain(exportTypes)
       .filter(({ schemaRef }) => schemaRef.startsWith(`#/paths/${normalizedOperationId}/responses/2`))
       .map(({ path: responsePath }) => responsePath)
       .value();
-    const errorTypePaths = chain(exportTypes)
+    const errorTypePaths = lodash
+      .chain(exportTypes)
       .filter(
         ({ schemaRef }) =>
           schemaRef.startsWith(`#/paths/${normalizedOperationId}/responses/4`) ||
@@ -259,8 +272,16 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
       .map(({ path: errorPath }) => errorPath)
       .value();
 
-    const responseType = !isEmpty(responseTypePaths) ? responseTypePaths.join(" | ") : "any";
-    const errorType = !isEmpty(errorTypePaths) ? errorTypePaths.join(" | ") : "undefined";
+    const responseType = !lodash.isEmpty(responseTypePaths) ? responseTypePaths.join(" | ") : "any";
+    const errorType = !lodash.isEmpty(errorTypePaths) ? errorTypePaths.join(" | ") : "undefined";
+    const queryParamsRequired = Array.isArray(operation.parameters)
+      ? operation.parameters.every((p) => {
+          if ("in" in p && p.in === "query" && p.required === false) {
+            return true;
+          }
+          return false;
+        })
+      : undefined;
 
     return {
       id: normalizedOperationId,
@@ -271,6 +292,7 @@ export const createSdk = <Client extends ClientInstance>(client: Client) => {
       responseType,
       path: adjustPathParamsFormat(relPath),
       method: method ? method.toUpperCase() : HttpMethod.GET,
+      queryParamsRequired,
     };
   }
 

package/src/commands/generate.ts

@@ -1,8 +1,8 @@
 /* eslint-disable no-param-reassign */
 import { Command } from "commander";
 import { z } from "zod";
-import path from "path";
-import fs from "fs-extra";
+import * as path from "node:path";
+import * as fs from "fs-extra";
 import { input, select, confirm } from "@inquirer/prompts";
 
 import { handleError } from "utils/handle-error";

package/src/commands/init.ts

@@ -1,8 +1,8 @@
 import { Command } from "commander";
 import { input, select } from "@inquirer/prompts";
 import { z } from "zod";
-import path from "path";
-import { existsSync, mkdir, readFileSync, writeFile } from "fs-extra";
+import * as path from "node:path";
+import * as fs from "fs-extra";
 
 import { handleError } from "../utils/handle-error";
 import { spinner } from "../utils/spinner";
@@ -103,16 +103,16 @@ export const init = new Command()
         {
           name: `Initialize API directory at ${relativePath}`,
           action: async () => {
-            if (!existsSync(fullPath)) {
-              await mkdir(fullPath, { recursive: true });
+            if (!fs.existsSync(fullPath)) {
+              await fs.mkdir(fullPath, { recursive: true });
             }
           },
         },
         {
           name: "Setup configuration",
           action: async (currentConfig) => {
-            if (existsSync(configPath)) {
-              const existingConfig = JSON.parse(readFileSync(configPath, "utf8"));
+            if (fs.existsSync(configPath)) {
+              const existingConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
               const { success, error, data } = configSchema.omit({ resolvedPaths: true }).safeParse({
                 ...defaultConfig,
                 ...existingConfig,
@@ -163,7 +163,7 @@ export const init = new Command()
 
             configSchema.omit({ resolvedPaths: true }).parse(finalConfig);
 
-            await writeFile(configPath, JSON.stringify(finalConfig, null, 2));
+            await fs.writeFile(configPath, JSON.stringify(finalConfig, null, 2));
           },
         },
       ];

package/src/config/get-config.ts

@@ -1,5 +1,5 @@
-import path from "path";
-import fs from "fs-extra";
+import * as path from "node:path";
+import * as fs from "fs-extra";
 import { loadConfig } from "tsconfig-paths";
 
 import { highlighter } from "utils/highlighter";

package/src/preflights/preflight-add.ts

@@ -1,5 +1,5 @@
-import path from "path";
-import fs from "fs-extra";
+import * as path from "node:path";
+import * as fs from "fs-extra";
 import { z } from "zod";
 
 import { addOptionsSchema } from "commands/add";

package/src/preflights/preflight-generate.ts

@@ -1,5 +1,5 @@
-import path from "path";
-import fs from "fs-extra";
+import * as path from "node:path";
+import * as fs from "fs-extra";
 import { z } from "zod";
 
 import { generateOptionsSchema } from "commands/generate";

package/src/utils/handle-error.ts

@@ -7,7 +7,7 @@ export function handleError(error: unknown) {
   logger.break();
   logger.error(`Something went wrong. Please check the error below for more details.`);
   logger.error(`If the problem persists, please open an issue on GitHub.`);
-  logger.error("");
+  logger.break();
   if (typeof error === "string") {
     logger.error(error);
     logger.break();
@@ -30,6 +30,8 @@ export function handleError(error: unknown) {
     process.exit(1);
   }
 
+  logger.error(JSON.stringify({ error }));
+
   logger.break();
   process.exit(1);
 }