@invect/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 @robase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/api.js

@@ -0,0 +1,42 @@
+import {
+  generateAllDrizzleSchemas,
+  generateAppendSchema,
+  generateDrizzleSchema,
+  generatePrismaSchema
+} from "./chunk-K4RRNATQ.js";
+
+// src/generators/index.ts
+var adapters = {
+  drizzle: generateDrizzleSchema,
+  prisma: generatePrismaSchema
+};
+async function generateSchema(opts) {
+  if (opts.adapter === "prisma") {
+    return generatePrismaSchema({
+      plugins: opts.plugins,
+      file: opts.file,
+      provider: opts.provider
+    });
+  }
+  if (opts.adapter === "drizzle") {
+    if (!opts.dialect) {
+      throw new Error("dialect is required for the drizzle adapter");
+    }
+    return generateDrizzleSchema({
+      plugins: opts.plugins,
+      file: opts.file,
+      dialect: opts.dialect
+    });
+  }
+  throw new Error(
+    `Unsupported adapter "${opts.adapter}". Invect supports: ${Object.keys(adapters).join(", ")}`
+  );
+}
+export {
+  adapters,
+  generateAllDrizzleSchemas,
+  generateAppendSchema,
+  generateDrizzleSchema,
+  generatePrismaSchema,
+  generateSchema
+};

package/dist/chunk-DGBTXQND.js

