squilo 0.1.2 → 0.2.0

package/README.md

@@ -20,64 +20,293 @@ bun init
 bun add squilo
 ```
 
-## Usage Example
+## Usage Examples
 
-### Exportable Servers (Production, Dev, ...)
+### Server Configuration with Azure AD Authentication
 
 ```ts
-// src/server.ts
+// servers/production.ts
 import { Server } from "squilo";
+import { ActiveDirectoryAccessToken } from "squilo/auth/strategies";
 
-export const ProdServer = Server({
-  server: "prod-host",
-  port: 1433,
-  options: { encrypt: true }
-});
+export const Production = Server({
+    server: "your-server.database.windows.net",
+    options: {
+        encrypt: true,
+        trustedConnection: true,
+        trustServerCertificate: false
+    },
+    requestTimeout: 300000
+}).Auth(await ActiveDirectoryAccessToken({
+    clientId: "your-client-id",
+    clientSecret: "your-client-secret",
+    authority: "https://login.microsoftonline.com/your-tenant-id"
+}));
+```
 
-export const DevServer = Server({
-  server: "localhost",
-  port: 1433,
-  options: { encrypt: false }
-});
+### Dynamic Database Connections
+
+```ts
+// databases/all-active.ts
+import { Production } from "../servers/production";
+import { Qas } from "../servers/qas";
+
+// Connect to multiple databases dynamically from Production
+export const AllActiveDatabases = Production
+    .Connect({
+        database: "ManagerDatabase",
+        query: "SELECT [Database] FROM Client WHERE Active = 1"
+    });
+
+// Same pattern for QAS environment
+export const AllActiveQasDatabases = Qas
+    .Connect({
+        database: "ManagerDatabase", 
+        query: "SELECT [Database] FROM Client WHERE Active = 1"
+    });
+
+// Simple database connection
+export const TestDatabase = Production.Connect("TestDatabase");
 ```
 
-### Exportable Authentications
+### Data Retrieval with Output Strategies
 
 ```ts
-// src/auth.ts
-import { UserAndPassword } from "squilo/pipes/auth/strategies";
+// scripts/user-report.ts
+import { JsonOutputStrategy, XlsOutputStrategy } from "squilo/output/strategies";
+import { Production } from "../servers/production";
+import { AllActiveDatabases } from "../databases/all-active";
+
+type UserData = {
+    Id: number;
+    Email: string;
+    CreatedAt: Date;
+}
 
-export const ProdAuth = UserAndPassword("prod_user", "prod_pass");
-export const DevAuth = UserAndPassword("sa", "your_dev_password");
+// Retrieve data from multiple databases (uses Production by default)
+await AllActiveDatabases
+    .Retrieve(async (transaction, database) => {
+        const result = await transaction
+            .request()
+            .query<UserData>`
+                SELECT Id, Email, CreatedAt
+                FROM Users
+                WHERE Active = 1
+                ORDER BY CreatedDate DESC
+            `;
+        return result.recordset;
+    })
+    .Output(JsonOutputStrategy());
 ```
 
-### Create Scripts
+### Execute Operations Across Multiple Databases
 
 ```ts
