@prisma-next/sql-contract-ts 0.5.0-dev.9 → 0.5.0

package/src/contract-dsl.ts

@@ -1,15 +1,14 @@
 import type {
   ColumnDefault,
   ColumnDefaultLiteralInputValue,
+  ExecutionMutationDefaultPhases,
   ExecutionMutationDefaultValue,
 } from '@prisma-next/contract/types';
-import type {
-  ColumnTypeDescriptor,
-  ForeignKeyDefaultsState,
-} from '@prisma-next/contract-authoring';
+import { isColumnDefault } from '@prisma-next/contract/types';
+import type { 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 { CodecLookup, ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type {
   ExtensionPackRef,
   FamilyPackRef,
@@ -46,7 +45,7 @@ export type ScalarFieldState<
   readonly nullable: Nullable;
   readonly columnName?: ColumnName | undefined;
   readonly default?: ColumnDefault | undefined;
-  readonly executionDefault?: ExecutionMutationDefaultValue | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
 } & (IdSpec extends NamedConstraintSpec ? { readonly id: IdSpec } : { readonly id?: undefined }) &
   (UniqueSpec extends NamedConstraintSpec
     ? { readonly unique: UniqueSpec }
@@ -59,7 +58,7 @@ type AnyScalarFieldState = {
   readonly nullable: boolean;
   readonly columnName?: string | undefined;
   readonly default?: ColumnDefault | undefined;
-  readonly executionDefault?: ExecutionMutationDefaultValue | undefined;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases | undefined;
   readonly id?: NamedConstraintSpec | undefined;
   readonly unique?: NamedConstraintSpec | undefined;
 };
@@ -136,12 +135,6 @@ export type GeneratedFieldSpec = {
   readonly generated: ExecutionMutationDefaultValue;
 };
 
-function isColumnDefault(value: unknown): value is ColumnDefault {
-  if (typeof value !== 'object' || value === null) return false;
-  const kind = (value as { kind?: unknown }).kind;
-  return kind === 'literal' || kind === 'function';
-}
-
 function toColumnDefault(value: ColumnDefaultLiteralInputValue | ColumnDefault): ColumnDefault {
   if (isColumnDefault(value)) {
     return value;
@@ -149,10 +142,7 @@ function toColumnDefault(value: ColumnDefaultLiteralInputValue | ColumnDefault):
   return { kind: 'literal', value };
 }
 
-// Chaining methods use `as unknown as <ConditionalType>` because TypeScript cannot
-// narrow generic conditional return types through object spread. The runtime values
-// are correct — the casts bridge the gap between the spread result and the
-// compile-time conditional type that encodes the state transition.
+// Chaining methods use `as unknown as <ConditionalType>` because TypeScript cannot narrow generic conditional return types through object spread. The runtime values are correct — the casts bridge the gap between the spread result and the compile-time conditional type that encodes the state transition.
 export class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFieldState> {
   declare readonly __state: State;
 
@@ -348,7 +338,7 @@ function generatedField<Descriptor extends ColumnTypeDescriptor>(
       ...(spec.typeParams ? { typeParams: spec.typeParams } : {}),
     },
     nullable: false,
-    executionDefault: spec.generated,
+    executionDefaults: { onCreate: spec.generated },
   });
 }
 
@@ -379,11 +369,8 @@ export function buildFieldPreset(
     kind: 'scalar',
     descriptor: preset.descriptor,
     nullable: preset.nullable,
-    ...ifDefined('default', preset.default as ColumnDefault | undefined),
-    ...ifDefined(
-      'executionDefault',
-      preset.executionDefault as ExecutionMutationDefaultValue | undefined,
-    ),
+    ...ifDefined('default', preset.default),
+    ...ifDefined('executionDefaults', preset.executionDefaults),
     ...(preset.id
       ? {
           id: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {},
@@ -478,7 +465,7 @@ export type RelationState =
   | ManyToManyRelation;
 
 type AnyRelationState = RelationState;
-type AnyRelationBuilder = RelationBuilder<AnyRelationState>;
+export type AnyRelationBuilder = RelationBuilder<AnyRelationState>;
 
 type ApplyBelongsToRelationSqlSpec<
   State extends RelationState,
@@ -550,11 +537,21 @@ type ConstraintOptions<Name extends string | undefined = string | undefined> = {
   readonly name?: Name;
 };
 
-type IndexOptions<Name extends string | undefined = string | undefined> =
-  ConstraintOptions<Name> & {
-    readonly using?: string;
-    readonly config?: Record<string, unknown>;
-  };
+export type IndexTypeMap = Record<string, { readonly options: unknown }>;
+
+type IndexInput<
+  Name extends string | undefined,
+  IndexTypes extends IndexTypeMap,
+> = keyof IndexTypes extends never
+  ? ConstraintOptions<Name>
+  :
+      | (ConstraintOptions<Name> & { readonly type?: never; readonly options?: never })
+      | {
+          readonly [K in keyof IndexTypes & string]: ConstraintOptions<Name> & {
+            readonly type: K;
+            readonly options: IndexTypes[K]['options'];
+          };
+        }[keyof IndexTypes & string];
 
 type ForeignKeyOptions<Name extends string | undefined = string | undefined> =
   ConstraintOptions<Name> & {
@@ -590,8 +587,8 @@ export type IndexConstraint<
   readonly kind: 'index';
   readonly fields: FieldNames;
   readonly name?: Name;
-  readonly using?: string;
-  readonly config?: Record<string, unknown>;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
 };
 
 export type ForeignKeyConstraint<
@@ -636,7 +633,7 @@ function normalizeTargetFieldRefInput(input: TargetFieldRef | readonly TargetFie
   };
 }
 
-function createConstraintsDsl() {
+function createConstraintsDsl<IndexTypes extends IndexTypeMap = Record<never, never>>() {
   function ref<ModelName extends string, FieldName extends string>(
     modelName: ModelName,
     fieldName: FieldName,
@@ -687,24 +684,26 @@ function createConstraintsDsl() {
     };
   }
 
-  function index<FieldName extends string, Name extends string | undefined = undefined>(
-    field: ColumnRef<FieldName>,
-    options?: IndexOptions<Name>,
-  ): IndexConstraint<readonly [FieldName], Name>;
   function index<FieldNames extends readonly string[], Name extends string | undefined = undefined>(
     fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string> },
-    options?: IndexOptions<Name>,
+    options?: IndexInput<Name, IndexTypes>,
   ): IndexConstraint<FieldNames, Name>;
   function index(
-    fieldOrFields: ColumnRef | readonly ColumnRef[],
-    options?: IndexOptions,
+    fields: readonly ColumnRef[],
+    options?: {
+      readonly name?: string;
+      readonly type?: string;
+      readonly options?: unknown;
+    },
   ): IndexConstraint {
     return {
       kind: 'index',
-      fields: normalizeFieldRefInput(fieldOrFields),
-      ...(options?.name ? { name: options.name } : {}),
-      ...(options?.using ? { using: options.using } : {}),
-      ...(options?.config ? { config: options.config } : {}),
+      fields: normalizeFieldRefInput(fields),
+      ...(options?.name !== undefined ? { name: options.name } : {}),
+      ...(options?.type !== undefined ? { type: options.type } : {}),
+      ...(options?.options !== undefined
+        ? { options: options.options as Record<string, unknown> }
+        : {}),
     };
   }
 
@@ -789,9 +788,26 @@ type AttributeContext<Fields extends Record<string, ScalarFieldBuilder>> = {
   readonly constraints: Pick<ConstraintsDsl, 'id' | 'unique'>;
 };
 
-type SqlContext<Fields extends Record<string, ScalarFieldBuilder>> = {
+type PackAwareIndex<IndexTypes extends IndexTypeMap> = <
+  FieldNames extends readonly string[],
+  Name extends string | undefined = undefined,
+>(
+  fields: { readonly [K in keyof FieldNames]: ColumnRef<FieldNames[K] & string> },
+  options?: IndexInput<Name, IndexTypes>,
+) => IndexConstraint<FieldNames, Name>;
+
+type PackAwareSqlConstraints<IndexTypes extends IndexTypeMap> = {
+  readonly foreignKey: ConstraintsDsl['foreignKey'];
+  readonly ref: ConstraintsDsl['ref'];
+  readonly index: PackAwareIndex<IndexTypes>;
+};
+
+export type SqlContext<
+  Fields extends Record<string, ScalarFieldBuilder>,
+  IndexTypes extends IndexTypeMap = Record<never, never>,
+> = {
   readonly cols: FieldRefs<Fields>;
-  readonly constraints: Pick<ConstraintsDsl, 'index' | 'foreignKey' | 'ref'>;
+  readonly constraints: PackAwareSqlConstraints<IndexTypes>;
 };
 
 function createFieldRefs<Fields extends Record<string, ScalarFieldBuilder>>(
@@ -842,8 +858,10 @@ function createAttributeConstraintsDsl(): AttributeContext<
   };
 }
 
-function createSqlConstraintsDsl(): SqlContext<Record<string, ScalarFieldBuilder>>['constraints'] {
-  const constraints = createConstraintsDsl();
+function createSqlConstraintsDsl<
+  IndexTypes extends IndexTypeMap = Record<never, never>,
+>(): SqlContext<Record<string, ScalarFieldBuilder>, IndexTypes>['constraints'] {
+  const constraints = createConstraintsDsl<IndexTypes>();
   return {
     index: constraints.index,
     foreignKey: constraints.foreignKey,
@@ -959,12 +977,14 @@ export class ContractModelBuilder<
   Relations extends Record<string, AnyRelationBuilder> = Record<never, never>,
   AttributesSpec extends ModelAttributesSpec | undefined = undefined,
   SqlSpec extends SqlStageSpec | undefined = undefined,
+  IndexTypes extends IndexTypeMap = Record<never, never>,
 > {
   declare readonly __name: ModelName;
   declare readonly __fields: Fields;
   declare readonly __relations: Relations;
   declare readonly __attributes: AttributesSpec;
   declare readonly __sql: SqlSpec;
+  declare readonly __indexTypes: IndexTypes;
   readonly refs: ModelName extends string ? ModelTokenRefs<ModelName, Fields> : never;
 
   constructor(
@@ -974,7 +994,7 @@ export class ContractModelBuilder<
       readonly relations: Relations;
     },
     readonly attributesFactory?: StageInput<AttributeContext<Fields>, AttributesSpec>,
-    readonly sqlFactory?: StageInput<SqlContext<Fields>, SqlSpec>,
+    readonly sqlFactory?: StageInput<SqlContext<Fields, IndexTypes>, SqlSpec>,
   ) {
     this.refs = (
       stageOne.modelName ? createModelTokenRefs(stageOne.modelName, stageOne.fields) : undefined
@@ -983,7 +1003,7 @@ export class ContractModelBuilder<
 
   ref<FieldName extends keyof Fields & string>(
     this: ModelName extends string
-      ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, SqlSpec>
+      ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, SqlSpec, IndexTypes>
       : never,
     fieldName: FieldName,
   ): TargetFieldRef<ModelName & string, FieldName> {
@@ -1002,7 +1022,14 @@ export class ContractModelBuilder<
 
   relations<const NextRelations extends Record<string, AnyRelationBuilder>>(
     relations: NextRelations,
-  ): ContractModelBuilder<ModelName, Fields, Relations & NextRelations, AttributesSpec, SqlSpec> {
+  ): ContractModelBuilder<
+    ModelName,
+    Fields,
+    Relations & NextRelations,
+    AttributesSpec,
+    SqlSpec,
+    IndexTypes
+  > {
     const duplicateRelationName = findDuplicateRelationName(this.stageOne.relations, relations);
     if (duplicateRelationName) {
       throw new Error(
@@ -1028,18 +1055,16 @@ export class ContractModelBuilder<
       AttributeContext<Fields>,
       ValidateAttributesStageSpec<Fields, SqlSpec, NextAttributesSpec>
     >,
-  ): ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec> {
+  ): ContractModelBuilder<ModelName, Fields, Relations, NextAttributesSpec, SqlSpec, IndexTypes> {
     return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
   }
 
   sql<const NextSqlSpec extends SqlStageSpec>(
-    specOrFactory: StageInput<SqlContext<Fields>, NextSqlSpec>,
+    specOrFactory: StageInput<SqlContext<Fields, IndexTypes>, NextSqlSpec>,
   ): [ValidateSqlStageSpec<Fields, AttributesSpec, NextSqlSpec>] extends [never]
-    ? 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 ContractModelBuilder regardless of the
-    // validation outcome (validation is type-level only).
+    ? ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, never, IndexTypes>
+    : ContractModelBuilder<ModelName, Fields, Relations, AttributesSpec, NextSqlSpec, IndexTypes> {
+    // Conditional return type cannot be verified by the implementation; the runtime value is always a valid ContractModelBuilder regardless of the validation outcome (validation is type-level only).
     return new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory) as never;
   }
 
@@ -1060,7 +1085,7 @@ export class ContractModelBuilder<
     }
     return buildStageSpec(this.sqlFactory, {
       cols: createColumnRefs(this.stageOne.fields),
-      constraints: createSqlConstraintsDsl() as SqlContext<Fields>['constraints'],
+      constraints: createSqlConstraintsDsl<IndexTypes>(),
     });
   }
 }

package/src/contract-lowering.ts

@@ -1,5 +1,6 @@
-import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ContractDefinition,
   FieldNode,
@@ -562,7 +563,7 @@ function resolveModelNode(
       descriptor,
       nullable: fieldState.nullable,
       ...(fieldState.default ? { default: fieldState.default } : {}),
-      ...(fieldState.executionDefault ? { executionDefault: fieldState.executionDefault } : {}),
+      ...(fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {}),
     });
   }
 
@@ -573,9 +574,9 @@ function resolveModelNode(
   })) 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 } : {}),
+    ...ifDefined('name', index.name),
+    ...ifDefined('type', index.type),
+    ...ifDefined('options', index.options),
   })) satisfies readonly IndexNode[];
   const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
   const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) =>

