@prisma-next/sql-contract 0.3.0-dev.15 → 0.3.0-dev.162

package/package.json

@@ -1,50 +1,47 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.15",
+  "version": "0.3.0-dev.162",
   "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.15"
+    "@prisma-next/contract": "0.3.0-dev.162",
+    "@prisma-next/framework-components": "0.3.0-dev.162"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@prisma-next/test-utils": "0.0.1"
+    "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
   "exports": {
-    "./types": {
-      "types": "./dist/exports/types.d.ts",
-      "import": "./dist/exports/types.js"
-    },
-    "./validators": {
-      "types": "./dist/exports/validators.d.ts",
-      "import": "./dist/exports/validators.js"
-    },
-    "./factories": {
-      "types": "./dist/exports/factories.d.ts",
-      "import": "./dist/exports/factories.js"
-    },
-    "./pack-types": {
-      "types": "./dist/exports/pack-types.d.ts",
-      "import": "./dist/exports/pack-types.js"
-    }
+    "./factories": "./dist/factories.mjs",
+    "./pack-types": "./dist/pack-types.mjs",
+    "./types": "./dist/types.mjs",
+    "./validate": "./dist/validate.mjs",
+    "./validators": "./dist/validators.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/2-sql/1-core/contract"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "typecheck": "tsc --noEmit",
     "lint": "biome check . --error-on-warnings",
     "lint:fix": "biome check --write .",
     "lint:fix:unsafe": "biome check --write --unsafe .",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/exports/factories.ts

@@ -1,11 +1 @@
-export {
-  col,
-  contract,
-  fk,
-  index,
-  model,
-  pk,
-  storage,
-  table,
-  unique,
-} from '../factories';
+export { col, fk, index, model, pk, table, unique } from '../factories';

package/src/exports/types.ts

@@ -1,17 +1,35 @@
 export type {
+  CodecTypesOf,
+  ContractWithTypeMaps,
   ExtractCodecTypes,
-  ExtractOperationTypes,
+  ExtractFieldInputTypes,
+  ExtractFieldOutputTypes,
+  ExtractQueryOperationTypes,
+  ExtractTypeMapsFromContract,
+  FieldInputTypesOf,
+  FieldOutputTypesOf,
   ForeignKey,
+  ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
-  ModelDefinition,
-  ModelField,
-  ModelStorage,
+  OperationTypesOf,
   PrimaryKey,
-  SqlContract,
-  SqlMappings,
+  QueryOperationTypeEntry,
+  QueryOperationTypesBase,
+  QueryOperationTypesOf,
+  ReferentialAction,
+  ResolveCodecTypes,
+  ResolveOperationTypes,
+  SqlModelFieldStorage,
+  SqlModelStorage,
+  SqlQueryOperationTypes,
   SqlStorage,
   StorageColumn,
   StorageTable,
+  StorageTypeInstance,
+  TypeMaps,
+  TypeMapsPhantomKey,
   UniqueConstraint,
 } from '../types';
+
+export { applyFkDefaults, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX } from '../types';

package/src/exports/validate.ts

@@ -0,0 +1 @@
+export { validateContract } from '../validate';

package/src/exports/validators.ts

@@ -1 +1 @@
-export { validateModel, validateSqlContract, validateStorage } from '../validators';
+export * from '../validators';

package/src/factories.ts

@@ -1,27 +1,18 @@
+import type { ScalarFieldType } from '@prisma-next/contract/types';
 import type {
   ForeignKey,
+  ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
-  ModelDefinition,
-  ModelField,
-  ModelStorage,
   PrimaryKey,
-  SqlContract,
-  SqlMappings,
-  SqlStorage,
+  SqlModelFieldStorage,
+  SqlModelStorage,
   StorageColumn,
   StorageTable,
   UniqueConstraint,
 } 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,
@@ -52,16 +43,20 @@ export function fk(
   columns: readonly string[],
   refTable: string,
   refColumns: readonly string[],
-  name?: string,
+  opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean },
 ): ForeignKey {
   const references: ForeignKeyReferences = {
     table: refTable,
     columns: refColumns,
   };
+
   return {
     columns,
     references,
-    ...(name !== undefined && { name }),
+    ...(opts?.name !== undefined && { name: opts.name }),
+    ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),
+    ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),
+    ...applyFkDefaults({ constraint: opts?.constraint, index: opts?.index }),
   };
 }
 
@@ -84,50 +79,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, { readonly nullable: boolean; readonly type: ScalarFieldType }>;
+  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,
+        type: { kind: 'scalar' as const, codecId: field.codecId ?? 'core/unknown@1' },
+      },
+    ]),
+  ) as Record<string, { nullable: boolean; type: ScalarFieldType }>;
   return {
     storage,
-    fields,
+    fields: domainFields,
     relations,
   };
 }