-// scripts/fixEmails.ts
-import { ProdServer } from "../src/server";
-import { ProdAuth } from "../src/auth";
-
-await ProdServer.Auth(ProdAuth)
-  .Connect(["db1", "db2"])
-  .Execute(async (transaction) => {
-    await transaction.request().query`
-      UPDATE Users SET Email = RTRIM(Email)
-    `;
-  });
+// scripts/update-campaign-status.ts
+import { AllActiveDatabases } from "../databases/all-active";
+import { Production } from "../servers/production";
+
+await AllActiveDatabases
+    .Execute(async (transaction, database) => {
+        await transaction.request().query`
+            UPDATE Campaigns 
+            SET Status = 'Active'
+            WHERE EndDate IS NULL AND StartDate <= GETDATE()
+        `;
+    })
+    .then(() => process.exit(0));
 ```
 
-### Run Scripts Using Bun
+### Complex Queries with TypeScript Types
 
-```bash
-bun run scripts/fixEmails.ts
+```ts
+// scripts/analytics-report.ts
+import { JsonOutputStrategy } from "squilo/output/strategies";
+import { Production } from "../servers/production";
+
+type AnalyticsResult = {
+    MaxConnectedStates: number;
+}
+
+await Production
+    .Connect("AnalyticsDatabase")
+    .Retrieve(async (transaction) => {
+        const result = await transaction.request().query<AnalyticsResult>`
+            -- Complex analytical query with CTEs and cursors
+            WITH ActiveStates AS (
+                SELECT DISTINCT State.Id
+                FROM State
+                INNER JOIN FlowState ON FlowState.StateId = State.Id
+                WHERE Flow.EndDate IS NULL
+            )
+            SELECT MAX(ConnectedCount) As MaxConnectedStates
+            FROM (
+                SELECT COUNT(*) as ConnectedCount
+                FROM ActiveStates
+                GROUP BY StateGroup
+            ) AS StateCounts;
+        `;
+        return result.recordset;
+    })
+    .Output(JsonOutputStrategy());
 ```
 
 ## Advanced Usage
 
-- Use `.Input()` to provide dynamic input for scripts
-- Use `.Retrieve()` to fetch results from databases
-- Use `.Output()` strategies to merge or format results
+### Authentication Strategies
+
+Squilo supports multiple authentication methods:
+
+```ts
+// User and Password authentication
+import { UserAndPassword } from "squilo/auth/strategies";
+const auth = UserAndPassword("username", "password");
+
+// Active Directory Access Token for Azure SQL
+import { ActiveDirectoryAccessToken } from "squilo/auth/strategies";
+const azureAuth = await ActiveDirectoryAccessToken({
+  clientId: "your-client-id",
+  clientSecret: "your-client-secret",
+  authority: "https://login.microsoftonline.com/your-tenant-id"
+});
+```
+
+### Input and Retrieval
+
+```ts
+// Retrieve data with typed results
+type ConfigData = {
+    Id: number;
+    Setting: string;
+    Value: string;
+}
+
+const results = await Production
+    .Connect("ConfigDatabase")
+    .Retrieve(async (transaction) => {
+        const result = await transaction
+            .request()
+            .query<ConfigData>`
+                SELECT Id, Setting, Value
+                FROM Configuration
+                ORDER BY CreatedDate
+            `;
+        return result.recordset;
+    });
+
+// Execute with database context
+await AllActiveDatabases
+    .Execute(async (transaction, database) => {
+        console.log(`Processing database: ${database}`);
+        await transaction.request().query`
+            UPDATE Settings SET LastProcessed = GETDATE()
+        `;
+    });
+```
+
+### Output Strategies
+
+Squilo provides multiple output formats:
+
+```ts
+// JSON output for data export
+import { JsonOutputStrategy } from "squilo/output/strategies";
+await AllActiveDatabases
+    .Retrieve(async (transaction) => {
+        const result = await transaction.request().query`
+            SELECT Id, Name, Status FROM Reports
+        `;
+        return result.recordset;
+    })
+    .Output(JsonOutputStrategy());
+
+// Excel output for reports
+import { XlsOutputStrategy } from "squilo/output/strategies";
+await Production
+    .Connect("ReportsDatabase")
+    .Retrieve(async (transaction) => {
+        const result = await transaction.request().query`
+            SELECT * FROM MonthlyStats WHERE Year = 2024
+        `;
+        return result.recordset;
+    })
+    .Output(XlsOutputStrategy());
+
+// Console output for debugging
+import { ConsoleOutputStrategy } from "squilo/output/strategies";
+await Production
+    .Connect("LogsDatabase")
+    .Retrieve(async (transaction) => {
+        const result = await transaction.request().query`
+            SELECT TOP 10 * FROM ErrorLogs ORDER BY Timestamp DESC
+        `;
+        return result.recordset;
+    })
+    .Output(ConsoleOutputStrategy());
+
+// Merge results from multiple databases
+import { MergeOutputStrategy } from "squilo/output/strategies";
+await AllActiveDatabases
+    .Retrieve(async (transaction, database) => {
+        const result = await transaction.request().query`
+            SELECT '${database}' as DatabaseName, COUNT(*) as UserCount
+            FROM Users WHERE Active = 1
+        `;
+        return result.recordset;
+    })
+    .Output(MergeOutputStrategy());
+```
+
+### Connection Management
+
+Properly manage connections in production scripts:
+
+```ts
+// Always close connections in production scripts
+import { Production } from "../servers/production";
+
+await Production
+    .Connect("ProductionDatabase")
+    .Retrieve(async (transaction) => {
+        const result = await transaction.request().query`
+            SELECT * FROM ImportantData
+        `;
+        return result.recordset;
+    })
+    .Output(JsonOutputStrategy());
+
+// Close the connection and exit
+await Production.Close();
+process.exit(0);
+```
+
+### Script Organization
+
+Organize your scripts in a clear structure:
+
+```
+project/
+├── servers/
+│   ├── production.ts    # Production server config
+│   └── qas.ts          # QAS/staging server config
+├── databases/
+│   ├── all-active.ts   # Dynamic database connections
+│   └── test.ts         # Test database connections
+└── scripts/
+    ├── reports/        # Report generation scripts
+    ├── maintenance/    # Database maintenance scripts
+    └── analytics/      # Analytics and data processing
+```
+
+### Running Scripts
+
+```bash
+# Run individual scripts
+bun run scripts/reports/user-activity.ts
+
+# Run with specific environment
+NODE_ENV=production bun run scripts/maintenance/cleanup.ts
+```
 
 ## Reference
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squilo",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {
@@ -14,9 +14,13 @@
     "name": "Douglas da Silva Sousa",
     "email": "douglass.sousa@outlook.com.br"
   },
