@drizzle-adapter/d1 1.0.0

package/src/Factory/D1DrizzleAdapterFactory.ts

@@ -0,0 +1,17 @@
+import type { TypeD1DatabaseConfig } from '../Type/Types';
+import { D1DrizzleAdapter } from '../Adapter/D1DrizzleAdapter';
+import type { DrizzleAdapterFactoryInterface } from '@drizzle-adapter/core';
+
+export class D1DrizzleAdapterFactory implements DrizzleAdapterFactoryInterface
+{
+	/**
+	 * Returns a adapter.
+	 *
+	 * @param {TypeD1DatabaseConfig} databaseConfig
+	 * @returns {Promise<D1DrizzleAdapter>}
+	 */
+	public async create(databaseConfig: TypeD1DatabaseConfig): Promise<D1DrizzleAdapter>
+	{
+		return new D1DrizzleAdapter(databaseConfig.DATABASE);
+	}
+}

package/src/Factory/index.ts

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

package/src/Interface/D1DrizzleClientInterface.ts

@@ -0,0 +1,15 @@
+import type { AnyD1Database } from 'drizzle-orm/d1';
+import type { DrizzleClientInterface } from '@drizzle-adapter/core';
+
+export interface D1DrizzleClientInterface extends DrizzleClientInterface
+{
+	execute(...args: any[]): ReturnType<AnyD1Database['run']>;
+	$with(...args: any[]): ReturnType<AnyD1Database['$with']>;
+	$count(...args: any[]): ReturnType<AnyD1Database['$count']>;
+	with(...args: any[]): ReturnType<AnyD1Database['with']>;
+	select(...args: any[]): ReturnType<AnyD1Database['select']>;
+	selectDistinct(...args: any[]): ReturnType<AnyD1Database['selectDistinct']>;
+	update(...args: any[]): ReturnType<AnyD1Database['update']>;
+	insert(...args: any[]): ReturnType<AnyD1Database['insert']>;
+	transaction(...args: any[]): ReturnType<AnyD1Database['transaction']>;
+}

package/src/Interface/index.ts

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

package/src/Type/Types.ts

@@ -0,0 +1,7 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { TypeDrizzleDatabaseConfig } from '@drizzle-adapter/core';
+
+export interface TypeD1DatabaseConfig extends TypeDrizzleDatabaseConfig
+{
+	readonly DATABASE: D1Database;
+}

package/src/Type/index.ts

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

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './Adapter';
+export * from './Factory';
+export * from './Interface';
+export * from './Type';
+
+// default export so that core factory can use it directly
+import { D1DrizzleAdapterFactory } from './Factory';
+export default D1DrizzleAdapterFactory;

package/tests/Adapter/D1DrizzleAdapter.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, vi } from 'vitest';
+import { D1DrizzleAdapter } from '../../src/Adapter/D1DrizzleAdapter';
+import { D1DrizzleConnection } from '../../src/Adapter/D1DrizzleConnection';
+import { SqliteCoreDrizzleDataTypes } from '@drizzle-adapter/sqlite-core';
+import type { D1Database } from '@cloudflare/workers-types';
+
+describe('D1DrizzleAdapter', () => {
+	const mockD1Database: D1Database = {
+		prepare: vi.fn(),
+		batch: vi.fn(),
+		exec: vi.fn(),
+		dump: vi.fn()
+	};
+
+	it('should create an instance with a D1 database', () => {
+		const adapter = new D1DrizzleAdapter(mockD1Database);
+		expect(adapter).toBeInstanceOf(D1DrizzleAdapter);
+	});
+
+	it('should return sqlite as dialect', () => {
+		const adapter = new D1DrizzleAdapter(mockD1Database);
+		expect(adapter.getDialect()).toBe('sqlite');
+	});
+
+	it('should return SqliteCoreDrizzleDataTypes instance', () => {
+		const adapter = new D1DrizzleAdapter(mockD1Database);
+		const dataTypes = adapter.getDataTypes();
+		expect(dataTypes).toBeInstanceOf(SqliteCoreDrizzleDataTypes);
+	});
+
+	it('should return D1DrizzleConnection instance with the provided database', () => {
+		const adapter = new D1DrizzleAdapter(mockD1Database);
+		const connection = adapter.getConnection();
+		expect(connection).toBeInstanceOf(D1DrizzleConnection);
+	});
+});

