Feat/support-bun-sql-sqlite

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

@@ -1,2 +1,8 @@
-export * from './driver.ts';
-export * from './session.ts';
+export { BunSQLPGDatabase as BunSQLDatabase, drizzle } from './pg/driver.ts';
+export {
+	BunSQLPGPreparedQuery as BunSQLPreparedQuery,
+	type BunSQLPGQueryResultHKT as BunSQLQueryResultHKT,
+	BunSQLPGSession as BunSQLSession,
+	type BunSQLPGSessionOptions as BunSQLSessionOptions,
+	BunSQLPGTransaction as BunSQLTransaction,
+} from './pg/session.ts';

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

@@ -1,9 +1,9 @@
 import type { MigrationConfig } from '~/migrator.ts';
 import { readMigrationFiles } from '~/migrator.ts';
-import type { BunSQLDatabase } from './driver.ts';
+import type { BunSQLPGDatabase } from './pg/driver.ts';
 
 export async function migrate<TSchema extends Record<string, unknown>>(
-	db: BunSQLDatabase<TSchema>,
+	db: BunSQLPGDatabase<TSchema>,
 	config: MigrationConfig,
 ) {
 	const migrations = readMigrationFiles(config);

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

@@ -13,19 +13,19 @@ import {
 	type TablesRelationalConfig,
 } from '~/relations.ts';
 import { type DrizzleConfig, isConfig } from '~/utils.ts';
-import type { BunSQLQueryResultHKT } from './session.ts';
-import { BunSQLSession } from './session.ts';
+import type { BunSQLPGQueryResultHKT } from './session.ts';
+import { BunSQLPGSession } from './session.ts';
 
-export class BunSQLDatabase<
+export class BunSQLPGDatabase<
 	TSchema extends Record<string, unknown> = Record<string, never>,
-> extends PgDatabase<BunSQLQueryResultHKT, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLDatabase';
+> extends PgDatabase<BunSQLPGQueryResultHKT, TSchema> {
+	static override readonly [entityKind]: string = 'BunSQLPGDatabase';
 }
 
 function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
 	client: SQL,
 	config: DrizzleConfig<TSchema> = {},
-): BunSQLDatabase<TSchema> & {
+): BunSQLPGDatabase<TSchema> & {
 	$client: SQL;
 } {
 	const dialect = new PgDialect({ casing: config.casing });
@@ -49,8 +49,8 @@ function construct<TSchema extends Record<string, unknown> = Record<string, neve
 		};
 	}
 
-	const session = new BunSQLSession(client, dialect, schema, { logger, cache: config.cache });
-	const db = new BunSQLDatabase(dialect, session, schema as any) as BunSQLDatabase<TSchema>;
+	const session = new BunSQLPGSession(client, dialect, schema, { logger, cache: config.cache });
+	const db = new BunSQLPGDatabase(dialect, session, schema as any) as BunSQLPGDatabase<TSchema>;
 	(<any> db).$client = client;
 	(<any> db).$cache = config.cache;
 	if ((<any> db).$cache) {
@@ -79,7 +79,7 @@ export function drizzle<
 			})
 		),
 	]
