@javalabs/prisma-client 1.0.18 → 1.0.19

package/src/scripts/sequence-sync-cli.ts

@@ -1,416 +1,416 @@
-#!/usr/bin/env node
-
-import { Command } from "commander";
-import { config } from "dotenv";
-import { Logger } from "@nestjs/common";
-import { Pool } from "pg";
-import * as path from "path";
-import * as fs from "fs";
-
-// Load environment variables
-config();
-
-const program = new Command();
-const logger = new Logger("SequenceSyncCLI");
-
-interface MigrationConfig {
-  commonSchema: string;
-  tables: {
-    [key: string]: {
-      type: string;
-      idField: string;
-      dependencies?: string[];
-      filterColumn?: string;
-    };
-  };
-  migrationPriorities: {
-    high: string[];
-    medium: string[];
-    low: string[];
-  };
-}
-
-program
-  .name("sequence-sync")
-  .description("Synchronize ID sequences in PostgreSQL database")
-  .option(
-    "-d, --database-url <url>",
-    "Database connection URL",
-    process.env.DATABASE_URL
-  )
-  .option(
-    "--dry-run",
-    "Show changes that would be made without applying them",
-    false
-  )
-  .option("-v, --verbose", "Show detailed information during execution", false)
-  .option("-t, --table <table>", "Synchronize a specific table", "")
-  .option(
-    "--priority <level>",
-    "Synchronize tables of a specific priority (high, medium, low)",
-    ""
-  )
-  .option("--fix", "Attempt to fix missing sequences", false);
-
-program.parse(process.argv);
-const options = program.opts();
-
-if (!options.databaseUrl) {
-  logger.error(
-    "Database URL must be provided via --database-url or DATABASE_URL environment variable"
-  );
-  process.exit(1);
-}
-
-// Load configuration
-const configPath = path.join(
-  __dirname,
-  "data-migration",
-  "migration-config.json"
-);
-let migrationConfig: MigrationConfig;
-
-try {
-  migrationConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
-} catch (error) {
-  logger.error("Error loading configuration file:", error.message);
-  process.exit(1);
-}
-
-interface TableInfo {
-  tableName: string;
-  primaryKeyColumn: string;
-  sequenceName: string | null;
-  hasAutoIncrement: boolean;
-}
-
-async function findExistingSequence(
-  pool: Pool,
-  tableName: string,
-  columnName: string
-): Promise<string | null> {
-  try {
-    // Query to find all sequences that might be associated with this column
-    const query = `
-      SELECT 
-        s.relname as sequence_name
-      FROM pg_class s
-      JOIN pg_depend d ON d.objid = s.oid
-      JOIN pg_class t ON d.refobjid = t.oid
-      JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)
-      JOIN pg_namespace n ON n.oid = s.relnamespace
-      WHERE s.relkind = 'S'
-        AND n.nspname = 'public'
-        AND t.relname = $1
-        AND a.attname = $2;
-    `;
-
-    const result = await pool.query(query, [tableName, columnName]);
-
-    if (result.rows.length > 0) {
-      if (options.verbose) {
-        logger.log(
-          `Found sequence for ${tableName}.${columnName}: ${result.rows[0].sequence_name}`
-        );
-      }
-      return result.rows[0].sequence_name;
-    }
-
-    return null;
-  } catch (error) {
-    logger.error(
-      `Error finding existing sequence for ${tableName}.${columnName}:`,
-      error.message
-    );
-    return null;
-  }
-}
-
-async function findOrCreateSequence(
-  pool: Pool,
-  tableName: string,
-  columnName: string
-): Promise<string | null> {
-  try {
-    // First try to find an existing sequence
-    let sequenceName = await findExistingSequence(pool, tableName, columnName);
-
-    if (sequenceName) {
-      return sequenceName;
-    }
-
-    if (!options.fix) {
-      if (options.verbose) {
-        logger.log(
-          `No sequence found for ${tableName}.${columnName} and --fix is not enabled`
-        );
-      }
-      return null;
-    }
-
-    // Try common sequence name patterns
-    const possibleNames = [
-      `${tableName}_${columnName}_seq`,
-      `${tableName}_id_seq`,
-      `${tableName}_seq`,
-    ];
-
-    for (const name of possibleNames) {
-      const exists = await pool.query(
-        `
-        SELECT EXISTS (
-          SELECT 1 FROM pg_class c
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE n.nspname = 'public'
-          AND c.relname = $1
-          AND c.relkind = 'S'
-        );
-      `,
-        [name]
-      );
-
-      if (exists.rows[0].exists) {
-        sequenceName = name;
-        break;
-      }
-    }
-
-    if (!sequenceName) {
-      // If no sequence exists, create a new one
-      sequenceName = `${tableName}_${columnName}_seq`;
-
-      if (options.verbose) {
-        logger.log(`Creating new sequence: ${sequenceName}`);
-      }
-
-      // Get current maximum value
-      const maxValQuery = `
-        SELECT COALESCE(MAX("${columnName}"), 0) as max_val 
-        FROM "${tableName}";
-      `;
-      const maxValResult = await pool.query(maxValQuery);
-      const maxVal = parseInt(maxValResult.rows[0].max_val);
-
-      if (!options.dryRun) {
-        // Create sequence
-        await pool.query(`
-          CREATE SEQUENCE IF NOT EXISTS "${sequenceName}"
-          START WITH ${maxVal + 1}
-          INCREMENT BY 1
-          NO MINVALUE
-          NO MAXVALUE
-          CACHE 1;
-        `);
-
-        // Associate sequence with column
-        await pool.query(`
-          ALTER TABLE "${tableName}" 
-          ALTER COLUMN "${columnName}" 
-          SET DEFAULT nextval('${sequenceName}'::regclass);
-        `);
-
-        logger.log(`✅ Sequence created and associated: ${sequenceName}`);
-      } else {
-        logger.log(`[DRY-RUN] Would create sequence: ${sequenceName}`);
-      }
-    }
-
-    return sequenceName;
-  } catch (error) {
-    logger.error(
-      `Error handling sequence for ${tableName}.${columnName}:`,
-      error.message
-    );
-    return null;
-  }
-}
-
-async function getTableInfo(
-  pool: Pool,
-  tableName: string,
-  idField: string
-): Promise<TableInfo | null> {
-  try {
-    // Check if table exists
-    const tableExistsQuery = `
-      SELECT EXISTS (
-        SELECT 1 
-        FROM information_schema.tables 
-        WHERE table_schema = $1 
-        AND table_name = $2
-      );
-    `;
-
-    const tableExists = await pool.query(tableExistsQuery, [
-      migrationConfig.commonSchema,
-      tableName,
-    ]);
-
-    if (!tableExists.rows[0].exists) {
-      logger.warn(`Table ${tableName} does not exist in database`);
-      return null;
-    }
-
-    // Try to find or create sequence
-    const sequenceName = await findOrCreateSequence(pool, tableName, idField);
-
-    // Check if column is auto-incrementing
-    const columnQuery = `
-      SELECT EXISTS (
-        SELECT 1 FROM pg_attrdef ad 
-        JOIN pg_attribute a ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
-        WHERE a.attrelid = $1::regclass 
-        AND a.attname = $2
-        AND (pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval%' OR $3::text IS NOT NULL)
-      ) as is_auto_increment;
-    `;
-
-    const columnResult = await pool.query(columnQuery, [
-      tableName,
-      idField,
-      sequenceName,
-    ]);
-
-    return {
-      tableName,
-      primaryKeyColumn: idField,
-      sequenceName,
-      hasAutoIncrement: columnResult.rows[0].is_auto_increment,
-    };
-  } catch (error) {
-    logger.error(
-      `Error getting table information for ${tableName}:`,
-      error.message
-    );
-    return null;
-  }
-}
-
-async function checkTableSequence(
-  pool: Pool,
-  tableName: string
-): Promise<void> {
-  try {
-    const tableConfig = migrationConfig.tables[tableName];
-    if (!tableConfig) {
-      logger.warn(`No configuration found for table ${tableName}`);
-      return;
-    }
-
-    const tableInfo = await getTableInfo(pool, tableName, tableConfig.idField);
-    if (!tableInfo) return;
-
-    if (!tableInfo.hasAutoIncrement || !tableInfo.sequenceName) {
-      if (options.verbose) {
-        logger.log(`\nTable ${tableInfo.tableName}:`);
-        logger.log(`- Primary key column: ${tableInfo.primaryKeyColumn}`);
-        logger.log(`- Does not use automatic sequence`);
-      }
-      return;
-    }
-
-    if (options.verbose) {
-      logger.log(`\nTable information:`);
-      logger.log(`- Table name: ${tableInfo.tableName}`);
-      logger.log(`- Primary key column: ${tableInfo.primaryKeyColumn}`);
-      logger.log(`- Sequence: ${tableInfo.sequenceName}`);
-    }
-
-    // Get maximum ID
-    const maxIdResult = await pool.query(`
-      SELECT COALESCE(MAX("${tableInfo.primaryKeyColumn}"), 0) as max_id 
-      FROM "${tableInfo.tableName}";
-    `);
-    const maxId = parseInt(maxIdResult.rows[0].max_id);
-
-    // Get current sequence value
-    const seqResult = await pool.query(`
-      SELECT last_value, is_called 
-      FROM "${tableInfo.sequenceName}";
-    `);
-    const currentSeqValue = parseInt(seqResult.rows[0].last_value);
-    const isCalled = seqResult.rows[0].is_called;
-
-    logger.log(`\nDiagnostics for table ${tableInfo.tableName}:`);
-    logger.log(
-      `- Maximum ID in table (${tableInfo.primaryKeyColumn}): ${maxId}`
-    );
-    logger.log(`- Current sequence value: ${currentSeqValue}`);
-    logger.log(`- Sequence has been called: ${isCalled}`);
-
-    if (currentSeqValue <= maxId) {
-      logger.log(`\n⚠️  Problem detected! Sequence is behind maximum ID`);
-
-      if (!options.dryRun) {
-        await pool.query(`SELECT setval($1, $2, true);`, [
-          tableInfo.sequenceName,
-          maxId,
-        ]);
-        logger.log(`✅ Sequence updated to value ${maxId}`);
-      } else {
-        logger.log(`[DRY-RUN] Would update sequence to value ${maxId}`);
-      }
-    } else {
-      logger.log(`✅ Sequence is properly configured`);
-    }
-  } catch (error) {
-    logger.error(`Error processing table ${tableName}:`, error.message);
-  }
-}
-
-async function main() {
-  try {
-    logger.log("Starting sequence synchronization...");
-    logger.log(`Database URL: ${options.databaseUrl.split("@")[1]}`);
-
-    if (options.dryRun) {
-      logger.log("Dry-run mode: No changes will be made");
-    }
-
-    const pool = new Pool({ connectionString: options.databaseUrl });
-
-    if (options.table) {
-      await checkTableSequence(pool, options.table);
-    } else if (options.priority) {
-      const tables =
-        migrationConfig.migrationPriorities[
-          options.priority as keyof typeof migrationConfig.migrationPriorities
-        ];
-      if (!tables) {
-        logger.error(`Invalid priority: ${options.priority}`);
-        process.exit(1);
-      }
-
-      for (const table of tables) {
-        if (options.verbose) {
-          logger.log(
-            `\nProcessing ${options.priority} priority table: ${table}`
-          );
-        }
-        await checkTableSequence(pool, table);
-      }
-    } else {
-      // Process all tables in priority order
-      const allTables = [
-        ...migrationConfig.migrationPriorities.high,
-        ...migrationConfig.migrationPriorities.medium,
-        ...migrationConfig.migrationPriorities.low,
-      ];
-
-      for (const table of allTables) {
-        if (options.verbose) {
-          logger.log(`\nProcessing table: ${table}`);
-        }
-        await checkTableSequence(pool, table);
-      }
-    }
-
-    await pool.end();
-    logger.log("\nSequence synchronization completed successfully");
-  } catch (error) {
-    logger.error("Error during synchronization:", error.stack);
-    process.exit(1);
-  }
-}
-
-main();
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { config } from "dotenv";
+import { Logger } from "@nestjs/common";
+import { Pool } from "pg";
+import * as path from "path";
+import * as fs from "fs";
+
+// Load environment variables
+config();
+
+const program = new Command();
+const logger = new Logger("SequenceSyncCLI");
+
+interface MigrationConfig {
+  commonSchema: string;
+  tables: {
+    [key: string]: {
+      type: string;
+      idField: string;
+      dependencies?: string[];
+      filterColumn?: string;
+    };
+  };
+  migrationPriorities: {
+    high: string[];
+    medium: string[];
+    low: string[];
+  };
+}
+
+program
+  .name("sequence-sync")
+  .description("Synchronize ID sequences in PostgreSQL database")
+  .option(
+    "-d, --database-url <url>",
+    "Database connection URL",
+    process.env.DATABASE_URL
+  )
+  .option(
+    "--dry-run",
+    "Show changes that would be made without applying them",
+    false
+  )
+  .option("-v, --verbose", "Show detailed information during execution", false)
+  .option("-t, --table <table>", "Synchronize a specific table", "")
+  .option(
+    "--priority <level>",
+    "Synchronize tables of a specific priority (high, medium, low)",
+    ""
+  )
+  .option("--fix", "Attempt to fix missing sequences", false);
+
+program.parse(process.argv);
+const options = program.opts();
+
+if (!options.databaseUrl) {
+  logger.error(
+    "Database URL must be provided via --database-url or DATABASE_URL environment variable"
+  );
+  process.exit(1);
+}
+
+// Load configuration
+const configPath = path.join(
+  __dirname,
+  "data-migration",
+  "migration-config.json"
+);
+let migrationConfig: MigrationConfig;
+
+try {
+  migrationConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+} catch (error) {
+  logger.error("Error loading configuration file:", error.message);
+  process.exit(1);
+}
+
+interface TableInfo {
+  tableName: string;
+  primaryKeyColumn: string;
+  sequenceName: string | null;
+  hasAutoIncrement: boolean;
+}
+
+async function findExistingSequence(
+  pool: Pool,
+  tableName: string,
+  columnName: string
+): Promise<string | null> {
+  try {
+    // Query to find all sequences that might be associated with this column
+    const query = `
+      SELECT 
+        s.relname as sequence_name
+      FROM pg_class s
+      JOIN pg_depend d ON d.objid = s.oid
+      JOIN pg_class t ON d.refobjid = t.oid
+      JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)
+      JOIN pg_namespace n ON n.oid = s.relnamespace
+      WHERE s.relkind = 'S'
+        AND n.nspname = 'public'
+        AND t.relname = $1
+        AND a.attname = $2;
+    `;
+
+    const result = await pool.query(query, [tableName, columnName]);
+
+    if (result.rows.length > 0) {
+      if (options.verbose) {
+        logger.log(
+          `Found sequence for ${tableName}.${columnName}: ${result.rows[0].sequence_name}`
+        );
+      }
+      return result.rows[0].sequence_name;
+    }
+
+    return null;
+  } catch (error) {
+    logger.error(
+      `Error finding existing sequence for ${tableName}.${columnName}:`,
+      error.message
+    );
+    return null;
+  }
+}
+
+async function findOrCreateSequence(
+  pool: Pool,
+  tableName: string,
+  columnName: string
+): Promise<string | null> {
+  try {
+    // First try to find an existing sequence
+    let sequenceName = await findExistingSequence(pool, tableName, columnName);
+
+    if (sequenceName) {
+      return sequenceName;
+    }
+
+    if (!options.fix) {
+      if (options.verbose) {
+        logger.log(
+          `No sequence found for ${tableName}.${columnName} and --fix is not enabled`
+        );
+      }
+      return null;
+    }
+
+    // Try common sequence name patterns
+    const possibleNames = [
+      `${tableName}_${columnName}_seq`,
+      `${tableName}_id_seq`,
+      `${tableName}_seq`,
+    ];
+
+    for (const name of possibleNames) {
+      const exists = await pool.query(
+        `
+        SELECT EXISTS (
+          SELECT 1 FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = 'public'
+          AND c.relname = $1
+          AND c.relkind = 'S'
+        );
+      `,
+        [name]
+      );
+
+      if (exists.rows[0].exists) {
+        sequenceName = name;
+        break;
+      }
+    }
+
+    if (!sequenceName) {
+      // If no sequence exists, create a new one
+      sequenceName = `${tableName}_${columnName}_seq`;
+
+      if (options.verbose) {
+        logger.log(`Creating new sequence: ${sequenceName}`);
+      }
+
+      // Get current maximum value
+      const maxValQuery = `
+        SELECT COALESCE(MAX("${columnName}"), 0) as max_val 
+        FROM "${tableName}";
+      `;
+      const maxValResult = await pool.query(maxValQuery);
+      const maxVal = parseInt(maxValResult.rows[0].max_val);
+
+      if (!options.dryRun) {
+        // Create sequence
+        await pool.query(`
+          CREATE SEQUENCE IF NOT EXISTS "${sequenceName}"
+          START WITH ${maxVal + 1}
+          INCREMENT BY 1
+          NO MINVALUE
+          NO MAXVALUE
+          CACHE 1;
+        `);
+
+        // Associate sequence with column
+        await pool.query(`
+          ALTER TABLE "${tableName}" 
+          ALTER COLUMN "${columnName}" 
+          SET DEFAULT nextval('${sequenceName}'::regclass);
+        `);
+
+        logger.log(`✅ Sequence created and associated: ${sequenceName}`);
+      } else {
+        logger.log(`[DRY-RUN] Would create sequence: ${sequenceName}`);
+      }
+    }
+
+    return sequenceName;
+  } catch (error) {
+    logger.error(
+      `Error handling sequence for ${tableName}.${columnName}:`,
+      error.message
+    );
+    return null;
+  }
+}
+
+async function getTableInfo(
+  pool: Pool,
+  tableName: string,
+  idField: string
+): Promise<TableInfo | null> {
+  try {
+    // Check if table exists
+    const tableExistsQuery = `
+      SELECT EXISTS (
+        SELECT 1 
+        FROM information_schema.tables 
+        WHERE table_schema = $1 
+        AND table_name = $2
+      );
+    `;
+
+    const tableExists = await pool.query(tableExistsQuery, [
+      migrationConfig.commonSchema,
+      tableName,
+    ]);
+
+    if (!tableExists.rows[0].exists) {
+      logger.warn(`Table ${tableName} does not exist in database`);
+      return null;
+    }
+
+    // Try to find or create sequence
+    const sequenceName = await findOrCreateSequence(pool, tableName, idField);
+
+    // Check if column is auto-incrementing
+    const columnQuery = `
+      SELECT EXISTS (
+        SELECT 1 FROM pg_attrdef ad 
+        JOIN pg_attribute a ON a.attrelid = ad.adrelid AND a.attnum = ad.adnum
+        WHERE a.attrelid = $1::regclass 
+        AND a.attname = $2
+        AND (pg_get_expr(ad.adbin, ad.adrelid) LIKE 'nextval%' OR $3::text IS NOT NULL)
+      ) as is_auto_increment;
+    `;
+
+    const columnResult = await pool.query(columnQuery, [
+      tableName,
+      idField,
+      sequenceName,
+    ]);
+
+    return {
+      tableName,
+      primaryKeyColumn: idField,
+      sequenceName,
+      hasAutoIncrement: columnResult.rows[0].is_auto_increment,
+    };
+  } catch (error) {
+    logger.error(
+      `Error getting table information for ${tableName}:`,
+      error.message
+    );
+    return null;
+  }
+}
+
+async function checkTableSequence(
+  pool: Pool,
+  tableName: string
+): Promise<void> {
+  try {
+    const tableConfig = migrationConfig.tables[tableName];
+    if (!tableConfig) {
+      logger.warn(`No configuration found for table ${tableName}`);
+      return;
+    }
+
+    const tableInfo = await getTableInfo(pool, tableName, tableConfig.idField);
+    if (!tableInfo) return;
+
+    if (!tableInfo.hasAutoIncrement || !tableInfo.sequenceName) {
+      if (options.verbose) {
+        logger.log(`\nTable ${tableInfo.tableName}:`);
+        logger.log(`- Primary key column: ${tableInfo.primaryKeyColumn}`);
+        logger.log(`- Does not use automatic sequence`);
+      }
+      return;
+    }
+
+    if (options.verbose) {
+      logger.log(`\nTable information:`);
+      logger.log(`- Table name: ${tableInfo.tableName}`);
+      logger.log(`- Primary key column: ${tableInfo.primaryKeyColumn}`);
+      logger.log(`- Sequence: ${tableInfo.sequenceName}`);
+    }
+
+    // Get maximum ID
+    const maxIdResult = await pool.query(`
+      SELECT COALESCE(MAX("${tableInfo.primaryKeyColumn}"), 0) as max_id 
+      FROM "${tableInfo.tableName}";
+    `);
+    const maxId = parseInt(maxIdResult.rows[0].max_id);
+
+    // Get current sequence value
+    const seqResult = await pool.query(`
+      SELECT last_value, is_called 
+      FROM "${tableInfo.sequenceName}";
+    `);
+    const currentSeqValue = parseInt(seqResult.rows[0].last_value);
+    const isCalled = seqResult.rows[0].is_called;
+
+    logger.log(`\nDiagnostics for table ${tableInfo.tableName}:`);
+    logger.log(
+      `- Maximum ID in table (${tableInfo.primaryKeyColumn}): ${maxId}`
+    );
+    logger.log(`- Current sequence value: ${currentSeqValue}`);
+    logger.log(`- Sequence has been called: ${isCalled}`);
+
+    if (currentSeqValue <= maxId) {
+      logger.log(`\n⚠️  Problem detected! Sequence is behind maximum ID`);
+
+      if (!options.dryRun) {
+        await pool.query(`SELECT setval($1, $2, true);`, [
+          tableInfo.sequenceName,
+          maxId,
+        ]);
+        logger.log(`✅ Sequence updated to value ${maxId}`);
+      } else {
+        logger.log(`[DRY-RUN] Would update sequence to value ${maxId}`);
+      }
+    } else {
+      logger.log(`✅ Sequence is properly configured`);
+    }
+  } catch (error) {
+    logger.error(`Error processing table ${tableName}:`, error.message);
+  }
+}
+
+async function main() {
+  try {
+    logger.log("Starting sequence synchronization...");
+    logger.log(`Database URL: ${options.databaseUrl.split("@")[1]}`);
+
+    if (options.dryRun) {
+      logger.log("Dry-run mode: No changes will be made");
+    }
+
+    const pool = new Pool({ connectionString: options.databaseUrl });
+
+    if (options.table) {
+      await checkTableSequence(pool, options.table);
+    } else if (options.priority) {
+      const tables =
+        migrationConfig.migrationPriorities[
+          options.priority as keyof typeof migrationConfig.migrationPriorities
+        ];
+      if (!tables) {
+        logger.error(`Invalid priority: ${options.priority}`);
+        process.exit(1);
+      }
+
+      for (const table of tables) {
+        if (options.verbose) {
+          logger.log(
+            `\nProcessing ${options.priority} priority table: ${table}`
+          );
+        }
+        await checkTableSequence(pool, table);
+      }
+    } else {
+      // Process all tables in priority order
+      const allTables = [
+        ...migrationConfig.migrationPriorities.high,
+        ...migrationConfig.migrationPriorities.medium,
+        ...migrationConfig.migrationPriorities.low,
+      ];
+
+      for (const table of allTables) {
+        if (options.verbose) {
+          logger.log(`\nProcessing table: ${table}`);
+        }
+        await checkTableSequence(pool, table);
+      }
+    }
+
+    await pool.end();
+    logger.log("\nSequence synchronization completed successfully");
+  } catch (error) {
+    logger.error("Error during synchronization:", error.stack);
+    process.exit(1);
+  }
+}
+
+main();