@anthonyalayo/drizzle-kit 1.0.1

package/src/cli/connections.ts

@@ -0,0 +1,914 @@
+import type { AwsDataApiPgQueryResult, AwsDataApiSessionOptions } from 'drizzle-orm/aws-data-api/pg';
+import type { MigrationConfig } from 'drizzle-orm/migrator';
+import type { PreparedQueryConfig } from 'drizzle-orm/pg-core';
+import fetch from 'node-fetch';
+import ws from 'ws';
+import { assertUnreachable } from '../global';
+import type { ProxyParams } from '../serializer/studio';
+import {
+	type DB,
+	LibSQLDB,
+	normalisePGliteUrl,
+	normaliseSQLiteUrl,
+	type Proxy,
+	type SQLiteDB,
+	type SqliteProxy,
+} from '../utils';
+import { assertPackages, checkPackage } from './utils';
+import { LibSQLCredentials } from './validations/libsql';
+import type { MysqlCredentials } from './validations/mysql';
+import { withStyle } from './validations/outputs';
+import type { PostgresCredentials } from './validations/postgres';
+import { SingleStoreCredentials } from './validations/singlestore';
+import type { SqliteCredentials } from './validations/sqlite';
+
+export const preparePostgresDB = async (
+	credentials: PostgresCredentials,
+): Promise<
+	DB & {
+		proxy: Proxy;
+		migrate: (config: string | MigrationConfig) => Promise<void>;
+	}
+> => {
+	if ('driver' in credentials) {
+		const { driver } = credentials;
+		if (driver === 'aws-data-api') {
+			assertPackages('@aws-sdk/client-rds-data');
+			const { RDSDataClient, ExecuteStatementCommand, TypeHint } = await import(
+				'@aws-sdk/client-rds-data'
+			);
+			const { AwsDataApiSession, drizzle } = await import(
+				'drizzle-orm/aws-data-api/pg'
+			);
+			const { migrate } = await import('drizzle-orm/aws-data-api/pg/migrator');
+			const { PgDialect } = await import('drizzle-orm/pg-core');
+
+			const config: AwsDataApiSessionOptions = {
+				database: credentials.database,
+				resourceArn: credentials.resourceArn,
+				secretArn: credentials.secretArn,
+			};
+			const rdsClient = new RDSDataClient();
+			const session = new AwsDataApiSession(
+				rdsClient,
+				new PgDialect(),
+				undefined,
+				config,
+				undefined,
+			);
+
+			const db = drizzle(rdsClient, config);
+			const migrateFn = async (config: MigrationConfig) => {
+				return migrate(db, config);
+			};
+
+			const query = async (sql: string, params: any[]) => {
+				const prepared = session.prepareQuery(
+					{ sql, params: params ?? [] },
+					undefined,
+					undefined,
+					false,
+				);
+				const result = await prepared.all();
+				return result as any[];
+			};
+			const proxy = async (params: ProxyParams) => {
+				const prepared = session.prepareQuery<
+					PreparedQueryConfig & {
+						execute: AwsDataApiPgQueryResult<unknown>;
+						values: AwsDataApiPgQueryResult<unknown[]>;
+					}
+				>(
+					{
+						sql: params.sql,
+						params: params.params ?? [],
+						typings: params.typings,
+					},
+					undefined,
+					undefined,
+					params.mode === 'array',
+				);
+				if (params.mode === 'array') {
+					const result = await prepared.values();
+					return result.rows;
+				}
+				const result = await prepared.execute();
+				return result.rows;
+			};
+
+			return {
+				query,
+				proxy,
+				migrate: migrateFn,
+			};
+		}
+
+		if (driver === 'pglite') {
+			assertPackages('@electric-sql/pglite');
+			const { PGlite, types } = await import('@electric-sql/pglite');
+			const { drizzle } = await import('drizzle-orm/pglite');
+			const { migrate } = await import('drizzle-orm/pglite/migrator');
+
+			const pglite = new PGlite(normalisePGliteUrl(credentials.url));
+			await pglite.waitReady;
+			const drzl = drizzle(pglite);
+			const migrateFn = async (config: MigrationConfig) => {
+				return migrate(drzl, config);
+			};
+
+			const parsers = {
+				[types.TIMESTAMP]: (value: any) => value,
+				[types.TIMESTAMPTZ]: (value: any) => value,
+				[types.INTERVAL]: (value: any) => value,
+				[types.DATE]: (value: any) => value,
+			};
+
+			const query = async <T>(sql: string, params: any[] = []) => {
+				const result = await pglite.query(sql, params, {
+					parsers,
+				});
+				return result.rows as T[];
+			};
+
+			const proxy = async (params: ProxyParams) => {
+				const preparedParams = preparePGliteParams(params.params);
+				const result = await pglite.query(params.sql, preparedParams, {
+					rowMode: params.mode,
+					parsers,
+				});
+				return result.rows;
+			};
+
+			return { query, proxy, migrate: migrateFn };
+		}
+
+		assertUnreachable(driver);
+	}
+
+	if (await checkPackage('pg')) {
+		console.log(withStyle.info(`Using 'pg' driver for database querying`));
+		const { default: pg } = await import('pg');
+		const { drizzle } = await import('drizzle-orm/node-postgres');
+		const { migrate } = await import('drizzle-orm/node-postgres/migrator');
+
+		const ssl = 'ssl' in credentials
+			? credentials.ssl === 'prefer'
+					|| credentials.ssl === 'require'
+					|| credentials.ssl === 'allow'
+				? { rejectUnauthorized: false }
+				: credentials.ssl === 'verify-full'
+				? {}
+				: credentials.ssl
+			: {};
+
+		// Override pg default date parsers
+		const types: { getTypeParser: typeof pg.types.getTypeParser } = {
+			// @ts-ignore
+			getTypeParser: (typeId, format) => {
+				if (typeId === pg.types.builtins.TIMESTAMPTZ) {
+					return (val) => val;
+				}
+				if (typeId === pg.types.builtins.TIMESTAMP) {
+					return (val) => val;
+				}
+				if (typeId === pg.types.builtins.DATE) {
+					return (val) => val;
+				}
+				if (typeId === pg.types.builtins.INTERVAL) {
+					return (val) => val;
+				}
+				// @ts-ignore
+				return pg.types.getTypeParser(typeId, format);
+			},
+		};
+
+		const client = 'url' in credentials
+			? new pg.Pool({ connectionString: credentials.url, max: 1 })
+			: new pg.Pool({ ...credentials, ssl, max: 1 });
+
+		const db = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.query({
+				text: sql,
+				values: params ?? [],
+				types,
+			});
+			return result.rows;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await client.query({
+				text: params.sql,
+				values: params.params,
+				...(params.mode === 'array' && { rowMode: 'array' }),
+				types,
+			});
+			return result.rows;
+		};
+
+		return { query, proxy, migrate: migrateFn };
+	}
+
+	if (await checkPackage('postgres')) {
+		console.log(
+			withStyle.info(`Using 'postgres' driver for database querying`),
+		);
+		const postgres = await import('postgres');
+
+		const { drizzle } = await import('drizzle-orm/postgres-js');
+		const { migrate } = await import('drizzle-orm/postgres-js/migrator');
+
+		const client = 'url' in credentials
+			? postgres.default(credentials.url, { max: 1 })
+			: postgres.default({ ...credentials, max: 1 });
+
+		const transparentParser = (val: any) => val;
+
+		// Override postgres.js default date parsers: https://github.com/porsager/postgres/discussions/761
+		for (const type of ['1184', '1082', '1083', '1114']) {
+			client.options.parsers[type as any] = transparentParser;
+			client.options.serializers[type as any] = transparentParser;
+		}
+		client.options.serializers['114'] = transparentParser;
+		client.options.serializers['3802'] = transparentParser;
+
+		const db = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.unsafe(sql, params ?? []);
+			return result as any[];
+		};
+
+		const proxy = async (params: ProxyParams) => {
+			if (params.mode === 'object') {
+				return await client.unsafe(params.sql, params.params);
+			}
+			return await client.unsafe(params.sql, params.params).values();
+		};
+
+		return { query, proxy, migrate: migrateFn };
+	}
+
+	if (await checkPackage('@vercel/postgres')) {
+		console.log(
+			withStyle.info(`Using '@vercel/postgres' driver for database querying`),
+		);
+		console.log(
+			withStyle.fullWarning(
+				"'@vercel/postgres' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket",
+			),
+		);
+		const { VercelPool, types: pgTypes } = await import('@vercel/postgres');
+		const { drizzle } = await import('drizzle-orm/vercel-postgres');
+		const { migrate } = await import('drizzle-orm/vercel-postgres/migrator');
+		const ssl = 'ssl' in credentials
+			? credentials.ssl === 'prefer'
+					|| credentials.ssl === 'require'
+					|| credentials.ssl === 'allow'
+				? { rejectUnauthorized: false }
+				: credentials.ssl === 'verify-full'
+				? {}
+				: credentials.ssl
+			: {};
+
+		// Override @vercel/postgres default date parsers
+		const types: { getTypeParser: typeof pgTypes.getTypeParser } = {
+			// @ts-ignore
+			getTypeParser: (typeId, format) => {
+				if (typeId === pgTypes.builtins.TIMESTAMPTZ) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.TIMESTAMP) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.DATE) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.INTERVAL) {
+					return (val: any) => val;
+				}
+				// @ts-ignore
+				return pgTypes.getTypeParser(typeId, format);
+			},
+		};
+
+		const client = 'url' in credentials
+			? new VercelPool({ connectionString: credentials.url })
+			: new VercelPool({ ...credentials, ssl });
+
+		await client.connect();
+
+		const db = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.query({
+				text: sql,
+				values: params ?? [],
+				types,
+			});
+			return result.rows;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await client.query({
+				text: params.sql,
+				values: params.params,
+				...(params.mode === 'array' && { rowMode: 'array' }),
+				types,
+			});
+			return result.rows;
+		};
+
+		return { query, proxy, migrate: migrateFn };
+	}
+
+	if (await checkPackage('@neondatabase/serverless')) {
+		console.log(
+			withStyle.info(
+				`Using '@neondatabase/serverless' driver for database querying`,
+			),
+		);
+		console.log(
+			withStyle.fullWarning(
+				"'@neondatabase/serverless' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket",
+			),
+		);
+		const { Pool, neonConfig, types: pgTypes } = await import('@neondatabase/serverless');
+		const { drizzle } = await import('drizzle-orm/neon-serverless');
+		const { migrate } = await import('drizzle-orm/neon-serverless/migrator');
+
+		const ssl = 'ssl' in credentials
+			? credentials.ssl === 'prefer'
+					|| credentials.ssl === 'require'
+					|| credentials.ssl === 'allow'
+				? { rejectUnauthorized: false }
+				: credentials.ssl === 'verify-full'
+				? {}
+				: credentials.ssl
+			: {};
+
+		// Override @neondatabase/serverless default date parsers
+		const types: { getTypeParser: typeof pgTypes.getTypeParser } = {
+			// @ts-ignore
+			getTypeParser: (typeId, format) => {
+				if (typeId === pgTypes.builtins.TIMESTAMPTZ) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.TIMESTAMP) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.DATE) {
+					return (val: any) => val;
+				}
+				if (typeId === pgTypes.builtins.INTERVAL) {
+					return (val: any) => val;
+				}
+				// @ts-ignore
+				return pgTypes.getTypeParser(typeId, format);
+			},
+		};
+
+		const client = 'url' in credentials
+			? new Pool({ connectionString: credentials.url, max: 1 })
+			: new Pool({ ...credentials, max: 1, ssl });
+		neonConfig.webSocketConstructor = ws;
+
+		const db = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async (sql: string, params?: any[]) => {
+			const result = await client.query({
+				text: sql,
+				values: params ?? [],
+				types,
+			});
+			return result.rows;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await client.query({
+				text: params.sql,
+				values: params.params,
+				...(params.mode === 'array' && { rowMode: 'array' }),
+				types,
+			});
+			return result.rows;
+		};
+
+		return { query, proxy, migrate: migrateFn };
+	}
+
+	console.error(
+		"To connect to Postgres database - please install either of 'pg', 'postgres', '@neondatabase/serverless' or '@vercel/postgres' drivers",
+	);
+	process.exit(1);
+};
+
+const parseSingleStoreCredentials = (credentials: SingleStoreCredentials) => {
+	if ('url' in credentials) {
+		const url = credentials.url;
+
+		const connectionUrl = new URL(url);
+		const pathname = connectionUrl.pathname;
+
+		const database = pathname.split('/')[pathname.split('/').length - 1];
+		if (!database) {
+			console.error(
+				'You should specify a database name in connection string (singlestore://USER:PASSWORD@HOST:PORT/DATABASE)',
+			);
+			process.exit(1);
+		}
+		return { database, url };
+	} else {
+		return {
+			database: credentials.database,
+			credentials,
+		};
+	}
+};
+
+export const connectToSingleStore = async (
+	it: SingleStoreCredentials,
+): Promise<{
+	db: DB;
+	proxy: Proxy;
+	database: string;
+	migrate: (config: MigrationConfig) => Promise<void>;
+}> => {
+	const result = parseSingleStoreCredentials(it);
+
+	if (await checkPackage('mysql2')) {
+		const { createConnection } = await import('mysql2/promise');
+		const { drizzle } = await import('drizzle-orm/singlestore');
+		const { migrate } = await import('drizzle-orm/singlestore/migrator');
+
+		const connection = result.url
+			? await createConnection(result.url)
+			: await createConnection(result.credentials!); // needed for some reason!
+
+		const db = drizzle(connection);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		await connection.connect();
+		const query: DB['query'] = async <T>(
+			sql: string,
+			params?: any[],
+		): Promise<T[]> => {
+			const res = await connection.execute(sql, params);
+			return res[0] as any;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await connection.query({
+				sql: params.sql,
+				values: params.params,
+				rowsAsArray: params.mode === 'array',
+			});
+			return result[0] as any[];
+		};
+
+		return {
+			db: { query },
+			proxy,
+			database: result.database,
+			migrate: migrateFn,
+		};
+	}
+
+	console.error(
+		"To connect to SingleStore database - please install 'singlestore' driver",
+	);
+	process.exit(1);
+};
+
+const parseMysqlCredentials = (credentials: MysqlCredentials) => {
+	if ('url' in credentials) {
+		const url = credentials.url;
+
+		const connectionUrl = new URL(url);
+		const pathname = connectionUrl.pathname;
+
+		const database = pathname.split('/')[pathname.split('/').length - 1];
+		if (!database) {
+			console.error(
+				'You should specify a database name in connection string (mysql://USER:PASSWORD@HOST:PORT/DATABASE)',
+			);
+			process.exit(1);
+		}
+		return { database, url };
+	} else {
+		return {
+			database: credentials.database,
+			credentials,
+		};
+	}
+};
+
+export const connectToMySQL = async (
+	it: MysqlCredentials,
+): Promise<{
+	db: DB;
+	proxy: Proxy;
+	database: string;
+	migrate: (config: MigrationConfig) => Promise<void>;
+}> => {
+	const result = parseMysqlCredentials(it);
+
+	if (await checkPackage('mysql2')) {
+		const { createConnection } = await import('mysql2/promise');
+		const { drizzle } = await import('drizzle-orm/mysql2');
+		const { migrate } = await import('drizzle-orm/mysql2/migrator');
+
+		const connection = result.url
+			? await createConnection(result.url)
+			: await createConnection(result.credentials!); // needed for some reason!
+
+		const db = drizzle(connection);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const typeCast = (field: any, next: any) => {
+			if (field.type === 'TIMESTAMP' || field.type === 'DATETIME' || field.type === 'DATE') {
+				return field.string();
+			}
+			return next();
+		};
+
+		await connection.connect();
+		const query: DB['query'] = async <T>(
+			sql: string,
+			params?: any[],
+		): Promise<T[]> => {
+			const res = await connection.execute({
+				sql,
+				values: params,
+				typeCast,
+			});
+			return res[0] as any;
+		};
+
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = await connection.query({
+				sql: params.sql,
+				values: params.params,
+				rowsAsArray: params.mode === 'array',
+				typeCast,
+			});
+			return result[0] as any[];
+		};
+
+		return {
+			db: { query },
+			proxy,
+			database: result.database,
+			migrate: migrateFn,
+		};
+	}
+
+	if (await checkPackage('@planetscale/database')) {
+		const { Client } = await import('@planetscale/database');
+		const { drizzle } = await import('drizzle-orm/planetscale-serverless');
+		const { migrate } = await import(
+			'drizzle-orm/planetscale-serverless/migrator'
+		);
+
+		const connection = new Client(result);
+
+		const db = drizzle(connection);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(db, config);
+		};
+
+		const query = async <T>(sql: string, params?: any[]): Promise<T[]> => {
+			const res = await connection.execute(sql, params);
+			return res.rows as T[];
+		};
+		const proxy: Proxy = async (params: ProxyParams) => {
+			const result = params.mode === 'object'
+				? await connection.execute(params.sql, params.params)
+				: await connection.execute(params.sql, params.params, {
+					as: 'array',
+				});
+			return result.rows;
+		};
+
+		return {
+			db: { query },
+			proxy,
+			database: result.database,
+			migrate: migrateFn,
+		};
+	}
+
+	console.error(
+		"To connect to MySQL database - please install either of 'mysql2' or '@planetscale/database' drivers",
+	);
+	process.exit(1);
+};
+
+const prepareSqliteParams = (params: any[], driver?: string) => {
+	return params.map((param) => {
+		if (
+			param
+			&& typeof param === 'object'
+			&& 'type' in param
+			&& 'value' in param
+			&& param.type === 'binary'
+		) {
+			const value = typeof param.value === 'object'
+				? JSON.stringify(param.value)
+				: (param.value as string);
+
+			if (driver === 'd1-http') {
+				return value;
+			}
+
+			return Buffer.from(value);
+		}
+		return param;
+	});
+};
+
+const preparePGliteParams = (params: any[]) => {
+	return params.map((param) => {
+		if (
+			param
+			&& typeof param === 'object'
+			&& 'type' in param
+			&& 'value' in param
+			&& param.type === 'binary'
+		) {
+			const value = typeof param.value === 'object'
+				? JSON.stringify(param.value)
+				: (param.value as string);
+
+			return value;
+		}
+		return param;
+	});
+};
+
+export const connectToSQLite = async (
+	credentials: SqliteCredentials,
+): Promise<
+	& SQLiteDB
+	& SqliteProxy
+	& { migrate: (config: MigrationConfig) => Promise<void> }
+> => {
+	if ('driver' in credentials) {
+		const { driver } = credentials;
+		if (driver === 'd1-http') {
+			const { drizzle } = await import('drizzle-orm/sqlite-proxy');
+			const { migrate } = await import('drizzle-orm/sqlite-proxy/migrator');
+
+			const remoteCallback: Parameters<typeof drizzle>[0] = async (
+				sql,
+				params,
+				method,
+			) => {
+				const res = await fetch(
+					`https://api.cloudflare.com/client/v4/accounts/${credentials.accountId}/d1/database/${credentials.databaseId}/${
+						method === 'values' ? 'raw' : 'query'
+					}`,
+					{
+						method: 'POST',
+						body: JSON.stringify({ sql, params }),
+						headers: {
+							'Content-Type': 'application/json',
+							Authorization: `Bearer ${credentials.token}`,
+						},
+					},
+				);
+
+				const data = (await res.json()) as
+					| {
+						success: true;
+						result: {
+							results:
+								| any[]
+								| {
+									columns: string[];
+									rows: any[][];
+								};
+						}[];
+					}
+					| {
+						success: false;
+						errors: { code: number; message: string }[];
+					};
+
+				if (!data.success) {
+					throw new Error(
+						data.errors.map((it) => `${it.code}: ${it.message}`).join('\n'),
+					);
+				}
+
+				const result = data.result[0].results;
+				const rows = Array.isArray(result) ? result : result.rows;
+
+				return {
+					rows,
+				};
+			};
+
+			const drzl = drizzle(remoteCallback);
+			const migrateFn = async (config: MigrationConfig) => {
+				return migrate(
+					drzl,
+					async (queries) => {
+						for (const query of queries) {
+							await remoteCallback(query, [], 'run');
+						}
+					},
+					config,
+				);
+			};
+
+			const db: SQLiteDB = {
+				query: async <T>(sql: string, params?: any[]) => {
+					const res = await remoteCallback(sql, params || [], 'all');
+					return res.rows as T[];
+				},
+				run: async (query: string) => {
+					await remoteCallback(query, [], 'run');
+				},
+			};
+			const proxy: SqliteProxy = {
+				proxy: async (params: ProxyParams) => {
+					const preparedParams = prepareSqliteParams(params.params, 'd1-http');
+					const result = await remoteCallback(
+						params.sql,
+						preparedParams,
+						params.mode === 'array' ? 'values' : 'all',
+					);
+
+					return result.rows;
+				},
+			};
+			return { ...db, ...proxy, migrate: migrateFn };
+		} else {
+			assertUnreachable(driver);
+		}
+	}
+
+	if (await checkPackage('@libsql/client')) {
+		const { createClient } = await import('@libsql/client');
+		const { drizzle } = await import('drizzle-orm/libsql');
+		const { migrate } = await import('drizzle-orm/libsql/migrator');
+
+		const client = createClient({
+			url: normaliseSQLiteUrl(credentials.url, 'libsql'),
+		});
+		const drzl = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const db: SQLiteDB = {
+			query: async <T>(sql: string, params?: any[]) => {
+				const res = await client.execute({ sql, args: params || [] });
+				return res.rows as T[];
+			},
+			run: async (query: string) => {
+				await client.execute(query);
+			},
+		};
+
+		const proxy: SqliteProxy = {
+			proxy: async (params: ProxyParams) => {
+				const preparedParams = prepareSqliteParams(params.params);
+				const result = await client.execute({
+					sql: params.sql,
+					args: preparedParams,
+				});
+
+				if (params.mode === 'array') {
+					return result.rows.map((row) => Object.values(row));
+				} else {
+					return result.rows;
+				}
+			},
+		};
+
+		return { ...db, ...proxy, migrate: migrateFn };
+	}
+
+	if (await checkPackage('better-sqlite3')) {
+		const { default: Database } = await import('better-sqlite3');
+		const { drizzle } = await import('drizzle-orm/better-sqlite3');
+		const { migrate } = await import('drizzle-orm/better-sqlite3/migrator');
+
+		const sqlite = new Database(
+			normaliseSQLiteUrl(credentials.url, 'better-sqlite'),
+		);
+		const drzl = drizzle(sqlite);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const db: SQLiteDB = {
+			query: async <T>(sql: string, params: any[] = []) => {
+				return sqlite.prepare(sql).bind(params).all() as T[];
+			},
+			run: async (query: string) => {
+				sqlite.prepare(query).run();
+			},
+		};
+
+		const proxy: SqliteProxy = {
+			proxy: async (params: ProxyParams) => {
+				const preparedParams = prepareSqliteParams(params.params);
+				if (
+					params.method === 'values'
+					|| params.method === 'get'
+					|| params.method === 'all'
+				) {
+					return sqlite
+						.prepare(params.sql)
+						.raw(params.mode === 'array')
+						.all(preparedParams);
+				}
+
+				return sqlite.prepare(params.sql).run(preparedParams);
+			},
+		};
+		return { ...db, ...proxy, migrate: migrateFn };
+	}
+
+	console.log(
+		"Please install either 'better-sqlite3' or '@libsql/client' for Drizzle Kit to connect to SQLite databases",
+	);
+	process.exit(1);
+};
+
+export const connectToLibSQL = async (credentials: LibSQLCredentials): Promise<
+	& LibSQLDB
+	& SqliteProxy
+	& { migrate: (config: MigrationConfig) => Promise<void> }
+> => {
+	if (await checkPackage('@libsql/client')) {
+		const { createClient } = await import('@libsql/client');
+		const { drizzle } = await import('drizzle-orm/libsql');
+		const { migrate } = await import('drizzle-orm/libsql/migrator');
+
+		const client = createClient({
+			url: normaliseSQLiteUrl(credentials.url, 'libsql'),
+			authToken: credentials.authToken,
+		});
+		const drzl = drizzle(client);
+		const migrateFn = async (config: MigrationConfig) => {
+			return migrate(drzl, config);
+		};
+
+		const db: LibSQLDB = {
+			query: async <T>(sql: string, params?: any[]) => {
+				const res = await client.execute({ sql, args: params || [] });
+				return res.rows as T[];
+			},
+			run: async (query: string) => {
+				await client.execute(query);
+			},
+			batchWithPragma: async (queries: string[]) => {
+				await client.migrate(queries);
+			},
+		};
+
+		const proxy: SqliteProxy = {
+			proxy: async (params: ProxyParams) => {
+				const preparedParams = prepareSqliteParams(params.params);
+				const result = await client.execute({
+					sql: params.sql,
+					args: preparedParams,
+				});
+
+				if (params.mode === 'array') {
+					return result.rows.map((row) => Object.values(row));
+				} else {
+					return result.rows;
+				}
+			},
+		};
+
+		return { ...db, ...proxy, migrate: migrateFn };
+	}
+
+	console.log(
+		"Please install '@libsql/client' for Drizzle Kit to connect to LibSQL databases",
+	);
+	process.exit(1);
+};