@hyper-fetch/cli 7.2.1

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@hyper-fetch/cli",
+  "version": "7.2.1",
+  "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/",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "source": "src/index.ts",
+  "cli": "src/cli/index.ts",
+  "climain": "dist/cli.cjs.js",
+  "bin": "dist/cli.cjs.js",
+  "scripts": {
+    "clean": "npx rimraf dist",
+    "test": "node --experimental-vm-modules ../../node_modules/jest/bin/jest --watchAll --maxWorkers=3 --forceExit",
+    "test:pipeline": "node --experimental-vm-modules ../../node_modules/jest/bin/jest --watchAll=false --maxWorkers=1 --no-cache --forceExit",
+    "dev": "npx tsx ./src/cli/index.ts",
+    "prebuild": "yarn update:version",
+    "build": "yarn clean && node ../../scripts/build.js",
+    "postbuild": "yarn rollup -c ../../rollup.config.js",
+    "update:version": "node ../../scripts/update-package-version.js --prefix hyper-fetch-cli-v",
+    "lint": "eslint . --ext .js,.jsx,.tsx,.ts --fix",
+    "format": "prettier --write .",
+    "typescheck": "tsc --noEmit --emitDeclarationOnly false",
+    "tests": "yarn lint-staged",
+    "release": "yarn semantic-release --extends ../../release.config.js  -t 'hyper-fetch-cli-v${version}'"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BetterTyped/hyper-fetch.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/BetterTyped/hyper-fetch/issues"
+  },
+  "dependencies": {
+    "@anttiviljami/dtsgenerator": "^3.12.2",
+    "@apidevtools/json-schema-ref-parser": "^11.9.3",
+    "@hyper-fetch/core": "*",
+    "@inquirer/prompts": "^7.6.0",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^11.0.0",
+    "execa": "^8.0.1",
+    "fs-extra": "^11.3.0",
+    "lodash": "^4.17.21",
+    "openapi-types": "^12.1.3",
+    "ora": "^8.2.0",
+    "prettier": "^3.6.2",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "zod": "^4.0.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "abortcontroller-polyfill": "^1.7.5"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "yarn jest --passWithNoTests"
+    ]
+  },
+  "keywords": [
+    "codegen",
+    "openapi",
+    "hyper fetch",
+    "swagger",
+    "openapi schema",
+    "code generator"
+  ]
+}

package/src/cli/index.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { select } from "@inquirer/prompts";
+
+import pkg from "../../package.json";
+import { generate } from "commands/generate";
+import { init } from "commands/init";
+
+const program = new Command();
+
+program.name("hyper-fetch").description("CLI for Hyper Fetch").version(pkg.version);
+
+const commands = {
+  init,
+  // add,
+  generate,
+};
+
+Object.values(commands).forEach((command) => {
+  program.addCommand(command);
+});
+
+const main = async () => {
+  try {
+    let chosenCommand: string | undefined;
+
+    if (process.argv[2] && Object.keys(commands).includes(process.argv[2])) {
+      const command = commands[process.argv[2] as keyof typeof commands]!;
+      chosenCommand = command.name();
+    }
+
+    if (!chosenCommand) {
+      chosenCommand = await select({
+        message: "What do you want to do?",
+        choices: program.commands.map((cmd) => ({
+          name: cmd.name(),
+          value: cmd.name(),
+          description: cmd.description(),
+        })),
+      });
+    }
+
+    await program.parseAsync([process.argv[0], process.argv[1], chosenCommand]);
+  } catch (e) {
+    if (e instanceof Error) {
+      if (e.message.includes("User force closed the prompt")) {
+        process.exit(0);
+      }
+    }
+    process.exit(1);
+  }
+};
+
+main();

package/src/codegen/index.ts

@@ -0,0 +1 @@
+export * from "./openapi/generator";

package/src/codegen/openapi/generator.ts

