@prisma-next/family-sql 0.12.0-dev.17 → 0.12.0-dev.2

package/src/core/schema-verify/verify-helpers.ts

@@ -3,7 +3,6 @@
  * These functions verify schema IR against contract requirements.
  */
 
-import type { ControlPolicy } from '@prisma-next/contract/types';
 import type {
   SchemaIssue,
   SchemaVerificationNode,
@@ -16,10 +15,6 @@ import type {
   UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
 import type { SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from '@prisma-next/sql-schema-ir/types';
-import {
-  emitIssueAndNodeUnderControlPolicy,
-  emitIssueUnderControlPolicy,
-} from './control-verify-emit';
 
 function indexOptionsLooselyEqual(
   a: Record<string, unknown> | undefined,
@@ -140,34 +135,34 @@ export function verifyPrimaryKey(
   schemaPK: PrimaryKey | undefined,
   tableName: string,
   namespaceId: string,
-  tableControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
-): 'pass' | 'warn' | 'fail' {
+): 'pass' | 'fail' {
   if (!schemaPK) {
-    const issue: SchemaIssue = {
+    issues.push({
       kind: 'primary_key_mismatch',
       table: tableName,
       namespaceId,
       expected: contractPK.columns.join(', '),
       message: `Table "${tableName}" is missing primary key`,
-    };
-    const outcome = emitIssueUnderControlPolicy(tableControlPolicy, issue, issues);
-    return outcome === 'suppress' ? 'pass' : outcome;
+    });
+    return 'fail';
   }
 
   if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
-    const issue: SchemaIssue = {
+    issues.push({
       kind: 'primary_key_mismatch',
       table: tableName,
       namespaceId,
       expected: contractPK.columns.join(', '),
       actual: schemaPK.columns.join(', '),
       message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(', ')}], got [${schemaPK.columns.join(', ')}]`,
-    };
-    const outcome = emitIssueUnderControlPolicy(tableControlPolicy, issue, issues);
-    return outcome === 'suppress' ? 'pass' : outcome;
+    });
+    return 'fail';
   }
 
+  // Name differences are ignored for semantic satisfaction.
+  // Names are persisted for deterministic DDL and diagnostics but are not identity.
+
   return 'pass';
 }
 
@@ -184,7 +179,6 @@ export function verifyForeignKeys(
   tableName: string,
   namespaceId: string,
   tablePath: string,
-  tableControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
   strict: boolean,
 ): SchemaVerificationNode[] {
@@ -213,62 +207,52 @@ export function verifyForeignKeys(
     });
 
     if (!matchingFK) {
-      const issue: SchemaIssue = {
+      issues.push({
         kind: 'foreign_key_mismatch',
         table: tableName,
         namespaceId,
         expected: `${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(', ')})`,
         message: `Table "${tableName}" is missing foreign key: ${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(', ')})`,
-      };
-      emitIssueAndNodeUnderControlPolicy(
-        tableControlPolicy,
-        issue,
-        {
-          status: 'fail',
-          kind: 'foreignKey',
-          name: `foreignKey(${contractFK.source.columns.join(', ')})`,
-          contractPath: fkPath,
-          code: 'foreign_key_mismatch',
-          message: 'Foreign key missing',
-          expected: contractFK,
-          actual: undefined,
-          children: [],
-        },
-        issues,
-        nodes,
-      );
+      });
+      nodes.push({
+        status: 'fail',
+        kind: 'foreignKey',
+        name: `foreignKey(${contractFK.source.columns.join(', ')})`,
+        contractPath: fkPath,
+        code: 'foreign_key_mismatch',
+        message: 'Foreign key missing',
+        expected: contractFK,
+        actual: undefined,
+        children: [],
+      });
     } else {
       const actionMismatches = getReferentialActionMismatches(contractFK, matchingFK);
       if (actionMismatches.length > 0) {
         const combinedMessage = actionMismatches.map((m) => m.message).join('; ');
         const combinedExpected = actionMismatches.map((m) => m.expected).join(', ');
         const combinedActual = actionMismatches.map((m) => m.actual).join(', ');
-        const issue: SchemaIssue = {
+        issues.push({
           kind: 'foreign_key_mismatch',
           table: tableName,
           namespaceId,
+          // Set indexOrConstraint so the planner classifies this as a non-additive
+          // conflict (existing FK with wrong actions cannot be fixed additively).
           indexOrConstraint: matchingFK.name ?? `fk(${contractFK.source.columns.join(',')})`,
           expected: combinedExpected,
           actual: combinedActual,
           message: `Table "${tableName}" foreign key ${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}: ${combinedMessage}`,
-        };
-        emitIssueAndNodeUnderControlPolicy(
-          tableControlPolicy,
-          issue,
-          {
-            status: 'fail',
-            kind: 'foreignKey',
-            name: `foreignKey(${contractFK.source.columns.join(', ')})`,
-            contractPath: fkPath,
-            code: 'foreign_key_mismatch',
-            message: combinedMessage,
-            expected: contractFK,
-            actual: matchingFK,
-            children: [],
-          },
-          issues,
-          nodes,
-        );
+        });
+        nodes.push({
+          status: 'fail',
+          kind: 'foreignKey',
+          name: `foreignKey(${contractFK.source.columns.join(', ')})`,
+          contractPath: fkPath,
+          code: 'foreign_key_mismatch',
+          message: combinedMessage,
+          expected: contractFK,
+          actual: matchingFK,
+          children: [],
+        });
       } else {
         nodes.push({
           status: 'pass',
@@ -302,30 +286,24 @@ export function verifyForeignKeys(
       });
 
       if (!matchingFK) {
-        const issue: SchemaIssue = {
+        issues.push({
           kind: 'extra_foreign_key',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaFK.name ?? `fk(${schemaFK.columns.join(',')})`,
           message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(', ')} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(', ')})`,
-        };
-        emitIssueAndNodeUnderControlPolicy(
-          tableControlPolicy,
-          issue,
-          {
-            status: 'fail',
-            kind: 'foreignKey',
-            name: `foreignKey(${schemaFK.columns.join(', ')})`,
-            contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(',')}]`,
-            code: 'extra_foreign_key',
-            message: 'Extra foreign key found',
-            expected: undefined,
-            actual: schemaFK,
-            children: [],
-          },
-          issues,
-          nodes,
-        );
+        });
+        nodes.push({
+          status: 'fail',
+          kind: 'foreignKey',
+          name: `foreignKey(${schemaFK.columns.join(', ')})`,
+          contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(',')}]`,
+          code: 'extra_foreign_key',
+          message: 'Extra foreign key found',
+          expected: undefined,
+          actual: schemaFK,
+          children: [],
+        });
       }
     }
   }
