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

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.5.0-dev.9",
+  "version": "0.6.0-dev.1",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "arktype": "^2.1.25",
+    "arktype": "^2.1.29",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0",
-    "@prisma-next/config": "0.5.0-dev.9",
-    "@prisma-next/contract": "0.5.0-dev.9",
-    "@prisma-next/contract-authoring": "0.5.0-dev.9",
-    "@prisma-next/utils": "0.5.0-dev.9",
-    "@prisma-next/sql-contract": "0.5.0-dev.9",
-    "@prisma-next/framework-components": "0.5.0-dev.9"
+    "@prisma-next/contract": "0.6.0-dev.1",
+    "@prisma-next/config": "0.6.0-dev.1",
+    "@prisma-next/contract-authoring": "0.6.0-dev.1",
+    "@prisma-next/framework-components": "0.6.0-dev.1",
+    "@prisma-next/sql-contract": "0.6.0-dev.1",
+    "@prisma-next/utils": "0.6.0-dev.1"
   },
   "devDependencies": {
-    "@types/pg": "8.16.0",
-    "pg": "8.16.3",
-    "tsdown": "0.18.4",
+    "@types/pg": "8.20.0",
+    "pg": "8.20.0",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
-    "@prisma-next/tsconfig": "0.0.0",
+    "vitest": "4.1.5",
     "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },
   "files": [

package/src/authoring-type-utils.ts

@@ -38,19 +38,21 @@ export type ArgTypeFromDescriptor<Arg extends AuthoringArgumentDescriptor> = Arg
   readonly kind: 'string';
 }
   ? string
-  : Arg extends { readonly kind: 'number' }
-    ? number
-    : Arg extends { readonly kind: 'stringArray' }
-      ? readonly string[]
-      : Arg extends {
-            readonly kind: 'object';
-            readonly properties: infer Properties extends Record<
-              string,
-              AuthoringArgumentDescriptor
-            >;
-          }
-        ? ObjectArgumentType<Properties>
-        : never;
+  : Arg extends { readonly kind: 'boolean' }
+    ? boolean
+    : Arg extends { readonly kind: 'number' }
+      ? number
+      : Arg extends { readonly kind: 'stringArray' }
+        ? readonly string[]
+        : Arg extends {
+              readonly kind: 'object';
+              readonly properties: infer Properties extends Record<
+                string,
+                AuthoringArgumentDescriptor
+              >;
+            }
+          ? ObjectArgumentType<Properties>
+          : never;
 
 export type TupleFromArgumentDescriptors<Args extends readonly AuthoringArgumentDescriptor[]> = {
   readonly [K in keyof Args]: Args[K] extends AuthoringArgumentDescriptor

package/src/build-contract.ts

@@ -13,11 +13,16 @@ import {
   type ContractValueObject,
   coreHash,
   type ExecutionMutationDefault,
-  type ExecutionMutationDefaultValue,
   type JsonValue,
   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,
@@ -64,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(
@@ -198,15 +229,19 @@ export function buildSqlContractFromDefinition(
     const domainFieldRefs: Record<string, DomainFieldRef> = {};
 
     for (const field of semanticModel.fields) {
-      if (field.executionDefault) {
+      const executionDefaultPhases =
+        field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate
+          ? field.executionDefaults
+          : undefined;
+      if (executionDefaultPhases) {
         if (field.default !== undefined) {
           throw new Error(
-            `Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefault.`,
+            `Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefaults.`,
           );
         }
         if (field.nullable) {
           throw new Error(
-            `Field "${semanticModel.modelName}.${field.fieldName}" cannot be nullable when executionDefault is present.`,
+            `Field "${semanticModel.modelName}.${field.fieldName}" cannot be nullable when executionDefaults are present.`,
           );
         }
       }
@@ -227,28 +262,15 @@ export function buildSqlContractFromDefinition(
         domainFieldRefs[field.fieldName] = { kind: 'scalar', many: true };
       }
 
-      if ('executionDefault' in field && field.executionDefault) {
+      if (executionDefaultPhases) {
         executionDefaults.push({
           ref: { table: tableName, column: field.columnName },
-          onCreate: field.executionDefault as ExecutionMutationDefaultValue,
+          ...ifDefined('onCreate', executionDefaultPhases.onCreate),
+          ...ifDefined('onUpdate', executionDefaultPhases.onUpdate),
         });
       }
     }
 
-    if (semanticModel.id) {
-      const fieldsByColumnName = new Map(
-        semanticModel.fields.map((field) => [field.columnName, field]),
-      );
-      for (const columnName of semanticModel.id.columns) {
-        const field = fieldsByColumnName.get(columnName);
-        if (field?.nullable) {
-          throw new Error(
-            `Model "${semanticModel.modelName}" uses nullable field "${field.fieldName}" in its identity.`,
-          );
-        }
-      }
-    }
-
     const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
       const targetModel = assertKnownTargetModel(
         modelsByName,
@@ -287,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
@@ -457,7 +479,7 @@ export function buildSqlContractFromDefinition(
     meta: {},
   };
 
-  assertStorageSemantics(contract.storage);
+  assertStorageSemantics(definition, contract);
 
   return contract;
 }

package/src/composed-authoring-helpers.ts

@@ -5,8 +5,10 @@ import type {
   AuthoringTypeNamespace,
 } from '@prisma-next/framework-components/authoring';
 import {
+  assertNoCrossRegistryCollisions,
   isAuthoringFieldPresetDescriptor,
   isAuthoringTypeConstructorDescriptor,
+  mergeAuthoringNamespaces,
 } from '@prisma-next/framework-components/authoring';
 import type {
   ExtensionPackRef,
@@ -24,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 };
@@ -91,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>,
@@ -102,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> &
@@ -121,54 +157,6 @@ function extractFieldNamespace<Pack>(pack: Pack): ExtractFieldNamespaceFromPack<
     {}) as ExtractFieldNamespaceFromPack<Pack>;
 }
 
-function mergeHelperNamespaces(
-  target: Record<string, unknown>,
-  source: Record<string, unknown>,
-  path: readonly string[],
-  leafGuard: (value: unknown) => boolean,
-  label: string,
-): void {
-  const assertSafePath = (currentPath: readonly string[]) => {
-    const blockedSegment = currentPath.find(
-      (segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype',
-    );
-    if (blockedSegment) {
-      throw new Error(
-        `Invalid authoring ${label} helper "${currentPath.join('.')}". Helper path segments must not use "${blockedSegment}".`,
-      );
-    }
-  };
-
-  for (const [key, sourceValue] of Object.entries(source)) {
-    const currentPath = [...path, key];
-    assertSafePath(currentPath);
-    const hasExistingValue = Object.hasOwn(target, key);
-    const existingValue = hasExistingValue ? target[key] : undefined;
-
-    if (!hasExistingValue) {
-      target[key] = sourceValue;
-      continue;
-    }
-
-    const existingIsLeaf = leafGuard(existingValue);
-    const sourceIsLeaf = leafGuard(sourceValue);
-
-    if (existingIsLeaf || sourceIsLeaf) {
-      throw new Error(
-        `Duplicate authoring ${label} helper "${currentPath.join('.')}". Helper names must be unique across composed packs.`,
-      );
-    }
-
-    mergeHelperNamespaces(
-      existingValue as Record<string, unknown>,
-      sourceValue as Record<string, unknown>,
-      currentPath,
-      leafGuard,
-      label,
-    );
-  }
-}
-
 type AuthoringComponent = {
   readonly authoring?: { readonly type?: unknown; readonly field?: unknown };
 };
@@ -178,7 +166,7 @@ function composeTypeNamespace(components: readonly AuthoringComponent[]): Author
   for (const component of components) {
     const ns = extractTypeNamespace(component);
     if (Object.keys(ns).length > 0) {
-      mergeHelperNamespaces(merged, ns, [], isAuthoringTypeConstructorDescriptor, 'type');
+      mergeAuthoringNamespaces(merged, ns, [], isAuthoringTypeConstructorDescriptor, 'type');
     }
   }
   return merged as AuthoringTypeNamespace;
@@ -189,17 +177,17 @@ function composeFieldNamespace(components: readonly AuthoringComponent[]): Autho
   for (const component of components) {
     const ns = extractFieldNamespace(component);
     if (Object.keys(ns).length > 0) {
-      mergeHelperNamespaces(merged, ns, [], isAuthoringFieldPresetDescriptor, 'field');
+      mergeAuthoringNamespaces(merged, ns, [], isAuthoringFieldPresetDescriptor, 'field');
     }
   }
   return merged as AuthoringFieldNamespace;
 }
 
 function createComposedFieldHelpers(
-  components: readonly AuthoringComponent[],
+  fieldNamespace: AuthoringFieldNamespace,
 ): CoreFieldHelpers & Record<string, unknown> {
   const helperNamespace = createFieldHelpersFromNamespace(
-    composeFieldNamespace(components),
+    fieldNamespace,
     ({ helperPath, descriptor }) =>
       createFieldPresetHelper({
         helperPath,
@@ -247,10 +235,16 @@ export function createComposedAuthoringHelpers<
     ...extensionValues,
   ];
 
+  const typeNamespace = composeTypeNamespace(components);
+  const fieldNamespace = composeFieldNamespace(components);
+  // Mirrors the call in `assembleAuthoringContributions`: PSL composes via
+  // `createControlStack`, the TS DSL composes here. Both seams need the guard.
+  assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace);
+
   return {
-    field: createComposedFieldHelpers(components),
+    field: createComposedFieldHelpers(fieldNamespace),
     model,
     rel,
-    type: createTypeHelpersFromNamespace(composeTypeNamespace(components)),
+    type: createTypeHelpersFromNamespace(typeNamespace),
   } as ComposedAuthoringHelpers<Family, Target, ExtensionPacks>;
 }

package/src/contract-definition.ts

@@ -1,18 +1,18 @@
-import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
-import type {
-  ColumnTypeDescriptor,
-  ForeignKeyDefaultsState,
-} from '@prisma-next/contract-authoring';
+import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
+import type { ForeignKeyDefaultsState } from '@prisma-next/contract-authoring';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { ReferentialAction, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 
+export type { ExecutionMutationDefaultPhases };
+
 export interface FieldNode {
   readonly fieldName: string;
   readonly columnName: string;
   readonly descriptor: ColumnTypeDescriptor;
   readonly nullable: boolean;
   readonly default?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly many?: boolean;
 }
 
@@ -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 {
@@ -71,7 +71,7 @@ export interface ValueObjectFieldNode {
   readonly valueObjectName: string;
   readonly nullable: boolean;
   readonly default?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
   readonly many?: boolean;
 }