squilo 0.2.3 → 0.3.0

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

@@ -1,48 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { JsonOutputStrategy } from "./index";
-
-describe("JsonOutputStrategy", () => {
-  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" }] });
-        controller.enqueue({ "database2": [{ id: 3, name: "Charlie" }] });
-        controller.close();
-      }
-    });
-
-    const strategy = JsonOutputStrategy();
-    const result = await strategy(mockData);
-    
-    // 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 and create file", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({});
-        controller.close();
-      }
-    });
-
-    const strategy = JsonOutputStrategy();
-    const result = await strategy(mockData);
-    
-    // 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,20 +0,0 @@
-import type { OutputStrategy } from '../types';
-
-export const JsonOutputStrategy = <TData>(): OutputStrategy<TData, string> => async (result) => {
-  const data: Record<string, TData[]> = {};
-  
-  for await (const item of result) {
-    Object.assign(data, item);
-  }
-
-  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.spec.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { MergeOutputStrategy } from "./index";
-
-describe("MergeOutputStrategy", () => {
-  test("should merge array data from multiple sources", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({"database1": [1, 2, 3, 4, 5]});
-        controller.enqueue({"database2": [6, 7, 8, 9, 10]});
-        controller.close();
-      }
-    });
-
-    const strategy = MergeOutputStrategy<number[]>();
-    const result = await strategy(mockData);
-    expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  });
-
-  test("should handle empty arrays", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({"database1": []});
-        controller.enqueue({"database2": []});
-        controller.close();
-      }
-    });
-
-    const strategy = MergeOutputStrategy<number[]>();
-    const result = await strategy(mockData);
-    
-    expect(result).toEqual([]);
-  });
-
-  test("should merge object arrays", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({"database1": [{ id: 1, name: "Alice" }]});
-        controller.enqueue({"database2": [{ id: 2, name: "Bob" }]});
-        controller.close();
-      }
-    });
-
-    const strategy = MergeOutputStrategy<{ id: number; name: string }[]>();
-    const result = await strategy(mockData);
-    
-    expect(result).toEqual([
-      { id: 1, name: "Alice" },
-      { id: 2, name: "Bob" }
-    ]);
-  });
-});

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

@@ -1,11 +0,0 @@
-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[] = [];
-  for await (const item of result) {
-    Object.values(item).forEach((value) => {
-      data.push(...value as TMerged[]);
-    });
-  }
-  return data;
-};

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

@@ -1,93 +0,0 @@
-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 () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({ 
-          "database1": [{ id: 1, name: "Alice", age: 30 }, { id: 2, name: "Bob", age: 25 }],
-          "database2": [{ id: 3, name: "Charlie", age: 35 }]
-        });
-        controller.close();
-      }
-    });
-
-    const strategy = XlsOutputStrategy(false);
-    const filename = await strategy(mockData);
-    
-    expect(await Bun.file(filename).exists()).toBe(true);
-    
-    // Clean up
-    await Bun.file(filename).delete();
-  });
-
-  test("should generate XLS file with combined sheet when unique=true", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({ 
-          "database1": [{ id: 1, name: "Alice", age: 30 }],
-          "database2": [{ id: 2, name: "Bob", age: 25 }]
-        });
-        controller.close();
-      }
-    });
-
-    const strategy = XlsOutputStrategy(true);
-    const filename = await strategy(mockData);
-    
-    expect(await Bun.file(filename).exists()).toBe(true);
-    
-    // Clean up
-    await Bun.file(filename).delete();
-  });
-
-  test("should create empty sheet when no data provided", async () => {
-    const mockData = new ReadableStream({
-      start(controller) {
-        controller.enqueue({});
-        controller.close();
-      }
-    });
-
-    const strategy = XlsOutputStrategy(false);
-    const filename = await strategy(mockData);
-    
-    expect(await Bun.file(filename).exists()).toBe(true);
-    
-    // Clean up
-    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,111 +0,0 @@
-import * as XLSX from 'xlsx';
-import type { OutputStrategy } from '../types';
-
-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: unknown[] = [];
-      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> {
-  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: unknown[] = [];
-      if (Array.isArray(data)) {
-        sheetData = data.map(item => ({ database, ...item }));
-      } else if (data && typeof data === 'object') {
-        sheetData = [{ database, ...data }];
-      } else {
-        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);
-    }
-  }
-  
-  if (allData.length === 0) {
-    return false;
-  }
-  
-  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): OutputStrategy<TData, string> => 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");
-    }
-  }
-
-  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

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

