tml-2912: unify SQL check-constraint mechanism + drift-manage array element checks

apps/telemetry-backend/src/prisma/contract.prisma

@@ -6,7 +6,7 @@ model TelemetryEvent {
   installationId String
   version        String
   command        String
-  flags          String[]
+  flags          Json
   runtimeName    String
   runtimeVersion String
   os             String
@@ -15,7 +15,7 @@ model TelemetryEvent {
   databaseTarget String?
   tsVersion      String?
   agent          String?
-  extensions     String[]
+  extensions     Json
 
   @@index([ingestedAt])
   @@map("telemetry_event")

apps/telemetry-backend/test/handler.test.ts

@@ -162,10 +162,8 @@ describe('telemetry POST /events', () => {
     const row = await fetchSingleRow();
     expect(row.installationId).toBe(maxString);
     expect(row.command).toBe(maxString);
-    expect(row.flags).toHaveLength(64);
-    expect(row.flags[0]).toBe(maxArrayItem);
-    expect(row.extensions).toHaveLength(64);
-    expect(row.extensions[0]).toBe(maxArrayItem);
+    expect(row.flags).toEqual(manyArrayItems);
+    expect(row.extensions).toEqual(manyArrayItems);
   });
 
   it('rejects strings beyond the configured schema bounds with 400', async () => {

examples/prisma-next-demo/migrations/app/20260422T0720_initial/migration.ts

@@ -121,15 +121,13 @@ export default class M extends Migration<never, End> {
         schema: 'public',
         table: 'user',
         constraint: 'user_kind_check',
-        column: 'kind',
-        values: ['admin', 'user'],
+        payload: { kind: 'valueSet', column: 'kind', values: ['admin', 'user'] },
       }),
       this.addCheckConstraint({
         schema: 'public',
         table: 'post',
         constraint: 'post_priority_check',
-        column: 'priority',
-        values: ['low', 'high', 'urgent'],
+        payload: { kind: 'valueSet', column: 'priority', values: ['low', 'high', 'urgent'] },
       }),
       this.addForeignKey({
         schema: 'public',

packages/1-framework/1-core/config/src/contract-source-types.ts

@@ -1,5 +1,6 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CapabilityMatrix } from '@prisma-next/framework-components/components';
 import type {
   AssembledAuthoringContributions,
   ControlMutationDefaults,
@@ -45,6 +46,7 @@ export interface ContractSourceContext {
   readonly codecLookup: CodecLookup;
   readonly controlMutationDefaults: ControlMutationDefaults;
   readonly resolvedInputs: readonly string[];
+  readonly capabilities: CapabilityMatrix;
 }
 
 /** Lets format-aware tooling avoid file-extension sniffing and opaque loader introspection. */

packages/1-framework/1-core/framework-components/src/control/control-stack.ts

@@ -1,5 +1,7 @@
 import type { JsonValue } from '@prisma-next/contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
+import type { CapabilityMatrix } from '../shared/capabilities';
+import { mergeCapabilityMatrices } from '../shared/capabilities';
 import type { Codec } from '../shared/codec';
 import type { AnyCodecDescriptor } from '../shared/codec-descriptor';
 import type { CodecLookup, CodecMeta, CodecRef, CodecRegistry } from '../shared/codec-types';
@@ -62,6 +64,7 @@ export interface ControlStack<
   readonly authoringContributions: AssembledAuthoringContributions;
   readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
   readonly controlMutationDefaults: ControlMutationDefaults;
+  readonly capabilities: CapabilityMatrix;
 }
 
 export interface CreateControlStackInput<
@@ -522,5 +525,10 @@ export function createControlStack<TFamilyId extends string, TTargetId extends s
     authoringContributions: assembleAuthoringContributions(allDescriptors),
     scalarTypeDescriptors,
     controlMutationDefaults: assembleControlMutationDefaults(allDescriptors),
+    capabilities: mergeCapabilityMatrices({}, [
+      target,
+      ...(adapter ? [adapter] : []),
+      ...orderedExtensionPacks,
+    ]),
   };
 }

packages/1-framework/1-core/framework-components/src/exports/components.ts

@@ -1,3 +1,4 @@
+export type { CapabilityMatrix } from '../shared/capabilities';
 export { mergeCapabilityMatrices } from '../shared/capabilities';
 export type {
   AdapterDescriptor,

packages/1-framework/1-core/framework-components/src/shared/capabilities.ts

@@ -9,7 +9,7 @@
 
 import { blindCast } from '@prisma-next/utils/casts';
 
-type CapabilityMatrix = Record<string, Record<string, boolean>>;
+export type CapabilityMatrix = Record<string, Record<string, boolean>>;
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);

packages/1-framework/2-authoring/psl-parser/src/resolve.ts

@@ -15,6 +15,7 @@ export interface ResolvedAttributeArg {
   readonly kind: 'positional' | 'named';
   readonly name?: string;
   readonly value: string;
+  readonly expression?: ExpressionAst;
   readonly span: PslSpan;
 }
 
@@ -69,10 +70,12 @@ function readResolvedArgList(
   const args: ResolvedAttributeArg[] = [];
   for (const arg of argList.args()) {
     const name = arg.name()?.name();
+    const expression = arg.value();
     args.push({
       kind: name !== undefined ? 'named' : 'positional',
       ...(name !== undefined ? { name } : {}),
-      value: renderExpression(arg.value()),
+      value: renderExpression(expression),
+      ...(expression !== undefined ? { expression } : {}),
       span: nodePslSpan(arg.syntax, sourceFile),
     });
   }

packages/1-framework/3-tooling/cli/src/control-api/client.ts

@@ -631,6 +631,7 @@ class ControlClientImpl implements ControlClient {
         codecLookup: stack.codecLookup,
         controlMutationDefaults: stack.controlMutationDefaults,
         resolvedInputs: contractConfig.source.inputs ?? [],
+        capabilities: stack.capabilities,
       };
       const providerResult = await contractConfig.source.load(sourceContext);
       if (!providerResult.ok) {

packages/1-framework/3-tooling/cli/src/control-api/operations/contract-emit.ts

@@ -221,6 +221,7 @@ export async function executeContractEmit(
       codecLookup: stack.codecLookup,
       controlMutationDefaults: stack.controlMutationDefaults,
       resolvedInputs: contractConfig.source.inputs ?? [],
+      capabilities: stack.capabilities,
     };
 
     startSpan(onProgress, 'resolveSource', 'Resolving contract source...');

packages/1-framework/3-tooling/cli/test/config-types.test.ts

@@ -217,6 +217,7 @@ describe('defineConfig', () => {
       },
       controlMutationDefaults: { defaultFunctionRegistry: new Map(), generatorDescriptors: [] },
       resolvedInputs: [],
+      capabilities: {},
     });
 
     expect(config.output).toBe('output/contract.json');

packages/2-mongo-family/2-authoring/contract-psl/test/provider.test.ts

@@ -26,6 +26,7 @@ function createMongoTestContext(overrides?: Partial<ContractSourceContext>): Con
       generatorDescriptors: [],
     },
     resolvedInputs: [],
+    capabilities: {},
     ...overrides,
   };
 }

