@prisma-next/family-sql 0.5.0-dev.67 → 0.5.0-dev.69

package/src/core/control-instance.ts

@@ -28,6 +28,7 @@ import {
 } from '@prisma-next/framework-components/control';
 import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
+import { assertDescriptorSelfConsistency } from '@prisma-next/migration-tools/spaces';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import { validateContract as sqlValidateContract } from '@prisma-next/sql-contract/validate';
 import {
@@ -205,6 +206,22 @@ export interface SqlControlFamilyInstance
 
   schemaVerify(options: SchemaVerifyOptions): Promise<VerifyDatabaseSchemaResult>;
 
+  /**
+   * Verify a contract against an already-introspected schema slice.
+   *
+   * Used by the aggregate verifier to invoke per-member verification
+   * with the live schema pre-projected to the member's claimed slice
+   * via `projectSchemaToSpace`. Closes F23 — without per-member
+   * pre-projection, single-contract verifiers see other-space tables
+   * as `extras`.
+   */
+  schemaVerifyAgainstSchema(options: {
+    readonly contract: unknown;
+    readonly schema: SqlSchemaIR;
+    readonly strict: boolean;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): VerifyDatabaseSchemaResult;
+
   sign(options: {
     readonly driver: ControlDriverInstance<'sql', string>;
     readonly contract: unknown;
@@ -233,7 +250,9 @@ function isSqlControlAdapter<TTargetId extends string>(
     'introspect' in value &&
     typeof (value as { introspect: unknown }).introspect === 'function' &&
     'readMarker' in value &&
-    typeof (value as { readMarker: unknown }).readMarker === 'function'
+    typeof (value as { readMarker: unknown }).readMarker === 'function' &&
+    'readAllMarkers' in value &&
+    typeof (value as { readAllMarkers: unknown }).readAllMarkers === 'function'
   );
 }
 
@@ -301,6 +320,29 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     stack.extensionPacks as unknown as readonly (SqlControlExtensionDescriptor<TTargetId> &
       DescriptorWithStorageTypes)[];
 
+  // Descriptor self-consistency check.
+  // Each extension that exposes a `contractSpace` must publish a
+  // `headRef.hash` that matches the canonical hash recomputed from its
+  // `contractJson`. A stale value would silently corrupt every downstream
+  // boundary that trusts `headRef.hash` as the canonical identity (drift
+  // detection, on-disk artefact emission, runner marker writes). Failing
+  // fast at descriptor-load time turns "extension author shipped an
+  // inconsistent descriptor" into an explicit, actionable error
+  // (`MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH`) rather than a confusing
+  // mismatch surfacing several layers downstream.
+  for (const extension of extensions) {
+    if (extension.contractSpace) {
+      const { contractJson, headRef } = extension.contractSpace;
+      assertDescriptorSelfConsistency({
+        extensionId: extension.id,
+        target: contractJson.target,
+        targetFamily: contractJson.targetFamily,
+        storage: contractJson.storage,
+        headRefHash: headRef.hash,
+      });
+    }
+  }
+
   const { codecTypeImports, operationTypeImports, extensionIds } = stack;
 
   const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
@@ -317,7 +359,7 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     const controlAdapter = adapter.create(stack);
     if (!isSqlControlAdapter(controlAdapter)) {
       throw new Error(
-        'Adapter does not implement SqlControlAdapter (missing introspect or readMarker)',
+        'Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)',
       );
     }
     return controlAdapter;
@@ -480,6 +522,27 @@ export function createSqlFamilyInstance<TTargetId extends string>(
         ...ifDefined('normalizeNativeType', controlAdapter.normalizeNativeType),
       });
     },
+    schemaVerifyAgainstSchema(options: {
+      readonly contract: unknown;
+      readonly schema: SqlSchemaIR;
+      readonly strict: boolean;
+      readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+    }): VerifyDatabaseSchemaResult {
+      const contract = sqlValidateContract<Contract<SqlStorage>>(
+        options.contract,
+        emptyCodecLookup,
+      );
+      const controlAdapter = getControlAdapter();
+      return verifySqlSchema({
+        contract,
+        schema: options.schema,
+        strict: options.strict,
+        typeMetadataRegistry,
+        frameworkComponents: options.frameworkComponents,
+        ...ifDefined('normalizeDefault', controlAdapter.normalizeDefault),
+        ...ifDefined('normalizeNativeType', controlAdapter.normalizeNativeType),
+      });
+    },
     async sign(options: {
       readonly driver: ControlDriverInstance<'sql', string>;
       readonly contract: unknown;
@@ -583,6 +646,11 @@ export function createSqlFamilyInstance<TTargetId extends string>(
     }): Promise<ContractMarkerRecord | null> {
       return getControlAdapter().readMarker(options.driver, options.space);
     },
+    async readAllMarkers(options: {
+      readonly driver: ControlDriverInstance<'sql', string>;
+    }): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+      return getControlAdapter().readAllMarkers(options.driver);
+    },
     async introspect(options: {
       readonly driver: ControlDriverInstance<'sql', string>;
       readonly contract?: unknown;

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

@@ -0,0 +1,196 @@
+/**
+ * Codec lifecycle hook planner — runs `onFieldEvent` for every per-field
+ * delta between two contracts and concatenates the returned ops in a
+ * deterministic order.
+ *
+ * Wired by each target's planner (`PostgresMigrationPlanner`,
+ * `SqliteMigrationPlanner`) so codec-emitted ops are inlined alongside
+ * structural DDL in the app-space migration's `ops.json`. Pure, target-
+ * agnostic, and only ever invoked at the app-space emitter; extension-space
+ * planning never reaches this helper.
+ *
+ * Ordering rules:
+ *
+ * - Events are grouped by phase: `'added'` → `'dropped'` → `'altered'`.
+ * - Within each phase, entries are sorted alphabetically by
+ *   `(tableName, fieldName)`.
+ * - The hook's returned ops are appended in the order the hook returned them.
+ *
+ * `'altered'` is suppressed when only `codecId` differs (codec rotation is a
+ * v1 non-goal).
+ */
+
+import type { Contract } from '@prisma-next/contract/types';
+import type { SqlStorage, StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
+import type {
+  CodecControlHooks,
+  FieldEvent,
+  FieldEventContext,
+  SqlMigrationPlanOperation,
+} from './types';
+
+export interface PlanFieldEventOperationsOptions {
+  /**
+   * Prior contract the planner is diffing against. `null` for first emits
+   * (every field is treated as added).
+   */
+  readonly priorContract: Contract<SqlStorage> | null;
+  /**
+   * New contract the user just authored.
+   */
+  readonly newContract: Contract<SqlStorage>;
+  /**
+   * Codec-id keyed map of control hooks, as produced by
+   * {@link import('./assembly').extractCodecControlHooks}. Hooks carry
+   * `unknown` target details after extraction; the caller casts the
+   * helper's returned ops to its target's `SqlMigrationPlanOperation`
+   * specialisation at the integration boundary, mirroring how
+   * `storageTypePlanCallStrategy` lifts `planTypeOperations` results into
+   * `RawSqlCall`.
+   */
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+
+interface FieldEntry {
+  readonly tableName: string;
+  readonly fieldName: string;
+  readonly priorTable: StorageTable | undefined;
+  readonly newTable: StorageTable | undefined;
+  readonly priorField: StorageColumn | undefined;
+  readonly newField: StorageColumn | undefined;
+}
+
+export function planFieldEventOperations(
+  options: PlanFieldEventOperationsOptions,
+): readonly SqlMigrationPlanOperation<unknown>[] {
+  const priorTables = options.priorContract?.storage.tables ?? {};
+  const newTables = options.newContract.storage.tables;
+
+  const added: FieldEntry[] = [];
+  const dropped: FieldEntry[] = [];
+  const altered: FieldEntry[] = [];
+
+  const tableNames = unionSorted(Object.keys(priorTables), Object.keys(newTables));
+  for (const tableName of tableNames) {
+    const priorTable = priorTables[tableName];
+    const newTable = newTables[tableName];
+    const fieldNames = unionSorted(
+      priorTable ? Object.keys(priorTable.columns) : [],
+      newTable ? Object.keys(newTable.columns) : [],
+    );
+    for (const fieldName of fieldNames) {
+      const priorField = priorTable?.columns[fieldName];
+      const newField = newTable?.columns[fieldName];
+      const entry: FieldEntry = {
+        tableName,
+        fieldName,
+        priorTable,
+        newTable,
+        priorField,
+        newField,
+      };
+      if (priorField === undefined && newField !== undefined) {
+        added.push(entry);
+      } else if (priorField !== undefined && newField === undefined) {
+        dropped.push(entry);
+      } else if (priorField !== undefined && newField !== undefined) {
+        if (isAlteration(priorField, newField)) altered.push(entry);
+      }
+    }
+  }
+
+  const ops: SqlMigrationPlanOperation<unknown>[] = [];
+  appendOps('added', added, options.codecHooks, ops, (e) => e.newField?.codecId);
+  appendOps('dropped', dropped, options.codecHooks, ops, (e) => e.priorField?.codecId);
+  appendOps('altered', altered, options.codecHooks, ops, (e) => e.newField?.codecId);
+  return ops;
+}
+
+function appendOps(
+  event: FieldEvent,
+  entries: readonly FieldEntry[],
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
+  ops: SqlMigrationPlanOperation<unknown>[],
+  pickCodecId: (entry: FieldEntry) => string | undefined,
+): void {
+  for (const entry of entries) {
+    const codecId = pickCodecId(entry);
+    if (codecId === undefined) continue;
+    const hook = codecHooks.get(codecId);
+    if (!hook?.onFieldEvent) continue;
+    const ctx = buildContext(event, entry);
+    const emitted = hook.onFieldEvent(event, ctx);
+    for (const op of emitted) ops.push(op);
+  }
+}
+
+/**
+ * The context's prior/new sides are scoped to the event:
+ *
+ * - `'added'`   — only `newTable` / `newField` populated.
+ * - `'dropped'` — only `priorTable` / `priorField` populated.
+ * - `'altered'` — both sides populated.
+ */
+function buildContext(event: FieldEvent, entry: FieldEntry): FieldEventContext {
+  const base = { tableName: entry.tableName, fieldName: entry.fieldName };
+  if (event === 'added') {
+    return {
+      ...base,
+      ...(entry.newTable !== undefined ? { newTable: entry.newTable } : {}),
+      ...(entry.newField !== undefined ? { newField: entry.newField } : {}),
+    };
+  }
+  if (event === 'dropped') {
+    return {
+      ...base,
+      ...(entry.priorTable !== undefined ? { priorTable: entry.priorTable } : {}),
+      ...(entry.priorField !== undefined ? { priorField: entry.priorField } : {}),
+    };
+  }
+  return {
+    ...base,
+    ...(entry.priorTable !== undefined ? { priorTable: entry.priorTable } : {}),
+    ...(entry.newTable !== undefined ? { newTable: entry.newTable } : {}),
+    ...(entry.priorField !== undefined ? { priorField: entry.priorField } : {}),
+    ...(entry.newField !== undefined ? { newField: entry.newField } : {}),
+  };
+}
+
+/**
+ * `'altered'` predicate. Returns `false` whenever `codecId` differs —
+ * any codec change suppresses the `altered` event entirely, including
+ * cases where another property also differs in the same diff. Codec
+ * rotation is a v1 non-goal (project spec § Non-goals); avoiding the
+ * mixed event keeps the migration semantics for codec changes explicit
+ * (out of scope) rather than smuggling them through as `altered`.
+ *
+ * For non-`codecId` diffs, returns `true` iff any other column property
+ * differs.
+ */
+function isAlteration(prior: StorageColumn, current: StorageColumn): boolean {
+  if (prior.codecId !== current.codecId) return false;
+  return !sameStorageColumn(prior, current);
+}
+
+function sameStorageColumn(a: StorageColumn, b: StorageColumn): boolean {
+  if (a === b) return true;
+  if (a.nativeType !== b.nativeType) return false;
+  if (a.nullable !== b.nullable) return false;
+  if (a.typeRef !== b.typeRef) return false;
+  if (!sameJson(a.typeParams, b.typeParams)) return false;
+  if (!sameJson(a.default, b.default)) return false;
+  return true;
+}
+
+function sameJson(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a === undefined || b === undefined) return false;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function unionSorted(a: readonly string[], b: readonly string[]): readonly string[] {
+  const set = new Set<string>();
+  for (const name of a) set.add(name);
+  for (const name of b) set.add(name);
+  return [...set].sort((x, y) => (x < y ? -1 : x > y ? 1 : 0));
+}

package/src/core/migrations/types.ts

@@ -18,7 +18,12 @@ import type {
   OperationContext,
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
-import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import type {
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstance,
+} from '@prisma-next/sql-contract/types';
 import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import type { Result } from '@prisma-next/utils/result';
@@ -83,6 +88,41 @@ export interface ResolveIdentityValueInput {
   readonly typeParams?: Record<string, unknown>;
 }
 
+/**
+ * Per-field lifecycle event a codec hook can react to.
+ *
+ * Fired during app-space migration emission as the SQL family diffs the
+ * prior contract against the new contract.
+ *
+ * - `'added'`     — the field is present in the new contract but not the prior.
+ * - `'dropped'`   — the field is present in the prior contract but not the new.
+ * - `'altered'`   — the field is present in both and any property other than
+ *                   `codecId` differs. Codec-id changes are a v1 non-goal:
+ *                   when only `codecId` differs, no `'altered'` event fires.
+ */
+export type FieldEvent = 'added' | 'dropped' | 'altered';
+
+/**
+ * Context passed to {@link CodecControlHooks.onFieldEvent}.
+ *
+ * `tableName` and `fieldName` are always populated; `priorTable` /
+ * `priorField` carry the prior contract's view of the table and column
+ * (present for `'dropped'` and `'altered'`); `newTable` / `newField`
+ * carry the new contract's view (present for `'added'` and `'altered'`).
+ *
+ * The hook only ever receives app-space contract IR — extension-space
+ * fields are scoped out by the API: the hook is wired at the
+ * application emitter only.
+ */
+export interface FieldEventContext {
+  readonly tableName: string;
+  readonly fieldName: string;
+  readonly priorTable?: StorageTable;
+  readonly newTable?: StorageTable;
+  readonly priorField?: StorageColumn;
+  readonly newField?: StorageColumn;
+}
+
 export interface CodecControlHooks<TTargetDetails = unknown> {
   planTypeOperations?: (options: {
     readonly typeName: string;
@@ -123,6 +163,21 @@ export interface CodecControlHooks<TTargetDetails = unknown> {
    * - undefined: no opinion; planner may use built-in fallbacks
    */
   resolveIdentityValue?: (input: ResolveIdentityValueInput) => string | null | undefined;
+  /**
+   * Reacts to per-field added / dropped / altered events as the app-space
+   * emitter diffs the prior contract against the new contract. Returned
+   * ops are inlined into the app-space migration's `ops.json` alongside
+   * the user's structural ops.
+   *
+   * Synchronous. Each returned op must carry its own `invariantId`. Hooks
+   * are dispatched per `(table, field)` based on the field's `codecId`
+   * (the new field's codec for `'added'` / `'altered'`; the prior field's
+   * codec for `'dropped'`).
+   */
+  onFieldEvent?: (
+    event: FieldEvent,
+    ctx: FieldEventContext,
+  ) => readonly SqlMigrationPlanOperation<TTargetDetails>[];
 }
 
 export interface SqlControlExtensionDescriptor<TTargetId extends string>
@@ -320,6 +375,14 @@ export interface SqlMigrationRunnerExecuteCallbacks<TTargetDetails> {
 export interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
   readonly plan: SqlMigrationPlan<TTargetDetails>;
   readonly driver: ControlDriverInstance<'sql', string>;
+  /**
+   * Logical contract space this plan applies to. When omitted the
+   * runner derives the space from {@link SqlMigrationPlan.spaceId};
+   * when supplied, the runner asserts it matches `plan.spaceId` so a
+   * caller cannot accidentally write the marker row for a different
+   * space than the plan was produced for.
+   */
+  readonly space?: string;
   /**
    * Destination contract IR.
    * Must correspond to `plan.destination` and is used for schema verification and marker/ledger writes.
@@ -371,11 +434,64 @@ export type SqlMigrationRunnerResult = Result<
 >;
 
 export interface SqlMigrationRunner<TTargetDetails> {
+  /**
+   * Apply a single migration plan, opening and managing its own
+   * transaction (and any target-specific connection-level setup, e.g.
+   * SQLite's `PRAGMA foreign_keys` toggle). Existing single-space
+   * callers route through here.
+   */
   execute(
     options: SqlMigrationRunnerExecuteOptions<TTargetDetails>,
   ): Promise<SqlMigrationRunnerResult>;
+
+  /**
+   * Apply a single migration plan against an already-open connection
+   * **without** opening a transaction. The caller is responsible for
+   * wrapping the call (and any siblings) in `BEGIN` / `COMMIT` /
+   * `ROLLBACK`. Used by the per-space runner wiring to fan out across
+   * contract spaces inside one outer transaction so a mid-apply
+   * failure rolls back every space's writes.
+   *
+   * Idempotent control-table setup (`prisma_contract.*`) and marker
+   * writes use `options.space` to address the per-space marker row.
+   */
+  executeOnConnection(
+    options: SqlMigrationRunnerExecuteOptions<TTargetDetails>,
+  ): Promise<SqlMigrationRunnerResult>;
+
+  /**
+   * Apply per-space plans across multiple contract spaces inside a
+   * single outer transaction. The caller orders the input list
+   * (typically via the aggregate planner's `applyOrder`: extensions
+   * alphabetical, then app); the runner is responsible for opening
+   * / committing the outer
+   * transaction (and any target-specific connection-level setup such
+   * as the SQLite FK pragma toggle). A failure on any space rolls
+   * back every space's writes.
+   *
+   * Each space's `SqlMigrationRunnerExecuteOptions` must reference the
+   * same `driver` (the connection the outer transaction is open on).
+   * Per-space marker writes use `options.space` to address the row.
+   */
+  executeAcrossSpaces(options: {
+    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly perSpaceOptions: ReadonlyArray<SqlMigrationRunnerExecuteOptions<TTargetDetails>>;
+  }): Promise<MultiSpaceRunnerResult>;
+}
+
+export interface MultiSpaceRunnerSuccessValue {
+  readonly perSpaceResults: ReadonlyArray<{
+    readonly space: string;
+    readonly value: SqlMigrationRunnerSuccessValue;
+  }>;
+}
+
+export interface MultiSpaceRunnerFailure extends SqlMigrationRunnerFailure {
+  readonly failingSpace: string;
 }
 
+export type MultiSpaceRunnerResult = Result<MultiSpaceRunnerSuccessValue, MultiSpaceRunnerFailure>;
+
 export interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails>
   extends MigratableTargetDescriptor<'sql', TTargetId, SqlControlFamilyInstance> {
   readonly queryOperations?: () => ReadonlyArray<SqlOperationDescriptor>;

package/src/exports/control.ts

@@ -24,6 +24,8 @@ export {
   contractToSchemaIR,
   detectDestructiveChanges,
 } from '../core/migrations/contract-to-schema-ir';
+export type { PlanFieldEventOperationsOptions } from '../core/migrations/field-event-planner';
+export { planFieldEventOperations } from '../core/migrations/field-event-planner';
 export {
   createMigrationPlan,
   plannerFailure,
@@ -38,6 +40,11 @@ export type {
   ComponentDatabaseDependency,
   CreateSqlMigrationPlanOptions,
   ExpandNativeTypeInput,
+  FieldEvent,
+  FieldEventContext,
+  MultiSpaceRunnerFailure,
+  MultiSpaceRunnerResult,
+  MultiSpaceRunnerSuccessValue,
   ResolveIdentityValueInput,
   SqlControlAdapterDescriptor,
   SqlControlExtensionDescriptor,

package/dist/types-Ds4dJyTI.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-Ds4dJyTI.d.mts","names":[],"sources":["../src/core/control-instance.ts","../src/core/migrations/types.ts"],"mappings":"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"}