@drizzle-adapter/d1 1.0.18 → 2.0.0

package/README.md

@@ -60,33 +60,43 @@ await client.run(sql`SELECT * FROM users`);
 ```
 
 ### Transaction Compatibility
-**Important**: Cloudflare D1 does not support real SQL transactions. This adapter provides a compatibility layer that allows transaction-based code to run without modifications, but **without transaction guarantees**:
+**Breaking in 2.0.0**: Cloudflare D1 has no interactive transactions. `transaction()` now throws `D1TransactionUnsupportedError` instead of running the callback without atomicity. The callback is never invoked.
 
 ```typescript
-// This code will run without errors, but operations are NOT atomic
-await client.transaction(async (tx) => {
-  await tx.insert(users).values({ name: 'John' });
-  await tx.update(posts).set({ published: 1 });
-  // If an error occurs here, previous operations will NOT be rolled back
-});
+import { D1TransactionUnsupportedError } from '@drizzle-adapter/d1';
+
+try {
+  await client.transaction(async (tx) => { /* never runs */ });
+} catch (caughtError) {
+  if (caughtError instanceof D1TransactionUnsupportedError) {
+    // use db.batch() instead
+  }
+}
 ```
 
-**For atomic operations**, use D1's batch API directly:
+**For atomic operations**, use `db.batch()`. It runs as one implicit SQL transaction (all-or-nothing):
 
 ```typescript
