Made pg code fully separated from the core one

Author: oskardudycz

src/package.json

@@ -11,6 +11,7 @@
     "setup": "cat .nvmrc | nvm install; nvm use",
     "build": "run-s build:ts build:dumbo build:pongo",
     "build:ts": "tsc -b",
+    "build:ts:clean": "tsc --build --clean",
     "build:ts:watch": "tsc -b --watch",
     "build:dumbo": "npm run build -w packages/dumbo",
     "build:pongo": "npm run build -w packages/pongo",

src/packages/dumbo/src/benchmarks/index.ts

@@ -2,7 +2,8 @@ import 'dotenv/config';
 
 import Benchmark from 'benchmark';
 import pg from 'pg';
-import { defaultPostgreSQLConenctionString, dumbo, rawSql, single } from '..';
+import { rawSql, single } from '..';
+import { defaultPostgreSQLConenctionString, dumbo } from '../pg';
 
 const connectionString =
   process.env.BENCHMARK_POSTGRESQL_CONNECTION_STRING ??

src/packages/dumbo/src/core/connections/connection.ts

@@ -1,3 +1,4 @@
+import type { ConnectorType } from '../connectors';
 import {
   sqlExecutor,
   type DbSQLExecutor,
@@ -10,11 +11,11 @@ import {
 } from './transaction';
 
 export interface Connection<
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
 > extends WithSQLExecutor,
-    DatabaseTransactionFactory<ConnectorType> {
-  connector: ConnectorType;
+    DatabaseTransactionFactory<Connector> {
+  connector: Connector;
   open: () => Promise<DbClient>;
   close: () => Promise<void>;
 }
@@ -30,36 +31,34 @@ export interface ConnectionFactory<
 }
 
 export type CreateConnectionOptions<
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
-  ConnectionType extends Connection<ConnectorType, DbClient> = Connection<
-    ConnectorType,
+  ConnectionType extends Connection<Connector, DbClient> = Connection<
+    Connector,
     DbClient
   >,
   Executor extends DbSQLExecutor = DbSQLExecutor,
 > = {
-  connector: ConnectorType;
+  connector: Connector;
   connect: Promise<DbClient>;
   close: (client: DbClient) => Promise<void>;
   initTransaction: (
     connection: () => ConnectionType,
-  ) => (
-    client: Promise<DbClient>,
-  ) => DatabaseTransaction<ConnectorType, DbClient>;
+  ) => (client: Promise<DbClient>) => DatabaseTransaction<Connector, DbClient>;
   executor: () => Executor;
 };
 
 export const createConnection = <
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
-  ConnectionType extends Connection<ConnectorType, DbClient> = Connection<
-    ConnectorType,
+  ConnectionType extends Connection<Connector, DbClient> = Connection<
+    Connector,
     DbClient
   >,
   Executor extends DbSQLExecutor = DbSQLExecutor,
 >(
   options: CreateConnectionOptions<
-    ConnectorType,
+    Connector,
     DbClient,
     ConnectionType,
     Executor
@@ -71,7 +70,7 @@ export const createConnection = <
 
   const getClient = async () => client ?? (client = await connect);
 
-  const connection: Connection<ConnectorType, DbClient> = {
+  const connection: Connection<Connector, DbClient> = {
     connector,
     open: getClient,
     close: () => (client ? close(client) : Promise.resolve()),

src/packages/dumbo/src/core/connections/transaction.ts

@@ -1,26 +1,27 @@
+import type { ConnectorType } from '../connectors';
 import type { WithSQLExecutor } from '../execute';
 import { type Connection } from './connection';
 
 export interface DatabaseTransaction<
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
 > extends WithSQLExecutor {
-  connector: ConnectorType;
-  connection: Connection<ConnectorType, DbClient>;
+  connector: Connector;
+  connection: Connection<Connector, DbClient>;
   begin: () => Promise<void>;
   commit: () => Promise<void>;
   rollback: (error?: unknown) => Promise<void>;
 }
 
 export interface DatabaseTransactionFactory<
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
 > {
-  transaction: () => DatabaseTransaction<ConnectorType, DbClient>;
+  transaction: () => DatabaseTransaction<Connector, DbClient>;
 
   withTransaction: <Result = never>(
     handle: (
-      transaction: DatabaseTransaction<ConnectorType, DbClient>,
+      transaction: DatabaseTransaction<Connector, DbClient>,
     ) => Promise<TransactionResult<Result> | Result>,
   ) => Promise<Result>;
 }
@@ -38,13 +39,13 @@ const toTransactionResult = <Result>(
     : { success: true, result: transactionResult };
 
 export const executeInTransaction = async <
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
   Result = void,
 >(
-  transaction: DatabaseTransaction<ConnectorType, DbClient>,
+  transaction: DatabaseTransaction<Connector, DbClient>,
   handle: (
-    transaction: DatabaseTransaction<ConnectorType, DbClient>,
+    transaction: DatabaseTransaction<Connector, DbClient>,
   ) => Promise<TransactionResult<Result> | Result>,
 ): Promise<Result> => {
   await transaction.begin();
@@ -63,14 +64,14 @@ export const executeInTransaction = async <
 };
 
 export const transactionFactoryWithDbClient = <
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
 >(
   connect: () => Promise<DbClient>,
   initTransaction: (
     client: Promise<DbClient>,
-  ) => DatabaseTransaction<ConnectorType, DbClient>,
-): DatabaseTransactionFactory<ConnectorType, DbClient> => ({
+  ) => DatabaseTransaction<Connector, DbClient>,
+): DatabaseTransactionFactory<Connector, DbClient> => ({
   transaction: () => initTransaction(connect()),
   withTransaction: (handle) =>
     executeInTransaction(initTransaction(connect()), handle),

src/packages/dumbo/src/core/execute/execute.ts

@@ -1,15 +1,16 @@
 import type { Connection } from '../connections';
+import type { ConnectorType } from '../connectors';
 import type { QueryResult, QueryResultRow } from '../query';
 import { type SQL } from '../sql';
 
 export type SQLQueryOptions = { timeoutMs?: number };
 export type SQLCommandOptions = { timeoutMs?: number };
 
 export interface DbSQLExecutor<
-  ConnectorType extends string = string,
+  Connector extends ConnectorType = ConnectorType,
   DbClient = unknown,
 > {
-  connector: ConnectorType;
+  connector: Connector;
   query<Result extends QueryResultRow = QueryResultRow>(
     client: DbClient,
     sql: SQL,

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

@@ -1,8 +1,21 @@
+import type { Connection, ConnectionPool } from './connections';
+import type { ConnectorType } from './connectors';
+
 export * from './connections';
 export * from './connectors';
 export * from './execute';
+export * from './locks';
 export * from './query';
 export * from './schema';
 export * from './serializer';
 export * from './sql';
 export * from './tracing';
+
+export type DumboOptions<Connector extends ConnectorType = ConnectorType> = {
+  connector?: Connector;
+};
+
+export type Dumbo<
+  Connector extends ConnectorType = ConnectorType,
+  ConnectionType extends Connection<Connector> = Connection<Connector>,
+> = ConnectionPool<ConnectionType>;

src/packages/dumbo/src/index.ts

@@ -1,28 +1 @@
-import {
-  postgresPool,
-  type PostgresPool,
-  type PostgresPoolOptions,
-} from './storage/postgresql';
-
 export * from './core';
-export * from './storage/postgresql';
-
-// TODO: Merge with ConnectorTypeName
-export type SupportedConnector = `PostgreSQL:pg` | `SQLite:sqlite3`;
-
-export type PoolOptions = {
-  connector?: SupportedConnector;
-};
-
-export type DumboOptions = PoolOptions & PostgresPoolOptions;
-export type Dumbo = PostgresPool;
-
-export const connectionPool = <PoolOptionsType extends DumboOptions>(
-  options: PoolOptionsType,
-) =>
-  // TODO: this should have the pattern matching and verification
-  postgresPool(options as unknown as PostgresPoolOptions);
-
-export const dumbo = <DumboOptionsType extends DumboOptions = DumboOptions>(
-  options: DumboOptionsType,
-): Dumbo => connectionPool(options);

src/packages/dumbo/src/pg.ts

@@ -1,2 +1,3 @@
+export * from './core';
 export * from './storage/postgresql/core';
 export * from './storage/postgresql/pg';

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

@@ -1,7 +1,7 @@
 import type { ConnectorType } from '../../../core';
 
-export * from '../../../core/locks';
 export * from './connections';
+export * from './locks';
 export * from './schema';
 
 export type PostgreSQLConnector = 'PostgreSQL';

src/packages/dumbo/src/storage/postgresql/core/locks/advisoryLocks.ts

@@ -1,12 +1,14 @@
 import {
   defaultDatabaseLockOptions,
+  single,
+  sql,
   type AcquireDatabaseLockMode,
   type AcquireDatabaseLockOptions,
   type DatabaseLock,
   type DatabaseLockOptions,
   type ReleaseDatabaseLockOptions,
-} from '..';
-import { single, sql, type SQLExecutor } from '../../../../core';
+  type SQLExecutor,
+} from '../../../../core';
 
 export const tryAcquireAdvisoryLock = async (
   execute: SQLExecutor,

src/packages/dumbo/src/storage/postgresql/core/schema/migrations.int.spec.ts

@@ -5,9 +5,10 @@ import {
 import assert from 'assert';
 import { after, before, beforeEach, describe, it } from 'node:test';
 import { tableExists } from '..';
-import { type Dumbo, dumbo } from '../../../..';
+import { type Dumbo } from '../../../..';
 import { count, rawSql, sql } from '../../../../core';
 import { type SQLMigration, MIGRATIONS_LOCK_ID } from '../../../../core/schema';
+import { dumbo } from '../../../../pg';
 import { acquireAdvisoryLock, releaseAdvisoryLock } from '../locks';
 import { runPostgreSQLMigrations } from './migrations';
 

src/packages/dumbo/src/storage/postgresql/core/schema/migrations.ts

@@ -1,12 +1,14 @@
-import { AdvisoryLock, type DatabaseLockOptions } from '../..';
-import { rawSql, type Dumbo } from '../../../..';
 import {
   MIGRATIONS_LOCK_ID,
+  rawSql,
   runSQLMigrations,
   schemaComponent,
   sqlMigration,
+  type DatabaseLockOptions,
+  type Dumbo,
   type SQLMigration,
-} from '../../../../core/schema';
+} from '../../../../core';
+import { AdvisoryLock } from '../locks';
 
 export type PostgreSQLMigratorOptions = {
   lock?: {

src/packages/dumbo/src/storage/postgresql/index.ts

@@ -1,4 +1,32 @@
-export * from '../core/locks';
+import type { Dumbo, DumboOptions } from '../../../core';
+import {
+  type NodePostgresConnection,
+  type NodePostgresConnector,
+  type NodePostgresPool,
+  nodePostgresPool,
+  type NodePostgresPoolOptions,
+} from './connections';
+
+export type PostgresConnector = NodePostgresConnector;
+export type PostgresPool = NodePostgresPool;
+export type PostgresConnection = NodePostgresConnection;
+
+export type PostgresPoolOptions = DumboOptions<NodePostgresConnector> &
+  NodePostgresPoolOptions;
+export const postgresPool = nodePostgresPool;
+
+export const connectionPool = <PoolOptionsType extends DumboOptions>(
+  options: PoolOptionsType,
+) =>
+  // TODO: this should have the pattern matching and verification
+  postgresPool(options as unknown as PostgresPoolOptions);
+
+export const dumbo = <
+  DumboOptionsType extends PostgresPoolOptions = PostgresPoolOptions,
+>(
+  options: DumboOptionsType,
+): Dumbo<NodePostgresConnector> => connectionPool(options);
+
 export * from './connections';
 export * from './execute';
 export * from './serialization';

src/packages/dumbo/src/storage/postgresql/pg/index.ts

@@ -1,9 +1,9 @@
+import { combineMigrations } from '@event-driven-io/dumbo';
 import {
-  combineMigrations,
   dumbo,
   migrationTableSchemaComponent,
   runPostgreSQLMigrations,
-} from '@event-driven-io/dumbo';
+} from '@event-driven-io/dumbo/pg';
 import { Command } from 'commander';
 import { pongoCollectionSchemaComponent } from '../core';
 import { loadConfigFile } from './configFile';

src/packages/pongo/src/commandLine/migrate.ts

@@ -1,12 +1,12 @@
 import {
-  checkConnection,
   color,
   LogLevel,
   LogStyle,
   prettyJson,
   SQL,
   type MigrationStyle,
 } from '@event-driven-io/dumbo';
+import { checkConnection } from '@event-driven-io/dumbo/pg';
 import Table from 'cli-table3';
 import { Command } from 'commander';
 import repl from 'node:repl';