package/src/contract-types.ts

@@ -5,6 +5,7 @@ import type {
   StorageHashBase,
 } from '@prisma-next/contract/types';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
+import type { IndexTypeRegistration } from '@prisma-next/sql-contract/index-types';
 import type {
   ContractWithTypeMaps,
   Index,
@@ -34,6 +35,28 @@ type MergeExtensionCodecTypesSafe<Packs> =
       : MergeExtensionCodecTypes<Packs>
     : Record<string, never>;
 
+export type ExtractIndexTypesFromPack<P> = P extends {
+  readonly indexTypes: IndexTypeRegistration<infer M>;
+}
+  ? M
+  : Record<never, never>;
+
+type AllIndexTypeLiterals<Packs> =
+  Packs extends Record<string, unknown>
+    ? { [K in keyof Packs]: keyof ExtractIndexTypesFromPack<Packs[K]> }[keyof Packs] & string
+    : never;
+
+export type MergeExtensionIndexTypes<Packs extends Record<string, unknown>> = {
+  readonly [Lit in AllIndexTypeLiterals<Packs>]: Extract<
+    {
+      [K in keyof Packs]: Lit extends keyof ExtractIndexTypesFromPack<Packs[K]>
+        ? ExtractIndexTypesFromPack<Packs[K]>[Lit]
+        : never;
+    }[keyof Packs],
+    { readonly options: unknown }
+  >;
+};
+
 export type MergeExtensionPackRefs<
   Existing extends Record<string, unknown> | undefined,
   Added extends Record<string, ExtensionPackRef<'sql', string>>,
@@ -64,6 +87,16 @@ type CodecTypesFromDefinition<Definition> = ExtractCodecTypesFromPack<
 > &
   MergeExtensionCodecTypesSafe<DefinitionExtensionPacks<Definition>>;
 
+type DefinitionTarget<Definition> = Definition extends { readonly target: infer Target }
+  ? Target
+  : never;
+
+type AllPacks<Definition> = DefinitionExtensionPacks<Definition> & {
+  readonly __target: DefinitionTarget<Definition>;
+};
+
+export type IndexTypesFromDefinition<Definition> = MergeExtensionIndexTypes<AllPacks<Definition>>;
+
 type DefinitionModels<Definition> = Definition extends {
   readonly models?: unknown;
 }