@hyper-fetch/cli 7.2.1

package/src/commands/generate.ts

@@ -0,0 +1,104 @@
+/* eslint-disable no-param-reassign */
+import { Command } from "commander";
+import { z } from "zod";
+import path from "path";
+import fs from "fs-extra";
+import { input, select, confirm } from "@inquirer/prompts";
+
+import { handleError } from "utils/handle-error";
+import { preFlightGenerate } from "preflights/preflight-generate";
+import { OpenapiRequestGenerator } from "codegen/openapi/generator";
+import { spinner } from "utils/spinner";
+import { logger } from "utils/logger";
+import { showHelp } from "utils/show-help";
+
+export const generateOptionsSchema = z.object({
+  template: z.enum(["openapi", "swagger"]).describe("API provider template to use"),
+  url: z.string().describe("The URL to generate the schema from"),
+  fileName: z.string().describe("The output file for the SDK."),
+  cwd: z.string().describe("The working directory. defaults to the current directory."),
+  overwrite: z.boolean().optional().describe("Overwrite existing files."),
+});
+
+export const generate = new Command()
+  .name("Generate")
+  .description("Generate SDK from a schema, url or service")
+  .option("-t, --template <template>", "API provider template to use")
+  .option("-u, --url <url>", "The URL to generate the schema from")
+  .option("-f, --fileName <fileName>", "The output file for the SDK.")
+  .option("-o, --overwrite", "overwrite existing files.")
+  .option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd())
+  .option("-h, --help <help>", "display help for command")
+  .action(async (opts: z.infer<typeof generateOptionsSchema>) => {
+    try {
+      const help = process.argv.includes("--help") || process.argv.includes("-h");
+
+      if (help) {
+        return showHelp(generateOptionsSchema);
+      }
+      const { config } = await preFlightGenerate(opts);
+
+      if (!opts.template) {
+        opts.template = await select({
+          message: "What source we want to use?",
+          choices: [
+            { name: "OpenAPI (v3)", value: "openapi" },
+            { name: "Swagger", value: "swagger" },
+          ],
+        });
+      }
+
+      if (!opts.url) {
+        opts.url = await input({
+          message: "Enter the URL to generate the schema from:",
+          validate: (value) => {
+            const result = z.url("Please enter a valid URL.").safeParse(value);
+            if (result.success) return true;
+            return result.error.message;
+          },
+        });
+      }
+
+      if (!opts.fileName) {
+        opts.fileName = await input({
+          message: "Enter the file name for the SDK:",
+          default: `api-${opts.template}.sdk.ts`,
+        });
+      }
+
+      const fileExists = fs.existsSync(path.join(opts.cwd, opts.fileName));
+      if (opts.overwrite === undefined && fileExists) {
+        opts.overwrite = await confirm({ message: "Overwrite existing files?" });
+      }
+
+      if (opts.overwrite === false && fileExists) {
+        return logger.info(`File ${opts.fileName} already exists. Use --overwrite to overwrite.`);
+      }
+
+      const options = generateOptionsSchema.parse(opts);
+
+      const componentSpinner = spinner(`Writing ${options.fileName}...`).start();
+      switch (options.template) {
+        case "openapi": {
+          const openapiSchema = await OpenapiRequestGenerator.getSchemaFromUrl({ url: options.url!, config });
+          const generator = new OpenapiRequestGenerator(openapiSchema);
+          await generator.generateFile({ fileName: options.fileName, config });
+          componentSpinner.succeed();
+          return process.exit(0);
+        }
+        case "swagger": {
+          const openapiSchema = await OpenapiRequestGenerator.getSchemaFromUrl({ url: options.url!, config });
+          const generator = new OpenapiRequestGenerator(openapiSchema);
+          await generator.generateFile({ fileName: options.fileName, config });
+          componentSpinner.succeed();
+          return process.exit(0);
+        }
+        default: {
+          componentSpinner.fail();
+          throw new Error(`Invalid template: ${options.template}`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/init.ts

@@ -0,0 +1,191 @@
+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 { handleError } from "../utils/handle-error";
+import { spinner } from "../utils/spinner";
+import { configSchema, Config } from "config/schema";
+import { logger } from "utils/logger";
+import { getTsConfigAliasPrefix } from "config/get-ts-alias";
+import { showHelp } from "utils/show-help";
+
+const initOptionsSchema = z.object({
+  yes: z.boolean().optional().describe("skip confirmation prompt."),
+  cwd: z.string().describe("the working directory. defaults to the current directory."),
+});
+
+type Step = {
+  name: string;
+  action: (config: Partial<Config>) => Promise<Partial<Config> | void>;
+};
+
+export const init = new Command()
+  .name("Init")
+  .description("Initialize HyperFetch Client configuration.")
+  .option("-y, --yes", "skip confirmation prompt.", false)
+  .option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd())
+  .option("-h, --help <help>", "display help for command")
+  .action(async (opts) => {
+    try {
+      const help = process.argv.includes("--help") || process.argv.includes("-h");
+
+      if (help) {
+        return showHelp(initOptionsSchema);
+      }
+
+      const { cwd, yes } = initOptionsSchema.parse(opts);
+
+      let config: Partial<Config> = {};
+
+      let mainPath: string;
+      let apiDir: string;
+
+      if (yes) {
+        mainPath = "src";
+        apiDir = "api";
+      } else {
+        // 1. ask for the path to the main directory
+        mainPath = await select({
+          message: "Select the main directory for your project:",
+          choices: [
+            { name: "src", value: "src" },
+            { name: "app", value: "app" },
+            { name: "other", value: "other" },
+          ],
+        });
+
+        if (mainPath === "other") {
+          mainPath = await input({
+            message: "Enter the path to the main directory:",
+            validate: (value) => {
+              if (!value) return "Path cannot be empty.";
+              return true;
+            },
+          });
+        }
+
+        // 2. text field - asking for the directory of api
+        apiDir = await input({
+          message: "Enter the name of the API directory:",
+          default: "api",
+          validate: (value) => {
+            if (!value) return "Directory name cannot be empty.";
+            return true;
+          },
+        });
+      }
+
+      const fullPath = path.join(cwd, mainPath, apiDir);
+      const relativePath = path.join(mainPath, apiDir);
+      const configPath = path.join(cwd, "api.json");
+
+      const aliasPrefix = (await getTsConfigAliasPrefix(cwd)) || "";
+      const alias = aliasPrefix ? `${aliasPrefix}/` : "";
+
+      const defaultAliases: Config["aliases"] = {
+        api: `${alias}${apiDir}`,
+        hooks: `${alias}hooks`,
+        ui: `${alias}components/ui`,
+        components: `${alias}components`,
+        lib: `${alias}lib`,
+      };
+
+      const defaultConfig: Omit<Config, "resolvedPaths"> = {
+        tsx: true,
+        aliases: defaultAliases,
+      };
+
+      logger.break();
+
+      const steps: Step[] = [
+        {
+          name: `Initialize API directory at ${relativePath}`,
+          action: async () => {
+            if (!existsSync(fullPath)) {
+              await mkdir(fullPath, { recursive: true });
+            }
+          },
+        },
+        {
+          name: "Setup configuration",
+          action: async (currentConfig) => {
+            if (existsSync(configPath)) {
+              const existingConfig = JSON.parse(readFileSync(configPath, "utf8"));
+              const { success, error, data } = configSchema.omit({ resolvedPaths: true }).safeParse({
+                ...defaultConfig,
+                ...existingConfig,
+                aliases: {
+                  ...defaultConfig.aliases,
+                  ...existingConfig.aliases,
+                },
+              });
+
+              if (error) {
+                logger.break();
+                logger.error(`Invalid configuration found in ${configPath}.`);
+                handleError(error);
+                logger.break();
+              }
+
+              if (success) {
+                return data;
+              }
+            }
+            return currentConfig;
+          },
+        },
+        {
+          name: "Setup Aliases",
+          action: async (currentConfig) => {
+            if (currentConfig.aliases) {
+              return currentConfig;
+            }
+
+            return {
+              ...currentConfig,
+              aliases: defaultAliases,
+            };
+          },
+        },
+        {
+          name: `Create api.json configuration file`,
+          action: async (currentConfig) => {
+            const finalConfig = {
+              ...defaultConfig,
+              ...currentConfig,
+              aliases: {
+                ...defaultConfig.aliases,
+                ...currentConfig.aliases,
+              },
+            };
+
+            configSchema.omit({ resolvedPaths: true }).parse(finalConfig);
+
+            await writeFile(configPath, JSON.stringify(finalConfig, null, 2));
+          },
+        },
+      ];
+
+      logger.break();
+      logger.info("Starting HyperFetch CLI initialization...");
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const step of steps) {
+        const s = spinner(step.name).start();
+        // eslint-disable-next-line no-await-in-loop
+        const result = await step.action(config);
+        if (result) {
+          config = result;
+        }
+        s.succeed();
+      }
+
+      logger.break();
+      logger.info("Configuration has been generated successfully! 🎉");
+      logger.info(`You can now find your configuration at ${configPath}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/config/get-config.ts

@@ -0,0 +1,59 @@
+import path from "path";
+import fs from "fs-extra";
+import { loadConfig } from "tsconfig-paths";
+
+import { highlighter } from "utils/highlighter";
+import { resolveImport } from "utils/resolve-import";
+import { logger } from "../utils/logger";
+import { handleError } from "../utils/handle-error";
+import { configSchema, Config } from "config/schema";
+
+export async function resolveConfigPaths(cwd: string, config: Omit<Config, "resolvedPaths">): Promise<Config> {
+  // Read tsconfig.json.
+  const tsConfig = await loadConfig(cwd);
+
+  if (tsConfig.resultType === "failed") {
+    throw new Error(`Failed to load ${config.tsx ? "tsconfig" : "jsconfig"}.json. ${tsConfig.message ?? ""}`.trim());
+  }
+
+  return configSchema.parse({
+    ...config,
+    resolvedPaths: {
+      cwd,
+      api: await resolveImport(config.aliases.api, tsConfig),
+      components: await resolveImport(config.aliases.components, tsConfig),
+      lib: await resolveImport(config.aliases.lib, tsConfig),
+      hooks: await resolveImport(config.aliases.hooks, tsConfig),
+      ui: await resolveImport(config.aliases.ui, tsConfig),
+    },
+  });
+}
+
+export async function getConfig(cwd: string): Promise<Config | null> {
+  // Check for existing api.json file.
+  if (!fs.existsSync(path.resolve(cwd, "api.json"))) {
+    logger.break();
+    logger.error(
+      `An invalid ${highlighter.info("api.json")} file was found at ${highlighter.info(
+        cwd,
+      )}.\nBefore you can add or generate SDKs, you must create a valid ${highlighter.info(
+        "api.json",
+      )} file by running the ${highlighter.info("init")} command.`,
+    );
+    logger.break();
+    process.exit(1);
+  }
+  const { data, error } = await configSchema
+    .omit({ resolvedPaths: true }) // We enrich it later
+    .safeParseAsync(JSON.parse(fs.readFileSync(path.resolve(cwd, "api.json"), "utf8")));
+
+  if (error) {
+    handleError(error);
+  }
+
+  if (!data) {
+    throw new Error(`Invalid configuration found in ${highlighter.info(cwd)}.`);
+  }
+
+  return resolveConfigPaths(cwd, data);
+}

package/src/config/get-ts-alias.ts

@@ -0,0 +1,25 @@
+import { loadConfig } from "tsconfig-paths";
+
+export async function getTsConfigAliasPrefix(cwd: string) {
+  const tsConfig = await loadConfig(cwd);
+
+  if (tsConfig?.resultType === "failed" || !Object.entries(tsConfig?.paths).length) {
+    return null;
+  }
+
+  // This assume that the first alias is the prefix.
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [alias, paths] of Object.entries(tsConfig.paths)) {
+    if (
+      paths.includes("./*") ||
+      paths.includes("./src/*") ||
+      paths.includes("./app/*") ||
+      paths.includes("./resources/js/*") // Laravel.
+    ) {
+      return alias.replace(/\/\*$/, "") ?? null;
+    }
+  }
+
+  // Use the first alias as the prefix.
+  return Object.keys(tsConfig?.paths)?.[0].replace(/\/\*$/, "") ?? null;
+}

package/src/config/schema.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+export const configSchema = z.object({
+  tsx: z.boolean(),
+  aliases: z.object({
+    api: z.string(),
+    hooks: z.string(),
+    ui: z.string(),
+    components: z.string(),
+    lib: z.string(),
+  }),
+  resolvedPaths: z.object({
+    cwd: z.string(),
+    api: z.string(),
+    hooks: z.string(),
+    ui: z.string(),
+    components: z.string(),
+    lib: z.string(),
+  }),
+});
+
+export type Config = z.infer<typeof configSchema>;

package/src/index.ts

@@ -0,0 +1 @@
+export * from "codegen";

package/src/preflights/preflight-add.ts

@@ -0,0 +1,43 @@
+import path from "path";
+import fs from "fs-extra";
+import { z } from "zod";
+
+import { addOptionsSchema } from "commands/add";
+import * as ERRORS from "utils/errors";
+import { getConfig } from "config/get-config";
+import { highlighter } from "utils/highlighter";
+import { logger } from "utils/logger";
+
+export async function preFlightAdd(options: z.infer<typeof addOptionsSchema>) {
+  const errors: Record<string, boolean> = {};
+
+  // Ensure target directory exists.
+  // Check for empty project. We assume if no package.json exists, the project is empty.
+  if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
+    errors[ERRORS.MISSING_DIR_OR_EMPTY_PROJECT] = true;
+    return {
+      errors,
+      config: null,
+    };
+  }
+
+  try {
+    const config = await getConfig(options.cwd);
+
+    return {
+      errors,
+      config: config!,
+    };
+  } catch (error) {
+    logger.break();
+    logger.error(
+      `An invalid ${highlighter.info("api.json")} file was found at ${highlighter.info(
+        options.cwd,
+      )}.\nBefore you can add SDKs, you must create a valid ${highlighter.info(
+        "api.json",
+      )} file by running the ${highlighter.info("init")} command.`,
+    );
+    logger.break();
+    process.exit(1);
+  }
+}

package/src/preflights/preflight-generate.ts

@@ -0,0 +1,46 @@
+import path from "path";
+import fs from "fs-extra";
+import { z } from "zod";
+
+import { generateOptionsSchema } from "commands/generate";
+import * as ERRORS from "utils/errors";
+import { getConfig } from "config/get-config";
+import { Config } from "config/schema";
+import { highlighter } from "utils/highlighter";
+import { logger } from "utils/logger";
+import { handleError } from "utils/handle-error";
+
+export async function preFlightGenerate(options: z.infer<typeof generateOptionsSchema>): Promise<{
+  errors: Record<string, boolean>;
+  config: Config;
+}> {
+  const errors: Record<string, boolean> = {};
+
+  // Ensure target directory exists.
+  // Check for empty project. We assume if no package.json exists, the project is empty.
+  if (!fs.existsSync(options.cwd) || !fs.existsSync(path.resolve(options.cwd, "package.json"))) {
+    errors[ERRORS.MISSING_DIR_OR_EMPTY_PROJECT] = true;
+
+    handleError(errors);
+  }
+
+  try {
+    const config = await getConfig(options.cwd);
+
+    return {
+      errors,
+      config: config!,
+    };
+  } catch (error) {
+    logger.break();
+    logger.error(
+      `An invalid ${highlighter.info("api.json")} file was found at ${highlighter.info(
+        options.cwd,
+      )}.\nBefore you can add SDKs, you must create a valid ${highlighter.info(
+        "api.json",
+      )} file by running the ${highlighter.info("init")} command.`,
+    );
+    logger.break();
+    process.exit(1);
+  }
+}

package/src/utils/errors.ts

@@ -0,0 +1,13 @@
+export const MISSING_DIR_OR_EMPTY_PROJECT = "1";
+export const EXISTING_CONFIG = "2";
+export const MISSING_CONFIG = "3";
+export const FAILED_CONFIG_READ = "4";
+export const TAILWIND_NOT_CONFIGURED = "5";
+export const IMPORT_ALIAS_MISSING = "6";
+export const UNSUPPORTED_FRAMEWORK = "7";
+export const COMPONENT_URL_NOT_FOUND = "8";
+export const COMPONENT_URL_UNAUTHORIZED = "9";
+export const COMPONENT_URL_FORBIDDEN = "10";
+export const COMPONENT_URL_BAD_REQUEST = "11";
+export const COMPONENT_URL_INTERNAL_SERVER_ERROR = "12";
+export const BUILD_MISSING_REGISTRY_FILE = "13";

package/src/utils/handle-error.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { z } from "zod";
+
+import { logger } from "utils/logger";
+
+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("");
+  if (typeof error === "string") {
+    logger.error(error);
+    logger.break();
+    process.exit(1);
+  }
+
+  if (error instanceof z.ZodError) {
+    logger.error("Validation failed:");
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [key, value] of Object.entries(error.flatten().fieldErrors)) {
+      logger.error(`- ${chalk.cyan(key)}: ${value}`);
+    }
+    logger.break();
+    process.exit(1);
+  }
+
+  if (error instanceof Error) {
+    logger.error(error.message);
+    logger.break();
+    process.exit(1);
+  }
+
+  logger.break();
+  process.exit(1);
+}

package/src/utils/highlighter.ts

@@ -0,0 +1,8 @@
+import { cyan, green, red, yellow } from "kleur/colors";
+
+export const highlighter = {
+  error: red,
+  warn: yellow,
+  info: cyan,
+  success: green,
+};

package/src/utils/logger.ts

@@ -0,0 +1,20 @@
+/* eslint-disable no-console */
+import chalk from "chalk";
+
+export const logger = {
+  info(...args: unknown[]) {
+    console.log(chalk.cyan("ℹ"), chalk.blue.bold("info"), ...args);
+  },
+  warn(...args: unknown[]) {
+    console.log(chalk.yellow("⚠"), chalk.yellow.bold("warn"), ...args);
+  },
+  error(...args: unknown[]) {
+    console.log(chalk.red("✖"), chalk.red.bold("error"), ...args);
+  },
+  success(...args: unknown[]) {
+    console.log(chalk.green("✔"), chalk.green.bold("success"), ...args);
+  },
+  break() {
+    console.log("");
+  },
+};

package/src/utils/resolve-import.ts

@@ -0,0 +1,14 @@
+import { createMatchPath, type ConfigLoaderSuccessResult } from "tsconfig-paths";
+
+export async function resolveImport(
+  importPath: string,
+  config: Pick<ConfigLoaderSuccessResult, "absoluteBaseUrl" | "paths">,
+) {
+  return createMatchPath(config.absoluteBaseUrl, config.paths)(importPath, undefined, () => true, [
+    ".ts",
+    ".tsx",
+    ".jsx",
+    ".js",
+    ".css",
+  ]);
+}

package/src/utils/show-help.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import Table from "cli-table3";
+
+import { zodToTable } from "./zod-to-table";
+
+export const showHelp = (schema: z.ZodType) => {
+  const rows = zodToTable(schema).map(({ name, description }) => [`--${name}`, description || ""]);
+
+  const maxOptionLength = rows.reduce((max, row) => Math.max(max, row[0].length), 0);
+  const terminalWidth = process.stdout.columns;
+
+  const tableOptions: Table.TableConstructorOptions = {
+    head: ["Option", "Description"],
+    style: {
+      head: ["blue"],
+    },
+    wordWrap: true,
+  };
+
+  if (terminalWidth) {
+    // Accounting for borders and padding.
+    const tableOverhead = 7;
+    const optionColWidth = maxOptionLength + 2;
+    const descriptionColWidth = terminalWidth - optionColWidth - tableOverhead;
+
+    if (descriptionColWidth > 10) {
+      tableOptions.colWidths = [optionColWidth, descriptionColWidth];
+    }
+  }
+
+  const table = new Table(tableOptions);
+
+  table.push(...rows);
+
+  // eslint-disable-next-line no-console
+  console.log(table.toString());
+};

package/src/utils/spinner.ts

@@ -0,0 +1,13 @@
+import ora, { type Options } from "ora";
+
+export function spinner(
+  text: Options["text"],
+  options?: {
+    silent?: boolean;
+  },
+) {
+  return ora({
+    text,
+    isSilent: options?.silent,
+  });
+}

package/src/utils/zod-to-table.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const zodToTable = (schema: z.ZodType): { name: string; description: string | undefined }[] => {
+  if (schema instanceof z.ZodObject) {
+    const { shape } = schema;
+    return Object.keys(shape).map((key) => {
+      const fieldSchema = shape[key];
+
+      return {
+        name: key,
+        description: fieldSchema.description,
+      };
+    });
+  }
+  return [];
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "strict": true,
+    "baseUrl": "./src",
+    "jsx": "react-jsx"
+  },
+  "exclude": ["node_modules", "dist", "jest.config.ts", "__tests__"]
+}