prisma · wmadden · Apr 1, 2026 · Mar 31, 2026 · Mar 31, 2026 · Mar 31, 2026
@@ -137,6 +137,8 @@ export type ModelDefinition = {
 
 export type SqlModelFieldStorage = {
   readonly column: string;
+  readonly codecId?: string;
+  readonly nullable?: boolean;
 };
 
 export type SqlModelStorage = {

@@ -141,6 +141,8 @@ const ModelFieldSchema = type({
 
 const ModelStorageFieldSchema = type({
   column: 'string',
+  'codecId?': 'string',
+  'nullable?': 'boolean',
 });
 
 const ModelStorageSchema = type({

@@ -544,6 +544,14 @@
         "column": {
           "type": "string",
           "description": "Column name in the model's backing table"
+        },
+        "codecId": {
+          "type": "string",
+          "description": "Codec identifier for the field (derived from storage column)"
+        },
+        "nullable": {
+          "type": "boolean",
+          "description": "Whether the field allows NULL values (derived from storage column)"
         }
       },
       "required": ["column"]
@@ -561,6 +569,11 @@
           "enum": ["1:1", "1:N", "N:1", "N:M"],
           "description": "Relation cardinality"
         },
+        "strategy": {
+          "type": "string",
+          "enum": ["reference", "embed"],
+          "description": "Relation strategy"
+        },
         "on": {
           "type": "object",
           "description": "Relation field mappings",

@@ -263,35 +263,41 @@ type ExtractCodecOutputType<
   : never;
 
 /**
- * Extracts the model name for a given table from the contract mappings.
+ * Extracts the model name for a given table by iterating models to find the one
+ * whose `storage.table` matches.
  */
 type ExtractTableToModel<
   Contract extends SqlContract<SqlStorage>,
   TableName extends string,
-> = Contract['mappings'] extends {
-  readonly tableToModel: infer TableToModel;
-}
-  ? TableToModel extends Record<string, string>
-    ? TableName extends keyof TableToModel
-      ? TableToModel[TableName]
-      : never
-    : never
+> = Contract['models'] extends infer Models extends Record<string, unknown>
+  ? {
+      [M in keyof Models & string]: Models[M] extends {
+        readonly storage: { readonly table: TableName };
+      }
+        ? M
+        : never;
+    }[keyof Models & string]
   : never;
 
 /**
- * Extracts the field name for a given table column from the contract mappings.
+ * Extracts the field name for a given column by finding the field in
+ * `model.storage.fields` whose `column` matches.
  */
 type ExtractColumnToField<
   Contract extends SqlContract<SqlStorage>,
   TableName extends string,
   ColumnName extends string,
-> = Contract['mappings'] extends {
-  readonly columnToField: infer ColumnToField;
-}
-  ? ColumnToField extends Record<string, Record<string, string>>
-    ? TableName extends keyof ColumnToField
-      ? ColumnName extends keyof ColumnToField[TableName]
-        ? ColumnToField[TableName][ColumnName]
+> = ExtractTableToModel<Contract, TableName> extends infer ModelName extends string
+  ? Contract['models'] extends infer Models extends Record<string, unknown>
+    ? ModelName & keyof Models extends infer MKey extends string
+      ? Models[MKey] extends {
+          readonly storage: { readonly fields: infer Fields extends Record<string, unknown> };
+        }
+        ? {
+            [F in keyof Fields & string]: Fields[F] extends { readonly column: ColumnName }
+              ? F
+              : never;
+          }[keyof Fields & string]
         : never
       : never
     : never
@@ -319,13 +325,8 @@ type ExtractFieldValue<
   : never;
 
 /**
- * Extracts the JavaScript type for a column from model mappings if available.
- * Returns `never` if the column maps to a ModelField object (which indicates
- * a relation that should fall through to codec-based type resolution).
- *
- * The check for ModelField uses `Exclude<keyof FieldValue, 'column'> extends never`
- * to ensure we only skip pure `{ column: string }` marker objects, not richer
- * object types that happen to include a `column` property.
+ * Extracts the JavaScript type for a column from model fields if available.
+ * Model fields in the .d.ts carry concrete JS types (e.g. `string`, `Char<36>`).
  */
 type ExtractColumnJsTypeFromModels<
   Contract extends SqlContract<SqlStorage>,
@@ -335,13 +336,7 @@ type ExtractColumnJsTypeFromModels<
   ? ModelName extends string
     ? ExtractColumnToField<Contract, TableName, ColumnName> extends infer FieldName
       ? FieldName extends string
-        ? ExtractFieldValue<Contract, ModelName, FieldName> extends infer FieldValue
-          ? FieldValue extends { readonly column: string }
-            ? Exclude<keyof FieldValue, 'column'> extends never
-              ? never
-              : FieldValue
-            : FieldValue
-          : never
+        ? ExtractFieldValue<Contract, ModelName, FieldName>
         : never
       : never
     : never

@@ -1,11 +1,12 @@
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import { getFieldToColumnMap } from './collection-contract';
 import type { AggregateBuilder, AggregateSelector, NumericFieldNames } from './types';
 
 export function createAggregateBuilder<
   TContract extends SqlContract<SqlStorage>,
   ModelName extends string,
 >(contract: TContract, modelName: ModelName): AggregateBuilder<TContract, ModelName> {
-  const fieldToColumn = contract.mappings.fieldToColumn?.[modelName] ?? {};
+  const fieldToColumn = getFieldToColumnMap(contract, modelName);
 
   return {
     count() {

@@ -1,19 +1,12 @@
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-
-export function mapFieldToColumn(
-  contract: SqlContract<SqlStorage>,
-  modelName: string,
-  fieldName: string,
-): string {
-  return contract.mappings.fieldToColumn?.[modelName]?.[fieldName] ?? fieldName;
-}
+import { getFieldToColumnMap } from './collection-contract';
 
 export function mapFieldsToColumns(
   contract: SqlContract<SqlStorage>,
   modelName: string,
   fieldNames: readonly string[],
 ): string[] {
-  const fieldToColumn = contract.mappings.fieldToColumn?.[modelName] ?? {};
+  const fieldToColumn = getFieldToColumnMap(contract, modelName);
   return fieldNames.map((fieldName) => fieldToColumn[fieldName] ?? fieldName);
 }
 
@@ -22,7 +15,7 @@ export function mapCursorValuesToColumns(
   modelName: string,
   cursorValues: Readonly<Record<string, unknown>>,
 ): Record<string, unknown> {
-  const fieldToColumn = contract.mappings.fieldToColumn?.[modelName] ?? {};
+  const fieldToColumn = getFieldToColumnMap(contract, modelName);
   const mappedCursor: Record<string, unknown> = {};
 
   for (const [fieldName, value] of Object.entries(cursorValues)) {