package/tests/Adapter/D1DrizzleConnection.test.ts

@@ -0,0 +1,40 @@
+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';
+
+// Mock drizzle-orm/d1
+vi.mock('drizzle-orm/d1', () => ({
+	drizzle: vi.fn().mockReturnValue({ mockedClient: true })
+}));
+
+describe('D1DrizzleConnection', () => {
+	const mockD1Database: D1Database = {
+		prepare: vi.fn(),
+		batch: vi.fn(),
+		exec: vi.fn(),
+		dump: vi.fn()
+	};
+
+	it('should create an instance with a D1 database and initialize drizzle', () => {
+		const connection = new D1DrizzleConnection(mockD1Database);
+		expect(connection).toBeInstanceOf(D1DrizzleConnection);
+		expect(drizzle).toHaveBeenCalledWith(mockD1Database);
+	});
+
+	it('should not perform any operation on connect (serverless)', async () => {
+		const connection = new D1DrizzleConnection(mockD1Database);
+		await expect(connection.connect()).resolves.toBeUndefined();
+	});
+
+	it('should not perform any operation on disconnect (serverless)', async () => {
+		const connection = new D1DrizzleConnection(mockD1Database);
+		await expect(connection.disconnect()).resolves.toBeUndefined();
+	});
+
+	it('should return the query client', async () => {
+		const connection = new D1DrizzleConnection(mockD1Database);
+		const client = await connection.getClient();
+		expect(client).toEqual({ mockedClient: true });
+	});
+});

package/tests/Factory/D1DrizzleAdapterFactory.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { D1DrizzleAdapterFactory } from '../../src/Factory';
+import { D1DrizzleAdapter } from '../../src/Adapter';
+import { drizzle } from 'drizzle-orm/d1';
+import type { D1Database } from '@cloudflare/workers-types';
+import type { TypeD1DatabaseConfig } from '../../src/Type';
+
+// Mock drizzle-orm/d1
+vi.mock('drizzle-orm/d1', () => ({
+	drizzle: vi.fn().mockReturnValue({ mockedQueryBuilder: true })
+}));
+
+describe('D1DrizzleAdapterFactory', () => {
+	const mockD1Database: D1Database = {
+		prepare: vi.fn(),
+		batch: vi.fn(),
+		exec: vi.fn(),
+		dump: vi.fn()
+	};
+
+	const mockDatabaseConfig: TypeD1DatabaseConfig = {
+		DATABASE_DRIVER: 'd1',
+		DATABASE_URL: mockD1Database
+	};
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should be instantiable', () => {
+		const factory = new D1DrizzleAdapterFactory();
+		expect(factory).toBeInstanceOf(D1DrizzleAdapterFactory);
+	});
+
+	it('should create a D1DrizzleAdapter instance', async () => {
+		const factory = new D1DrizzleAdapterFactory();
+		const adapter = await factory.create(mockDatabaseConfig);
+
+		expect(adapter).toBeInstanceOf(D1DrizzleAdapter);
+	});
+});