+  "files": [
+    "src/**/*"
+  ],
   "exports": {
     ".": "./src/index.ts",
-    "./auth": "./src/pipes/auth/strategies/index.ts"
+    "./auth/strategies": "./src/pipes/auth/strategies/index.ts",
+    "./output/strategies": "./src/pipes/output/strategies/index.ts"
   },
   "scripts": {
     "test": "bun test",
@@ -24,21 +28,22 @@
     "test:debug": "bun test --inspect"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.2.0",
-    "@faker-js/faker": "^9.9.0",
+    "@biomejs/biome": "2.2.6",
+    "@faker-js/faker": "^10.1.0",
     "@types/bun": "latest",
-    "@types/xlsx": "^0.0.36",
-    "testcontainers": "^11.5.1"
+    "@types/cli-progress": "^3.11.6",
+    "testcontainers": "^11.7.1"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@azure/msal-node": "^3.7.1",
-    "@types/mssql": "^9.1.7",
-    "mssql": "^11.0.1",
+    "@azure/msal-node": "^3.8.0",
+    "@types/mssql": "^9.1.8",
+    "cli-progress": "^3.12.0",
+    "mssql": "^12.0.0",
     "open": "^10.2.0",
-    "xlsx": "^0.18.5"
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "license": "MIT"
-}
+}

package/src/index.ts

@@ -1 +1,3 @@
-export * from  "./pipes/server"
+export * from  "./pipes"
+export * from "./pipes/types"
+export * as SQL from "mssql";

package/src/pipes/auth/index.ts

@@ -1,17 +1,7 @@
-import type { config } from 'mssql';
 import type { ServerConfig } from "../server/types";
-import type { ConnectionOptions } from "../connect";
 import { Pool } from "../../pool";
