@prisma-next/family-sql 0.3.0-dev.5 → 0.3.0-dev.53

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

@@ -33,9 +33,71 @@ export function arraysEqual(a: readonly string[], b: readonly string[]): boolean
   return true;
 }
 
+// ============================================================================
+// Semantic Satisfaction Predicates
+// ============================================================================
+// These predicates implement the "stronger satisfies weaker" logic for storage
+// objects. They are used by both verification and migration planning to ensure
+// consistent behavior across the control plane.
+
+/**
+ * Checks if a unique constraint requirement is satisfied by the given columns.
+ *
+ * Semantic satisfaction: a unique constraint requirement can be satisfied by:
+ * - A unique constraint with the same columns, OR
+ * - A unique index with the same columns
+ *
+ * @param uniques - The unique constraints in the schema table
+ * @param indexes - The indexes in the schema table
+ * @param columns - The columns required by the unique constraint
+ * @returns true if the requirement is satisfied
+ */
+export function isUniqueConstraintSatisfied(
+  uniques: readonly SqlUniqueIR[],
+  indexes: readonly SqlIndexIR[],
+  columns: readonly string[],
+): boolean {
+  // Check for matching unique constraint
+  const hasConstraint = uniques.some((unique) => arraysEqual(unique.columns, columns));
+  if (hasConstraint) {
+    return true;
+  }
+  // Check for matching unique index (semantic satisfaction)
+  return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
+}
+
+/**
+ * Checks if an index requirement is satisfied by the given columns.
+ *
+ * Semantic satisfaction: a non-unique index requirement can be satisfied by:
+ * - Any index (unique or non-unique) with the same columns, OR
+ * - A unique constraint with the same columns (stronger satisfies weaker)
+ *
+ * @param indexes - The indexes in the schema table
+ * @param uniques - The unique constraints in the schema table
+ * @param columns - The columns required by the index
+ * @returns true if the requirement is satisfied
+ */
+export function isIndexSatisfied(
+  indexes: readonly SqlIndexIR[],
+  uniques: readonly SqlUniqueIR[],
+  columns: readonly string[],
+): boolean {
+  // Check for any matching index (unique or non-unique)
+  const hasMatchingIndex = indexes.some((index) => arraysEqual(index.columns, columns));
+  if (hasMatchingIndex) {
+    return true;
+  }
+  // Check for matching unique constraint (semantic satisfaction)
+  return uniques.some((unique) => arraysEqual(unique.columns, columns));
+}
+
 /**
  * Verifies primary key matches between contract and schema.
  * Returns 'pass' or 'fail'.
+ *
+ * Uses semantic satisfaction: identity is based on (table + kind + columns).
+ * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
  */
 export function verifyPrimaryKey(
   contractPK: PrimaryKey,
@@ -64,18 +126,8 @@ export function verifyPrimaryKey(
     return 'fail';
   }
 
-  // Compare name if both are modeled
-  if (contractPK.name && schemaPK.name && contractPK.name !== schemaPK.name) {
-    issues.push({
-      kind: 'primary_key_mismatch',
-      table: tableName,
-      indexOrConstraint: contractPK.name,
-      expected: contractPK.name,
-      actual: schemaPK.name,
-      message: `Table "${tableName}" has primary key name mismatch: expected "${contractPK.name}", got "${schemaPK.name}"`,
-    });
-    return 'fail';
-  }
+  // Name differences are ignored for semantic satisfaction.
+  // Names are persisted for deterministic DDL and diagnostics but are not identity.
 
   return 'pass';
 }