@@ -0,0 +1,338 @@
+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 prettier from "prettier";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { createClient } from "@hyper-fetch/core";
+
+import { Document, Operation, GeneratedTypes } from "./openapi.types";
+import { getAvailableOperations } from "./operations";
+import { adjustPathParamsFormat, normalizeOperationId, createTypeBaseName, isUrl } from "./utils";
+import { HttpMethod } from "./http-methods.enum";
+import { Config } from "config/schema";
+
+interface RefError {
+  path: string;
+  ref: string;
+  message: string;
+}
+
+const formatSchema = (obj: any, indent = 1): string => {
+  const indentation = "  ".repeat(indent);
+  const entries = Object.entries(obj)
+    .map(([key, value]) => {
+      const formattedKey = key.includes("-") ? `"${key}"` : key;
+      if (typeof value === "string") {
+        return `${indentation}${formattedKey}: ${value};`;
+      }
+      if (typeof value === "object" && value !== null) {
+        return `${indentation}${formattedKey}: {\n${formatSchema(value, indent + 1)}\n${indentation}};`;
+      }
+      return "";
+    })
+    .join("\n");
+  return entries;
+};
+
+export class OpenapiRequestGenerator {
+  protected openapiDocument: Document;
+  constructor(openapiDocument: any) {
+    this.openapiDocument = openapiDocument as Document;
+  }
+
+  async generateFile({ config, fileName }: { config: Config; fileName: string }) {
+    const defaultFileName = "openapi.client";
+    const { schemaTypes, generatedTypes, sdkSchema, createSdkFn } = await this.generateRequestsFromSchema();
+    const contents = [
+      `import { createSdk as coreCreateSdk, ClientInstance, RequestInstance } from "@hyper-fetch/core";`,
+      "\n\n",
+      schemaTypes,
+      "\n\n",
+      generatedTypes.join("\n\n"),
+      "\n\n",
+      sdkSchema,
+      "\n\n",
+      createSdkFn,
+    ].join("");
+    const prettierOpts = {
+      printWidth: 120,
+      tabWidth: 2,
+      useTabs: false,
+      semi: true,
+      singleQuote: false,
+      trailingComma: "all" as const,
+      bracketSpacing: true,
+      bracketSameLine: false,
+      proseWrap: "always" as const,
+      arrowParens: "always" as const,
+      parser: "typescript" as const,
+    };
+
+    const fName = fileName || defaultFileName;
+    const extension = config.tsx ? ".ts" : ".js";
+    const hasExtension = [".ts", ".js", ".tsx", ".jsx"].some((ext) => fName.endsWith(ext));
+    const generatedPath = path.join(config.resolvedPaths.api, `${fName}${hasExtension ? "" : extension}`);
+
+    const file = await prettier.format(contents, prettierOpts);
+    await fs.writeFile(generatedPath, file, {
+      flag: "w",
+    });
+
+    return generatedPath;
+  }
+
+  static getSchemaFromUrl = async ({ url, config }: { url: string; config: Config }) => {
+    if (isUrl(url)) {
+      const client = createClient({ url });
+      const getSchema = client.createRequest<{ response: Document }>()({ endpoint: "" });
+      const { data, error } = await getSchema.send();
+      if (data) {
+        return data;
+      }
+      throw error || new Error("Failed to fetch schema");
+    }
+
+    const schema = fs.readFileSync(path.join(config.resolvedPaths.cwd, url), "utf-8");
+    return JSON.parse(schema);
+  };
+
+  generateRequestsFromSchema = async () => {
+    const { schemaTypes, exportedTypes } = await OpenapiRequestGenerator.prepareSchema(this.openapiDocument);
+
+    const generatedTypes: string[] = [];
+    const schemaTree: Record<string, any> = {};
+
+    getAvailableOperations(this.openapiDocument).forEach((operation) => {
+      const meta = OpenapiRequestGenerator.generateMethodMetadata(operation, exportedTypes);
+      const operationTypes = OpenapiRequestGenerator.generateTypes(meta);
+      const requestInstanceType = OpenapiRequestGenerator.generateRequestInstanceType(meta, operationTypes);
+
+      generatedTypes.push(Object.values(operationTypes).join("\n"));
+
+      const { path: relPath, method } = meta;
+      const segments = relPath.split("/").filter(Boolean);
+
+      let currentLevel = schemaTree;
+      // eslint-disable-next-line no-restricted-syntax
+      for (const segment of segments) {
+        const key = segment.startsWith(":") ? `$${segment.slice(1)}` : segment;
+        if (!currentLevel[key]) {
+          currentLevel[key] = {};
+        }
+        currentLevel = currentLevel[key];
+      }
+      currentLevel[method.toLowerCase()] = requestInstanceType;
+    });
+
+    const sdkSchema = `export type SdkSchema<Client extends ClientInstance> = {\n${formatSchema(schemaTree)}\n}`;
+
+    const createSdkFn = `
+export const createSdk = <Client extends ClientInstance>(client: Client) => {
+  return coreCreateSdk<Client, SdkSchema<Client>>(client);
+};
+`;
+
+    return { schemaTypes, generatedTypes, sdkSchema, createSdkFn };
+  };
+
+  static generateRequestInstanceType(
+    { id, path: relPath }: { id: string; path: string },
+    types: Record<string, string>,
+  ) {
+    const Response = types[`${createTypeBaseName(id)}ResponseType`]
+      ? `${createTypeBaseName(id)}ResponseType`
+      : undefined;
+    const Payload = types[`${createTypeBaseName(id)}RequestBody`] ? `${createTypeBaseName(id)}RequestBody` : undefined;
+    const LocalError = types[`${createTypeBaseName(id)}ErrorType`] ? `${createTypeBaseName(id)}ErrorType` : undefined;
+    const QueryParams = types[`${createTypeBaseName(id)}QueryParams`]
+      ? `${createTypeBaseName(id)}QueryParams`
+      : undefined;
+
+    const genericTypes: string[] = [];
+
+    genericTypes.push(`client: Client`);
+    genericTypes.push(`endpoint: "${relPath}"`);
+
+    if (Response) {
+      genericTypes.push(`response: ${Response}`);
+    }
+    if (Payload) {
+      genericTypes.push(`payload: ${Payload}`);
+    }
+    if (LocalError) {
+      genericTypes.push(`error: ${LocalError}`);
+    }
+    if (QueryParams) {
+      genericTypes.push(`queryParams: ${QueryParams}`);
+    }
+
+    return `RequestInstance<{ ${genericTypes.join(", ")} }>`;
+  }
+
+  static generateHyperFetchRequest(
+    { id, path: relPath, method }: { id: string; path: string; method: string },
+    types: Record<string, string>,
+  ) {
+    const Response = types[`${createTypeBaseName(id)}ResponseType`]
+      ? `${createTypeBaseName(id)}ResponseType`
+      : undefined;
+    const Payload = types[`${createTypeBaseName(id)}RequestBody`] ? `${createTypeBaseName(id)}RequestBody` : undefined;
+    const LocalError = types[`${createTypeBaseName(id)}ErrorType`] ? `${createTypeBaseName(id)}ErrorType` : undefined;
+    const QueryParams = types[`${createTypeBaseName(id)}QueryParams`]
+      ? `${createTypeBaseName(id)}QueryParams`
+      : undefined;
+    const getVariableName = (str: string) => str.charAt(0).toLowerCase() + str.slice(1);
+
+    let genericType = "";
+
+    const addToGenericType = (key: string, value: string) => {
+      if (genericType) {
+        genericType += ",";
+      }
+      genericType += `${key}:${value}`;
+    };
+
+    if (Response) {
+      addToGenericType("response", Response);
+    }
+    if (Payload) {
+      addToGenericType("payload", Payload);
+    }
+    if (LocalError) {
+      addToGenericType("error", LocalError);
+    }
+    if (QueryParams) {
+      addToGenericType("query", QueryParams);
+    }
+
+    if (genericType) {
+      genericType = `<{${genericType}}>`;
+    }
+
+    return `export const ${getVariableName(
+      createTypeBaseName(id),
+    )} = client.createRequest${genericType}()({method: "${method}", endpoint: "${relPath}"})`;
+  }
+
+  static generateTypes({
+    id,
+    pathParametersType,
+    queryParametersType,
+    requestBodyType,
+    errorType,
+    responseType,
+  }: {
+    id: string;
+    pathParametersType: string | undefined;
+    queryParametersType: string | undefined;
+    requestBodyType: string | undefined;
+    errorType: string;
+    responseType: string;
+  }) {
+    const typeName = createTypeBaseName(id);
+    const types: GeneratedTypes<typeof typeName> = {};
+    if (pathParametersType) {
+      types[`${typeName}PathParams`] = `export type ${typeName}PathParams = ${pathParametersType}`;
+    }
+    if (queryParametersType) {
+      types[`${typeName}QueryParams`] = `export type ${typeName}QueryParams = ${queryParametersType}`;
+    }
+    if (requestBodyType) {
+      types[`${typeName}RequestBody`] = `export type ${typeName}RequestBody = ${requestBodyType}`;
+    }
+    if (errorType) {
+      types[`${typeName}ErrorType`] = `export type ${typeName}ErrorType = ${errorType}`;
+    }
+    if (responseType) {
+      types[`${typeName}ResponseType`] = `export type ${typeName}ResponseType = ${responseType}`;
+    }
+    return types;
+  }
+
+  static generateMethodMetadata(
+    operation: { operationId: string; path: string; method: string } & Partial<Operation>,
+    exportTypes: ExportedType[],
+  ) {
+    const { operationId, method, path: relPath } = operation;
+    const normalizedOperationId = normalizeOperationId(operationId);
+    const pathParametersType = find(exportTypes, {
+      schemaRef: `#/paths/${normalizedOperationId}/pathParameters`,
+    })?.path;
+    const queryParametersType = find(exportTypes, {
+      schemaRef: `#/paths/${normalizedOperationId}/queryParameters`,
+    })?.path;
+    const requestBodyType = find(exportTypes, { schemaRef: `#/paths/${normalizedOperationId}/requestBody` })?.path;
+    const responseTypePaths = chain(exportTypes)
+      .filter(({ schemaRef }) => schemaRef.startsWith(`#/paths/${normalizedOperationId}/responses/2`))
+      .map(({ path: responsePath }) => responsePath)
+      .value();
+    const errorTypePaths = chain(exportTypes)
+      .filter(
+        ({ schemaRef }) =>
+          schemaRef.startsWith(`#/paths/${normalizedOperationId}/responses/4`) ||
+          schemaRef.startsWith(`#/paths/${normalizedOperationId}/responses/5`),
+      )
+      .map(({ path: errorPath }) => errorPath)
+      .value();
+
+    const responseType = !isEmpty(responseTypePaths) ? responseTypePaths.join(" | ") : "any";
+    const errorType = !isEmpty(errorTypePaths) ? errorTypePaths.join(" | ") : "undefined";
+
+    return {
+      id: normalizedOperationId,
+      pathParametersType,
+      queryParametersType,
+      requestBodyType,
+      errorType,
+      responseType,
+      path: adjustPathParamsFormat(relPath),
+      method: method ? method.toUpperCase() : HttpMethod.GET,
+    };
+  }
+
+  static validateSchema(openapiDocument: Document) {
+    // Validate refs before processing
+    const errors: RefError[] = [];
+
+    function validateRefs(obj: any, refPath = "") {
+      if (!obj || typeof obj !== "object") return;
+
+      // Check if current object has $ref
+      if (obj.$ref && typeof obj.$ref === "string" && obj.$ref.endsWith("/")) {
+        errors.push({
+          path: refPath,
+          ref: obj.$ref,
+          message: `Invalid reference "${obj.$ref}" - reference path cannot end with '/'`,
+        });
+      }
+
+      // Recursively check all object properties
+      Object.entries(obj).forEach(([key, value]) => {
+        const newPath = refPath ? `${refPath}.${key}` : key;
+        validateRefs(value, newPath);
+      });
+    }
+
+    validateRefs(openapiDocument);
+
+    // If there are validation errors, throw them with details
+    if (errors.length > 0) {
+      const errorMessages = errors.map((err) => `Invalid reference at ${err.path}: ${err.message}`);
+      throw new Error(`Schema validation failed. The following errors were found:\n${errorMessages.join("\n")}`);
+    }
+  }
+
+  static async prepareSchema(openapiDocument: Document) {
+    OpenapiRequestGenerator.validateSchema(openapiDocument);
+
+    const rootSchema = await RefParser.bundle(openapiDocument);
+    const schema = parseSchema(rootSchema as any);
+    const generator = new DtsGenerator([schema]);
+    const schemaTypes = await generator.generate();
+    const exportedTypes = generator.getExports();
+
+    return { schemaTypes, exportedTypes };
+  }
+}

