algolia-codegen 0.1.0 → 0.1.2

package/dist/cli.cjs

@@ -1,16 +1,617 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/cli.ts
+var import_dotenv = require("dotenv");
+var import_fs4 = require("fs");
+var import_path3 = require("path");
 var import_commander = require("commander");
 
+// src/utils/load-config.ts
+var import_fs2 = require("fs");
+var import_path = require("path");
+var import_url = require("url");
+
+// src/utils/load-typescript-config.ts
+var import_fs = require("fs");
+async function loadTypeScriptConfig(resolvedPath) {
+  const esbuild = await import("esbuild");
+  const source = (0, import_fs.readFileSync)(resolvedPath, "utf-8");
+  const result = esbuild.transformSync(source, {
+    loader: "ts",
+    format: "esm",
+    target: "node18",
+    sourcefile: resolvedPath
+  });
+  if (!result.code) {
+    throw new Error("Failed to transform TypeScript config file");
+  }
+  const dataUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(result.code)}`;
+  const module2 = await import(dataUrl);
+  return module2;
+}
+
+// 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}`
+    );
+  }
+  const cfg = config;
+  const requiredFields = [
+    "appId",
+    "searchKey",
+    "indexName"
+  ];
+  for (const field of requiredFields) {
+    if (!(field in cfg)) {
+      throw new Error(
+        `Invalid generator config: missing required property '${field}'
+Path: ${path}`
+      );
+    }
+    if (typeof cfg[field] !== "string") {
+      throw new Error(
+        `Invalid generator config: '${field}' must be a string
+Path: ${path}
+Received: ${typeof cfg[field]}`
+      );
+    }
+  }
+  if ("prefix" in cfg && cfg.prefix !== void 0 && typeof cfg.prefix !== "string") {
+    throw new Error(
+      `Invalid generator config: 'prefix' must be a string or undefined
+Path: ${path}
+Received: ${typeof cfg.prefix}`
+    );
+  }
+  if ("postfix" in cfg && cfg.postfix !== void 0 && typeof cfg.postfix !== "string") {
+    throw new Error(
+      `Invalid generator config: 'postfix' must be a string or undefined
+Path: ${path}
+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}`
+    );
+  }
+  const schema = urlSchema;
+  for (const [filePath, generatorConfig] of Object.entries(schema)) {
+    if (typeof filePath !== "string") {
+      throw new Error(
+        `Invalid generates entry: file path must be a string
+Path: ${path}[${filePath}]`
+      );
+    }
+    validateGeneratorConfig(generatorConfig, `${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}`
+    );
+  }
+  const cfg = config;
+  if (!("overwrite" in cfg)) {
+    throw new Error(
+      `Invalid config: missing required property 'overwrite'
+Config file: ${configPath}`
+    );
+  }
+  if (typeof cfg.overwrite !== "boolean") {
+    throw new Error(
+      `Invalid config: 'overwrite' must be a boolean
+Config file: ${configPath}
+Received: ${typeof cfg.overwrite}`
+    );
+  }
+  if (!("generates" in cfg)) {
+    throw new Error(
+      `Invalid config: missing required property 'generates'
+Config file: ${configPath}`
+    );
+  }
+  const generates = cfg.generates;
+  if (Array.isArray(generates)) {
+    generates.forEach((item, index) => {
+      validateUrlSchema(item, `${configPath}[generates][${index}]`);
+    });
+  } else if (typeof generates === "object" && generates !== null) {
+    validateUrlSchema(generates, `${configPath}[generates]`);
+  } else {
+    throw new Error(
+      `Invalid config: 'generates' must be an object or an array of objects
+Config file: ${configPath}
+Received: ${typeof generates}`
+    );
+  }
+}
+
+// src/utils/load-config.ts
+async function loadConfig(configPath) {
+  const defaultConfigPath = "algolia-codegen.ts";
+  const finalConfigPath = configPath || defaultConfigPath;
+  const resolvedPath = (0, import_path.resolve)(process.cwd(), finalConfigPath);
+  if (!(0, import_fs2.existsSync)(resolvedPath)) {
+    throw new Error(
+      `Config file not found: ${resolvedPath}
+Please create a config file or specify a different path using --config option.`
+    );
+  }
+  const configUrl = (0, import_url.pathToFileURL)(resolvedPath).href;
+  let configModule;
+  if (resolvedPath.endsWith(".ts")) {
+    try {
+      configModule = await loadTypeScriptConfig(resolvedPath);
+    } catch (tsError) {
+      const jsPath = resolvedPath.replace(/\.ts$/, ".js");
+      if ((0, import_fs2.existsSync)(jsPath)) {
+        const jsUrl = (0, import_url.pathToFileURL)(jsPath).href;
+        try {
+          configModule = await import(jsUrl);
+        } catch (jsImportError) {
+          throw new Error(
+            `Failed to import config file: ${resolvedPath}
+Tried both .ts (via esbuild) and .js extensions.
+TypeScript error: ${tsError instanceof Error ? tsError.message : String(tsError)}
+JavaScript error: ${jsImportError instanceof Error ? jsImportError.message : String(jsImportError)}`
+          );
+        }
+      } else {
+        throw new Error(
+          `Failed to load TypeScript config file: ${resolvedPath}
+Error: ${tsError instanceof Error ? tsError.message : String(tsError)}
+Make sure esbuild is installed as a dependency.`
+        );
+      }
+    }
+  } else {
+    try {
+      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}`
+      );
+    }
+  }
+  if (!configModule.default) {
+    throw new Error(
+      `Config file does not export a default object: ${resolvedPath}
+Please ensure your config file exports a default object: export default { ... }`
+    );
+  }
+  const config = configModule.default;
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    throw new Error(
+      `Config file default export must be an object: ${resolvedPath}
+Received: ${typeof config}`
+    );
+  }
+  validateConfig(config, resolvedPath);
+  return config;
+}
+
+// src/utils/fetch-algolia-data.ts
+var import_algoliasearch = require("algoliasearch");
+var import_fs3 = require("fs");
+var import_path2 = require("path");
+
+// src/utils/generate-typescript-types.ts
+var TypeGenerator = class {
+  typeMap = /* @__PURE__ */ new Map();
+  generatedTypes = /* @__PURE__ */ new Set();
+  idValueTypes = /* @__PURE__ */ new Set();
+  prefix;
+  postfix;
+  indexName;
+  constructor(config) {
+    this.prefix = config.prefix || "";
+    this.postfix = config.postfix || "";
+    this.indexName = config.indexName;
+  }
+  /**
+   * Convert a value to its TypeScript type representation
+   */
+  inferType(value, path = []) {
+    if (value === null || value === void 0) {
+      return { type: "unknown", isOptional: true, isArray: false, nestedTypes: /* @__PURE__ */ new Map() };
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return { type: "unknown[]", isOptional: false, isArray: true, nestedTypes: /* @__PURE__ */ new Map() };
+      }
+      const itemTypes = value.map((item, idx) => this.inferType(item, [...path, `[${idx}]`]));
+      if (this.isIdValuePattern(value)) {
+        const firstItem = value[0];
+        const valueType = this.inferType(firstItem.value, [...path, "[0].value"]);
+        const idValueTypeName = `${this.prefix}IdValue`;
+        this.idValueTypes.add(idValueTypeName);
+        const typeString = valueType.type !== "string" ? `${idValueTypeName}<${valueType.type}>` : idValueTypeName;
+        return {
+          type: `${typeString}[]`,
+          isOptional: false,
+          isArray: true,
+          nestedTypes: /* @__PURE__ */ new Map()
+        };
+      }
+      const firstType = itemTypes[0];
+      const allSameType = itemTypes.every(
+        (t) => t.type === firstType.type && !t.isArray && t.nestedTypes.size === firstType.nestedTypes.size
+      );
+      if (allSameType && !firstType.isArray) {
+        return {
+          type: `${firstType.type}[]`,
+          isOptional: false,
+          isArray: true,
+          nestedTypes: firstType.nestedTypes
+        };
+      }
+      const uniqueTypes = Array.from(new Set(itemTypes.map((t) => t.type)));
+      const unionType = uniqueTypes.length === 1 ? uniqueTypes[0] : uniqueTypes.join(" | ");
+      return {
+        type: `${unionType}[]`,
+        isOptional: false,
+        isArray: true,
+        nestedTypes: /* @__PURE__ */ new Map()
+      };
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      const typeName = this.generateTypeName(path);
+      const nestedTypes = /* @__PURE__ */ new Map();
+      for (const [key, val] of Object.entries(obj)) {
+        nestedTypes.set(key, this.inferType(val, [...path, key]));
+      }
+      if (!this.generatedTypes.has(typeName)) {
+        this.generatedTypes.add(typeName);
+        this.typeMap.set(typeName, this.generateInterface(typeName, nestedTypes, obj));
+      }
+      return {
+        type: typeName,
+        isOptional: false,
+        isArray: false,
+        nestedTypes
+      };
+    }
+    const jsType = typeof value;
+    let tsType;
+    if (jsType === "number") {
+      tsType = "number";
+    } else if (jsType === "boolean") {
+      tsType = "boolean";
+    } else {
+      tsType = "string";
+    }
+    return { type: tsType, isOptional: false, isArray: false, nestedTypes: /* @__PURE__ */ new Map() };
+  }
+  /**
+   * Check if an array follows the AlgoliaIdValue pattern
+   */
+  isIdValuePattern(arr) {
+    return arr.length > 0 && arr.every(
+      (item) => typeof item === "object" && item !== null && "id" in item && "value" in item && typeof item.id === "string"
+    );
+  }
+  /**
+   * Generate a TypeScript type name from a path
+   */
+  generateTypeName(path) {
+    if (path.length === 0) {
+      return `${this.prefix}Hit${this.postfix}`;
+    }
+    const lastPart = path[path.length - 1];
+    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];
+      if (parent.includes("Info")) {
+        return `${this.prefix}${pascalCase}Info${this.postfix}`;
+      }
+    }
+    return `${this.prefix}${pascalCase}${this.postfix}`;
+  }
+  /**
+   * Generate TypeScript interface code
+   */
+  generateInterface(typeName, nestedTypes, sampleObj) {
+    const lines = [];
+    const description = this.getTypeDescription(typeName);
+    lines.push("/**");
+    lines.push(` * ${description}`);
+    lines.push(" */");
+    lines.push(`export interface ${typeName} {`);
+    const sortedKeys = Array.from(nestedTypes.keys()).sort();
+    for (const key of sortedKeys) {
+      const typeInfo = nestedTypes.get(key);
+      const value = sampleObj[key];
+      const isOptional = typeInfo.isOptional || value === null || value === void 0;
+      const optionalMarker = isOptional ? "?" : "";
+      let typeString = typeInfo.type;
+      if (typeInfo.isArray && !typeString.endsWith("[]")) {
+        typeString = `${typeString}[]`;
+      }
+      if (value === null && typeString !== "null") {
+        typeString = `${typeString} | null`;
+      }
+      lines.push(`  ${key}${optionalMarker}: ${typeString};`);
+    }
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Get a description for a type based on its name
+   */
+  getTypeDescription(typeName) {
+    const withoutPrefix = typeName.replace(new RegExp(`^${this.prefix}`), "");
+    const withoutPostfix = withoutPrefix.replace(new RegExp(`${this.postfix}$`), "");
+    const readable = withoutPostfix.replace(/([A-Z])/g, " $1").trim().toLowerCase();
+    return readable.charAt(0).toUpperCase() + readable.slice(1) + " structure in Algolia";
+  }
+  /**
+   * Collect all types that need to be generated
+   */
+  collectTypes(typeInfo, typesToGenerate) {
+    if (typeInfo.nestedTypes.size > 0 && !typeInfo.isArray) {
+      typesToGenerate.add(typeInfo.type);
+      for (const nestedTypeInfo of typeInfo.nestedTypes.values()) {
+        this.collectTypes(nestedTypeInfo, typesToGenerate);
+      }
+    }
+  }
+  /**
+   * Get dependencies for a type (types that it references)
+   */
+  getTypeDependencies(typeName) {
+    const typeCode = this.typeMap.get(typeName);
+    if (!typeCode) return [];
+    const dependencies = [];
+    const importRegex = new RegExp(`(${this.prefix}\\w+)`, "g");
+    const matches = typeCode.matchAll(importRegex);
+    for (const match of matches) {
+      const depTypeName = match[1];
+      if (depTypeName !== typeName && this.generatedTypes.has(depTypeName)) {
+        dependencies.push(depTypeName);
+      }
+    }
+    return Array.from(new Set(dependencies));
+  }
+  /**
+   * Sort types by dependencies (topological sort)
+   */
+  sortTypesByDependencies(typeNames) {
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (typeName) => {
+      if (visiting.has(typeName)) {
+        return;
+      }
+      if (visited.has(typeName)) {
+        return;
+      }
+      visiting.add(typeName);
+      const dependencies = this.getTypeDependencies(typeName);
+      for (const dep of dependencies) {
+        visit(dep);
+      }
+      visiting.delete(typeName);
+      visited.add(typeName);
+      sorted.push(typeName);
+    };
+    for (const typeName of typeNames) {
+      visit(typeName);
+    }
+    return sorted;
+  }
+  /**
+   * Generate IdValue type definition (generic type)
+   */
+  generateIdValueType(typeName) {
+    return `export type ${typeName}<T = string> = {
+  id: string;
+  value: T;
+};
+
+`;
+  }
+  /**
+   * Generate all types as a single file content
+   */
+  generateAllTypes(sampleHit) {
+    const rootType = this.inferType(sampleHit, []);
+    const typesToGenerate = /* @__PURE__ */ new Set();
+    this.collectTypes(rootType, typesToGenerate);
+    const rootTypeName = rootType.type;
+    if (rootType.nestedTypes.size > 0 && !rootType.isArray) {
+      typesToGenerate.add(rootTypeName);
+    }
+    const sortedTypes = this.sortTypesByDependencies(Array.from(typesToGenerate));
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * Generated TypeScript types for Algolia index: ${this.indexName}`);
+    lines.push(" * This file is auto-generated. Do not edit manually.");
+    lines.push(" */");
+    lines.push("");
+    if (this.idValueTypes.size > 0) {
+      const idValueTypeName = Array.from(this.idValueTypes)[0];
+      lines.push(this.generateIdValueType(idValueTypeName));
+    }
+    for (const typeName of sortedTypes) {
+      const typeCode = this.typeMap.get(typeName);
+      if (typeCode) {
+        lines.push(typeCode);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+function generateTypeScriptTypes(sampleHit, config) {
+  const generator = new TypeGenerator(config);
+  return generator.generateAllTypes(sampleHit);
+}
+
+// src/utils/fetch-algolia-data.ts
+async function fetchAlgoliaData(filePath, generatorConfig, overwrite) {
+  console.log(`
+Processing file: ${filePath}`);
+  const resolvedPath = (0, import_path2.resolve)(process.cwd(), filePath);
+  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}`);
+  let client;
+  try {
+    client = (0, import_algoliasearch.algoliasearch)(
+      generatorConfig.appId,
+      generatorConfig.searchKey
+    );
+  } catch (error) {
+    throw new Error(
+      `Failed to initialize Algolia client: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  console.log(`Fetching sample record from index: ${generatorConfig.indexName}`);
+  let results;
+  try {
+    results = await client.search([
+      {
+        indexName: generatorConfig.indexName,
+        params: {
+          query: "",
+          hitsPerPage: 1
+        }
+      }
+    ]);
+  } catch (error) {
+    let errorMessage;
+    if (error instanceof Error) {
+      errorMessage = error.message;
+    } 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);
+    }
+    throw new Error(
+      `Failed to fetch data from Algolia index "${generatorConfig.indexName}" (App ID: ${generatorConfig.appId}): ${errorMessage}`
+    );
+  }
+  if (!results.results || results.results.length === 0) {
+    throw new Error(`No results found in Algolia index: ${generatorConfig.indexName}`);
+  }
+  const result = results.results[0];
+  if (!("hits" in result) || !result.hits || result.hits.length === 0) {
+    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"}`);
+  const fileContent = generateTypeScriptTypes(sampleHit, generatorConfig);
+  const dir = (0, import_path2.dirname)(resolvedPath);
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs3.writeFileSync)(resolvedPath, fileContent, "utf-8");
+  console.log(`Generated file: ${filePath}`);
+}
+
 // src/index.ts
-var main = () => {
-  console.log("Main!");
+var main = async (configPath) => {
+  try {
+    const config = await loadConfig(configPath);
+    console.log("Config loaded successfully");
+    const generatesArray = Array.isArray(config.generates) ? config.generates : [config.generates];
+    for (const urlSchema of generatesArray) {
+      for (const [filePath, generatorConfig] of Object.entries(urlSchema)) {
+        try {
+          await fetchAlgoliaData(filePath, generatorConfig, config.overwrite);
+        } 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));
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error loading config:");
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(String(error));
+    }
+    process.exit(1);
+  }
 };
 
 // src/cli.ts
+var envPath = (0, import_path3.resolve)(process.cwd(), ".env");
+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(() => {
-  main();
+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);
 }).parse();

package/dist/cli.js

@@ -1,11 +1,18 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-U33HDFDI.js";
+} from "./chunk-R66ECGLW.js";
 
 // src/cli.ts
+import { config as loadDotenv } from "dotenv";
+import { existsSync } from "fs";
+import { resolve } from "path";
 import { Command } from "commander";
+var envPath = resolve(process.cwd(), ".env");
+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(() => {
-  main();
+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);
 }).parse();