package/src/pipes/retrieve/index.ts

@@ -1,61 +0,0 @@
-import type { Transaction } from "mssql";
-import { Output } from "../output"
-import type { DatabaseConnection } from "../connect/types";
-import type { RetrieveChain } from "./types";
-import { Presets, SingleBar } from "cli-progress";
-import { CleanErrors, type ErrorType } from "../../utils/append-error";
-import { TransactionRunner } from "../shared/transaction-runner";
-
-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 = (dc: DatabaseConnection) => TransactionRunner()({
-            connection: dc,
-            input,
-            fn,
-            onSuccess: async (result) => {
-                await writer.write({ [dc.database]: result });
-            },
-            onError: async (error) => {
-                await writable.abort(error as ErrorType);
-            },
-            singleBar: singlerBar,
-        });
-
-        // Process all connections and close the stream when done
-        (async () => {
-            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 {
-            Output: Output(readable)
-        };
-    }
-}

package/src/pipes/retrieve/types.ts

@@ -1,5 +0,0 @@
-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,6 +0,0 @@
-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,8 +0,0 @@
-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/shared/transaction-runner.ts

@@ -1,58 +0,0 @@
-import type { Transaction } from 'mssql';
-import type { DatabaseConnection } from '../connect/types';
-import { SingleBar } from 'cli-progress';
-import { AppendError, type ErrorType } from '../../utils/append-error';
-import { LoadEnv } from '../../utils/load-env';
-
-export interface TransactionRunnerOptions<TParam, TReturn> {
-    connection: DatabaseConnection;
-    input: TParam;
-    fn: (transaction: Transaction, database: string, params: TParam) => Promise<TReturn>;
-    onSuccess?: (result: TReturn) => Promise<void> | void;
-    onError?: (error: any) => Promise<void> | void;
-    singleBar?: SingleBar;
-}
-
-export const TransactionRunner = () => {
-    const ENV = LoadEnv();
-    const limit = ENV.MAX_ERRORS;
-    let errorsCount = 0;
-
-    return async <TParam, TReturn>({
-        connection: dc,
-        input,
-        fn,
-        onSuccess,
-        onError,
-        singleBar,
-    }: TransactionRunnerOptions<TParam, TReturn>): Promise<void> => {
-        return dc.connection
-            .then(opened => opened.transaction())
-            .then(tran => tran.begin()
-                .then(() => fn(tran, dc.database, input))
-                .then(async (result) => {
-                    if (onSuccess) {
-                        await onSuccess(result);
-                    }
-                    return result;
-                })
-                .then(() => tran.commit())
-                .then(() => {
-                    if (singleBar && Bun.env.NODE_ENV !== 'test') {
-                        singleBar.increment(1, { database: dc.database });
-                    }
-                })
-                .catch(error => tran.rollback().then(() => { throw error }))
-            )
-            .catch(async error => {
-                AppendError(dc.database, error as ErrorType);
-                if (++errorsCount > limit) {
-                    if (onError) {
-                        await onError(error);
-                    }
-                    console.error('Max errors reached, exiting...');
-                    process.exit(1);
-                }
-            });
-    };
-};

package/src/pipes/types.ts

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

package/src/pool/index.ts