@@ -0,0 +1,109 @@
+import {
+  findConfigPath,
+  loadConfig
+} from "./chunk-Q6JKV7VX.js";
+
+// src/commands/migrate.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 migrateCommand = new Command("migrate").description("Apply pending database migrations via Drizzle Kit").option("--config <path>", "Path to your Invect config file").option("-y, --yes", "Skip confirmation prompt").option("--push", "Push schema directly without migration files (dev mode)").action(migrateAction);
+async function migrateAction(options) {
+  console.log(pc.bold("\n\u{1F5C4}\uFE0F  Invect Migration\n"));
+  const configPath = findConfigPath(options.config);
+  if (!configPath) {
+    console.error(
+      pc.red("\u2717 Could not find Invect config file.") + "\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 ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+  const dbType = config.baseDatabaseConfig?.type;
+  const dbUrl = config.baseDatabaseConfig?.connectionString;
+  if (!dbType) {
+    console.error(
+      pc.red("\u2717 No baseDatabaseConfig.type found in your config.") + "\n" + pc.dim(
+        '  Expected: baseDatabaseConfig: { type: "sqlite" | "postgresql" | "mysql", ... }'
+      ) + "\n"
+    );
+    process.exit(1);
+  }
+  console.log(pc.dim(`  Database: ${dbType}`));
+  if (dbUrl) {
+    const redacted = dbUrl.replace(/:\/\/[^@]+@/, "://***@");
+    console.log(pc.dim(`  Connection: ${redacted}`));
+  }
+  const mode = options.push ? "push" : "migrate";
+  console.log(pc.dim(`  Mode: ${mode === "push" ? "push (direct schema sync)" : "migrate (SQL migration files)"}`));
+  if (!options.yes) {
+    const message = mode === "push" ? `Push schema directly to your ${dbType} database?` : `Apply pending migrations to your ${dbType} database?`;
+    const response = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message,
+      initial: true
+    });
+    if (!response.proceed) {
+      console.log(pc.dim("\n  Cancelled.\n"));
+      process.exit(0);
+    }
+  }
+  console.log(pc.dim(`
+  Running drizzle-kit ${mode}...
+`));
+  try {
+    const drizzleConfigFile = detectDrizzleConfig(dbType);
+    const configFlag = drizzleConfigFile ? ` --config ${drizzleConfigFile}` : "";
+    const cmd = `npx drizzle-kit ${mode}${configFlag}`;
+    execSync(cmd, {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    if (mode === "push") {
+      console.log(pc.bold(pc.green("\n\u2713 Schema pushed successfully!\n")));
+    } else {
+      console.log(pc.bold(pc.green("\n\u2713 Migrations applied successfully!\n")));
+    }
+  } catch {
+    console.error(pc.red(`
+\u2717 drizzle-kit ${mode} failed.`));
+    console.error(
+      pc.dim("  Make sure drizzle-kit is installed and your drizzle config is correct.\n")
+    );
+    if (mode === "migrate") {
+      console.error(
+        pc.dim("  Have you generated migrations? Run: ") + pc.cyan("npx invect generate") + "\n"
+      );
+    }
+    process.exit(1);
+  }
+}
+function detectDrizzleConfig(dbType) {
+  const candidates = {
+    sqlite: ["drizzle.config.sqlite.ts", "drizzle.config.ts"],
+    postgresql: ["drizzle.config.postgres.ts", "drizzle.config.postgresql.ts", "drizzle.config.ts"],
+    mysql: ["drizzle.config.mysql.ts", "drizzle.config.ts"]
+  };
+  const searchPaths = candidates[dbType] || ["drizzle.config.ts"];
+  for (const filename of searchPaths) {
+    if (fs.existsSync(path.resolve(process.cwd(), filename))) {
+      return filename;
+    }
+  }
+  return null;
+}
+
+export {
+  migrateCommand,
+  migrateAction
+};

package/dist/chunk-K4RRNATQ.js

@@ -0,0 +1,458 @@
+// src/generators/drizzle.ts
+import { existsSync, readFileSync } from "fs";
+var generateDrizzleSchema = async ({
+  plugins,
+  file,
+  dialect
+}) => {
+  const {
+    mergeSchemas,
+    generateSqliteSchema,
+    generatePostgresSchema,
+    generateMysqlSchema
+  } = await import("@invect/core");
+  const mergedSchema = mergeSchemas(plugins);
+  const generators = {
+    sqlite: generateSqliteSchema,
+    postgresql: generatePostgresSchema,
+    mysql: generateMysqlSchema
+  };
+  const generator = generators[dialect];
+  if (!generator) {
+    throw new Error(
+      `Unsupported dialect "${dialect}". Expected one of: sqlite, postgresql, mysql`
+    );
+  }
+  const code = generator(mergedSchema);
+  const defaultFiles = {
+    sqlite: "./src/database/schema-sqlite.ts",
+    postgresql: "./src/database/schema-postgres.ts",
+    mysql: "./src/database/schema-mysql.ts"
+  };
+  const fileName = file || defaultFiles[dialect];
+  if (existsSync(fileName)) {
+    const existing = readFileSync(fileName, "utf-8");
+    if (existing === code) {
+      return { code: void 0, fileName };
+    }
+  }
+  return { code, fileName, overwrite: existsSync(fileName) };
+};
+async function generateAllDrizzleSchemas(options) {
+  const {
+    mergeSchemas,
+    CORE_SCHEMA
+  } = await import("@invect/core");
+  const mergedSchema = mergeSchemas(options.plugins);
+  const coreTableCount = Object.keys(CORE_SCHEMA).length;
+  const pluginsWithSchema = options.plugins.filter(
+    (p) => p.schema
+  ).length;
+  const {
+    generateSqliteSchema,
+    generatePostgresSchema,
+    generateMysqlSchema
+  } = await import("@invect/core");
+  const dir = options.outputDir || "./src/database";
+  const dialects = [
+    { dialect: "sqlite", fileName: `${dir}/schema-sqlite.ts`, generate: generateSqliteSchema },
+    { dialect: "postgresql", fileName: `${dir}/schema-postgres.ts`, generate: generatePostgresSchema },
+    { dialect: "mysql", fileName: `${dir}/schema-mysql.ts`, generate: generateMysqlSchema }
+  ];
+  const results = [];
+  for (const { fileName, generate } of dialects) {
+    const code = generate(mergedSchema);
+    const exists = existsSync(fileName);
+    if (exists) {
+      const existing = readFileSync(fileName, "utf-8");
+      if (existing === code) {
+        results.push({ code: void 0, fileName });
+        continue;
+      }
+    }
+    results.push({ code, fileName, overwrite: exists });
+  }
+  return {
+    results,
+    mergedSchema,
+    stats: {
+      totalTables: mergedSchema.tables.length,
+      coreTableCount,
+      pluginTableCount: mergedSchema.tables.length - coreTableCount,
+      pluginsWithSchema
+    }
+  };
+}
+async function generateAppendSchema(options) {
+  const {
+    mergeSchemas,
+    CORE_SCHEMA,
+    generateSqliteSchemaAppend,
+    generatePostgresSchemaAppend,
+    generateMysqlSchemaAppend
+  } = await import("@invect/core");
+  const mergedSchema = mergeSchemas(options.plugins);
+  const coreTableCount = Object.keys(CORE_SCHEMA).length;
+  const generators = {
+    sqlite: generateSqliteSchemaAppend,
+    postgresql: generatePostgresSchemaAppend,
+    mysql: generateMysqlSchemaAppend
+  };
+  const generator = generators[options.dialect];
+  if (!generator) {
+    throw new Error(
+      `Unsupported dialect "${options.dialect}". Expected one of: sqlite, postgresql, mysql`
+    );
+  }
+  const result = generator(mergedSchema);
+  return {
+    result,
+    stats: {
+      totalTables: mergedSchema.tables.length,
+      coreTableCount,
+      pluginTableCount: mergedSchema.tables.length - coreTableCount
+    }
+  };
+}
+
+// src/generators/prisma.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path from "path";
+import { produceSchema } from "@mrleebo/prisma-ast";
+function getPrismaVersion(cwd) {
+  try {
+    const pkgPath = path.join(cwd || process.cwd(), "package.json");
+    if (!existsSync2(pkgPath)) return null;
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const version = pkg.dependencies?.prisma || pkg.devDependencies?.prisma || pkg.dependencies?.["@prisma/client"] || pkg.devDependencies?.["@prisma/client"];
+    if (!version) return null;
+    const match = version.match(/(\d+)/);
+    return match ? parseInt(match[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
+async function generatePrismaSchema(options) {
+  const {
+    mergeSchemas
+  } = await import("@invect/core");
+  const mergedSchema = mergeSchemas(options.plugins);
+  const provider = options.provider || "postgresql";
+  const filePath = options.file || "./prisma/schema.prisma";
+  const fileExists = existsSync2(filePath);
+  let code;
+  if (fileExists) {
+    const existingContent = readFileSync2(filePath, "utf-8");
+    code = mergeIntoExistingSchema(existingContent, mergedSchema, provider);
+  } else {
+    const baseSchema = generateMinimalPrismaBase(provider);
+    code = mergeIntoExistingSchema(baseSchema, mergedSchema, provider);
+  }
+  if (fileExists) {
+    const existingContent = readFileSync2(filePath, "utf-8");
+    if (normalizeSchema(existingContent) === normalizeSchema(code)) {
+      return { code: void 0, fileName: filePath };
+    }
+  }
+  return {
+    code,
+    fileName: filePath,
+    overwrite: fileExists
+  };
+}
+function normalizeSchema(schema) {
+  return schema.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function generateMinimalPrismaBase(provider) {
+  const prismaVersion = getPrismaVersion();
+  const isV7 = prismaVersion !== null && prismaVersion >= 7;
+  const clientProvider = isV7 ? "prisma-client" : "prisma-client-js";
+  if (isV7) {
+    return `generator client {
+  provider = "${clientProvider}"
+}
+
+datasource db {
+  provider = "${provider}"
+}
+`;
+  }
+  const url = provider === "sqlite" ? '"file:./dev.db"' : 'env("DATABASE_URL")';
+  return `generator client {
+  provider = "${clientProvider}"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = ${url}
+}
+`;
+}
+function mergeIntoExistingSchema(existingContent, mergedSchema, provider) {
+  const prismaVersion = getPrismaVersion();
+  const isV7 = prismaVersion !== null && prismaVersion >= 7;
+  let contentToMerge = existingContent;
+  if (isV7) {
+    contentToMerge = produceSchema(contentToMerge, (builder) => {
+      const generator = builder.findByType("generator", { name: "client" });
+      if (generator?.assignments) {
+        const providerProp = generator.assignments.find(
+          (prop) => prop.type === "assignment" && prop.key === "provider"
+        );
+        if (providerProp && providerProp.value === '"prisma-client-js"') {
+          providerProp.value = '"prisma-client"';
+        }
+      }
+      const datasource = builder.findByType("datasource", { name: "db" });
+      if (datasource?.assignments) {
+        const urlIndex = datasource.assignments.findIndex(
+          (prop) => prop.type === "assignment" && prop.key === "url"
+        );
+        if (urlIndex !== -1) {
+          datasource.assignments.splice(urlIndex, 1);
+        }
+      }
+    });
+  }
+  return produceSchema(contentToMerge, (builder) => {
+    for (const table of mergedSchema.tables) {
+      const modelName = capitalize(table.name);
+      const existingModel = builder.findByType("model", { name: modelName });
+      if (!existingModel) {
+        createPrismaModel(builder, table, mergedSchema, provider);
+      } else {
+        addMissingFields(builder, existingModel, table, mergedSchema, provider);
+        addTableMapping(builder, table, modelName, existingModel);
+      }
+    }
+  });
+}
+function createPrismaModel(builder, table, schema, provider) {
+  const modelName = capitalize(table.name);
+  const { definition } = table;
+  const uniqueFields = [];
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    const prismaType = getPrismaType(field, provider);
+    const fieldBuilder = builder.model(modelName).field(fieldName, prismaType);
+    if (field.primaryKey) {
+      fieldBuilder.attribute("id");
+    }
+    addDefaultAttribute(fieldBuilder, field, fieldName, provider);
+    if (fieldName === "updatedAt" && field.type === "date") {
+      fieldBuilder.attribute("updatedAt");
+    }
+    const dbColName = toSnakeCase(fieldName);
+    if (dbColName !== fieldName) {
+      fieldBuilder.attribute(`map("${dbColName}")`);
+    }
+    if (provider === "mysql" && field.type === "text") {
+      fieldBuilder.attribute("db.Text");
+    }
+    if (provider === "postgresql" && field.type === "date") {
+      fieldBuilder.attribute("db.Timestamptz(3)");
+    }
+    if (field.unique) {
+      uniqueFields.push(fieldName);
+    }
+  }
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    if (!field.references) continue;
+    const refLogical = findLogicalName(schema, field.references.table);
+    const refModel = capitalize(refLogical);
+    const relName = fieldName.replace(/Id$/, "").replace(/_id$/, "");
+    const onDelete = mapOnDelete(field.references.onDelete);
+    builder.model(modelName).field(relName, `${refModel}${!field.required ? "?" : ""}`).attribute(
+      `relation(fields: [${fieldName}], references: [${field.references.field}], onDelete: ${onDelete})`
+    );
+  }
+  for (const otherTable of schema.tables) {
+    if (otherTable.name === table.name) continue;
+    for (const [_, field] of Object.entries(otherTable.definition.fields)) {
+      if (!field.references) continue;
+      const refsThisTable = field.references.table === table.name || field.references.table === (definition.tableName || toSnakeCase(table.name));
+      if (refsThisTable) {
+        const otherModelName = capitalize(otherTable.name);
+        const isUnique = field.unique === true;
+        builder.model(modelName).field(
+          otherTable.name,
+          `${otherModelName}${isUnique ? "?" : "[]"}`
+        );
+      }
+    }
+  }
+  for (const fieldName of uniqueFields) {
+    builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+  }
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    if (field.index && !field.unique && !field.primaryKey) {
+      builder.model(modelName).blockAttribute(`index([${fieldName}])`);
+    }
+  }
+  if (definition.compositePrimaryKey?.length) {
+    builder.model(modelName).blockAttribute("id", `[${definition.compositePrimaryKey.join(", ")}]`);
+  }
+  const dbTableName = definition.tableName || toSnakeCase(table.name);
+  if (dbTableName !== table.name) {
+    builder.model(modelName).blockAttribute("map", dbTableName);
+  }
+}
+function addMissingFields(builder, existingModel, table, schema, provider) {
+  const modelName = capitalize(table.name);
+  const { definition } = table;
+  const uniqueFields = [];
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    const isAlreadyExist = builder.findByType("field", {
+      name: fieldName,
+      within: existingModel.properties
+    });
+    if (isAlreadyExist) continue;
+    const prismaType = getPrismaType(field, provider);
+    const fieldBuilder = builder.model(modelName).field(fieldName, prismaType);
+    if (field.primaryKey) {
+      fieldBuilder.attribute("id");
+    }
+    addDefaultAttribute(fieldBuilder, field, fieldName, provider);
+    if (fieldName === "updatedAt" && field.type === "date") {
+      fieldBuilder.attribute("updatedAt");
+    }
+    const dbColName = toSnakeCase(fieldName);
+    if (dbColName !== fieldName) {
+      fieldBuilder.attribute(`map("${dbColName}")`);
+    }
+    if (provider === "mysql" && field.type === "text") {
+      fieldBuilder.attribute("db.Text");
+    }
+    if (provider === "postgresql" && field.type === "date") {
+      fieldBuilder.attribute("db.Timestamptz(3)");
+    }
+    if (field.unique) {
+      uniqueFields.push(fieldName);
+    }
+  }
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    if (!field.references) continue;
+    const isFieldAlreadyExist = builder.findByType("field", {
+      name: fieldName,
+      within: existingModel.properties
+    });
+    if (isFieldAlreadyExist) continue;
+    const refLogical = findLogicalName(schema, field.references.table);
+    const refModel = capitalize(refLogical);
+    const relName = fieldName.replace(/Id$/, "").replace(/_id$/, "");
+    const onDelete = mapOnDelete(field.references.onDelete);
+    const relExists = builder.findByType("field", {
+      name: relName,
+      within: existingModel.properties
+    });
+    if (!relExists) {
+      builder.model(modelName).field(relName, `${refModel}${!field.required ? "?" : ""}`).attribute(
+        `relation(fields: [${fieldName}], references: [${field.references.field}], onDelete: ${onDelete})`
+      );
+    }
+  }
+  for (const fieldName of uniqueFields) {
+    builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+  }
+  for (const [fieldName, field] of Object.entries(definition.fields)) {
+    if (field.index && !field.unique && !field.primaryKey) {
+      const indexExists = existingModel.properties?.some(
+        (v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args?.[0]?.value)?.includes(fieldName)
+      );
+      if (!indexExists) {
+        builder.model(modelName).blockAttribute(`index([${fieldName}])`);
+      }
+    }
+  }
+}
+function addTableMapping(builder, table, modelName, existingModel) {
+  const dbTableName = table.definition.tableName || toSnakeCase(table.name);
+  if (dbTableName === table.name) return;
+  if (existingModel) {
+    const hasMap = builder.findByType("attribute", {
+      name: "map",
+      within: existingModel.properties
+    });
+    if (hasMap) return;
+  }
+  builder.model(modelName).blockAttribute("map", dbTableName);
+}
+function getPrismaType(field, provider) {
+  const optional = field.required === false ? "?" : "";
+  if (Array.isArray(field.type)) {
+    return `String${optional}`;
+  }
+  switch (field.type) {
+    case "string":
+    case "text":
+    case "uuid":
+      return `String${optional}`;
+    case "number":
+      return `Int${optional}`;
+    case "bigint":
+      return `BigInt${optional}`;
+    case "boolean":
+      return `Boolean${optional}`;
+    case "date":
+      return `DateTime${optional}`;
+    case "json":
+      if (provider === "sqlite") return `String${optional}`;
+      return `Json${optional}`;
+    default:
+      return `String${optional}`;
+  }
+}
+function addDefaultAttribute(fieldBuilder, field, fieldName, _provider) {
+  if (field.defaultValue === void 0) return;
+  if (field.defaultValue === "uuid()") {
+    fieldBuilder.attribute("default(uuid())");
+  } else if (field.defaultValue === "now()") {
+    if (fieldName !== "updatedAt") {
+      fieldBuilder.attribute("default(now())");
+    }
+  } else if (typeof field.defaultValue === "boolean") {
+    fieldBuilder.attribute(`default(${field.defaultValue})`);
+  } else if (typeof field.defaultValue === "number") {
+    fieldBuilder.attribute(`default(${field.defaultValue})`);
+  } else if (typeof field.defaultValue === "string") {
+    fieldBuilder.attribute(`default("${field.defaultValue}")`);
+  }
+}
+function mapOnDelete(onDelete) {
+  switch (onDelete) {
+    case "cascade":
+      return "Cascade";
+    case "set null":
+      return "SetNull";
+    case "restrict":
+      return "Restrict";
+    case "no action":
+      return "NoAction";
+    default:
+      return "NoAction";
+  }
+}
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function findLogicalName(schema, tableRef) {
+  const exact = schema.tables.find((t) => t.name === tableRef);
+  if (exact) return exact.name;
+  const byDbName = schema.tables.find(
+    (t) => t.definition.tableName === tableRef || toSnakeCase(t.name) === tableRef
+  );
+  if (byDbName) return byDbName.name;
+  if (tableRef.includes("_")) {
+    return tableRef.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  }
+  return tableRef;
+}
+
+export {
+  generateDrizzleSchema,
+  generateAllDrizzleSchemas,
+  generateAppendSchema,
+  generatePrismaSchema
+};