@prisma-next/sql-contract-ts 0.3.0-dev.135 → 0.3.0-dev.146

package/src/{semantic-contract.ts → contract-definition.ts}

@@ -1,38 +1,39 @@
-import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/contract/framework-components';
 import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
 import type {
   ColumnTypeDescriptor,
   ForeignKeyDefaultsState,
 } from '@prisma-next/contract-authoring';
+import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { ReferentialAction, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 
-export interface SqlSemanticFieldNode {
+export interface FieldNode {
   readonly fieldName: string;
   readonly columnName: string;
   readonly descriptor: ColumnTypeDescriptor;
   readonly nullable: boolean;
   readonly default?: ColumnDefault;
   readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly many?: boolean;
 }
 
-export interface SqlSemanticPrimaryKeyNode {
+export interface PrimaryKeyNode {
   readonly columns: readonly string[];
   readonly name?: string;
 }
 
-export interface SqlSemanticUniqueConstraintNode {
+export interface UniqueConstraintNode {
   readonly columns: readonly string[];
   readonly name?: string;
 }
 
-export interface SqlSemanticIndexNode {
+export interface IndexNode {
   readonly columns: readonly string[];
   readonly name?: string;
   readonly using?: string;
   readonly config?: Record<string, unknown>;
 }
 
-export interface SqlSemanticForeignKeyNode {
+export interface ForeignKeyNode {
   readonly columns: readonly string[];
   readonly references: {
     readonly model: string;
@@ -46,7 +47,7 @@ export interface SqlSemanticForeignKeyNode {
   readonly index?: boolean;
 }
 
-export interface SqlSemanticRelationNode {
+export interface RelationNode {
   readonly fieldName: string;
   readonly toModel: string;
   readonly toTable: string;
@@ -64,23 +65,39 @@ export interface SqlSemanticRelationNode {
   };
 }
 
-export interface SqlSemanticModelNode {
+export interface ValueObjectFieldNode {
+  readonly fieldName: string;
+  readonly columnName: string;
+  readonly valueObjectName: string;
+  readonly nullable: boolean;
+  readonly default?: ColumnDefault;
+  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly many?: boolean;
+}
+
+export interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+}
+
+export interface ModelNode {
   readonly modelName: string;
   readonly tableName: string;
-  readonly fields: readonly SqlSemanticFieldNode[];
-  readonly id?: SqlSemanticPrimaryKeyNode;
-  readonly uniques?: readonly SqlSemanticUniqueConstraintNode[];
-  readonly indexes?: readonly SqlSemanticIndexNode[];
-  readonly foreignKeys?: readonly SqlSemanticForeignKeyNode[];
-  readonly relations?: readonly SqlSemanticRelationNode[];
+  readonly fields: readonly (FieldNode | ValueObjectFieldNode)[];
+  readonly id?: PrimaryKeyNode;
+  readonly uniques?: readonly UniqueConstraintNode[];
+  readonly indexes?: readonly IndexNode[];
+  readonly foreignKeys?: readonly ForeignKeyNode[];
+  readonly relations?: readonly RelationNode[];
 }
 
-export interface SqlSemanticContractDefinition {
+export interface ContractDefinition {
   readonly target: TargetPackRef<'sql', string>;
   readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly capabilities?: Record<string, Record<string, boolean>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
   readonly storageTypes?: Record<string, StorageTypeInstance>;
-  readonly models: readonly SqlSemanticModelNode[];
+  readonly models: readonly ModelNode[];
+  readonly valueObjects?: readonly ValueObjectNode[];
 }

package/src/{staged-contract-dsl.ts → contract-dsl.ts}

@@ -1,10 +1,3 @@
-import type {
-  AuthoringFieldPresetDescriptor,
-  ExtensionPackRef,
-  FamilyPackRef,
-  TargetPackRef,
-} from '@prisma-next/contract/framework-components';
-import { instantiateAuthoringFieldPreset } from '@prisma-next/contract/framework-components';
 import type {
   ColumnDefault,
   ColumnDefaultLiteralInputValue,
@@ -14,6 +7,14 @@ import type {
   ColumnTypeDescriptor,
   ForeignKeyDefaultsState,
 } from '@prisma-next/contract-authoring';
+import type { AuthoringFieldPresetDescriptor } from '@prisma-next/framework-components/authoring';
+import { instantiateAuthoringFieldPreset } from '@prisma-next/framework-components/authoring';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type {
+  ExtensionPackRef,
+  FamilyPackRef,
+  TargetPackRef,
+} from '@prisma-next/framework-components/components';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { NamedConstraintSpec } from './authoring-type-utils';
@@ -952,7 +953,7 @@ function findDuplicateRelationName(
   );
 }
 
-export class StagedModelBuilder<
+export class ContractModelBuilder<
   ModelName extends string | undefined,
   Fields extends Record<string, ScalarFieldBuilder>,
   Relations extends Record<string, AnyRelationBuilder> = Record<never, never>,
@@ -982,7 +983,7 @@ export class StagedModelBuilder<
 
   ref<FieldName extends keyof Fields & string>(
     this: ModelName extends string
-      ? StagedModelBuilder<ModelName, Fields, Relations, AttributesSpec, SqlSpec>
+      ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, SqlSpec>
       : never,
     fieldName: FieldName,
   ): TargetFieldRef<ModelName & string, FieldName> {
@@ -1001,7 +1002,7 @@ export class StagedModelBuilder<
 
   relations<const NextRelations extends Record<string, AnyRelationBuilder>>(
     relations: NextRelations,
-  ): StagedModelBuilder<ModelName, Fields, Relations & NextRelations, AttributesSpec, SqlSpec> {
+  ): ContractModelBuilder<ModelName, Fields, Relations & NextRelations, AttributesSpec, SqlSpec> {
     const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
     if (duplicateRelationName) {
       throw new Error(
@@ -1009,7 +1010,7 @@ export class StagedModelBuilder<
       );
     }
 
-    return new StagedModelBuilder(
+    return new ContractModelBuilder(
       {
         ...this.stageOne,
         relations: {
@@ -1027,19 +1028,19 @@ export class StagedModelBuilder<
       AttributeContext<Fields>,
       ValidateAttributesStageSpec<Fields, SqlSpec, NextAttributesSpec>
     >,
-  ): StagedModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec> {
-    return new StagedModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
+  ): ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec> {
+    return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
   }
 
   sql<const NextSqlSpec extends SqlStageSpec>(
     specOrFactory: StageInput<SqlContext<Fields>, NextSqlSpec>,
   ): [ValidateSqlStageSpec<Fields, AttributesSpec, NextSqlSpec>] extends [never]
-    ? StagedModelBuilder<ModelName, Fields, Relations, AttributesSpec, never>
-    : StagedModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec> {
+    ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, never>
+    : ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec> {
     // Conditional return type cannot be verified by the implementation; the
-    // runtime value is always a valid StagedModelBuilder regardless of the
+    // runtime value is always a valid ContractModelBuilder regardless of the
     // validation outcome (validation is type-level only).
-    return new StagedModelBuilder(this.stageOne, this.attributesFactory, specOrFactory) as never;
+    return new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory) as never;
   }
 
   buildAttributesSpec(): AttributesSpec {
@@ -1157,13 +1158,13 @@ function normalizeRelationModelSource(
   };
 }
 
-export type StagedContractInput<
+export type ContractInput<
   Family extends FamilyPackRef<string> = FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string> = TargetPackRef<'sql', string>,
   Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   Models extends Record<
     string,
-    StagedModelBuilder<
+    ContractModelBuilder<
       string | undefined,
       Record<string, ScalarFieldBuilder>,
       Record<string, AnyRelationBuilder>,
@@ -1183,6 +1184,7 @@ export type StagedContractInput<
   readonly capabilities?: Capabilities;
   readonly types?: Types;
   readonly models?: Models;
+  readonly codecLookup?: CodecLookup;
 };
 
 export function model<
@@ -1195,7 +1197,7 @@ export function model<
     readonly fields: Fields;
     readonly relations?: Relations;
   },
-): StagedModelBuilder<ModelName, Fields, Relations>;
+): ContractModelBuilder<ModelName, Fields, Relations>;
 
 export function model<
   Fields extends Record<string, ScalarFieldBuilder>,
@@ -1203,7 +1205,7 @@ export function model<
 >(input: {
   readonly fields: Fields;
   readonly relations?: Relations;
-}): StagedModelBuilder<undefined, Fields, Relations>;
+}): ContractModelBuilder<undefined, Fields, Relations>;
 
 export function model<
   const ModelName extends string,
@@ -1220,14 +1222,14 @@ export function model<
     readonly fields: Fields;
     readonly relations?: Relations;
   },
-): StagedModelBuilder<ModelName | undefined, Fields, Relations> {
+): ContractModelBuilder<ModelName | undefined, Fields, Relations> {
   const input = typeof modelNameOrInput === 'string' ? maybeInput : modelNameOrInput;
 
   if (!input) {
     throw new Error('model("ModelName", ...) requires a model definition.');
   }
 
-  return new StagedModelBuilder({
+  return new ContractModelBuilder({
     ...(typeof modelNameOrInput === 'string' ? { modelName: modelNameOrInput } : {}),
     fields: input.fields,
     relations: (input.relations ?? {}) as Relations,
@@ -1372,7 +1374,7 @@ export const field = {
   namedType: namedTypeField,
 };
 
-export function isStagedContractInput(value: unknown): value is StagedContractInput {
+export function isContractInput(value: unknown): value is ContractInput {
   if (typeof value !== 'object' || value === null || !('target' in value) || !('family' in value)) {
     return false;
   }
@@ -1437,7 +1439,7 @@ export type FieldStateOf<T> = T extends ScalarFieldBuilder<infer State> ? State
 export type RelationStateOf<T> = T extends RelationBuilder<infer State> ? State : never;
 
 export type ModelFieldsOf<T> =
-  T extends StagedModelBuilder<
+  T extends ContractModelBuilder<
     string | undefined,
     infer Fields,
     Record<string, AnyRelationBuilder>,
@@ -1448,7 +1450,7 @@ export type ModelFieldsOf<T> =
     : never;
 
 export type ModelRelationsOf<T> =
-  T extends StagedModelBuilder<
+  T extends ContractModelBuilder<
     string | undefined,
     Record<string, ScalarFieldBuilder>,
     infer Relations,
@@ -1459,7 +1461,7 @@ export type ModelRelationsOf<T> =
     : never;
 
 export type ModelAttributesOf<T> =
-  T extends StagedModelBuilder<
+  T extends ContractModelBuilder<
     string | undefined,
     Record<string, ScalarFieldBuilder>,
     Record<string, AnyRelationBuilder>,
@@ -1470,7 +1472,7 @@ export type ModelAttributesOf<T> =
     : undefined;
 
 export type ModelSqlOf<T> =
-  T extends StagedModelBuilder<
+  T extends ContractModelBuilder<
     string | undefined,
     Record<string, ScalarFieldBuilder>,
     Record<string, AnyRelationBuilder>,

package/src/{staged-contract-lowering.ts → contract-lowering.ts}

@@ -1,40 +1,40 @@
 import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import type {
-  SqlSemanticContractDefinition,
-  SqlSemanticFieldNode,
-  SqlSemanticForeignKeyNode,
-  SqlSemanticIndexNode,
-  SqlSemanticModelNode,
-  SqlSemanticPrimaryKeyNode,
-  SqlSemanticRelationNode,
-  SqlSemanticUniqueConstraintNode,
-} from './semantic-contract';
+  ContractDefinition,
+  FieldNode,
+  ForeignKeyNode,
+  IndexNode,
+  ModelNode,
+  PrimaryKeyNode,
+  RelationNode,
+  UniqueConstraintNode,
+} from './contract-definition';
 import {
   applyNaming,
+  type ContractInput,
+  type ContractModelBuilder,
   type FieldStateOf,
   type ForeignKeyConstraint,
   type IdConstraint,
   type ModelAttributesSpec,
   normalizeRelationFieldNames,
   type RelationBuilder,
+  type RelationState,
   resolveRelationModelName,
   type ScalarFieldBuilder,
   type SqlStageSpec,
-  type StagedContractInput,
-  type StagedModelBuilder,
-  type RelationState as StagedRelationState,
   type UniqueConstraint,
-} from './staged-contract-dsl';
+} from './contract-dsl';
 import {
   emitTypedCrossModelFallbackWarnings,
   emitTypedNamedTypeFallbackWarnings,
-} from './staged-contract-warnings';
+} from './contract-warnings';
 
-type RuntimeStagedModel = StagedModelBuilder<
+type RuntimeModel = ContractModelBuilder<
   string | undefined,
   Record<string, ScalarFieldBuilder>,
-  Record<string, RelationBuilder<StagedRelationState>>,
+  Record<string, RelationBuilder<RelationState>>,
   ModelAttributesSpec | undefined,
   SqlStageSpec | undefined
 >;
@@ -44,15 +44,15 @@ type RuntimeModelSpec = {
   readonly tableName: string;
   readonly fieldBuilders: Record<string, ScalarFieldBuilder>;
   readonly fieldToColumn: Record<string, string>;
-  readonly relations: Record<string, RelationBuilder<StagedRelationState>>;
+  readonly relations: Record<string, RelationBuilder<RelationState>>;
   readonly attributesSpec: ModelAttributesSpec | undefined;
   readonly sqlSpec: SqlStageSpec | undefined;
   readonly idConstraint: IdConstraint | undefined;
 };
 
-type RuntimeStagedCollection = {
+type RuntimeCollection = {
   readonly storageTypes: Record<string, StorageTypeInstance>;
-  readonly models: Record<string, RuntimeStagedModel>;
+  readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
 
@@ -114,7 +114,7 @@ function mapFieldNamesToColumnNames(
   return fieldNames.map((fieldName) => {
     const columnName = fieldToColumn[fieldName];
     if (!columnName) {
-      throw new Error(`Unknown field "${modelName}.${fieldName}" in staged contract definition`);
+      throw new Error(`Unknown field "${modelName}.${fieldName}" in contract definition`);
     }
     return columnName;
   });
@@ -294,10 +294,10 @@ function resolveRelationAnchorFields(spec: RuntimeModelSpec): readonly string[]
 
 function lowerBelongsToRelation(
   relationName: string,
-  relation: Extract<StagedRelationState, { kind: 'belongsTo' }>,
+  relation: Extract<RelationState, { kind: 'belongsTo' }>,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-): SqlSemanticRelationNode {
+): RelationNode {
   const targetModelName = resolveRelationModelName(relation.toModel);
   const targetSpec = allSpecs.get(targetModelName);
   if (!targetSpec) {
@@ -341,10 +341,10 @@ function lowerBelongsToRelation(
 
 function lowerHasOwnershipRelation(
   relationName: string,
-  relation: Extract<StagedRelationState, { kind: 'hasMany' | 'hasOne' }>,
+  relation: Extract<RelationState, { kind: 'hasMany' | 'hasOne' }>,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-): SqlSemanticRelationNode {
+): RelationNode {
   const targetModelName = resolveRelationModelName(relation.toModel);
   const targetSpec = allSpecs.get(targetModelName);
   if (!targetSpec) {
@@ -388,10 +388,10 @@ function lowerHasOwnershipRelation(
 
 function lowerManyToManyRelation(
   relationName: string,
-  relation: Extract<StagedRelationState, { kind: 'manyToMany' }>,
+  relation: Extract<RelationState, { kind: 'manyToMany' }>,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-): SqlSemanticRelationNode {
+): RelationNode {
   const targetModelName = resolveRelationModelName(relation.toModel);
   const targetSpec = allSpecs.get(targetModelName);
   if (!targetSpec) {
@@ -456,12 +456,12 @@ function lowerManyToManyRelation(
   };
 }
 
-function resolveSemanticRelationNode(
+function resolveRelationNode(
   relationName: string,
-  relation: StagedRelationState,
+  relation: RelationState,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-): SqlSemanticRelationNode {
+): RelationNode {
   if (relation.kind === 'belongsTo') {
     return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs);
   }
@@ -485,7 +485,7 @@ function lowerForeignKeyNode(
     readonly constraint?: boolean | undefined;
     readonly index?: boolean | undefined;
   },
-): SqlSemanticForeignKeyNode {
+): ForeignKeyNode {
   return {
     columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
     references: {
@@ -505,10 +505,10 @@ function lowerForeignKeyNode(
   };
 }
 
-function resolveSemanticForeignKeyNodes(
+function resolveForeignKeyNodes(
   spec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-): readonly SqlSemanticForeignKeyNode[] {
+): readonly ForeignKeyNode[] {
   const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
     const targetSpec = allSpecs.get(foreignKey.targetModel);
     if (!targetSpec) {
@@ -534,13 +534,13 @@ function resolveSemanticForeignKeyNodes(
   return [...relationForeignKeys, ...sqlForeignKeys];
 }
 
-function resolveSemanticModelNode(
+function resolveModelNode(
   spec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
   storageTypes: Record<string, StorageTypeInstance>,
   storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance, string>,
-): SqlSemanticModelNode {
-  const fields: SqlSemanticFieldNode[] = [];
+): ModelNode {
+  const fields: FieldNode[] = [];
 
   for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
     const fieldState = fieldBuilder.build();
@@ -570,16 +570,16 @@ function resolveSemanticModelNode(
   const uniques = resolveModelUniqueConstraints(spec).map((unique) => ({
     columns: mapFieldNamesToColumnNames(spec.modelName, unique.fields, spec.fieldToColumn),
     ...(unique.name ? { name: unique.name } : {}),
-  })) satisfies readonly SqlSemanticUniqueConstraintNode[];
+  })) satisfies readonly UniqueConstraintNode[];
   const indexes = (spec.sqlSpec?.indexes ?? []).map((index) => ({
     columns: mapFieldNamesToColumnNames(spec.modelName, index.fields, spec.fieldToColumn),
     ...(index.name ? { name: index.name } : {}),
     ...(index.using ? { using: index.using } : {}),
     ...(index.config ? { config: index.config } : {}),
-  })) satisfies readonly SqlSemanticIndexNode[];
-  const foreignKeys = resolveSemanticForeignKeyNodes(spec, allSpecs);
+  })) satisfies readonly IndexNode[];
+  const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
   const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) =>
-    resolveSemanticRelationNode(relationName, relationBuilder.build(), spec, allSpecs),
+    resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs),
   );
 
   return {
@@ -595,7 +595,7 @@ function resolveSemanticModelNode(
               spec.fieldToColumn,
             ),
             ...(idConstraint.name ? { name: idConstraint.name } : {}),
-          } satisfies SqlSemanticPrimaryKeyNode,
+          } satisfies PrimaryKeyNode,
         }
       : {}),
     ...(uniques.length > 0 ? { uniques } : {}),
@@ -605,9 +605,9 @@ function resolveSemanticModelNode(
   };
 }
 
-function collectRuntimeModelSpecs(definition: StagedContractInput): RuntimeStagedCollection {
+function collectRuntimeModelSpecs(definition: ContractInput): RuntimeCollection {
   const storageTypes = { ...(definition.types ?? {}) } as Record<string, StorageTypeInstance>;
-  const models = { ...(definition.models ?? {}) } as Record<string, RuntimeStagedModel>;
+  const models = { ...(definition.models ?? {}) } as Record<string, RuntimeModel>;
 
   emitTypedNamedTypeFallbackWarnings(models, storageTypes);
 
@@ -671,12 +671,12 @@ function collectRuntimeModelSpecs(definition: StagedContractInput): RuntimeStage
   };
 }
 
-function lowerSemanticModels(collection: RuntimeStagedCollection): readonly SqlSemanticModelNode[] {
+function lowerModels(collection: RuntimeCollection): readonly ModelNode[] {
   emitTypedCrossModelFallbackWarnings(collection);
 
   const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
   return Array.from(collection.modelSpecs.values()).map((spec) =>
-    resolveSemanticModelNode(
+    resolveModelNode(
       spec,
       collection.modelSpecs,
       collection.storageTypes,
@@ -685,11 +685,9 @@ function lowerSemanticModels(collection: RuntimeStagedCollection): readonly SqlS
   );
 }
 
-export function buildStagedSemanticContractDefinition(
-  definition: StagedContractInput,
-): SqlSemanticContractDefinition {
+export function buildContractDefinition(definition: ContractInput): ContractDefinition {
   const collection = collectRuntimeModelSpecs(definition);
-  const models = lowerSemanticModels(collection);
+  const models = lowerModels(collection);
 
   return {
     target: definition.target,