@javalabs/prisma-client 1.0.18 → 1.0.20

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}"`);

package/dist/scripts/fix-table-indexes.js

@@ -44,11 +44,11 @@ class TableIndexFixer {
         }
     }
     async getSchemas() {
-        const result = await this.targetPool.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(`
+      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);
     }
@@ -66,11 +66,11 @@ class TableIndexFixer {
         }
     }
     async getTablesForSchema(schema) {
-        const result = await this.targetPool.query(`
-      SELECT table_name
-      FROM information_schema.tables
-      WHERE table_schema = $1
-      AND table_type = 'BASE TABLE'
+        const result = await this.targetPool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = $1
+      AND table_type = 'BASE TABLE'
     `, [schema]);
         return result.rows.map(row => row.table_name);
     }
@@ -126,24 +126,24 @@ class TableIndexFixer {
     async fixUserTableSequences(schema, table) {
         var _a;
         try {
-            const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+            const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
       `;
             const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
             const identityColumns = columnsResult.rows.map(row => row.column_name);
             for (const column of identityColumns) {
-                const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+                const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
         `;
                 const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
                 const sequenceName = (_a = sequenceResult.rows[0]) === null || _a === void 0 ? void 0 : _a.sequence_name;
                 if (sequenceName) {
-                    const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+                    const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
           `;
                     await this.targetPool.query(resetQuery, [sequenceName]);
                     this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table} (tabla de usuarios)`);
@@ -210,24 +210,24 @@ class TableIndexFixer {
     async fixSequences(schema, table) {
         var _a;
         try {
-            const columnsQuery = `
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = $1
-        AND table_name = $2
-        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
+            const columnsQuery = `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = $1
+        AND table_name = $2
+        AND (is_identity = 'YES' OR column_default LIKE 'nextval%')
       `;
             const columnsResult = await this.targetPool.query(columnsQuery, [schema, table]);
             const identityColumns = columnsResult.rows.map(row => row.column_name);
             for (const column of identityColumns) {
-                const sequenceQuery = `
-          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
+                const sequenceQuery = `
+          SELECT pg_get_serial_sequence($1, $2) AS sequence_name
         `;
                 const sequenceResult = await this.targetPool.query(sequenceQuery, [`${schema}.${table}`, column]);
                 const sequenceName = (_a = sequenceResult.rows[0]) === null || _a === void 0 ? void 0 : _a.sequence_name;
                 if (sequenceName) {
-                    const resetQuery = `
-            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
+                    const resetQuery = `
+            SELECT setval($1, COALESCE((SELECT MAX(${column}) FROM ${schema}.${table}), 0) + 1, true)
           `;
                     await this.targetPool.query(resetQuery, [sequenceName]);
                     this.logger.log(`Restablecida secuencia ${sequenceName} para la columna ${column} en ${schema}.${table}`);
@@ -249,14 +249,14 @@ class TableIndexFixer {
     async getTableInfo(schema, table) {
         var _a;
         try {
-            const identityQuery = `
-        SELECT EXISTS (
-          SELECT 1
-          FROM information_schema.columns
-          WHERE table_schema = $1
-          AND table_name = $2
-          AND is_identity = 'YES'
-        ) AS has_identity_column;
+            const identityQuery = `
+        SELECT EXISTS (
+          SELECT 1
+          FROM information_schema.columns
+          WHERE table_schema = $1
+          AND table_name = $2
+          AND is_identity = 'YES'
+        ) AS has_identity_column;
       `;
             const result = await this.targetPool.query(identityQuery, [schema, table]);
             return {
@@ -269,26 +269,26 @@ class TableIndexFixer {
         }
     }
     async getTableIndexes(pool, schema, table) {
-        const query = `
-      SELECT
-        i.relname AS index_name,
-        array_agg(a.attname) AS column_names,
-        ix.indisunique AS is_unique,
-        ix.indisprimary AS is_primary,
-        pg_get_indexdef(ix.indexrelid) AS definition
-      FROM
-        pg_index ix
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_class t ON t.oid = ix.indrelid
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-      WHERE
-        n.nspname = $1
-        AND t.relname = $2
-      GROUP BY
-        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
-      ORDER BY
-        i.relname;
+        const query = `
+      SELECT
+        i.relname AS index_name,
+        array_agg(a.attname) AS column_names,
+        ix.indisunique AS is_unique,
+        ix.indisprimary AS is_primary,
+        pg_get_indexdef(ix.indexrelid) AS definition
+      FROM
+        pg_index ix
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+      WHERE
+        n.nspname = $1
+        AND t.relname = $2
+      GROUP BY
+        i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid
+      ORDER BY
+        i.relname;
     `;
         try {
             const result = await pool.query(query, [schema, table]);
@@ -367,35 +367,35 @@ class TableIndexFixer {
         }
     }
     async getTableColumns(schema, table) {
-        const query = `
-      SELECT column_name, data_type, is_nullable
-      FROM information_schema.columns
-      WHERE table_schema = $1
-      AND table_name = $2
+        const query = `
+      SELECT column_name, data_type, is_nullable
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      AND table_name = $2
     `;
         const result = await this.targetPool.query(query, [schema, table]);
         return result.rows;
     }
     async fixForeignKeyIndexes(schema, table) {
         try {
-            const fkQuery = `
-        SELECT
-          kcu.column_name,
-          ccu.table_schema AS foreign_table_schema,
-          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 = $1
-          AND tc.table_name = $2;
+            const fkQuery = `
+        SELECT
+          kcu.column_name,
+          ccu.table_schema AS foreign_table_schema,
+          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 = $1
+          AND tc.table_name = $2;
       `;
             const fkResult = await this.targetPool.query(fkQuery, [schema, table]);
             const existingIndexes = await this.getTableIndexes(this.targetPool, schema, table);

package/dist/scripts/migrate-schema-structure.js

@@ -57,10 +57,10 @@ async function migrateSchemaStructure() {
 async function checkSchemaExists(schemaName) {
     const prisma = new client_1.PrismaClient();
     try {
-        const result = await prisma.$queryRaw `
-      SELECT schema_name 
-      FROM information_schema.schemata 
-      WHERE schema_name = ${schemaName}
+        const result = await prisma.$queryRaw `
+      SELECT schema_name 
+      FROM information_schema.schemata 
+      WHERE schema_name = ${schemaName}
     `;
         return Array.isArray(result) && result.length > 0;
     }