@hyper-fetch/cli 7.5.2 → 7.5.3

package/__tests__/codegen/openapi/v3/generator.spec.ts

@@ -0,0 +1,366 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/**
+ * @jest-environment node
+ */
+
+import { promises as fsPromises } from "fs";
+import * as path from "path";
+import * as fs from "fs-extra";
+
+import { OpenapiRequestGenerator, Document, getAvailableOperations, Operation } from "codegen/openapi";
+import { HttpMethod } from "codegen/openapi/http-methods.enum";
+
+const expectedMetadata = {
+  findPets: {
+    id: "findPets",
+    pathParametersType: undefined,
+    queryParametersType: "Paths.FindPets.QueryParameters",
+    requestBodyType: undefined,
+    responseType: "Paths.FindPets.Responses.$200",
+    path: "/pets",
+    method: "GET",
+  },
+  addPet: {
+    id: "addPet",
+    pathParametersType: undefined,
+    queryParametersType: undefined,
+    requestBodyType: "Paths.AddPet.RequestBody",
+    responseType: "Paths.AddPet.Responses.$200",
+    path: "/pet",
+    method: "POST",
+  },
+  find_pet_by_id: {
+    id: "find_pet_by_id",
+    pathParametersType: "Paths.FindPetById.PathParameters",
+    queryParametersType: undefined,
+    requestBodyType: undefined,
+    responseType: "Paths.FindPetById.Responses.$200",
+    path: "/pet/:id",
+    method: "GET",
+  },
+  deletePet: {
+    id: "deletePet",
+    pathParametersType: "Paths.DeletePet.PathParameters",
+    queryParametersType: undefined,
+    requestBodyType: undefined,
+    responseType: "any",
+    path: "/pet/:petId",
+    method: "DELETE",
+  },
+  updatePet: {
+    id: "updatePet",
+    pathParametersType: undefined,
+    queryParametersType: undefined,
+    requestBodyType: "Paths.UpdatePet.RequestBody",
+    responseType: "Paths.UpdatePet.Responses.$200",
+    path: "/pet",
+    method: "PUT",
+  },
+};
+const expectedOperationTypes = {
+  FindPetsQueryParams: "export type FindPetsQueryParams = Paths.FindPets.QueryParameters",
+  FindPetsResponseType: "export type FindPetsResponseType = Paths.FindPets.Responses.$200",
+  AddPetRequestBody: "export type AddPetRequestBody = Paths.AddPet.RequestBody",
+  AddPetResponseType: "export type AddPetResponseType = Paths.AddPet.Responses.$200",
+  AddPetErrorType: "export type AddPetErrorType = Paths.AddPet.Responses.$405",
+  FindPetByIdPathParams: "export type FindPetByIdPathParams = Paths.FindPetById.PathParameters",
+  FindPetByIdResponseType: "export type FindPetByIdResponseType = Paths.FindPetById.Responses.$200",
+  DeletePetPathParams: "export type DeletePetPathParams = Paths.DeletePet.PathParameters",
+  DeletePetResponseType: "export type DeletePetResponseType = any",
+  DeletePetErrorType: "export type DeletePetErrorType = Paths.DeletePet.Responses.$400",
+  UpdatePetRequestBody: "export type UpdatePetRequestBody = Paths.UpdatePet.RequestBody",
+  UpdatePetResponseType: "export type UpdatePetResponseType = Paths.UpdatePet.Responses.$200",
+  UpdatePetErrorType:
+    "export type UpdatePetErrorType = Paths.UpdatePet.Responses.$400 | Paths.UpdatePet.Responses.$404 | Paths.UpdatePet.Responses.$405",
+};
+const expectedRequests = [
+  `export const findPets = client.createRequest<{response:FindPetsResponseType,queryParams?:FindPetsQueryParams}>()({method: "GET", endpoint: "/pets"})`,
+  `export const addPet = client.createRequest<{response:AddPetResponseType,payload:AddPetRequestBody,error:AddPetErrorType}>()({method: "POST", endpoint: "/pet"})`,
+  `export const deletePet = client.createRequest<{response:DeletePetResponseType,error:DeletePetErrorType}>()({method: "DELETE", endpoint: "/pet/:petId"})`,
+  `export const updatePet = client.createRequest<{response:UpdatePetResponseType,payload:UpdatePetRequestBody,error:UpdatePetErrorType}>()({method: "PUT", endpoint: "/pet"})`,
+];
+
+describe("Generator", () => {
+  let schema: string;
+
+  beforeAll(async () => {
+    const file = await fsPromises.readFile(path.resolve(__dirname, "../schemas/v3/petstore-expanded.json"), "utf8");
+    schema = JSON.parse(file);
+
+    // Ensure the directory exists before writing the file
+    await fs.ensureDir(path.join(__dirname, "../__temp__"));
+  });
+
+  it("should generate hyper fetch requests", async () => {
+    const { exportedTypes } = await OpenapiRequestGenerator.prepareSchema(schema as unknown as Document);
+    getAvailableOperations(schema as unknown as Document).forEach((operation) => {
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      const operationTypes = OpenapiRequestGenerator.generateTypes(meta);
+      const generatedRequest = OpenapiRequestGenerator.generateHyperFetchRequest(meta, operationTypes);
+
+      if (expectedMetadata[meta.id as keyof typeof expectedMetadata]) {
+        expect(meta).toMatchObject(expectedMetadata[meta.id as keyof typeof expectedMetadata]);
+
+        Object.entries(operationTypes).forEach(([name, value]) => {
+          expect(value).toStrictEqual(expectedOperationTypes[name as keyof typeof expectedOperationTypes]);
+        });
+        expect(expectedRequests).toContain(generatedRequest);
+      }
+    });
+  });
+
+  it("Should generate file with default name", async () => {
+    const generator = new OpenapiRequestGenerator(schema);
+    const generatedFileNamePath = await generator.generateFile({
+      config: {
+        tsx: true,
+        aliases: { api: "api", hooks: "hooks", ui: "ui", components: "components", lib: "lib" },
+        resolvedPaths: {
+          cwd: __dirname,
+          api: path.join(__dirname, "../__temp__"),
+          hooks: path.join(__dirname, "hooks"),
+          ui: path.join(__dirname, "ui"),
+          components: path.join(__dirname, "components"),
+          lib: path.join(__dirname, "lib"),
+        },
+      },
+      fileName: "openapi.client",
+    });
+    expect(generatedFileNamePath).toEndWith("openapi.client.ts");
+  });
+
+  it("Should generate file with js extension", async () => {
+    const generator = new OpenapiRequestGenerator(schema);
+    const generatedFileNamePath = await generator.generateFile({
+      config: {
+        tsx: false,
+        aliases: { api: "api", hooks: "hooks", ui: "ui", components: "components", lib: "lib" },
+        resolvedPaths: {
+          cwd: __dirname,
+          api: path.join(__dirname, "../__temp__"),
+          hooks: path.join(__dirname, "hooks"),
+          ui: path.join(__dirname, "ui"),
+          components: path.join(__dirname, "components"),
+          lib: path.join(__dirname, "lib"),
+        },
+      },
+      fileName: "openapi.client",
+    });
+    expect(generatedFileNamePath).toEndWith("openapi.client.js");
+  });
+
+  it("Should generate file with provided name", async () => {
+    const generator = new OpenapiRequestGenerator(schema);
+    const generatedFileNamePath = await generator.generateFile({
+      config: {
+        tsx: true,
+        aliases: { api: "api", hooks: "hooks", ui: "ui", components: "components", lib: "lib" },
+        resolvedPaths: {
+          cwd: __dirname,
+          api: path.join(__dirname, "../__temp__"),
+          hooks: path.join(__dirname, "hooks"),
+          ui: path.join(__dirname, "ui"),
+          components: path.join(__dirname, "components"),
+          lib: path.join(__dirname, "lib"),
+        },
+      },
+      fileName: "schemaApiRequests",
+    });
+    expect(generatedFileNamePath).toEndWith("schemaApiRequests.ts");
+  });
+
+  it("Should generate file with provided name without duplication for .ts ending if provided", async () => {
+    const generator = new OpenapiRequestGenerator(schema);
+    const generatedFileNamePath = await generator.generateFile({
+      config: {
+        tsx: true,
+        aliases: { api: "api", hooks: "hooks", ui: "ui", components: "components", lib: "lib" },
+        resolvedPaths: {
+          cwd: __dirname,
+          api: path.join(__dirname, "../__temp__"),
+          hooks: path.join(__dirname, "hooks"),
+          ui: path.join(__dirname, "ui"),
+          components: path.join(__dirname, "components"),
+          lib: path.join(__dirname, "lib"),
+        },
+      },
+      fileName: "schemaApiRequests.ts",
+    });
+    expect(generatedFileNamePath).toEndWith("schemaApiRequests.ts");
+  });
+
+  // it("Should generate file with provided baseUrl", async () => {
+  //   const baseUrl = "http://baseurl.com";
+  //   const generator = new OpenapiRequestGenerator(schema);
+  //   const generatedFileNamePath = await generator.generateFile({ url: "http://baseurl.com" });
+  //   const imported = await import(generatedFileNamePath);
+  //   expect(imported.client.url).toEqual(baseUrl);
+  //
+  // });
+
+  describe("HTTP Method handling", () => {
+    it("should use provided HTTP method in uppercase", async () => {
+      const { exportedTypes } = await OpenapiRequestGenerator.prepareSchema(schema as unknown as Document);
+      const operations = getAvailableOperations(schema as unknown as Document);
+
+      // Find the POST operation (addPet)
+      const postOperation = operations.find((op) => op.method === "post");
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(postOperation!, exportedTypes);
+
+      expect(meta.method).toBe("POST");
+    });
+
+    it("should default to GET when no method is provided", async () => {
+      const { exportedTypes } = await OpenapiRequestGenerator.prepareSchema(schema as unknown as Document);
+      const operation = {
+        // Minimal operation object without method
+        operationId: "testOperation",
+        path: "/test",
+        method: undefined as any,
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+
+      expect(meta.method).toBe("get");
+    });
+  });
+
+  describe("Error type handling", () => {
+    let exportedTypes: any;
+
+    beforeEach(async () => {
+      exportedTypes = (await OpenapiRequestGenerator.prepareSchema(schema as unknown as Document)).exportedTypes;
+    });
+
+    it("should generate both error and response types when both are present", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+
+        responses: {
+          "200": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+          "400": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+        },
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      meta.errorType = "ErrorType";
+      meta.responseType = "ResponseType";
+
+      const types = OpenapiRequestGenerator.generateTypes(meta);
+
+      // Verify exact type strings are generated
+      expect(types.TestOperationErrorType).toBe("export type TestOperationErrorType = ErrorType");
+      expect(types.TestOperationResponseType).toBe("export type TestOperationResponseType = ResponseType");
+    });
+
+    it("should generate only response type when error type is null", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+        responses: {
+          "200": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+        },
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      // @ts-ignore
+      meta.errorType = null;
+      meta.responseType = "ResponseType";
+
+      const types = OpenapiRequestGenerator.generateTypes(meta);
+
+      // Verify only response type is generated
+      expect(types.TestOperationErrorType).toBeUndefined();
+      expect(types.TestOperationResponseType).toBe("export type TestOperationResponseType = ResponseType");
+    });
+
+    it("should generate only error type when response type is null", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+        responses: {
+          "400": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+        },
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      meta.errorType = "ErrorType";
+      // @ts-ignore
+      meta.responseType = null;
+
+      const types = OpenapiRequestGenerator.generateTypes(meta);
+
+      // Verify only error type is generated
+      expect(types.TestOperationErrorType).toBe("export type TestOperationErrorType = ErrorType");
+      expect(types.TestOperationResponseType).toBeUndefined();
+    });
+
+    it("should not generate any types when both are null", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      // @ts-ignore
+      meta.errorType = null;
+      // @ts-ignore
+      meta.responseType = null;
+
+      const types = OpenapiRequestGenerator.generateTypes(meta);
+
+      // Verify no types are generated
+      expect(types.TestOperationErrorType).toBeUndefined();
+      expect(types.TestOperationResponseType).toBeUndefined();
+    });
+  });
+
+  describe("Generic type handling", () => {
+    let exportedTypes: any;
+
+    beforeEach(async () => {
+      exportedTypes = (await OpenapiRequestGenerator.prepareSchema(schema as unknown as Document)).exportedTypes;
+    });
+
+    it("should include generic type when present", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+        responses: {
+          "200": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+        },
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+
+      const request = OpenapiRequestGenerator.generateHyperFetchRequest(meta, {
+        TestOperationResponseType: "string",
+      });
+      expect(request).toBe(
+        'export const testOperation = client.createRequest<{response:TestOperationResponseType}>()({method: "GET", endpoint: "/test"})',
+      );
+    });
+
+    it("should generate basic request when genericType is falsy", async () => {
+      const operation: { operationId: string; path: string; method: string } & Partial<Operation> = {
+        operationId: "testOperation",
+        path: "/test",
+        method: HttpMethod.GET,
+        responses: {
+          "200": { content: { "application/json": { schema: { type: "object" } } }, description: "" },
+        },
+      };
+
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+
+      const request = OpenapiRequestGenerator.generateHyperFetchRequest(meta, {});
+      expect(request).toBe('export const testOperation = client.createRequest()({method: "GET", endpoint: "/test"})');
+    });
+  });
+});

