algolia-codegen 0.1.0 → 0.1.1

package/dist/chunk-4FWQJC54.js

@@ -0,0 +1,558 @@
+// src/utils/config-loader.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+
+// 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/config-loader.ts
+async function loadConfig(configPath) {
+  const defaultConfigPath = "algolia-codegen.ts";
+  const finalConfigPath = configPath || defaultConfigPath;
+  const resolvedPath = resolve(process.cwd(), finalConfigPath);
+  if (!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 = pathToFileURL(resolvedPath).href;
+  let configModule;
+  try {
+    configModule = await import(configUrl);
+  } catch (importError) {
+    const jsPath = resolvedPath.replace(/\.ts$/, ".js");
+    if (existsSync(jsPath)) {
+      const jsUrl = pathToFileURL(jsPath).href;
+      try {
+        configModule = await import(jsUrl);
+      } catch (jsImportError) {
+        throw new Error(
+          `Failed to import config file: ${resolvedPath}
+Tried both .ts and .js extensions.
+Error: ${jsImportError instanceof Error ? jsImportError.message : String(jsImportError)}
+Note: If using TypeScript config, you may need to compile it first or use a tool like tsx.`
+        );
+      }
+    } else {
+      const errorMessage = importError instanceof Error ? importError.message : String(importError);
+      const isTypeScriptError = resolvedPath.endsWith(".ts") && (errorMessage.includes("Cannot find module") || errorMessage.includes("Unknown file extension"));
+      throw new Error(
+        `Failed to import config file: ${resolvedPath}
+` + (isTypeScriptError ? `Node.js cannot directly import TypeScript files.
+Please either:
+  1. Compile your config to JavaScript (.js)
+  2. Use a tool like tsx to run the CLI: tsx algolia-codegen
+  3. Or use a JavaScript config file instead
+` : `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
+import algoliasearch from "algoliasearch";
+import { existsSync as existsSync2, writeFileSync, mkdirSync } from "fs";
+import { resolve as resolve2, dirname } from "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 = resolve2(process.cwd(), filePath);
+  if (existsSync2(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 = 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,
+        query: "",
+        params: {
+          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 = dirname(resolvedPath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(resolvedPath, fileContent, "utf-8");
+  console.log(`Generated file: ${filePath}`);
+}
+
+// src/index.ts
+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);
+  }
+};
+
+export {
+  validateGeneratorConfig,
+  validateUrlSchema,
+  validateConfig,
+  main
+};