@prisma-next/family-sql 0.14.0-dev.39 → 0.14.0-dev.40

package/src/core/{schema-verify/verify-sql-schema.ts → diff/sql-schema-diff.ts}

@@ -18,15 +18,15 @@ import type {
 } from '@prisma-next/framework-components/control';
 
 import {
-  isStorageTable,
   isStorageTypeInstance,
   type SqlStorage,
   type StorageColumn,
-  type StorageTable,
+  StorageTable,
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
-import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import type { SqlSchemaIR, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { canonicalStringify } from '@prisma-next/utils/canonical-stringify';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { extractCodecControlHooks } from '../assembly';
 import { resolveValueSetValues } from '../migrations/contract-to-schema-ir';
@@ -43,6 +43,30 @@ import {
   verifyUniqueConstraints,
 } from './verify-helpers';
 
+/**
+ * Returns the per-schema namespace nodes of an introspected schema node, for
+ * the relational verify to consume one at a time. Structure-agnostic — imports
+ * no target node class. A root exposing a `namespaces` record (Postgres) yields
+ * its namespace nodes (never merged, so same-named tables in different schemas
+ * cannot collide); a flat schema (SQLite) is its own single namespace and
+ * yields itself. Handles spread-flattened input (own-enumerable fields survive).
+ */
+function namespaceSchemaNodes(schema: SqlSchemaIRNode): readonly SqlSchemaIR[] {
+  const obj = blindCast<
+    { readonly namespaces?: Readonly<Record<string, SqlSchemaIR>> },
+    'structural read of an own-enumerable namespaces record; survives the projectSchemaToSpace spread'
+  >(schema);
+  if (obj.namespaces !== undefined) {
+    return Object.values(obj.namespaces);
+  }
+  return [
+    blindCast<
+      SqlSchemaIR,
+      'a flat schema node (no namespaces) is its own single namespace, exposing the per-schema { tables } shape'
+    >(schema),
+  ];
+}
+
 /**
  * Function type for normalizing raw database default expressions into ColumnDefault.
  * Target-specific implementations handle database dialect differences.
@@ -90,6 +114,15 @@ export interface VerifySqlSchemaOptions {
    * with contract native types (e.g., Postgres 'varchar' → 'character varying').
    */
   readonly normalizeNativeType?: NativeTypeNormalizer;
+  /**
+   * When set, only the contract tables in these namespace ids are checked
+   * against `schema` (the matching actual namespace node). The full contract is
+   * still consulted for cross-namespace value-set / control-policy resolution.
+   * Used by the multi-schema verify, which pairs each contract namespace to its
+   * own actual node. Absent ⇒ all contract namespaces are checked against the
+   * single (flat) `schema` — the single-schema / SQLite path.
+   */
+  readonly restrictToNamespaceIds?: ReadonlySet<string>;
 }
 
 /**
@@ -129,6 +162,7 @@ export function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabase
     storageTypes,
     ...ifDefined('normalizeDefault', normalizeDefault),
     ...ifDefined('normalizeNativeType', normalizeNativeType),
+    ...ifDefined('restrictToNamespaceIds', options.restrictToNamespaceIds),
   });
 
   validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
@@ -276,6 +310,7 @@ function verifySchemaTables(options: {
   storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   normalizeDefault?: DefaultNormalizer;
   normalizeNativeType?: NativeTypeNormalizer;
+  restrictToNamespaceIds?: ReadonlySet<string>;
 }): { issues: SchemaIssue[]; rootChildren: SchemaVerificationNode[] } {
   const {
     contract,
@@ -286,6 +321,7 @@ function verifySchemaTables(options: {
     storageTypes,
     normalizeDefault,
     normalizeNativeType,
+    restrictToNamespaceIds,
   } = options;
   const contractDefaultControl = contract.defaultControlPolicy;
   const issues: SchemaIssue[] = [];
@@ -296,14 +332,17 @@ function verifySchemaTables(options: {
   );
 
   for (const namespaceId of namespaceIds) {
+    // When the caller pairs each contract namespace to its own actual node, it
+    // restricts the table check to that namespace; the full contract is still
+    // consulted for value-set / control-policy resolution.
+    if (restrictToNamespaceIds !== undefined && !restrictToNamespaceIds.has(namespaceId)) continue;
     const ns = contract.storage.namespaces[namespaceId];
     if (!ns) continue;
     for (const [tableName, contractTableRaw] of Object.entries(ns.entries.table ?? {})) {
-      if (!isStorageTable(contractTableRaw)) {
-        throw new Error(
-          `verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.entries.table.${tableName}`,
-        );
-      }
+      StorageTable.assert(
+        contractTableRaw,
+        `storage.namespaces.${namespaceId}.entries.table.${tableName}`,
+      );
       const contractTable = contractTableRaw;
       const tableControlPolicy = effectiveControlPolicy(
         contractTable.control,
@@ -315,6 +354,7 @@ function verifySchemaTables(options: {
       if (!schemaTable) {
         const issue: SchemaIssue = {
           kind: 'missing_table',
+          reason: 'not-found',
           table: tableName,
           namespaceId,
           message: `Table "${tableName}" is missing from database`,
@@ -369,6 +409,7 @@ function verifySchemaTables(options: {
         const extraTableControlPolicy = effectiveControlPolicy(undefined, contractDefaultControl);
         const issue: SchemaIssue = {
           kind: 'extra_table',
+          reason: 'not-expected',
           table: tableName,
           message: `Extra table "${tableName}" found in database (not in contract)`,
         };
@@ -385,6 +426,7 @@ function verifySchemaTables(options: {
             expected: undefined,
             actual: undefined,
             children: [],
+            reason: 'not-expected',
           },
           issues,
           rootChildren,
@@ -509,6 +551,7 @@ function verifyTableChildren(options: {
   } else if (schemaTable.primaryKey && strict) {
     const issue: SchemaIssue = {
       kind: 'extra_primary_key',
+      reason: 'not-expected',
       table: tableName,
       namespaceId,
       message: 'Extra primary key found in database (not in contract)',
@@ -652,6 +695,7 @@ function collectContractColumnNodes(options: {
     if (!schemaColumn) {
       const issue: SchemaIssue = {
         kind: 'missing_column',
+        reason: 'not-found',
         table: tableName,
         namespaceId,
         column: columnName,
@@ -724,6 +768,7 @@ function appendExtraColumnNodes(options: {
     if (!contractTable.columns[columnName]) {
       const issue: SchemaIssue = {
         kind: 'extra_column',
+        reason: 'not-expected',
         table: tableName,
         namespaceId,
         column: columnName,
@@ -801,6 +846,7 @@ function verifyColumn(options: {
   if (!typesMatch) {
     const issue: SchemaIssue = {
       kind: 'type_mismatch',
+      reason: 'not-equal',
       table: tableName,
       namespaceId,
       column: columnName,
@@ -861,6 +907,7 @@ function verifyColumn(options: {
   if (contractColumn.nullable !== schemaColumn.nullable) {
     const issue: SchemaIssue = {
       kind: 'nullability_mismatch',
+      reason: 'not-equal',
       table: tableName,
       namespaceId,
       column: columnName,
@@ -891,6 +938,7 @@ function verifyColumn(options: {
       const defaultDescription = describeColumnDefault(contractColumn.default);
       const issue: SchemaIssue = {
         kind: 'default_missing',
+        reason: 'not-found',
         table: tableName,
         namespaceId,
         column: columnName,
@@ -925,6 +973,7 @@ function verifyColumn(options: {
       const actualDescription = schemaColumn.default;
       const issue: SchemaIssue = {
         kind: 'default_mismatch',
+        reason: 'not-equal',
         table: tableName,
         namespaceId,
         column: columnName,
@@ -952,6 +1001,7 @@ function verifyColumn(options: {
   } else if (strict && schemaColumn.default) {
     const issue: SchemaIssue = {
       kind: 'extra_default',
+      reason: 'not-expected',
       table: tableName,
       namespaceId,
       column: columnName,
@@ -1313,3 +1363,141 @@ function formatLiteralValue(value: unknown): string {
   }
   return JSON.stringify(value);
 }
+
+/**
+ * Reads a namespace node's DDL schema name. Namespaced target nodes (Postgres
+ * `PostgresNamespaceSchemaNode`) carry `schemaName`; a flat schema (SQLite) has
+ * none and pairs by position as the sole namespace.
+ */
+function namespaceSchemaName(node: SqlSchemaIR): string | undefined {
+  return blindCast<
+    { readonly schemaName?: string },
+    'reading the optional namespace schemaName off a per-schema node'
+  >(node).schemaName;
+}
+
+/**
+ * Returns a shallow copy of `contract` exposing only the one named namespace —
+ * used solely to resolve that namespace's live DDL schema via the target's
+ * expected-tree projection (never for verification, so global value-sets it may
+ * reference are not consulted).
+ */
+function scopeContractToNamespace(
+  contract: Contract<SqlStorage>,
+  namespaceId: string,
+): Contract<SqlStorage> {
+  const namespace = contract.storage.namespaces[namespaceId];
+  const scopedNamespaces = namespace === undefined ? {} : { [namespaceId]: namespace };
+  return blindCast<
+    Contract<SqlStorage>,
+    'narrowing storage.namespaces to one entry; the rest of the contract is preserved'
+  >({
+    ...contract,
+    storage: blindCast<
+      SqlStorage,
+      'shallow storage copy with a single-namespace map; other storage fields are preserved'
+    >({
+      ...contract.storage,
+      namespaces: scopedNamespaces,
+    }),
+  });
+}
+
+/**
+ * Combines two `VerifyDatabaseSchemaResult`s by concatenating issues and summing
+ * counts — used to fold the per-namespace pairings of a multi-schema database
+ * into one result. The verification-tree `root` of the first pairing is
+ * retained (multi-schema verify-tree shaping is future work).
+ */
+function mergeVerifyResults(
+  a: VerifyDatabaseSchemaResult,
+  b: VerifyDatabaseSchemaResult,
+): VerifyDatabaseSchemaResult {
+  return {
+    ...a,
+    ok: a.ok && b.ok,
+    ...ifDefined('code', a.code ?? b.code),
+    schema: {
+      ...a.schema,
+      issues: [...a.schema.issues, ...b.schema.issues],
+      schemaDiffIssues: [...a.schema.schemaDiffIssues, ...b.schema.schemaDiffIssues],
+      counts: {
+        pass: a.schema.counts.pass + b.schema.counts.pass,
+        warn: a.schema.counts.warn + b.schema.counts.warn,
+        fail: a.schema.counts.fail + b.schema.counts.fail,
+        totalNodes: a.schema.counts.totalNodes + b.schema.counts.totalNodes,
+      },
+    },
+  };
+}
+
+/**
+ * The single per-namespace-paired relational verify shared by the migration
+ * planner and the family schema verify — there is exactly one such operation.
+ *
+ * Each contract namespace is paired to the introspected namespace node holding
+ * the same DDL schema, then `verifySqlSchema` checks that namespace's tables
+ * against the matching actual node (a contract table under `auth` is only ever
+ * looked up in the `auth` actual node, so a multi-schema database no longer
+ * reports tables in other schemas as missing). The full contract is passed every
+ * time — `restrictToNamespaceIds` scopes only which tables are checked, so
+ * cross-namespace value-set / control-policy resolution is unaffected.
+ *
+ * The DDL schema of each contract namespace is read from a single-namespace
+ * expected projection (`buildExpectedSchema`), which both callers already build
+ * the same way. Empty contract namespaces verify nothing and are skipped.
+ * Single-schema (one namespace) and SQLite's flat schema are one pairing —
+ * byte-identical to the prior per-node verify.
+ */
+export function verifySqlSchemaTree(options: {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly buildExpectedSchema: (contract: Contract<SqlStorage>) => SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly typeMetadataRegistry: ReadonlyMap<string, { nativeType?: string }>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  readonly normalizeDefault?: DefaultNormalizer;
+  readonly normalizeNativeType?: NativeTypeNormalizer;
+}): VerifyDatabaseSchemaResult {
+  const baseOptions = {
+    contract: options.contract,
+    strict: options.strict,
+    typeMetadataRegistry: options.typeMetadataRegistry,
+    frameworkComponents: options.frameworkComponents,
+    ...ifDefined('normalizeDefault', options.normalizeDefault),
+    ...ifDefined('normalizeNativeType', options.normalizeNativeType),
+  };
+
+  const actualNodes = namespaceSchemaNodes(options.actualSchema);
+  const actualByName = new Map<string, SqlSchemaIR>();
+  for (const node of actualNodes) {
+    const name = namespaceSchemaName(node);
+    if (name !== undefined) actualByName.set(name, node);
+  }
+  // A flat actual schema (SQLite) has no named namespaces — it is the sole node.
+  const soleFlatActual = actualByName.size === 0 ? actualNodes[0] : undefined;
+  const emptyNamespace: SqlSchemaIR = { tables: {} };
+
+  let combined: VerifyDatabaseSchemaResult | undefined;
+  for (const namespaceId of Object.keys(options.contract.storage.namespaces)) {
+    const namespace = options.contract.storage.namespaces[namespaceId];
+    if (!namespace || Object.keys(namespace.entries.table ?? {}).length === 0) continue;
+
+    const ddlSchema = namespaceSchemaNodes(
+      options.buildExpectedSchema(scopeContractToNamespace(options.contract, namespaceId)),
+    )
+      .map(namespaceSchemaName)
+      .find((name) => name !== undefined);
+    const actualNode =
+      (ddlSchema !== undefined ? actualByName.get(ddlSchema) : soleFlatActual) ?? emptyNamespace;
+
+    const result = verifySqlSchema({
+      ...baseOptions,
+      schema: actualNode,
+      restrictToNamespaceIds: new Set([namespaceId]),
+    });
+    combined = combined === undefined ? result : mergeVerifyResults(combined, result);
+  }
+
+  return combined ?? verifySqlSchema({ ...baseOptions, schema: emptyNamespace });
+}

package/src/core/{schema-verify → diff}/verify-helpers.ts

@@ -151,6 +151,7 @@ export function verifyPrimaryKey(
   if (!schemaPK) {
     const issue: SchemaIssue = {
       kind: 'primary_key_mismatch',
+      reason: 'not-equal',
       table: tableName,
       namespaceId,
       expected: contractPK.columns.join(', '),
@@ -163,6 +164,7 @@ export function verifyPrimaryKey(
   if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
     const issue: SchemaIssue = {
       kind: 'primary_key_mismatch',
+      reason: 'not-equal',
       table: tableName,
       namespaceId,
       expected: contractPK.columns.join(', '),
@@ -220,6 +222,7 @@ export function verifyForeignKeys(
     if (!matchingFK) {
       const issue: SchemaIssue = {
         kind: 'foreign_key_mismatch',
+        reason: 'not-equal',
         table: tableName,
         namespaceId,
         expected: `${contractFK.source.columns.join(', ')} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(', ')})`,
@@ -250,6 +253,7 @@ export function verifyForeignKeys(
         const combinedActual = actionMismatches.map((m) => m.actual).join(', ');
         const issue: SchemaIssue = {
           kind: 'foreign_key_mismatch',
+          reason: 'not-equal',
           table: tableName,
           namespaceId,
           indexOrConstraint: matchingFK.name ?? `fk(${contractFK.source.columns.join(',')})`,
@@ -309,6 +313,7 @@ export function verifyForeignKeys(
       if (!matchingFK) {
         const issue: SchemaIssue = {
           kind: 'extra_foreign_key',
+          reason: 'not-expected',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaFK.name ?? `fk(${schemaFK.columns.join(',')})`,
@@ -379,6 +384,7 @@ export function verifyUniqueConstraints(
     if (!matchingUnique && !matchingUniqueIndex) {
       const issue: SchemaIssue = {
         kind: 'unique_constraint_mismatch',
+        reason: 'not-equal',
         table: tableName,
         namespaceId,
         expected: contractUnique.columns.join(', '),
@@ -425,6 +431,7 @@ export function verifyUniqueConstraints(
       if (!matchingUnique) {
         const issue: SchemaIssue = {
           kind: 'extra_unique_constraint',
+          reason: 'not-expected',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaUnique.name ?? `unique(${schemaUnique.columns.join(',')})`,
@@ -501,6 +508,7 @@ export function verifyIndexes(
     if (!matchingIndex && !matchingUniqueConstraint) {
       const issue: SchemaIssue = {
         kind: 'index_mismatch',
+        reason: 'not-equal',
         table: tableName,
         namespaceId,
         expected: contractIndex.columns.join(', '),
@@ -552,6 +560,7 @@ export function verifyIndexes(
       if (!matchingIndex) {
         const issue: SchemaIssue = {
           kind: 'extra_index',
+          reason: 'not-expected',
           table: tableName,
           namespaceId,
           indexOrConstraint: schemaIndex.name ?? `idx(${schemaIndex.columns.join(',')})`,
@@ -718,6 +727,7 @@ export function verifyCheckConstraints(
     if (!liveCheck) {
       const issue: SchemaIssue = {
         kind: 'check_missing',
+        reason: 'not-found',
         table: tableName,
         namespaceId,
         indexOrConstraint: contractCheck.name,
@@ -744,6 +754,7 @@ export function verifyCheckConstraints(
     } else if (!valueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {
       const issue: SchemaIssue = {
         kind: 'check_mismatch',
+        reason: 'not-equal',
         table: tableName,
         namespaceId,
         indexOrConstraint: contractCheck.name,
@@ -789,6 +800,7 @@ export function verifyCheckConstraints(
       if (!matchingContract) {
         const issue: SchemaIssue = {
           kind: 'check_removed',
+          reason: 'not-equal',
           table: tableName,
           namespaceId,
           indexOrConstraint: liveCheck.name,

package/src/core/migrations/contract-to-schema-ir.ts

@@ -4,11 +4,10 @@ import {
   type CheckConstraint,
   type ForeignKey,
   type Index,
-  isStorageTable,
   isStorageTypeInstance,
   type SqlStorage,
   type StorageColumn,
-  type StorageTable,
+  StorageTable,
   type StorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
@@ -305,7 +304,7 @@ export function detectDestructiveChanges(
 
     for (const tableName of Object.keys(fromTables)) {
       const toTableRaw = toNs?.entries.table?.[tableName];
-      if (!isStorageTable(toTableRaw)) {
+      if (!StorageTable.is(toTableRaw)) {
         conflicts.push({
           kind: 'tableRemoved',
           summary: `Table "${tableName}" was removed`,
@@ -315,7 +314,7 @@ export function detectDestructiveChanges(
       const toTable = toTableRaw;
 
       const fromTableRaw = fromTables[tableName];
-      if (!isStorageTable(fromTableRaw)) continue;
+      if (!StorageTable.is(fromTableRaw)) continue;
       const fromTable = fromTableRaw;
 
       for (const columnName of Object.keys(fromTable.columns)) {
@@ -360,6 +359,48 @@ export interface ContractToSchemaIROptions {
  *
  * Returns an empty schema IR when `contract` is `null` (new project).
  */
+/**
+ * Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+ * table name within that namespace. Unlike {@link contractToSchemaIR}, which
+ * flattens every namespace's tables into one bare-keyed record (and throws on a
+ * cross-namespace name collision), this scopes the table iteration to one
+ * namespace so the same table name can exist in two schemas.
+ *
+ * The full `storage` is still passed to `convertTable`, so value-set / enum /
+ * type resolution that legitimately spans namespaces is unaffected. Foreign
+ * keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+ * FKs survive per-namespace conversion. The `annotations` block (storage-type
+ * derived) is omitted here — the per-namespace tree consumer reads only the
+ * per-table fields.
+ */
+export function contractNamespaceToSchemaIR(
+  storage: SqlStorage,
+  namespaceId: string,
+  options: ContractToSchemaIROptions,
+): SqlSchemaIR {
+  if (options.annotationNamespace.length === 0) {
+    throw new Error('annotationNamespace must be a non-empty string');
+  }
+  const namespace = storage.namespaces[namespaceId];
+  if (!namespace) {
+    return { tables: {} };
+  }
+  const storageTypes: ResolvedStorageTypes = { ...(storage.types ?? {}) };
+  const tables: Record<string, SqlTableIR> = {};
+  for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
+    StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
+    tables[tableName] = convertTable(
+      tableName,
+      tableDefRaw,
+      storageTypes,
+      options.expandNativeType,
+      options.renderDefault,
+      storage,
+    );
+  }
+  return { tables };
+}
+
 export function contractToSchemaIR(
   contract: Contract<SqlStorage> | null,
   options: ContractToSchemaIROptions,
@@ -373,17 +414,11 @@ export function contractToSchemaIR(
   }
 
   const storage = contract.storage;
-  const storageTypes: ResolvedStorageTypes = {
-    ...((storage.types ?? {}) as ResolvedStorageTypes),
-  };
+  const storageTypes: ResolvedStorageTypes = { ...(storage.types ?? {}) };
   const tables: Record<string, SqlTableIR> = {};
   for (const ns of Object.values(storage.namespaces)) {
     for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
-      if (!isStorageTable(tableDefRaw)) {
-        throw new Error(
-          `contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.entries.table.${tableName}`,
-        );
-      }
+      StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
       const tableDef = tableDefRaw;
       if (tables[tableName] !== undefined) {
         throw new Error(
@@ -420,7 +455,7 @@ function deriveAnnotations(
 ): SqlAnnotations | undefined {
   const storageTypes: Record<string, StorageTypeInstance> = {};
 
-  for (const typeInstance of Object.values((storage.types ?? {}) as ResolvedStorageTypes)) {
+  for (const typeInstance of Object.values(storage.types ?? {})) {
     if (isStorageTypeInstance(typeInstance)) {
       storageTypes[typeInstance.nativeType] = typeInstance;
     }

package/src/core/migrations/field-event-planner.ts

@@ -24,12 +24,7 @@
 
 import type { Contract } from '@prisma-next/contract/types';
 import type { OpFactoryCall } from '@prisma-next/framework-components/control';
-import {
-  isStorageTable,
-  type SqlStorage,
-  type StorageColumn,
-  type StorageTable,
-} from '@prisma-next/sql-contract/types';
+import { type SqlStorage, type StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
 import type { CodecControlHooks, FieldEvent, FieldEventContext } from './types';
 
 export interface PlanFieldEventOperationsOptions {
@@ -93,8 +88,8 @@ export function planFieldEventOperations(
     for (const tableName of tableNames) {
       const priorTableRaw = priorTables?.[tableName];
       const newTableRaw = newTables?.[tableName];
-      const priorTable = isStorageTable(priorTableRaw) ? priorTableRaw : undefined;
-      const newTable = isStorageTable(newTableRaw) ? newTableRaw : undefined;
+      const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : undefined;
+      const newTable = StorageTable.is(newTableRaw) ? newTableRaw : undefined;
       const fieldNames = unionSorted(
         priorTable ? Object.keys(priorTable.columns) : [],
         newTable ? Object.keys(newTable.columns) : [],

package/src/core/migrations/schema-differ.ts

@@ -0,0 +1,40 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  SchemaDiffer,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * Inputs to a SQL target's schema-differ (`diffDatabaseSchema` /
+ * `verifyDatabaseSchema` on the descriptor): the contract (the expected side
+ * derives from it), the introspected actual schema node, and the resolution
+ * context the relational diff needs.
+ */
+export interface DiffDatabaseSchemaInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly typeMetadataRegistry: ReadonlyMap<string, { readonly nativeType?: string }>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+
+/**
+ * The `SchemaDiffer` a SQL target implements: the black-box comparison of the
+ * contract's expected schema against the introspected actual schema, projected
+ * to the two issue lists. How it computes them is private to the target.
+ */
+export type SqlDiffDatabaseSchema = SchemaDiffer<DiffDatabaseSchemaInput>['diff'];
+
+/**
+ * The same combined comparison as {@link SqlDiffDatabaseSchema}, wrapped in the
+ * verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
+ * pass/warn/fail tree the CLI renders. Verify calls this instead of the diff so
+ * the relational walk that produces the tree runs once per verify, not once for
+ * the diff and again for the tree.
+ */
+export type SqlVerifyDatabaseSchema = (
+  input: DiffDatabaseSchemaInput,
+) => VerifyDatabaseSchemaResult;