feat: typed constraint errors + onError config hook (#376)

drizzle-orm/src/aws-data-api/pg/driver.ts

@@ -1,5 +1,6 @@
 import { RDSDataClient, type RDSDataClientConfig } from '@aws-sdk/client-rds-data';
 import { entityKind, is } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { DefaultLogger } from '~/logger.ts';
 import { PgDatabase } from '~/pg-core/db.ts';
@@ -22,6 +23,7 @@ import { AwsDataApiSession } from './session.ts';
 export interface PgDriverOptions {
 	logger?: Logger;
 	cache?: Cache;
+	onError?: (error: DrizzleQueryError) => void;
 	database: string;
 	resourceArn: string;
 	secretArn: string;
@@ -119,7 +121,12 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		};
 	}
 
-	const session = new AwsDataApiSession(client, dialect, schema, { ...config, logger, cache: config.cache }, undefined);
+	const session = new AwsDataApiSession(client, dialect, schema, {
+		...config,
+		logger,
+		cache: config.cache,
+		onError: config.onError,
+	}, undefined);
 	const db = new AwsDataApiPgDatabase(dialect, session, schema as any);
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;

drizzle-orm/src/aws-data-api/pg/session.ts

@@ -9,6 +9,7 @@ import type { Cache } from '~/cache/core/cache.ts';
 import { NoopCache } from '~/cache/core/cache.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import {
 	type PgDialect,
@@ -151,6 +152,7 @@ export class AwsDataApiPreparedQuery<
 export interface AwsDataApiSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	onError?: (error: DrizzleQueryError) => void;
 	database: string;
 	resourceArn: string;
 	secretArn: string;
@@ -188,6 +190,7 @@ export class AwsDataApiSession<
 			database: options.database,
 		};
 		this.cache = options.cache ?? new NoopCache();
+		this.onError = options.onError;
 	}
 
 	prepareQuery<
@@ -206,19 +209,21 @@ export class AwsDataApiSession<
 		cacheConfig?: WithCacheConfig,
 		transactionId?: string,
 	): AwsDataApiPreparedQuery<T> {
-		return new AwsDataApiPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			query.typings ?? [],
-			this.options,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			transactionId ?? this.transactionId,
-			isResponseInArrayMode,
-			customResultMapper,
+		return this.attachErrorHandler(
+			new AwsDataApiPreparedQuery(
+				this.client,
+				query.sql,
+				query.params,
+				query.typings ?? [],
+				this.options,
+				this.cache,
+				queryMetadata,
+				cacheConfig,
+				fields,
+				transactionId ?? this.transactionId,
+				isResponseInArrayMode,
+				customResultMapper,
+			),
 		);
 	}
 

drizzle-orm/src/better-sqlite3/driver.ts

@@ -54,7 +54,7 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		};
 	}
 
-	const session = new BetterSQLiteSession(client, dialect, schema, { logger });
+	const session = new BetterSQLiteSession(client, dialect, schema, { logger, onError: config.onError });
 	const db = new BetterSQLite3Database('sync', dialect, session, schema);
 	(<any> db).$client = client;
 	// (<any> db).$cache = config.cache;

drizzle-orm/src/better-sqlite3/session.ts

@@ -2,6 +2,7 @@ import type { Database, RunResult, Statement } from 'better-sqlite3';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
@@ -21,6 +22,7 @@ import { mapResultRow } from '~/utils.ts';
 export interface BetterSQLiteSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	onError?: (error: DrizzleQueryError) => void;
 }
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
@@ -43,6 +45,7 @@ export class BetterSQLiteSession<
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
+		this.onError = options.onError;
 	}
 
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
@@ -58,17 +61,19 @@ export class BetterSQLiteSession<
 		cacheConfig?: WithCacheConfig,
 	): PreparedQuery<T> {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(
-			stmt,
-			query,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+		return this.attachErrorHandler(
+			new PreparedQuery(
+				stmt,
+				query,
+				this.logger,
+				this.cache,
+				queryMetadata,
+				cacheConfig,
+				fields,
+				executeMethod,
+				isResponseInArrayMode,
+				customResultMapper,
+			),
 		);
 	}
 

drizzle-orm/src/bun-sql/driver.ts

@@ -49,7 +49,11 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		};
 	}
 
-	const session = new BunSQLSession(client, dialect, schema, { logger, cache: config.cache });
+	const session = new BunSQLSession(client, dialect, schema, {
+		logger,
+		cache: config.cache,
+		onError: config.onError,
+	});
 	const db = new BunSQLDatabase(dialect, session, schema as any) as BunSQLDatabase<TSchema>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;

drizzle-orm/src/bun-sql/session.ts

@@ -4,6 +4,7 @@ import type { SavepointSQL, SQL, TransactionSQL } from 'bun';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { PgDialect } from '~/pg-core/dialect.ts';
@@ -105,6 +106,7 @@ export class BunSQLPreparedQuery<T extends PreparedQueryConfig> extends PgPrepar
 export interface BunSQLSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	onError?: (error: DrizzleQueryError) => void;
 }
 
 export class BunSQLSession<