@@ -351,7 +329,6 @@ export function verifyUniqueConstraints(
   tableName: string,
   namespaceId: string,
   tablePath: string,
-  tableControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
   strict: boolean,
 ): SchemaVerificationNode[] {
@@ -372,31 +349,27 @@ export function verifyUniqueConstraints(
       schemaIndexes.find((idx) => idx.unique && arraysEqual(idx.columns, contractUnique.columns));
 
     if (!matchingUnique && !matchingUniqueIndex) {
-      const issue: SchemaIssue = {
+      issues.push({
         kind: 'unique_constraint_mismatch',
         table: tableName,
         namespaceId,
         expected: contractUnique.columns.join(', '),
         message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(', ')}`,
-      };
-      emitIssueAndNodeUnderControlPolicy(
-        tableControlPolicy,
-        issue,
-        {
-          status: 'fail',
-          kind: 'unique',
-          name: `unique(${contractUnique.columns.join(', ')})`,
-          contractPath: uniquePath,
-          code: 'unique_constraint_mismatch',
-          message: 'Unique constraint missing',
-          expected: contractUnique,
-          actual: undefined,
-          children: [],
-        },
-        issues,
-        nodes,
-      );
+      });
+      nodes.push({
+        status: 'fail',
+        kind: 'unique',
+        name: `unique(${contractUnique.columns.join(', ')})`,
+        contractPath: uniquePath,
+        code: 'unique_constraint_mismatch',
+        message: 'Unique constraint missing',
+        expected: contractUnique,
+        actual: undefined,
+        children: [],
+      });
     } else {
+      // Name differences are ignored for semantic satisfaction.
+      // Names are persisted for deterministic DDL and diagnostics but are not identity.
       nodes.push({
         status: 'pass',
         kind: 'unique',
@@ -411,6 +384,7 @@ export function verifyUniqueConstraints(
     }
   }
 
+  // Check for extra uniques in strict mode
   if (strict) {
     for (const schemaUnique of schemaUniques) {
       const matchingUnique = contractUniques.find((u) =>
@@ -418,30 +392,24 @@ export function verifyUniqueConstraints(
       );
 
       if (!matchingUnique) {
-        const issue: SchemaIssue = {
+        issues.push({
           kind: 'extra_unique_constraint',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaUnique.name ?? `unique(${schemaUnique.columns.join(',')})`,
           message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(', ')}`,
-        };
-        emitIssueAndNodeUnderControlPolicy(
-          tableControlPolicy,
-          issue,
-          {
-            status: 'fail',
-            kind: 'unique',
-            name: `unique(${schemaUnique.columns.join(', ')})`,
-            contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(',')}]`,
-            code: 'extra_unique_constraint',
-            message: 'Extra unique constraint found',
-            expected: undefined,
-            actual: schemaUnique,
-            children: [],
-          },
-          issues,
-          nodes,
-        );
+        });
+        nodes.push({
+          status: 'fail',
+          kind: 'unique',
+          name: `unique(${schemaUnique.columns.join(', ')})`,
+          contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(',')}]`,
+          code: 'extra_unique_constraint',
+          message: 'Extra unique constraint found',
+          expected: undefined,
+          actual: schemaUnique,
+          children: [],
+        });
       }
     }
   }
