Removed redundant dynamic import for the sqlite3 client that was messing up with the bundle

Author: oskardudycz

.github/workflows/build_and_test.yml

@@ -41,6 +41,9 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Rebuild sqlite3
+        run: npm rebuild sqlite3
+
       - name: Build TS
         run: npm run build:ts
 

samples/simple-ts/tsup.config.ts

@@ -6,7 +6,7 @@ export default defineConfig({
   dts: true, // generate dts files
   format: ['cjs', 'esm'], // generate cjs and esm files
   minify: true, //env === 'production',
-  bundle: true, //env === 'production',
+  bundle: false, //env === 'production',
   skipNodeModulesBundle: true,
   target: 'esnext',
   outDir: 'dist', //env === 'production' ? 'dist' : 'lib',

src/package-lock.json

@@ -1,5 +1,4 @@
-import { getDatabaseDriverName, type DatabaseDriverType } from '../../..';
-import type { SQLiteClientFactory } from './connections';
+import { type DatabaseDriverType } from '../../..';
 
 export * from './connections';
 export * from './execute';
@@ -15,21 +14,3 @@ export type SQLiteDriverType<DriverName extends string = string> =
   DatabaseDriverType<SQLiteDatabaseName, DriverName>;
 
 export type SQLiteDatabaseType = 'SQLite';
-
-export const sqliteClientProvider = async <
-  DriverType extends SQLiteDriverType = SQLiteDriverType,
->(
-  driverType: DriverType,
-): Promise<SQLiteClientFactory> => {
-  const driverName = getDatabaseDriverName(driverType);
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const driverModule = await import(`../${driverName.toLowerCase()}`);
-
-  if (!('sqliteClient' in driverModule))
-    throw new Error(
-      `The driver type module "${driverType}" does not export a sqliteClient`,
-    );
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  return driverModule.sqliteClient as SQLiteClientFactory;
-};

src/packages/dumbo/src/storage/sqlite/core/index.ts

@@ -1,10 +1,10 @@
 import {
   InMemorySQLiteDatabase,
-  sqliteClientProvider,
   sqliteConnection,
   SQLiteConnectionString,
   type SQLiteClient,
   type SQLiteClientConnection,
+  type SQLiteClientFactory,
   type SQLiteDriverType,
   type SQLitePoolClientConnection,
 } from '..';
@@ -55,22 +55,22 @@ export const sqliteSingletonClientPool = <
     driverType: DriverType;
     database?: string | undefined;
     allowNestedTransactions?: boolean;
-  } & SQLiteFileNameOrConnectionString,
+  } & SQLiteFileNameOrConnectionString &
+    SQLitePoolConfig,
 ): SQLiteAmbientClientPool<DriverType> => {
-  const { driverType } = options;
+  const { driverType, sqliteClient } = options;
   let connection: SQLiteClientConnection | undefined = undefined;
 
   const getConnection = () => {
     if (connection) return connection;
 
-    const connect = () =>
-      sqliteClientProvider(driverType).then(async (sqliteClient) => {
-        const client = sqliteClient(options);
+    const connect = async () => {
+      const client = sqliteClient(options);
 
-        await client.connect();
+      await client.connect();
 
-        return client;
-      });
+      return client;
+    };
 
     return (connection = sqliteConnection({
       driverType,
@@ -101,21 +101,21 @@ export const sqliteAlwaysNewClientPool = <
     driverType: DriverType;
     database?: string | undefined;
     allowNestedTransactions?: boolean;
-  } & SQLiteFileNameOrConnectionString,
+  } & SQLiteFileNameOrConnectionString &
+    SQLitePoolConfig,
 ): SQLiteAmbientClientPool<DriverType> => {
-  const { driverType, allowNestedTransactions } = options;
+  const { driverType, allowNestedTransactions, sqliteClient } = options;
 
   return createConnectionPool({
     driverType,
     getConnection: () => {
-      const connect = () =>
-        sqliteClientProvider(driverType).then(async (sqliteClient) => {
-          const client = sqliteClient(options);
+      const connect = async () => {
+        const client = sqliteClient(options);
 
-          await client.connect();
+        await client.connect();
 
-          return client;
-        });
+        return client;
+      };
 
       return sqliteConnection({
         driverType,
@@ -218,17 +218,20 @@ export type SQLiteDumboConnectionOptions<
   serializer?: JSONSerializer;
 } & SQLiteFileNameOrConnectionString;
 
+export type SQLitePoolConfig = { sqliteClient: SQLiteClientFactory };
+
 export function sqlitePool<
   DriverType extends SQLiteDriverType = SQLiteDriverType,
 >(
   options: SQLitePoolNotPooledOptions<DriverType> &
-    SQLiteFileNameOrConnectionString,
+    SQLiteFileNameOrConnectionString &
+    SQLitePoolConfig,
 ): SQLiteAmbientClientPool<DriverType>;
 
 export function sqlitePool<
   DriverType extends SQLiteDriverType = SQLiteDriverType,
 >(
-  options: SQLiteDumboConnectionOptions<DriverType>,
+  options: SQLiteDumboConnectionOptions<DriverType> & SQLitePoolConfig,
 ):
   | SQLiteAmbientClientPool<DriverType>
   | SQLiteAmbientConnectionPool<DriverType> {

src/packages/dumbo/src/storage/sqlite/core/pool/pool.ts

@@ -4,7 +4,8 @@ import { afterEach, describe, it } from 'node:test';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { SQL } from '../../../../core';
-import { InMemorySQLiteDatabase, sqlitePool } from '../../core';
+import { sqlite3Pool } from '../../../../sqlite3';
+import { InMemorySQLiteDatabase } from '../../core';
 import { sqlite3Client } from './connection';
 
 void describe('Node SQLite pool', () => {
@@ -35,7 +36,7 @@ void describe('Node SQLite pool', () => {
 
   void describe(`in-memory database`, () => {
     void it('returns the singleton connection', async () => {
-      const pool = sqlitePool({
+      const pool = sqlite3Pool({
         driverType: 'SQLite:sqlite3',
         fileName: inMemoryfileName,
       });
@@ -58,7 +59,10 @@ void describe('Node SQLite pool', () => {
 
   void describe(`file-based database`, () => {
     void it('returns the new connection each time', async () => {
-      const pool = sqlitePool({ driverType: 'SQLite:sqlite3', fileName });
+      const pool = sqlite3Pool({
+        driverType: 'SQLite:sqlite3',
+        fileName,
+      });
       const connection = await pool.connection();
       const otherConnection = await pool.connection();
 
@@ -76,7 +80,7 @@ void describe('Node SQLite pool', () => {
     });
 
     void it('for singleton setting returns the singleton connection', async () => {
-      const pool = sqlitePool({
+      const pool = sqlite3Pool({
         driverType: 'SQLite:sqlite3',
         fileName,
         singleton: true,
@@ -99,9 +103,12 @@ void describe('Node SQLite pool', () => {
   });
 
   for (const { testName, fileName } of testCases) {
-    void describe(`sqlitePool with ${testName} database`, () => {
+    void describe(`sqlite3Pool with ${testName} database`, () => {
       void it('connects using default pool', async () => {
-        const pool = sqlitePool({ driverType: 'SQLite:sqlite3', fileName });
+        const pool = sqlite3Pool({
+          driverType: 'SQLite:sqlite3',
+          fileName,
+        });
         const connection = await pool.connection();
 
         try {
@@ -116,7 +123,7 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using client', async () => {
-        const pool = sqlitePool({
+        const pool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
           pooled: false,
@@ -135,7 +142,7 @@ void describe('Node SQLite pool', () => {
         const existingClient = sqlite3Client({ fileName });
         await existingClient.connect();
 
-        const pool = sqlitePool({
+        const pool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
           client: existingClient,
@@ -152,14 +159,14 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using connected ambient connected connection', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
         const ambientConnection = await ambientPool.connection();
         await ambientConnection.open();
 
-        const pool = sqlitePool({
+        const pool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
           connection: ambientConnection,
@@ -175,13 +182,13 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using connected ambient not-connected connection', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
         const ambientConnection = await ambientPool.connection();
 
-        const pool = sqlitePool({
+        const pool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
           connection: ambientConnection,
@@ -197,7 +204,7 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using ambient connected connection with transaction', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
@@ -206,7 +213,7 @@ void describe('Node SQLite pool', () => {
 
         try {
           await ambientConnection.withTransaction<void>(async () => {
-            const pool = sqlitePool({
+            const pool = sqlite3Pool({
               driverType: 'SQLite:sqlite3',
               fileName,
               connection: ambientConnection,
@@ -226,15 +233,15 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using ambient not-connected connection with transaction', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
         const ambientConnection = await ambientPool.connection();
 
         try {
           await ambientConnection.withTransaction<void>(async () => {
-            const pool = sqlitePool({
+            const pool = sqlite3Pool({
               driverType: 'SQLite:sqlite3',
               fileName,
               connection: ambientConnection,
@@ -254,13 +261,13 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using ambient connection in withConnection scope', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
         try {
           await ambientPool.withConnection(async (ambientConnection) => {
-            const pool = sqlitePool({
+            const pool = sqlite3Pool({
               driverType: 'SQLite:sqlite3',
               fileName,
               connection: ambientConnection,
@@ -279,14 +286,14 @@ void describe('Node SQLite pool', () => {
       });
 
       void it('connects using ambient connection in withConnection and withTransaction scope', async () => {
-        const ambientPool = sqlitePool({
+        const ambientPool = sqlite3Pool({
           driverType: 'SQLite:sqlite3',
           fileName,
         });
         try {
           await ambientPool.withConnection((ambientConnection) =>
             ambientConnection.withTransaction<void>(async () => {
-              const pool = sqlitePool({
+              const pool = sqlite3Pool({
                 driverType: 'SQLite:sqlite3',
                 fileName,
                 connection: ambientConnection,

src/packages/dumbo/src/storage/sqlite/sqlite3/connections/connection.int.spec.ts

@@ -12,16 +12,22 @@ import {
   sqlitePool,
   type SQLiteConnection,
   type SQLiteDumboConnectionOptions,
+  type SQLitePoolConfig,
 } from '../core';
-import {
-  SQLite3DriverType,
-  sqlite3Client as sqliteClient,
-} from './connections';
+import { sqlite3Client, SQLite3DriverType } from './connections';
+
+export const sqlite3Pool = (
+  options: SQLiteDumboConnectionOptions<SQLite3DriverType>,
+) =>
+  sqlitePool({
+    ...options,
+    sqliteClient: sqlite3Client,
+  } as SQLiteDumboConnectionOptions<SQLite3DriverType> & SQLitePoolConfig);
 
 export const sqlite3DatabaseDriver = {
   driverType: 'SQLite:sqlite3' as const,
   createPool: (options) =>
-    sqlitePool(options as SQLiteDumboConnectionOptions<SQLite3DriverType>),
+    sqlite3Pool(options as SQLiteDumboConnectionOptions<SQLite3DriverType>),
   sqlFormatter: sqliteFormatter,
   defaultMigratorOptions: DefaultSQLiteMigratorOptions,
   getDatabaseNameOrDefault: () => InMemorySQLiteDatabase,
@@ -52,6 +58,9 @@ export type SQLite3DumboConnectionOptions = DumboConnectionOptions<
 
 useSqlite3DatabaseDriver();
 
-export { sqlite3DatabaseDriver as databaseDriver, sqliteClient };
+export {
+  sqlite3DatabaseDriver as databaseDriver,
+  sqlite3Client as sqliteClient,
+};
 
 export const connectionPool = sqlitePool;