@drizzle-adapter/d1 1.0.17 → 1.0.18

package/README.md

@@ -46,6 +46,47 @@ import '@drizzle-adapter/d1';
 import { DrizzleAdapterFactory } from '@drizzle-adapter/core';
 ```
 
+## D1 Compatibility Layer
+
+This adapter provides several compatibility enhancements to make D1 work seamlessly with existing Drizzle ORM code:
+
+### Execute Method Mapping
+D1's Drizzle implementation uses `run()` instead of the standard `execute()` method. This adapter automatically maps `execute()` to `run()` for compatibility:
+
+```typescript
+// Both of these work identically
+await client.execute(sql`SELECT * FROM users`);
+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**:
+
+```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
+});
+```
+
+**For atomic operations**, use D1's batch API directly:
+
+```typescript
+// This provides atomic execution - all succeed or all fail
+const results = await client.batch([
+  client.insert(users).values({ name: 'John' }).prepare(),
+  client.update(posts).set({ published: 1 }).prepare()
+]);
+```
+
+### Migration Considerations
+- **Transaction Compatibility**: Existing code using `db.transaction()` will work without modification
+- **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
+
 ## Usage
 
 ### Cloudflare Workers Setup

package/dist/Adapter/D1DrizzleConnection.js

@@ -14,6 +14,14 @@ export class D1DrizzleConnection {
         // 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);
+        };
         this.client = database;
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drizzle-adapter/d1",
   "type": "module",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/src/Adapter/D1DrizzleConnection.ts

@@ -22,6 +22,17 @@ export class D1DrizzleConnection implements DrizzleConnectionInterface
 		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);
+		};
+
 		this.client = database as unknown as D1DrizzleClientInterface;
 	}