@drizzle-adapter/d1 1.0.0 → 1.0.3

package/README.md

@@ -34,6 +34,18 @@ D1 offers unique advantages for Cloudflare Workers:
 pnpm install @drizzle-adapter/core @drizzle-adapter/d1
 ```
 
+## Important: Adapter Registration
+
+For the adapter to work correctly with the DrizzleAdapterFactory, you must import it for its self-registration side effects:
+
+```typescript
+// Import for side effects - adapter will self-register
+import '@drizzle-adapter/d1';
+
+// Now you can use the factory
+import { DrizzleAdapterFactory } from '@drizzle-adapter/core';
+```
+
 ## Usage
 
 ### Cloudflare Workers Setup
@@ -67,7 +79,7 @@ const config: TypeDrizzleDatabaseConfig = {
 };
 
 const factory = new DrizzleAdapterFactory();
-const adapter = await factory.create(config);
+const adapter = factory.create(config);
 ```
 
 ### Important Note About Connections
@@ -77,9 +89,9 @@ While D1 operates within the Workers environment and doesn't require traditional
 ```typescript
 // These connection operations are no-ops for D1 but ensure
 // your code remains portable if you switch to another database
-const connection = adapter.getConnection();
-await connection.connect(); // No-op for D1
-const client = await connection.getClient();
+const connection = await adapter.getConnection();
+
+const client = connection.getClient();
 
 // Your database operations
 
@@ -201,7 +213,7 @@ interface Env {
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     const factory = new DrizzleAdapterFactory();
-    const adapter = await factory.create({
+    const adapter = factory.create({
       DATABASE_DRIVER: 'd1',
       DATABASE: env.DB
     });

package/dist/Adapter/D1DrizzleAdapter.d.ts

@@ -3,14 +3,13 @@ import { D1DrizzleConnection } from './D1DrizzleConnection.js';
 import { D1DrizzleDataTypes } from './D1DrizzleDataTypes.js';
 import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
 export declare class D1DrizzleAdapter implements DrizzleAdapterInterface {
-    private readonly connection;
-    private connectionInstance;
+    private connection;
     /**
      * Constructor.
      *
-     * @param {D1Database} connectionDriver
+     * @param {D1Database} driver
      */
-    constructor(connection: D1Database);
+    constructor(driver: D1Database);
     /**
      * Returns the dialect.
      *
@@ -26,7 +25,7 @@ export declare class D1DrizzleAdapter implements DrizzleAdapterInterface {
     /**
      * Returns the connection.
      *
-     * @returns {D1DrizzleConnection}
+     * @returns {Promise<D1DrizzleConnection>}
      */
-    getConnection(): D1DrizzleConnection;
+    getConnection(): Promise<D1DrizzleConnection>;
 }

package/dist/Adapter/D1DrizzleAdapter.js

@@ -2,14 +2,13 @@ import { D1DrizzleConnection } from './D1DrizzleConnection.js';
 import { D1DrizzleDataTypes } from './D1DrizzleDataTypes.js';
 export class D1DrizzleAdapter {
     connection;
-    connectionInstance = null;
     /**
      * Constructor.
      *
-     * @param {D1Database} connectionDriver
+     * @param {D1Database} driver
      */
-    constructor(connection) {
-        this.connection = connection;
+    constructor(driver) {
+        this.connection = new D1DrizzleConnection(driver);
     }
     /**
      * Returns the dialect.
@@ -30,12 +29,9 @@ export class D1DrizzleAdapter {
     /**
      * Returns the connection.
      *
-     * @returns {D1DrizzleConnection}
+     * @returns {Promise<D1DrizzleConnection>}
      */
-    getConnection() {
-        if (!this.connectionInstance) {
-            this.connectionInstance = new D1DrizzleConnection(this.connection);
-        }
-        return this.connectionInstance;
+    async getConnection() {
+        return this.connection.connect();
     }
 }

package/dist/Adapter/D1DrizzleConnection.d.ts

@@ -1,5 +1,6 @@
 import type { D1Database } from '@cloudflare/workers-types';
-import type { DrizzleClientInterface, DrizzleConnectionInterface } from '@drizzle-adapter/core';
+import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
+import type { D1DrizzleClientInterface } from 'src/Interface';
 export declare class D1DrizzleConnection implements DrizzleConnectionInterface {
     private client;
     /**
@@ -13,17 +14,17 @@ export declare class D1DrizzleConnection implements DrizzleConnectionInterface {
      *
      * @returns {Promise<void>}
      */
-    connect(): Promise<void>;
+    connect(): Promise<D1DrizzleConnection>;
     /**
      * Disconnects from the database.
      *
      * @returns {Promise<void>}
      */
-    disconnect(): Promise<void>;
+    disconnect(): Promise<D1DrizzleConnection>;
     /**
      * Returns the client.
      *
-     * @returns {Promise<DrizzleClientInterface>}
+     * @returns {D1DrizzleClientInterface}
      */
-    getClient(): Promise<DrizzleClientInterface>;
+    getClient(): D1DrizzleClientInterface;
 }

package/dist/Adapter/D1DrizzleConnection.js

@@ -19,6 +19,7 @@ export class D1DrizzleConnection {
      */
     async connect() {
         // D1 is serverless, no need to explicitly connect
+        return this;
     }
     /**
      * Disconnects from the database.
@@ -27,13 +28,14 @@ export class D1DrizzleConnection {
      */
     async disconnect() {
         // D1 is serverless, no need to explicitly disconnect
+        return this;
     }
     /**
      * Returns the client.
      *
-     * @returns {Promise<DrizzleClientInterface>}
+     * @returns {D1DrizzleClientInterface}
      */
-    async getClient() {
+    getClient() {
         return this.client;
     }
 }

package/dist/Adapter/D1DrizzleMigrator.d.ts

@@ -0,0 +1,12 @@
+import type { DrizzleMigratorInterface } from '@drizzle-adapter/core';
+import type { MigrationConfig } from 'drizzle-orm/migrator';
+import type { D1DrizzleClientInterface } from '../Interface/index.js';
+export declare class D1DrizzleMigrator implements DrizzleMigratorInterface {
+    /**
+     * Migrate the database.
+     *
+     * @param {DrizzleClientInterface} client The Drizzle client.
+     * @param {MigrationConfig} config The migration configuration.
+     */
+    migrate(client: D1DrizzleClientInterface, config: MigrationConfig): Promise<void>;
+}

package/dist/Adapter/D1DrizzleMigrator.js

@@ -0,0 +1,13 @@
+import { DrizzleD1Database } from 'drizzle-orm/d1/driver';
+import { migrate } from 'drizzle-orm/d1/migrator';
+export class D1DrizzleMigrator {
+    /**
+     * Migrate the database.
+     *
+     * @param {DrizzleClientInterface} client The Drizzle client.
+     * @param {MigrationConfig} config The migration configuration.
+     */
+    async migrate(client, config) {
+        await migrate(client, config);
+    }
+}

package/dist/Factory/D1DrizzleAdapterFactory.d.ts

@@ -6,7 +6,7 @@ export declare class D1DrizzleAdapterFactory implements DrizzleAdapterFactoryInt
      * Returns a adapter.
      *
      * @param {TypeD1DatabaseConfig} databaseConfig
-     * @returns {Promise<D1DrizzleAdapter>}
+     * @returns {D1DrizzleAdapter}
      */
-    create(databaseConfig: TypeD1DatabaseConfig): Promise<D1DrizzleAdapter>;
+    create(databaseConfig: TypeD1DatabaseConfig): D1DrizzleAdapter;
 }

package/dist/Factory/D1DrizzleAdapterFactory.js

@@ -4,9 +4,9 @@ export class D1DrizzleAdapterFactory {
      * Returns a adapter.
      *
      * @param {TypeD1DatabaseConfig} databaseConfig
-     * @returns {Promise<D1DrizzleAdapter>}
+     * @returns {D1DrizzleAdapter}
      */
-    async create(databaseConfig) {
+    create(databaseConfig) {
         return new D1DrizzleAdapter(databaseConfig.DATABASE);
     }
 }

package/dist/index.js

@@ -5,3 +5,5 @@ export * from './Type/index.js';
 // default export so that core factory can use it directly
 import { D1DrizzleAdapterFactory } from './Factory/index.js';
 export default D1DrizzleAdapterFactory;
+import { DrizzleAdapterFactoryRegistry } from '@drizzle-adapter/core';
+DrizzleAdapterFactoryRegistry.register('d1', D1DrizzleAdapterFactory);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drizzle-adapter/d1",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "devDependencies": {
@@ -18,13 +18,13 @@
     "wrangler": "^3.91.0"
   },
   "dependencies": {
+    "@drizzle-adapter/sqlite-core": ">=1.0.3",
     "@libsql/client": "^0.5.6",
-    "drizzle-orm": "^0.36.4",
-    "@drizzle-adapter/sqlite-core": "1.0.0"
+    "drizzle-orm": "^0.36.4"
   },
   "scripts": {
-    "lint": "eslint .",
-    "format": "eslint --fix .",
+    "lint": "eslint src/",
+    "format": "eslint --fix src/",
     "test": "vitest run",
     "check": "tsc --noEmit",
     "build": "shx rm -rf dist && tsc && fix-esm-import-path dist",

package/src/Adapter/D1DrizzleAdapter.ts

@@ -5,14 +5,17 @@ import type { DrizzleAdapterInterface } from '@drizzle-adapter/core';
 
 export class D1DrizzleAdapter implements DrizzleAdapterInterface
 {
-	private connectionInstance: D1DrizzleConnection | null = null;
+	private connection: D1DrizzleConnection;
 
 	/**
 	 * Constructor.
 	 *
-	 * @param {D1Database} connectionDriver
+	 * @param {D1Database} driver
 	 */
-	public constructor(private readonly connection: D1Database) {}
+	public constructor(driver: D1Database)
+	{
+		this.connection = new D1DrizzleConnection(driver);
+	}
 
 	/**
 	 * Returns the dialect.
@@ -37,14 +40,10 @@ export class D1DrizzleAdapter implements DrizzleAdapterInterface
 	/**
 	 * Returns the connection.
 	 *
-	 * @returns {D1DrizzleConnection}
+	 * @returns {Promise<D1DrizzleConnection>}
 	 */
-	public getConnection(): D1DrizzleConnection
+	public async getConnection(): Promise<D1DrizzleConnection>
 	{
-		if (!this.connectionInstance)
-		{
-			this.connectionInstance = new D1DrizzleConnection(this.connection);
-		}
-		return this.connectionInstance;
+		return this.connection.connect();
 	}
 }

package/src/Adapter/D1DrizzleConnection.ts

@@ -1,11 +1,11 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import { drizzle } from 'drizzle-orm/d1';
-import type { DrizzleClientInterface, DrizzleConnectionInterface } from '@drizzle-adapter/core';
+import type { DrizzleConnectionInterface } from '@drizzle-adapter/core';
 import type { D1DrizzleClientInterface } from 'src/Interface';
 
 export class D1DrizzleConnection implements DrizzleConnectionInterface
 {
-	private client: DrizzleClientInterface;
+	private client: D1DrizzleClientInterface;
 
 	/**
 	 * Constructor.
@@ -26,9 +26,10 @@ export class D1DrizzleConnection implements DrizzleConnectionInterface
 	 *
 	 * @returns {Promise<void>}
 	 */
-	public async connect(): Promise<void>
+	public async connect(): Promise<D1DrizzleConnection>
 	{
 		// D1 is serverless, no need to explicitly connect
+		return this;
 	}
 
 	/**
@@ -36,17 +37,18 @@ export class D1DrizzleConnection implements DrizzleConnectionInterface
 	 *
 	 * @returns {Promise<void>}
 	 */
-	public async disconnect(): Promise<void>
+	public async disconnect(): Promise<D1DrizzleConnection>
 	{
 		// D1 is serverless, no need to explicitly disconnect
+		return this;
 	}
 
 	/**
 	 * Returns the client.
 	 *
-	 * @returns {Promise<DrizzleClientInterface>}
+	 * @returns {D1DrizzleClientInterface}
 	 */
-	public async getClient(): Promise<DrizzleClientInterface>
+	public getClient(): D1DrizzleClientInterface
 	{
 		return this.client;
 	}

package/src/Adapter/D1DrizzleMigrator.ts

@@ -0,0 +1,19 @@
+import type { DrizzleMigratorInterface } from '@drizzle-adapter/core';
+import type { MigrationConfig } from 'drizzle-orm/migrator';
+import { DrizzleD1Database } from 'drizzle-orm/d1/driver';
+import { migrate } from 'drizzle-orm/d1/migrator';
+import type { D1DrizzleClientInterface } from '../Interface';
+
+export class D1DrizzleMigrator implements DrizzleMigratorInterface
+{
+	/**
+	 * Migrate the database.
+	 *
+	 * @param {DrizzleClientInterface} client The Drizzle client.
+	 * @param {MigrationConfig} config The migration configuration.
+	 */
+	public async migrate(client: D1DrizzleClientInterface, config: MigrationConfig): Promise<void>
+	{
+		await migrate(client as unknown as DrizzleD1Database<Record<string, unknown>>, config);
+	}
+}

package/src/Factory/D1DrizzleAdapterFactory.ts

@@ -8,9 +8,9 @@ export class D1DrizzleAdapterFactory implements DrizzleAdapterFactoryInterface
 	 * Returns a adapter.
 	 *
 	 * @param {TypeD1DatabaseConfig} databaseConfig
-	 * @returns {Promise<D1DrizzleAdapter>}
+	 * @returns {D1DrizzleAdapter}
 	 */
-	public async create(databaseConfig: TypeD1DatabaseConfig): Promise<D1DrizzleAdapter>
+	public create(databaseConfig: TypeD1DatabaseConfig): D1DrizzleAdapter
 	{
 		return new D1DrizzleAdapter(databaseConfig.DATABASE);
 	}

package/src/index.ts

@@ -6,3 +6,6 @@ export * from './Type';
 // default export so that core factory can use it directly
 import { D1DrizzleAdapterFactory } from './Factory';
 export default D1DrizzleAdapterFactory;
+
+import { DrizzleAdapterFactoryRegistry } from '@drizzle-adapter/core';
+DrizzleAdapterFactoryRegistry.register('d1', D1DrizzleAdapterFactory);

package/tests/Adapter/D1DrizzleAdapter.test.ts

@@ -30,7 +30,6 @@ describe('D1DrizzleAdapter', () => {
 
 	it('should return D1DrizzleConnection instance with the provided database', () => {
 		const adapter = new D1DrizzleAdapter(mockD1Database);
-		const connection = adapter.getConnection();
-		expect(connection).toBeInstanceOf(D1DrizzleConnection);
+		expect(adapter.getConnection()).resolves.toBeInstanceOf(D1DrizzleConnection);
 	});
 });

package/tests/Adapter/D1DrizzleConnection.test.ts

@@ -24,17 +24,17 @@ describe('D1DrizzleConnection', () => {
 
 	it('should not perform any operation on connect (serverless)', async () => {
 		const connection = new D1DrizzleConnection(mockD1Database);
-		await expect(connection.connect()).resolves.toBeUndefined();
+		await expect(connection.connect()).resolves.toBeInstanceOf(D1DrizzleConnection);
 	});
 
 	it('should not perform any operation on disconnect (serverless)', async () => {
 		const connection = new D1DrizzleConnection(mockD1Database);
-		await expect(connection.disconnect()).resolves.toBeUndefined();
+		await expect(connection.disconnect()).resolves.toBeInstanceOf(D1DrizzleConnection);
 	});
 
 	it('should return the query client', async () => {
 		const connection = new D1DrizzleConnection(mockD1Database);
-		const client = await connection.getClient();
+		const client = connection.getClient();
 		expect(client).toEqual({ mockedClient: true });
 	});
 });

package/tests/Adapter/D1DrizzleMigrator.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { D1DrizzleMigrator } from '../../src/Adapter/D1DrizzleMigrator';
+import * as migrator from 'drizzle-orm/d1/migrator';
+import type { MigrationConfig } from 'drizzle-orm/migrator';
+import type { D1DrizzleClientInterface } from '../../src/Interface';
+
+// Mock the migrate function from drizzle-orm/d1/migrator
+vi.mock('drizzle-orm/d1/migrator', () => ({
+	migrate: vi.fn().mockImplementation(async (client, config) => {
+		if (!client || !config) {
+			throw new Error('Invalid arguments');
+		}
+		return Promise.resolve();
+	})
+}));
+
+describe('D1DrizzleMigrator', () => {
+	const mockClient: D1DrizzleClientInterface = {
+		mockedClient: true
+	} as unknown as D1DrizzleClientInterface;
+
+	const mockConfig: MigrationConfig = {
+		migrationsFolder: './drizzle'
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should create an instance with a D1 client', () => {
+		const migratorInstance = new D1DrizzleMigrator();
+		expect(migratorInstance).toBeInstanceOf(D1DrizzleMigrator);
+	});
+
+	it('should call migrate with correct parameters', async () => {
+		const migratorInstance = new D1DrizzleMigrator();
+		await migratorInstance.migrate(mockClient, mockConfig);
+
+		expect(migrator.migrate).toHaveBeenCalledWith(
+			expect.objectContaining({ mockedClient: true }),
+			mockConfig
+		);
+		expect(migrator.migrate).toHaveBeenCalledTimes(1);
+	});
+
+	it('should handle migration errors', async () => {
+		const migratorInstance = new D1DrizzleMigrator();
+		
+		// Mock migrate to throw an error
+		vi.mocked(migrator.migrate).mockImplementationOnce(async () => {
+			throw new Error('Migration failed');
+		});
+
+		await expect(migratorInstance.migrate(mockClient, mockConfig))
+			.rejects
+			.toThrow('Migration failed');
+	});
+});

package/tests/Factory/D1DrizzleAdapterFactory.test.ts

@@ -34,7 +34,7 @@ describe('D1DrizzleAdapterFactory', () => {
 
 	it('should create a D1DrizzleAdapter instance', async () => {
 		const factory = new D1DrizzleAdapterFactory();
-		const adapter = await factory.create(mockDatabaseConfig);
+		const adapter = factory.create(mockDatabaseConfig);
 
 		expect(adapter).toBeInstanceOf(D1DrizzleAdapter);
 	});

package/tests/worker.ts

@@ -21,12 +21,12 @@ export default {
 			case '/test/create-record': {
 				try {
 					const factory = new D1DrizzleAdapterFactory();
-					const adapter = await factory.create({
+					const adapter = factory.create({
 						DATABASE: env.DB
 					}) as D1DrizzleAdapter;
 
-					const connection = adapter.getConnection();
-					const client = await connection.getClient();
+					const connection = await adapter.getConnection();
+					const client = connection.getClient();
 
 					// Create table definition
 					const dataTypes = adapter.getDataTypes();
@@ -65,12 +65,12 @@ export default {
 			case '/test/update-record': {
 				try {
 					const factory = new D1DrizzleAdapterFactory();
-					const adapter = await factory.create({
+					const adapter = factory.create({
 						DATABASE: env.DB
 					}) as D1DrizzleAdapter;
 
-					const connection = adapter.getConnection();
-					const client = await connection.getClient();
+					const connection = await adapter.getConnection();
+					const client = connection.getClient();
 
 					// Create table definition
 					const dataTypes = adapter.getDataTypes();
@@ -116,12 +116,12 @@ export default {
 			case '/test/select-records': {
 				try {
 					const factory = new D1DrizzleAdapterFactory();
-					const adapter = await factory.create({
+					const adapter = factory.create({
 						DATABASE: env.DB
 					}) as D1DrizzleAdapter;
 
-					const connection = adapter.getConnection();
-					const client = await connection.getClient();
+					const connection = await adapter.getConnection();
+					const client = connection.getClient();
 
 					// Create table definition
 					const dataTypes = adapter.getDataTypes();
@@ -174,12 +174,12 @@ export default {
 			case '/test/migrations': {
 				try {
 					const factory = new D1DrizzleAdapterFactory();
-					const adapter = await factory.create({
+					const adapter = factory.create({
 						DATABASE: env.DB
 					}) as D1DrizzleAdapter;
 
-					const connection = adapter.getConnection();
-					const client = await connection.getClient();
+					const connection = await adapter.getConnection();
+					const client = connection.getClient();
 
 					// Create table definition
 					const dataTypes = adapter.getDataTypes();
@@ -277,12 +277,12 @@ export default {
 			case '/test/text-type': {
 				try {
 					const factory = new D1DrizzleAdapterFactory();
-					const adapter = await factory.create({
+					const adapter = factory.create({
 						DATABASE: env.DB
 					}) as D1DrizzleAdapter;
 
-					const connection = adapter.getConnection();
-					const client = await connection.getClient();
+					const connection = await adapter.getConnection();
+					const client = connection.getClient();
 
 					// Create table definition
 					const dataTypes = adapter.getDataTypes();

package/vitest.config.ts

@@ -3,12 +3,14 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
 	test: {
 		globals: true,
+		passWithNoTests: true,
 		environment: 'node',
 		include: ['tests/**/*.test.ts'],
 		// Run tests sequentially
 		threads: false,
 		// Increase timeout for integration tests
-		testTimeout: 10000,
+		testTimeout: 30000,
+		hookTimeout: 30000,
 		// Ensure test isolation
 		isolate: true
 	}