@javalabs/prisma-client 1.0.18 → 1.0.19

package/dist/scripts/data-migration/schema-utils.js

@@ -11,28 +11,28 @@ class SchemaUtils {
         const pool = dbType === "source"
             ? this.connections.sourcePool
             : this.connections.targetPool;
-        const query = `
-      SELECT 
-        c.table_name,
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.character_maximum_length,
-        c.is_nullable,
-        c.column_default,
-        tc.constraint_type
-      FROM 
-        information_schema.columns c
-      LEFT JOIN information_schema.constraint_column_usage ccu 
-        ON c.column_name = ccu.column_name 
-        AND c.table_name = ccu.table_name
-      LEFT JOIN information_schema.table_constraints tc 
-        ON ccu.constraint_name = tc.constraint_name
-      WHERE 
-        c.table_schema = $1 
-        AND c.table_name = $2
-      ORDER BY 
-        c.ordinal_position
+        const query = `
+      SELECT 
+        c.table_name,
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.character_maximum_length,
+        c.is_nullable,
+        c.column_default,
+        tc.constraint_type
+      FROM 
+        information_schema.columns c
+      LEFT JOIN information_schema.constraint_column_usage ccu 
+        ON c.column_name = ccu.column_name 
+        AND c.table_name = ccu.table_name
+      LEFT JOIN information_schema.table_constraints tc 
+        ON ccu.constraint_name = tc.constraint_name
+      WHERE 
+        c.table_schema = $1 
+        AND c.table_name = $2
+      ORDER BY 
+        c.ordinal_position
     `;
         try {
             const result = await pool.query(query, [schema, tableName]);
@@ -45,10 +45,10 @@ class SchemaUtils {
     }
     async checkSchemaExists(schemaName) {
         try {
-            const query = `
-        SELECT schema_name 
-        FROM information_schema.schemata 
-        WHERE schema_name = $1
+            const query = `
+        SELECT schema_name 
+        FROM information_schema.schemata 
+        WHERE schema_name = $1
       `;
             const result = await this.connections.targetPool.query(query, [
                 schemaName,
@@ -62,11 +62,11 @@ class SchemaUtils {
     }
     async getTargetTables(schemaName) {
         try {
-            const query = `
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = $1
-        AND table_type = 'BASE TABLE'
+            const query = `
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
       `;
             const result = await this.connections.targetPool.query(query, [
                 schemaName,
@@ -84,13 +84,13 @@ class SchemaUtils {
     }
     async getEnumValues(schemaName, enumName) {
         try {
-            const query = `
-        SELECT e.enumlabel
-        FROM pg_type t 
-        JOIN pg_enum e ON t.oid = e.enumtypid  
-        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-        WHERE t.typname = $1
-        AND n.nspname = $2
+            const query = `
+        SELECT e.enumlabel
+        FROM pg_type t 
+        JOIN pg_enum e ON t.oid = e.enumtypid  
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typname = $1
+        AND n.nspname = $2
       `;
             const result = await this.connections.targetPool.query(query, [
                 enumName,
@@ -112,25 +112,25 @@ class SchemaUtils {
     async createMissingColumns(tableName, schema, columns) {
         for (const column of columns) {
             try {
-                const query = `
-          ALTER TABLE "${schema}"."${tableName}"
-          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
-          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
-          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
+                const query = `
+          ALTER TABLE "${schema}"."${tableName}"
+          ADD COLUMN IF NOT EXISTS "${column.column_name}" ${column.data_type}
+          ${column.is_nullable === "NO" ? "NOT NULL" : ""}
+          ${column.column_default ? `DEFAULT ${column.column_default}` : ""}
         `;
                 await this.connections.targetPool.query(query);
                 if (column.constraint_type === "UNIQUE") {
                     const constraintName = `${tableName}_${column.column_name}_unique`;
-                    const uniqueQuery = `
-            DO $$
-            BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
-              ) THEN
-                ALTER TABLE "${schema}"."${tableName}"
-                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
-              END IF;
-            END $$;
+                    const uniqueQuery = `
+            DO $$
+            BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'
+              ) THEN
+                ALTER TABLE "${schema}"."${tableName}"
+                ADD CONSTRAINT "${constraintName}" UNIQUE ("${column.column_name}");
+              END IF;
+            END $$;
           `;
                     await this.connections.targetPool.query(uniqueQuery);
                 }
@@ -146,10 +146,10 @@ class SchemaUtils {
             await this.connections.targetPool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
             const tables = await this.getPublicTables();
             for (const table of tables) {
-                await this.connections.targetPool.query(`
-          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
-            LIKE public."${table}" INCLUDING ALL
-          );
+                await this.connections.targetPool.query(`
+          CREATE TABLE IF NOT EXISTS "${schemaName}"."${table}" (
+            LIKE public."${table}" INCLUDING ALL
+          );
         `);
             }
             this.logger.log(`Created schema ${schemaName} with all tables`);
@@ -160,27 +160,27 @@ class SchemaUtils {
         }
     }
     async getPublicTables() {
-        const result = await this.connections.targetPool.query(`
-      SELECT tablename 
-      FROM pg_tables 
-      WHERE schemaname = 'public'
+        const result = await this.connections.targetPool.query(`
+      SELECT tablename 
+      FROM pg_tables 
+      WHERE schemaname = 'public'
     `);
         return result.rows.map((row) => row.tablename);
     }
     async getTableColumns(schema, table) {
-        const query = `
-      SELECT 
-        column_name,
-        data_type,
-        is_nullable,
-        column_default,
-        character_maximum_length,
-        numeric_precision,
-        numeric_scale
-      FROM information_schema.columns
-      WHERE table_schema = $1
-        AND table_name = $2
-      ORDER BY ordinal_position;
+        const query = `
+      SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale
+      FROM information_schema.columns
+      WHERE table_schema = $1
+        AND table_name = $2
+      ORDER BY ordinal_position;
     `;
         try {
             const result = await this.connections.sourcePool.query(query, [

package/dist/scripts/data-migration/typecast-manager.js

@@ -56,10 +56,10 @@ class TypecastManager {
         return tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.get(columnName);
     }
     async loadTableSchema(tableName) {
-        const columns = await this.prisma.$queryRawUnsafe(`
-      SELECT column_name, data_type, udt_name, is_nullable
-      FROM information_schema.columns
-      WHERE table_name = '${tableName}'
+        const columns = await this.prisma.$queryRawUnsafe(`
+      SELECT column_name, data_type, udt_name, is_nullable
+      FROM information_schema.columns
+      WHERE table_name = '${tableName}'
     `);
         const tableSchema = new Map();
         for (const column of columns) {

package/dist/scripts/database-initializer.js

@@ -14,11 +14,11 @@ class DatabaseInitializer {
             const { Pool } = await Promise.resolve().then(() => require("pg"));
             const pool = new Pool({ connectionString: this.databaseUrl });
             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'
         `);
                 const tableCount = parseInt(result.rows[0].count);
                 if (tableCount === 0) {

package/dist/scripts/drop-database.js

@@ -41,11 +41,11 @@ class DatabaseDropTool {
     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/fix-data-types.js

@@ -18,11 +18,11 @@ class DataTypeFixer {
     async fixDataTypes() {
         try {
             this.logger.log("Starting data type fixing process");
-            const schemasQuery = `
-        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 schemasQuery = `
+        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 schemasResult = await this.targetPool.query(schemasQuery);
             const schemas = schemasResult.rows.map(row => row.schema_name);
@@ -43,31 +43,31 @@ class DataTypeFixer {
     async fixNumericFieldsForSchema(schema) {
         this.logger.log(`Processing numeric fields for schema: ${schema}`);
         try {
-            const numericColumnsQuery = `
-        SELECT 
-          table_name, 
-          column_name
-        FROM 
-          information_schema.columns
-        WHERE 
-          table_schema = $1
-          AND data_type = 'numeric'
+            const numericColumnsQuery = `
+        SELECT 
+          table_name, 
+          column_name
+        FROM 
+          information_schema.columns
+        WHERE 
+          table_schema = $1
+          AND data_type = 'numeric'
       `;
             const numericColumnsResult = await this.targetPool.query(numericColumnsQuery, [schema]);
             for (const row of numericColumnsResult.rows) {
                 const tableName = row.table_name;
                 const columnName = row.column_name;
                 this.logger.log(`Fixing numeric column ${columnName} in table ${schema}.${tableName}`);
-                const updateQuery = `
-          UPDATE "${schema}"."${tableName}"
-          SET "${columnName}" = CASE
-            WHEN "${columnName}" IS NULL THEN NULL
-            WHEN "${columnName}" = '' THEN NULL
-            ELSE CAST("${columnName}" AS NUMERIC)
-          END
-          WHERE "${columnName}" IS NOT NULL
-          AND "${columnName}" != ''
-          AND "${columnName}" ~ '^[0-9]+(\.[0-9]+)?$';
+                const updateQuery = `
+          UPDATE "${schema}"."${tableName}"
+          SET "${columnName}" = CASE
+            WHEN "${columnName}" IS NULL THEN NULL
+            WHEN "${columnName}" = '' THEN NULL
+            ELSE CAST("${columnName}" AS NUMERIC)
+          END
+          WHERE "${columnName}" IS NOT NULL
+          AND "${columnName}" != ''
+          AND "${columnName}" ~ '^[0-9]+(\.[0-9]+)?$';
         `;
                 try {
                     await this.targetPool.query(updateQuery);
@@ -86,17 +86,17 @@ class DataTypeFixer {
     async fixEnumFieldsForSchema(schema) {
         this.logger.log(`Processing enum fields for schema: ${schema}`);
         try {
-            const enumColumnsQuery = `
-        SELECT 
-          c.table_name, 
-          c.column_name,
-          c.udt_name
-        FROM 
-          information_schema.columns c
-        WHERE 
-          c.table_schema = $1
-          AND c.data_type = 'USER-DEFINED'
-          AND c.udt_name LIKE 'enum_%'
+            const enumColumnsQuery = `
+        SELECT 
+          c.table_name, 
+          c.column_name,
+          c.udt_name
+        FROM 
+          information_schema.columns c
+        WHERE 
+          c.table_schema = $1
+          AND c.data_type = 'USER-DEFINED'
+          AND c.udt_name LIKE 'enum_%'
       `;
             const enumColumnsResult = await this.targetPool.query(enumColumnsQuery, [schema]);
             for (const row of enumColumnsResult.rows) {
@@ -104,12 +104,12 @@ class DataTypeFixer {
                 const columnName = row.column_name;
                 const enumTypeName = row.udt_name;
                 this.logger.log(`Fixing enum column ${columnName} (${enumTypeName}) in table ${schema}.${tableName}`);
-                const enumValuesQuery = `
-          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 enumValuesQuery = `
+          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 enumValuesResult = await this.targetPool.query(enumValuesQuery, [enumTypeName]);
                 const validEnumValues = enumValuesResult.rows.map(r => r.enumlabel);
@@ -118,10 +118,10 @@ class DataTypeFixer {
                     continue;
                 }
                 this.logger.log(`Valid values for ${enumTypeName}: ${validEnumValues.join(', ')}`);
-                const currentValuesQuery = `
-          SELECT DISTINCT "${columnName}" 
-          FROM "${schema}"."${tableName}" 
-          WHERE "${columnName}" IS NOT NULL
+                const currentValuesQuery = `
+          SELECT DISTINCT "${columnName}" 
+          FROM "${schema}"."${tableName}" 
+          WHERE "${columnName}" IS NOT NULL
         `;
                 const currentValuesResult = await this.targetPool.query(currentValuesQuery);
                 const currentValues = currentValuesResult.rows.map(r => r[columnName]);
@@ -132,19 +132,19 @@ class DataTypeFixer {
                         const matchingValidValue = validEnumValues.find(v => v.toLowerCase() === invalidValue.toLowerCase());
                         let updateQuery;
                         if (matchingValidValue) {
-                            updateQuery = `
-                UPDATE "${schema}"."${tableName}"
-                SET "${columnName}" = $1
-                WHERE "${columnName}" = $2
+                            updateQuery = `
+                UPDATE "${schema}"."${tableName}"
+                SET "${columnName}" = $1
+                WHERE "${columnName}" = $2
               `;
                             await this.targetPool.query(updateQuery, [matchingValidValue, invalidValue]);
                             this.logger.log(`Updated invalid value "${invalidValue}" to "${matchingValidValue}"`);
                         }
                         else {
-                            updateQuery = `
-                UPDATE "${schema}"."${tableName}"
-                SET "${columnName}" = NULL
-                WHERE "${columnName}" = $1
+                            updateQuery = `
+                UPDATE "${schema}"."${tableName}"
+                SET "${columnName}" = NULL
+                WHERE "${columnName}" = $1
               `;
                             await this.targetPool.query(updateQuery, [invalidValue]);
                             this.logger.log(`Set invalid value "${invalidValue}" to NULL`);

package/dist/scripts/fix-enum-values.js

@@ -52,28 +52,28 @@ class EnumFixer {
         }
     }
     async getSchemas() {
-        const result = await this.pool.query(`
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('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 ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
     `);
         return result.rows.map((row) => row.schema_name);
     }
     async fixEnumValuesForSchema(schema) {
         this.logger.log(`Processing enum fields for schema: ${schema}`);
         try {
-            const enumColumnsQuery = `
-        SELECT 
-          c.table_name, 
-          c.column_name,
-          c.udt_name
-        FROM 
-          information_schema.columns c
-        WHERE 
-          c.table_schema = $1
-          AND c.data_type = 'USER-DEFINED'
-          AND c.udt_name LIKE 'enum_%'
+            const enumColumnsQuery = `
+        SELECT 
+          c.table_name, 
+          c.column_name,
+          c.udt_name
+        FROM 
+          information_schema.columns c
+        WHERE 
+          c.table_schema = $1
+          AND c.data_type = 'USER-DEFINED'
+          AND c.udt_name LIKE 'enum_%'
       `;
             const enumColumnsResult = await this.pool.query(enumColumnsQuery, [
                 schema,
@@ -111,10 +111,10 @@ class EnumFixer {
                 return;
             }
             this.logger.log(`Valid values for ${enumTypeName}: ${validEnumValues.join(", ")}`);
-            const currentValuesQuery = `
-        SELECT DISTINCT "${columnName}" 
-        FROM "${schema}"."${tableName}" 
-        WHERE "${columnName}" IS NOT NULL
+            const currentValuesQuery = `
+        SELECT DISTINCT "${columnName}" 
+        FROM "${schema}"."${tableName}" 
+        WHERE "${columnName}" IS NOT NULL
       `;
             const currentValuesResult = await this.pool.query(currentValuesQuery);
             const currentValues = currentValuesResult.rows.map((r) => r[columnName]);
@@ -162,15 +162,15 @@ class EnumFixer {
                     }
                 }
                 const updateQuery = mappedValue !== null
-                    ? `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = CAST($1 AS "${enumTypeName}")
-            WHERE "${columnName}" = $2
+                    ? `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = CAST($1 AS "${enumTypeName}")
+            WHERE "${columnName}" = $2
           `
-                    : `
-            UPDATE "${schema}"."${tableName}"
-            SET "${columnName}" = NULL
-            WHERE "${columnName}" = $1
+                    : `
+            UPDATE "${schema}"."${tableName}"
+            SET "${columnName}" = NULL
+            WHERE "${columnName}" = $1
           `;
                 const updateParams = mappedValue !== null ? [mappedValue, invalidValue] : [invalidValue];
                 const updateResult = await this.pool.query(updateQuery, updateParams);
@@ -183,12 +183,12 @@ class EnumFixer {
     }
     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.pool.query(enumQuery, [enumTypeName]);
             return result.rows.map((row) => row.enumlabel);

package/dist/scripts/fix-schema-discrepancies.js

@@ -119,11 +119,11 @@ class SchemaDiscrepancyFixer {
         }
     }
     async getTargetSchemas() {
-        const query = `
-      SELECT schema_name
-      FROM information_schema.schemata
-      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
-      AND schema_name NOT LIKE 'pg_%'
+        const query = `
+      SELECT schema_name
+      FROM information_schema.schemata
+      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+      AND schema_name NOT LIKE 'pg_%'
     `;
         const result = await this.targetPool.query(query);
         return result.rows.map(row => row.schema_name);
@@ -133,22 +133,22 @@ class SchemaDiscrepancyFixer {
             this.columnTypeCache[table] = {};
         }
         const columnsStr = columns.map(c => `'${c}'`).join(',');
-        const query = `
-      SELECT column_name, data_type, 
-        CASE 
-          WHEN data_type = 'character varying' THEN data_type || '(' || character_maximum_length || ')'
-          WHEN data_type = 'numeric' THEN 
-            CASE 
-              WHEN numeric_precision IS NOT NULL AND numeric_scale IS NOT NULL 
-              THEN data_type || '(' || numeric_precision || ',' || numeric_scale || ')'
-              ELSE data_type
-            END
-          ELSE data_type
-        END as full_data_type
-      FROM information_schema.columns
-      WHERE table_schema = 'public'
-      AND table_name = $1
-      AND column_name IN (${columnsStr})
+        const query = `
+      SELECT column_name, data_type, 
+        CASE 
+          WHEN data_type = 'character varying' THEN data_type || '(' || character_maximum_length || ')'
+          WHEN data_type = 'numeric' THEN 
+            CASE 
+              WHEN numeric_precision IS NOT NULL AND numeric_scale IS NOT NULL 
+              THEN data_type || '(' || numeric_precision || ',' || numeric_scale || ')'
+              ELSE data_type
+            END
+          ELSE data_type
+        END as full_data_type
+      FROM information_schema.columns
+      WHERE table_schema = 'public'
+      AND table_name = $1
+      AND column_name IN (${columnsStr})
     `;
         const result = await this.sourcePool.query(query, [table]);
         for (const row of result.rows) {
@@ -156,33 +156,33 @@ class SchemaDiscrepancyFixer {
         }
     }
     async checkTableExists(schema, table) {
-        const query = `
-      SELECT EXISTS (
-        SELECT FROM information_schema.tables 
-        WHERE table_schema = $1
-        AND table_name = $2
-      );
+        const query = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = $1
+        AND table_name = $2
+      );
     `;
         const result = await this.targetPool.query(query, [schema, table]);
         return result.rows[0].exists;
     }
     async checkColumnExists(schema, table, column) {
-        const query = `
-      SELECT EXISTS (
-        SELECT FROM information_schema.columns 
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND column_name = $3
-      );
+        const query = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.columns 
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND column_name = $3
+      );
     `;
         const result = await this.targetPool.query(query, [schema, table, column]);
         return result.rows[0].exists;
     }
     async addColumn(schema, table, column, type) {
         try {
-            const query = `
-        ALTER TABLE "${schema}"."${table}" 
-        ADD COLUMN IF NOT EXISTS "${column}" ${type};
+            const query = `
+        ALTER TABLE "${schema}"."${table}" 
+        ADD COLUMN IF NOT EXISTS "${column}" ${type};
       `;
             await this.targetPool.query(query);
             this.logger.log(`Added column "${column}" to "${schema}"."${table}" with type "${type}"`);
@@ -195,9 +195,9 @@ class SchemaDiscrepancyFixer {
     async addUniqueConstraint(schema, table, column) {
         try {
             const constraintName = `${table}_${column}_unique`;
-            const query = `
-        ALTER TABLE "${schema}"."${table}" 
-        ADD CONSTRAINT "${constraintName}" UNIQUE ("${column}");
+            const query = `
+        ALTER TABLE "${schema}"."${table}" 
+        ADD CONSTRAINT "${constraintName}" UNIQUE ("${column}");
       `;
             await this.targetPool.query(query);
             this.logger.log(`Added UNIQUE constraint on "${column}" to "${schema}"."${table}"`);