squilo 0.1.2

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

@@ -0,0 +1,79 @@
+import * as XLSX from 'xlsx';
+import type { OutputStrategy } from '../index';
+
+async function processSeparateSheets<TData>(
+  result: ReadableStream<Record<string, TData>>,
+  workbook: XLSX.WorkBook
+): Promise<boolean> {
+  let hasData = false;
+  
+  for await (const dbResult of result) {
+    for (const [database, data] of Object.entries(dbResult)) {
+      let sheetData: any[] = [];
+      if (Array.isArray(data)) {
+        sheetData = data;
+      } else if (data && typeof data === 'object') {
+        sheetData = [data];
+      } else {
+        sheetData = [{ value: data }];
+      }
+      
+      if (sheetData.length > 0) {
+        const worksheet = XLSX.utils.json_to_sheet(sheetData);
+        XLSX.utils.book_append_sheet(workbook, worksheet, database);
+        hasData = true;
+      }
+    }
+  }
+  
+  return hasData;
+}
+
+async function processCombinedSheet<TData>(
+  result: ReadableStream<Record<string, TData>>,
+  workbook: XLSX.WorkBook
+): Promise<boolean> {
+  let allData: any[] = [];
+  
+  for await (const dbResult of result) {
+    for (const [database, data] of Object.entries(dbResult)) {
+      let sheetData: any[] = [];
+      if (Array.isArray(data)) {
+        sheetData = data.map(item => ({ ...item, database }));
+      } else if (data && typeof data === 'object') {
+        sheetData = [{ ...data, database }];
+      } else {
+        sheetData = [{ value: data, database }];
+      }
+      allData.push(...sheetData);
+    }
+  }
+  
+  if (allData.length === 0) {
+    return false;
+  }
+  
+  const worksheet = XLSX.utils.json_to_sheet(allData);
+  XLSX.utils.book_append_sheet(workbook, worksheet, "Combined");
+  return true;
+}
+
+export const XlsOutputStrategy = <TData>(unique: boolean = false, filename: string): OutputStrategy<TData, void> => async (result) => {
+  const workbook = XLSX.utils.book_new();
+  
+  if (unique) {
+    const hasData = await processCombinedSheet(result, workbook);
+    if (!hasData) {
+      const emptyWorksheet = XLSX.utils.json_to_sheet([{ message: "No data available" }]);
+      XLSX.utils.book_append_sheet(workbook, emptyWorksheet, "Empty");
+    }
+  } else {
+    const hasData = await processSeparateSheets(result, workbook);
+    if (!hasData) {
+      const emptyWorksheet = XLSX.utils.json_to_sheet([{ message: "No data available" }]);
+      XLSX.utils.book_append_sheet(workbook, emptyWorksheet, "Empty");
+    }
+  }
+  
+  XLSX.writeFile(workbook, filename);
+};

package/src/pipes/retrieve/index.ts

@@ -0,0 +1,47 @@
+import type { Transaction } from "mssql";
+import { type OutputStrategy, Output } from "../output";
+import type { DatabaseConnection } from "../connect";
+
+export type RetrieveChain<TReturn> = {
+    Output<TOutput>(strategy: OutputStrategy<TReturn, TOutput>): Promise<TOutput>;
+}
+
+export const Retrieve = <TParam>(connections$: AsyncGenerator<DatabaseConnection[]>, 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 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();
+            } catch (error) {
+                // TODO: Append client name and error in a structured json file
+                transaction.rollback();
+            }
+        };
+
+        // 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);
+            }
+        })();
+
+        return {
+            Output: Output(readable)
+        };
+    }
+}

package/src/pipes/server/index.ts

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

package/src/pipes/server/types.ts

@@ -0,0 +1,3 @@
+import type { config } from "mssql";
+
+export type ServerConfig = Omit<config, "authentication" | "user" | "password">;

package/src/pool/index.ts