@@ -1,49 +0,0 @@
-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 => {
-                    delete POOL[database];
-                    throw err;
-                });
-
-                POOL[database] = pool
-                    .connect()
-                    .catch(err => {
-                        delete POOL[database];
-                        throw err;
-                    });
-            }
-
-            return POOL[database]!;
-        },
-        closeAll: async () => {
-            const closes = Object.values(POOL).map(pool => pool.then(p => p.close()));
-            await Promise.all(closes);
-        }
-
-    }
-}

package/src/utils/append-error.spec.ts

@@ -1,100 +0,0 @@
-import { describe, expect, test, afterEach, beforeAll } from "bun:test";
-import { existsSync } from "fs";
-import { AppendError, CleanErrors, GetErrors, SetLogPath } from "./append-error";
-
-describe("Append Error Utils", () => {
-    let errorLogPath: string;
-
-    beforeAll(() => {
-        // Calculate the error log path based on test file name
-        errorLogPath = `${import.meta.path.replace(/\.(?:js|ts)/, '')}-last-errors.json`;
-        SetLogPath(errorLogPath);
-    });
-
-    afterEach(async () => {
-        await CleanErrors();
-    });
-
-    describe("Error logging functionality", () => {
-        test("Should create error log file when AppendError is called", async () => {
-            const testError = new Error("Test error");
-            AppendError("TestDB1", testError);
-
-            expect(existsSync(errorLogPath)).toBe(true);
-        });
-
-        test("Should store error details correctly in log file", async () => {
-            const testError = new Error("Test error message");
-            testError.stack = "Test stack trace";
-
-            AppendError("TestDB1", testError);
-
-            const logs = await GetErrors();
-
-            expect(logs.length).toBe(1);
-            expect(logs[0].database).toBe("TestDB1");
-            expect(logs[0].error.message).toBe("Test error message");
-            expect(logs[0].error.stack).toBe("Test stack trace");
-        });
-
-        test("Should accumulate errors for multiple databases", async () => {
-            const error1 = new Error("Error in DB1");
-            const error2 = new Error("Error in DB2");
-
-            AppendError("TestDB1", error1);
-            AppendError("TestDB2", error2);
-
-            const logs = await GetErrors();
-            expect(logs.length).toBe(2);
-            expect(logs[0].database).toBe("TestDB1");
-            expect(logs[0].error.message).toBe("Error in DB1");
-            expect(logs[1].database).toBe("TestDB2");
-            expect(logs[1].error.message).toBe("Error in DB2");
-        });
-
-        test("Should overwrite existing error for same database", async () => {
-            const initialError = new Error("Initial error");
-            const updatedError = new Error("Updated error");
-
-            AppendError("TestDB1", initialError);
-            AppendError("TestDB1", updatedError);
-
-            const logContent = await GetErrors();
-            expect(logContent.length).toBe(2);
-            expect(logContent[0].database).toBe("TestDB1");
-            expect(logContent[0].error.message).toBe("Initial error");
-            expect(logContent[1].database).toBe("TestDB1");
-            expect(logContent[1].error.message).toBe("Updated error");
-        });
-    });
-
-    describe("Error log persistence and cleanup", () => {
-        test("Should persist error log across operations", async () => {
-            const testError = new Error("Persistent error");
-            AppendError("TestDB1", testError);
-
-            const logContent = await GetErrors();
-            expect(logContent.length).toBe(1);
-            expect(logContent[0].database).toBe("TestDB1");
-            expect(logContent[0].error.message).toBe("Persistent error");
-        });
-
-        test("Should handle concurrent error logging", async () => {
-            const errors: Error[] = [
-                new Error("Error 1"),
-                new Error("Error 2"),
-                new Error("Error 3")
-            ];
-
-            // Log errors concurrently
-            await Promise.all([
-                AppendError("TestDB1", errors[0]!),
-                AppendError("TestDB2", errors[1]!),
-                AppendError("TestDB3", errors[2]!)
-            ]);
-
-            const logContent = await GetErrors();
-            expect(logContent.length).toBeGreaterThanOrEqual(1);
-        });
-    });
-});