-import { type ConnectionChain, Connect } from "../connect";
-
-export type AuthStrategy = (config: ServerConfig) => config;
-
-export type AuthenticationChain = {
-    Connect(database: string): ConnectionChain;
-    Connect(databases: string[], concurrent?: number): ConnectionChain;
-    Connect(options: ConnectionOptions, concurrent?: number): ConnectionChain;
-    Close(): Promise<void>;
-}
+import { Connect } from "../connect";
+import type { AuthStrategy, AuthenticationChain } from "./types";
 
 export const Auth = (config: ServerConfig) => (strategy: AuthStrategy): AuthenticationChain => {
     const configWithAuth = strategy(config);

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

@@ -12,7 +12,7 @@ import {
 
 import * as path from "path";
 import type { ServerConfig } from "../../server/types";
-import type { AuthStrategy } from "..";
+import type { AuthStrategy } from "../types";
 import { cwd } from "process";
 
 const SCOPES = ["https://database.windows.net//.default"];
@@ -80,12 +80,19 @@ export const GetToken = async (config: NodeAuthOptions) => {
     let result: AuthenticationResult | null;
 
     if (accounts.length > 0 && accounts[0]) {
-        result = await pca.acquireTokenSilent({
-            scopes: SCOPES,
-            account: accounts[0],
-        });
-
-        return result?.accessToken;
+        try {
+            result = await pca.acquireTokenSilent({
+                scopes: SCOPES,
+                account: accounts[0],
+            });
+
+            return result?.accessToken;
+        } catch (error) {
+            if (error instanceof Error) {
+                console.error('Silent token acquisition failed:', error.message);
+            }
+            console.log("Proceeding to interactive authentication");
+        }
     }
 
     const interactiveRequest: InteractiveRequest = {

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

@@ -1,4 +1,4 @@
-import type { AuthStrategy } from ".."
+import type { AuthStrategy } from "../types"
 import type { ServerConfig } from "../../server/types"
 
 export const UserAndPassword = (username: string, password: string): AuthStrategy => (config: ServerConfig) => {

package/src/pipes/auth/types.ts

@@ -0,0 +1,12 @@
+import type { config } from "mssql";
+import type { ConnectionChain, ConnectionOptions } from "../connect/types";
+import type { ServerConfig } from "../server/types";
+
+export type AuthStrategy = (config: ServerConfig) => config;
+
+export type AuthenticationChain = {
+    Connect(database: string): ConnectionChain;
+    Connect(databases: string[], concurrent?: number): ConnectionChain;
+    Connect(options: ConnectionOptions, concurrent?: number): ConnectionChain;
+    Close(): Promise<void>;
+}

package/src/pipes/connect/index.ts

@@ -1,48 +1,31 @@
-import type { ConnectionPool, Transaction } from "mssql";
 import type { Pool } from "../../pool";
-import { type InputChain, Input } from "../input";
+import { Input } from "../input";
 import { Execute } from "../execute";
-import { type RetrieveChain, Retrieve } from "../retrieve";
+import { Retrieve } from "../retrieve";
 
-export type ConnectOverloads = {
-    (database: string): ConnectionChain;
-    (databases: string[], concurrent?: number): ConnectionChain;
-    (options: ConnectionOptions, concurrent?: number): ConnectionChain;
-}
+import type { ConnectOverloads, ConnectionOptions, ConnectionChain, DatabaseConnection } from "./types";
 
-export type ConnectionOptions = {
-    database: string;
-    query: `SELECT${string}FROM${string}`;
-}
+export const Connect = (pool: Pool): ConnectOverloads => (param: string | string[] | ConnectionOptions, concurrent?: number): ConnectionChain => {
+    process.on("exit", async () => {
+        await pool.closeAll();
+    });
 
-export type DatabaseConnection = {
-    database: string;
-    connection: Promise<ConnectionPool>;
-}
-
-export type ConnectionChain = {
-    Execute(fn: (transaction: Transaction, database: string) => Promise<void>): Promise<void>;
-    Retrieve<TResult>(fn: (transaction: Transaction, database: string) => Promise<TResult>): RetrieveChain<TResult>;
-    Input<TParam>(fn: () => TParam): InputChain<TParam>;
-}
-
-export const Connect = (pool: Pool): ConnectOverloads => (param: string | string[] | ConnectionOptions, concurrent?: number): ConnectionChain => {    
-    let connections$: AsyncGenerator<DatabaseConnection[]>;
+    let connections$: (databases: string[]) => Generator<DatabaseConnection[]>;
     let databases$: Promise<string[]>;
 
-    async function *connections(databases$: Promise<string[]>, concurrent: number = Number.MAX_VALUE) {
-        const databases = await databases$;
-        
-        const databases_result_chunks = Array.from(
-            {length: Math.ceil(databases.length / concurrent)},
-            (_, i) => databases.slice(i * concurrent, (i + 1) * concurrent)
-        );
-
-        for (const databases_result_chunk of databases_result_chunks) {
-            yield databases_result_chunk.map(database => ({
-                database,
-                connection: pool.connect({ database })
-            }));
+    function connections(concurrent: number = Number.MAX_VALUE): (databases: string[]) => Generator<DatabaseConnection[]> {
+        return function *(databases: string[]) {
+            const databases_result_chunks = Array.from(
+                {length: Math.ceil(databases.length / concurrent)},
+                (_, i) => databases.slice(i * concurrent, (i + 1) * concurrent)
+            );
+
+            for (const databases_result_chunk of databases_result_chunks) {
+                yield databases_result_chunk.map(database => ({
+                    database,
+                    connection: pool.connect({ database })
+                }));
+            }
         }
     }
 
@@ -68,11 +51,11 @@ export const Connect = (pool: Pool): ConnectOverloads => (param: string | string
         throw new Error("Invalid parameter");
     }
 
-    connections$ = connections(databases$, concurrent);
+    connections$ = connections(concurrent);
 
     return {
-        Input: Input(connections$),
-        Execute: Execute(connections$, null),
-        Retrieve: Retrieve(connections$, null)
+        Input: Input(connections$, databases$),
+        Execute: Execute(connections$, databases$, null),
+        Retrieve: Retrieve(connections$, databases$, null)
     }
   }

package/src/pipes/connect/types.ts

@@ -0,0 +1,25 @@
+import type { ConnectionPool, Transaction } from "mssql";
+import type { InputChain } from "../input/types";
+import type { RetrieveChain } from "../retrieve/types";
+
+export type ConnectOverloads = {
+    (database: string): ConnectionChain;
+    (databases: string[], concurrent?: number): ConnectionChain;
+    (options: ConnectionOptions, concurrent?: number): ConnectionChain;
+}
+
+export type ConnectionOptions = {
+    database: string;
+    query: `SELECT${string}FROM${string}`;
+}
+
+export type DatabaseConnection = {
+    database: string;
+    connection: Promise<ConnectionPool>;
+}
+
+export type ConnectionChain = {
+    Execute(fn: (transaction: Transaction, database: string) => Promise<void>): Promise<void>;
+    Retrieve<TResult>(fn: (transaction: Transaction, database: string) => Promise<TResult>): RetrieveChain<TResult>;
+    Input<TParam>(fn: () => TParam): InputChain<TParam>;
+}

package/src/pipes/execute/index.ts

@@ -1,13 +1,25 @@
 import type { Transaction } from 'mssql';
-import type { DatabaseConnection } from "../connect";
+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;
+
 
 export const Execute = <TParam>(
-    connections$: AsyncGenerator<DatabaseConnection[]>, 
+    connections$: (databases: string[]) => Generator<DatabaseConnection[]>,
+    databases$: Promise<string[]>,
     input: TParam
 ) => {
     return async (
         fn: (transaction: Transaction, database: string, params: TParam) => Promise<void>
     ): Promise<void> => {
+        const singlerBar = new SingleBar({
+            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()
@@ -15,15 +27,35 @@ export const Execute = <TParam>(
                 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);
+                }
             }
         };
 
-        for await (const connectionBatch of connections$) {
+        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();
+        }
     };
 };

package/src/pipes/index.ts

@@ -1 +1 @@
-export { Server } from './server/index'
+export { Server } from './server/index'