@@ -0,0 +1,43 @@
+import { type config, ConnectionPool } from 'mssql';
+export type Pool = {
+    connect: (partialConfig: Partial<config>) => Promise<ConnectionPool>;
+    closeAll: () => Promise<void>;
+}
+
+export function Pool(poolConfig: config): Pool {
+    const POOL: Record<string, Promise<ConnectionPool>> = {};
+
+    return {
+        connect: (partialConfig: Partial<config>) => {
+            const config = { ...poolConfig, ...partialConfig };
+            const database = config.database;
+    
+            if (!database) {
+                throw new Error('Database name is required');
+            }
+    
+            if(!(database in POOL)) {
+                const pool = new ConnectionPool(config);
+                const close = pool.close.bind(pool);
+    
+                pool.close = async () => {
+                    delete POOL[database];
+                    return await close();
+                }
+    
+                pool.on('error', err => {
+                    throw new Error(err.message);
+                });
+    
+                POOL[database] = pool.connect();
+            }
+    
+            return POOL[database]!;
+        },
+        closeAll: async () => {
+            const closes = Object.values(POOL).map(pool => pool.then(p => p.close()));
+            await Promise.all(closes);
+        }
+        
+    }
+}

package/test/connect.spec.ts

@@ -0,0 +1,119 @@
+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),
+        })));
+    })
+})

package/test/container/container.spec.ts

@@ -0,0 +1,33 @@
+import { afterAll, beforeAll, describe, expect, it, test } from 'bun:test'
+import { connect, ConnectionPool } from 'mssql'
+import type { StartedTestContainer } from 'testcontainers'
+import { AzureSqlEdge, SQL_PASSWORD } from './container';
+
+describe('SQL Server', async () => {
+    let container: StartedTestContainer
+    let sqlClient: ConnectionPool
+
+    beforeAll(async () => {
+        container = await AzureSqlEdge()
+        sqlClient = await connect({
+            server: container.getHost(),
+            port: container.getMappedPort(1433),
+            database: 'master',
+            user: 'sa',
+            password: SQL_PASSWORD,
+            options: {
+                encrypt: false
+            }
+        });
+    })
+
+    afterAll(async () => {
+        await sqlClient.close();
+        await container.stop();
+    })
+
+    it('should connect to the database', async () => {
+        const result = await sqlClient.query`SELECT 'Hello'`;
+        expect(result.recordset[0]['']).toBe('Hello');
+    })
+})

package/test/container/container.ts

@@ -0,0 +1,22 @@
+import { GenericContainer, type StartedTestContainer, Wait } from "testcontainers";
+
+export const SQL_PASSWORD = "YourStrong@Passw0rd";
+
+export const AzureSqlEdge = () => new GenericContainer('mcr.microsoft.com/azure-sql-edge')
+    .withEnvironment({
+        'ACCEPT_EULA': 'Y',
+        'MSSQL_SA_PASSWORD': SQL_PASSWORD
+    })
+    .withExposedPorts(1433)
+    .withWaitStrategy(Wait.forLogMessage('Recovery is complete'))
+    .start();
+
+export const CONFIG = (container: StartedTestContainer) => ({
+    server: container.getHost(),
+    port: container.getMappedPort(1433),
+    user: "sa",
+    password: SQL_PASSWORD,
+    options: {
+        encrypt: false
+    }
+})

package/test/container/setup/databases.spec.ts

@@ -0,0 +1,24 @@
+import { beforeAll, describe, expect, it } from "bun:test"
+import { SetupDatabases } from "./databases"
+import { AzureSqlEdge, CONFIG } from "../container"
+import { connect } from "mssql"
+
+describe('Database creation', async () => {
+    const container = await AzureSqlEdge();
+
+    beforeAll(async () => {
+        await SetupDatabases(container);
+    })
+
+    it('Should create 5 databases', async () => {
+        const conn = await connect({
+            ...CONFIG(container),
+            database: "master"
+        });
+
+        const result = await conn.query`SELECT * FROM sys.databases WHERE name like 'TestDB%'`
+        expect(result.recordset).toHaveLength(5);
+
+        await conn.close();
+    })
+})

package/test/container/setup/databases.ts

