@drizzle-adapter/d1 1.0.0

package/tests/worker.ts

@@ -0,0 +1,334 @@
+/// <reference types="@cloudflare/workers-types" />
+import { D1DrizzleAdapterFactory } from '../src/Factory';
+import type { D1DrizzleAdapter } from '../src/Adapter';
+import { eq, sql } from 'drizzle-orm';
+
+// Simple UUID v4 generator for worker environment
+function generateUUID(): string {
+	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		const v = c === 'x' ? r : (r & 0x3 | 0x8);
+		return v.toString(16);
+	});
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		const url = new URL(request.url);
+
+		// Test endpoints
+		switch (url.pathname) {
+			case '/test/create-record': {
+				try {
+					const factory = new D1DrizzleAdapterFactory();
+					const adapter = await factory.create({
+						DATABASE: env.DB
+					}) as D1DrizzleAdapter;
+
+					const connection = adapter.getConnection();
+					const client = await connection.getClient();
+
+					// Create table definition
+					const dataTypes = adapter.getDataTypes();
+					const tableName = `test_users_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+					const users = dataTypes.dbTable(tableName, {
+						id: dataTypes.dbInteger('id').primaryKey({ autoIncrement: true }),
+						name: dataTypes.dbText('name').notNull(),
+						email: dataTypes.dbText('email').notNull()
+					});
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)`);
+
+					// Insert record
+					const result = await client.insert(users).values({
+						name: 'John Doe',
+						email: 'john@example.com'
+					}).returning();
+
+					// Verify and cleanup
+					const success = result[0]?.name === 'John Doe' && result[0]?.email === 'john@example.com';
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					return new Response(JSON.stringify({ success, result: result[0] }), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			case '/test/update-record': {
+				try {
+					const factory = new D1DrizzleAdapterFactory();
+					const adapter = await factory.create({
+						DATABASE: env.DB
+					}) as D1DrizzleAdapter;
+
+					const connection = adapter.getConnection();
+					const client = await connection.getClient();
+
+					// Create table definition
+					const dataTypes = adapter.getDataTypes();
+					const tableName = `test_users_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+					const users = dataTypes.dbTable(tableName, {
+						id: dataTypes.dbInteger('id').primaryKey({ autoIncrement: true }),
+						name: dataTypes.dbText('name').notNull(),
+						email: dataTypes.dbText('email').notNull()
+					});
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)`);
+
+					// Insert initial record
+					const inserted = await client.insert(users).values({
+						name: 'Jane Doe',
+						email: 'jane@example.com'
+					}).returning();
+
+					// Update record
+					const updated = await client
+						.update(users)
+						.set({ name: 'Jane Smith' })
+						.where(eq(users.id, inserted[0].id))
+						.returning();
+
+					// Verify and cleanup
+					const success = updated[0]?.name === 'Jane Smith' && updated[0]?.email === 'jane@example.com';
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					return new Response(JSON.stringify({ success, result: updated[0] }), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			case '/test/select-records': {
+				try {
+					const factory = new D1DrizzleAdapterFactory();
+					const adapter = await factory.create({
+						DATABASE: env.DB
+					}) as D1DrizzleAdapter;
+
+					const connection = adapter.getConnection();
+					const client = await connection.getClient();
+
+					// Create table definition
+					const dataTypes = adapter.getDataTypes();
+					const tableName = `test_users_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+					const users = dataTypes.dbTable(tableName, {
+						id: dataTypes.dbInteger('id').primaryKey({ autoIncrement: true }),
+						name: dataTypes.dbText('name').notNull(),
+						email: dataTypes.dbText('email').notNull()
+					});
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)`);
+
+					// Insert test data
+					await client.insert(users).values([
+						{ name: 'User 1', email: 'user1@example.com' },
+						{ name: 'User 2', email: 'user2@example.com' }
+					]);
+
+					// Select all records
+					const allUsers = await client.select().from(users);
+
+					// Select specific record
+					const specificUser = await client
+						.select()
+						.from(users)
+						.where(eq(users.email, 'user1@example.com'));
+
+					// Verify and cleanup
+					const success = allUsers.length >= 2 && 
+						specificUser[0]?.name === 'User 1';
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					return new Response(JSON.stringify({ 
+						success, 
+						allUsers,
+						specificUser: specificUser[0]
+					}), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			case '/test/migrations': {
+				try {
+					const factory = new D1DrizzleAdapterFactory();
+					const adapter = await factory.create({
+						DATABASE: env.DB
+					}) as D1DrizzleAdapter;
+
+					const connection = adapter.getConnection();
+					const client = await connection.getClient();
+
+					// Create table definition
+					const dataTypes = adapter.getDataTypes();
+					const tableName = `event_action_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+					const eventActionTable = dataTypes.dbTable(tableName, {
+						id: dataTypes.dbInteger('id').primaryKey({ autoIncrement: true }),
+						createdAt: dataTypes.dbInteger('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
+						updatedAt: dataTypes.dbInteger('updated_at').notNull(),
+						action: dataTypes.dbText('action').notNull()
+					});
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, created_at INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at INTEGER NOT NULL, action TEXT NOT NULL)`);
+
+					// Create index
+					const indexName = `idx_${tableName}`;
+					await env.DB.exec(`CREATE INDEX "${indexName}" ON "${tableName}" (action)`);
+
+					// Insert test data
+					const now = Math.floor(Date.now() / 1000);
+					const result = await client.insert(eventActionTable).values({
+						action: 'TEST_ACTION',
+						updatedAt: now
+					}).returning();
+
+					// Test update
+					await new Promise(resolve => setTimeout(resolve, 1000));
+					const newTimestamp = Math.floor(Date.now() / 1000);
+					const updated = await client
+						.update(eventActionTable)
+						.set({ 
+							action: 'UPDATED_ACTION',
+							updatedAt: newTimestamp
+						})
+						.where(sql`${eventActionTable.id} = ${result[0].id}`)
+						.returning();
+
+					// Verify and cleanup
+					const success = result[0]?.action === 'TEST_ACTION' && 
+						updated[0]?.action === 'UPDATED_ACTION' &&
+						updated[0]?.updatedAt > result[0]?.updatedAt;
+
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					return new Response(JSON.stringify({ 
+						success,
+						initial: result[0],
+						updated: updated[0]
+					}), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			case '/test/constraints': {
+				try {
+					const tableName = `event_action_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, created_at INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at INTEGER NOT NULL, action TEXT NOT NULL)`);
+
+					let error: unknown;
+					try {
+						// Try to insert NULL values
+						await env.DB.exec(`INSERT INTO "${tableName}" (updated_at, action) VALUES (${Math.floor(Date.now() / 1000)}, NULL)`);
+					} catch (e) {
+						error = e;
+					}
+
+					// Cleanup
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					// Verify
+					const success = error instanceof Error && 
+						error.message.includes('NOT NULL constraint failed');
+
+					return new Response(JSON.stringify({ success }), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			case '/test/text-type': {
+				try {
+					const factory = new D1DrizzleAdapterFactory();
+					const adapter = await factory.create({
+						DATABASE: env.DB
+					}) as D1DrizzleAdapter;
+
+					const connection = adapter.getConnection();
+					const client = await connection.getClient();
+
+					// Create table definition
+					const dataTypes = adapter.getDataTypes();
+					const tableName = `event_action_${Date.now()}_${generateUUID().replace(/-/g, '_')}`;
+					const eventActionTable = dataTypes.dbTable(tableName, {
+						id: dataTypes.dbInteger('id').primaryKey({ autoIncrement: true }),
+						createdAt: dataTypes.dbInteger('created_at').notNull().default(sql`CURRENT_TIMESTAMP`),
+						updatedAt: dataTypes.dbInteger('updated_at').notNull(),
+						action: dataTypes.dbText('action').notNull()
+					});
+
+					// Create table
+					await env.DB.exec(`CREATE TABLE "${tableName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, created_at INTEGER NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at INTEGER NOT NULL, action TEXT NOT NULL)`);
+
+					// Test with a long text value
+					const longAction = 'A'.repeat(1000);
+					const result = await client.insert(eventActionTable).values({
+						action: longAction,
+						updatedAt: Math.floor(Date.now() / 1000)
+					}).returning();
+
+					// Verify and cleanup
+					const success = result[0]?.action === longAction;
+					await env.DB.exec(`DROP TABLE IF EXISTS "${tableName}"`);
+
+					return new Response(JSON.stringify({ 
+						success,
+						result: result[0]
+					}), {
+						headers: { 'Content-Type': 'application/json' }
+					});
+				} catch (error: unknown) {
+					const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+					return new Response(JSON.stringify({ error: errorMessage }), {
+						status: 500,
+						headers: { 'Content-Type': 'application/json' }
+					});
+				}
+			}
+
+			default:
+				return new Response('D1 Worker Ready');
+		}
+	}
+};
+
+export interface Env {
+	DB: D1Database;
+}

package/tsconfig.eslint.json

@@ -0,0 +1,4 @@
+{
+	"extends": "./tsconfig.json",
+	"include": ["**/*.ts", "**/*.tsx"],
+}

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+	"compilerOptions": {
+		"jsx": "react",
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "ESNext",
+		
+		// Node module resolution
+		"moduleResolution": "node",
+		"verbatimModuleSyntax": true,
+		"esModuleInterop": true,
+		
+		// Emit options
+		"declaration": true,
+		"emitDeclarationOnly": false,
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"resolveJsonModule": true,
+		"allowSyntheticDefaultImports": true,
+		
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"noPropertyAccessFromIndexSignature": true,
+
+		"baseUrl": ".",
+		"paths": {
+			"@drizzle-adapter/*": ["../*/dist"]
+		}
+	},
+	"include": ["src/**/*.ts", "tests/worker.ts", "tests/worker.ts"],
+	"exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

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

package/wrangler.toml

@@ -0,0 +1,8 @@
+name = "drizzle-adapter-d1"
+main = "src/worker.ts"
+compatibility_date = "2024-02-28"
+
+[[d1_databases]]
+binding = "DB"
+database_name = "drizzle-adapter-test"
+database_id = "45bdd3c7-9fa9-4f31-be4c-8e90c09540e7"