@prisma-next/family-sql 0.8.0 → 0.9.0-dev.2

package/README.md

@@ -11,7 +11,7 @@ Provides the SQL family descriptor (`ControlFamilyDescriptor`) that includes:
 ## Responsibilities
 
 - **Family Descriptor Export**: Exports the SQL `ControlFamilyDescriptor` for use in CLI configuration files
-- **Family Instance Creation**: Creates `SqlFamilyInstance` objects that implement control-plane domain actions (`verify`, `schemaVerify`, `introspect`, `emitContract`, `validateContract`)
+- **Family Instance Creation**: Creates `SqlFamilyInstance` objects that implement control-plane domain actions (`verify`, `schemaVerify`, `introspect`, `emitContract`, `deserializeContract`)
 - **Planner & Runner SPI**: Owns the `MigrationPlanner` / `MigrationRunner` interfaces plus the `SqlControlTargetDescriptor` helper so targets can expose planners and runners (e.g., Postgres init planner/runner)
 - **Family Hook Integration**: Integrates the SQL target family hook (`sqlEmission`) from `@prisma-next/sql-contract-emitter`
 - **Control Plane Entry Point**: Serves as the control plane entry point for the SQL family, enabling the CLI to select the family hook and create family instances
@@ -51,7 +51,7 @@ const stack = createControlStack({
 const familyInstance = sql.create(stack);
 
 // Use instance methods for domain actions
-const contract = familyInstance.validateContract(contractJson);
+const contract = familyInstance.deserializeContract(contractJson);
 const verifyResult = await familyInstance.verify({ driver, contract, ... });
 
 // Targets that implement SqlControlTargetDescriptor can build planners
@@ -96,7 +96,7 @@ The framework CLI uses this descriptor to:
 1. Create family instances for control-plane operations (via `create()`)
 
 Family instances implement domain actions:
-- **`validateContract(contractJson)`**: Validates and normalizes contract, returns `Contract` without mappings
+- **`deserializeContract(contractJson)`**: Validates and normalizes contract, returns `Contract` without mappings
 - **`verify()`**: Verifies database marker against contract (compares target, storageHash, profileHash)
 - **`schemaVerify()`**: Verifies database schema against contract (compares contract requirements vs live schema)
 - **`introspect()`**: Introspects database schema and returns `SqlSchemaIR`
@@ -108,7 +108,7 @@ The descriptor is "pure data + factory" - it only provides the hook and factory
 ## Package Structure
 
 - **`src/core/control-descriptor.ts`**: `SqlFamilyDescriptor` class implementing `ControlFamilyDescriptor` interface (pure data + factory)
-- **`src/core/control-instance.ts`**: `createSqlFamilyInstance` function that creates `SqlFamilyInstance` with domain action methods (`validateContract`, `verify`, `schemaVerify`, `introspect`, `toSchemaView`, `emitContract`). Contains `convertOperationManifest` function used internally by instance creation and test utilities in the same package.
+- **`src/core/control-instance.ts`**: `createSqlFamilyInstance` function that creates `SqlFamilyInstance` with domain action methods (`deserializeContract`, `verify`, `schemaVerify`, `introspect`, `toSchemaView`, `emitContract`). Contains `convertOperationManifest` function used internally by instance creation and test utilities in the same package.
 - **`src/core/assembly.ts`**: Assembly helpers for extracting type imports, collecting codec-owned storage type control hooks, and composing mutation-default registries with duplicate detection.
 - **`src/core/verify.ts`**: Verification helpers (`parseContractMarkerRow`, `collectSupportedCodecTypeIds`)
 - **`src/core/control-adapter.ts`**: SQL control adapter interface (`SqlControlAdapter`) for control-plane operations
@@ -140,7 +140,7 @@ The runner returns structured errors with the following codes:
 
 - **`@prisma-next/framework-components`**: Control plane types via `./control` (`ControlFamilyDescriptor`, `ControlTargetDescriptor`, `ControlAdapterDescriptor`, `ControlDriverDescriptor`, `ControlExtensionDescriptor`, `ControlDriverInstance`, etc.)
 - **`@prisma-next/sql-contract-emitter`**: SQL target family hook (`sqlEmission`)
-- **`@prisma-next/sql-contract`**: SQL contract types plus validation (`validateContract`)
+- **`@prisma-next/sql-contract`**: SQL contract types plus validation primitives (`validateSqlContractFully`, consumed by the family serializer base)
 - **`@prisma-next/sql-operations`**: SQL operation registry types (`SqlOperationEntry`, `SqlOperationRegistry`)
 
 **Dependents:**

package/dist/control-adapter.d.mts

@@ -1,5 +1,6 @@
-import { n as NativeTypeNormalizer, t as DefaultNormalizer } from "./verify-sql-schema-CPHiuYHR.mjs";
+import { n as NativeTypeNormalizer, t as DefaultNormalizer } from "./verify-sql-schema-Bfvz07Ik.mjs";
 import { ControlAdapterInstance, ControlDriverInstance, ControlStack } from "@prisma-next/framework-components/control";
+import { PostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { ContractMarkerRecord } from "@prisma-next/contract/types";
 import { AnyQueryAst, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
@@ -61,6 +62,15 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
    * before comparison with contract native types during schema verification.
    */
   readonly normalizeNativeType?: NativeTypeNormalizer;
+  /**
+   * Optional bridging adapter for resolving the existing values of a
+   * native enum type from the introspected schema IR. Targets supply
+   * this so the family-level schema verifier can walk
+   * `PostgresEnumStorageEntry` entries natively without needing to
+   * know the target-specific `schema.annotations` shape
+   * (e.g. `schema.annotations.pg.storageTypes`).
+   */
+  readonly resolveExistingEnumValues?: (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry) => readonly string[] | null;
   /**
    * Lower a SQL query AST into a target-flavored `{ sql, params }` payload.
    *

package/dist/control-adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control-adapter.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;AAoBA;;;;UAAiB,iBAAA,0CACP,sBAAA,QAA8B,OAAA;EAiB5B;;;;;;;;;;;;;;;EADV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAsDgD;;;;;;;EA7C3D,cAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,IACpC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EAbrB;;;;;;;;;;;;EA2BV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAJX;;;;;EAAA,SAWS,gBAAA,GAAmB,iBAAA;EAPzB;;;;;EAAA,SAcM,mBAAA,GAAsB,oBAAA;EAW/B;;;;;;;;AASF;EATE,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAS5C,2BAAA;EAOf;;;;;;EAAA,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}
+{"version":3,"file":"control-adapter.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;AAqBA;;;;UAAiB,iBAAA,0CACP,sBAAA,QAA8B,OAAA;EAiB5B;;;;;;;;;;;;;;;EADV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAmEA;;;;;;;EA1DX,cAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,IACpC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EA9BO;;;;;;;;;;;;EA4CtC,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAlBA;;;;;EAAA,SAyBF,gBAAA,GAAmB,iBAAA;EAT1B;;;;;EAAA,SAgBO,mBAAA,GAAsB,oBAAA;EAAtB;;;;;;;;EAAA,SAUA,yBAAA,IACP,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA;EAYN;;;;;;AASR;;;EATE,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAS5C,2BAAA;EAOmB;;;;;;EAAlC,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/control.d.mts

@@ -1,10 +1,10 @@
-import { A as SqlPlannerConflictKind, C as SqlMigrationRunnerExecuteCallbacks, D as SqlMigrationRunnerSuccessValue, E as SqlMigrationRunnerResult, F as StorageTypePlanResult, I as SchemaVerifyOptions, L as SqlControlFamilyInstance, M as SqlPlannerFailureResult, N as SqlPlannerResult, O as SqlPlanTargetDetails, P as SqlPlannerSuccessResult, S as SqlMigrationRunnerErrorCode, T as SqlMigrationRunnerFailure, _ as SqlMigrationPlanOperationStep, a as FieldEvent, b as SqlMigrationPlannerPlanOptions, c as MultiSpaceRunnerResult, d as SqlControlAdapterDescriptor, f as SqlControlExtensionDescriptor, g as SqlMigrationPlanOperation, h as SqlMigrationPlanContractInfo, i as ExpandNativeTypeInput, j as SqlPlannerConflictLocation, k as SqlPlannerConflict, l as MultiSpaceRunnerSuccessValue, m as SqlMigrationPlan, n as CodecControlHooks, o as FieldEventContext, p as SqlControlTargetDescriptor, r as CreateSqlMigrationPlanOptions, s as MultiSpaceRunnerFailure, t as AnyRecord, u as ResolveIdentityValueInput, v as SqlMigrationPlanOperationTarget, w as SqlMigrationRunnerExecuteOptions, x as SqlMigrationRunner, y as SqlMigrationPlanner } from "./types-Da-eOg20.mjs";
+import { A as SqlPlannerConflictKind, C as SqlMigrationRunnerExecuteCallbacks, D as SqlMigrationRunnerSuccessValue, E as SqlMigrationRunnerResult, F as StorageTypePlanResult, I as SqlControlFamilyInstance, M as SqlPlannerFailureResult, N as SqlPlannerResult, O as SqlPlanTargetDetails, P as SqlPlannerSuccessResult, S as SqlMigrationRunnerErrorCode, T as SqlMigrationRunnerFailure, _ as SqlMigrationPlanOperationStep, a as FieldEvent, b as SqlMigrationPlannerPlanOptions, c as MultiSpaceRunnerResult, d as SqlControlAdapterDescriptor, f as SqlControlExtensionDescriptor, g as SqlMigrationPlanOperation, h as SqlMigrationPlanContractInfo, i as ExpandNativeTypeInput, j as SqlPlannerConflictLocation, k as SqlPlannerConflict, l as MultiSpaceRunnerSuccessValue, m as SqlMigrationPlan, n as CodecControlHooks, o as FieldEventContext, p as SqlControlTargetDescriptor, r as CreateSqlMigrationPlanOptions, s as MultiSpaceRunnerFailure, t as AnyRecord, u as ResolveIdentityValueInput, v as SqlMigrationPlanOperationTarget, w as SqlMigrationRunnerExecuteOptions, x as SqlMigrationRunner, y as SqlMigrationPlanner } from "./types-DMINfGUO.mjs";
 import { ControlFamilyDescriptor, ControlStack, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan, MigrationPlanOperation, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MutationDefaultGeneratorDescriptor, OpFactoryCall, TargetMigrationsCapability, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
+import { SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
 import { NotOk, Ok } from "@prisma-next/utils/result";
 import { ColumnDefault, Contract } from "@prisma-next/contract/types";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-import { SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
 import { EmissionSpi } from "@prisma-next/framework-components/emission";
 
 //#region src/core/control-descriptor.d.ts
@@ -411,5 +411,5 @@ declare function temporalAuthoringPresets<const CodecId extends string, const Na
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { type CodecControlHooks, type ContractToSchemaIROptions, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type MultiSpaceRunnerFailure, type MultiSpaceRunnerResult, type MultiSpaceRunnerSuccessValue, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, type SchemaVerifyOptions, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type StorageTypePlanResult, type TargetMigrationsCapability, assembleAuthoringContributions, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { type CodecControlHooks, type ContractToSchemaIROptions, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type MultiSpaceRunnerFailure, type MultiSpaceRunnerResult, type MultiSpaceRunnerSuccessValue, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type StorageTypePlanResult, type TargetMigrationsCapability, assembleAuthoringContributions, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/field-event-planner.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;;ADdf;;;;KEuBY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBAuI3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UAiCK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;AAAA;;;;;;;;;;;;;;;iBAiBX,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UCrNc,+BAAA;EHZI;;;;EAAA,SGiBV,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAY3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,aAAA;;;iBCiCI,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCyBlB,QAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/field-event-planner.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;;ADdf;;;;KE2BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBA+J3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UAiCK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;AAAA;;;;;;;;;;;;;;;iBAiBX,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UCjPc,+BAAA;EHZI;;;;EAAA,SGiBV,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAY3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,aAAA;;;iBCiCI,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCyBlB,QAAA"}

package/dist/control.mjs

@@ -1,15 +1,15 @@
 import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-F4JpCJl7.mjs";
-import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-DV-UsTG9.mjs";
-import { t as collectSupportedCodecTypeIds } from "./verify-pRYxnpiG.mjs";
-import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-BWp8S2sa.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-qUQCnP-k.mjs";
+import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-BXw7yx6L.mjs";
+import { t as collectSupportedCodecTypeIds } from "./verify-Crewz6hG.mjs";
+import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-r7BP5n3l.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
-import { emptyCodecLookup } from "@prisma-next/framework-components/codec";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
-import { validateContract } from "@prisma-next/sql-contract/validate";
 import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -1097,18 +1097,22 @@ function createSqlFamilyInstance(stack) {
 		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)");
 		return controlAdapter;
 	};
+	const targetSerializer = target.contractSerializer;
+	const deserializeWithTargetSerializer = (contractJson) => {
+		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
+	};
 	return {
 		familyId: "sql",
 		codecTypeImports,
 		extensionIds,
 		typeMetadataRegistry,
-		validateContract(contractJson) {
-			return validateContract(contractJson, emptyCodecLookup);
+		deserializeContract(contractJson) {
+			return deserializeWithTargetSerializer(contractJson);
 		},
 		async verify(verifyOptions) {
 			const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = verifyOptions;
 			const startTime = Date.now();
-			const contract = validateContract(rawContract, emptyCodecLookup);
+			const contract = deserializeWithTargetSerializer(rawContract);
 			const contractStorageHash = contract.storage.storageHash;
 			const contractProfileHash = contract.profileHash;
 			const contractTarget = contract.target;
@@ -1196,23 +1200,8 @@ function createSqlFamilyInstance(stack) {
 				...configPath ? { configPath } : {}
 			});
 		},
-		async schemaVerify(options) {
-			const { driver, contract: contractInput, strict, context, frameworkComponents } = options;
-			const contract = validateContract(contractInput, emptyCodecLookup);
-			const controlAdapter = getControlAdapter();
-			return verifySqlSchema({
-				contract,
-				schema: await controlAdapter.introspect(driver, contractInput),
-				strict,
-				...ifDefined("context", context),
-				typeMetadataRegistry,
-				frameworkComponents,
-				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
-				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
-			});
-		},
-		schemaVerifyAgainstSchema(options) {
-			const contract = validateContract(options.contract, emptyCodecLookup);
+		verifySchema(options) {
+			const contract = deserializeWithTargetSerializer(options.contract);
 			const controlAdapter = getControlAdapter();
 			return verifySqlSchema({
 				contract,
@@ -1221,13 +1210,14 @@ function createSqlFamilyInstance(stack) {
 				typeMetadataRegistry,
 				frameworkComponents: options.frameworkComponents,
 				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
-				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
+				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType),
+				...ifDefined("resolveExistingEnumValues", controlAdapter.resolveExistingEnumValues)
 			});
 		},
 		async sign(options) {
 			const { driver, contract: contractInput, contractPath, configPath } = options;
 			const startTime = Date.now();
-			const contract = validateContract(contractInput, emptyCodecLookup);
+			const contract = deserializeWithTargetSerializer(contractInput);
 			const contractStorageHash = contract.storage.storageHash;
 			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
 			const contractTarget = contract.target;
@@ -1436,11 +1426,17 @@ function resolveColumnTypeMetadata(column, storageTypes) {
 	if (!column.typeRef) return column;
 	const referenced = storageTypes[column.typeRef];
 	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
-	return {
+	if (isPostgresEnumStorageEntry(referenced)) return {
+		codecId: referenced.codecId,
+		nativeType: referenced.nativeType,
+		typeParams: { values: referenced.values }
+	};
+	if (isStorageTypeInstance(referenced)) return {
 		codecId: referenced.codecId,
 		nativeType: referenced.nativeType,
 		typeParams: referenced.typeParams
 	};
+	throw new Error(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected codec-instance or postgres-enum.`);
 }
 function convertUnique(unique) {
 	return {
@@ -1550,9 +1546,20 @@ function contractToSchemaIR(contract, options) {
 	};
 }
 function deriveAnnotations(storage, annotationNamespace) {
-	if (!storage.types || Object.keys(storage.types).length === 0) return void 0;
+	const types = storage.types;
+	if (!types || Object.keys(types).length === 0) return void 0;
 	const byNativeType = {};
-	for (const typeInstance of Object.values(storage.types)) byNativeType[typeInstance.nativeType] = typeInstance;
+	for (const typeInstance of Object.values(types)) {
+		if (isPostgresEnumStorageEntry(typeInstance)) {
+			byNativeType[typeInstance.nativeType] = toStorageTypeInstance({
+				codecId: typeInstance.codecId,
+				nativeType: typeInstance.nativeType,
+				typeParams: { values: typeInstance.values }
+			});
+			continue;
+		}
+		if (isStorageTypeInstance(typeInstance)) byNativeType[typeInstance.nativeType] = typeInstance;
+	}
 	return { [annotationNamespace]: { storageTypes: byNativeType } };
 }
 //#endregion