@drizzle-adapter/d1 1.0.15 → 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/D1DrizzleAdapter.d.ts

@@ -1,31 +1,35 @@
 import type { D1Database } from '@cloudflare/workers-types';
+import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
 import { D1DrizzleConnection } from './D1DrizzleConnection.js';
 import { D1DrizzleDataTypes } from './D1DrizzleDataTypes.js';
-import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
+/**
+ * D1 adapter implementation for Drizzle ORM.
+ * Provides D1-specific database operations and connection management.
+ */
 export declare class D1DrizzleAdapter implements DrizzleAdapterInterface {
     private connection;
     /**
      * Constructor.
      *
-     * @param {D1Database} driver
+     * @param {D1Database} driver - The D1 database driver instance
      */
     constructor(driver: D1Database);
     /**
-     * Returns the dialect.
+     * Returns the connection.
      *
-     * @returns {string}
+     * @returns {Promise<D1DrizzleConnection>} A promise that resolves to the D1 connection instance
      */
-    getDialect(): string;
+    getConnection(): Promise<D1DrizzleConnection>;
     /**
      * Returns the data types.
      *
-     * @returns {D1DrizzleDataTypes}
+     * @returns {D1DrizzleDataTypes} The D1 data types instance
      */
     getDataTypes(): D1DrizzleDataTypes;
     /**
-     * Returns the connection.
+     * Returns the dialect.
      *
-     * @returns {Promise<D1DrizzleConnection>}
+     * @returns {string} The database dialect string
      */
-    getConnection(): Promise<D1DrizzleConnection>;
+    getDialect(): string;
 }

package/dist/Adapter/D1DrizzleAdapter.js