package/__tests__/codegen/openapi/v3/operations.spec.ts

@@ -0,0 +1,52 @@
+/**
+ * @jest-environment node
+ */
+
+import { promises as fsPromises } from "fs";
+import * as path from "path";
+
+import { Document } from "codegen/openapi";
+import { getAvailableOperations } from "codegen/openapi/operations";
+
+describe("Operations", () => {
+  let schema: string;
+  beforeAll(async () => {
+    const file = await fsPromises.readFile(path.resolve(__dirname, "../schemas/v3/petstore-expanded.json"), "utf8");
+    schema = JSON.parse(file);
+  });
+
+  it("should get available operations for openapi schema", async () => {
+    const operationIdMap = {
+      findPets: {
+        _shouldExist: ["responses", "parameters"],
+        path: "/pets",
+        method: "get",
+      },
+      addPet: {
+        _shouldExist: ["responses", "requestBody"],
+        path: "/pet",
+        method: "post",
+      },
+      deletePet: {
+        _shouldExist: ["parameters", "responses"],
+        path: "/pet/{petId}",
+        method: "delete",
+      },
+    };
+    getAvailableOperations(schema as unknown as Document).forEach((operation) => {
+      const requirements = operationIdMap[operation.operationId as keyof typeof operationIdMap];
+      if (requirements) {
+        expect(requirements.path).toEqual(operation.path);
+        expect(requirements.method).toEqual(operation.method);
+        // eslint-disable-next-line @typescript-eslint/no-loop-func
+        requirements._shouldExist?.forEach((req) => {
+          expect(operation).toHaveProperty(req);
+        });
+      }
+    });
+  });
+  it("should return empty object if no correct json was passed", () => {
+    const operations = getAvailableOperations({} as unknown as Document);
+    expect(operations).toStrictEqual([]);
+  });
+});

