Merge pull request #422 from drizzle-team/beta

Author: dankochetov

.eslintrc.yaml

@@ -9,6 +9,7 @@ rules:
   '@typescript-eslint/consistent-type-imports':
     - error
     - disallowTypeAnnotations: false
+      fixStyle: inline-type-imports
   import/no-cycle: error
   import/no-self-import: error
   import/no-empty-named-blocks: error

.nvmrc

@@ -0,0 +1 @@
+19

README.md

@@ -2,7 +2,7 @@
 <h1>Drizzle ORM <a href=""><img alt="npm" src="https://img.shields.io/npm/v/drizzle-orm?label="></a></h1>
 <img alt="npm" src="https://img.shields.io/npm/dm/drizzle-orm">
 <img alt="npm bundle size" src="https://img.shields.io/bundlephobia/min/drizzle-orm">
-<a href="https://discord.gg/yfjTbVXMW4"><img alt="Discord" src="https://img.shields.io/discord/1043890932593987624"></a>
+<a href="https://discord.gg/yfjTbVXMW4"><img alt="Discord" src="https://img.shields.io/discord/1043890932593987624?label=Discord"></a>
 <img alt="License" src="https://img.shields.io/npm/l/drizzle-orm">
 <h6><i>If you know SQL, you know Drizzle ORM</i></h6>
 <hr />
@@ -41,6 +41,7 @@ Drizzle ORM is being battle-tested on production projects by multiple teams 🚀
 | CockroachDB                                           |   ⏳    |                                                |
 
 ## Our sponsors ❤️
+
 <p align="center">
 <a href="https://drizzle.team" target="_blank">
 <img src='https://api.drizzle.team/github/sponsors/svg'/>

changelogs/drizzle-orm/0.23.9.md

