@prisma-next/sql-contract 0.3.0-dev.131 → 0.3.0-dev.132

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.131",
+  "version": "0.3.0-dev.132",
   "type": "module",
   "sideEffects": false,
   "description": "SQL contract types, validators, and IR factories for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.25",
-    "@prisma-next/contract": "0.3.0-dev.131"
+    "@prisma-next/contract": "0.3.0-dev.132"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1"
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",

package/src/construct.ts

@@ -1,158 +1,4 @@
-import type { ModelDefinition, SqlContract, SqlMappings, SqlStorage } from './types';
-
-type ResolvedMappings = {
-  modelToTable: Record<string, string>;
-  tableToModel: Record<string, string>;
-  fieldToColumn: Record<string, Record<string, string>>;
-  columnToField: Record<string, Record<string, string>>;
-};
-
-function computeDefaultMappings(models: Record<string, ModelDefinition>): ResolvedMappings {
-  const modelToTable: Record<string, string> = {};
-  const tableToModel: Record<string, string> = {};
-  const fieldToColumn: Record<string, Record<string, string>> = {};
-  const columnToField: Record<string, Record<string, string>> = {};
-
-  for (const [modelName, model] of Object.entries(models)) {
-    const tableName = model.storage.table;
-    modelToTable[modelName] = tableName;
-    tableToModel[tableName] = modelName;
-
-    const modelFieldToColumn: Record<string, string> = {};
-    for (const [fieldName, field] of Object.entries(model.fields)) {
-      const columnName = field.column;
-      modelFieldToColumn[fieldName] = columnName;
-      if (!columnToField[tableName]) {
-        columnToField[tableName] = {};
-      }
-      columnToField[tableName][columnName] = fieldName;
-    }
-
-    fieldToColumn[modelName] = modelFieldToColumn;
-  }
-
-  return {
-    modelToTable,
-    tableToModel,
-    fieldToColumn,
-    columnToField,
-  };
-}
-
-function assertInverseModelMappings(
-  modelToTable: Record<string, string>,
-  tableToModel: Record<string, string>,
-): void {
-  for (const [model, table] of Object.entries(modelToTable)) {
-    if (tableToModel[table] !== model) {
-      throw new Error(
-        `Mappings override mismatch: modelToTable.${model}="${table}" is not mirrored in tableToModel`,
-      );
-    }
-  }
-  for (const [table, model] of Object.entries(tableToModel)) {
-    if (modelToTable[model] !== table) {
-      throw new Error(
-        `Mappings override mismatch: tableToModel.${table}="${model}" is not mirrored in modelToTable`,
-      );
-    }
-  }
-}
-
-function assertInverseFieldMappings(
-  fieldToColumn: Record<string, Record<string, string>>,
-  columnToField: Record<string, Record<string, string>>,
-  modelToTable: Record<string, string>,
-  tableToModel: Record<string, string>,
-): void {
-  for (const [model, fields] of Object.entries(fieldToColumn)) {
-    const table = modelToTable[model];
-    if (!table) {
-      throw new Error(
-        `Mappings override mismatch: fieldToColumn references unknown model "${model}"`,
-      );
-    }
-    const reverseFields = columnToField[table];
-    if (!reverseFields) {
-      throw new Error(
-        `Mappings override mismatch: columnToField is missing table "${table}" for model "${model}"`,
-      );
-    }
-    for (const [field, column] of Object.entries(fields)) {
-      if (reverseFields[column] !== field) {
-        throw new Error(
-          `Mappings override mismatch: fieldToColumn.${model}.${field}="${column}" is not mirrored in columnToField.${table}`,
-        );
-      }
-    }
-  }
-
-  for (const [table, columns] of Object.entries(columnToField)) {
-    const model = tableToModel[table];
-    if (!model) {
-      throw new Error(
-        `Mappings override mismatch: columnToField references unknown table "${table}"`,
-      );
-    }
-    const forwardFields = fieldToColumn[model];
-    if (!forwardFields) {
-      throw new Error(
-        `Mappings override mismatch: fieldToColumn is missing model "${model}" for table "${table}"`,
-      );
-    }
-    for (const [column, field] of Object.entries(columns)) {
-      if (forwardFields[field] !== column) {
-        throw new Error(
-          `Mappings override mismatch: columnToField.${table}.${column}="${field}" is not mirrored in fieldToColumn.${model}`,
-        );
-      }
-    }
-  }
-}
-
-function mergeMappings(
-  defaults: ResolvedMappings,
-  existingMappings?: Partial<SqlMappings>,
-): ResolvedMappings {
-  const hasModelToTable = existingMappings?.modelToTable !== undefined;
-  const hasTableToModel = existingMappings?.tableToModel !== undefined;
-  if (hasModelToTable !== hasTableToModel) {
-    throw new Error(
-      'Mappings override mismatch: modelToTable and tableToModel must be provided together',
-    );
-  }
-
-  const hasFieldToColumn = existingMappings?.fieldToColumn !== undefined;
-  const hasColumnToField = existingMappings?.columnToField !== undefined;
-  if (hasFieldToColumn !== hasColumnToField) {
-    throw new Error(
-      'Mappings override mismatch: fieldToColumn and columnToField must be provided together',
-    );
-  }
-
-  const modelToTable: Record<string, string> = hasModelToTable
-    ? (existingMappings?.modelToTable ?? {})
-    : defaults.modelToTable;
-  const tableToModel: Record<string, string> = hasTableToModel
-    ? (existingMappings?.tableToModel ?? {})
-    : defaults.tableToModel;
-  assertInverseModelMappings(modelToTable, tableToModel);
-
-  const fieldToColumn: Record<string, Record<string, string>> = hasFieldToColumn
-    ? (existingMappings?.fieldToColumn ?? {})
-    : defaults.fieldToColumn;
-  const columnToField: Record<string, Record<string, string>> = hasColumnToField
-    ? (existingMappings?.columnToField ?? {})
-    : defaults.columnToField;
-  assertInverseFieldMappings(fieldToColumn, columnToField, modelToTable, tableToModel);
-
-  return {
-    modelToTable,
-    tableToModel,
-    fieldToColumn,
-    columnToField,
-  };
-}
+import type { SqlContract, SqlStorage } from './types';
 
 type ValidatedContractInput = SqlContract<SqlStorage> & { _generated?: unknown };
 
