squilo 0.1.2 → 0.2.0

package/src/pipes/input/index.ts

@@ -1,19 +1,14 @@
-import type { Transaction } from "mssql";
 import { Execute } from "../execute";
-import type { DatabaseConnection } from "../connect";
-import { Retrieve, type RetrieveChain } from "../retrieve";
+import type { DatabaseConnection } from "../connect/types";
+import { Retrieve } from "../retrieve";
+import type { InputChain } from "./types";
 
-export type InputChain<TParam> = {
-    Execute(fn: (transaction: Transaction, database: string, params: TParam) => Promise<void>): Promise<void>;
-    Retrieve<TResult>(fn: (transaction: Transaction, database: string, params: TParam) => Promise<TResult>): RetrieveChain<TResult>;
-}
-
-export const Input = (connections: AsyncGenerator<DatabaseConnection[]>) => {
+export const Input = (connections$: (databases: string[]) => Generator<DatabaseConnection[]>, databases$: Promise<string[]>) => {
     return <TParam>(fn: () => TParam): InputChain<TParam> => {
         const params = fn();
         return {
-            Execute: Execute(connections, params),
-            Retrieve: Retrieve(connections, params)
+            Execute: Execute(connections$, databases$, params),
+            Retrieve: Retrieve(connections$, databases$, params)
         }
     }
 }

package/src/pipes/input/types.ts

@@ -0,0 +1,7 @@
+import type { Transaction } from "mssql";
+import type { RetrieveChain } from "../retrieve/types";
+
+export type InputChain<TParam> = {
+    Execute(fn: (transaction: Transaction, database: string, params: TParam) => Promise<void>): Promise<void>;
+    Retrieve<TResult>(fn: (transaction: Transaction, database: string, params: TParam) => Promise<TResult>): RetrieveChain<TResult>;
+}

package/src/pipes/output/index.ts

@@ -1,4 +1,5 @@
-export type OutputStrategy<TReturn, TOutput = void> = (data: ReadableStream<Record<string, TReturn>>) => Promise<TOutput>;
-
-export const Output = <TReturn, TOutput = void>(data: ReadableStream<Record<string, TReturn>>) => (strategy: OutputStrategy<TReturn, TOutput>): Promise<TOutput> => strategy(data);
+import type { OutputStrategy } from "./types";
 
+export const Output = 
+    <TReturn, TOutput = void>(data: ReadableStream<Record<string, TReturn>>) => 
+    (strategy: OutputStrategy<TReturn, TOutput>): Promise<TOutput> => strategy(data);

package/src/pipes/output/strategies/console.ts

@@ -1,4 +1,4 @@
-import type { OutputStrategy } from '../index';
+import type { OutputStrategy } from '../types';
 
 export const ConsoleOutputStrategy = <TData>(): OutputStrategy<TData, void> => async (result) => {
   for await (const data of result) {

package/src/pipes/output/strategies/json.spec.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { JsonOutputStrategy } from "./index";
 
 describe("JsonOutputStrategy", () => {
-  test("should format data as JSON with database keys", async () => {
+  test("should write JSON data to file and return filename", async () => {
     const mockData = new ReadableStream({
       start(controller) {
         controller.enqueue({ "database1": [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }] });
@@ -14,14 +14,19 @@ describe("JsonOutputStrategy", () => {
     const strategy = JsonOutputStrategy();
     const result = await strategy(mockData);
     
-    expect(typeof result).toBe("object");
-    expect(result).toEqual({
+    // Verify file exists and contains correct data
+    const fileContent = await Bun.file(result).text();
+    const parsedData = JSON.parse(fileContent);
+    expect(parsedData).toEqual({
       "database1": [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }],
       "database2": [{ id: 3, name: "Charlie" }]
     });
+    
+    // Clean up
+    await Bun.$`rm ${result}`;
   });
 
-  test("should handle empty data", async () => {
+  test("should handle empty data and create file", async () => {
     const mockData = new ReadableStream({
       start(controller) {
         controller.enqueue({});
@@ -32,7 +37,12 @@ describe("JsonOutputStrategy", () => {
     const strategy = JsonOutputStrategy();
     const result = await strategy(mockData);
     
-    expect(typeof result).toBe("object");
-    expect(result).toEqual({});
+    // Verify file exists and contains empty object
+    const fileContent = await Bun.file(result).text();
+    const parsedData = JSON.parse(fileContent);
+    expect(parsedData).toEqual({});
+    
+    // Clean up
+    await Bun.$`rm ${result}`;
   });
 });

package/src/pipes/output/strategies/json.ts

@@ -1,9 +1,20 @@
-import type { OutputStrategy } from '../index';
+import type { OutputStrategy } from '../types';
 
-export const JsonOutputStrategy = <TData>(): OutputStrategy<TData, Record<string, TData[]>> => async (result) => {
+export const JsonOutputStrategy = <TData>(): OutputStrategy<TData, string> => async (result) => {
   const data: Record<string, TData[]> = {};
+  
   for await (const item of result) {
     Object.assign(data, item);
   }
-  return data;
+
+  let filename = process.argv[1]?.replace(/\.(?:js|ts)/, '')
+  filename = `${filename}-${Date.now()}.json`;
+
+  try {
+    await Bun.write(filename, JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.error('Error writing JSON file:', error);
+  }
+
+  return filename;
 };

package/src/pipes/output/strategies/merge.ts

@@ -1,4 +1,4 @@
-import type { OutputStrategy } from '../index';
+import type { OutputStrategy } from '../types';
 
 export const MergeOutputStrategy = <TData extends Array<unknown>, TMerged = TData extends Array<infer TItem> ? TItem : TData>(): OutputStrategy<TData, TMerged[]> => async (result) => {
   const data: TMerged[] = [];

package/src/pipes/output/strategies/xls.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { XlsOutputStrategy } from "./index";
+import * as XLSX from "xlsx";
 
 describe("XlsOutputStrategy", () => {
   test("should generate XLS file with separate sheets", async () => {
@@ -13,14 +14,13 @@ describe("XlsOutputStrategy", () => {
       }
     });
 
-    const testFile = "/tmp/test-separate.xlsx";
-    const strategy = XlsOutputStrategy(false, testFile);
-    await strategy(mockData);
+    const strategy = XlsOutputStrategy(false);
+    const filename = await strategy(mockData);
     
-    expect(await Bun.file(testFile).exists()).toBe(true);
+    expect(await Bun.file(filename).exists()).toBe(true);
     
     // Clean up
-    await Bun.file(testFile).delete();
+    await Bun.file(filename).delete();
   });
 
   test("should generate XLS file with combined sheet when unique=true", async () => {
@@ -34,14 +34,13 @@ describe("XlsOutputStrategy", () => {
       }
     });
 
-    const testFile = "/tmp/test-combined.xlsx";
-    const strategy = XlsOutputStrategy(true, testFile);
-    await strategy(mockData);
+    const strategy = XlsOutputStrategy(true);
+    const filename = await strategy(mockData);
     
-    expect(await Bun.file(testFile).exists()).toBe(true);
+    expect(await Bun.file(filename).exists()).toBe(true);
     
     // Clean up
-    await Bun.file(testFile).delete();
+    await Bun.file(filename).delete();
   });
 
   test("should create empty sheet when no data provided", async () => {
@@ -52,13 +51,43 @@ describe("XlsOutputStrategy", () => {
       }
     });
 
-    const testFile = "/tmp/test-empty.xlsx";
-    const strategy = XlsOutputStrategy(false, testFile);
-    await strategy(mockData);
+    const strategy = XlsOutputStrategy(false);
+    const filename = await strategy(mockData);
     
-    expect(await Bun.file(testFile).exists()).toBe(true);
+    expect(await Bun.file(filename).exists()).toBe(true);
     
     // Clean up
-    await Bun.file(testFile).delete();
+    await Bun.file(filename).delete();
+  });
+
+  test("Should group rows by database when unique=true", async () => {
+    const mockData = new ReadableStream({
+      start(controller) {
+        controller.enqueue({ 
+          "database1": [{ id: 1, name: "Alice", age: 30 }, { id: 2, name: "Bob", age: 25 }],
+          "database2": [{ id: 1, name: "Charlie", age: 35 }, { id: 2, name: "Dave", age: 40 }]
+        });
+        controller.close();
+      }
+    });
+
+    const strategy = XlsOutputStrategy(true);
+    const filename = await strategy(mockData);
+
+    const file = Bun.file(filename);
+    
+    expect(await file.exists()).toBe(true);
+
+    const workbook = XLSX.read(await file.arrayBuffer(), { cellStyles: true });
+    const worksheet = workbook.Sheets["Combined"];
+    expect(worksheet).toBeDefined();
+    
+    const rows = worksheet!['!rows']!;
+    // Check if row grouping is set correctly
+    expect(rows[1]!.level).toEqual(1); // Summary row for database1
+    expect(rows[3]!.level).toEqual(1); // Summary row for database2
+    
+    // Clean up
+    await Bun.file(filename).delete();
   });
 });

package/src/pipes/output/strategies/xls.ts

@@ -1,5 +1,5 @@
 import * as XLSX from 'xlsx';
-import type { OutputStrategy } from '../index';
+import type { OutputStrategy } from '../types';
 
 async function processSeparateSheets<TData>(
   result: ReadableStream<Record<string, TData>>,
@@ -9,7 +9,7 @@ async function processSeparateSheets<TData>(
   
   for await (const dbResult of result) {
     for (const [database, data] of Object.entries(dbResult)) {
-      let sheetData: any[] = [];
+      let sheetData: unknown[] = [];
       if (Array.isArray(data)) {
         sheetData = data;
       } else if (data && typeof data === 'object') {
@@ -33,18 +33,28 @@ async function processCombinedSheet<TData>(
   result: ReadableStream<Record<string, TData>>,
   workbook: XLSX.WorkBook
 ): Promise<boolean> {
-  let allData: any[] = [];
+  const allData: unknown[] = [];
+  const databaseGroups: { [database: string]: { startRow: number, endRow: number } } = {};
+  let currentRow = 1; // Start from row 1 (header is row 0)
   
   for await (const dbResult of result) {
     for (const [database, data] of Object.entries(dbResult)) {
-      let sheetData: any[] = [];
+      let sheetData: unknown[] = [];
       if (Array.isArray(data)) {
-        sheetData = data.map(item => ({ ...item, database }));
+        sheetData = data.map(item => ({ database, ...item }));
       } else if (data && typeof data === 'object') {
-        sheetData = [{ ...data, database }];
+        sheetData = [{ database, ...data }];
       } else {
-        sheetData = [{ value: data, database }];
+        sheetData = [{ database, value: data }];
       }
+      
+      // Track the start row for this database group
+      databaseGroups[database] ??= { startRow: currentRow, endRow: currentRow };
+      
+      // Update the end row for this database group
+      databaseGroups[database].endRow = currentRow + sheetData.length - 1;
+      currentRow += sheetData.length;
+      
       allData.push(...sheetData);
     }
   }
@@ -54,11 +64,23 @@ async function processCombinedSheet<TData>(
   }
   
   const worksheet = XLSX.utils.json_to_sheet(allData);
+  
+  worksheet['!rows'] ??= [];
+  
+  // Set row grouping for each database
+  for (const [_, { startRow, endRow }] of Object.entries(databaseGroups)) {
+    // Set level 1 for all rows in this database group
+    for (let i = startRow; i <= endRow; i++) {
+      worksheet['!rows'][i] ??= {hpx: 20};
+      worksheet['!rows'][i]!.level = i === endRow ? 0 : 1;
+    }
+  }
+  
   XLSX.utils.book_append_sheet(workbook, worksheet, "Combined");
   return true;
 }
 
-export const XlsOutputStrategy = <TData>(unique: boolean = false, filename: string): OutputStrategy<TData, void> => async (result) => {
+export const XlsOutputStrategy = <TData>(unique: boolean = false): OutputStrategy<TData, string> => async (result) => {
   const workbook = XLSX.utils.book_new();
   
   if (unique) {
@@ -74,6 +96,16 @@ export const XlsOutputStrategy = <TData>(unique: boolean = false, filename: stri
       XLSX.utils.book_append_sheet(workbook, emptyWorksheet, "Empty");
     }
   }
-  
-  XLSX.writeFile(workbook, filename);
+
+  let filename = process.argv[1]?.replace(/\.(?:js|ts)/, '');
+  filename = `${filename}-${Date.now()}.xlsx`;
+
+  try {
+    const buffer = XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx', cellStyles: true });
+    await Bun.write(filename, buffer);
+    return filename;
+  } catch (error) {
+    console.error('Error writing Excel file');
+    throw error;
+  }
 };

package/src/pipes/output/types.ts

@@ -0,0 +1 @@
+export type OutputStrategy<TReturn, TOutput = void> = (data: ReadableStream<Record<string, TReturn>>) => Promise<TOutput>;

package/src/pipes/retrieve/index.ts

@@ -1,43 +1,72 @@
 import type { Transaction } from "mssql";
-import { type OutputStrategy, Output } from "../output";
-import type { DatabaseConnection } from "../connect";
+import { Output } from "../output"
+import type { DatabaseConnection } from "../connect/types";
+import type { RetrieveChain } from "./types";
+import { Presets, SingleBar } from "cli-progress";
+import { LoadEnv } from "../../utils/load-env";
+import { AppendError, CleanErrors, type ErrorType } from "../../utils/append-error";
 
-export type RetrieveChain<TReturn> = {
-    Output<TOutput>(strategy: OutputStrategy<TReturn, TOutput>): Promise<TOutput>;
-}
+const ENV = LoadEnv();
+let ERRORS_COUNT = 0;
 
-export const Retrieve = <TParam>(connections$: AsyncGenerator<DatabaseConnection[]>, input: TParam) => {
+export const Retrieve = <TParam>(
+    connections$: (databases: string[]) => Generator<DatabaseConnection[]>,
+    databases$: Promise<string[]>,
+    input: TParam
+) => {
     return <TReturn>(fn: (transaction: Transaction, database: string, params: TParam) => Promise<TReturn>): RetrieveChain<TReturn> => {
         const { readable, writable } = new TransformStream<Record<string, TReturn>, Record<string, TReturn>>();
         const writer = writable.getWriter();
 
+        const singlerBar = new SingleBar({
+            format: `{bar} {percentage}% | {value}/{total} | {database}`
+        }, Presets.shades_classic);
+
         const executeFn = async (dc: DatabaseConnection) => {
             const opened = await dc.connection;
             const transaction = opened.transaction();
             try {
                 await transaction.begin();
                 const result = await fn(transaction, dc.database, input);
-                await writer.write({ [dc.database]: result });
                 transaction.commit();
+
+                await writer.write({ [dc.database]: result });
+
+                if (Bun.env.NODE_ENV !== 'test') {
+                    singlerBar.increment(1, { database: dc.database });
+                }
             } catch (error) {
-                // TODO: Append client name and error in a structured json file
-                transaction.rollback();
+                await transaction.rollback();
+                await AppendError(dc.database, error as ErrorType);
+
+                if (++ERRORS_COUNT > ENV.MAX_ERRORS) {
+                    await writable.abort(error as ErrorType);
+                    console.error('Max errors reached, exiting...');
+                    process.exit(1);
+                }
             }
         };
 
         // Process all connections and close the stream when done
         (async () => {
-            try {
-                for await (const connectionBatch of connections$) {
-                    const executions = connectionBatch.map(executeFn);
-                    await Promise.all(executions);
-                }
-                // Close the writer when all connections are processed
-                await writer.close();
-            } catch (error) {
-                // If there's an error in processing connections, abort the writer
-                writer.abort(error);
+            await CleanErrors();
+            const databases = await databases$;
+
+            if (Bun.env.NODE_ENV !== 'test') {
+                singlerBar.start(databases.length, 0);
+            }
+
+            for await (const connectionBatch of connections$(databases)) {
+                const executions = connectionBatch.map(executeFn);
+                await Promise.allSettled(executions);
+            }
+
+            if (Bun.env.NODE_ENV !== 'test') {
+                singlerBar.stop();
             }
+
+            // Close the writer when all connections are processed
+            await writer.close();
         })();
 
         return {

package/src/pipes/retrieve/types.ts

@@ -0,0 +1,5 @@
+import type { OutputStrategy } from "../output/types";
+
+export type RetrieveChain<TReturn> = {
+    Output<TOutput>(strategy: OutputStrategy<TReturn, TOutput>): Promise<TOutput>;
+}

package/src/pipes/server/index.ts

@@ -1,9 +1,5 @@
-import { type AuthStrategy, type AuthenticationChain, Auth } from "../auth";
-import type { ServerConfig } from "./types";
-
-type ServerChain = {
-    Auth(strategy: AuthStrategy): AuthenticationChain;
-}
+import { Auth } from "../auth";
+import type { ServerChain, ServerConfig } from "./types";
 
 export const Server = (config: ServerConfig): ServerChain => ({
     Auth: Auth(config),

package/src/pipes/server/types.ts

@@ -1,3 +1,8 @@
 import type { config } from "mssql";
+import type { AuthStrategy, AuthenticationChain } from "../auth/types";
 
 export type ServerConfig = Omit<config, "authentication" | "user" | "password">;
+
+export type ServerChain = {
+    Auth(strategy: AuthStrategy): AuthenticationChain;
+}

package/src/pipes/types.ts

@@ -0,0 +1 @@
+export * from "./auth/types"

package/src/utils/append-error.ts

@@ -0,0 +1,42 @@
+import { ConnectionError, PreparedStatementError, RequestError, TransactionError } from "mssql";
+
+export type ErrorType = Error | ConnectionError | TransactionError | RequestError | PreparedStatementError;
+
+const BASE_FILENAME = process.argv[1]?.replace(/\.(?:js|ts)/, '');
+const ERROR_LOG_PATH = `${BASE_FILENAME}-last-errors.json`;
+
+export const CleanErrors = async () => {
+    if (await Bun.file(ERROR_LOG_PATH).exists()) {
+        await Bun.file(ERROR_LOG_PATH).delete()
+    } 
+}
+
+export const AppendError = async (database: string, error: ErrorType) => {
+    const errorFile = Bun.file(ERROR_LOG_PATH);
+    const errorContent = await errorFile.exists() 
+        ? await errorFile.json()
+        : {};
+
+    // Create a serializable error object
+    const serializableError = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        code: (error as any).code || undefined,
+        number: (error as any).number || undefined,
+        state: (error as any).state || undefined,
+        class: (error as any).class || undefined,
+        serverName: (error as any).serverName || undefined,
+        procName: (error as any).procName || undefined,
+        lineNumber: (error as any).lineNumber || undefined
+    };
+
+    // Update error content with new error for database
+    const updatedContent = {
+        ...errorContent,
+        [database]: serializableError
+    };
+
+    // Write updated error content to file
+    await Bun.write(errorFile, JSON.stringify(updatedContent, null, 2));
+}

package/src/utils/load-env.ts

@@ -0,0 +1,18 @@
+type Env =  {
+    MAX_ERRORS: number;
+}
+
+type StringEnv = {
+    [P in keyof Env]?: string
+}
+
+declare module "bun" {
+    interface Env extends StringEnv {}
+}
+
+export const LoadEnv = (): Env => {
+    const MAX_ERRORS = Number.parseInt(Bun.env.MAX_ERRORS || '1', 10);
+    return {
+        MAX_ERRORS
+    }
+}

package/biome.json

@@ -1,34 +0,0 @@
-{
-	"$schema": "https://biomejs.dev/schemas/2.2.0/schema.json",
-	"vcs": {
-		"enabled": false,
-		"clientKind": "git",
-		"useIgnoreFile": false
-	},
-	"files": {
-		"ignoreUnknown": false
-	},
-	"formatter": {
-		"enabled": true,
-		"indentStyle": "tab"
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true
-		}
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "double"
-		}
-	},
-	"assist": {
-		"enabled": true,
-		"actions": {
-			"source": {
-				"organizeImports": "on"
-			}
-		}
-	}
-}

package/test/connect.spec.ts

@@ -1,119 +0,0 @@
-import { beforeAll, describe, expect, test, mock, afterEach} from 'bun:test'
-import { AzureSqlEdge, SQL_PASSWORD } from './container/container'
-import { Server } from '../src';
-import { UserAndPassword } from '../src/pipes/auth/strategies';
-import { CLIENTS_MANAGER_DATABASE, DATABASES, SetupClientManager, SetupDatabases } from './container/setup/databases';
-import { type DatabaseConnection } from '../src/pipes/connect';
-import type { Transaction } from 'mssql';
-
-const mockExecute = mock(<TParam>(connections$: AsyncGenerator<DatabaseConnection[]>) => (fn: (transaction: Transaction, database: string, params: TParam) => Promise<void>) => Promise<void>);
-mock.module('../src/pipes/execute', () => ({
-    Execute: mockExecute,
-}))
-
-describe('Connection overloads', async () => {
-    const container = await AzureSqlEdge();
-    const LocalServer = Server({
-        server: container.getHost(),
-        port: container.getMappedPort(1433),
-        options: {
-            encrypt: false
-        }
-    }).Auth(UserAndPassword("sa", SQL_PASSWORD));
-
-    beforeAll(async () => {
-        await SetupDatabases(container);
-        await SetupClientManager(container);
-    });
-
-    afterEach(() => {
-        mockExecute.mockClear();
-    })
-
-    test('Connect to unique database', async () => {
-        const database = DATABASES[0]!;
-        const Connection = LocalServer.Connect(database);
-
-        expect(Connection).toBeDefined();
-        expect(mockExecute).toHaveBeenCalledTimes(1);
-
-        const connectionsGenerator = mockExecute.mock.calls[0]![0];
-        const uniqueConnection = await connectionsGenerator.next();
-
-        expect(uniqueConnection.done).toBe(false);
-        expect(uniqueConnection.value).toHaveLength(1);
-        expect(uniqueConnection.value).toEqual([{
-            database,
-            connection: expect.any(Promise),
-        }]);
-    });
-
-    test('Connect with database list', async () => {
-        const databases = [DATABASES[0]!, DATABASES[1]!];
-        LocalServer.Connect(databases);
-
-        expect(mockExecute).toHaveBeenCalledTimes(1);
-        const connectionsGenerator = mockExecute.mock.calls[0]![0];
-        const connections = await connectionsGenerator.next();
-
-        expect(connections.done).toBe(false);
-        expect(connections.value).toHaveLength(2);
-        expect(connections.value).toEqual([{
-            database: DATABASES[0]!,
-            connection: expect.any(Promise),
-        }, {
-            database: DATABASES[1]!,
-            connection: expect.any(Promise),
-        }]);
-    });
-
-    test('Connect with limited concurrent database list', async () => {
-        const databases = [DATABASES[0]!, DATABASES[1]!, DATABASES[2]!, DATABASES[3]!];
-        LocalServer.Connect(databases, 2);
-
-        expect(mockExecute).toHaveBeenCalledTimes(1);
-        const connectionsGenerator = mockExecute.mock.calls[0]![0];
-        const firstConnections = await connectionsGenerator.next();
-
-        expect(firstConnections.done).toBe(false);
-        expect(firstConnections.value).toHaveLength(2); 
-        expect(firstConnections.value).toEqual([{
-            database: DATABASES[0]!,
-            connection: expect.any(Promise),
-        }, {
-            database: DATABASES[1]!,
-            connection: expect.any(Promise),
-        }]);
-
-        const secondConnections = await connectionsGenerator.next();
-        expect(secondConnections.done).toBe(false);
-        expect(secondConnections.value).toHaveLength(2);
-        expect(secondConnections.value).toEqual([{
-            database: DATABASES[2]!,
-            connection: expect.any(Promise),
-        }, {
-            database: DATABASES[3]!,
-            connection: expect.any(Promise),
-        }]);
-
-        const thirdConnections = await connectionsGenerator.next();
-        expect(thirdConnections.done).toBe(true);
-    });
-
-    test('Connect with query', async () => {
-        LocalServer.Connect({
-            database: CLIENTS_MANAGER_DATABASE,
-            query: 'SELECT DatabaseName FROM Clients WHERE Active = 1'
-        });
-
-        expect(mockExecute).toHaveBeenCalledTimes(1);
-        const connectionsGenerator = mockExecute.mock.calls[0]![0];
-        const connections = await connectionsGenerator.next();
-        expect(connections.done).toBe(false);
-        expect(connections.value).toHaveLength(5);
-        expect(connections.value).toEqual(DATABASES.map(database => ({
-            database,
-            connection: expect.any(Promise),
-        })));
-    })
-})