@@ -83,6 +135,9 @@ export function verifyPrimaryKey(
 /**
  * Verifies foreign keys match between contract and schema.
  * Returns verification nodes for the tree.
+ *
+ * Uses semantic satisfaction: identity is based on (table + columns + referenced table + referenced columns).
+ * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
  */
 export function verifyForeignKeys(
   contractFKs: readonly ForeignKey[],
@@ -124,15 +179,20 @@ export function verifyForeignKeys(
         children: [],
       });
     } else {
-      // Compare name if both are modeled
-      if (contractFK.name && matchingFK.name && contractFK.name !== matchingFK.name) {
+      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(', ');
         issues.push({
           kind: 'foreign_key_mismatch',
           table: tableName,
-          indexOrConstraint: contractFK.name,
-          expected: contractFK.name,
-          actual: matchingFK.name,
-          message: `Table "${tableName}" has foreign key name mismatch: expected "${contractFK.name}", got "${matchingFK.name}"`,
+          // 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.columns.join(',')})`,
+          expected: combinedExpected,
+          actual: combinedActual,
+          message: `Table "${tableName}" foreign key ${contractFK.columns.join(', ')} -> ${contractFK.references.table}: ${combinedMessage}`,
         });
         nodes.push({
           status: 'fail',
@@ -140,9 +200,9 @@ export function verifyForeignKeys(
           name: `foreignKey(${contractFK.columns.join(', ')})`,
           contractPath: fkPath,
           code: 'foreign_key_mismatch',
-          message: 'Foreign key name mismatch',
-          expected: contractFK.name,
-          actual: matchingFK.name,
+          message: combinedMessage,
+          expected: contractFK,
+          actual: matchingFK,
           children: [],
         });
       } else {
@@ -199,10 +259,18 @@ export function verifyForeignKeys(
 /**
  * Verifies unique constraints match between contract and schema.
  * Returns verification nodes for the tree.
+ *
+ * Uses semantic satisfaction: identity is based on (table + kind + columns).
+ * A unique constraint requirement can be satisfied by either:
+ * - A unique constraint with the same columns, or
+ * - A unique index with the same columns
+ *
+ * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
  */
 export function verifyUniqueConstraints(
   contractUniques: readonly UniqueConstraint[],
   schemaUniques: readonly SqlUniqueIR[],
+  schemaIndexes: readonly SqlIndexIR[],
   tableName: string,
   tablePath: string,
   issues: SchemaIssue[],
@@ -213,11 +281,18 @@ export function verifyUniqueConstraints(
   // Check each contract unique exists in schema
   for (const contractUnique of contractUniques) {
     const uniquePath = `${tablePath}.uniques[${contractUnique.columns.join(',')}]`;
+
+    // First check for a matching unique constraint
     const matchingUnique = schemaUniques.find((u) =>
       arraysEqual(u.columns, contractUnique.columns),
     );
 
-    if (!matchingUnique) {
+    // If no matching constraint, check for a unique index with the same columns
+    const matchingUniqueIndex =
+      !matchingUnique &&
+      schemaIndexes.find((idx) => idx.unique && arraysEqual(idx.columns, contractUnique.columns));
+
+    if (!matchingUnique && !matchingUniqueIndex) {
       issues.push({
         kind: 'unique_constraint_mismatch',
         table: tableName,
@@ -236,44 +311,19 @@ export function verifyUniqueConstraints(
         children: [],
       });
     } else {
-      // Compare name if both are modeled
-      if (
-        contractUnique.name &&
-        matchingUnique.name &&
-        contractUnique.name !== matchingUnique.name
-      ) {
-        issues.push({
-          kind: 'unique_constraint_mismatch',
-          table: tableName,
-          indexOrConstraint: contractUnique.name,
-          expected: contractUnique.name,
-          actual: matchingUnique.name,
-          message: `Table "${tableName}" has unique constraint name mismatch: expected "${contractUnique.name}", got "${matchingUnique.name}"`,
-        });
-        nodes.push({
-          status: 'fail',
-          kind: 'unique',
-          name: `unique(${contractUnique.columns.join(', ')})`,
-          contractPath: uniquePath,
-          code: 'unique_constraint_mismatch',
-          message: 'Unique constraint name mismatch',
-          expected: contractUnique.name,
-          actual: matchingUnique.name,
-          children: [],
-        });
-      } else {
-        nodes.push({
-          status: 'pass',
-          kind: 'unique',
-          name: `unique(${contractUnique.columns.join(', ')})`,
-          contractPath: uniquePath,
-          code: '',
-          message: '',
-          expected: undefined,
-          actual: undefined,
-          children: [],
-        });
-      }
+      // 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',
+        name: `unique(${contractUnique.columns.join(', ')})`,
+        contractPath: uniquePath,
+        code: '',
+        message: '',
+        expected: undefined,
+        actual: undefined,
+        children: [],
+      });
     }
   }
 
@@ -311,10 +361,18 @@ export function verifyUniqueConstraints(
 /**
  * Verifies indexes match between contract and schema.
  * Returns verification nodes for the tree.
+ *
+ * Uses semantic satisfaction: identity is based on (table + kind + columns).
+ * A non-unique index requirement can be satisfied by either:
+ * - A non-unique index with the same columns, or
+ * - A unique index with the same columns (stronger satisfies weaker)
+ *
+ * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
  */
 export function verifyIndexes(
   contractIndexes: readonly Index[],
   schemaIndexes: readonly SqlIndexIR[],
+  schemaUniques: readonly SqlUniqueIR[],
   tableName: string,
   tablePath: string,
   issues: SchemaIssue[],
@@ -325,11 +383,18 @@ export function verifyIndexes(
   // Check each contract index exists in schema
   for (const contractIndex of contractIndexes) {
     const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(',')}]`;
-    const matchingIndex = schemaIndexes.find(
-      (idx) => arraysEqual(idx.columns, contractIndex.columns) && idx.unique === false,
+
+    // Check for any matching index (unique or non-unique)
+    // A unique index can satisfy a non-unique index requirement (stronger satisfies weaker)
+    const matchingIndex = schemaIndexes.find((idx) =>
+      arraysEqual(idx.columns, contractIndex.columns),
     );
 
-    if (!matchingIndex) {
+    // Also check if a unique constraint satisfies the index requirement
+    const matchingUniqueConstraint =
+      !matchingIndex && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
+
+    if (!matchingIndex && !matchingUniqueConstraint) {
       issues.push({
         kind: 'index_mismatch',
         table: tableName,
@@ -348,40 +413,19 @@ export function verifyIndexes(
         children: [],
       });
     } else {
-      // Compare name if both are modeled
-      if (contractIndex.name && matchingIndex.name && contractIndex.name !== matchingIndex.name) {
-        issues.push({
-          kind: 'index_mismatch',
-          table: tableName,
-          indexOrConstraint: contractIndex.name,
-          expected: contractIndex.name,
-          actual: matchingIndex.name,
-          message: `Table "${tableName}" has index name mismatch: expected "${contractIndex.name}", got "${matchingIndex.name}"`,
-        });
-        nodes.push({
-          status: 'fail',
-          kind: 'index',
-          name: `index(${contractIndex.columns.join(', ')})`,
-          contractPath: indexPath,
-          code: 'index_mismatch',
-          message: 'Index name mismatch',
-          expected: contractIndex.name,
-          actual: matchingIndex.name,
-          children: [],
-        });
-      } else {
-        nodes.push({
-          status: 'pass',
-          kind: 'index',
-          name: `index(${contractIndex.columns.join(', ')})`,
-          contractPath: indexPath,
-          code: '',
-          message: '',
-          expected: undefined,
-          actual: undefined,
-          children: [],
-        });
-      }
+      // 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',
+        name: `index(${contractIndex.columns.join(', ')})`,
+        contractPath: indexPath,
+        code: '',
+        message: '',
+        expected: undefined,
+        actual: undefined,
+        children: [],
+      });
     }
   }
 
@@ -512,3 +556,49 @@ export function computeCounts(node: SchemaVerificationNode): {
     totalNodes: pass + warn + fail,
   };
 }
+
+/**
+ * Compares referential actions between a contract FK and a schema FK.
+ * Only compares when the contract FK explicitly specifies onDelete or onUpdate.
+ * Returns all mismatches (both onDelete and onUpdate) so both are reported at once.
+ *
+ * Note: 'noAction' in the contract is semantically equivalent to undefined in the
+ * schema IR, because the introspection adapter omits 'NO ACTION' (the database default)
+ * to keep the IR sparse. We normalize both sides before comparing.
+ */
+function getReferentialActionMismatches(
+  contractFK: ForeignKey,
+  schemaFK: SqlForeignKeyIR,
+): ReadonlyArray<{ expected: string; actual: string; message: string }> {
+  const mismatches: Array<{ expected: string; actual: string; message: string }> = [];
+
+  const contractOnDelete = normalizeReferentialAction(contractFK.onDelete);
+  const schemaOnDelete = normalizeReferentialAction(schemaFK.onDelete);
+  if (contractOnDelete !== undefined && contractOnDelete !== schemaOnDelete) {
+    mismatches.push({
+      expected: `onDelete: ${contractFK.onDelete}`,
+      actual: `onDelete: ${schemaFK.onDelete ?? 'noAction (default)'}`,
+      message: `onDelete mismatch: expected ${contractFK.onDelete}, got ${schemaFK.onDelete ?? 'noAction (default)'}`,
+    });
+  }
+
+  const contractOnUpdate = normalizeReferentialAction(contractFK.onUpdate);
+  const schemaOnUpdate = normalizeReferentialAction(schemaFK.onUpdate);
+  if (contractOnUpdate !== undefined && contractOnUpdate !== schemaOnUpdate) {
+    mismatches.push({
+      expected: `onUpdate: ${contractFK.onUpdate}`,
+      actual: `onUpdate: ${schemaFK.onUpdate ?? 'noAction (default)'}`,
+      message: `onUpdate mismatch: expected ${contractFK.onUpdate}, got ${schemaFK.onUpdate ?? 'noAction (default)'}`,
+    });
+  }
+
+  return mismatches;
+}
+
+/**
+ * Normalizes a referential action value for comparison.
+ * 'noAction' is the database default and equivalent to undefined (omitted) in the sparse IR.
+ */
+function normalizeReferentialAction(action: string | undefined): string | undefined {
+  return action === 'noAction' ? undefined : action;
+}