@invect/cli 0.0.1

package/dist/chunk-Q6JKV7VX.js

@@ -0,0 +1,157 @@
+// src/utils/config-loader.ts
+import path from "path";
+import fs from "fs";
+import pc from "picocolors";
+var CONFIG_FILENAMES = [
+  "invect.config.ts",
+  "invect.config.js",
+  "invect.config.mjs"
+];
+var CONFIG_DIRECTORIES = [".", "src", "lib", "config", "utils"];
+function findConfigPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = path.resolve(process.cwd(), explicitPath);
+    if (fs.existsSync(resolved)) {
+      return resolved;
+    }
+    return null;
+  }
+  for (const dir of CONFIG_DIRECTORIES) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = path.resolve(process.cwd(), dir, filename);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function stripJsonComments(jsonString) {
+  return jsonString.replace(
+    /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g,
+    (m, g) => g ? "" : m
+  ).replace(/,(?=\s*[}\]])/g, "");
+}
+function getPathAliases(cwd) {
+  let tsConfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsConfigPath)) {
+    tsConfigPath = path.join(cwd, "jsconfig.json");
+  }
+  if (!fs.existsSync(tsConfigPath)) {
+    return null;
+  }
+  try {
+    const result = getPathAliasesRecursive(tsConfigPath, /* @__PURE__ */ new Set());
+    return Object.keys(result).length > 0 ? result : null;
+  } catch {
+    return null;
+  }
+}
+function getPathAliasesRecursive(configPath, visited) {
+  const resolvedPath = path.resolve(configPath);
+  if (visited.has(resolvedPath)) return {};
+  visited.add(resolvedPath);
+  if (!fs.existsSync(resolvedPath)) return {};
+  let tsConfig;
+  try {
+    const text = fs.readFileSync(resolvedPath, "utf-8");
+    tsConfig = JSON.parse(stripJsonComments(text));
+  } catch {
+    return {};
+  }
+  const result = {};
+  const compilerOptions = tsConfig.compilerOptions;
+  const paths = compilerOptions?.paths;
+  const baseUrl = compilerOptions?.baseUrl;
+  const configDir = path.dirname(resolvedPath);
+  if (paths) {
+    for (const [alias, targets] of Object.entries(paths)) {
+      if (typeof alias === "string" && alias.endsWith("/*") && Array.isArray(targets) && targets.length > 0) {
+        const aliasPrefix = alias.slice(0, -2);
+        const targetDir = targets[0].replace(/\/\*$/, "");
+        const resolvedTarget = baseUrl ? path.resolve(configDir, baseUrl, targetDir) : path.resolve(configDir, targetDir);
+        result[aliasPrefix] = resolvedTarget;
+      }
+    }
+  }
+  const references = tsConfig.references;
+  if (references) {
+    for (const ref of references) {
+      const refPath = path.resolve(configDir, ref.path);
+      const refConfigPath = refPath.endsWith(".json") ? refPath : path.join(refPath, "tsconfig.json");
+      const refAliases = getPathAliasesRecursive(refConfigPath, visited);
+      Object.assign(result, refAliases);
+    }
+  }
+  return result;
+}
+async function loadConfig(configPath) {
+  const aliases = getPathAliases(process.cwd()) || {};
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    // Pass resolved path aliases so @/ imports work
+    alias: aliases
+  });
+  let configModule;
+  try {
+    configModule = await jiti.import(configPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("Cannot find module") || message.includes("Cannot resolve")) {
+      console.error(pc.red("\n\u2717 Failed to load config file."));
+      console.error(pc.dim("  If your config uses import aliases (e.g., @/ or ~/),"));
+      console.error(pc.dim("  try using relative paths instead, then run the CLI again."));
+      console.error(pc.dim(`
+  Error: ${message}
+`));
+    }
+    throw new Error(`Failed to load config from ${configPath}: ${message}`);
+  }
+  const raw = resolveConfigExport(configModule);
+  if (!raw || typeof raw !== "object") {
+    throw new Error(
+      `Config file at ${configPath} does not export a valid Invect config object.
+Expected: export default { baseDatabaseConfig: ..., plugins: [...] }`
+    );
+  }
+  const config = raw;
+  const plugins = Array.isArray(config.plugins) ? config.plugins : [];
+  for (let i = 0; i < plugins.length; i++) {
+    const plugin = plugins[i];
+    if (!plugin || typeof plugin !== "object" || !("id" in plugin)) {
+      console.warn(
+        pc.yellow(`\u26A0 Plugin at index ${i} does not have an 'id' property \u2014 skipping`)
+      );
+    }
+  }
+  const validPlugins = plugins.filter(
+    (p) => p !== null && typeof p === "object" && "id" in p
+  );
+  return {
+    plugins: validPlugins,
+    baseDatabaseConfig: config.baseDatabaseConfig,
+    raw: config,
+    configPath
+  };
+}
+function resolveConfigExport(module) {
+  if (!module || typeof module !== "object") return module;
+  const mod = module;
+  if ("default" in mod) {
+    const def = mod.default;
+    if (def && typeof def === "object" && "default" in def) {
+      return def.default;
+    }
+    return def;
+  }
+  if ("config" in mod) return mod.config;
+  if ("invectConfig" in mod) return mod.invectConfig;
+  if ("baseDatabaseConfig" in mod || "plugins" in mod) return mod;
+  return mod;
+}
+
+export {
+  findConfigPath,
+  loadConfig
+};