squilo 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squilo",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/douglasdasilvasousa/Squilo.git"
+    "url": "git+https://github.com/dodevs/Squilo.git"
   },
   "author": {
     "name": "Douglas da Silva Sousa",

package/src/pipes/auth/strategies/msal.ts

@@ -18,7 +18,7 @@ import { cwd } from "process";
 const SCOPES = ["https://database.windows.net//.default"];
 
 const cacheAccess = (hash: string) => {
-    const cacheFilePath = path.join(cwd(), `${hash}.json`);
+    const cacheFilePath = path.join(cwd(), `./.active-directory-cache/${hash}.json`);
 
     const before = async (cacheContext: TokenCacheContext) => {
         try {

package/src/pipes/execute/index.ts

@@ -1,12 +1,8 @@
 import type { Transaction } from 'mssql';
 import type { DatabaseConnection } from "../connect/types";
 import { Presets, SingleBar } from 'cli-progress';
-import { AppendError, CleanErrors, type ErrorType } from '../../utils/append-error';
-import { LoadEnv } from '../../utils/load-env';
-
-const ENV = LoadEnv();
-let ERRORS_COUNT = 0;
-
+import { CleanErrors } from '../../utils/append-error';
+import { TransactionRunner } from '../shared/transaction-runner';
 
 export const Execute = <TParam>(
     connections$: (databases: string[]) => Generator<DatabaseConnection[]>,
@@ -20,27 +16,12 @@ export const Execute = <TParam>(
             format: `{bar} {percentage}% | {value}/{total} | {database}`
         }, Presets.shades_classic);
 
-        const executeFn = async (dc: DatabaseConnection): Promise<void> => {
-            const opened = await dc.connection;
-            const transaction = opened.transaction()
-            try {
-                await transaction.begin();
-                await fn(transaction, dc.database, input);
-                await transaction.commit();
-                if (Bun.env.NODE_ENV !== 'test') {
-                    singlerBar.increment(1, { database: dc.database });
-                }
-            }
-            catch (error) {
-                await transaction.rollback();
-                await AppendError(dc.database, error as ErrorType);
-
-                if (++ERRORS_COUNT > ENV.MAX_ERRORS) {
-                    console.error('Max errors reached, exiting...');
-                    process.exit(1);
-                }
-            }
-        };
+        const executeFn = (dc: DatabaseConnection) => TransactionRunner()({
+            connection: dc,
+            input,
+            fn,
+            singleBar: singlerBar,
+        });
 
         await CleanErrors();
         const databases = await databases$;

package/src/pipes/retrieve/index.ts

@@ -3,11 +3,8 @@ 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";
-
-const ENV = LoadEnv();
-let ERRORS_COUNT = 0;
+import { CleanErrors, type ErrorType } from "../../utils/append-error";
+import { TransactionRunner } from "../shared/transaction-runner";
 
 export const Retrieve = <TParam>(
     connections$: (databases: string[]) => Generator<DatabaseConnection[]>,
@@ -22,30 +19,18 @@ export const Retrieve = <TParam>(
             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);
-                transaction.commit();
-
+        const executeFn = (dc: DatabaseConnection) => TransactionRunner()({
+            connection: dc,
+            input,
+            fn,
+            onSuccess: async (result) => {
                 await writer.write({ [dc.database]: result });
-
-                if (Bun.env.NODE_ENV !== 'test') {
-                    singlerBar.increment(1, { database: dc.database });
-                }
-            } catch (error) {
-                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);
-                }
-            }
-        };
+            },
+            onError: async (error) => {
+                await writable.abort(error as ErrorType);
+            },
+            singleBar: singlerBar,
+        });
 
         // Process all connections and close the stream when done
         (async () => {

package/src/pipes/shared/transaction-runner.ts

@@ -0,0 +1,58 @@
+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/pool/index.ts

@@ -11,33 +11,39 @@ export function Pool(poolConfig: config): Pool {
         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)) {
+
+            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);
+                    delete POOL[database];
+                    throw err;
                 });
-    
-                POOL[database] = pool.connect();
+
+                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

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

package/src/utils/append-error.ts

@@ -1,42 +1,74 @@
+import type { FileSink } from "bun";
 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`;
+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 (await Bun.file(ERROR_LOG_PATH).exists()) {
-        await Bun.file(ERROR_LOG_PATH).delete()
-    } 
+    if (logWriter) {
+        logWriter.end();
+        logWriter = null;
+    }
+    const path = getLogPath();
+    if (await Bun.file(path).exists()) {
+        await Bun.file(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
-    };
+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();
 
-    // Update error content with new error for database
-    const updatedContent = {
-        ...errorContent,
-        [database]: serializableError
+    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
+        }
     };
 
-    // Write updated error content to file
-    await Bun.write(errorFile, JSON.stringify(updatedContent, null, 2));
+    writer.write(JSON.stringify(content) + '\n');
+    writer.flush();
 }