linkgress-orm 0.4.59 → 0.4.61

package/dist/migration/db-schema-manager.js

@@ -40,6 +40,7 @@ const collation_builder_1 = require("../types/collation-builder");
 const conditions_1 = require("../query/conditions");
 const index_sql_1 = require("./index-sql");
 const statistics_sql_1 = require("./statistics-sql");
+const check_constraint_sql_1 = require("./check-constraint-sql");
 const dbsetting_sql_1 = require("./dbsetting-sql");
 const partition_sql_1 = require("./partition-sql");
 /**
@@ -128,10 +129,10 @@ class DbSchemaManager {
         }
         for (const [enumName, enumDef] of enums.entries()) {
             // Check if enum already exists
-            const checkSQL = `
-        SELECT EXISTS (
-          SELECT 1 FROM pg_type WHERE typname = $1
-        ) as exists
+            const checkSQL = `
+        SELECT EXISTS (
+          SELECT 1 FROM pg_type WHERE typname = $1
+        ) as exists
       `;
             const result = await this.client.query(checkSQL, [enumName]);
             const exists = result.rows[0]?.exists;
@@ -162,10 +163,10 @@ class DbSchemaManager {
             this.logger('Creating collations...\n');
         }
         for (const [collationName, collationDef] of collations.entries()) {
-            const checkSQL = `
-        SELECT EXISTS (
-          SELECT 1 FROM pg_collation WHERE collname = $1
-        ) as exists
+            const checkSQL = `
+        SELECT EXISTS (
+          SELECT 1 FROM pg_collation WHERE collname = $1
+        ) as exists
       `;
             const result = await this.client.query(checkSQL, [collationName]);
             const exists = result.rows[0]?.exists;
@@ -200,13 +201,13 @@ class DbSchemaManager {
                 : `"${config.name}"`;
             // Check if sequence already exists
             const checkSQL = config.schema
-                ? `SELECT EXISTS (
-            SELECT 1 FROM information_schema.sequences
-            WHERE sequence_schema = $1 AND sequence_name = $2
+                ? `SELECT EXISTS (
+            SELECT 1 FROM information_schema.sequences
+            WHERE sequence_schema = $1 AND sequence_name = $2
           ) as exists`
-                : `SELECT EXISTS (
-            SELECT 1 FROM information_schema.sequences
-            WHERE sequence_name = $1 AND sequence_schema = 'public'
+                : `SELECT EXISTS (
+            SELECT 1 FROM information_schema.sequences
+            WHERE sequence_name = $1 AND sequence_schema = 'public'
           ) as exists`;
             const checkParams = config.schema ? [config.schema, config.name] : [config.name];
             const result = await this.client.query(checkSQL, checkParams);
@@ -347,10 +348,10 @@ class DbSchemaManager {
             (0, partition_sql_1.validatePartitioningPrimaryKey)(tableSchema.partitioning, pkColumnNames, tableName);
             partitionByClause = ` ${(0, partition_sql_1.buildPartitionByClause)(tableSchema.partitioning)}`;
         }
-        const createTableSQL = `
-      CREATE TABLE IF NOT EXISTS ${qualifiedTableName} (
-        ${columnDefs.join(',\n        ')}
-      )${partitionByClause}
+        const createTableSQL = `
+      CREATE TABLE IF NOT EXISTS ${qualifiedTableName} (
+        ${columnDefs.join(',\n        ')}
+      )${partitionByClause}
     `;
         if (this.logQueries) {
             this.logger(`  Creating table ${qualifiedTableName}...`);
@@ -568,6 +569,11 @@ class DbSchemaManager {
         for (const [tableName, tableSchema] of sortedTables) {
             await this.createIndexes(tableName, tableSchema);
         }
+        // Create CHECK constraints (existence-guarded — no ADD CONSTRAINT IF NOT
+        // EXISTS in PostgreSQL, and ensureCreated must stay idempotent)
+        for (const [tableName, tableSchema] of sortedTables) {
+            await this.createCheckConstraints(tableName, tableSchema);
+        }
         // Create extended-statistics objects (after indexes so the ANALYZE they
         // trigger also refreshes freshly indexed expression columns)
         for (const [tableName, tableSchema] of sortedTables) {
@@ -608,6 +614,23 @@ class DbSchemaManager {
             await this.executeCreateStatistics(tableName, spec, tableSchema.schema);
         }
     }
+    /**
+     * Create the declared CHECK constraints of a table that are missing on it.
+     * Reconciled by NAME (see check-constraint-sql.ts) — existing same-named
+     * constraints are left untouched, so the pass is idempotent.
+     */
+    async createCheckConstraints(tableName, tableSchema) {
+        const checkConstraints = tableSchema.checkConstraints || [];
+        if (checkConstraints.length === 0) {
+            return;
+        }
+        const existing = await this.getExistingCheckConstraints(tableName, tableSchema.schema);
+        for (const spec of checkConstraints) {
+            if (!existing.includes(spec.name)) {
+                await this.executeCreateCheckConstraint(tableName, spec, tableSchema.schema);
+            }
+        }
+    }
     /**
      * Converge declared database-level settings (`model.hasDbSetting`) — apply
      * every declaration that is missing from `pg_db_role_setting` or whose
@@ -640,11 +663,11 @@ class DbSchemaManager {
      * keyed by lower-cased parameter name (GUC names are case-insensitive).
      */
     async getExistingDatabaseSettings() {
-        const result = await this.client.query(`
-      SELECT entry
-      FROM pg_db_role_setting, LATERAL unnest(setconfig) AS entry
-      WHERE setrole = 0
-        AND setdatabase = (SELECT oid FROM pg_database WHERE datname = current_database())
+        const result = await this.client.query(`
+      SELECT entry
+      FROM pg_db_role_setting, LATERAL unnest(setconfig) AS entry
+      WHERE setrole = 0
+        AND setdatabase = (SELECT oid FROM pg_database WHERE datname = current_database())
     `);
         const settings = new Map();
         for (const row of result.rows) {
@@ -750,10 +773,10 @@ class DbSchemaManager {
         }
         // Add schema creation operations if needed
         for (const schemaName of modelSchemas) {
-            const result = await this.client.query(`
-        SELECT EXISTS (
-          SELECT 1 FROM information_schema.schemata WHERE schema_name = $1
-        ) as exists
+            const result = await this.client.query(`
+        SELECT EXISTS (
+          SELECT 1 FROM information_schema.schemata WHERE schema_name = $1
+        ) as exists
       `, [schemaName]);
             if (!result.rows[0]?.exists) {
                 operations.push({ type: 'create_schema', schemaName });
@@ -762,10 +785,10 @@ class DbSchemaManager {
         // Check collations
         const modelCollations = collation_builder_1.CollationRegistry.getAll();
         for (const [collationName, collationDef] of modelCollations.entries()) {
-            const result = await this.client.query(`
-        SELECT EXISTS (
-          SELECT 1 FROM pg_collation WHERE collname = $1
-        ) as exists
+            const result = await this.client.query(`
+        SELECT EXISTS (
+          SELECT 1 FROM pg_collation WHERE collname = $1
+        ) as exists
       `, [collationName]);
             if (!result.rows[0]?.exists) {
                 operations.push({ type: 'create_collation', collation: collationDef });
@@ -774,11 +797,11 @@ class DbSchemaManager {
         // Check enums
         const modelEnums = enum_builder_1.EnumTypeRegistry.getAll();
         for (const [enumName, enumDef] of modelEnums.entries()) {
-            const existing = await this.client.query(`
-        SELECT e.enumlabel
-        FROM pg_type t
-        JOIN pg_enum e ON e.enumtypid = t.oid
-        WHERE t.typname = $1
+            const existing = await this.client.query(`
+        SELECT e.enumlabel
+        FROM pg_type t
+        JOIN pg_enum e ON e.enumtypid = t.oid
+        WHERE t.typname = $1
       `, [enumName]);
             if (existing.rows.length === 0) {
                 // Enum type doesn't exist yet — create it with the full value set.
@@ -799,13 +822,13 @@ class DbSchemaManager {
         // Check sequences
         for (const [_, config] of this.sequenceRegistry.entries()) {
             const checkSQL = config.schema
-                ? `SELECT EXISTS (
-            SELECT 1 FROM information_schema.sequences
-            WHERE sequence_schema = $1 AND sequence_name = $2
+                ? `SELECT EXISTS (
+            SELECT 1 FROM information_schema.sequences
+            WHERE sequence_schema = $1 AND sequence_name = $2
           ) as exists`
-                : `SELECT EXISTS (
-            SELECT 1 FROM information_schema.sequences
-            WHERE sequence_name = $1 AND sequence_schema = 'public'
+                : `SELECT EXISTS (
+            SELECT 1 FROM information_schema.sequences
+            WHERE sequence_name = $1 AND sequence_schema = 'public'
           ) as exists`;
             const checkParams = config.schema ? [config.schema, config.name] : [config.name];
             const result = await this.client.query(checkSQL, checkParams);
@@ -921,6 +944,22 @@ class DbSchemaManager {
                         });
                     }
                 }
+                // Compare CHECK constraints — by NAME only (create missing; never
+                // drop or rebuild — rename a constraint to change its definition).
+                if ((schema.checkConstraints || []).length > 0) {
+                    const existingCheckConstraints = await this.getExistingCheckConstraints(tableName, schema.schema);
+                    for (const modelCheck of schema.checkConstraints || []) {
+                        if (!existingCheckConstraints.includes(modelCheck.name)) {
+                            operations.push({
+                                type: 'create_check_constraint',
+                                tableName,
+                                schema: schema.schema,
+                                constraintName: modelCheck.name,
+                                expression: modelCheck.expression,
+                            });
+                        }
+                    }
+                }
                 // Compare foreign key constraints
                 const existingForeignKeys = await this.getExistingForeignKeys(tableName, schema.schema);
                 const modelForeignKeys = schema.foreignKeys || [];
@@ -1046,6 +1085,16 @@ class DbSchemaManager {
                             nullsNotDistinct: index.nullsNotDistinct,
                         });
                     }
+                    // Add CHECK constraints for newly created tables to phase 3
+                    for (const check of schema.checkConstraints || []) {
+                        phase3Ops.push({
+                            type: 'create_check_constraint',
+                            tableName,
+                            schema: schema.schema,
+                            constraintName: check.name,
+                            expression: check.expression,
+                        });
+                    }
                 }
             }
             const totalOps = phase1Ops.length + phase2Ops.length + phase3Ops.length;
@@ -1169,6 +1218,12 @@ class DbSchemaManager {
                     kinds: operation.kinds,
                 }, operation.schema);
                 break;
+            case 'create_check_constraint':
+                await this.executeCreateCheckConstraint(operation.tableName, {
+                    name: operation.constraintName,
+                    expression: operation.expression,
+                }, operation.schema);
+                break;
             case 'set_database_setting':
                 await this.executeSetDatabaseSetting(operation);
                 break;
@@ -1447,16 +1502,55 @@ class DbSchemaManager {
      * the table's namespace so the lookup is independent of search_path.
      */
     async getExistingStatistics(tableName, schemaName) {
-        const result = await this.client.query(`
-      SELECT s.stxname
-      FROM pg_statistic_ext s
-      JOIN pg_class c ON c.oid = s.stxrelid
-      JOIN pg_namespace n ON n.oid = c.relnamespace
-      WHERE n.nspname = $1
-        AND c.relname = $2
+        const result = await this.client.query(`
+      SELECT s.stxname
+      FROM pg_statistic_ext s
+      JOIN pg_class c ON c.oid = s.stxrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = $1
+        AND c.relname = $2
     `, [schemaName || 'public', tableName]);
         return result.rows.map((row) => row.stxname);
     }
+    /**
+     * Add a CHECK constraint, guarded by a fresh existence lookup (PostgreSQL
+     * has no ADD CONSTRAINT IF NOT EXISTS) so replays stay idempotent.
+     * PostgreSQL validates existing rows as part of the ALTER — a table holding
+     * violating rows fails the statement loudly; backfill data first.
+     */
+    async executeCreateCheckConstraint(tableName, spec, schema) {
+        if (!spec.expression || spec.expression.trim().length === 0) {
+            throw new Error(`Check constraint "${spec.name}" has no expression. Pass the raw SQL boolean expression as the second argument of hasCheckConstraint().`);
+        }
+        const existing = await this.getExistingCheckConstraints(tableName, schema);
+        if (existing.includes(spec.name)) {
+            return;
+        }
+        const qualifiedTableName = this.getQualifiedTableName(tableName, schema);
+        this.logger(`  Adding check constraint "${spec.name}" to ${qualifiedTableName}...`);
+        await this.client.query((0, check_constraint_sql_1.buildAddCheckConstraintStatement)(spec, qualifiedTableName));
+        this.logger(`  ✓ Check constraint "${spec.name}" added
+`);
+    }
+    /**
+     * Names of the CHECK constraints (`contype = 'c'`) defined on a table,
+     * resolved via the table's namespace so the lookup is independent of
+     * search_path. Includes column NOT NULL-style checks PostgreSQL stores as
+     * table constraints, which is fine — reconciliation only tests declared
+     * names for membership.
+     */
+    async getExistingCheckConstraints(tableName, schemaName) {
+        const result = await this.client.query(`
+      SELECT con.conname
+      FROM pg_constraint con
+      JOIN pg_class c ON c.oid = con.conrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = $1
+        AND c.relname = $2
+        AND con.contype = 'c'
+    `, [schemaName || 'public', tableName]);
+        return result.rows.map((row) => row.conname);
+    }
     /**
      * Execute create foreign key
      */
@@ -1499,10 +1593,10 @@ class DbSchemaManager {
         }
         const tables = new Map();
         for (const schemaName of schemas) {
-            const result = await this.client.query(`
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+            const result = await this.client.query(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = $1 AND table_type = 'BASE TABLE'
       `, [schemaName]);
             for (const row of result.rows) {
                 // Use composite key for non-public schemas to avoid collisions
@@ -1516,20 +1610,20 @@ class DbSchemaManager {
      * Get all columns for a table
      */
     async getExistingColumns(tableName, schemaName) {
-        const result = await this.client.query(`
-      SELECT
-        column_name,
-        data_type,
-        udt_name,
-        character_maximum_length,
-        numeric_precision,
-        numeric_scale,
-        is_nullable,
-        column_default,
-        collation_name
-      FROM information_schema.columns
-      WHERE table_schema = $1 AND table_name = $2
-      ORDER BY ordinal_position
+        const result = await this.client.query(`
+      SELECT
+        column_name,
+        data_type,
+        udt_name,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale,
+        is_nullable,
+        column_default,
+        collation_name
+      FROM information_schema.columns
+      WHERE table_schema = $1 AND table_name = $2
+      ORDER BY ordinal_position
     `, [schemaName || 'public', tableName]);
         const columns = new Map();
         for (const row of result.rows) {
@@ -1544,24 +1638,24 @@ class DbSchemaManager {
         // `pg_get_indexdef(oid, 0, true)` yields the canonical, pretty-printed
         // CREATE INDEX statement (no CONCURRENTLY / IF NOT EXISTS, redundant parens
         // stripped), which the signature comparison parses to detect changes.
-        const result = await this.client.query(`
-      SELECT
-        i.relname as index_name,
-        pg_get_indexdef(i.oid, 0, true) as canonical_def,
-        ARRAY(
-          SELECT a.attname
-          FROM unnest(ix.indkey) WITH ORDINALITY k(attnum, ord)
-          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
-          ORDER BY k.ord
-        ) as column_names
-      FROM pg_index ix
-      JOIN pg_class t ON t.oid = ix.indrelid
-      JOIN pg_class i ON i.oid = ix.indexrelid
-      JOIN pg_namespace n ON n.oid = t.relnamespace
-      WHERE
-        n.nspname = $1
-        AND t.relname = $2
-        AND NOT ix.indisprimary
+        const result = await this.client.query(`
+      SELECT
+        i.relname as index_name,
+        pg_get_indexdef(i.oid, 0, true) as canonical_def,
+        ARRAY(
+          SELECT a.attname
+          FROM unnest(ix.indkey) WITH ORDINALITY k(attnum, ord)
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+          ORDER BY k.ord
+        ) as column_names
+      FROM pg_index ix
+      JOIN pg_class t ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      WHERE
+        n.nspname = $1
+        AND t.relname = $2
+        AND NOT ix.indisprimary
     `, [schemaName || 'public', tableName]);
         return result.rows.map(row => ({
             index_name: row.index_name,
@@ -1641,29 +1735,29 @@ class DbSchemaManager {
      * Get all foreign key constraints for a table
      */
     async getExistingForeignKeys(tableName, schemaName) {
-        const result = await this.client.query(`
-      SELECT
-        tc.constraint_name,
-        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) as column_names,
-        ccu.table_name AS referenced_table,
-        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) as referenced_column_names,
-        rc.delete_rule as on_delete,
-        rc.update_rule as on_update
-      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
-      JOIN information_schema.referential_constraints AS rc
-        ON rc.constraint_name = tc.constraint_name
-        AND rc.constraint_schema = tc.table_schema
-      WHERE
-        tc.table_schema = $1
-        AND tc.table_name = $2
-        AND tc.constraint_type = 'FOREIGN KEY'
-      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
+        const result = await this.client.query(`
+      SELECT
+        tc.constraint_name,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) as column_names,
+        ccu.table_name AS referenced_table,
+        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) as referenced_column_names,
+        rc.delete_rule as on_delete,
+        rc.update_rule as on_update
+      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
+      JOIN information_schema.referential_constraints AS rc
+        ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+      WHERE
+        tc.table_schema = $1
+        AND tc.table_name = $2
+        AND tc.constraint_type = 'FOREIGN KEY'
+      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
     `, [schemaName || 'public', tableName]);
         return result.rows.map(row => ({
             constraint_name: row.constraint_name,
@@ -1894,6 +1988,8 @@ class DbSchemaManager {
                 const kindsDesc = operation.kinds && operation.kinds.length > 0 ? ` (${operation.kinds.join(', ')})` : '';
                 return `Create statistics "${operation.statisticsName}"${kindsDesc} on "${operation.tableName}" (${operation.expressions.join(', ')})`;
             }
+            case 'create_check_constraint':
+                return `Add check constraint "${operation.constraintName}" on "${operation.tableName}" CHECK (${operation.expression})`;
             case 'set_database_setting':
                 return `Set database parameter ${operation.name} = ${operation.value} (ALTER DATABASE ... SET, persists for new sessions)`;
             case 'create_foreign_key':
@@ -1969,15 +2065,15 @@ exports.DbSchemaManager = DbSchemaManager;
  * `search_path`, so an unqualified `'unaccent'::regdictionary` would fail with
  * "text search dictionary unaccent does not exist" when the index is built.
  */
-DbSchemaManager.SEARCH_NORMALIZE_FUNCTION_SQL = `
-CREATE OR REPLACE FUNCTION public.search_normalize(value text)
-RETURNS text
-LANGUAGE sql
-IMMUTABLE
-PARALLEL SAFE
-RETURNS NULL ON NULL INPUT
-AS $$
-  SELECT lower(public.unaccent('public.unaccent', value))
+DbSchemaManager.SEARCH_NORMALIZE_FUNCTION_SQL = `
+CREATE OR REPLACE FUNCTION public.search_normalize(value text)
+RETURNS text
+LANGUAGE sql
+IMMUTABLE
+PARALLEL SAFE
+RETURNS NULL ON NULL INPUT
+AS $$
+  SELECT lower(public.unaccent('public.unaccent', value))
 $$`;
 /**
  * Execute create index