@@ -467,7 +435,6 @@ export function verifyIndexes(
   tableName: string,
   namespaceId: string,
   tablePath: string,
-  tableControlPolicy: ControlPolicy,
   issues: SchemaIssue[],
   strict: boolean,
 ): SchemaVerificationNode[] {
@@ -494,31 +461,27 @@ export function verifyIndexes(
       schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
 
     if (!matchingIndex && !matchingUniqueConstraint) {
-      const issue: SchemaIssue = {
+      issues.push({
         kind: 'index_mismatch',
         table: tableName,
         namespaceId,
         expected: contractIndex.columns.join(', '),
         message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(', ')}`,
-      };
-      emitIssueAndNodeUnderControlPolicy(
-        tableControlPolicy,
-        issue,
-        {
-          status: 'fail',
-          kind: 'index',
-          name: `index(${contractIndex.columns.join(', ')})`,
-          contractPath: indexPath,
-          code: 'index_mismatch',
-          message: 'Index missing',
-          expected: contractIndex,
-          actual: undefined,
-          children: [],
-        },
-        issues,
-        nodes,
-      );
+      });
+      nodes.push({
+        status: 'fail',
+        kind: 'index',
+        name: `index(${contractIndex.columns.join(', ')})`,
+        contractPath: indexPath,
+        code: 'index_mismatch',
+        message: 'Index missing',
+        expected: contractIndex,
+        actual: undefined,
+        children: [],
+      });
     } else {
+      // Name differences are ignored for semantic satisfaction.
+      // Names are persisted for deterministic DDL and diagnostics but are not identity.
       nodes.push({
         status: 'pass',
         kind: 'index',
@@ -533,8 +496,10 @@ export function verifyIndexes(
     }
   }
 
+  // Check for extra indexes in strict mode
   if (strict) {
     for (const schemaIndex of schemaIndexes) {
+      // Skip unique indexes (they're handled as unique constraints)
       if (schemaIndex.unique) {
         continue;
       }
@@ -545,30 +510,24 @@ export function verifyIndexes(
       );
 
       if (!matchingIndex) {
-        const issue: SchemaIssue = {
+        issues.push({
           kind: 'extra_index',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaIndex.name ?? `idx(${schemaIndex.columns.join(',')})`,
           message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(', ')}`,
-        };
-        emitIssueAndNodeUnderControlPolicy(
-          tableControlPolicy,
-          issue,
-          {
-            status: 'fail',
-            kind: 'index',
-            name: `index(${schemaIndex.columns.join(', ')})`,
-            contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(',')}]`,
-            code: 'extra_index',
-            message: 'Extra index found',
-            expected: undefined,
-            actual: schemaIndex,
-            children: [],
-          },
-          issues,
-          nodes,
-        );
+        });
+        nodes.push({
+          status: 'fail',
+          kind: 'index',
+          name: `index(${schemaIndex.columns.join(', ')})`,
+          contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(',')}]`,
+          code: 'extra_index',
+          message: 'Extra index found',
+          expected: undefined,
+          actual: schemaIndex,
+          children: [],
+        });
       }
     }
   }