-): BunSQLDatabase<TSchema> & {
+): BunSQLPGDatabase<TSchema> & {
 	$client: TClient;
 } {
 	if (typeof params[0] === 'string') {
@@ -113,7 +113,7 @@ export function drizzle<
 export namespace drizzle {
 	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
 		config?: DrizzleConfig<TSchema>,
-	): BunSQLDatabase<TSchema> & {
+	): BunSQLPGDatabase<TSchema> & {
 		$client: '$client is not available on drizzle.mock()';
 	} {
 		return construct({

drizzle-orm/src/bun-sql/pg/index.ts

@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';

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

@@ -16,8 +16,8 @@ import { fillPlaceholders, type Query } from '~/sql/sql.ts';
 import { tracer } from '~/tracing.ts';
 import { type Assume, mapResultRow } from '~/utils.ts';
 
-export class BunSQLPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
-	static override readonly [entityKind]: string = 'BunSQLPreparedQuery';
+export class BunSQLPGPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
+	static override readonly [entityKind]: string = 'BunSQLPGPreparedQuery';
 
 	constructor(
 		private client: SQL,
@@ -102,17 +102,17 @@ export class BunSQLPreparedQuery<T extends PreparedQueryConfig> extends PgPrepar
 	}
 }
 
-export interface BunSQLSessionOptions {
+export interface BunSQLPGSessionOptions {
 	logger?: Logger;
 	cache?: Cache;
 }
 
-export class BunSQLSession<
+export class BunSQLPGSession<
 	TSQL extends SQL,
 	TFullSchema extends Record<string, unknown>,
 	TSchema extends TablesRelationalConfig,
-> extends PgSession<BunSQLQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLSession';
+> extends PgSession<BunSQLPGQueryResultHKT, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'BunSQLPGSession';
 
 	logger: Logger;
 	private cache: Cache;
@@ -122,7 +122,7 @@ export class BunSQLSession<
 		dialect: PgDialect,
 		private schema: RelationalSchemaConfig<TSchema> | undefined,
 		/** @internal */
-		readonly options: BunSQLSessionOptions = {},
+		readonly options: BunSQLPGSessionOptions = {},
 	) {
 		super(dialect);
 		this.logger = options.logger ?? new NoopLogger();
@@ -141,7 +141,7 @@ export class BunSQLSession<
 		},
 		cacheConfig?: WithCacheConfig,
 	): PgPreparedQuery<T> {
-		return new BunSQLPreparedQuery(
+		return new BunSQLPGPreparedQuery(
 			this.client,
 			query.sql,
 			query.params,
@@ -168,17 +168,17 @@ export class BunSQLSession<
 	}
 
 	override transaction<T>(
-		transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: BunSQLPGTransaction<TFullSchema, TSchema>) => Promise<T>,
 		config?: PgTransactionConfig,
 	): Promise<T> {
 		return this.client.begin(async (client) => {
-			const session = new BunSQLSession<TransactionSQL, TFullSchema, TSchema>(
+			const session = new BunSQLPGSession<TransactionSQL, TFullSchema, TSchema>(
 				client,
 				this.dialect,
 				this.schema,
 				this.options,
 			);
-			const tx = new BunSQLTransaction(this.dialect, session, this.schema);
+			const tx = new BunSQLPGTransaction(this.dialect, session, this.schema);
 			if (config) {
 				await tx.setTransaction(config);
 			}
@@ -187,38 +187,38 @@ export class BunSQLSession<
 	}
 }
 
-export class BunSQLTransaction<
+export class BunSQLPGTransaction<
 	TFullSchema extends Record<string, unknown>,
 	TSchema extends TablesRelationalConfig,
-> extends PgTransaction<BunSQLQueryResultHKT, TFullSchema, TSchema> {
-	static override readonly [entityKind]: string = 'BunSQLTransaction';
+> extends PgTransaction<BunSQLPGQueryResultHKT, TFullSchema, TSchema> {
+	static override readonly [entityKind]: string = 'BunSQLPGTransaction';
 
 	constructor(
 		dialect: PgDialect,
 		/** @internal */
-		override readonly session: BunSQLSession<TransactionSQL | SavepointSQL, TFullSchema, TSchema>,
+		override readonly session: BunSQLPGSession<TransactionSQL | SavepointSQL, TFullSchema, TSchema>,
 		schema: RelationalSchemaConfig<TSchema> | undefined,
 		nestedIndex = 0,
 	) {
 		super(dialect, session, schema, nestedIndex);
 	}
 
 	override transaction<T>(
-		transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: BunSQLPGTransaction<TFullSchema, TSchema>) => Promise<T>,
 	): Promise<T> {
 		return (this.session.client as TransactionSQL).savepoint((client) => {
-			const session = new BunSQLSession<SavepointSQL, TFullSchema, TSchema>(
+			const session = new BunSQLPGSession<SavepointSQL, TFullSchema, TSchema>(
 				client,
 				this.dialect,
 				this.schema,
 				this.session.options,
 			);
-			const tx = new BunSQLTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
+			const tx = new BunSQLPGTransaction<TFullSchema, TSchema>(this.dialect, session, this.schema);
 			return transaction(tx);
 		}) as Promise<T>;
 	}
 }
 
-export interface BunSQLQueryResultHKT extends PgQueryResultHKT {
+export interface BunSQLPGQueryResultHKT extends PgQueryResultHKT {
 	type: Assume<this['row'], Record<string, any>[]>;
 }

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

@@ -0,0 +1,125 @@
+/// <reference types="bun-types" />
+
+import type { SQLOptions } from 'bun';
+import { SQL } from 'bun';
+import { entityKind } from '~/entity.ts';
+import { DefaultLogger } from '~/logger.ts';
+import {
+	createTableRelationsHelpers,
+	extractTablesRelationalConfig,
+	type RelationalSchemaConfig,
+	type TablesRelationalConfig,
+} from '~/relations.ts';
+import { BaseSQLiteDatabase } from '~/sqlite-core/db.ts';
+import { SQLiteAsyncDialect } from '~/sqlite-core/dialect.ts';
+import { type DrizzleConfig, isConfig } from '~/utils.ts';
+import { BunSQLSQLiteSession } from './session.ts';
+
+export class BunSQLSQLiteDatabase<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+> extends BaseSQLiteDatabase<'async', void, TSchema> {
+	static override readonly [entityKind]: string = 'BunSQLSQLiteDatabase';
+}
+
+function construct<TSchema extends Record<string, unknown> = Record<string, never>>(
+	client: SQL,
+	config: DrizzleConfig<TSchema> = {},
+): BunSQLSQLiteDatabase<TSchema> & {
+	$client: SQL;
+} {
+	const dialect = new SQLiteAsyncDialect({ casing: config.casing });
+	let logger;
+	if (config.logger === true) {
+		logger = new DefaultLogger();
+	} else if (config.logger !== false) {
+		logger = config.logger;
+	}
+
+	let schema: RelationalSchemaConfig<TablesRelationalConfig> | undefined;
+	if (config.schema) {
+		const tablesConfig = extractTablesRelationalConfig(
+			config.schema,
+			createTableRelationsHelpers,
+		);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap,
+		};
+	}
+
+	const session = new BunSQLSQLiteSession(client, dialect, schema, { logger });
+	const db = new BunSQLSQLiteDatabase('async', dialect, session, schema as any) as BunSQLSQLiteDatabase<TSchema>;
+	(<any> db).$client = client;
+	(<any> db).$cache = config.cache;
+	if ((<any> db).$cache) {
+		(<any> db).$cache['invalidate'] = config.cache?.onMutate;
+	}
+
+	return db as any;
+}
+
+export function drizzle<
+	TSchema extends Record<string, unknown> = Record<string, never>,
+	TClient extends SQL = SQL,
+>(
+	...params: [
+		TClient | string,
+	] | [
+		TClient | string,
+		DrizzleConfig<TSchema>,
+	] | [
+		(
+			& DrizzleConfig<TSchema>
+			& ({
+				connection: string | ({ url?: string } & SQLOptions);
+			} | {
+				client: TClient;
+			})
+		),
+	]
+): BunSQLSQLiteDatabase<TSchema> & {
+	$client: TClient;
+} {
+	if (typeof params[0] === 'string') {
+		const instance = new SQL(params[0]);
+
+		return construct(instance, params[1]) as any;
+	}
+
+	if (isConfig(params[0])) {
+		const { connection, client, ...drizzleConfig } = params[0] as {
+			connection?: { url?: string } & SQLOptions;
+			client?: TClient;
+		} & DrizzleConfig<TSchema>;
+
+		if (client) return construct(client, drizzleConfig) as any;
+
+		if (typeof connection === 'object' && connection.url !== undefined) {
+			const { url, ...config } = connection;
+
+			const instance = new SQL({ url, ...config });
+			return construct(instance, drizzleConfig) as any;
+		}
+
+		const instance = new SQL(connection);
+		return construct(instance, drizzleConfig) as any;
+	}
+
+	return construct(params[0] as TClient, params[1] as DrizzleConfig<TSchema> | undefined) as any;
+}
+
+export namespace drizzle {
+	export function mock<TSchema extends Record<string, unknown> = Record<string, never>>(
+		config?: DrizzleConfig<TSchema>,
+	): BunSQLSQLiteDatabase<TSchema> & {
+		$client: '$client is not available on drizzle.mock()';
+	} {
+		return construct({
+			options: {
+				parsers: {},
+				serializers: {},
+			},
+		} as any, config) as any;
+	}
+}

drizzle-orm/src/bun-sql/sqlite/index.ts

@@ -0,0 +1,2 @@
+export * from './driver.ts';
+export * from './session.ts';