@@ -0,0 +1,77 @@
+import { Bit, connect, NVarChar, Table } from "mssql";
+import { CONFIG } from "../container";
+import type { StartedTestContainer } from "testcontainers";
+
+export const CLIENTS_MANAGER_DATABASE = 'ClientsManager';
+
+export const DATABASES = [
+    "TestDB1",
+    "TestDB2",
+    "TestDB3",
+    "TestDB4",
+    "TestDB5",
+];
+
+export const SetupClientManager = async (container: StartedTestContainer) => {
+    const masterConn = await connect({
+        ...CONFIG(container),
+        database: "master"
+    });
+
+    await masterConn.query(`
+        IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = '${CLIENTS_MANAGER_DATABASE}')
+        BEGIN
+            CREATE DATABASE ${CLIENTS_MANAGER_DATABASE};
+        END
+    `);
+
+    await masterConn.close();
+
+    const clientManagerConn = await connect({
+        ...CONFIG(container),
+        database: CLIENTS_MANAGER_DATABASE
+    });
+
+    await clientManagerConn.query(`
+        IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'Clients')
+        BEGIN
+            CREATE TABLE Clients (
+                Id INT PRIMARY KEY IDENTITY(1,1),
+                Name NVARCHAR(255) UNIQUE NOT NULL,
+                DatabaseName NVARCHAR(255) UNIQUE NOT NULL,
+                Active BIT NOT NULL
+            );
+        END
+    `);
+
+    const table = new Table("Clients");
+    table.columns.add("Name", NVarChar(255), { nullable: false});
+    table.columns.add("DatabaseName", NVarChar(255), { nullable: false});
+    table.columns.add("Active", Bit(), { nullable: false});
+    
+    for (const database of DATABASES) {
+        table.rows.add(database, database, 1);
+    }
+    table.rows.add("TestDB6", "TestDB6", 0);
+
+    await clientManagerConn.request().bulk(table);
+    await clientManagerConn.close();
+}
+
+export const SetupDatabases = async (container: StartedTestContainer) => {
+    const conn = await connect({
+        ...CONFIG(container),
+        database: "master"
+    });
+
+    for (const dbName of DATABASES) {
+        await conn.query(`
+            IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = '${dbName}')
+            BEGIN
+                CREATE DATABASE ${dbName};
+            END
+        `);
+    }
+    
+    await conn.close();
+}

package/test/container/setup/users.spec.ts

@@ -0,0 +1,25 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { AzureSqlEdge, CONFIG } from "../container";
+import { DATABASES, SetupDatabases } from "./databases";
+import { SetupUsers } from "./users";
+import { connect } from "mssql";
+
+describe('Users table', async () => {
+    const container = await AzureSqlEdge();
+
+    beforeAll(async () => {
+        await SetupDatabases(container);
+        await SetupUsers(container);
+    })
+
+    test.each(DATABASES)('Should create 10 users in %s', async (database) => {
+        const conn = await connect({
+            ...CONFIG(container),
+            database
+        });
+        const result = await conn.query`SELECT * FROM Users`
+        expect(result.recordset).toHaveLength(10);
+
+        await conn.close();
+    })
+})

package/test/container/setup/users.ts

@@ -0,0 +1,54 @@
+import { DATABASES } from "./databases";
+import { connect, NVarChar, Table } from "mssql";
+import { CONFIG } from "../container";
+import { faker } from "@faker-js/faker";
+import type { StartedTestContainer } from "testcontainers";
+
+export type User = {
+  Id: number;
+  Name: string;
+  Email: string;
+};
+
+export const SetupUsers = async (container: StartedTestContainer, options: {
+  populate: boolean;
+} = { 
+  populate: true 
+}) => {
+    for (const database of DATABASES) {
+    const conn = await connect({
+      ...CONFIG(container),
+      database
+    });
+
+    await conn.request().query`
+      IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'Users')
+      BEGIN
+        CREATE TABLE Users (
+          Id INT PRIMARY KEY IDENTITY(1,1),
+          Name NVARCHAR(100) NOT NULL,
+          Email NVARCHAR(100) NOT NULL
+        );
+      END
+    `;
+
+    if (options.populate) {
+      await conn.request().query(`DELETE FROM Users`);
+
+      const usersTable = new Table("Users");
+      usersTable.columns.add("Name", NVarChar(100), { nullable: false });
+      usersTable.columns.add("Email", NVarChar(100), { nullable: false });
+    
+      for (let i = 0; i < 10; i++) {
+        const name = faker.person.fullName({ firstName: "Joe"});
+        const email = faker.internet.email({ firstName: "Joe" }) + " ";
+
+        usersTable.rows.add(name, email);
+      }
+
+      await conn.request().bulk(usersTable);
+    }
+    
+    await conn.close();
+  }
+}

