@javalabs/prisma-client 1.0.18 → 1.0.19

package/dist/scripts/pre-migration-validator.js

@@ -103,8 +103,8 @@ class PreMigrationValidator {
     async validateApiKeys() {
         this.logger.log('Validating API keys');
         try {
-            const result = await this.sourcePool.query(`
-        SELECT COUNT(*) as count FROM api_keys
+            const result = await this.sourcePool.query(`
+        SELECT COUNT(*) as count FROM api_keys
       `);
             const count = parseInt(result.rows[0].count);
             if (count === 0) {
@@ -129,35 +129,35 @@ class PreMigrationValidator {
     async validateDataTypeCompatibility() {
         this.logger.log('Validating data type compatibility');
         try {
-            const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
+            const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
       `);
             for (const tableRow of tablesResult.rows) {
                 const tableName = tableRow.table_name;
-                const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
+                const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
         `, [tableName]);
-                const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
+                const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
         `, [tableName]);
                 if (targetTableExists.rows.length === 0) {
                     continue;
                 }
-                const targetColumnsResult = await this.targetPool.query(`
-          SELECT column_name, data_type, udt_name
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
+                const targetColumnsResult = await this.targetPool.query(`
+          SELECT column_name, data_type, udt_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
         `, [tableName]);
                 const sourceColumns = sourceColumnsResult.rows.reduce((map, col) => {
                     map[col.column_name] = col;
@@ -217,28 +217,28 @@ class PreMigrationValidator {
     async validateColumnSizes() {
         this.logger.log('Validating column sizes');
         try {
-            const tablesResult = await this.sourcePool.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public'
-        AND table_type = 'BASE TABLE'
+            const tablesResult = await this.sourcePool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
       `);
             for (const tableRow of tablesResult.rows) {
                 const tableName = tableRow.table_name;
-                const sourceColumnsResult = await this.sourcePool.query(`
-          SELECT column_name, data_type, character_maximum_length
-          FROM information_schema.columns
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          AND data_type IN ('character varying', 'character', 'varchar', 'char')
-          AND character_maximum_length IS NOT NULL
+                const sourceColumnsResult = await this.sourcePool.query(`
+          SELECT column_name, data_type, character_maximum_length
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          AND data_type IN ('character varying', 'character', 'varchar', 'char')
+          AND character_maximum_length IS NOT NULL
         `, [tableName]);
-                const targetTableExists = await this.targetPool.query(`
-          SELECT 1
-          FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-          LIMIT 1
+                const targetTableExists = await this.targetPool.query(`
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+          LIMIT 1
         `, [tableName]);
                 if (targetTableExists.rows.length === 0) {
                     continue;
@@ -246,13 +246,13 @@ class PreMigrationValidator {
                 for (const sourceColumn of sourceColumnsResult.rows) {
                     const columnName = sourceColumn.column_name;
                     const sourceMaxLength = sourceColumn.character_maximum_length;
-                    const targetColumnResult = await this.targetPool.query(`
-            SELECT character_maximum_length
-            FROM information_schema.columns
-            WHERE table_schema = 'public'
-            AND table_name = $1
-            AND column_name = $2
-            AND data_type IN ('character varying', 'character', 'varchar', 'char')
+                    const targetColumnResult = await this.targetPool.query(`
+            SELECT character_maximum_length
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+            AND table_name = $1
+            AND column_name = $2
+            AND data_type IN ('character varying', 'character', 'varchar', 'char')
           `, [tableName, columnName]);
                     if (targetColumnResult.rows.length > 0) {
                         const targetMaxLength = targetColumnResult.rows[0].character_maximum_length;
@@ -282,41 +282,41 @@ class PreMigrationValidator {
     async validateEnumValues() {
         this.logger.log('Validating enum values');
         try {
-            const sourceEnumsResult = await this.sourcePool.query(`
-        SELECT t.typname AS enum_name
-        FROM pg_type t
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typtype = 'e'
-        AND n.nspname = 'public'
+            const sourceEnumsResult = await this.sourcePool.query(`
+        SELECT t.typname AS enum_name
+        FROM pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typtype = 'e'
+        AND n.nspname = 'public'
       `);
             for (const enumRow of sourceEnumsResult.rows) {
                 const enumName = enumRow.enum_name;
-                const sourceEnumValuesResult = await this.sourcePool.query(`
-          SELECT e.enumlabel
-          FROM pg_enum e
-          JOIN pg_type t ON e.enumtypid = t.oid
-          WHERE t.typname = $1
-          ORDER BY e.enumsortorder
+                const sourceEnumValuesResult = await this.sourcePool.query(`
+          SELECT e.enumlabel
+          FROM pg_enum e
+          JOIN pg_type t ON e.enumtypid = t.oid
+          WHERE t.typname = $1
+          ORDER BY e.enumsortorder
         `, [enumName]);
                 const sourceEnumValues = sourceEnumValuesResult.rows.map(row => row.enumlabel);
-                const targetEnumExistsResult = await this.targetPool.query(`
-          SELECT 1
-          FROM pg_type t
-          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-          WHERE t.typtype = 'e'
-          AND t.typname = $1
-          AND n.nspname = 'public'
-          LIMIT 1
+                const targetEnumExistsResult = await this.targetPool.query(`
+          SELECT 1
+          FROM pg_type t
+          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          WHERE t.typtype = 'e'
+          AND t.typname = $1
+          AND n.nspname = 'public'
+          LIMIT 1
         `, [enumName]);
                 if (targetEnumExistsResult.rows.length === 0) {
                     continue;
                 }
-                const targetEnumValuesResult = await this.targetPool.query(`
-          SELECT e.enumlabel
-          FROM pg_enum e
-          JOIN pg_type t ON e.enumtypid = t.oid
-          WHERE t.typname = $1
-          ORDER BY e.enumsortorder
+                const targetEnumValuesResult = await this.targetPool.query(`
+          SELECT e.enumlabel
+          FROM pg_enum e
+          JOIN pg_type t ON e.enumtypid = t.oid
+          WHERE t.typname = $1
+          ORDER BY e.enumsortorder
         `, [enumName]);
                 const targetEnumValues = targetEnumValuesResult.rows.map(row => row.enumlabel);
                 for (const sourceValue of sourceEnumValues) {
@@ -343,22 +343,22 @@ class PreMigrationValidator {
     async validateForeignKeyConstraints() {
         this.logger.log('Validating foreign key constraints');
         try {
-            const foreignKeysResult = await this.sourcePool.query(`
-        SELECT
-          tc.table_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name
-        FROM
-          information_schema.table_constraints AS tc
-          JOIN information_schema.key_column_usage AS kcu
-            ON tc.constraint_name = kcu.constraint_name
-            AND tc.table_schema = kcu.table_schema
-          JOIN information_schema.constraint_column_usage AS ccu
-            ON ccu.constraint_name = tc.constraint_name
-            AND ccu.table_schema = tc.table_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = 'public'
+            const foreignKeysResult = await this.sourcePool.query(`
+        SELECT
+          tc.table_name,
+          kcu.column_name,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = 'public'
       `);
             this.logger.log(`Found ${foreignKeysResult.rows.length} foreign key constraints in source database`);
         }
@@ -373,28 +373,28 @@ class PreMigrationValidator {
     async validateUniqueConstraints() {
         this.logger.log('Validating unique constraints...');
         try {
-            const sourceConstraintsQuery = `
-        SELECT 
-          tc.table_name, 
-          kcu.column_name 
-        FROM 
-          information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-        WHERE 
-          tc.constraint_type = 'UNIQUE'
-          AND tc.table_schema = 'public'
+            const sourceConstraintsQuery = `
+        SELECT 
+          tc.table_name, 
+          kcu.column_name 
+        FROM 
+          information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE 
+          tc.constraint_type = 'UNIQUE'
+          AND tc.table_schema = 'public'
       `;
             const sourceConstraints = await this.sourcePool.query(sourceConstraintsQuery);
             for (const constraint of sourceConstraints.rows) {
                 const { table_name, column_name } = constraint;
                 try {
-                    const columnExistsQuery = `
-            SELECT column_name 
-            FROM information_schema.columns 
-            WHERE table_name = $1 
-              AND column_name = $2
-              AND table_schema = 'public'
+                    const columnExistsQuery = `
+            SELECT column_name 
+            FROM information_schema.columns 
+            WHERE table_name = $1 
+              AND column_name = $2
+              AND table_schema = 'public'
           `;
                     const columnExists = await this.targetPool.query(columnExistsQuery, [table_name, column_name]);
                     if (columnExists.rows.length === 0) {

package/dist/scripts/reset-database.js

@@ -105,12 +105,12 @@ class DatabaseResetTool {
     async dropAllCustomTypes() {
         this.logger.log("Dropping all custom types (enums, domains, etc.)");
         try {
-            const typesQuery = `
-        SELECT t.typname AS name
-        FROM pg_type t 
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE n.nspname = 'public'
-        AND t.typtype = 'e' -- enum types
+            const typesQuery = `
+        SELECT t.typname AS name
+        FROM pg_type t 
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE n.nspname = 'public'
+        AND t.typtype = 'e' -- enum types
       `;
             const typesResult = await this.pool.query(typesQuery);
             const types = typesResult.rows.map(row => row.name);
@@ -130,20 +130,20 @@ class DatabaseResetTool {
         }
     }
     async getCustomSchemas() {
-        const result = await this.pool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
+        const result = await this.pool.query(`
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('public', 'information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
     `);
         return result.rows.map(row => row.schema_name);
     }
     async getPublicTables() {
-        const result = await this.pool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = 'public'
-      AND table_type = 'BASE TABLE'
+        const result = await this.pool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      AND table_type = 'BASE TABLE'
     `);
         return result.rows.map(row => row.table_name);
     }
@@ -154,11 +154,11 @@ class DatabaseResetTool {
     async terminateConnections(dbName) {
         this.logger.log(`Terminating all connections to database: ${dbName}`);
         try {
-            await this.adminPool.query(`
-        SELECT pg_terminate_backend(pg_stat_activity.pid)
-        FROM pg_stat_activity
-        WHERE pg_stat_activity.datname = $1
-        AND pid <> pg_backend_pid()
+            await this.adminPool.query(`
+        SELECT pg_terminate_backend(pg_stat_activity.pid)
+        FROM pg_stat_activity
+        WHERE pg_stat_activity.datname = $1
+        AND pid <> pg_backend_pid()
       `, [dbName]);
             this.logger.log("All connections terminated successfully");
         }

package/dist/scripts/retry-failed-migrations.js

@@ -131,10 +131,10 @@ class FailedMigrationRetry {
                         if (columnNames.includes(recordId)) {
                             createData[recordId] = data[recordId];
                         }
-                        const checkExistQuery = `
-              SELECT 1 FROM "${tenantId}"."${entity}" 
-              WHERE "${recordId}" = $1
-              LIMIT 1
+                        const checkExistQuery = `
+              SELECT 1 FROM "${tenantId}"."${entity}" 
+              WHERE "${recordId}" = $1
+              LIMIT 1
             `;
                         const existResult = await this.targetPool.query(checkExistQuery, [
                             data[recordId],
@@ -150,10 +150,10 @@ class FailedMigrationRetry {
                                 return `"${key}" = $${index + 2}`;
                             });
                             if (updateFields.length > 0) {
-                                const updateQuery = `
-                  UPDATE "${tenantId}"."${entity}"
-                  SET ${updateFields.join(", ")}
-                  WHERE "${recordId}" = $1
+                                const updateQuery = `
+                  UPDATE "${tenantId}"."${entity}"
+                  SET ${updateFields.join(", ")}
+                  WHERE "${recordId}" = $1
                 `;
                                 const updateValues = [
                                     data[recordId],
@@ -176,9 +176,9 @@ class FailedMigrationRetry {
                                 }
                                 return `$${index + 1}`;
                             });
-                            const insertQuery = `
-                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
-                VALUES (${insertPlaceholders.join(", ")})
+                            const insertQuery = `
+                INSERT INTO "${tenantId}"."${entity}" (${insertFields.join(", ")})
+                VALUES (${insertPlaceholders.join(", ")})
               `;
                             const insertValues = Object.keys(createData)
                                 .filter(key => key !== '_enumTypes')
@@ -196,11 +196,11 @@ class FailedMigrationRetry {
                 }
                 await tenantPrisma.$disconnect();
             }
-            this.logger.log(`
-Retry Summary:
-- Total errors: ${totalErrors}
-- Successfully retried: ${retrySuccessCount}
-- Failed retries: ${retryFailCount}
+            this.logger.log(`
+Retry Summary:
+- Total errors: ${totalErrors}
+- Successfully retried: ${retrySuccessCount}
+- Failed retries: ${retryFailCount}
       `);
             const remainingErrorsReport = this.errorHandler.generateErrorReport();
             this.logger.log("Remaining Errors Report:\n" + remainingErrorsReport);
@@ -214,12 +214,12 @@ Retry Summary:
     }
     async getTableSchema(tableName, schemaName) {
         try {
-            const schemaQuery = `
-        SELECT column_name, data_type, column_default, is_nullable, udt_name
-        FROM information_schema.columns
-        WHERE table_name = $1
-        AND table_schema = $2
-        ORDER BY ordinal_position
+            const schemaQuery = `
+        SELECT column_name, data_type, column_default, is_nullable, udt_name
+        FROM information_schema.columns
+        WHERE table_name = $1
+        AND table_schema = $2
+        ORDER BY ordinal_position
       `;
             const result = await this.targetPool.query(schemaQuery, [
                 tableName,
@@ -234,12 +234,12 @@ Retry Summary:
     }
     async getEnumValues(enumTypeName) {
         try {
-            const enumQuery = `
-        SELECT e.enumlabel
-        FROM pg_enum e
-        JOIN pg_type t ON e.enumtypid = t.oid
-        WHERE t.typname = $1
-        ORDER BY e.enumsortorder
+            const enumQuery = `
+        SELECT e.enumlabel
+        FROM pg_enum e
+        JOIN pg_type t ON e.enumtypid = t.oid
+        WHERE t.typname = $1
+        ORDER BY e.enumsortorder
       `;
             const result = await this.targetPool.query(enumQuery, [enumTypeName]);
             return result.rows.map((row) => row.enumlabel);

package/dist/scripts/run-migration.js

@@ -139,11 +139,11 @@ program
                 const pool = new Pool({ connectionString: process.env.DATABASE_URL });
                 async function checkIfTablesExist(pool) {
                     try {
-                        const result = await pool.query(`
-                SELECT COUNT(*) 
-                FROM information_schema.tables 
-                WHERE table_schema = 'public'
-                AND table_type = 'BASE TABLE'
+                        const result = await pool.query(`
+                SELECT COUNT(*) 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public'
+                AND table_type = 'BASE TABLE'
               `);
                         return parseInt(result.rows[0].count) > 0;
                     }

package/dist/scripts/schema-sync.js

@@ -28,11 +28,11 @@ async function main() {
     }
 }
 async function getTablesFromDatabase(pool) {
-    const query = `
-    SELECT table_name 
-    FROM information_schema.tables 
-    WHERE table_schema = 'public'
-    AND table_type = 'BASE TABLE'
+    const query = `
+    SELECT table_name 
+    FROM information_schema.tables 
+    WHERE table_schema = 'public'
+    AND table_type = 'BASE TABLE'
   `;
     const result = await pool.query(query);
     return result.rows.map(row => row.table_name);
@@ -61,19 +61,19 @@ async function generateSyncScript(sourcePool, targetPool, sourceTables, targetTa
     return script;
 }
 async function getTableColumns(pool, table) {
-    const query = `
-    SELECT 
-      column_name, 
-      data_type, 
-      is_nullable,
-      column_default
-    FROM 
-      information_schema.columns
-    WHERE 
-      table_schema = 'public' 
-      AND table_name = $1
-    ORDER BY 
-      ordinal_position
+    const query = `
+    SELECT 
+      column_name, 
+      data_type, 
+      is_nullable,
+      column_default
+    FROM 
+      information_schema.columns
+    WHERE 
+      table_schema = 'public' 
+      AND table_name = $1
+    ORDER BY 
+      ordinal_position
   `;
     const result = await pool.query(query, [table]);
     return result.rows;