@@ -1,37 +1,41 @@
 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 class D1DrizzleAdapter {
     connection;
     /**
      * Constructor.
      *
-     * @param {D1Database} driver
+     * @param {D1Database} driver - The D1 database driver instance
      */
     constructor(driver) {
         this.connection = new D1DrizzleConnection(driver);
     }
     /**
-     * Returns the dialect.
+     * Returns the connection.
      *
-     * @returns {string}
+     * @returns {Promise<D1DrizzleConnection>} A promise that resolves to the D1 connection instance
      */
-    getDialect() {
-        return 'sqlite';
+    async getConnection() {
+        return this.connection.connect();
     }
     /**
      * Returns the data types.
      *
-     * @returns {D1DrizzleDataTypes}
+     * @returns {D1DrizzleDataTypes} The D1 data types instance
      */
     getDataTypes() {
         return new D1DrizzleDataTypes();
     }
     /**
-     * Returns the connection.
+     * Returns the dialect.
      *
-     * @returns {Promise<D1DrizzleConnection>}
+     * @returns {string} The database dialect string
      */
-    async getConnection() {
-        return this.connection.connect();
+    getDialect() {
+        return 'sqlite';
     }
 }

package/dist/Adapter/D1DrizzleConnection.d.ts

@@ -1,12 +1,16 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
 import type { D1DrizzleClientInterface } from 'src/Interface';
+/**
+ * D1 connection implementation for Drizzle ORM.
+ * Manages database connections and provides client access for D1 databases.
+ */
 export declare class D1DrizzleConnection implements DrizzleConnectionInterface {
     private client;
     /**
      * Constructor.
      *
-     * @param {D1Database} driver
+     * @param {D1Database} driver - The D1 database driver instance
      */
     constructor(driver: D1Database);
     /**
@@ -24,7 +28,7 @@ export declare class D1DrizzleConnection implements DrizzleConnectionInterface {
     /**
      * Returns the client.
      *
-     * @returns {D1DrizzleClientInterface}
+     * @returns {D1DrizzleClientInterface} The D1 Drizzle client instance
      */
     getClient(): D1DrizzleClientInterface;
 }

package/dist/Adapter/D1DrizzleConnection.js

@@ -1,15 +1,27 @@
 import { drizzle } from 'drizzle-orm/d1';
+/**
+ * D1 connection implementation for Drizzle ORM.
+ * Manages database connections and provides client access for D1 databases.
+ */
 export class D1DrizzleConnection {
     client;
     /**
      * Constructor.
      *
-     * @param {D1Database} driver
+     * @param {D1Database} driver - The D1 database driver instance
      */
     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);
+        };
         this.client = database;
     }
     /**
@@ -33,7 +45,7 @@ export class D1DrizzleConnection {
     /**
      * Returns the client.
      *
-     * @returns {D1DrizzleClientInterface}
+     * @returns {D1DrizzleClientInterface} The D1 Drizzle client instance
      */
     getClient() {
         return this.client;

package/dist/Adapter/D1DrizzleDataTypes.d.ts

@@ -1,3 +1,7 @@
 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,3 +1,7 @@
 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/D1DrizzleMigrator.d.ts

@@ -1,5 +1,9 @@
 import type { DrizzleMigratorInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
 import type { D1DrizzleClientInterface } from '../Interface/index.js';
+/**
+ * D1 migrator implementation for Drizzle ORM.
+ * Handles database migrations for D1 databases.
+ */
 export declare class D1DrizzleMigrator implements DrizzleMigratorInterface {
     private readonly config;
     /**
@@ -11,7 +15,7 @@ export declare class D1DrizzleMigrator implements DrizzleMigratorInterface {
     /**
      * Migrate the database.
      *
-     * @param {DrizzleClientInterface} client The Drizzle client.
+     * @param {D1DrizzleClientInterface} client The Drizzle client.
      */
     migrate(client: D1DrizzleClientInterface): Promise<void>;
 }

package/dist/Adapter/D1DrizzleMigrator.js

@@ -1,4 +1,8 @@
 import { DrizzleD1Database } from 'drizzle-orm/d1/driver';
+/**
+ * D1 migrator implementation for Drizzle ORM.
+ * Handles database migrations for D1 databases.
+ */
 export class D1DrizzleMigrator {
     config;
     /**
@@ -12,7 +16,7 @@ export class D1DrizzleMigrator {
     /**
      * Migrate the database.
      *
-     * @param {DrizzleClientInterface} client The Drizzle client.
+     * @param {D1DrizzleClientInterface} client The Drizzle client.
      */
     async migrate(client) {
         const { migrate } = await import('drizzle-orm/d1/migrator');

package/dist/Factory/D1DrizzleAdapterFactory.d.ts

@@ -1,12 +1,16 @@
-import type { TypeD1DatabaseConfig } from '../Type/Types.js';
-import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter.js';
 import type { DrizzleAdapterFactoryInterface } from '@drizzle-adapter/core';
+import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter.js';
+import type { TypeD1DatabaseConfig } from '../Type/Types.js';
+/**
+ * Factory for creating D1 adapter instances.
+ * Implements the DrizzleAdapterFactoryInterface for D1 database operations.
+ */
 export declare class D1DrizzleAdapterFactory implements DrizzleAdapterFactoryInterface {
     /**
      * Returns a adapter.
      *
-     * @param {TypeD1DatabaseConfig} databaseConfig
-     * @returns {D1DrizzleAdapter}
+     * @param {TypeD1DatabaseConfig} databaseConfig - The D1 database configuration
+     * @returns {D1DrizzleAdapter} A new D1 adapter instance
      */
     create(databaseConfig: TypeD1DatabaseConfig): D1DrizzleAdapter;
 }

package/dist/Factory/D1DrizzleAdapterFactory.js

@@ -1,10 +1,14 @@
 import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter.js';
+/**
+ * Factory for creating D1 adapter instances.
+ * Implements the DrizzleAdapterFactoryInterface for D1 database operations.
+ */
 export class D1DrizzleAdapterFactory {
     /**
      * Returns a adapter.
      *
-     * @param {TypeD1DatabaseConfig} databaseConfig
-     * @returns {D1DrizzleAdapter}
+     * @param {TypeD1DatabaseConfig} databaseConfig - The D1 database configuration
+     * @returns {D1DrizzleAdapter} A new D1 adapter instance
      */
     create(databaseConfig) {
         return new D1DrizzleAdapter(databaseConfig.DATABASE);

package/dist/Factory/D1DrizzleDataTypesFactory.d.ts

@@ -1,11 +1,15 @@
 import type { DrizzleDataTypesFactoryInterface, TypeDrizzleDatabaseConfig } from '@drizzle-adapter/core';
 import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
+/**
+ * Factory for creating D1 data types instances.
+ * Implements the DrizzleDataTypesFactoryInterface for D1 database operations.
+ */
 export declare class D1DrizzleDataTypesFactory implements DrizzleDataTypesFactoryInterface {
     /**
      * Creates a new data types instance.
      *
      * @param {TypeDrizzleDatabaseConfig} _config - Not used in this implementation
-     * @returns {SqliteCoreDrizzleDataTypes}
+     * @returns {SqliteCoreDrizzleDataTypes} A new SQLite core data types instance
      */
     create(_config: TypeDrizzleDatabaseConfig): SqliteCoreDrizzleDataTypes;
 }

package/dist/Factory/D1DrizzleDataTypesFactory.js

@@ -1,10 +1,14 @@
 import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
+/**
+ * Factory for creating D1 data types instances.
+ * Implements the DrizzleDataTypesFactoryInterface for D1 database operations.
+ */
 export class D1DrizzleDataTypesFactory {
     /**
      * Creates a new data types instance.
      *
      * @param {TypeDrizzleDatabaseConfig} _config - Not used in this implementation
-     * @returns {SqliteCoreDrizzleDataTypes}
+     * @returns {SqliteCoreDrizzleDataTypes} A new SQLite core data types instance
      */
     create(_config) {
         return new SqliteCoreDrizzleDataTypes();

package/dist/Factory/D1DrizzleMigratorFactory.d.ts

@@ -1,11 +1,15 @@
 import type { DrizzleMigratorFactoryInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
 import { D1DrizzleMigrator } from '../migrator.js';
+/**
+ * Factory for creating D1 migrator instances.
+ * Implements the DrizzleMigratorFactoryInterface for D1 database migrations.
+ */
 export declare class D1DrizzleMigratorFactory implements DrizzleMigratorFactoryInterface {
     /**
      * Returns a new migrator.
      *
-     * @param {TypeDrizzleMigratorConfig} config
-     * @returns {D1DrizzleMigrator}
+     * @param {TypeDrizzleMigratorConfig} config - The migrator configuration
+     * @returns {D1DrizzleMigrator} A new D1 migrator instance
      */
     create(config: TypeDrizzleMigratorConfig): D1DrizzleMigrator;
 }

package/dist/Factory/D1DrizzleMigratorFactory.js

@@ -1,10 +1,14 @@
 import { D1DrizzleMigrator } from '../migrator.js';
+/**
+ * Factory for creating D1 migrator instances.
+ * Implements the DrizzleMigratorFactoryInterface for D1 database migrations.
+ */
 export class D1DrizzleMigratorFactory {
     /**
      * Returns a new migrator.
      *
-     * @param {TypeDrizzleMigratorConfig} config
-     * @returns {D1DrizzleMigrator}
+     * @param {TypeDrizzleMigratorConfig} config - The migrator configuration
+     * @returns {D1DrizzleMigrator} A new D1 migrator instance
      */
     create(config) {
         return new D1DrizzleMigrator(config);

package/dist/Interface/D1DrizzleClientInterface.d.ts

@@ -1,5 +1,9 @@
-import type { AnyD1Database } from 'drizzle-orm/d1';
 import type { DrizzleClientInterface } from '@drizzle-adapter/core';
+import type { AnyD1Database } from 'drizzle-orm/d1';
+/**
+ * Interface for D1 Drizzle client operations.
+ * Extends the core DrizzleClientInterface with D1-specific database operations.
+ */
 export interface D1DrizzleClientInterface extends DrizzleClientInterface {
     execute(...args: any[]): ReturnType<AnyD1Database['run']>;
     $with(...args: any[]): ReturnType<AnyD1Database['$with']>;

package/dist/Type/Types.d.ts

@@ -1,5 +1,9 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { TypeDrizzleDatabaseConfig } from '@drizzle-adapter/core';
+/**
+ * Configuration interface for D1 database connections.
+ * Extends the core database configuration with D1-specific settings.
+ */
 export interface TypeD1DatabaseConfig extends TypeDrizzleDatabaseConfig {
     readonly DATABASE: D1Database;
 }

package/eslint.config.mjs

@@ -3,4 +3,4 @@ import eslintConfig from '@dmitryrechkin/eslint-standard/eslint.config.mjs';
 export default eslintConfig({
 	tsconfigPath: './tsconfig.eslint.json',
 	ignores: ['packages/**', 'tests/**'],
-});
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drizzle-adapter/d1",
   "type": "module",
-  "version": "1.0.15",
+  "version": "1.0.18",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -17,21 +17,22 @@
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250419.0",
     "@dmitryrechkin/eslint-standard": "^1.0.7",
-    "dotenv": "^16.5.0",
-    "eslint": "^8.57.1",
-    "eslint-plugin-unused-imports": "^3.2.0",
-    "shx": "^0.3.4",
+    "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": "^0.24.5",
-    "wrangler": "^3.114.6"
+    "vitest": "^3.2.4",
+    "wrangler": "^3.114.11"
   },
   "dependencies": {
-    "drizzle-orm": "^0.36.4",
-    "@drizzle-adapter/core": "^1.0.12",
-    "@drizzle-adapter/sqlite-core": "^1.0.12"
+    "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/",

package/src/Adapter/D1DrizzleAdapter.ts

@@ -1,8 +1,13 @@
 import type { D1Database } from '@cloudflare/workers-types';
+import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
+
 import { D1DrizzleConnection } from './D1DrizzleConnection';
 import { D1DrizzleDataTypes } from './D1DrizzleDataTypes';
-import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
 
+/**
+ * D1 adapter implementation for Drizzle ORM.
+ * Provides D1-specific database operations and connection management.
+ */
 export class D1DrizzleAdapter implements DrizzleAdapterInterface
 {
 	private connection: D1DrizzleConnection;
@@ -10,7 +15,7 @@ export class D1DrizzleAdapter implements DrizzleAdapterInterface
 	/**
 	 * Constructor.
 	 *
-	 * @param {D1Database} driver
+	 * @param {D1Database} driver - The D1 database driver instance
 	 */
 	public constructor(driver: D1Database)
 	{
@@ -18,19 +23,19 @@ export class D1DrizzleAdapter implements DrizzleAdapterInterface
 	}
 
 	/**
-	 * Returns the dialect.
+	 * Returns the connection.
 	 *
-	 * @returns {string}
+	 * @returns {Promise<D1DrizzleConnection>} A promise that resolves to the D1 connection instance
 	 */
-	public getDialect(): string
+	public async getConnection(): Promise<D1DrizzleConnection>
 	{
-		return 'sqlite';
+		return this.connection.connect();
 	}
 
 	/**
 	 * Returns the data types.
 	 *
-	 * @returns {D1DrizzleDataTypes}
+	 * @returns {D1DrizzleDataTypes} The D1 data types instance
 	 */
 	public getDataTypes(): D1DrizzleDataTypes
 	{
@@ -38,12 +43,12 @@ export class D1DrizzleAdapter implements DrizzleAdapterInterface
 	}
 
 	/**
-	 * Returns the connection.
+	 * Returns the dialect.
 	 *
-	 * @returns {Promise<D1DrizzleConnection>}
+	 * @returns {string} The database dialect string
 	 */
-	public async getConnection(): Promise<D1DrizzleConnection>
+	public getDialect(): string
 	{
-		return this.connection.connect();
+		return 'sqlite';
 	}
 }

package/src/Adapter/D1DrizzleConnection.ts

@@ -1,8 +1,12 @@
 import type { D1Database } from '@cloudflare/workers-types';
-import { drizzle } from 'drizzle-orm/d1';
 import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
+import { drizzle } from 'drizzle-orm/d1';
 import type { D1DrizzleClientInterface } from 'src/Interface';
 
+/**
+ * D1 connection implementation for Drizzle ORM.
+ * Manages database connections and provides client access for D1 databases.
+ */
 export class D1DrizzleConnection implements DrizzleConnectionInterface
 {
 	private client: D1DrizzleClientInterface;
@@ -10,7 +14,7 @@ export class D1DrizzleConnection implements DrizzleConnectionInterface
 	/**
 	 * Constructor.
 	 *
-	 * @param {D1Database} driver
+	 * @param {D1Database} driver - The D1 database driver instance
 	 */
 	public constructor(driver: D1Database)
 	{
@@ -18,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;
 	}
 
@@ -46,7 +61,7 @@ export class D1DrizzleConnection implements DrizzleConnectionInterface
 	/**
 	 * Returns the client.
 	 *
-	 * @returns {D1DrizzleClientInterface}
+	 * @returns {D1DrizzleClientInterface} The D1 Drizzle client instance
 	 */
 	public getClient(): D1DrizzleClientInterface
 	{

package/src/Adapter/D1DrizzleDataTypes.ts

@@ -1,3 +1,7 @@
 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/D1DrizzleMigrator.ts

@@ -1,7 +1,12 @@
 import type { DrizzleMigratorInterface, TypeDrizzleMigratorConfig } from '@drizzle-adapter/core';
 import { DrizzleD1Database } from 'drizzle-orm/d1/driver';
+
 import type { D1DrizzleClientInterface } from '../Interface';
 
+/**
+ * D1 migrator implementation for Drizzle ORM.
+ * Handles database migrations for D1 databases.
+ */
 export class D1DrizzleMigrator implements DrizzleMigratorInterface
 {
 	/**
@@ -14,7 +19,7 @@ export class D1DrizzleMigrator implements DrizzleMigratorInterface
 	/**
 	 * Migrate the database.
 	 *
-	 * @param {DrizzleClientInterface} client The Drizzle client.
+	 * @param {D1DrizzleClientInterface} client The Drizzle client.
 	 */
 	public async migrate(client: D1DrizzleClientInterface): Promise<void>
 	{

package/src/Factory/D1DrizzleAdapterFactory.ts

@@ -1,14 +1,19 @@
-import type { TypeD1DatabaseConfig } from '../Type/Types';
-import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter';
 import type { DrizzleAdapterFactoryInterface } from '@drizzle-adapter/core';
 
+import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter';
+import type { TypeD1DatabaseConfig } from '../Type/Types';
+
+/**
+ * Factory for creating D1 adapter instances.
+ * Implements the DrizzleAdapterFactoryInterface for D1 database operations.
+ */
 export class D1DrizzleAdapterFactory implements DrizzleAdapterFactoryInterface
 {
 	/**
 	 * Returns a adapter.
 	 *
-	 * @param {TypeD1DatabaseConfig} databaseConfig
-	 * @returns {D1DrizzleAdapter}
+	 * @param {TypeD1DatabaseConfig} databaseConfig - The D1 database configuration
+	 * @returns {D1DrizzleAdapter} A new D1 adapter instance
 	 */
 	public create(databaseConfig: TypeD1DatabaseConfig): D1DrizzleAdapter
 	{

package/src/Factory/D1DrizzleDataTypesFactory.ts

@@ -1,13 +1,17 @@
 import type { DrizzleDataTypesFactoryInterface, TypeDrizzleDatabaseConfig } from '@drizzle-adapter/core';
 import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
 
+/**
+ * Factory for creating D1 data types instances.
+ * Implements the DrizzleDataTypesFactoryInterface for D1 database operations.
+ */
 export class D1DrizzleDataTypesFactory implements DrizzleDataTypesFactoryInterface
 {
 	/**
 	 * Creates a new data types instance.
 	 *
 	 * @param {TypeDrizzleDatabaseConfig} _config - Not used in this implementation
-	 * @returns {SqliteCoreDrizzleDataTypes}
+	 * @returns {SqliteCoreDrizzleDataTypes} A new SQLite core data types instance
 	 */
 	public create(_config: TypeDrizzleDatabaseConfig): SqliteCoreDrizzleDataTypes
 	{