package/test/index.spec.ts

@@ -0,0 +1,68 @@
+import { expect, beforeAll, describe, it, afterAll, test } from "bun:test";
+import { Server } from "../src/pipes/server";
+import { UserAndPassword } from "../src/pipes/auth/strategies";
+import { MergeOutputStrategy } from "../src/pipes/output/strategies";
+import { AzureSqlEdge, SQL_PASSWORD } from "./container/container";
+import { DATABASES, SetupDatabases } from "./container/setup/databases";
+import { SetupUsers, type User } from "./container/setup/users";
+
+describe('Squilo test', 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 SetupUsers(container);
+  })
+
+  afterAll(async () => {
+    await LocalServer.Close();
+  })
+
+  it("Get one from each database", async () => {
+
+    const users = await LocalServer
+      .Connect(DATABASES)
+      .Retrieve(async (transaction) => {
+        const result = await transaction.request().query<User>`
+            SELECT TOP 1 * FROM Users
+        `;
+
+        return result.recordset;
+      })
+      .Output(MergeOutputStrategy());
+
+      expect(users).toHaveLength(5);
+    });
+
+    test('Should fix user\'s email that are ending with extra space', async () => {
+      await LocalServer
+        .Connect(DATABASES)
+        .Execute(async (transaction) => {
+          await transaction.request().query`
+            UPDATE Users SET Email = RTRIM(Email)
+          `;
+        })
+
+      const users = await LocalServer
+        .Connect(DATABASES)
+        .Retrieve(async (transaction) => {
+          const result = await transaction.request().query<User>`
+            SELECT * FROM Users
+          `;
+
+          return result.recordset;
+        })
+        .Output(MergeOutputStrategy());
+
+      expect(users.every((user) => user.Email.endsWith(" ") === false)).toBe(true);
+    })
+});

package/test/input.spec.ts

@@ -0,0 +1,64 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { AzureSqlEdge, SQL_PASSWORD } from "./container/container";
+import { Server } from "../src/pipes/server";
+import { UserAndPassword } from "../src/pipes/auth/strategies";
+import { DATABASES, SetupDatabases } from "./container/setup/databases";
+import { SetupUsers, type User } from "./container/setup/users";
+import { MergeOutputStrategy } from "../src/pipes/output/strategies";
+
+describe('Squilo input test', 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 SetupUsers(container, { populate: false })
+    })
+
+    afterAll(async () => {
+        await localServer.Close();
+    })
+
+    test('Should add a user using console input', async () => {
+        let name: string | null = "joe";
+        let email: string | null = "joe.doe@example.com";
+
+        await localServer
+            .Connect(DATABASES)
+            .Input<Omit<User, "Id">>(() => {
+                return {
+                    Name: name!,
+                    Email: email!,
+                }
+            })
+            .Execute(async (transaction, _, user) => {
+                await transaction.request().query`
+                    INSERT INTO Users (Name, Email)
+                    VALUES (${user.Name}, ${user.Email})
+                `;
+            });
+
+            const users = await localServer
+                .Connect(DATABASES)
+                .Retrieve(async (transaction) => {
+                    const result = await transaction.request().query<User>`
+                        SELECT * FROM Users
+                    `;
+
+                    return result.recordset;
+                })
+                .Output(MergeOutputStrategy());
+
+            expect(users).toHaveLength(5);
+            
+            const everyUserIsJoe = users.every(user => user.Name === name && user.Email === email);
+            expect(everyUserIsJoe).toBe(true);
+    })
+})