@invect/cli 0.0.1

package/dist/chunk-T4KEEHFJ.js

@@ -0,0 +1,569 @@
+import {
+  generateAllDrizzleSchemas,
+  generateAppendSchema,
+  generatePrismaSchema
+} from "./chunk-K4RRNATQ.js";
+import {
+  findConfigPath,
+  loadConfig
+} from "./chunk-Q6JKV7VX.js";
+
+// src/commands/generate.ts
+import { Command } from "commander";
+import path from "path";
+import fs from "fs";
+import pc from "picocolors";
+import prompts from "prompts";
+import { execSync } from "child_process";
+var generateCommand = new Command("generate").description("Generate Drizzle or Prisma schema files from core + plugin schemas").option(
+  "--config <path>",
+  "Path to your Invect config file. Defaults to the first config found."
+).option(
+  "--output <path>",
+  "Output directory for generated schema files (used when --schema is not set)",
+  "./src/database"
+).option(
+  "--schema <path>",
+  "Path to your existing Drizzle schema file. Invect tables will be appended to this file. If not provided, auto-detected from drizzle.config.ts."
+).option(
+  "--adapter <adapter>",
+  'Schema adapter to use: "drizzle" (default) or "prisma"'
+).option(
+  "--dialect <dialect>",
+  "Database dialect (sqlite, postgresql, mysql). Required when using --schema. Auto-detected from drizzle.config.ts when possible."
+).option("-y, --yes", "Skip confirmation prompt and generate directly", false).action(generateAction);
+async function generateAction(options) {
+  console.log(pc.bold("\n\u{1F527} Invect Schema Generator\n"));
+  const adapter = (options.adapter || "drizzle").toLowerCase();
+  if (adapter !== "drizzle" && adapter !== "prisma") {
+    console.error(
+      pc.red(`\u2717 Unknown adapter "${options.adapter}".`) + "\n" + pc.dim("  Supported adapters: drizzle (default), prisma\n")
+    );
+    process.exit(1);
+  }
+  const configPath = findConfigPath(options.config);
+  if (!configPath) {
+    console.error(
+      pc.red("\u2717 Could not find Invect config file.") + "\n\n" + pc.dim("  Searched for: invect.config.ts in ./, src/, lib/, config/") + "\n" + pc.dim("  Use --config <path> to specify the config file explicitly.") + "\n\n" + pc.dim("  You can create one with: " + pc.cyan("npx invect init")) + "\n"
+    );
+    process.exit(1);
+  }
+  console.log(pc.dim(`  Config: ${path.relative(process.cwd(), configPath)}`));
+  let config;
+  try {
+    config = await loadConfig(configPath);
+  } catch (error) {
+    console.error(
+      pc.red(`
+\u2717 Failed to load config.`) + "\n" + pc.dim(`  ${error instanceof Error ? error.message : String(error)}`) + "\n\n" + pc.dim("  If your config uses import aliases (e.g., @/ or ~/),") + "\n" + pc.dim("  try using relative paths instead, then run the CLI again.\n")
+    );
+    process.exit(1);
+  }
+  if (adapter === "prisma") {
+    await runPrismaMode(config, options);
+    process.exit(0);
+  }
+  let schemaFile = options.schema ? path.resolve(process.cwd(), options.schema) : void 0;
+  let dialect = normalizeDialect(options.dialect);
+  if (!schemaFile) {
+    const detected = detectDrizzleSchema();
+    if (detected) {
+      schemaFile = detected.schemaPath;
+      dialect = dialect || detected.dialect;
+      console.log(
+        pc.dim(`  Schema: ${path.relative(process.cwd(), schemaFile)}`) + pc.dim(` (auto-detected from ${detected.configFile})`)
+      );
+    }
+  } else {
+    console.log(pc.dim(`  Schema: ${path.relative(process.cwd(), schemaFile)}`));
+  }
+  const useAppendMode = !!schemaFile;
+  if (useAppendMode && !dialect) {
+    console.error(
+      pc.red("\u2717 Cannot determine database dialect.") + "\n\n" + pc.dim("  When using --schema, provide --dialect (sqlite, postgresql, or mysql).") + "\n" + pc.dim("  Or ensure your drizzle.config.ts specifies a dialect.\n")
+    );
+    process.exit(1);
+  }
+  if (useAppendMode) {
+    await runAppendMode(config, schemaFile, dialect, options);
+  } else {
+    await runSeparateFilesMode(config, options);
+  }
+  process.exit(0);
+}
+async function runPrismaMode(config, options) {
+  const provider = normalizePrismaProvider(options.dialect) || "postgresql";
+  const schemaFile = options.schema ? path.resolve(process.cwd(), options.schema) : path.resolve(process.cwd(), "prisma/schema.prisma");
+  console.log(pc.dim(`  Adapter: ${pc.cyan("Prisma")}`));
+  console.log(pc.dim(`  Provider: ${pc.white(provider)}`));
+  console.log(pc.dim(`  Schema: ${path.relative(process.cwd(), schemaFile)}`));
+  let result;
+  try {
+    result = await generatePrismaSchema({
+      plugins: config.plugins,
+      file: schemaFile,
+      provider
+    });
+  } catch (error) {
+    console.error(pc.red(`
+\u2717 Prisma schema generation failed:`));
+    console.error(pc.dim(`  ${error instanceof Error ? error.message : String(error)}
+`));
+    process.exit(1);
+  }
+  if (result.code === void 0) {
+    console.log(pc.bold(pc.green("\n\u2713 Prisma schema is already up to date.\n")));
+    process.exit(0);
+  }
+  const rel = path.relative(process.cwd(), result.fileName);
+  console.log("");
+  console.log(pc.bold("  Files:"));
+  if (result.overwrite) {
+    console.log(pc.yellow(`    ~ ${rel}`) + pc.dim(" (will update)"));
+  } else {
+    console.log(pc.green(`    + ${rel}`) + pc.dim(" (will create)"));
+  }
+  if (!options.yes) {
+    console.log("");
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: result.overwrite ? `Update ${pc.cyan(rel)}?` : `Create ${pc.cyan(rel)}?`,
+      initial: true
+    });
+    if (!response.proceed) {
+      console.log(pc.dim("\n  Cancelled.\n"));
+      process.exit(0);
+    }
+  }
+  const dir = path.dirname(result.fileName);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(result.fileName, result.code, "utf-8");
+  console.log(
+    pc.bold(pc.green(`
+\u2713 Prisma schema ${result.overwrite ? "updated" : "created"}: ${rel}
+`))
+  );
+  console.log(pc.dim("  Next steps:"));
+  console.log(
+    pc.dim("    1. Run ") + pc.cyan("npx prisma db push") + pc.dim(" to apply schema changes")
+  );
+  console.log(
+    pc.dim("    2. Run ") + pc.cyan("npx prisma generate") + pc.dim(" to regenerate the Prisma client")
+  );
+  console.log("");
+}
+function normalizePrismaProvider(dialect) {
+  if (!dialect) return void 0;
+  const d = dialect.toLowerCase();
+  if (d === "sqlite") return "sqlite";
+  if (d === "postgresql" || d === "pg" || d === "postgres") return "postgresql";
+  if (d === "mysql") return "mysql";
+  return void 0;
+}
+async function runAppendMode(config, schemaFile, dialect, options) {
+  let appendResult;
+  try {
+    appendResult = await generateAppendSchema({
+      plugins: config.plugins,
+      dialect
+    });
+  } catch (error) {
+    console.error(pc.red(`
+\u2717 Schema generation failed:`));
+    console.error(pc.dim(`  ${error instanceof Error ? error.message : String(error)}
+`));
+    process.exit(1);
+  }
+  const { result, stats } = appendResult;
+  await printSummary(config, stats);
+  const fileExists = fs.existsSync(schemaFile);
+  const currentFileContent = fileExists ? fs.readFileSync(schemaFile, "utf-8") : "";
+  let existingContent = currentFileContent;
+  const marker = "// Invect tables \u2014 AUTO-GENERATED by @invect/cli";
+  const markerIndex = existingContent.indexOf(marker);
+  if (markerIndex !== -1) {
+    const sectionDivider = "// =============================================================================";
+    const dividerIndex = existingContent.lastIndexOf(sectionDivider, markerIndex);
+    const stripFrom = dividerIndex !== -1 ? dividerIndex : markerIndex;
+    existingContent = existingContent.substring(0, stripFrom).trimEnd();
+  }
+  const pendingImports = [];
+  let mergedContent = existingContent;
+  for (const imp of result.imports) {
+    const fromMatch = imp.match(/from\s+['"]([^'"]+)['"]/);
+    if (!fromMatch) {
+      pendingImports.push(imp);
+      continue;
+    }
+    const modulePath = fromMatch[1];
+    const moduleImportRegex = new RegExp(
+      `import\\s*\\{([\\s\\S]*?)\\}\\s*from\\s*['"]${modulePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"];?`,
+      "m"
+    );
+    const existingModuleImport = mergedContent.match(moduleImportRegex);
+    if (!existingModuleImport) {
+      pendingImports.push(imp);
+      continue;
+    }
+    const newSpecifiersMatch = imp.match(/import\s*\{([\s\S]*?)\}\s*from/);
+    if (!newSpecifiersMatch) {
+      continue;
+    }
+    const existingSpecifiers = existingModuleImport[1].split(",").map((specifier) => specifier.trim()).filter(Boolean);
+    const nextSpecifiers = newSpecifiersMatch[1].split(",").map((specifier) => specifier.trim()).filter(Boolean);
+    const mergedSpecifiers = Array.from(/* @__PURE__ */ new Set([...existingSpecifiers, ...nextSpecifiers]));
+    const replacement = `import { ${mergedSpecifiers.join(", ")} } from '${modulePath}';`;
+    mergedContent = mergedContent.replace(moduleImportRegex, replacement);
+  }
+  let finalContent = mergedContent;
+  if (pendingImports.length > 0) {
+    const importRegex = /^import\s.*$/gm;
+    let lastImportEnd = 0;
+    let match;
+    while ((match = importRegex.exec(finalContent)) !== null) {
+      lastImportEnd = match.index + match[0].length;
+    }
+    if (lastImportEnd > 0) {
+      finalContent = finalContent.substring(0, lastImportEnd) + "\n" + pendingImports.join("\n") + finalContent.substring(lastImportEnd);
+    } else {
+      finalContent = pendingImports.join("\n") + "\n" + finalContent;
+    }
+  }
+  finalContent = finalContent.trimEnd() + "\n" + result.code + "\n";
+  if (currentFileContent === finalContent) {
+    printSummaryAlreadyUpToDate();
+    process.exit(0);
+  }
+  const rel = path.relative(process.cwd(), schemaFile);
+  console.log("");
+  console.log(pc.bold("  Files:"));
+  if (fileExists) {
+    if (markerIndex !== -1) {
+      console.log(pc.yellow(`    ~ ${rel}`) + pc.dim(" (Invect tables will be regenerated)"));
+    } else {
+      console.log(pc.green(`    ~ ${rel}`) + pc.dim(" (Invect tables will be appended)"));
+    }
+  } else {
+    console.log(pc.green(`    + ${rel}`) + pc.dim(" (will create)"));
+  }
+  if (!options.yes) {
+    console.log("");
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: fileExists ? `Append Invect tables to ${pc.cyan(rel)}?` : `Create ${pc.cyan(rel)} with Invect tables?`,
+      initial: true
+    });
+    if (!response.proceed) {
+      console.log(pc.dim("\n  Cancelled.\n"));
+      process.exit(0);
+    }
+  }
+  const dir = path.dirname(schemaFile);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(schemaFile, finalContent, "utf-8");
+  const schemaFileChanged = currentFileContent !== finalContent;
+  console.log(
+    pc.bold(
+      pc.green(
+        `
+\u2713 Invect tables ${markerIndex !== -1 ? "updated" : "appended"} in ${rel}
+`
+      )
+    )
+  );
+  if (!schemaFileChanged) {
+    console.log(
+      pc.dim("  Schema file unchanged after regeneration \u2014 skipping drizzle-kit push.\n") + pc.dim("  The database is already up to date.\n")
+    );
+  } else if (!options.yes) {
+    const { runPush } = await prompts({
+      type: "confirm",
+      name: "runPush",
+      message: `Run ${pc.cyan("drizzle-kit push")} to apply schema changes?`,
+      initial: true
+    });
+    if (runPush) {
+      await runDrizzleKitPush();
+    } else {
+      console.log(
+        pc.dim("\n  Next: run ") + pc.cyan("npx drizzle-kit push") + pc.dim(" to apply schema changes.\n")
+      );
+    }
+  } else {
+    await runDrizzleKitPush();
+  }
+}
+async function runSeparateFilesMode(config, options) {
+  const outputDir = path.resolve(process.cwd(), options.output);
+  let generated;
+  try {
+    generated = await generateAllDrizzleSchemas({
+      plugins: config.plugins,
+      outputDir
+    });
+  } catch (error) {
+    console.error(pc.red(`
+\u2717 Schema generation failed:`));
+    console.error(pc.dim(`  ${error instanceof Error ? error.message : String(error)}
+`));
+    process.exit(1);
+  }
+  const { results, stats } = generated;
+  await printSummary(config, stats);
+  const filteredResults = options.dialect ? results.filter((r) => {
+    const d = options.dialect.toLowerCase();
+    if (d === "sqlite") return r.fileName.includes("sqlite");
+    if (d === "postgresql" || d === "pg" || d === "postgres")
+      return r.fileName.includes("postgres");
+    if (d === "mysql") return r.fileName.includes("mysql");
+    return true;
+  }) : results;
+  const hasChanges = filteredResults.some((r) => r.code !== void 0);
+  if (!hasChanges) {
+    console.log(pc.bold(pc.green("\n\u2713 Schema files are already up to date.\n")));
+    process.exit(0);
+  }
+  console.log("");
+  console.log(pc.bold("  Files:"));
+  for (const result of filteredResults) {
+    const rel = path.relative(process.cwd(), result.fileName);
+    if (result.code === void 0) {
+      console.log(pc.dim(`    \xB7 ${rel} (unchanged)`));
+    } else if (result.overwrite) {
+      console.log(pc.yellow(`    ~ ${rel}`) + pc.dim(" (will update)"));
+    } else {
+      console.log(pc.green(`    + ${rel}`) + pc.dim(" (will create)"));
+    }
+  }
+  if (!options.yes) {
+    console.log("");
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: "Generate schema files?",
+      initial: true
+    });
+    if (!response.proceed) {
+      console.log(pc.dim("\n  Cancelled.\n"));
+      process.exit(0);
+    }
+  }
+  let writtenCount = 0;
+  for (const result of filteredResults) {
+    if (result.code === void 0) continue;
+    const dir = path.dirname(result.fileName);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(result.fileName, result.code, "utf-8");
+    writtenCount++;
+  }
+  console.log(
+    pc.bold(
+      pc.green(`
+\u2713 Generated ${writtenCount} schema file${writtenCount !== 1 ? "s" : ""}.
+`)
+    )
+  );
+  if (!options.yes) {
+    const { runDrizzleKit } = await prompts({
+      type: "confirm",
+      name: "runDrizzleKit",
+      message: `Run ${pc.cyan("drizzle-kit generate")} to create SQL migrations?`,
+      initial: true
+    });
+    if (runDrizzleKit) {
+      await runDrizzleKitGenerate();
+    } else {
+      printNextSteps();
+    }
+  } else {
+    await runDrizzleKitGenerate();
+  }
+}
+function printSummaryAlreadyUpToDate() {
+  console.log(pc.bold(pc.green("\n\u2713 Schema is already up to date. Nothing to do.\n")));
+}
+async function printSummary(config, stats) {
+  const pluginsWithSchema = config.plugins.filter((p) => p.schema);
+  const pluginsWithRequiredTablesOnly = config.plugins.filter(
+    (p) => !p.schema && Array.isArray(p.requiredTables) && p.requiredTables.length > 0
+  );
+  console.log(
+    pc.dim(
+      `  Plugins: ${pc.white(String(config.plugins.length))} loaded` + (pluginsWithSchema.length > 0 ? `, ${pc.cyan(String(pluginsWithSchema.length))} with schema` : "")
+    )
+  );
+  console.log(
+    pc.dim(
+      `  Tables:  ${pc.white(String(stats.totalTables))} total (${stats.coreTableCount} core` + (stats.pluginTableCount > 0 ? ` + ${pc.cyan(String(stats.pluginTableCount))} plugin` : "") + ")"
+    )
+  );
+  if (pluginsWithSchema.length > 0) {
+    let coreSchema;
+    try {
+      const core = await import("@invect/core");
+      coreSchema = core.CORE_SCHEMA;
+    } catch {
+      coreSchema = {};
+    }
+    console.log("");
+    for (const plugin of pluginsWithSchema) {
+      const tableNames = Object.keys(plugin.schema);
+      const newTables = tableNames.filter((t) => !(t in coreSchema));
+      const extendedTables = tableNames.filter((t) => t in coreSchema);
+      console.log(pc.dim(`  Plugin ${pc.cyan(plugin.id)}:`));
+      for (const t of newTables) {
+        const fields = Object.keys(
+          plugin.schema[t]?.fields || {}
+        );
+        console.log(
+          pc.green(`    + ${t}`) + pc.dim(` (new table, ${fields.length} field${fields.length !== 1 ? "s" : ""})`)
+        );
+      }
+      for (const t of extendedTables) {
+        const fields = Object.keys(
+          plugin.schema[t]?.fields || {}
+        );
+        console.log(
+          pc.yellow(`    ~ ${t}`) + pc.dim(` (${fields.length} field${fields.length !== 1 ? "s" : ""} added)`)
+        );
+      }
+    }
+  }
+  if (pluginsWithRequiredTablesOnly.length > 0) {
+    console.log("");
+    console.log(
+      pc.yellow("  \u26A0 Some plugins require tables but do not provide schema definitions:")
+    );
+    for (const plugin of pluginsWithRequiredTablesOnly) {
+      const tables = plugin.requiredTables.join(", ");
+      console.log(
+        pc.dim(`    ${pc.yellow(plugin.id)}: requires `) + pc.white(tables)
+      );
+      if (plugin.setupInstructions) {
+        console.log(pc.dim(`      \u2192 ${plugin.setupInstructions}`));
+      }
+    }
+    console.log(
+      pc.dim(
+        "\n  These tables must be added to your schema manually (or via the plugin's own tooling).\n  The generated schema files will NOT include them automatically.\n"
+      )
+    );
+  }
+}
+function detectDrizzleSchema() {
+  const configFile = findDrizzleConfig();
+  if (!configFile) return null;
+  const configPath = path.resolve(process.cwd(), configFile);
+  let content;
+  try {
+    content = fs.readFileSync(configPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const schemaMatch = content.match(/schema\s*:\s*['"]([^'"]+)['"]/);
+  if (!schemaMatch) return null;
+  let schemaPath = schemaMatch[1];
+  if (!schemaPath.endsWith(".ts") && !schemaPath.endsWith(".js")) {
+    schemaPath += ".ts";
+  }
+  schemaPath = path.resolve(process.cwd(), schemaPath);
+  let dialect;
+  const dialectMatch = content.match(/dialect\s*:\s*['"]([^'"]+)['"]/);
+  if (dialectMatch) {
+    const d = dialectMatch[1].toLowerCase();
+    if (d === "sqlite") dialect = "sqlite";
+    else if (d === "postgresql" || d === "pg" || d === "postgres") dialect = "postgresql";
+    else if (d === "mysql") dialect = "mysql";
+  }
+  return { schemaPath, dialect, configFile };
+}
+function normalizeDialect(dialect) {
+  if (!dialect) return void 0;
+  const d = dialect.toLowerCase();
+  if (d === "sqlite") return "sqlite";
+  if (d === "postgresql" || d === "pg" || d === "postgres") return "postgresql";
+  if (d === "mysql") return "mysql";
+  return void 0;
+}
+async function runDrizzleKitGenerate() {
+  console.log(pc.dim("\n  Running drizzle-kit generate...\n"));
+  try {
+    const configFile = findDrizzleConfig();
+    const cmd = configFile ? `npx drizzle-kit generate --config ${configFile}` : "npx drizzle-kit generate";
+    execSync(cmd, { stdio: "inherit", cwd: process.cwd() });
+    console.log(
+      pc.bold(pc.green("\n\u2713 SQL migrations generated.\n")) + pc.dim("  Run ") + pc.cyan("npx invect migrate") + pc.dim(" to apply them.\n")
+    );
+  } catch {
+    console.error(
+      pc.yellow("\n\u26A0 drizzle-kit generate failed.") + "\n" + pc.dim("  Make sure drizzle-kit is installed and drizzle.config.ts exists.") + "\n" + pc.dim("  You can run it manually: ") + pc.cyan("npx drizzle-kit generate") + "\n"
+    );
+  }
+}
+async function runDrizzleKitPush() {
+  console.log(pc.dim("\n  Running drizzle-kit push...\n"));
+  try {
+    const configFile = findDrizzleConfig();
+    const cmd = configFile ? `npx drizzle-kit push --config ${configFile}` : "npx drizzle-kit push";
+    const output = execSync(cmd, {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    if (output) process.stdout.write(output);
+    console.log(
+      pc.bold(pc.green("\n\u2713 Schema pushed to database.\n"))
+    );
+  } catch (error) {
+    const execError = error;
+    const combinedOutput = [
+      execError.stdout || "",
+      execError.stderr || "",
+      execError.message || ""
+    ].join("\n");
+    if (/already exists/i.test(combinedOutput)) {
+      console.log(
+        pc.bold(pc.green("\n\u2713 Schema is already applied to the database.\n"))
+      );
+    } else {
+      if (execError.stderr) process.stderr.write(execError.stderr);
+      if (execError.stdout) process.stdout.write(execError.stdout);
+      console.error(
+        pc.yellow("\n\u26A0 drizzle-kit push failed.") + "\n" + pc.dim("  Make sure drizzle-kit is installed and drizzle.config.ts exists.") + "\n" + pc.dim("  You can run it manually: ") + pc.cyan("npx drizzle-kit push") + "\n"
+      );
+    }
+  }
+}
+function findDrizzleConfig() {
+  const candidates = [
+    "drizzle.config.ts",
+    "drizzle.config.js",
+    "drizzle.config.sqlite.ts",
+    "drizzle.config.postgres.ts",
+    "drizzle.config.mysql.ts"
+  ];
+  for (const file of candidates) {
+    if (fs.existsSync(path.resolve(process.cwd(), file))) {
+      return file;
+    }
+  }
+  return null;
+}
+function printNextSteps() {
+  console.log(pc.dim("\n  Next steps:"));
+  console.log(pc.dim("    1. Review the generated schema files"));
+  console.log(
+    pc.dim("    2. Run ") + pc.cyan("npx drizzle-kit generate") + pc.dim(" to create SQL migrations")
+  );
+  console.log(
+    pc.dim("    3. Run ") + pc.cyan("npx invect migrate") + pc.dim(" to apply them")
+  );
+  console.log("");
+}
+
+export {
+  generateCommand,
+  generateAction
+};

package/dist/generate-JDAYY3OL.js

@@ -0,0 +1,10 @@
+import {
+  generateAction,
+  generateCommand
+} from "./chunk-T4KEEHFJ.js";
+import "./chunk-K4RRNATQ.js";
+import "./chunk-Q6JKV7VX.js";
+export {
+  generateAction,
+  generateCommand
+};