@prisma-next/sql-contract 0.3.0-dev.6 → 0.3.0-dev.62

package/dist/validators.d.mts

@@ -0,0 +1,65 @@
+import { a as ForeignKey, g as SqlStorage, l as ModelDefinition, m as SqlContract, p as ReferentialAction, s as ForeignKeyReferences } from "./types-T6o5-ZB3.mjs";
+import * as arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
+import * as arktype_internal_variants_string_ts0 from "arktype/internal/variants/string.ts";
+
+//#region src/validators.d.ts
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;
+};
+type ColumnDefaultFunction = {
+  readonly kind: 'function';
+  readonly expression: string;
+};
+declare const ColumnDefaultLiteralSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultLiteral, {}>;
+declare const ColumnDefaultFunctionSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultFunction, {}>;
+declare const ColumnDefaultSchema: arktype_internal_variants_object_ts0.ObjectType<ColumnDefaultLiteral | ColumnDefaultFunction, {}>;
+declare const ForeignKeyReferencesSchema: arktype_internal_variants_object_ts0.ObjectType<ForeignKeyReferences, {}>;
+declare const ReferentialActionSchema: arktype_internal_variants_string_ts0.StringType<ReferentialAction, {}>;
+declare const ForeignKeySchema: arktype_internal_variants_object_ts0.ObjectType<ForeignKey, {}>;
+/**
+ * Validates the structural shape of SqlStorage using Arktype.
+ *
+ * @param value - The storage value to validate
+ * @returns The validated storage if structure is valid
+ * @throws Error if the storage structure is invalid
+ */
+declare function validateStorage(value: unknown): SqlStorage;
+/**
+ * Validates the structural shape of ModelDefinition using Arktype.
+ *
+ * @param value - The model value to validate
+ * @returns The validated model if structure is valid
+ * @throws Error if the model structure is invalid
+ */
+declare function validateModel(value: unknown): ModelDefinition;
+/**
+ * Validates the structural shape of a SqlContract using Arktype.
+ *
+ * **Responsibility: Validation Only**
+ * This function validates that the contract has the correct structure and types.
+ * It does NOT normalize the contract - normalization must happen in the contract builder.
+ *
+ * The contract passed to this function must already be normalized (all required fields present).
+ * If normalization is needed, it should be done by the contract builder before calling this function.
+ *
+ * This ensures all required fields are present and have the correct types.
+ *
+ * @param value - The contract value to validate (typically from a JSON import)
+ * @returns The validated contract if structure is valid
+ * @throws Error if the contract structure is invalid
+ */
+declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
+/**
+ * Validates semantic constraints on SqlStorage that cannot be expressed in Arktype schemas.
+ *
+ * Returns an array of human-readable error strings. Empty array = valid.
+ *
+ * Currently checks:
+ * - `setNull` referential action on a non-nullable FK column (would fail at runtime)
+ * - `setDefault` referential action on a non-nullable FK column without a DEFAULT (would fail at runtime)
+ */
+declare function validateStorageSemantics(storage: SqlStorage): string[];
+//#endregion
+export { ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ForeignKeyReferencesSchema, ForeignKeySchema, ReferentialActionSchema, validateModel, validateSqlContract, validateStorage, validateStorageSemantics };
+//# sourceMappingURL=validators.d.mts.map

package/dist/validators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"sourcesContent":[],"mappings":";;;;;KAgBK,oBAAA;;8CAEyC;;AAJ7B,KAMZ,qBAAA,GAJoB;EAIpB,SAAA,IAAA,EAAA,UAAqB;EAMb,SAAA,UAAA,EAAA,MAAA;AAKb,CAAA;AAKa,cAVA,0BAUgF,EAVtD,oCAAA,CAAA,UAUsD,CAVtD,oBAUsD,EAAA,CAAA,CAAA,CAAA;AAA7D,cALnB,2BAKmB,EALQ,oCAAA,CAAA,UAKR,CALQ,qBAKR,EAAA,CAAA,CAAA,CAAA;AAAA,cAAnB,mBAAmB,EAAA,oCAAA,CAAA,UAAA,CAAA,oBAAA,GAAA,qBAAA,EAAA,CAAA,CAAA,CAAA;AAAA,cAgEnB,0BAhEmB,EAgEO,oCAAA,CAAA,UAhEP,CAgEO,oBAhEP,EAAA,CAAA,CAAA,CAAA;AAAA,cAqEnB,uBArEmB,EAqEI,oCAAA,CAAA,UArEJ,CAqEI,iBArEJ,EAAA,CAAA,CAAA,CAAA;AAgEnB,cASA,gBANX,EAM2B,oCAAA,CAAA,UATU,CASV,UATU,EAAA,CAAA,CAAA,CAAA;AAKvC;AAIA;AAwFA;AAgBA;AAyBA;;;AAAwF,iBAzCxE,eAAA,CAyCwE,KAAA,EAAA,OAAA,CAAA,EAzCvC,UAyCuC;;AAiCxF;;;;;;iBA1DgB,aAAA,kBAA+B;;;;;;;;;;;;;;;;;iBAyB/B,8BAA8B,YAAY,8BAA8B;;;;;;;;;;iBAiCxE,wBAAA,UAAkC"}

package/dist/validators.mjs

