algolia-codegen 0.1.2 → 0.1.4

package/dist/cli.cjs

@@ -42,7 +42,7 @@ async function loadTypeScriptConfig(resolvedPath) {
   const result = esbuild.transformSync(source, {
     loader: "ts",
     format: "esm",
-    target: "node18",
+    target: "node20",
     sourcefile: resolvedPath
   });
   if (!result.code) {
@@ -56,10 +56,8 @@ async function loadTypeScriptConfig(resolvedPath) {
 // src/utils/validations/generator-config.ts
 function validateGeneratorConfig(config, path) {
   if (typeof config !== "object" || config === null || Array.isArray(config)) {
-    throw new Error(
-      `Invalid generator config: must be an object
-Path: ${path}`
-    );
+    throw new Error(`Invalid generator config: must be an object
+Path: ${path}`);
   }
   const cfg = config;
   const requiredFields = [
@@ -101,10 +99,8 @@ Received: ${typeof cfg.postfix}`
 // src/utils/validations/url-schema.ts
 function validateUrlSchema(urlSchema, path) {
   if (typeof urlSchema !== "object" || urlSchema === null || Array.isArray(urlSchema)) {
-    throw new Error(
-      `Invalid generates entry: must be an object
-Path: ${path}`
-    );
+    throw new Error(`Invalid generates entry: must be an object
+Path: ${path}`);
   }
   const schema = urlSchema;
   for (const [filePath, generatorConfig] of Object.entries(schema)) {
@@ -121,10 +117,8 @@ Path: ${path}[${filePath}]`
 // src/utils/validations/config.ts
 function validateConfig(config, configPath) {
   if (typeof config !== "object" || config === null || Array.isArray(config)) {
-    throw new Error(
-      `Invalid config: must be an object
-Config file: ${configPath}`
-    );
+    throw new Error(`Invalid config: must be an object
+Config file: ${configPath}`);
   }
   const cfg = config;
   if (!("overwrite" in cfg)) {
@@ -205,10 +199,8 @@ Make sure esbuild is installed as a dependency.`
       configModule = await import(configUrl);
     } catch (importError) {
       const errorMessage = importError instanceof Error ? importError.message : String(importError);
-      throw new Error(
-        `Failed to import config file: ${resolvedPath}
-Error: ${errorMessage}`
-      );
+      throw new Error(`Failed to import config file: ${resolvedPath}
+Error: ${errorMessage}`);
     }
   }
   if (!configModule.default) {
@@ -337,7 +329,7 @@ var TypeGenerator = class {
       return `${this.prefix}Hit${this.postfix}`;
     }
     const lastPart = path[path.length - 1];
-    const parts = lastPart.replace(/[\[\]]/g, "").split(/[-_\s]+/).filter(Boolean);
+    const parts = lastPart.replace(/[[\]]/g, "").split(/[-_\s]+/).filter(Boolean);
     const pascalCase = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
     if (path.length > 1) {
       const parent = path[path.length - 2];
@@ -489,30 +481,34 @@ function generateTypeScriptTypes(sampleHit, config) {
 }
 
 // src/utils/fetch-algolia-data.ts
-async function fetchAlgoliaData(filePath, generatorConfig, overwrite) {
-  console.log(`
-Processing file: ${filePath}`);
+async function fetchAlgoliaData(filePath, generatorConfig, overwrite, logger) {
+  logger.info(`Processing file: ${filePath}`);
   const resolvedPath = (0, import_path2.resolve)(process.cwd(), filePath);
+  logger.verbose(`Resolved path: ${resolvedPath}`);
   if ((0, import_fs3.existsSync)(resolvedPath) && !overwrite) {
     throw new Error(
       `File already exists: ${resolvedPath}
 Set overwrite: true in config to allow overwriting existing files.`
     );
   }
-  console.log(`Connecting to Algolia...`);
-  console.log(`App ID: ${generatorConfig.appId}`);
+  const connectSpinner = logger.spinner("Connecting to Algolia...");
+  connectSpinner.start();
   let client;
   try {
-    client = (0, import_algoliasearch.algoliasearch)(
-      generatorConfig.appId,
-      generatorConfig.searchKey
-    );
+    logger.verbose(`App ID: ${generatorConfig.appId}`);
+    logger.verbose(`Index: ${generatorConfig.indexName}`);
+    client = (0, import_algoliasearch.algoliasearch)(generatorConfig.appId, generatorConfig.searchKey);
+    connectSpinner.succeed("Connected to Algolia");
   } catch (error) {
+    connectSpinner.fail("Failed to connect to Algolia");
     throw new Error(
       `Failed to initialize Algolia client: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  console.log(`Fetching sample record from index: ${generatorConfig.indexName}`);
+  const fetchSpinner = logger.spinner(
+    `Fetching sample record from index: ${generatorConfig.indexName}`
+  );
+  fetchSpinner.start();
   let results;
   try {
     results = await client.search([
@@ -524,7 +520,9 @@ Set overwrite: true in config to allow overwriting existing files.`
         }
       }
     ]);
+    fetchSpinner.succeed("Sample record fetched successfully");
   } catch (error) {
+    fetchSpinner.fail("Failed to fetch data from Algolia");
     let errorMessage;
     if (error instanceof Error) {
       errorMessage = error.message;
@@ -556,52 +554,183 @@ Set overwrite: true in config to allow overwriting existing files.`
     throw new Error(`No hits found in Algolia index: ${generatorConfig.indexName}`);
   }
   const sampleHit = result.hits[0];
-  console.log("Sample record fetched successfully");
-  console.log(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  logger.verbose(`ObjectID: ${sampleHit.objectID || "N/A"}`);
+  const generateSpinner = logger.spinner("Generating TypeScript types...");
+  generateSpinner.start();
   const fileContent = generateTypeScriptTypes(sampleHit, generatorConfig);
+  generateSpinner.succeed("TypeScript types generated");
   const dir = (0, import_path2.dirname)(resolvedPath);
   if (!(0, import_fs3.existsSync)(dir)) {
-    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    if (!logger.isDryRun) {
+      (0, import_fs3.mkdirSync)(dir, { recursive: true });
+      logger.verbose(`Created directory: ${dir}`);
+    } else {
+      logger.dryRun(`Would create directory: ${dir}`);
+    }
+  }
+  if (logger.isDryRun) {
+    logger.dryRun(`Would write file: ${filePath}`);
+    logger.verbose(`File content length: ${fileContent.length} characters`);
+  } else {
+    (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
+    logger.success(`Generated file: ${filePath}`);
   }
-  (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
-  console.log(`Generated file: ${filePath}`);
 }
 
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var Logger = class {
+  _verbose;
+  _dryRun;
+  constructor(options = {}) {
+    this._verbose = options.verbose ?? false;
+    this._dryRun = options.dryRun ?? false;
+  }
+  /**
+   * Check if verbose mode is enabled
+   */
+  get isVerbose() {
+    return this._verbose;
+  }
+  /**
+   * Check if dry-run mode is enabled
+   */
+  get isDryRun() {
+    return this._dryRun;
+  }
+  /**
+   * Log info message (always shown)
+   */
+  info(message) {
+    console.log(import_chalk.default.blue("\u2139"), message);
+  }
+  /**
+   * Log success message (always shown)
+   */
+  success(message) {
+    console.log(import_chalk.default.green("\u2713"), message);
+  }
+  /**
+   * Log warning message (always shown)
+   */
+  warn(message) {
+    console.log(import_chalk.default.yellow("\u26A0"), message);
+  }
+  /**
+   * Log error message (always shown)
+   */
+  error(message) {
+    console.error(import_chalk.default.red("\u2717"), message);
+  }
+  /**
+   * Log verbose message (only shown in verbose mode)
+   */
+  verbose(message) {
+    if (this._verbose) {
+      console.log(import_chalk.default.gray("\u2192"), message);
+    }
+  }
+  /**
+   * Log dry-run message (only shown in dry-run mode)
+   */
+  dryRun(message) {
+    if (this._dryRun) {
+      console.log(import_chalk.default.cyan("[DRY-RUN]"), message);
+    }
+  }
+  /**
+   * Create a spinner for long-running operations
+   */
+  spinner(text) {
+    return (0, import_ora.default)({
+      text,
+      color: "cyan",
+      spinner: "dots"
+    });
+  }
+  /**
+   * Log file operation (respects dry-run)
+   */
+  fileOperation(action, filePath) {
+    if (this._dryRun) {
+      this.dryRun(`Would ${action}: ${import_chalk.default.underline(filePath)}`);
+    } else {
+      this.verbose(`${action}: ${filePath}`);
+    }
+  }
+  /**
+   * Format error with context
+   */
+  formatError(error, context) {
+    let errorMessage = "";
+    if (error instanceof Error) {
+      errorMessage = error.message;
+      if (this._verbose && error.stack) {
+        errorMessage += `
+${import_chalk.default.gray(error.stack)}`;
+      }
+    } else if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.message) {
+        errorMessage = String(errorObj.message);
+      } else if (errorObj.status) {
+        errorMessage = `HTTP ${errorObj.status}: ${errorObj.statusText || "Unknown error"}`;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error, null, 2);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+    } else {
+      errorMessage = String(error);
+    }
+    if (context) {
+      return `${import_chalk.default.red(context)}
+${errorMessage}`;
+    }
+    return errorMessage;
+  }
+};
+var logger_default = Logger;
+
 // src/index.ts
-var main = async (configPath) => {
+var main = async (options) => {
+  const opts = typeof options === "string" ? { configPath: options } : options ?? {};
+  const logger = new logger_default({
+    verbose: opts.verbose ?? false,
+    dryRun: opts.dryRun ?? false
+  });
   try {
-    const config = await loadConfig(configPath);
-    console.log("Config loaded successfully");
+    const configSpinner = logger.spinner("Loading configuration...");
+    configSpinner.start();
+    const config = await loadConfig(opts.configPath);
+    configSpinner.succeed("Configuration loaded successfully");
+    logger.verbose(`Config path: ${opts.configPath || "default"}`);
+    logger.verbose(`Overwrite mode: ${config.overwrite ? "enabled" : "disabled"}`);
     const generatesArray = Array.isArray(config.generates) ? config.generates : [config.generates];
+    logger.verbose(`Found ${generatesArray.length} generate configuration(s)`);
     for (const urlSchema of generatesArray) {
       for (const [filePath, generatorConfig] of Object.entries(urlSchema)) {
         try {
-          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite);
+          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite, logger);
         } catch (error) {
-          console.error(`
-Error processing file: ${filePath}`);
-          if (error instanceof Error) {
-            console.error(error.message);
-            if (error.stack) {
-              console.error(error.stack);
-            }
-          } else {
-            try {
-              console.error(JSON.stringify(error, null, 2));
-            } catch {
-              console.error(String(error));
-            }
-          }
+          logger.error(`Error processing file: ${filePath}`);
+          const errorMessage = logger.formatError(error, "Processing failed");
+          logger.error(errorMessage);
         }
       }
     }
-  } catch (error) {
-    console.error("Error loading config:");
-    if (error instanceof Error) {
-      console.error(error.message);
+    if (opts.dryRun) {
+      logger.info("Dry-run completed. No files were written.");
     } else {
-      console.error(String(error));
+      logger.success("All files generated successfully!");
     }
+  } catch (error) {
+    logger.error("Failed to load configuration");
+    const errorMessage = logger.formatError(error, "Configuration error");
+    logger.error(errorMessage);
     process.exit(1);
   }
 };
@@ -612,6 +741,10 @@ if ((0, import_fs4.existsSync)(envPath)) {
   (0, import_dotenv.config)({ path: envPath });
 }
 var program = new import_commander.Command();
-program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").action(async (options) => {
-  await main(options.config);
+program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").option("-v, --verbose", "Enable verbose output").option("--dry-run", "Simulate execution without writing files").action(async (options) => {
+  await main({
+    configPath: options.config,
+    verbose: options.verbose ?? false,
+    dryRun: options.dryRun ?? false
+  });
 }).parse();

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-R66ECGLW.js";
+} from "./chunk-USMYY2DN.js";
 
 // src/cli.ts
 import { config as loadDotenv } from "dotenv";
@@ -13,6 +13,10 @@ if (existsSync(envPath)) {
   loadDotenv({ path: envPath });
 }
 var program = new Command();
-program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").action(async (options) => {
-  await main(options.config);
+program.name("algolia-codegen").description("Generate TypeScript types from Algolia index").option("-c, --config <path>", "Config file path").option("-v, --verbose", "Enable verbose output").option("--dry-run", "Simulate execution without writing files").action(async (options) => {
+  await main({
+    configPath: options.config,
+    verbose: options.verbose ?? false,
+    dryRun: options.dryRun ?? false
+  });
 }).parse();