package/__tests__/codegen/openapi/v3/utils.spec.ts

@@ -0,0 +1,28 @@
+import { promises as fsPromises } from "fs";
+import path from "path";
+
+import { getBaseUrl, isUrl, normalizeOperationId } from "codegen/openapi/utils";
+import { Document } from "codegen/openapi";
+
+describe("Utils", () => {
+  it("should check if provided path is url or not", () => {
+    const urlPath = "https://petstore3.swagger.io/api/v3/openapi.json";
+    const localpath = "./petstore.json";
+    expect(isUrl(urlPath)).toBe(true);
+    expect(isUrl(localpath)).toBe(false);
+  });
+
+  it("should normalize operation id", () => {
+    const normalizedOperationId = normalizeOperationId("/pets by id");
+    expect(normalizedOperationId).toBe("Pets_by_id");
+  });
+
+  it("should return available server link or empty string", async () => {
+    const file = await fsPromises.readFile(path.resolve(__dirname, "../schemas/v3/petstore-expanded.json"), "utf8");
+    const schema = JSON.parse(file);
+    const baseUrl = getBaseUrl(schema);
+    const emptyString = getBaseUrl({} as unknown as Document);
+    expect(baseUrl).toEqual("/api/v3");
+    expect(emptyString).toEqual("");
+  });
+});