@@ -127,6 +129,7 @@ export class BunSQLSession<
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
+		this.onError = options.onError;
 	}
 
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
@@ -141,17 +144,19 @@ export class BunSQLSession<
 		},
 		cacheConfig?: WithCacheConfig,
 	): PgPreparedQuery<T> {
-		return new BunSQLPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			isResponseInArrayMode,
-			customResultMapper,
+		return this.attachErrorHandler(
+			new BunSQLPreparedQuery(
+				this.client,
+				query.sql,
+				query.params,
+				this.logger,
+				this.cache,
+				queryMetadata,
+				cacheConfig,
+				fields,
+				isResponseInArrayMode,
+				customResultMapper,
+			),
 		);
 	}
 

drizzle-orm/src/bun-sqlite/driver.ts

@@ -75,7 +75,7 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		};
 	}
 
-	const session = new SQLiteBunSession(client, dialect, schema, { logger });
+	const session = new SQLiteBunSession(client, dialect, schema, { logger, onError: config.onError });
 	const db = new BunSQLiteDatabase('sync', dialect, session, schema) as BunSQLiteDatabase<TSchema>;
 	(<any> db).$client = client;
 

drizzle-orm/src/bun-sqlite/session.ts

@@ -2,6 +2,7 @@
 
 import type { Database, Statement as BunStatement } from 'bun:sqlite';
 import { entityKind } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
@@ -19,6 +20,7 @@ import { mapResultRow } from '~/utils.ts';
 
 export interface SQLiteBunSessionOptions {
 	logger?: Logger;
+	onError?: (error: DrizzleQueryError) => void;
 }
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
@@ -40,6 +42,7 @@ export class SQLiteBunSession<
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
+		this.onError = options.onError;
 	}
 
 	exec(query: string): void {
@@ -54,14 +57,16 @@ export class SQLiteBunSession<
 		customResultMapper?: (rows: unknown[][]) => unknown,
 	): PreparedQuery<T> {
 		const stmt = this.client.prepare(query.sql);
-		return new PreparedQuery(
-			stmt,
-			query,
-			this.logger,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+		return this.attachErrorHandler(
+			new PreparedQuery(
+				stmt,
+				query,
+				this.logger,
+				fields,
+				executeMethod,
+				isResponseInArrayMode,
+				customResultMapper,
+			),
 		);
 	}
 

drizzle-orm/src/d1/driver.ts

@@ -66,7 +66,11 @@ export function drizzle<
 		};
 	}
 
-	const session = new SQLiteD1Session(client as D1Database, dialect, schema, { logger, cache: config.cache });
+	const session = new SQLiteD1Session(client as D1Database, dialect, schema, {
+		logger,
+		cache: config.cache,
+		onError: config.onError,
+	});
 	const db = new DrizzleD1Database('async', dialect, session, schema) as DrizzleD1Database<TSchema>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;

drizzle-orm/src/d1/session.ts

@@ -4,6 +4,7 @@ import type { BatchItem } from '~/batch.ts';
 import { type Cache, NoopCache } from '~/cache/core/index.ts';
 import type { WithCacheConfig } from '~/cache/core/types.ts';
 import { entityKind } from '~/entity.ts';
+import type { DrizzleQueryError } from '~/errors.ts';
 import type { Logger } from '~/logger.ts';
 import { NoopLogger } from '~/logger.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
@@ -23,6 +24,7 @@ import { mapResultRow } from '~/utils.ts';
 export interface SQLiteD1SessionOptions {
 	logger?: Logger;
 	cache?: Cache;
+	onError?: (error: DrizzleQueryError) => void;
 }
 
 type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
@@ -45,6 +47,7 @@ export class SQLiteD1Session<
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
 		this.cache = options.cache ?? new NoopCache();
+		this.onError = options.onError;
 	}
 
 	prepareQuery(
@@ -60,17 +63,19 @@ export class SQLiteD1Session<
 		cacheConfig?: WithCacheConfig,
 	): D1PreparedQuery {
 		const stmt = this.client.prepare(query.sql);
-		return new D1PreparedQuery(
-			stmt,
-			query,
-			this.logger,
-			this.cache,
-			queryMetadata,
-			cacheConfig,
-			fields,
-			executeMethod,
-			isResponseInArrayMode,
-			customResultMapper,
+		return this.attachErrorHandler(
+			new D1PreparedQuery(
+				stmt,
+				query,
+				this.logger,
+				this.cache,
+				queryMetadata,
+				cacheConfig,
+				fields,
+				executeMethod,
+				isResponseInArrayMode,
+				customResultMapper,
+			),
 		);
 	}
 

drizzle-orm/src/durable-sqlite/driver.ts

@@ -52,7 +52,10 @@ export function drizzle<
 		};
 	}
 
-	const session = new SQLiteDOSession(client as DurableObjectStorage, dialect, schema, { logger });
+	const session = new SQLiteDOSession(client as DurableObjectStorage, dialect, schema, {
+		logger,
+		onError: config.onError,
+	});
 	const db = new DrizzleSqliteDODatabase('sync', dialect, session, schema) as DrizzleSqliteDODatabase<TSchema>;
 	(<any> db).$client = client;