package/tests/Integration/D1DrizzleAdapter.integration.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { getWorker, isReady, getWorkerUrl } from '../test-runner';
+
+interface User {
+	id: number;
+	name: string;
+	email: string;
+}
+
+interface CreateRecordResponse {
+	success: boolean;
+	result: User;
+}
+
+interface UpdateRecordResponse {
+	success: boolean;
+	result: User;
+}
+
+interface SelectRecordsResponse {
+	success: boolean;
+	allUsers: User[];
+	specificUser: User;
+}
+
+describe('D1DrizzleAdapter Integration Tests', () => {
+	it('should create a new record', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/create-record`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as CreateRecordResponse;
+		expect(data.success).toBe(true);
+		expect(data.result.name).toBe('John Doe');
+		expect(data.result.email).toBe('john@example.com');
+	});
+
+	it('should update an existing record', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/update-record`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as UpdateRecordResponse;
+		expect(data.success).toBe(true);
+		expect(data.result.name).toBe('Jane Smith');
+		expect(data.result.email).toBe('jane@example.com');
+	});
+
+	it('should select records', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/select-records`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as SelectRecordsResponse;
+		expect(data.success).toBe(true);
+		expect(data.allUsers.length).toBeGreaterThanOrEqual(2);
+		expect(data.specificUser.name).toBe('User 1');
+	});
+});

package/tests/Integration/D1DrizzleMigrations.integration.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { getWorker, isReady, getWorkerUrl } from '../test-runner';
+
+interface EventAction {
+	id: number;
+	createdAt: number;
+	updatedAt: number;
+	action: string;
+}
+
+interface MigrationsResponse {
+	success: boolean;
+	initial: EventAction;
+	updated: EventAction;
+}
+
+interface ConstraintsResponse {
+	success: boolean;
+}
+
+interface TextTypeResponse {
+	success: boolean;
+	result: EventAction;
+}
+
+describe('D1Drizzle Migrations Integration Tests', () => {
+	it('should create a table with migrations', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/migrations`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as MigrationsResponse;
+		expect(data.success).toBe(true);
+		expect(data.initial.action).toBe('TEST_ACTION');
+		expect(data.updated.action).toBe('UPDATED_ACTION');
+		expect(data.updated.updatedAt).toBeGreaterThan(data.initial.updatedAt);
+	});
+
+	it('should enforce NOT NULL constraints', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/constraints`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as ConstraintsResponse;
+		expect(data.success).toBe(true);
+	});
+
+	it('should handle TEXT data type properly', async () => {
+		if (!isReady()) {
+			console.log('Skipping test: worker not ready');
+			return;
+		}
+
+		const worker = getWorker();
+		const workerUrl = getWorkerUrl();
+		if (!worker || !workerUrl) {
+			throw new Error('Worker not available');
+		}
+
+		const response = await worker.fetch(`${workerUrl}/test/text-type`);
+		if (!response.ok) {
+			const error = await response.text();
+			console.error('Error response:', error);
+		}
+		expect(response.ok).toBe(true);
+
+		const data = await response.json() as TextTypeResponse;
+		expect(data.success).toBe(true);
+		expect(data.result.action.length).toBe(1000);
+		expect(data.result.action).toBe('A'.repeat(1000));
+	});
+});

package/tests/test-runner.ts

@@ -0,0 +1,51 @@
+import { unstable_dev } from 'wrangler';
+import type { UnstableDevWorker } from 'wrangler';
+import { beforeAll, afterAll } from 'vitest';
+
+let worker: UnstableDevWorker | null = null;
+let isWorkerReady = false;
+let workerUrl: string | null = null;
+
+beforeAll(async () => {
+	try {
+		// Start worker with D1 binding
+		worker = await unstable_dev('tests/worker.ts', {
+			experimental: { disableExperimentalWarning: true },
+			local: true
+		});
+
+		// Store worker URL
+		workerUrl = `http://${worker.address}:${worker.port}`;
+
+		// Test if worker is ready
+		const response = await worker.fetch('/__d1');
+		if (response.ok) {
+			isWorkerReady = true;
+			console.log('Worker ready');
+		}
+	} catch (error) {
+		console.error('Failed to start worker:', error);
+	}
+});
+
+afterAll(async () => {
+	if (worker) {
+		await worker.stop();
+		console.log('Worker stopped');
+	}
+});
+
+// Export function to get worker status
+export function isReady(): boolean {
+	return isWorkerReady;
+}
+
+// Export function to get worker
+export function getWorker(): UnstableDevWorker | null {
+	return worker;
+}
+
+// Export function to get worker URL
+export function getWorkerUrl(): string | null {
+	return workerUrl;
+}