-// This provides atomic execution - all succeed or all fail
+import { sql } from 'drizzle-orm';
+
 const results = await client.batch([
-  client.insert(users).values({ name: 'John' }).prepare(),
-  client.update(posts).set({ published: 1 }).prepare()
+  client.insert(users).values({ name: 'John' }),
+  client.run(sql`UPDATE posts SET published = 1 WHERE id = ${postId}`)
 ]);
 ```
 
 ### Migration Considerations
-- **Transaction Compatibility**: Existing code using `db.transaction()` will work without modification
+- **Transaction Compatibility**: Since 2.0.0, `db.transaction()` throws `D1TransactionUnsupportedError`; migrate to `db.batch()`
 - **No Rollback**: Failed operations cannot be automatically rolled back
 - **Batch Operations**: Use `db.batch()` for operations that require atomicity
 - **Error Handling**: Implement manual cleanup logic for critical operations
 
+### Releasing
+```bash
+pnpm check && pnpm lint && pnpm test
+pnpm --filter @drizzle-adapter/d1 publish --access public   # run from the repo root
+```
+
 ## Usage
 
 ### Cloudflare Workers Setup

package/dist/Adapter/D1DrizzleAdapter.d.ts

@@ -1,13 +1,13 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
+import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
 import { D1DrizzleConnection } from './D1DrizzleConnection.js';
-import { D1DrizzleDataTypes } from './D1DrizzleDataTypes.js';
 /**
  * D1 adapter implementation for Drizzle ORM.
  * Provides D1-specific database operations and connection management.
  */
 export declare class D1DrizzleAdapter implements DrizzleAdapterInterface {
-    private connection;
+    private readonly connection;
     /**
      * Constructor.
      *
@@ -23,9 +23,9 @@ export declare class D1DrizzleAdapter implements DrizzleAdapterInterface {
     /**
      * Returns the data types.
      *
-     * @returns {D1DrizzleDataTypes} The D1 data types instance
+     * @returns {SqliteCoreDrizzleDataTypes} The SQLite core data types instance
      */
-    getDataTypes(): D1DrizzleDataTypes;
+    getDataTypes(): SqliteCoreDrizzleDataTypes;
     /**
      * Returns the dialect.
      *

package/dist/Adapter/D1DrizzleAdapter.js

@@ -1,5 +1,5 @@
+import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
 import { D1DrizzleConnection } from './D1DrizzleConnection.js';
-import { D1DrizzleDataTypes } from './D1DrizzleDataTypes.js';
 /**
  * D1 adapter implementation for Drizzle ORM.
  * Provides D1-specific database operations and connection management.
@@ -25,10 +25,10 @@ export class D1DrizzleAdapter {
     /**
      * Returns the data types.
      *
-     * @returns {D1DrizzleDataTypes} The D1 data types instance
+     * @returns {SqliteCoreDrizzleDataTypes} The SQLite core data types instance
      */
     getDataTypes() {
-        return new D1DrizzleDataTypes();
+        return new SqliteCoreDrizzleDataTypes();
     }
     /**
      * Returns the dialect.

package/dist/Adapter/D1DrizzleConnection.d.ts

@@ -1,12 +1,12 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
-import type { D1DrizzleClientInterface } from 'src/Interface';
+import type { D1DrizzleClientInterface } from '../Interface/D1DrizzleClientInterface.js';
 /**
  * D1 connection implementation for Drizzle ORM.
  * Manages database connections and provides client access for D1 databases.
  */
 export declare class D1DrizzleConnection implements DrizzleConnectionInterface {
-    private client;
+    private readonly client;
     /**
      * Constructor.
      *

package/dist/Adapter/D1DrizzleConnection.js

@@ -1,4 +1,5 @@
 import { drizzle } from 'drizzle-orm/d1';
+import { D1TransactionUnsupportedError } from '../Error/D1TransactionUnsupportedError.js';
 /**
  * D1 connection implementation for Drizzle ORM.
  * Manages database connections and provides client access for D1 databases.
@@ -13,15 +14,18 @@ export class D1DrizzleConnection {
     constructor(driver) {
         // We want to add the execute method as an alias for run
         const database = drizzle(driver);
-        database.execute = database.run;
-        // Override transaction method to provide transaction-like behavior
-        // Since D1 doesn't support real transactions, we pass the original client
-        // Users can implement their own batching if needed for atomicity
-        database.transaction = async (callback) => {
-            // For now, just pass the original client - no transaction isolation
-            // This allows code to work without modifications while being explicit about the limitation
-            return await callback(database);
-        };
+        database.execute =
+            database.run;
+        /**
+         * Replaces drizzle's transaction. drizzle-orm d1/session.js transaction() issues raw `begin`, which D1 rejects (probe in 1TS-Monorepo#4023).
+         * The callback is never run; callers must use batch().
+         * @returns {Promise<never>} Always rejects with D1TransactionUnsupportedError.
+         */
+        database.transaction =
+            async () => {
+                // `return await` satisfies both require-await and the no-bare-throw lint rules
+                return await Promise.reject(new D1TransactionUnsupportedError());
+            };
         this.client = database;
     }
     /**

package/dist/Adapter/D1DrizzleMigrator.d.ts

@@ -1,5 +1,5 @@
 import type { DrizzleMigratorInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
-import type { D1DrizzleClientInterface } from '../Interface/index.js';
+import type { D1DrizzleClientInterface } from '../Interface/D1DrizzleClientInterface.js';
 /**
  * D1 migrator implementation for Drizzle ORM.
  * Handles database migrations for D1 databases.

package/dist/Error/D1TransactionUnsupportedError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Thrown by transaction() on a D1 client. D1 has no interactive transactions,
+ * so the callback could not run atomically.
+ */
+export declare class D1TransactionUnsupportedError extends Error {
+    /**
+     * Constructor.
+     */
+    constructor();
+}

package/dist/Error/D1TransactionUnsupportedError.js

@@ -0,0 +1,13 @@
+/**
+ * Thrown by transaction() on a D1 client. D1 has no interactive transactions,
+ * so the callback could not run atomically.
+ */
+export class D1TransactionUnsupportedError extends Error {
+    /**
+     * Constructor.
+     */
+    constructor() {
+        super('D1 has no interactive transactions, so transaction() would run your callback without atomicity. Use db.batch([...]) instead: it is atomic (one implicit SQL transaction, all-or-nothing). Wrap raw SQL as db.run(sql`...`) inside the batch.');
+        this.name = 'D1TransactionUnsupportedError';
+    }
+}

package/dist/Interface/D1DrizzleClientInterface.d.ts

@@ -13,5 +13,6 @@ export interface D1DrizzleClientInterface extends DrizzleClientInterface {
     selectDistinct(...args: any[]): ReturnType<AnyD1Database['selectDistinct']>;
     update(...args: any[]): ReturnType<AnyD1Database['update']>;
     insert(...args: any[]): ReturnType<AnyD1Database['insert']>;
-    transaction(...args: any[]): ReturnType<AnyD1Database['transaction']>;
+    /** Always rejects with D1TransactionUnsupportedError — use batch(). */
+    transaction(...args: unknown[]): Promise<never>;
 }

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export * from './Adapter/index.js';
-export * from './Factory/index.js';
-export * from './Interface/index.js';
-export * from './Type/index.js';
-import { D1DrizzleAdapterFactory } from './Factory/index.js';
+import { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory.js';
+export { D1DrizzleAdapter } from './Adapter/D1DrizzleAdapter.js';
+export { D1DrizzleConnection } from './Adapter/D1DrizzleConnection.js';
+export { D1TransactionUnsupportedError } from './Error/D1TransactionUnsupportedError.js';
+export { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory.js';
+export { D1DrizzleDataTypesFactory } from './Factory/D1DrizzleDataTypesFactory.js';
+export * from './Interface/D1DrizzleClientInterface.js';
+export * from './Type/Types.js';
 export default D1DrizzleAdapterFactory;

package/dist/index.js

@@ -1,10 +1,14 @@
-export * from './Adapter/index.js';
-export * from './Factory/index.js';
-export * from './Interface/index.js';
-export * from './Type/index.js';
 // default export so that core factory can use it directly
-import { D1DrizzleAdapterFactory, D1DrizzleDataTypesFactory } from './Factory/index.js';
-export default D1DrizzleAdapterFactory;
 import { DrizzleAdapterFactoryRegistry, DrizzleDataTypesFactoryRegistry } from '@drizzle-adapter/core';
+import { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory.js';
+import { D1DrizzleDataTypesFactory } from './Factory/D1DrizzleDataTypesFactory.js';
+export { D1DrizzleAdapter } from './Adapter/D1DrizzleAdapter.js';
+export { D1DrizzleConnection } from './Adapter/D1DrizzleConnection.js';
+export { D1TransactionUnsupportedError } from './Error/D1TransactionUnsupportedError.js';
+export { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory.js';
+export { D1DrizzleDataTypesFactory } from './Factory/D1DrizzleDataTypesFactory.js';
+export * from './Interface/D1DrizzleClientInterface.js';
+export * from './Type/Types.js';
+export default D1DrizzleAdapterFactory;
 DrizzleAdapterFactoryRegistry.registerAdapterFactory('d1', D1DrizzleAdapterFactory);
 DrizzleDataTypesFactoryRegistry.registerDataTypesFactory('d1', D1DrizzleDataTypesFactory);

package/dist/migrator.d.ts

@@ -1,4 +1,4 @@
+import { D1DrizzleMigratorFactory } from './Factory/D1DrizzleMigratorFactory.js';
 export * from './Adapter/D1DrizzleMigrator.js';
 export * from './Factory/D1DrizzleMigratorFactory.js';
-import { D1DrizzleMigratorFactory } from './Factory/D1DrizzleMigratorFactory.js';
 export default D1DrizzleMigratorFactory;

package/dist/migrator.js

@@ -1,7 +1,7 @@
-export * from './Adapter/D1DrizzleMigrator.js';
-export * from './Factory/D1DrizzleMigratorFactory.js';
 // default export so that core factory can use it directly
+import { DrizzleMigratorFactoryRegistry } from '@drizzle-adapter/core/migrator';
 import { D1DrizzleMigratorFactory } from './Factory/D1DrizzleMigratorFactory.js';
+export * from './Adapter/D1DrizzleMigrator.js';
+export * from './Factory/D1DrizzleMigratorFactory.js';
 export default D1DrizzleMigratorFactory;
-import { DrizzleMigratorFactoryRegistry } from '@drizzle-adapter/core/migrator';
 DrizzleMigratorFactoryRegistry.registerMigratorFactory('d1', D1DrizzleMigratorFactory);

package/eslint.config.mjs

@@ -1,4 +1,4 @@
-import eslintConfig from '@dmitryrechkin/eslint-standard/eslint.config.mjs';
+import eslintConfig from '@dmitryrechkin/eslint-standard';
 
 export default eslintConfig({
 	tsconfigPath: './tsconfig.eslint.json',

package/package.json

@@ -1,38 +1,19 @@
 {
   "name": "@drizzle-adapter/d1",
   "type": "module",
-  "version": "1.0.18",
+  "version": "2.0.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./migrator": {
-      "import": "./dist/migrator.js",
-      "types": "./dist/migrator.d.ts"
+      "types": "./dist/migrator.d.ts",
+      "default": "./dist/migrator.js"
     }
   },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250419.0",
-    "@dmitryrechkin/eslint-standard": "^1.0.7",
-    "dotenv": "^17.0.1",
-    "eslint": "^9.30.1",
-    "eslint-plugin-unused-imports": "^4.1.4",
-    "shx": "^0.4.0",
-    "tsc-esm-fix": "^3.1.2",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.4",
-    "wrangler": "^3.114.11"
-  },
-  "dependencies": {
-    "drizzle-orm": "^0.44.2",
-    "@drizzle-adapter/core": "^1.0.14",
-    "@drizzle-adapter/sqlite-core": "^1.0.14"
-  },
-  "license": "MIT",
   "scripts": {
     "lint": "eslint src/",
     "format": "eslint --fix src/",
@@ -40,6 +21,27 @@
     "check": "tsc --noEmit",
     "build": "shx rm -rf dist && tsc && tsc-esm-fix",
     "package:tgz": "pnpm pack",
-    "package:publish": "pnpm publish --access public"
-  }
-}
+    "package:publish": "pnpm publish --access public",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260317.1",
+    "@dmitryrechkin/eslint-standard": "^1.5.13",
+    "dotenv": "^17.3.1",
+    "eslint": "^10.1.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "miniflare": "4.20260317.2",
+    "shx": "^0.4.0",
+    "tsc-esm-fix": "^3.1.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.1",
+    "wrangler": "^4.77.0"
+  },
+  "dependencies": {
+    "@drizzle-adapter/core": "workspace:^",
+    "@drizzle-adapter/sqlite-core": "workspace:^",
+    "drizzle-orm": "^0.45.1"
+  },
+  "license": "MIT"
+}

package/src/Adapter/D1DrizzleAdapter.ts

@@ -1,8 +1,8 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
+import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
 
 import { D1DrizzleConnection } from './D1DrizzleConnection';
-import { D1DrizzleDataTypes } from './D1DrizzleDataTypes';
 
 /**
  * D1 adapter implementation for Drizzle ORM.
@@ -10,14 +10,14 @@ import { D1DrizzleDataTypes } from './D1DrizzleDataTypes';
  */
 export class D1DrizzleAdapter implements DrizzleAdapterInterface
 {
-	private connection: D1DrizzleConnection;
+	private readonly connection: D1DrizzleConnection;
 
 	/**
 	 * Constructor.
 	 *
 	 * @param {D1Database} driver - The D1 database driver instance
 	 */
-	public constructor(driver: D1Database)
+	constructor(driver: D1Database)
 	{
 		this.connection = new D1DrizzleConnection(driver);
 	}
@@ -35,11 +35,11 @@ export class D1DrizzleAdapter implements DrizzleAdapterInterface
 	/**
 	 * Returns the data types.
 	 *
-	 * @returns {D1DrizzleDataTypes} The D1 data types instance
+	 * @returns {SqliteCoreDrizzleDataTypes} The SQLite core data types instance
 	 */
-	public getDataTypes(): D1DrizzleDataTypes
+	public getDataTypes(): SqliteCoreDrizzleDataTypes
 	{
-		return new D1DrizzleDataTypes();
+		return new SqliteCoreDrizzleDataTypes();
 	}
 
 	/**

package/src/Adapter/D1DrizzleConnection.ts

@@ -1,7 +1,9 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
 import { drizzle } from 'drizzle-orm/d1';
-import type { D1DrizzleClientInterface } from 'src/Interface';
+
+import { D1TransactionUnsupportedError } from '../Error/D1TransactionUnsupportedError';
+import type { D1DrizzleClientInterface } from '../Interface/D1DrizzleClientInterface';
 
 /**
  * D1 connection implementation for Drizzle ORM.
@@ -9,29 +11,35 @@ import type { D1DrizzleClientInterface } from 'src/Interface';
  */
 export class D1DrizzleConnection implements DrizzleConnectionInterface
 {
-	private client: D1DrizzleClientInterface;
+	private readonly client: D1DrizzleClientInterface;
 
 	/**
 	 * Constructor.
 	 *
 	 * @param {D1Database} driver - The D1 database driver instance
 	 */
-	public constructor(driver: D1Database)
+	constructor(driver: D1Database)
 	{
 		// We want to add the execute method as an alias for run
-		const database: ReturnType<typeof drizzle> | D1DrizzleClientInterface = drizzle(driver);
-		(database as unknown  as D1DrizzleClientInterface).execute = database.run;
+		const database: ReturnType<typeof drizzle> | D1DrizzleClientInterface =
+			drizzle(driver);
+
+		(database as unknown as D1DrizzleClientInterface).execute =
+			database.run;
 
-		// Override transaction method to provide transaction-like behavior
-		// Since D1 doesn't support real transactions, we pass the original client
-		// Users can implement their own batching if needed for atomicity
-		(database as unknown as D1DrizzleClientInterface).transaction = async <T>(
-			callback: (tx: D1DrizzleClientInterface) => Promise<T>
-		): Promise<T> => {
-			// For now, just pass the original client - no transaction isolation
-			// This allows code to work without modifications while being explicit about the limitation
-			return await callback(database as unknown as D1DrizzleClientInterface);
-		};
+		/**
+		 * Replaces drizzle's transaction. drizzle-orm d1/session.js transaction() issues raw `begin`, which D1 rejects (probe in 1TS-Monorepo#4023).
+		 * The callback is never run; callers must use batch().
+		 * @returns {Promise<never>} Always rejects with D1TransactionUnsupportedError.
+		 */
+		(database as unknown as D1DrizzleClientInterface).transaction =
+			async (): Promise<never> =>
+			{
+				// `return await` satisfies both require-await and the no-bare-throw lint rules
+				return await Promise.reject(
+					new D1TransactionUnsupportedError()
+				);
+			};
 
 		this.client = database as unknown as D1DrizzleClientInterface;
 	}

package/src/Adapter/D1DrizzleMigrator.ts

@@ -1,7 +1,10 @@
-import type { DrizzleMigratorInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
+import type {
+	DrizzleMigratorInterface,
+	TypeDrizzleMigratorConfig
+} from '@drizzle-adapter/core';
 import { DrizzleD1Database } from 'drizzle-orm/d1/driver';
 
-import type { D1DrizzleClientInterface } from '../Interface';
+import type { D1DrizzleClientInterface } from '../Interface/D1DrizzleClientInterface';
 
 /**
  * D1 migrator implementation for Drizzle ORM.
@@ -14,7 +17,8 @@ export class D1DrizzleMigrator implements DrizzleMigratorInterface
 	 *
 	 * @param {TypeDrizzleMigratorConfig} config The migrator configuration.
 	 */
-	public constructor(private readonly config: TypeDrizzleMigratorConfig) {}
+	constructor(private readonly config: TypeDrizzleMigratorConfig)
+	{}
 
 	/**
 	 * Migrate the database.
@@ -24,10 +28,14 @@ export class D1DrizzleMigrator implements DrizzleMigratorInterface
 	public async migrate(client: D1DrizzleClientInterface): Promise<void>
 	{
 		const { migrate } = await import('drizzle-orm/d1/migrator');
-		await migrate(client as unknown as DrizzleD1Database<Record<string, unknown>>, {
-			migrationsFolder: this.config.DATABASE_MIGRATIONS_FOLDER,
-			migrationsTable: this.config.DATABASE_MIGRATIONS_TABLE,
-			migrationsSchema: this.config.DATABASE_MIGRATIONS_SCHEMA
-		});
+
+		await migrate(
+			client as unknown as DrizzleD1Database<Record<string, unknown>>,
+			{
+				migrationsFolder: this.config.DATABASE_MIGRATIONS_FOLDER,
+				migrationsTable: this.config.DATABASE_MIGRATIONS_TABLE,
+				migrationsSchema: this.config.DATABASE_MIGRATIONS_SCHEMA
+			}
+		);
 	}
 }

package/src/Error/D1TransactionUnsupportedError.ts

@@ -0,0 +1,17 @@
+/**
+ * Thrown by transaction() on a D1 client. D1 has no interactive transactions,
+ * so the callback could not run atomically.
+ */
+export class D1TransactionUnsupportedError extends Error
+{
+	/**
+	 * Constructor.
+	 */
+	constructor()
+	{
+		super(
+			'D1 has no interactive transactions, so transaction() would run your callback without atomicity. Use db.batch([...]) instead: it is atomic (one implicit SQL transaction, all-or-nothing). Wrap raw SQL as db.run(sql`...`) inside the batch.'
+		);
+		this.name = 'D1TransactionUnsupportedError';
+	}
+}

package/src/Factory/D1DrizzleDataTypesFactory.ts

@@ -1,4 +1,7 @@
-import type { DrizzleDataTypesFactoryInterface, TypeDrizzleDatabaseConfig } from '@drizzle-adapter/core';
+import type {
+	DrizzleDataTypesFactoryInterface,
+	TypeDrizzleDatabaseConfig
+} from '@drizzle-adapter/core';
 import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
 
 /**
@@ -13,7 +16,9 @@ export class D1DrizzleDataTypesFactory implements DrizzleDataTypesFactoryInterfa
 	 * @param {TypeDrizzleDatabaseConfig} _config - Not used in this implementation
 	 * @returns {SqliteCoreDrizzleDataTypes} A new SQLite core data types instance
 	 */
-	public create(_config: TypeDrizzleDatabaseConfig): SqliteCoreDrizzleDataTypes
+	public create(
+		_config: TypeDrizzleDatabaseConfig
+	): SqliteCoreDrizzleDataTypes
 	{
 		return new SqliteCoreDrizzleDataTypes();
 	}

package/src/Factory/D1DrizzleMigratorFactory.ts

@@ -1,4 +1,7 @@
-import type { DrizzleMigratorFactoryInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
+import type {
+	DrizzleMigratorFactoryInterface,
+	TypeDrizzleMigratorConfig
+} from '@drizzle-adapter/core';
 
 import { D1DrizzleMigrator } from '../migrator';
 

package/src/Interface/D1DrizzleClientInterface.ts

@@ -15,5 +15,6 @@ export interface D1DrizzleClientInterface extends DrizzleClientInterface
 	selectDistinct(...args: any[]): ReturnType<AnyD1Database['selectDistinct']>;
 	update(...args: any[]): ReturnType<AnyD1Database['update']>;
 	insert(...args: any[]): ReturnType<AnyD1Database['insert']>;
-	transaction(...args: any[]): ReturnType<AnyD1Database['transaction']>;
+	/** Always rejects with D1TransactionUnsupportedError — use batch(). */
+	transaction(...args: unknown[]): Promise<never>;
 }

package/src/index.ts

@@ -1,13 +1,25 @@
-export * from './Adapter';
-export * from './Factory';
-export * from './Interface';
-export * from './Type';
-
 // default export so that core factory can use it directly
-import { D1DrizzleAdapterFactory, D1DrizzleDataTypesFactory } from './Factory';
-export default D1DrizzleAdapterFactory;
+import {
+	DrizzleAdapterFactoryRegistry,
+	DrizzleDataTypesFactoryRegistry
+} from '@drizzle-adapter/core';
 
-import { DrizzleAdapterFactoryRegistry, DrizzleDataTypesFactoryRegistry } from '@drizzle-adapter/core';
-DrizzleAdapterFactoryRegistry.registerAdapterFactory('d1', D1DrizzleAdapterFactory);
-DrizzleDataTypesFactoryRegistry.registerDataTypesFactory('d1', D1DrizzleDataTypesFactory);
+import { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory';
+import { D1DrizzleDataTypesFactory } from './Factory/D1DrizzleDataTypesFactory';
 
+export { D1DrizzleAdapter } from './Adapter/D1DrizzleAdapter';
+export { D1DrizzleConnection } from './Adapter/D1DrizzleConnection';
+export { D1TransactionUnsupportedError } from './Error/D1TransactionUnsupportedError';
+export { D1DrizzleAdapterFactory } from './Factory/D1DrizzleAdapterFactory';
+export { D1DrizzleDataTypesFactory } from './Factory/D1DrizzleDataTypesFactory';
+export * from './Interface/D1DrizzleClientInterface';
+export * from './Type/Types';
+export default D1DrizzleAdapterFactory;
+DrizzleAdapterFactoryRegistry.registerAdapterFactory(
+	'd1',
+	D1DrizzleAdapterFactory
+);
+DrizzleDataTypesFactoryRegistry.registerDataTypesFactory(
+	'd1',
+	D1DrizzleDataTypesFactory
+);

package/src/migrator.ts

@@ -1,9 +1,12 @@
-export * from './Adapter/D1DrizzleMigrator';
-export * from './Factory/D1DrizzleMigratorFactory';
-
 // default export so that core factory can use it directly
+import { DrizzleMigratorFactoryRegistry } from '@drizzle-adapter/core/migrator';
+
 import { D1DrizzleMigratorFactory } from './Factory/D1DrizzleMigratorFactory';
-export default D1DrizzleMigratorFactory;
 
-import { DrizzleMigratorFactoryRegistry } from '@drizzle-adapter/core/migrator';
-DrizzleMigratorFactoryRegistry.registerMigratorFactory('d1', D1DrizzleMigratorFactory);
+export * from './Adapter/D1DrizzleMigrator';
+export * from './Factory/D1DrizzleMigratorFactory';
+export default D1DrizzleMigratorFactory;
+DrizzleMigratorFactoryRegistry.registerMigratorFactory(
+	'd1',
+	D1DrizzleMigratorFactory
+);

package/tests/Adapter/D1DrizzleAdapter.test.ts

@@ -28,8 +28,8 @@ describe('D1DrizzleAdapter', () => {
 		expect(dataTypes).toBeInstanceOf(SqliteCoreDrizzleDataTypes);
 	});
 
-	it('should return D1DrizzleConnection instance with the provided database', () => {
+	it('should return D1DrizzleConnection instance with the provided database', async () => {
 		const adapter = new D1DrizzleAdapter(mockD1Database);
-		expect(adapter.getConnection()).resolves.toBeInstanceOf(D1DrizzleConnection);
+		await expect(adapter.getConnection()).resolves.toBeInstanceOf(D1DrizzleConnection);
 	});
 });

package/tests/Adapter/D1DrizzleConnection.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { D1DrizzleConnection } from '../../src/Adapter/D1DrizzleConnection';
 import { drizzle } from 'drizzle-orm/d1';
 import type { D1Database } from '@cloudflare/workers-types';
+import { D1TransactionUnsupportedError } from '../../src/Error/D1TransactionUnsupportedError';
 
 // Mock drizzle-orm/d1
 vi.mock('drizzle-orm/d1', () => ({
@@ -35,6 +36,15 @@ describe('D1DrizzleConnection', () => {
 	it('should return the query client', async () => {
 		const connection = new D1DrizzleConnection(mockD1Database);
 		const client = connection.getClient();
-		expect(client).toEqual({ mockedClient: true });
+		expect(client).toMatchObject({ mockedClient: true });
+	});
+
+	it('transaction() rejects with D1TransactionUnsupportedError and never runs the callback', async () => {
+		const connection = new D1DrizzleConnection(mockD1Database);
+		const callback = vi.fn();
+		const transactionPromise = (connection.getClient() as unknown as { transaction: (cb: typeof callback) => Promise<unknown> }).transaction(callback);
+		await expect(transactionPromise).rejects.toBeInstanceOf(D1TransactionUnsupportedError);
+		await expect(transactionPromise).rejects.toThrow('db.batch');
+		expect(callback).not.toHaveBeenCalled();
 	});
 });

package/tests/Adapter/D1DrizzleMigrator.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { D1DrizzleMigrator } from '../../src/Adapter/D1DrizzleMigrator';
 import * as migrator from 'drizzle-orm/d1/migrator';
 import type { TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
-import type { D1DrizzleClientInterface } from '../../src/Interface';
+import type { D1DrizzleClientInterface } from '../../src';
 
 // Mock the migrate function from drizzle-orm/d1/migrator
 vi.mock('drizzle-orm/d1/migrator', () => ({

package/tests/Error/D1TransactionUnsupportedError.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import * as packageEntry from '../../src/index';
+
+describe('D1TransactionUnsupportedError', () => {
+	it('is exported from the package entry point', () => {
+		expect(packageEntry.D1TransactionUnsupportedError).toBeDefined();
+		const error = new packageEntry.D1TransactionUnsupportedError();
+		expect(error).toBeInstanceOf(Error);
+		expect(error.name).toBe('D1TransactionUnsupportedError');
+		expect(error.message).toContain('db.batch');
+	});
+});

package/tests/Factory/D1DrizzleAdapterFactory.test.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { D1DrizzleAdapterFactory } from '../../src/Factory';
-import { D1DrizzleAdapter } from '../../src/Adapter';
+import { D1DrizzleAdapterFactory } from '../../src';
+import { D1DrizzleAdapter } from '../../src';
 import { drizzle } from 'drizzle-orm/d1';
 import type { D1Database } from '@cloudflare/workers-types';
-import type { TypeD1DatabaseConfig } from '../../src/Type';
+import type { TypeD1DatabaseConfig } from '../../src';
 
 // Mock drizzle-orm/d1
 vi.mock('drizzle-orm/d1', () => ({

package/tests/Integration/D1Atomicity.miniflare.test.ts

@@ -0,0 +1,77 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import { sql } from 'drizzle-orm';
+import type { DrizzleD1Database } from 'drizzle-orm/d1';
+import { Miniflare } from 'miniflare';
+import type { D1Database as MiniflareD1Database } from 'miniflare';
+import { describe, it, expect, vi, beforeAll, afterAll } from 'vitest';
+import { D1DrizzleConnection } from '../../src/Adapter/D1DrizzleConnection';
+import { D1TransactionUnsupportedError } from '../../src/Error/D1TransactionUnsupportedError';
+
+describe('D1 atomicity (real Miniflare D1)', () => {
+	let miniflare: Miniflare;
+	let miniflareDatabase: MiniflareD1Database;
+
+	beforeAll(async () => {
+		miniflare = new Miniflare({
+			modules: true,
+			script: 'export default {fetch(){return new Response("")}}',
+			d1Databases: ['DB']
+		});
+		miniflareDatabase = await miniflare.getD1Database('DB');
+		await miniflareDatabase.exec('CREATE TABLE probe (id INTEGER PRIMARY KEY, name TEXT UNIQUE)');
+	});
+
+	afterAll(async () => {
+		await miniflare.dispose();
+	});
+
+	// Real adapter client. batch() and run() exist on the drizzle D1 client at runtime
+	// but are not on D1DrizzleClientInterface, so the client is cast to DrizzleD1Database.
+	const buildAdapterClient = (): DrizzleD1Database =>
+		new D1DrizzleConnection(miniflareDatabase as unknown as D1Database).getClient() as unknown as DrizzleD1Database;
+
+	const countProbeRows = async (): Promise<number> => {
+		const result = await miniflareDatabase
+			.prepare('SELECT count(*) AS total FROM probe')
+			.first<{ total: number }>();
+		return Number(result?.total);
+	};
+
+	const clearProbeRows = async (): Promise<void> => {
+		await miniflareDatabase.exec('DELETE FROM probe');
+	};
+
+	it('transaction() rejects with D1TransactionUnsupportedError and never runs the callback', async () => {
+		await clearProbeRows();
+		const client = buildAdapterClient();
+		const callback = vi.fn(async () => 'ran');
+		await expect(
+			(client as unknown as { transaction: (work: typeof callback) => Promise<unknown> }).transaction(callback)
+		).rejects.toBeInstanceOf(D1TransactionUnsupportedError);
+		expect(callback).not.toHaveBeenCalled();
+		expect(await countProbeRows()).toBe(0);
+	});
+
+	// drizzle-orm d1/session.js batch() forwards to native D1Database.batch, which is one implicit SQL transaction.
+	it('a batch with a UNIQUE violation is all-or-nothing', async () => {
+		await clearProbeRows();
+		const client = buildAdapterClient();
+		await expect(
+			client.batch([
+				client.run(sql`INSERT INTO probe (name) VALUES ('dup')`),
+				client.run(sql`INSERT INTO probe (name) VALUES ('dup')`)
+			])
+		).rejects.toThrow(/UNIQUE/);
+		expect(await countProbeRows()).toBe(0);
+	});
+
+	it('a batch of two distinct inserts commits both rows (control)', async () => {
+		await clearProbeRows();
+		const client = buildAdapterClient();
+		await client.batch([
+			client.run(sql`INSERT INTO probe (name) VALUES ('alpha')`),
+			client.run(sql`INSERT INTO probe (name) VALUES ('beta')`)
+		]);
+		expect(await countProbeRows()).toBe(2);
+	});
+});

package/tsconfig.json

@@ -26,12 +26,7 @@
 		// Some stricter flags (disabled by default)
 		"noUnusedLocals": true,
 		"noUnusedParameters": true,
-		"noPropertyAccessFromIndexSignature": true,
-
-		"baseUrl": ".",
-		"paths": {
-			"@drizzle-adapter/*": ["../*/dist"]
-		}
+		"noPropertyAccessFromIndexSignature": true
 	},
 	"include": ["src/**/*.ts", "tests/worker.ts", "tests/worker.ts"],
 	"exclude": ["node_modules", "dist", "tests"]

package/dist/Adapter/D1DrizzleDataTypes.d.ts

@@ -1,7 +0,0 @@
-import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
-/**
- * D1 data types implementation for Drizzle ORM.
- * Extends the core SQLite data types with D1-specific functionality.
- */
-export declare class D1DrizzleDataTypes extends SqliteCoreDrizzleDataTypes {
-}

package/dist/Adapter/D1DrizzleDataTypes.js

@@ -1,7 +0,0 @@
-import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
-/**
- * D1 data types implementation for Drizzle ORM.
- * Extends the core SQLite data types with D1-specific functionality.
- */
-export class D1DrizzleDataTypes extends SqliteCoreDrizzleDataTypes {
-}

package/dist/Adapter/index.d.ts

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapter.js';
-export * from './D1DrizzleConnection.js';

package/dist/Adapter/index.js

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapter.js';
-export * from './D1DrizzleConnection.js';

package/dist/Factory/index.d.ts

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapterFactory.js';
-export * from './D1DrizzleDataTypesFactory.js';

package/dist/Factory/index.js

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapterFactory.js';
-export * from './D1DrizzleDataTypesFactory.js';

package/dist/Interface/index.d.ts

@@ -1 +0,0 @@
-export * from './D1DrizzleClientInterface.js';

package/dist/Interface/index.js

@@ -1 +0,0 @@
-export * from './D1DrizzleClientInterface.js';

package/dist/Type/index.d.ts

@@ -1 +0,0 @@
-export * from './Types.js';

package/dist/Type/index.js

@@ -1 +0,0 @@
-export * from './Types.js';

package/src/Adapter/D1DrizzleDataTypes.ts

@@ -1,7 +0,0 @@
-import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
-
-/**
- * D1 data types implementation for Drizzle ORM.
- * Extends the core SQLite data types with D1-specific functionality.
- */
-export class D1DrizzleDataTypes extends SqliteCoreDrizzleDataTypes {}

package/src/Adapter/index.ts

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapter';
-export * from './D1DrizzleConnection';

package/src/Factory/index.ts

@@ -1,2 +0,0 @@
-export * from './D1DrizzleAdapterFactory';
-export * from './D1DrizzleDataTypesFactory';

package/src/Interface/index.ts

@@ -1 +0,0 @@
-export * from './D1DrizzleClientInterface';

package/src/Type/index.ts

@@ -1 +0,0 @@
-export * from './Types';