@@ -165,17 +11,6 @@ function stripGenerated(obj: ValidatedContractInput): Omit<ValidatedContractInpu
 export function constructContract<TContract extends SqlContract<SqlStorage>>(
   input: ValidatedContractInput,
 ): TContract {
-  const existingMappings = (input as { mappings?: Partial<SqlMappings> }).mappings;
-  const defaultMappings = computeDefaultMappings(input.models as Record<string, ModelDefinition>);
-  const mappings = mergeMappings(defaultMappings, existingMappings);
-
   const stripped = stripGenerated(input);
-
-  const contractWithMappings = {
-    ...stripped,
-    mappings,
-    roots: stripped.roots,
-  };
-
-  return contractWithMappings as TContract;
+  return stripped as TContract;
 }

package/src/exports/types.ts

@@ -9,9 +9,6 @@ export type {
   ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
-  ModelDefinition,
-  ModelField,
-  ModelStorage,
   OperationTypesOf,
   PrimaryKey,
   QueryOperationTypeEntry,
@@ -21,7 +18,6 @@ export type {
   ResolveCodecTypes,
   ResolveOperationTypes,
   SqlContract,
-  SqlMappings,
   SqlModelFieldStorage,
   SqlModelStorage,
   SqlQueryOperationTypes,

package/src/factories.ts

@@ -8,12 +8,10 @@ import type {
   ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
-  ModelDefinition,
-  ModelField,
-  ModelStorage,
   PrimaryKey,
   SqlContract,
-  SqlMappings,
+  SqlModelFieldStorage,
+  SqlModelStorage,
   SqlStorage,
   StorageColumn,
   StorageTable,
@@ -21,14 +19,6 @@ import type {
 } from './types';
 import { applyFkDefaults } from './types';
 
-/**
- * Creates a StorageColumn with nativeType and codecId.
- *
- * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')
- * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')
- * @param nullable - Whether the column is nullable (default: false)
- * @returns StorageColumn with nativeType and codecId
- */
 export function col(nativeType: string, codecId: string, nullable = false): StorageColumn {
   return {
     nativeType,
@@ -95,14 +85,27 @@ export function table(
 }
 
 export function model(
-  table: string,
-  fields: Record<string, ModelField>,
+  tableName: string,
+  fields: Record<string, SqlModelFieldStorage>,
   relations: Record<string, unknown> = {},
-): ModelDefinition {
-  const storage: ModelStorage = { table };
+): {
+  storage: SqlModelStorage;
+  fields: Record<string, { nullable: boolean; codecId?: string }>;
+  relations: Record<string, unknown>;
+} {
+  const storage: SqlModelStorage = { table: tableName, fields };
+  const domainFields = Object.fromEntries(
+    Object.entries(fields).map(([name, field]) => [
+      name,
+      {
+        nullable: field.nullable ?? false,
+        ...(field.codecId !== undefined ? { codecId: field.codecId } : {}),
+      },
+    ]),
+  ) as Record<string, { nullable: boolean; codecId?: string }>;
   return {
     storage,
-    fields,
+    fields: domainFields,
     relations,
   };
 }
@@ -120,9 +123,7 @@ export function contract<
   storageHash: TStorageHash;
   executionHash?: TExecutionHash;
   storage: SqlStorage;
-  models?: Record<string, ModelDefinition>;
-  relations?: Record<string, unknown>;
-  mappings?: Partial<SqlMappings>;
+  models?: Record<string, unknown>;
   schemaVersion?: '1';
   targetFamily?: 'sql';
   profileHash?: TProfileHash;
@@ -130,15 +131,7 @@ export function contract<
   extensionPacks?: Record<string, unknown>;
   meta?: Record<string, unknown>;
   sources?: Record<string, unknown>;
-}): SqlContract<
-  SqlStorage,
-  Record<string, unknown>,
-  Record<string, unknown>,
-  SqlMappings,
-  TStorageHash,
-  TExecutionHash,
-  TProfileHash
-> {
+}): SqlContract<SqlStorage, Record<string, unknown>, TStorageHash, TExecutionHash, TProfileHash> {
   return {
     schemaVersion: opts.schemaVersion ?? '1',
     target: opts.target,
@@ -147,20 +140,11 @@ export function contract<
     ...(opts.executionHash !== undefined && { executionHash: opts.executionHash }),
     storage: opts.storage,
     models: opts.models ?? {},
-    relations: opts.relations ?? {},
-    mappings: (opts.mappings ?? {}) as SqlMappings,
+    roots: {},
     ...(opts.profileHash !== undefined && { profileHash: opts.profileHash }),
     ...(opts.capabilities !== undefined && { capabilities: opts.capabilities }),
     ...(opts.extensionPacks !== undefined && { extensionPacks: opts.extensionPacks }),
     ...(opts.meta !== undefined && { meta: opts.meta }),
     ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),
-  } as SqlContract<
-    SqlStorage,
-    Record<string, unknown>,
-    Record<string, unknown>,
-    SqlMappings,
-    TStorageHash,
-    TExecutionHash,
-    TProfileHash
-  >;
+  } as SqlContract<SqlStorage, Record<string, unknown>, TStorageHash, TExecutionHash, TProfileHash>;
 }