-
-export function storage(tables: Record<string, StorageTable>): SqlStorage {
-  return { tables };
-}
-
-export function contract(opts: {
-  target: string;
-  coreHash: string;
-  storage: SqlStorage;
-  models?: Record<string, ModelDefinition>;
-  relations?: Record<string, unknown>;
-  mappings?: Partial<SqlMappings>;
-  schemaVersion?: '1';
-  targetFamily?: 'sql';
-  profileHash?: string;
-  capabilities?: Record<string, Record<string, boolean>>;
-  extensionPacks?: Record<string, unknown>;
-  meta?: Record<string, unknown>;
-  sources?: Record<string, unknown>;
-}): SqlContract {
-  return {
-    schemaVersion: opts.schemaVersion ?? '1',
-    target: opts.target,
-    targetFamily: opts.targetFamily ?? 'sql',
-    coreHash: opts.coreHash,
-    storage: opts.storage,
-    models: opts.models ?? {},
-    relations: opts.relations ?? {},
-    mappings: (opts.mappings ?? {}) as SqlMappings,
-    ...(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;
-}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './exports/factories';
 export * from './exports/types';
+export * from './exports/validate';
 export * from './exports/validators';

package/src/types.ts

@@ -1,9 +1,32 @@
-import type { ContractBase } from '@prisma-next/contract/types';
+import type { ColumnDefault, StorageBase } from '@prisma-next/contract/types';
 
+/**
+ * A column definition in storage.
+ *
+ * `typeParams` is optional because most columns use non-parameterized types.
+ * Columns with parameterized types can either inline `typeParams` or reference
+ * a named {@link StorageTypeInstance} via `typeRef`.
+ */
 export type StorageColumn = {
   readonly nativeType: string;
   readonly codecId: string;
   readonly nullable: boolean;
+  /**
+   * Opaque, codec-owned JS/type parameters.
+   * The codec that owns `codecId` defines the shape and semantics.
+   * Mutually exclusive with `typeRef`.
+   */
+  readonly typeParams?: Record<string, unknown>;
+  /**
+   * Reference to a named type instance in `storage.types`.
+   * Mutually exclusive with `typeParams`.
+   */
+  readonly typeRef?: string;
+  /**
+   * Default value for the column.
+   * Can be a literal value or database function.
+   */
+  readonly default?: ColumnDefault;
 };
 
 export type PrimaryKey = {
@@ -19,6 +42,16 @@ export type UniqueConstraint = {
 export type Index = {
   readonly columns: readonly string[];
   readonly name?: string;
+  /**
+   * Optional access method identifier.
+   * Extension-specific methods are represented as strings and interpreted
+   * by the owning extension package.
+   */
+  readonly using?: string;
+  /**
+   * Optional extension-owned index configuration payload.
+   */
+  readonly config?: Record<string, unknown>;
 };
 
 export type ForeignKeyReferences = {
@@ -26,10 +59,24 @@ export type ForeignKeyReferences = {
   readonly columns: readonly string[];
 };
 
+export type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+
+export type ForeignKeyOptions = {
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+};
+
 export type ForeignKey = {
   readonly columns: readonly string[];
   readonly references: ForeignKeyReferences;
   readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
+  readonly constraint: boolean;
+  /** Whether to emit a backing index for the FK columns. */
+  readonly index: boolean;
 };
 
 export type StorageTable = {
@@ -40,48 +87,135 @@ export type StorageTable = {
   readonly foreignKeys: ReadonlyArray<ForeignKey>;
 };
 
-export type SqlStorage = {
+/**
+ * A named, parameterized type instance.
+ * These are registered in `storage.types` for reuse across columns
+ * and to enable ergonomic schema surfaces like `schema.types.MyType`.
+ *
+ * Unlike {@link StorageColumn}, `typeParams` is required here because
+ * `StorageTypeInstance` exists specifically to define reusable parameterized types.
+ * A type instance without parameters would be redundant—columns can reference
+ * the codec directly via `codecId`.
+ */
+export type StorageTypeInstance = {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+};
+
+export type SqlStorage<THash extends string = string> = StorageBase<THash> & {
   readonly tables: Record<string, StorageTable>;
+  /**
+   * Named type instances for parameterized/custom types.
+   * Columns can reference these via `typeRef`.
+   */
+  readonly types?: Record<string, StorageTypeInstance>;
 };
 
-export type ModelField = {
+export type SqlModelFieldStorage = {
   readonly column: string;
+  readonly codecId?: string;
+  readonly nullable?: boolean;
 };
 
-export type ModelStorage = {
+export type SqlModelStorage = {
   readonly table: string;
+  readonly fields: Record<string, SqlModelFieldStorage>;
 };
 
-export type ModelDefinition = {
-  readonly storage: ModelStorage;
-  readonly fields: Record<string, ModelField>;
-  readonly relations: Record<string, unknown>;
+export const DEFAULT_FK_CONSTRAINT = true;
+export const DEFAULT_FK_INDEX = true;
+
+export function applyFkDefaults(
+  fk: { constraint?: boolean | undefined; index?: boolean | undefined },
+  overrideDefaults?: { constraint?: boolean | undefined; index?: boolean | undefined },
+): { constraint: boolean; index: boolean } {
+  return {
+    constraint: fk.constraint ?? overrideDefaults?.constraint ?? DEFAULT_FK_CONSTRAINT,
+    index: fk.index ?? overrideDefaults?.index ?? DEFAULT_FK_INDEX,
+  };
+}
+
+export type TypeMaps<
+  TCodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
+  TOperationTypes extends Record<string, unknown> = Record<string, never>,
+  TQueryOperationTypes extends Record<string, unknown> = Record<string, never>,
+  TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
+  TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
+> = {
+  readonly codecTypes: TCodecTypes;
+  readonly operationTypes: TOperationTypes;
+  readonly queryOperationTypes: TQueryOperationTypes;
+  readonly fieldOutputTypes: TFieldOutputTypes;
+  readonly fieldInputTypes: TFieldInputTypes;
 };
 
-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>>;
-  readonly codecTypes: Record<string, { readonly output: unknown }>;
-  readonly operationTypes: Record<string, Record<string, unknown>>;
+export type CodecTypesOf<T> = [T] extends [never]
+  ? Record<string, never>
+  : T extends { readonly codecTypes: infer C }
+    ? C extends Record<string, { output: unknown }>
+      ? C
+      : Record<string, never>
+    : Record<string, never>;
+
+export type OperationTypesOf<T> = [T] extends [never]
+  ? Record<string, never>
+  : T extends { readonly operationTypes: infer O }
+    ? O extends Record<string, unknown>
+      ? O
+      : Record<string, never>
+    : Record<string, never>;
+
+export type QueryOperationTypeEntry = {
+  readonly args: readonly { readonly codecId: string; readonly nullable: boolean }[];
+  readonly returns: { readonly codecId: string; readonly nullable: boolean };
 };
 
-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,
-> = ContractBase & {
-  readonly targetFamily: string;
-  readonly storage: S;
-  readonly models: M;
-  readonly relations: R;
-  readonly mappings: Map;
+export type SqlQueryOperationTypes<T extends Record<string, QueryOperationTypeEntry>> = T;
+
+export type QueryOperationTypesBase = Record<string, QueryOperationTypeEntry>;
+
+export type QueryOperationTypesOf<T> = [T] extends [never]
+  ? Record<string, never>
+  : T extends { readonly queryOperationTypes: infer Q }
+    ? Q extends Record<string, unknown>
+      ? Q
+      : Record<string, never>
+    : Record<string, never>;
+
+export type TypeMapsPhantomKey = '__@prisma-next/sql-contract/typeMaps@__';
+
+export type ContractWithTypeMaps<TContract, TTypeMaps> = TContract & {
+  readonly [K in TypeMapsPhantomKey]?: TTypeMaps;
 };
 
-export type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> =
-  TContract['mappings']['codecTypes'];
+export type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T
+  ? NonNullable<T[TypeMapsPhantomKey & keyof T]>
+  : never;
+
+export type FieldOutputTypesOf<T> = [T] extends [never]
+  ? Record<string, never>
+  : T extends { readonly fieldOutputTypes: infer F }
+    ? F extends Record<string, Record<string, unknown>>
+      ? F
+      : Record<string, never>
+    : Record<string, never>;
+
+export type FieldInputTypesOf<T> = [T] extends [never]
+  ? Record<string, never>
+  : T extends { readonly fieldInputTypes: infer F }
+    ? F extends Record<string, Record<string, unknown>>
+      ? F
+      : Record<string, never>
+    : Record<string, never>;
+
+export type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;
+export type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;
+export type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;
+export type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
+
+export type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never]
+  ? ExtractCodecTypes<TContract>
+  : CodecTypesOf<TTypeMaps>;
 
-export type ExtractOperationTypes<TContract extends SqlContract<SqlStorage>> =
-  TContract['mappings']['operationTypes'];
+export type ResolveOperationTypes<_TContract, TTypeMaps> = OperationTypesOf<TTypeMaps>;