packages/2-mongo-family/2-authoring/contract-ts/test/config-types.test.ts

@@ -19,6 +19,7 @@ const emptyContext: ContractSourceContext = {
     generatorDescriptors: [],
   },
   resolvedInputs: [],
+  capabilities: {},
 };
 
 function minimalMongoContract(overrides?: {

packages/2-sql/1-core/schema-ir/src/exports/types.ts

@@ -3,6 +3,7 @@ export type {
   SqlAnnotations,
   SqlCheckConstraintIRInput,
   SqlColumnIRInput,
+  SqlExpressionCheckIRInput,
   SqlForeignKeyIRInput,
   SqlIndexIRInput,
   SqlReferentialAction,
@@ -12,16 +13,20 @@ export type {
   SqlTypeMetadata,
   SqlTypeMetadataRegistry,
   SqlUniqueIRInput,
+  SqlValueSetCheckIRInput,
 } from '../types';
 
 export {
   PrimaryKey,
   SqlCheckConstraintIR,
   SqlColumnIR,
+  SqlExpressionCheckIR,
   SqlForeignKeyIR,
   SqlIndexIR,
   SqlSchemaIR,
   SqlSchemaIRNode,
   SqlTableIR,
   SqlUniqueIR,
+  SqlValueSetCheckIR,
+  sqlCheckConstraintIR,
 } from '../types';

packages/2-sql/1-core/schema-ir/src/ir/sql-check-constraint-ir.ts

@@ -1,7 +1,12 @@
-import { freezeNode } from '@prisma-next/framework-components/ir';
-import { SqlSchemaIRNode } from './sql-schema-ir-node';
+import { freezeNode, IRNodeBase } from '@prisma-next/framework-components/ir';
 
-export interface SqlCheckConstraintIRInput {
+/**
+ * Input for a value-set (enum-style `IN (...)`) check constraint. Carries the
+ * **resolved values** rather than a raw SQL predicate so callers can compare
+ * value-sets without parsing SQL.
+ */
+export interface SqlValueSetCheckIRInput {
+  readonly kind: 'valueSet';
   /** Constraint name as stored in the database catalog. */
   readonly name: string;
   /** Column the check restricts. */
@@ -11,22 +16,75 @@ export interface SqlCheckConstraintIRInput {
 }
 
 /**
- * Schema IR node for a table-level check constraint that restricts a
- * column to a set of permitted values (an enum-style `IN (...)` check).
+ * Input for an expression check constraint that carries a canonical SQL
+ * predicate string (e.g. the scalar-array element-non-null check
+ * `array_position("tags", NULL) IS NULL`). Compared by strict string equality
+ * on the canonical predicate.
+ */
+export interface SqlExpressionCheckIRInput {
+  readonly kind: 'expression';
+  /** Constraint name as stored in the database catalog. */
+  readonly name: string;
+  /** Canonical SQL predicate emitted verbatim into `CHECK (<expression>)`. */
+  readonly expression: string;
+}
+
+/**
+ * A table-level check constraint, discriminated on `kind`:
+ *
+ * - `valueSet` — an enum-style `column IN (...)` restriction carrying the
+ *   resolved permitted values.
+ * - `expression` — a canonical SQL predicate (the scalar-array
+ *   element-non-null check) compared by strict string equality.
+ */
+export type SqlCheckConstraintIRInput = SqlValueSetCheckIRInput | SqlExpressionCheckIRInput;
+
+/**
+ * Schema IR node for a table-level check constraint.
  *
- * Carries the **resolved values** rather than a raw SQL predicate so
- * callers can compare value-sets without parsing SQL.
+ * A leaf that earns polymorphic dispatch: value-set and expression checks are
+ * switched over at the verifier, planner, and introspection sites, so the leaf
+ * carries its own literal `kind` (per the `IRNodeBase` alphabet contract).
  */
-export class SqlCheckConstraintIR extends SqlSchemaIRNode {
+export abstract class SqlCheckConstraintIR extends IRNodeBase {
+  abstract override readonly kind: 'valueSet' | 'expression';
   readonly name: string;
+
+  protected constructor(name: string) {
+    super();
+    this.name = name;
+  }
+}
+
+/** Value-set (`column IN (...)`) check constraint. */
+export class SqlValueSetCheckIR extends SqlCheckConstraintIR {
+  override readonly kind = 'valueSet' as const;
   readonly column: string;
   readonly permittedValues: readonly string[];
 
-  constructor(input: SqlCheckConstraintIRInput) {
-    super();
-    this.name = input.name;
+  constructor(input: Omit<SqlValueSetCheckIRInput, 'kind'>) {
+    super(input.name);
     this.column = input.column;
     this.permittedValues = Object.freeze([...input.permittedValues]);
     freezeNode(this);
   }
 }
+
+/** Expression (canonical SQL predicate) check constraint. */
+export class SqlExpressionCheckIR extends SqlCheckConstraintIR {
+  override readonly kind = 'expression' as const;
+  readonly expression: string;
+
+  constructor(input: Omit<SqlExpressionCheckIRInput, 'kind'>) {
+    super(input.name);
+    this.expression = input.expression;
+    freezeNode(this);
+  }
+}
+
+/** Builds the concrete check-constraint IR node for a discriminated input. */
+export function sqlCheckConstraintIR(input: SqlCheckConstraintIRInput): SqlCheckConstraintIR {
+  return input.kind === 'valueSet'
+    ? new SqlValueSetCheckIR(input)
+    : new SqlExpressionCheckIR(input);
+}

packages/2-sql/1-core/schema-ir/src/ir/sql-table-ir.ts

@@ -1,6 +1,10 @@
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
-import { SqlCheckConstraintIR, type SqlCheckConstraintIRInput } from './sql-check-constraint-ir';
+import {
+  SqlCheckConstraintIR,
+  type SqlCheckConstraintIRInput,
+  sqlCheckConstraintIR,
+} from './sql-check-constraint-ir';
 import { type SqlAnnotations, SqlColumnIR, type SqlColumnIRInput } from './sql-column-ir';
 import { SqlForeignKeyIR, type SqlForeignKeyIRInput } from './sql-foreign-key-ir';
 import { SqlIndexIR, type SqlIndexIRInput } from './sql-index-ir';
@@ -72,9 +76,7 @@ export class SqlTableIR extends SqlSchemaIRNode {
     if (input.annotations !== undefined) this.annotations = input.annotations;
     if (input.checks !== undefined && input.checks.length > 0) {
       this.checks = Object.freeze(
-        input.checks.map((c) =>
-          c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c),
-        ),
+        input.checks.map((c) => (c instanceof SqlCheckConstraintIR ? c : sqlCheckConstraintIR(c))),
       );
     }
     freezeNode(this);