package/__tests__/commands/generate/generate.spec.ts

@@ -0,0 +1,106 @@
+import { jest } from "@jest/globals";
+import { input, select, confirm } from "@inquirer/prompts";
+
+import { generate } from "commands/generate";
+import { handleError } from "utils/handle-error";
+import { preFlightGenerate } from "preflights/preflight-generate";
+import { OpenapiRequestGenerator } from "codegen/openapi/generator";
+
+// Mocks
+jest.mock("utils/handle-error", () => ({ handleError: jest.fn() }));
+jest.mock("preflights/preflight-generate", () => {
+  const fakeConfig = {
+    tsx: true,
+    aliases: { api: "/tmp", hooks: "/tmp", ui: "/tmp", components: "/tmp", lib: "/tmp" },
+    resolvedPaths: { cwd: "/tmp", api: "/tmp", hooks: "/tmp", ui: "/tmp", components: "/tmp", lib: "/tmp" },
+  };
+  return {
+    preFlightGenerate: jest.fn(async () => ({ errors: {}, config: fakeConfig })),
+  };
+});
+jest.mock("codegen/openapi/generator", () => {
+  class FakeGenerator {
+    static getSchemaFromUrl = jest.fn(async () => ({ openapi: "3.0.0", paths: {} }));
+    generateFile = jest.fn(async () => undefined);
+  }
+  return { OpenapiRequestGenerator: FakeGenerator };
+});
+jest.mock("utils/spinner", () => ({
+  spinner: jest.fn(() => ({
+    start: jest.fn(() => ({ succeed: jest.fn(), fail: jest.fn() })),
+  })),
+}));
+jest.mock("utils/logger", () => ({ logger: { info: jest.fn(), error: jest.fn(), log: jest.fn() } }));
+jest.mock("@inquirer/prompts", () => ({
+  input: jest.fn(),
+  select: jest.fn(),
+  confirm: jest.fn(),
+}));
+
+describe("cli generate command", () => {
+  const originalArgv = process.argv;
+  const exitSpy = jest
+    .spyOn(process, "exit")
+    .mockImplementation((() => undefined) as (code?: string | number | null | undefined) => never);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+    process.argv = originalArgv;
+  });
+
+  it("bypasses prompts and generates when params are provided", async () => {
+    process.argv = [
+      "/usr/local/bin/node",
+      "cli",
+      "--template",
+      "openapi",
+      "--url",
+      "https://example.com/openapi.json",
+      "--fileName",
+      "api-openapi.sdk.ts",
+      "--cwd",
+      "/tmp",
+      "--overwrite",
+    ];
+
+    await generate.parseAsync(process.argv, { from: "user" });
+
+    expect(preFlightGenerate).toHaveBeenCalled();
+    expect(select).not.toHaveBeenCalled();
+    expect(input).not.toHaveBeenCalled();
+    expect(confirm).not.toHaveBeenCalled();
+    expect(OpenapiRequestGenerator.getSchemaFromUrl).toHaveBeenCalledWith({
+      url: "https://example.com/openapi.json",
+      config: expect.any(Object),
+    });
+    expect(process.exit).toHaveBeenCalledWith(0);
+  });
+
+  it("handles invalid params by displaying error", async () => {
+    process.argv = [
+      "/usr/local/bin/node",
+      "cli",
+      "--template",
+      "invalid-template",
+      "--url",
+      "not-a-url",
+      "--fileName",
+      "api-invalid.sdk.ts",
+      "--cwd",
+      "/tmp",
+    ];
+
+    await generate.parseAsync(process.argv, { from: "user" });
+
+    expect(select).not.toHaveBeenCalled();
+    expect(input).not.toHaveBeenCalled();
+    expect(confirm).not.toHaveBeenCalled();
+    expect(handleError).toHaveBeenCalled();
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    expect(process.exit).not.toHaveBeenCalledWith(0);
+  });
+});

package/__tests__/global.d.ts

@@ -0,0 +1 @@
+import "jest-extended";

package/__tests__/jest.setup.ts

@@ -0,0 +1,5 @@
+import { AbortController } from "abortcontroller-polyfill/dist/cjs-ponyfill";
+
+if (!global.AbortController) {
+  global.AbortController = AbortController as any;
+}

package/__tests__/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "noEmit": true,
+    "baseUrl": "../src",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "exclude": ["node_modules", "dist", "__temp__"]
+}

package/jest.config.ts

@@ -0,0 +1,6 @@
+import type { Config } from "@jest/types";
+
+import { getJestConfig } from "../../jest.config";
+
+const config: Config.InitialOptions = getJestConfig();
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyper-fetch/cli",
-  "version": "7.5.2",
+  "version": "7.5.3",
   "description": "Hyper Fetch cli for code generation and utilities",
   "author": "Maciej Pyrc <maciekpyrc@gmail.com>, Kacper Skawina <kacper.skawina@gmail.com>",
   "homepage": "https://hyperfetch.bettertyped.com/",

package/project.json

@@ -0,0 +1,4 @@
+{
+  "name": "cli",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json"
+}