@plyaz/db 0.3.0 → 0.3.1

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import * as fs3 from 'fs';
+import * as fs4 from 'fs';
 import * as path4 from 'path';
 import { Command } from 'commander';
 import { DatabaseError } from '@plyaz/errors';
@@ -13,8 +13,10 @@ import { Pool } from 'pg';
 import { eq, sql, isNotNull, isNull, between, like, not, inArray, lte, lt, gte, gt, asc, desc } from 'drizzle-orm';
 import { PgColumn } from 'drizzle-orm/pg-core';
 import { createClient } from '@supabase/supabase-js';
-import { randomBytes, createCipheriv, createDecipheriv } from 'crypto';
-import { pathToFileURL } from 'url';
+import { randomBytes, createCipheriv, createDecipheriv, randomUUID } from 'crypto';
+import * as readline from 'readline';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { execSync } from 'child_process';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -59,7 +61,7 @@ function suggestDownMigration(sqlContent, filename) {
   };
 }
 function addDownSection(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   if (content.includes("-- DOWN")) {
     return content;
   }
@@ -68,16 +70,16 @@ function addDownSection(filePath) {
   return content + downSection;
 }
 function processDirectory(migrationsPath, dryRun = true) {
-  if (!fs3.existsSync(migrationsPath)) {
+  if (!fs4.existsSync(migrationsPath)) {
     console.error(`Migration directory not found: ${migrationsPath}`);
     return;
   }
-  const files = fs3.readdirSync(migrationsPath).filter((f) => f.endsWith(".sql"));
+  const files = fs4.readdirSync(migrationsPath).filter((f) => f.endsWith(".sql"));
   console.log(`Found ${files.length} SQL migration files
 `);
   for (const file of files) {
     const filePath = path4.join(migrationsPath, file);
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     if (content.includes("-- DOWN")) {
       console.log(`✓ ${file} - Already has DOWN section`);
       continue;
@@ -91,7 +93,7 @@ function processDirectory(migrationsPath, dryRun = true) {
       const downSection = newContent.split("-- DOWN")[1];
       console.log(downSection);
     } else {
-      fs3.writeFileSync(filePath, newContent, "utf-8");
+      fs4.writeFileSync(filePath, newContent, "utf-8");
       console.log(`✓ ${file} - Added DOWN section`);
     }
   }
@@ -258,12 +260,12 @@ var MigrationManager = class {
    * Discover migration files from migrations directory (including subdirectories)
    */
   async discoverMigrations() {
-    if (!fs3.existsSync(this.migrationsPath)) {
+    if (!fs4.existsSync(this.migrationsPath)) {
       return [];
     }
     const migrations = [];
     const scanDirectory = /* @__PURE__ */ __name((dir) => {
-      const entries = fs3.readdirSync(dir, { withFileTypes: true });
+      const entries = fs4.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path4.join(dir, entry.name);
         if (entry.isDirectory()) {
@@ -426,7 +428,7 @@ var MigrationManager = class {
    * Load SQL migration from file
    */
   loadSqlMigration(migrationFile) {
-    const sql2 = fs3.readFileSync(migrationFile.filePath, "utf-8");
+    const sql2 = fs4.readFileSync(migrationFile.filePath, "utf-8");
     const { upSQL, downSQL } = this.parseSqlSections(sql2);
     return {
       version: migrationFile.version,
@@ -770,10 +772,10 @@ var SeedManager = class {
    * Discover seed files from seeds directory
    */
   async discoverSeeds() {
-    if (!fs3.existsSync(this.seedsPath)) {
+    if (!fs4.existsSync(this.seedsPath)) {
       return [];
     }
-    const files = fs3.readdirSync(this.seedsPath);
+    const files = fs4.readdirSync(this.seedsPath);
     const seeds = [];
     for (const file of files) {
       const match = file.match(/^(\d+)_(.+)\.(ts|js|sql)$/);
@@ -903,7 +905,7 @@ var SeedManager = class {
    * Load SQL seed from file
    */
   loadSqlSeed(seedFile) {
-    const sql2 = fs3.readFileSync(seedFile.filePath, "utf-8");
+    const sql2 = fs4.readFileSync(seedFile.filePath, "utf-8");
     return {
       name: seedFile.name,
       run: /* @__PURE__ */ __name(async () => {
@@ -8267,6 +8269,9 @@ async function createDatabaseService(config) {
 }
 __name(createDatabaseService, "createDatabaseService");
 var JSON_INDENT_SPACES = 2;
+var VERSION_PAD_LENGTH = 3;
+var DECIMAL_RADIX = 10;
+var SEPARATOR_WIDTH = 50;
 async function getUserSchemas(adapter) {
   const result = await adapter.query?.(`
     SELECT schema_name FROM information_schema.schemata
@@ -8327,8 +8332,8 @@ function parseEnvLine(line) {
 }
 __name(parseEnvLine, "parseEnvLine");
 function loadEnvFile(envFilePath) {
-  if (!fs3.existsSync(envFilePath)) return;
-  const envContent = fs3.readFileSync(envFilePath, "utf-8");
+  if (!fs4.existsSync(envFilePath)) return;
+  const envContent = fs4.readFileSync(envFilePath, "utf-8");
   for (const line of envContent.split("\n")) {
     const parsed = parseEnvLine(line);
     if (parsed) {
@@ -8361,7 +8366,7 @@ __name(loadConfigFromPath, "loadConfigFromPath");
 async function findAndLoadConfig() {
   for (const configName of CONFIG_PATHS) {
     const configFilePath = path4.join(process.cwd(), configName);
-    if (fs3.existsSync(configFilePath)) {
+    if (fs4.existsSync(configFilePath)) {
       return loadConfigFromPath(configFilePath);
     }
   }
@@ -8371,7 +8376,7 @@ __name(findAndLoadConfig, "findAndLoadConfig");
 function warnAboutTypeScriptConfigs() {
   for (const tsName of TS_CONFIG_PATHS) {
     const tsPath = path4.join(process.cwd(), tsName);
-    if (fs3.existsSync(tsPath)) {
+    if (fs4.existsSync(tsPath)) {
       console.warn(
         `⚠️  Found ${path4.basename(tsPath)} but cannot import TypeScript files directly.`
       );
@@ -8406,7 +8411,7 @@ async function loadConfig(configPath) {
   const explicitPath = configPath ?? globalConfigPath;
   if (explicitPath) {
     const resolvedPath = path4.resolve(process.cwd(), explicitPath);
-    if (fs3.existsSync(resolvedPath)) {
+    if (fs4.existsSync(resolvedPath)) {
       return loadConfigFromPath(resolvedPath);
     }
     console.error(`❌ Config file not found: ${resolvedPath}`);
@@ -9226,6 +9231,417 @@ program.command("reset").description(
     process.exit(1);
   }
 });
+function createReadlineInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+__name(createReadlineInterface, "createReadlineInterface");
+async function promptInput(message, defaultValue) {
+  const rl = createReadlineInterface();
+  const prompt = defaultValue ? `${message} (${defaultValue}): ` : `${message}: `;
+  return new Promise((resolve4) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve4(trimmed !== "" ? trimmed : defaultValue ?? "");
+    });
+  });
+}
+__name(promptInput, "promptInput");
+async function promptSelect(message, options) {
+  const rl = createReadlineInterface();
+  console.log(message);
+  options.forEach((opt, i) => console.log(`  ${i + 1}) ${opt}`));
+  return new Promise((resolve4) => {
+    rl.question("Select (number): ", (answer) => {
+      rl.close();
+      const index = Number.parseInt(answer, DECIMAL_RADIX) - 1;
+      resolve4(options[index] ?? options[0]);
+    });
+  });
+}
+__name(promptSelect, "promptSelect");
+async function promptConfirm(message) {
+  const rl = createReadlineInterface();
+  return new Promise((resolve4) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+__name(promptConfirm, "promptConfirm");
+async function runInteractiveMigration(config) {
+  console.log();
+  console.log("📦 Create Migration - Interactive Mode");
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  console.log();
+  const name = await promptInput("Migration name (e.g., add_users_table)");
+  if (!name) {
+    console.error("❌ Migration name is required");
+    process.exit(1);
+  }
+  const snakeName = toSnakeCase(name);
+  const tableName = await promptInput("Table name", snakeName);
+  const schema = await promptInput("Database schema", "public");
+  const typeChoice = await promptSelect("File type:", [
+    "SQL (.sql)",
+    "TypeScript (.ts)"
+  ]);
+  const type = typeChoice.includes("TypeScript") ? "ts" : "sql";
+  const gitUser = getGitUsername();
+  const includeAuthor = gitUser ? await promptConfirm(`Include author (${gitUser})?`) : false;
+  const author = includeAuthor ? gitUser : "";
+  console.log();
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  console.log(`Migration: ${name}`);
+  console.log(`Table: ${schema}.${tableName}`);
+  console.log(`Type: ${type.toUpperCase()}`);
+  if (author) console.log(`Author: ${author}`);
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  const confirm = await promptConfirm("Create migration?");
+  if (!confirm) {
+    console.log("Cancelled.");
+    process.exit(0);
+  }
+  const migrationsPath = config.migrationsPath ?? "./migrations";
+  if (!fs4.existsSync(migrationsPath)) {
+    fs4.mkdirSync(migrationsPath, { recursive: true });
+  }
+  const version = getNextMigrationVersion(migrationsPath);
+  const filename = `${version}_${snakeName}.${type}`;
+  const filepath = path4.join(migrationsPath, filename);
+  const content = getMigrationTemplate({
+    name,
+    version,
+    tableName,
+    schema,
+    author,
+    type
+  });
+  fs4.writeFileSync(filepath, content, "utf-8");
+  console.log(`✅ Created: ${filepath}`);
+}
+__name(runInteractiveMigration, "runInteractiveMigration");
+async function runInteractiveSeed(config) {
+  console.log();
+  console.log("🌱 Create Seed - Interactive Mode");
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  console.log();
+  const name = await promptInput("Seed name (e.g., admin_users)");
+  if (!name) {
+    console.error("❌ Seed name is required");
+    process.exit(1);
+  }
+  const snakeName = toSnakeCase(name);
+  const tableName = await promptInput("Table name", snakeName);
+  const schema = await promptInput("Database schema", "public");
+  const typeChoice = await promptSelect("File type:", [
+    "TypeScript (.ts)",
+    "SQL (.sql)",
+    "CSV (.csv)"
+  ]);
+  const typeMap = {
+    "TypeScript (.ts)": "ts",
+    "SQL (.sql)": "sql",
+    "CSV (.csv)": "csv"
+  };
+  const type = typeMap[typeChoice] ?? "ts";
+  let author = "";
+  if (type !== "csv") {
+    const gitUser = getGitUsername();
+    const includeAuthor = gitUser ? await promptConfirm(`Include author (${gitUser})?`) : false;
+    author = includeAuthor ? gitUser : "";
+  }
+  console.log();
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  console.log(`Seed: ${name}`);
+  console.log(`Table: ${schema}.${tableName}`);
+  console.log(`Type: ${type.toUpperCase()}`);
+  if (author) console.log(`Author: ${author}`);
+  console.log("─".repeat(SEPARATOR_WIDTH));
+  const confirm = await promptConfirm("Create seed?");
+  if (!confirm) {
+    console.log("Cancelled.");
+    process.exit(0);
+  }
+  const seedsPath = config.seedsPath ?? "./seeds";
+  if (!fs4.existsSync(seedsPath)) {
+    fs4.mkdirSync(seedsPath, { recursive: true });
+  }
+  const order = getNextSeedOrder(seedsPath);
+  const filename = `${order}_${snakeName}.${type}`;
+  const filepath = path4.join(seedsPath, filename);
+  let content;
+  if (type === "csv") {
+    content = getCsvSeedTemplate({ name, tableName, schema });
+  } else {
+    content = getSeedTemplate({
+      name,
+      order,
+      tableName,
+      schema,
+      author,
+      type
+    });
+  }
+  fs4.writeFileSync(filepath, content, "utf-8");
+  console.log(`✅ Created: ${filepath}`);
+}
+__name(runInteractiveSeed, "runInteractiveSeed");
+function getNextMigrationVersion(migrationsPath) {
+  if (!fs4.existsSync(migrationsPath)) {
+    return "001";
+  }
+  const files = fs4.readdirSync(migrationsPath);
+  const versions = files.map((f) => {
+    const match = f.match(/^(\d+)_/);
+    return match ? Number.parseInt(match[1], DECIMAL_RADIX) : 0;
+  }).filter((v) => v > 0);
+  const maxVersion = versions.length > 0 ? Math.max(...versions) : 0;
+  return String(maxVersion + 1).padStart(VERSION_PAD_LENGTH, "0");
+}
+__name(getNextMigrationVersion, "getNextMigrationVersion");
+function getNextSeedOrder(seedsPath) {
+  if (!fs4.existsSync(seedsPath)) {
+    return "001";
+  }
+  const files = fs4.readdirSync(seedsPath);
+  const orders = files.map((f) => {
+    const match = f.match(/^(\d+)_/);
+    return match ? Number.parseInt(match[1], DECIMAL_RADIX) : 0;
+  }).filter((v) => v > 0);
+  const maxOrder = orders.length > 0 ? Math.max(...orders) : 0;
+  return String(maxOrder + 1).padStart(VERSION_PAD_LENGTH, "0");
+}
+__name(getNextSeedOrder, "getNextSeedOrder");
+function toSnakeCase(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "").replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_");
+}
+__name(toSnakeCase, "toSnakeCase");
+function toPascalCase(name) {
+  return name.split(/[_\s-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+__name(toPascalCase, "toPascalCase");
+function getTemplateDir() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = path4.dirname(currentFile);
+  const packageRoot = path4.resolve(currentDir, "..", "..");
+  return path4.join(packageRoot, "template");
+}
+__name(getTemplateDir, "getTemplateDir");
+function loadTemplate(templatePath, vars) {
+  const fullPath = path4.join(getTemplateDir(), templatePath);
+  if (!fs4.existsSync(fullPath)) {
+    throw new Error(`Template not found: ${fullPath}`);
+  }
+  let content = fs4.readFileSync(fullPath, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    content = content.replace(regex, value ?? "");
+  }
+  return content;
+}
+__name(loadTemplate, "loadTemplate");
+function getGitUsername() {
+  try {
+    return execSync("git config user.name", { encoding: "utf-8" }).trim();
+  } catch {
+    return "";
+  }
+}
+__name(getGitUsername, "getGitUsername");
+function getMigrationTemplate(options) {
+  const { name, version, tableName, schema, author, type } = options;
+  const description = toPascalCase(name);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const vars = {
+    VERSION: version,
+    DESCRIPTION: description,
+    TABLE_NAME: tableName,
+    SCHEMA: schema,
+    CREATED_DATE: date,
+    AUTHOR: author
+  };
+  const templateFile = type === "ts" ? "migrations/migration.ts.template" : "migrations/migration.sql.template";
+  return loadTemplate(templateFile, vars);
+}
+__name(getMigrationTemplate, "getMigrationTemplate");
+function getSeedTemplate(options) {
+  const { name, order, tableName, schema, author, type } = options;
+  const description = toPascalCase(name);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const vars = {
+    ORDER: order,
+    DESCRIPTION: description,
+    TABLE_NAME: tableName,
+    SCHEMA: schema,
+    CREATED_DATE: date,
+    AUTHOR: author,
+    UUID_1: randomUUID(),
+    UUID_2: randomUUID(),
+    UUID_3: randomUUID()
+  };
+  const templateFile = type === "ts" ? "seeds/seed.ts.template" : "seeds/seed.sql.template";
+  return loadTemplate(templateFile, vars);
+}
+__name(getSeedTemplate, "getSeedTemplate");
+function getCsvSeedTemplate(options) {
+  const { name, tableName, schema } = options;
+  const description = toPascalCase(name);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const vars = {
+    DESCRIPTION: description,
+    TABLE_NAME: tableName,
+    SCHEMA: schema,
+    CREATED_DATE: date,
+    AUTHOR: "",
+    UUID_1: randomUUID(),
+    UUID_2: randomUUID(),
+    UUID_3: randomUUID()
+  };
+  try {
+    return loadTemplate("seeds/seed.csv.template", vars);
+  } catch {
+    return `id,name,created_at
+${randomUUID()},Example 1,${(/* @__PURE__ */ new Date()).toISOString()}
+${randomUUID()},Example 2,${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  }
+}
+__name(getCsvSeedTemplate, "getCsvSeedTemplate");
+var createCommand = program.command("create").description("Create new migration or seed files");
+createCommand.command("migration").description("Create a new migration file (interactive if no name provided)").argument("[name]", "Migration name (e.g., add_users_table)").option("-t, --type <type>", "File type: sql or ts (default: sql)", "sql").option(
+  "-T, --table <table>",
+  "Table name (default: derived from migration name)"
+).option(
+  "-s, --schema <schema>",
+  "Database schema (default: public)",
+  "public"
+).option("--no-author", "Skip adding git username as author").option("-i, --interactive", "Force interactive mode").action(
+  async (name, options) => {
+    try {
+      const config = await loadConfig();
+      if (!name || options.interactive) {
+        await runInteractiveMigration(config);
+        process.exit(0);
+      }
+      const migrationsPath = config.migrationsPath ?? "./migrations";
+      if (!fs4.existsSync(migrationsPath)) {
+        fs4.mkdirSync(migrationsPath, { recursive: true });
+        console.log(`📁 Created directory: ${migrationsPath}`);
+      }
+      const version = getNextMigrationVersion(migrationsPath);
+      const snakeName = toSnakeCase(name);
+      const tableName = options.table ?? snakeName;
+      const schema = options.schema;
+      const author = options.author ? getGitUsername() : "";
+      const extension = options.type === "ts" ? "ts" : "sql";
+      const filename = `${version}_${snakeName}.${extension}`;
+      const filepath = path4.join(migrationsPath, filename);
+      if (fs4.existsSync(filepath)) {
+        console.error(`❌ File already exists: ${filepath}`);
+        process.exit(1);
+      }
+      const content = getMigrationTemplate({
+        name,
+        version,
+        tableName,
+        schema,
+        author,
+        type: options.type === "ts" ? "ts" : "sql"
+      });
+      fs4.writeFileSync(filepath, content, "utf-8");
+      console.log(`✅ Created migration: ${filename}`);
+      console.log(`   Path: ${filepath}`);
+      console.log(`   Type: ${options.type.toUpperCase()}`);
+      console.log(`   Table: ${schema}.${tableName}`);
+      if (author) {
+        console.log(`   Author: ${author}`);
+      }
+      console.log("");
+      console.log("📝 Next steps:");
+      console.log(`   1. Edit the migration file to add your schema changes`);
+      console.log(`   2. Run 'plyaz-db migrate up' to apply the migration`);
+      console.log(
+        `   3. Test rollback with 'plyaz-db migrate down' before deploying`
+      );
+      process.exit(0);
+    } catch (error) {
+      console.error("❌ Error:", error.message);
+      process.exit(1);
+    }
+  }
+);
+createCommand.command("seed").description("Create a new seed file (interactive if no name provided)").argument("[name]", "Seed name (e.g., admin_users)").option("-t, --type <type>", "File type: ts, sql, or csv (default: ts)", "ts").option("-T, --table <table>", "Table name (default: derived from seed name)").option(
+  "-s, --schema <schema>",
+  "Database schema (default: public)",
+  "public"
+).option("--no-author", "Skip adding git username as author").option("-i, --interactive", "Force interactive mode").action(
+  async (name, options) => {
+    try {
+      const config = await loadConfig();
+      if (!name || options.interactive) {
+        await runInteractiveSeed(config);
+        process.exit(0);
+      }
+      const seedsPath = config.seedsPath ?? "./seeds";
+      if (!fs4.existsSync(seedsPath)) {
+        fs4.mkdirSync(seedsPath, { recursive: true });
+        console.log(`📁 Created directory: ${seedsPath}`);
+      }
+      const order = getNextSeedOrder(seedsPath);
+      const snakeName = toSnakeCase(name);
+      const tableName = options.table ?? snakeName;
+      const schema = options.schema;
+      const author = options.author ? getGitUsername() : "";
+      const typeMap = {
+        ts: "ts",
+        sql: "sql",
+        csv: "csv"
+      };
+      const fileType = typeMap[options.type] ?? "ts";
+      const filename = `${order}_${snakeName}.${fileType}`;
+      const filepath = path4.join(seedsPath, filename);
+      if (fs4.existsSync(filepath)) {
+        console.error(`❌ File already exists: ${filepath}`);
+        process.exit(1);
+      }
+      let content;
+      if (fileType === "csv") {
+        content = getCsvSeedTemplate({ name, tableName, schema });
+      } else {
+        content = getSeedTemplate({
+          name,
+          order,
+          tableName,
+          schema,
+          author,
+          type: fileType
+        });
+      }
+      fs4.writeFileSync(filepath, content, "utf-8");
+      console.log(`✅ Created seed: ${filename}`);
+      console.log(`   Path: ${filepath}`);
+      console.log(`   Type: ${fileType.toUpperCase()}`);
+      console.log(`   Table: ${schema}.${tableName}`);
+      if (author && fileType !== "csv") {
+        console.log(`   Author: ${author}`);
+      }
+      console.log("");
+      console.log("📝 Next steps:");
+      console.log(`   1. Edit the seed file to add your data`);
+      console.log(`   2. Run 'plyaz-db seed run' to execute seeds`);
+      console.log(`   3. Use 'plyaz-db seed status' to check seed status`);
+      process.exit(0);
+    } catch (error) {
+      console.error("❌ Error:", error.message);
+      process.exit(1);
+    }
+  }
+);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map