package/src/types.ts

@@ -120,21 +120,6 @@ export type SqlStorage = {
   readonly types?: Record<string, StorageTypeInstance>;
 };
 
-export type ModelField = {
-  readonly column: string;
-};
-
-export type ModelStorage = {
-  readonly table: string;
-};
-
-export type ModelDefinition = {
-  readonly storage: ModelStorage;
-  readonly fields: Record<string, ModelField>;
-  readonly relations: Record<string, unknown>;
-  readonly owner?: string;
-};
-
 export type SqlModelFieldStorage = {
   readonly column: string;
   readonly codecId?: string;
@@ -152,13 +137,6 @@ export type SqlRelation = {
   readonly on: DomainRelationOn;
 };
 
-export type SqlMappings = {
-  readonly modelToTable?: Record<string, string>;
-  readonly tableToModel?: Record<string, string>;
-  readonly fieldToColumn?: Record<string, Record<string, string>>;
-  readonly columnToField?: Record<string, Record<string, string>>;
-};
-
 export const DEFAULT_FK_CONSTRAINT = true;
 export const DEFAULT_FK_INDEX = true;
 
@@ -223,17 +201,14 @@ export type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & {
 
 export type SqlContract<
   S extends SqlStorage = SqlStorage,
-  M extends Record<string, unknown> = Record<string, unknown>,
-  R extends Record<string, unknown> = Record<string, unknown>,
-  Map extends SqlMappings = SqlMappings,
+  TModels extends Record<string, unknown> = Record<string, unknown>,
   TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
   TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
   TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
-> = ContractBase<TStorageHash, TExecutionHash, TProfileHash, M> & {
+> = Omit<ContractBase<TStorageHash, TExecutionHash, TProfileHash>, 'models'> & {
   readonly targetFamily: string;
   readonly storage: S;
-  readonly relations: R;
-  readonly mappings: Map;
+  readonly models: TModels;
   readonly execution?: ExecutionSection;
 };