squilo 0.1.2 → 0.2.1

package/src/utils/append-error.ts

@@ -0,0 +1,73 @@
+import type { FileSink } from "bun";
+import { ConnectionError, PreparedStatementError, RequestError, TransactionError } from "mssql";
+
+export type ErrorType = Error | ConnectionError | TransactionError | RequestError | PreparedStatementError;
+
+let customLogPath: string | null = null;
+
+export const SetLogPath = (path: string) => {
+    customLogPath = path;
+    if (logWriter) {
+        logWriter.end();
+        logWriter = null;
+    }
+}
+
+const getLogPath = () => {
+    if (customLogPath) return customLogPath;
+    const base = process.argv[1]?.replace(/\.(?:js|ts)/, '');
+    return `${base}-last-errors.json`;
+}
+
+export const CleanErrors = async () => {
+    if (logWriter) {
+        logWriter.end();
+        logWriter = null;
+    }
+    const path = getLogPath();
+    if (await Bun.file(path).exists()) {
+        await Bun.file(path).delete()
+    }
+}
+
+let logWriter: FileSink | null = null;
+
+const getWriter = () => {
+    if (!logWriter) {
+        logWriter = Bun.file(getLogPath()).writer();
+    }
+    return logWriter;
+}
+
+export const GetErrors = async () => {
+    const writer = getWriter();
+    writer.end();
+    logWriter = null;
+
+    return Bun.file(getLogPath())
+        .text()
+        .then(text => text.split('\n').filter(line => line !== ''))
+        .then(lines => lines.map(line => JSON.parse(line)));
+}
+
+export const AppendError = (database: string, error: ErrorType) => {
+    const writer = getWriter();
+
+    const content = {
+        database,
+        error: {
+            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
+        }
+    };
+
+    writer.write(JSON.stringify(content) + '\n');
+}

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),
-        })));
-    })
-})

package/test/container/container.spec.ts

@@ -1,33 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

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

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}