@@ -0,0 +1,19 @@
+# Transactions support 🎉
+
+You can now use transactions with all the supported databases and drivers.
+
+`node-postgres` example:
+
+```ts
+await db.transaction(async (tx) => {
+  await tx.insert(users).values(newUser);
+  await tx.update(users).set({ name: 'Mr. Dan' }).where(eq(users.name, 'Dan'));
+  await tx.delete(users).where(eq(users.name, 'Dan'));
+});
+```
+
+For more information, see transactions docs:
+
+- [PostgreSQL](/drizzle-orm/src/pg-core/README.md#transactions)
+- [MySQL](/drizzle-orm/src/mysql-core/README.md#transactions)
+- [SQLite](/drizzle-orm/src/sqlite-core/README.md#transactions)

drizzle-orm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.23.8",
+  "version": "0.23.9",
   "description": "Drizzle ORM package for SQL databases",
   "scripts": {
     "build": "tsc && resolve-tspaths && cp ../README.md package.json dist/",

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

@@ -2,7 +2,7 @@ import type { Logger } from '~/logger';
 import { DefaultLogger } from '~/logger';
 import { PgDatabase } from '~/pg-core/db';
 import { PgDialect } from '~/pg-core/dialect';
-import type { AwsDataApiClient, AwsDataApiPgQueryResultHKT} from './session';
+import type { AwsDataApiClient, AwsDataApiPgQueryResultHKT } from './session';
 import { AwsDataApiSession } from './session';
 
 export interface PgDriverOptions {
@@ -21,7 +21,7 @@ export class AwsDataApiDriver {
 	}
 
 	createSession(): AwsDataApiSession {
-		return new AwsDataApiSession(this.client, this.dialect, this.options);
+		return new AwsDataApiSession(this.client, this.dialect, this.options, undefined);
 	}
 }
 
@@ -32,7 +32,7 @@ export interface DrizzleConfig {
 	secretArn: string;
 }
 
-export type AwsDataApiPgDatabase = PgDatabase<AwsDataApiPgQueryResultHKT, AwsDataApiSession>;
+export type AwsDataApiPgDatabase = PgDatabase<AwsDataApiPgQueryResultHKT>;
 
 export class AwsPgDialect extends PgDialect {
 	override escapeName(name: string): string {

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

@@ -1,48 +1,8 @@
-import type { MigrationConfig} from '~/migrator';
+import type { MigrationConfig } from '~/migrator';
 import { readMigrationFiles } from '~/migrator';
-import { sql } from '~/sql';
 import type { AwsDataApiPgDatabase } from './driver';
 
 export async function migrate(db: AwsDataApiPgDatabase, config: string | MigrationConfig) {
 	const migrations = readMigrationFiles(config);
-
-	// TODO: Write own aws datapi migrator
-	const { session } = db;
-
-	const migrationTableCreate = sql`CREATE TABLE IF NOT EXISTS "drizzle"."__drizzle_migrations" (
-		id SERIAL PRIMARY KEY,
-		hash text NOT NULL,
-		created_at bigint
-	)`;
-	await session.execute(sql`CREATE SCHEMA IF NOT EXISTS "drizzle"`);
-	await session.execute(migrationTableCreate);
-
-	const dbMigrations = await session.execute<{ id: number; hash: string; created_at: string }[]>(
-		sql`SELECT id, hash, created_at FROM "drizzle"."__drizzle_migrations" ORDER BY created_at DESC LIMIT 1`,
-	);
-
-	const lastDbMigration = dbMigrations[0];
-	const transactionId = await session.beginTransaction();
-
-	try {
-		for await (const migration of migrations) {
-			if (
-				!lastDbMigration
-				|| parseInt(lastDbMigration.created_at, 10) < migration.folderMillis
-			) {
-				for (const stmnt of migration.sql) {
-					await session.executeWithTransaction(sql.raw(stmnt), transactionId);	
-				}
-				await session.executeWithTransaction(
-					sql`INSERT INTO "drizzle"."__drizzle_migrations" ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`,
-					transactionId,
-				);
-			}
-		}
-
-		await session.commitTransaction(transactionId!);
-	} catch (e) {
-		await session.rollbackTransaction(transactionId!);
-		throw e;
-	}
+	await db.dialect.migrate(migrations, db.session);
 }

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

@@ -1,22 +1,22 @@
-import type {
-	BeginTransactionCommandInput,
-	CommitTransactionCommandInput,
-	ExecuteStatementCommandOutput,
-	RDSDataClient,
-	RollbackTransactionCommandInput,
-} from '@aws-sdk/client-rds-data';
+import type { ExecuteStatementCommandOutput, RDSDataClient } from '@aws-sdk/client-rds-data';
 import {
 	BeginTransactionCommand,
 	CommitTransactionCommand,
 	ExecuteStatementCommand,
 	RollbackTransactionCommand,
 } from '@aws-sdk/client-rds-data';
 import type { Logger } from '~/logger';
-import type { PgDialect, PreparedQueryConfig, QueryResultHKT } from '~/pg-core';
-import { PgSession, PreparedQuery } from '~/pg-core';
+import {
+	type PgDialect,
+	PgSession,
+	PgTransaction,
+	type PgTransactionConfig,
+	PreparedQuery,
+	type PreparedQueryConfig,
+	type QueryResultHKT,
+} from '~/pg-core';
 import type { SelectedFieldsOrdered } from '~/pg-core/query-builders/select.types';
-import type { Query, QueryTypingsValue, SQL } from '~/sql';
-import { fillPlaceholders } from '~/sql';
+import { fillPlaceholders, type Query, type QueryTypingsValue, type SQL, sql } from '~/sql';
 import { mapResultRow } from '~/utils';
 import { getValueFromDataApi, toValueParam } from '../common';
 
@@ -32,8 +32,8 @@ export class AwsDataApiPreparedQuery<T extends PreparedQueryConfig> extends Prep
 		private typings: QueryTypingsValue[],
 		private options: AwsDataApiSessionOptions,
 		private fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		transactionId: string | undefined,
+		/** @internal */
+		readonly transactionId: string | undefined,
 	) {
 		super();
 		this.rawQuery = new ExecuteStatementCommand({
@@ -68,14 +68,6 @@ export class AwsDataApiPreparedQuery<T extends PreparedQueryConfig> extends Prep
 			return mapResultRow<T['execute']>(fields, mappedResult, this.joinsNotNullableMap);
 		});
 	}
-
-	all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']> {
-		throw new Error('Method not implemented.');
-	}
-
-	values(placeholderValues?: Record<string, unknown> | undefined): Promise<T['values']> {
-		throw new Error('Method not implemented.');
-	}
 }
 
 export interface AwsDataApiSessionOptions {
@@ -85,13 +77,23 @@ export interface AwsDataApiSessionOptions {
 	secretArn: string;
 }
 
-export class AwsDataApiSession extends PgSession {
-	private rawQuery: BeginTransactionCommandInput | CommitTransactionCommandInput | RollbackTransactionCommandInput;
+interface AwsDataApiQueryBase {
+	resourceArn: string;
+	secretArn: string;
+	database: string;
+}
+
+export class AwsDataApiSession extends PgSession<AwsDataApiPgQueryResultHKT> {
+	/** @internal */
+	readonly rawQuery: AwsDataApiQueryBase;
 
 	constructor(
-		private client: AwsDataApiClient,
+		/** @internal */
+		readonly client: AwsDataApiClient,
 		dialect: PgDialect,
 		private options: AwsDataApiSessionOptions,
+		/** @internal */
+		readonly transactionId: string | undefined,
 	) {
 		super(dialect);
 		this.rawQuery = {
@@ -104,25 +106,7 @@ export class AwsDataApiSession extends PgSession {
 	prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(
 		query: Query,
 		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-	): PreparedQuery<T> {
-		return new AwsDataApiPreparedQuery(
-			this.client,
-			query.sql,
-			query.params,
-			query.typings ?? [],
-			this.options,
-			fields,
-			name,
-			undefined,
-		);
-	}
-
-	prepareQueryWithTransaction<T extends PreparedQueryConfig = PreparedQueryConfig>(
-		query: Query,
-		fields: SelectedFieldsOrdered | undefined,
-		name: string | undefined,
-		transactionId: string | undefined,
+		transactionId?: string,
 	): PreparedQuery<T> {
 		return new AwsDataApiPreparedQuery(
 			this.client,
@@ -131,39 +115,52 @@ export class AwsDataApiSession extends PgSession {
 			query.typings ?? [],
 			this.options,
 			fields,
-			name,
 			transactionId,
 		);
 	}
 
-	executeWithTransaction<T>(query: SQL, transactionId: string | undefined): Promise<T> {
-		return this.prepareQueryWithTransaction<PreparedQueryConfig & { execute: T }>(
-			this.dialect.sqlToQuery(query),
-			undefined,
-			undefined,
-			transactionId,
-		).execute();
-	}
-
 	override execute<T>(query: SQL): Promise<T> {
 		return this.prepareQuery<PreparedQueryConfig & { execute: T }>(
 			this.dialect.sqlToQuery(query),
 			undefined,
-			undefined,
+			this.transactionId,
 		).execute();
 	}
 
-	async beginTransaction(): Promise<string | undefined> {
-		const transactionRes = await this.client.send(new BeginTransactionCommand(this.rawQuery));
-		return transactionRes.transactionId;
-	}
-
-	async commitTransaction(transactionId: string): Promise<void> {
-		await this.client.send(new CommitTransactionCommand({ ...this.rawQuery, transactionId }));
+	override async transaction<T>(
+		transaction: (tx: AwsDataApiTransaction) => Promise<T>,
+		config?: PgTransactionConfig | undefined,
+	): Promise<T> {
+		const { transactionId } = await this.client.send(new BeginTransactionCommand(this.rawQuery));
+		const session = new AwsDataApiSession(this.client, this.dialect, this.options, transactionId);
+		const tx = new AwsDataApiTransaction(this.dialect, session);
+		if (config) {
+			await tx.setTransaction(config);
+		}
+		try {
+			const result = await transaction(tx);
+			await this.client.send(new CommitTransactionCommand({ ...this.rawQuery, transactionId }));
+			return result;
+		} catch (e) {
+			await this.client.send(new RollbackTransactionCommand({ ...this.rawQuery, transactionId }));
+			throw e;
+		}
 	}
+}
 
-	async rollbackTransaction(transactionId: string): Promise<void> {
-		await this.client.send(new RollbackTransactionCommand({ ...this.rawQuery, transactionId }));
+export class AwsDataApiTransaction extends PgTransaction<AwsDataApiPgQueryResultHKT> {
+	override transaction<T>(transaction: (tx: AwsDataApiTransaction) => Promise<T>): Promise<T> {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new AwsDataApiTransaction(this.dialect, this.session, this.nestedIndex + 1);
+		this.session.execute(sql`savepoint ${savepointName}`);
+		try {
+			const result = transaction(tx);
+			this.session.execute(sql`release savepoint ${savepointName}`);
+			return result;
+		} catch (e) {
+			this.session.execute(sql`rollback to savepoint ${savepointName}`);
+			throw e;
+		}
 	}
 }
 

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

@@ -1,11 +1,11 @@
 import type { Database, RunResult, Statement } from 'better-sqlite3';
 import type { Logger } from '~/logger';
 import { NoopLogger } from '~/logger';
-import type { Query } from '~/sql';
-import { fillPlaceholders } from '~/sql';
+import { fillPlaceholders, type Query, sql } from '~/sql';
+import { SQLiteTransaction } from '~/sqlite-core';
 import type { SQLiteSyncDialect } from '~/sqlite-core/dialect';
 import type { SelectedFieldsOrdered } from '~/sqlite-core/query-builders/select.types';
-import type { PreparedQueryConfig as PreparedQueryConfigBase, Transaction } from '~/sqlite-core/session';
+import type { PreparedQueryConfig as PreparedQueryConfigBase, SQLiteTransactionConfig } from '~/sqlite-core/session';
 import { PreparedQuery as PreparedQueryBase, SQLiteSession } from '~/sqlite-core/session';
 import { mapResultRow } from '~/utils';
 
@@ -27,10 +27,6 @@ export class BetterSQLiteSession extends SQLiteSession<'sync', RunResult> {
 		this.logger = options.logger ?? new NoopLogger();
 	}
 
-	exec(query: string): void {
-		this.client.exec(query);
-	}
-
 	prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(
 		query: Query,
 		fields: SelectedFieldsOrdered | undefined,
@@ -39,8 +35,26 @@ export class BetterSQLiteSession extends SQLiteSession<'sync', RunResult> {
 		return new PreparedQuery(stmt, query.sql, query.params, this.logger, fields);
 	}
 
-	override transaction(): Transaction<'sync', RunResult> {
-		throw new Error('Method not implemented.');
+	override transaction<T>(transaction: (tx: BetterSQLiteTransaction) => T, config: SQLiteTransactionConfig = {}): T {
+		const tx = new BetterSQLiteTransaction(this.dialect, this);
+		const nativeTx = this.client.transaction(transaction);
+		return nativeTx[config.behavior ?? 'deferred'](tx);
+	}
+}
+
+export class BetterSQLiteTransaction extends SQLiteTransaction<'sync', RunResult> {
+	override transaction<T>(transaction: (tx: BetterSQLiteTransaction) => T): T {
+		const savepointName = `sp${this.nestedIndex}`;
+		const tx = new BetterSQLiteTransaction(this.dialect, this.session, this.nestedIndex + 1);
+		this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = transaction(tx);
+			this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
 	}
 }