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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.5.0-dev.81",
+  "version": "0.5.0-dev.82",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,12 +9,12 @@
     "arktype": "^2.1.29",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0",
-    "@prisma-next/config": "0.5.0-dev.81",
-    "@prisma-next/contract-authoring": "0.5.0-dev.81",
-    "@prisma-next/framework-components": "0.5.0-dev.81",
-    "@prisma-next/utils": "0.5.0-dev.81",
-    "@prisma-next/contract": "0.5.0-dev.81",
-    "@prisma-next/sql-contract": "0.5.0-dev.81"
+    "@prisma-next/config": "0.5.0-dev.82",
+    "@prisma-next/contract-authoring": "0.5.0-dev.82",
+    "@prisma-next/framework-components": "0.5.0-dev.82",
+    "@prisma-next/sql-contract": "0.5.0-dev.82",
+    "@prisma-next/utils": "0.5.0-dev.82",
+    "@prisma-next/contract": "0.5.0-dev.82"
   },
   "devDependencies": {
     "@types/pg": "8.20.0",
@@ -23,8 +23,8 @@
     "typescript": "5.9.3",
     "vitest": "4.1.5",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",

package/src/build-contract.ts

@@ -17,6 +17,12 @@ import {
   type StorageHashBase,
 } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import { validateIndexTypes } from '@prisma-next/sql-contract/index-type-validation';
+import {
+  createIndexTypeRegistry,
+  type IndexTypeMap,
+  type IndexTypeRegistration,
+} from '@prisma-next/sql-contract/index-types';
 import {
   applyFkDefaults,
   type SqlStorage,
@@ -63,11 +69,37 @@ function encodeColumnDefault(
   };
 }
 
-function assertStorageSemantics(storage: SqlStorage): void {
-  const semanticErrors = validateStorageSemantics(storage);
+function assertStorageSemantics(
+  definition: ContractDefinition,
+  contract: Contract<SqlStorage>,
+): void {
+  const semanticErrors = validateStorageSemantics(contract.storage);
   if (semanticErrors.length > 0) {
     throw new Error(`Contract semantic validation failed: ${semanticErrors.join('; ')}`);
   }
+
+  const indexTypeRegistry = createIndexTypeRegistry();
+  const packsToRegister: ReadonlyArray<{ readonly id?: string; readonly indexTypes?: unknown }> = [
+    definition.target,
+    ...Object.values(definition.extensionPacks ?? {}),
+  ];
+  for (const pack of packsToRegister) {
+    const registration = pack.indexTypes;
+    if (registration === undefined) continue;
+    if (
+      typeof registration !== 'object' ||
+      registration === null ||
+      !Array.isArray((registration as { entries?: unknown }).entries)
+    ) {
+      throw new Error(
+        `Pack "${pack.id ?? '<unknown>'}" declares "indexTypes" but its value is not an IndexTypeRegistration (expected an object with an "entries" array; got ${typeof registration}).`,
+      );
+    }
+    for (const entry of (registration as IndexTypeRegistration<IndexTypeMap>).entries) {
+      indexTypeRegistry.register(entry);
+    }
+  }
+  validateIndexTypes(contract, indexTypeRegistry);
 }
 
 function assertKnownTargetModel(
@@ -277,8 +309,8 @@ export function buildSqlContractFromDefinition(
       indexes: (semanticModel.indexes ?? []).map((i) => ({
         columns: i.columns,
         ...ifDefined('name', i.name),
-        ...ifDefined('using', i.using),
-        ...ifDefined('config', i.config),
+        ...ifDefined('type', i.type),
+        ...ifDefined('options', i.options),
       })),
       foreignKeys,
       ...(semanticModel.id
@@ -447,7 +479,7 @@ export function buildSqlContractFromDefinition(
     meta: {},
   };
 
-  assertStorageSemantics(contract.storage);
+  assertStorageSemantics(definition, contract);
 
   return contract;
 }

package/src/composed-authoring-helpers.ts

@@ -26,7 +26,14 @@ import type {
   TupleFromArgumentDescriptors,
   UnionToIntersection,
 } from './authoring-type-utils';
+import type {
+  AnyRelationBuilder,
+  ContractModelBuilder,
+  IndexTypeMap,
+  ScalarFieldBuilder,
+} from './contract-dsl';
 import { buildFieldPreset, field, model, rel } from './contract-dsl';
+import type { MergeExtensionIndexTypes } from './contract-types';
 
 type ExtractTypeNamespaceFromPack<Pack> = Pack extends {
   readonly authoring?: { readonly type?: infer Namespace extends AuthoringTypeNamespace };
@@ -93,6 +100,33 @@ type TypeHelpersFromNamespace<Namespace> = {
 
 type CoreFieldHelpers = Pick<typeof field, 'column' | 'generated' | 'namedType'>;
 
+type MergeAllPackIndexTypes<Family, Target, ExtensionPacks> = MergeExtensionIndexTypes<
+  { readonly __family: Family; readonly __target: Target } & (ExtensionPacks extends Record<
+    string,
+    unknown
+  >
+    ? ExtensionPacks
+    : Record<never, never>)
+>;
+
+type PackAwareModel<IndexTypes extends IndexTypeMap> = {
+  <
+    const ModelName extends string,
+    Fields extends Record<string, ScalarFieldBuilder>,
+    Relations extends Record<string, AnyRelationBuilder> = Record<never, never>,
+  >(
+    modelName: ModelName,
+    input: { readonly fields: Fields; readonly relations?: Relations },
+  ): ContractModelBuilder<ModelName, Fields, Relations, undefined, undefined, IndexTypes>;
+  <
+    Fields extends Record<string, ScalarFieldBuilder>,
+    Relations extends Record<string, AnyRelationBuilder> = Record<never, never>,
+  >(input: {
+    readonly fields: Fields;
+    readonly relations?: Relations;
+  }): ContractModelBuilder<undefined, Fields, Relations, undefined, undefined, IndexTypes>;
+};
+
 export type ComposedAuthoringHelpers<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
@@ -104,7 +138,7 @@ export type ComposedAuthoringHelpers<
         ExtractFieldNamespaceFromPack<Target> &
         MergeExtensionFieldNamespaces<ExtensionPacks>
     >;
-  readonly model: typeof model;
+  readonly model: PackAwareModel<MergeAllPackIndexTypes<Family, Target, ExtensionPacks>>;
   readonly rel: typeof rel;
   readonly type: TypeHelpersFromNamespace<
     ExtractTypeNamespaceFromPack<Family> &

package/src/contract-definition.ts

@@ -29,8 +29,8 @@ export interface UniqueConstraintNode {
 export interface IndexNode {
   readonly columns: readonly string[];
   readonly name?: string;
-  readonly using?: string;
-  readonly config?: Record<string, unknown>;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
 }
 
 export interface ForeignKeyNode {

package/src/contract-dsl.ts

@@ -465,7 +465,7 @@ export type RelationState =
   | ManyToManyRelation;
 
 type AnyRelationState = RelationState;
-type AnyRelationBuilder = RelationBuilder<AnyRelationState>;
+export type AnyRelationBuilder = RelationBuilder<AnyRelationState>;
 
 type ApplyBelongsToRelationSqlSpec<
   State extends RelationState,
@@ -537,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> & {
@@ -577,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<
@@ -623,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,
@@ -674,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> }
+        : {}),
     };
   }
 
@@ -776,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>>(
@@ -829,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,
@@ -946,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(
@@ -961,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
@@ -970,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> {
@@ -989,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(
@@ -1015,15 +1055,15 @@ 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> {
+    ? 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;
   }
@@ -1045,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/framework-components/codec';
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ContractDefinition,
   FieldNode,
@@ -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;
 }