@@ -0,0 +1,3 @@
+import { a as ForeignKeySchema, c as validateSqlContract, i as ForeignKeyReferencesSchema, l as validateStorage, n as ColumnDefaultLiteralSchema, o as ReferentialActionSchema, r as ColumnDefaultSchema, s as validateModel, t as ColumnDefaultFunctionSchema, u as validateStorageSemantics } from "./validators-Dz93b38w.mjs";
+
+export { ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ForeignKeyReferencesSchema, ForeignKeySchema, ReferentialActionSchema, validateModel, validateSqlContract, validateStorage, validateStorageSemantics };

package/package.json

@@ -1,50 +1,46 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.6",
+  "version": "0.3.0-dev.62",
   "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.6"
+    "@prisma-next/contract": "0.3.0-dev.62"
   },
   "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/tsconfig": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1",
+    "@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",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/exports/types.ts

@@ -2,16 +2,21 @@ export type {
   ExtractCodecTypes,
   ExtractOperationTypes,
   ForeignKey,
+  ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
   ModelDefinition,
   ModelField,
   ModelStorage,
   PrimaryKey,
+  ReferentialAction,
   SqlContract,
   SqlMappings,
   SqlStorage,
   StorageColumn,
   StorageTable,
+  StorageTypeInstance,
   UniqueConstraint,
 } from '../types';
+
+export { applyFkDefaults, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX } from '../types';

package/src/exports/validate.ts

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

package/src/exports/validators.ts

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

package/src/factories.ts

@@ -1,5 +1,11 @@
+import type {
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
 import type {
   ForeignKey,
+  ForeignKeyOptions,
   ForeignKeyReferences,
   Index,
   ModelDefinition,
@@ -13,6 +19,7 @@ import type {
   StorageTable,
   UniqueConstraint,
 } from './types';
+import { applyFkDefaults } from './types';
 
 /**
  * Creates a StorageColumn with nativeType and codecId.
@@ -52,16 +59,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 }),
   };
 }
 
@@ -100,26 +111,40 @@ export function storage(tables: Record<string, StorageTable>): SqlStorage {
   return { tables };
 }
 
-export function contract(opts: {
+export function contract<
+  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
+  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
+  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
+>(opts: {
   target: string;
-  coreHash: string;
+  storageHash: TStorageHash;
+  executionHash?: TExecutionHash;
   storage: SqlStorage;
   models?: Record<string, ModelDefinition>;
   relations?: Record<string, unknown>;
   mappings?: Partial<SqlMappings>;
   schemaVersion?: '1';
   targetFamily?: 'sql';
-  profileHash?: string;
+  profileHash?: TProfileHash;
   capabilities?: Record<string, Record<string, boolean>>;
   extensionPacks?: Record<string, unknown>;
   meta?: Record<string, unknown>;
   sources?: Record<string, unknown>;
-}): SqlContract {
+}): SqlContract<
+  SqlStorage,
+  Record<string, unknown>,
+  Record<string, unknown>,
+  SqlMappings,
+  TStorageHash,
+  TExecutionHash,
+  TProfileHash
+> {
   return {
     schemaVersion: opts.schemaVersion ?? '1',
     target: opts.target,
     targetFamily: opts.targetFamily ?? 'sql',
-    coreHash: opts.coreHash,
+    storageHash: opts.storageHash,
+    ...(opts.executionHash !== undefined && { executionHash: opts.executionHash }),
     storage: opts.storage,
     models: opts.models ?? {},
     relations: opts.relations ?? {},
@@ -129,5 +154,13 @@ export function contract(opts: {
     ...(opts.extensionPacks !== undefined && { extensionPacks: opts.extensionPacks }),
     ...(opts.meta !== undefined && { meta: opts.meta }),
     ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),
-  } as SqlContract;
+  } as SqlContract<
+    SqlStorage,
+    Record<string, unknown>,
+    Record<string, unknown>,
+    SqlMappings,
+    TStorageHash,
+    TExecutionHash,
+    TProfileHash
+  >;
 }

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,39 @@
-import type { ContractBase } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ContractBase,
+  ExecutionHashBase,
+  ExecutionSection,
+  ProfileHashBase,
+  StorageHashBase,
+} 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 = {
@@ -26,10 +56,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,8 +84,29 @@ export type StorageTable = {
   readonly foreignKeys: ReadonlyArray<ForeignKey>;
 };
 
+/**
+ * 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 = {
   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 = {
@@ -67,17 +132,38 @@ export type SqlMappings = {
   readonly operationTypes: Record<string, Record<string, unknown>>;
 };
 
+export const DEFAULT_FK_CONSTRAINT = true;
+export const DEFAULT_FK_INDEX = true;
+
+/**
+ * Resolves foreign key `constraint` and `index` fields to their effective boolean values,
+ * falling back through optional override defaults, then to the global defaults.
+ */
+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 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 & {
+  TStorageHash extends StorageHashBase<string> = StorageHashBase<string>,
+  TExecutionHash extends ExecutionHashBase<string> = ExecutionHashBase<string>,
+  TProfileHash extends ProfileHashBase<string> = ProfileHashBase<string>,
+> = ContractBase<TStorageHash, TExecutionHash, TProfileHash> & {
   readonly targetFamily: string;
   readonly storage: S;
   readonly models: M;
   readonly relations: R;
   readonly mappings: Map;
+  readonly execution?: ExecutionSection;
 };
 
 export type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> =