package/src/codegen/openapi/http-methods.enum.ts

@@ -0,0 +1,10 @@
+export enum HttpMethod {
+  GET = "get",
+  PUT = "put",
+  POST = "post",
+  PATCH = "patch",
+  DELETE = "delete",
+  OPTIONS = "options",
+  HEAD = "head",
+  TRACE = "trace",
+}

package/src/codegen/openapi/index.ts

@@ -0,0 +1,3 @@
+export * from "./generator";
+export * from "./openapi.types";
+export * from "./operations";

package/src/codegen/openapi/openapi.types.ts

@@ -0,0 +1,14 @@
+import { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+
+import { HttpMethod } from "./http-methods.enum";
+
+export interface Operation extends OpenAPIV3.OperationObject {
+  path: string;
+  method: HttpMethod;
+}
+
+export type Document = OpenAPIV3.Document | OpenAPIV3_1.Document;
+
+export type GeneratedTypes<T extends string> = {
+  [K in `${T}PathParams` | `${T}QueryParams` | `${T}RequestBody` | `${T}ResponseType` | `${T}ErrorType`]: string;
+};

package/src/codegen/openapi/operations.ts

@@ -0,0 +1,22 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+
+import { HttpMethod } from "./http-methods.enum";
+import { Operation } from "./openapi.types";
+
+export function getAvailableOperations(openApiJson: OpenAPIV3.Document | OpenAPIV3_1.Document) {
+  const paths = openApiJson.paths || {};
+  return Object.entries(paths).flatMap(([path, pathObject]) => {
+    return Object.values(HttpMethod)
+      .map((method) => ({ path, method, operation: pathObject?.[method] }))
+      .filter(({ operation }) => operation?.operationId)
+      .map(({ operation, method }) => {
+        const op: { operationId: string; path: string; method: string } & Partial<Operation> = {
+          ...operation,
+          operationId: operation!.operationId as string,
+          path,
+          method,
+        };
+        return op;
+      });
+  }) as ({ operationId: string } & Operation)[];
+}

package/src/codegen/openapi/utils.ts

@@ -0,0 +1,34 @@
+import { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+
+export function adjustPathParamsFormat(path: string) {
+  // Naive implementation for now:
+  return path.replace(/}/g, "").replace(/{/g, ":");
+}
+export function createTypeBaseName(str: string) {
+  const capitalizeFirstLetter = (s: string) => {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  };
+  return str.split("_").map(capitalizeFirstLetter).join("");
+}
+
+export function normalizeOperationId(key: string): string {
+  return key
+    .replace(/\/(.)/g, (_match: string, p1: string) => {
+      return p1.toUpperCase();
+    })
+    .replace(/}/g, "")
+    .replace(/{/g, "$")
+    .replace(/^\//, "")
+    .replace(/[^0-9A-Za-z_$]+/g, "_");
+}
+export const isUrl = (schemaPath: string) => {
+  try {
+    return Boolean(new URL(schemaPath));
+  } catch (e) {
+    return false;
+  }
+};
+
+export function getBaseUrl(openApiJson: OpenAPIV3.Document | OpenAPIV3_1.Document): string {
+  return openApiJson.servers?.[0]?.url ?? "";
+}

package/src/commands/add.ts

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import { checkbox, confirm } from "@inquirer/prompts";
+import { z } from "zod";
+
+// import { Registry } from "registry/schema";
+import { logger } from "../utils/logger";
+import { handleError } from "../utils/handle-error";
+import { preFlightAdd } from "preflights/preflight-add";
+import { showHelp } from "utils/show-help";
+
+// const registry: Registry[] = getRegistry();
+
+export const addOptionsSchema = z.object({
+  sdks: z.array(z.string()).optional().describe("names, url or local path to the sdks"),
+  yes: z.boolean().optional().describe("skip confirmation prompt."),
+  overwrite: z.boolean().optional().describe("overwrite existing files."),
+  cwd: z.string().describe("the working directory. defaults to the current directory."),
+});
+
+async function promptForSdks() {
+  const sdks = await checkbox({
+    message: "Which SDKs would you like to add?",
+    choices: [] as { name: string; value: string }[],
+    // choices: registry.map((sdk) => ({
+    //   name: sdk.meta.name,
+    //   value: sdk.meta.name,
+    // })),
+  });
+
+  return sdks;
+}
+
+// TODO: figure out a way to add sdks from registry?
+export const add = new Command()
+  .name("Add")
+  .description("Add SDK from registry to your project")
+  .argument("[sdks...]", "names, url or local path to the sdks")
+  .option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd())
+  .option("-y, --yes", "skip confirmation prompt.", false)
+  .option("-o, --overwrite", "overwrite existing files.", false)
+  .option("-h, --help <help>", "display help for command")
+  .action(async (sdks: string[], opts: z.infer<typeof addOptionsSchema>) => {
+    try {
+      const help = process.argv.includes("--help") || process.argv.includes("-h");
+
+      if (help) {
+        return showHelp(addOptionsSchema);
+      }
+
+      await preFlightAdd({
+        ...opts,
+        sdks,
+      });
+
+      const options = addOptionsSchema.parse({
+        sdks,
+        ...opts,
+      });
+
+      let selectedSdks = options.sdks;
+      if (!selectedSdks?.length) {
+        selectedSdks = await promptForSdks();
+      }
+
+      if (!selectedSdks?.length) {
+        logger.warn("No SDKs selected. Exiting.");
+        process.exit(0);
+      }
+
+      if (!options.yes) {
+        const proceed = await confirm({
+          message: `Ready to install the following SDKs?\n  - ${selectedSdks.join("\n  - ")}`,
+        });
+
+        if (!proceed) {
+          process.exit(0);
+        }
+      }
+
+      logger.info("Installing SDKs...");
+
+      // for (const sdk of selectedSdks) {
+      //  TODO: implement
+      // }
+
+      logger.success("SDKs installed successfully!");
+    } catch (error) {
+      handleError(error);
+    }
+  });