squilo 0.2.4 → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { config as config2 } from "mssql";
+import { Transaction as Transaction3 } from "mssql";
+import { Transaction as Transaction2 } from "mssql";
+type OutputStrategy<
+	TReturn,
+	TOutput = void
+> = (data: ReadableStream<Record<string, TReturn>>) => Promise<TOutput>;
+import { ConnectionError, PreparedStatementError, RequestError, TransactionError } from "mssql";
+type ErrorType = Error | ConnectionError | TransactionError | RequestError | PreparedStatementError;
+type ExecutionError = {
+	database: string;
+	error: ErrorType;
+};
+type RetrieveChain<TReturn> = {
+	Output<TOutput>(strategy: OutputStrategy<TReturn, TOutput>): Promise<[ExecutionError[], TOutput]>;
+};
+type InputChain<TParam> = {
+	Execute(fn: (transaction: Transaction2, database: string, params: TParam) => Promise<void>): Promise<ExecutionError[]>;
+	Retrieve<TResult>(fn: (transaction: Transaction2, database: string, params: TParam) => Promise<TResult>): RetrieveChain<TResult>;
+};
+type ConnectionOptions = {
+	database: string;
+	query: `SELECT${string}FROM${string}`;
+};
+type ConnectionChain = {
+	Execute(fn: (transaction: Transaction3, database: string) => Promise<void>): Promise<ExecutionError[]>;
+	Retrieve<TResult>(fn: (transaction: Transaction3, database: string) => Promise<TResult>): RetrieveChain<TResult>;
+	Input<TParam>(fn: () => TParam): InputChain<TParam>;
+};
+type AuthenticationChain = {
+	Connect(database: string): ConnectionChain;
+	Connect(databases: string[], concurrent?: number): ConnectionChain;
+	Connect(options: ConnectionOptions, concurrent?: number): ConnectionChain;
+	Close(): Promise<void>;
+};
+import { config } from "mssql";
+type AuthStrategy = (config: ServerConfig) => config;
+type ServerConfig = Omit<config2, "authentication" | "user" | "password">;
+type ServerChain = {
+	Auth(strategy: AuthStrategy): AuthenticationChain;
+};
+declare const Server: (config: ServerConfig) => ServerChain;
+export { Server };

package/dist/index.js

@@ -0,0 +1,270 @@
+// @bun
+import"./shared/chunk-s3vw82k6.js";
+
+// src/pool/index.ts
+import { ConnectionPool } from "mssql";
+function Pool(poolConfig) {
+  const POOL = {};
+  return {
+    connect: (partialConfig) => {
+      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);
+    }
+  };
+}
+
+// src/pipes/shared/transaction-runner.ts
+import { Presets, SingleBar } from "cli-progress";
+
+// src/utils/load-env.ts
+var LoadEnv = () => {
+  const SAFE_GUARD = Number.parseInt(Bun.env.SAFE_GUARD || "1", 10);
+  return {
+    SAFE_GUARD
+  };
+};
+
+// src/pipes/shared/transaction-runner.ts
+class SafeGuardError extends Error {
+  constructor() {
+    super(`Safe guard reached`);
+  }
+}
+var TransactionRunner = () => {
+  const singleBar = new SingleBar({
+    format: `{bar} {percentage}% | {value}/{total} | {database}`
+  }, Presets.shades_classic);
+  const [guard, trackError] = (() => {
+    const limit = LoadEnv().SAFE_GUARD;
+    let errorsCount = 0, open = false;
+    const guard2 = async () => {
+      if (open) {
+        throw new SafeGuardError;
+      }
+    };
+    const trackError2 = () => {
+      errorsCount++;
+      if (errorsCount >= limit) {
+        open = true;
+      }
+    };
+    return [guard2, trackError2];
+  })();
+  const runner = async ({
+    connection: dc,
+    input,
+    fn,
+    onSuccess = () => {},
+    onError = () => {}
+  }) => {
+    return guard().then(() => {
+      if (singleBar && Bun.env.NODE_ENV !== "test") {
+        singleBar.update({ database: dc.database });
+      }
+    }).then(() => dc.connection).then((opened) => opened.transaction()).then((tran) => tran.begin().then(() => fn(tran, dc.database, input)).then((result) => onSuccess(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) => {
+      if (error instanceof SafeGuardError) {
+        return;
+      }
+      trackError();
+      onError(error);
+    });
+  };
+  return [runner, singleBar];
+};
+
+// src/pipes/execute/index.ts
+var Execute = (connections$, databases$, input) => {
+  return async (fn) => {
+    const errors = [];
+    const [runner, singleBar] = TransactionRunner();
+    const executeFn = (dc) => runner({
+      connection: dc,
+      input,
+      fn,
+      onError: async (error) => {
+        errors.push({
+          database: dc.database,
+          error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            code: error.code || undefined,
+            number: error.number || undefined,
+            state: error.state || undefined,
+            class: error.class || undefined,
+            serverName: error.serverName || undefined,
+            procName: error.procName || undefined,
+            lineNumber: error.lineNumber || undefined
+          }
+        });
+      }
+    });
+    const databases = await databases$;
+    if (Bun.env.NODE_ENV !== "test") {
+      singleBar.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") {
+      singleBar.stop();
+    }
+    return errors;
+  };
+};
+
+// src/pipes/output/index.ts
+var Output = (data, error) => async (strategy) => {
+  const errors = [];
+  const output = await strategy(data);
+  for await (const item of error) {
+    errors.push(item);
+  }
+  return [errors, output];
+};
+
+// src/pipes/retrieve/index.ts
+var Retrieve = (connections$, databases$, input) => {
+  return (fn) => {
+    const { readable: readableData, writable: writableData } = new TransformStream;
+    const { readable: readableError, writable: writableError } = new TransformStream;
+    const dataWriter = writableData.getWriter();
+    const errorWriter = writableError.getWriter();
+    const [runner, singleBar] = TransactionRunner();
+    const executeFn = (dc) => runner({
+      connection: dc,
+      input,
+      fn,
+      onSuccess: async (result) => {
+        await dataWriter.write({ [dc.database]: result });
+      },
+      onError: async (error) => {
+        await errorWriter.write({ database: dc.database, error });
+      }
+    });
+    (async () => {
+      const databases = await databases$;
+      if (Bun.env.NODE_ENV !== "test") {
+        singleBar.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") {
+        singleBar.stop();
+      }
+      await dataWriter.close();
+      await errorWriter.close();
+    })();
+    return {
+      Output: Output(readableData, readableError)
+    };
+  };
+};
+
+// src/pipes/input/index.ts
+var Input = (connections$, databases$) => {
+  return (fn) => {
+    const params = fn();
+    return {
+      Execute: Execute(connections$, databases$, params),
+      Retrieve: Retrieve(connections$, databases$, params)
+    };
+  };
+};
+
+// src/pipes/connect/index.ts
+var Connect = (pool) => (param, concurrent) => {
+  let connections$;
+  let databases$;
+  function connections(concurrent2 = Number.MAX_VALUE) {
+    return function* (databases) {
+      const _databases = [...databases];
+      const safe_guard = LoadEnv().SAFE_GUARD;
+      if (safe_guard > 0) {
+        const guard_test = _databases.splice(0, safe_guard);
+        for (const database of guard_test) {
+          yield [{
+            database,
+            connection: pool.connect({ database })
+          }];
+        }
+      }
+      const databases_result_chunks = Array.from({ length: Math.ceil(_databases.length / concurrent2) }, (_, i) => _databases.slice(i * concurrent2, (i + 1) * concurrent2));
+      for (const databases_result_chunk of databases_result_chunks) {
+        yield databases_result_chunk.map((database) => ({
+          database,
+          connection: pool.connect({ database })
+        }));
+      }
+    };
+  }
+  if (typeof param === "string") {
+    databases$ = Promise.resolve([param]);
+  } else if (Array.isArray(param)) {
+    databases$ = Promise.resolve(param);
+  } else if (typeof param === "object" && "query" in param) {
+    databases$ = pool.connect({ database: param.database, arrayRowMode: true }).then((conn) => conn.request().query(param.query)).then((result) => result.recordset.flat());
+  } else {
+    throw new Error("Invalid parameter");
+  }
+  connections$ = connections(concurrent);
+  return {
+    Input: Input(connections$, databases$),
+    Execute: Execute(connections$, databases$, null),
+    Retrieve: Retrieve(connections$, databases$, null)
+  };
+};
+
+// src/pipes/auth/index.ts
+var Auth = (config) => (strategy) => {
+  const configWithAuth = strategy(config);
+  const pool = Pool(configWithAuth);
+  return {
+    Connect: Connect(pool),
+    Close: () => pool.closeAll()
+  };
+};
+
+// src/pipes/server/index.ts
+var Server = (config) => ({
+  Auth: Auth(config)
+});
+export {
+  Server
+};
+
+//# debugId=7B64C9FB2CADE14664756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,19 @@
+{
+  "version": 3,
+  "sources": ["src/pool/index.ts", "src/pipes/shared/transaction-runner.ts", "src/utils/load-env.ts", "src/pipes/execute/index.ts", "src/pipes/output/index.ts", "src/pipes/retrieve/index.ts", "src/pipes/input/index.ts", "src/pipes/connect/index.ts", "src/pipes/auth/index.ts", "src/pipes/server/index.ts"],
+  "sourcesContent": [
+    "import { type config, ConnectionPool } from 'mssql';\nexport type Pool = {\n    connect: (partialConfig: Partial<config>) => Promise<ConnectionPool>;\n    closeAll: () => Promise<void>;\n}\n\nexport function Pool(poolConfig: config): Pool {\n    const POOL: Record<string, Promise<ConnectionPool>> = {};\n\n    return {\n        connect: (partialConfig: Partial<config>) => {\n            const config = { ...poolConfig, ...partialConfig };\n            const database = config.database;\n\n            if (!database) {\n                throw new Error('Database name is required');\n            }\n\n            if (!(database in POOL)) {\n                const pool = new ConnectionPool(config);\n                const close = pool.close.bind(pool);\n\n                pool.close = async () => {\n                    delete POOL[database];\n                    return await close();\n                }\n\n                pool.on('error', err => {\n                    delete POOL[database];\n                    throw err;\n                });\n\n                POOL[database] = pool\n                    .connect()\n                    .catch(err => {\n                        delete POOL[database];\n                        throw err;\n                    });\n            }\n\n            return POOL[database]!;\n        },\n        closeAll: async () => {\n            const closes = Object.values(POOL).map(pool => pool.then(p => p.close()));\n            await Promise.all(closes);\n        }\n\n    }\n}",
+    "import type { ConnectionError, PreparedStatementError, RequestError, Transaction, TransactionError } from 'mssql';\nimport type { DatabaseConnection } from '../connect/types';\nimport { Presets, SingleBar } from 'cli-progress';\nimport { LoadEnv } from '../../utils/load-env';\n\nexport type ErrorType = Error | ConnectionError | TransactionError | RequestError | PreparedStatementError;\n\nexport interface TransactionRunnerOptions<TParam, TReturn> {\n    connection: DatabaseConnection;\n    input: TParam;\n    fn: (transaction: Transaction, database: string, params: TParam) => Promise<TReturn>;\n    onSuccess?: (result: TReturn) => Promise<void> | void;\n    onError?: (error: ErrorType) => Promise<void> | void;\n}\n\nexport type TransactionRunner = <TParam, TReturn>(options: TransactionRunnerOptions<TParam, TReturn>) => Promise<void>;\n\nclass SafeGuardError extends Error {\n    constructor() {\n        super(`Safe guard reached`);\n    }\n}\n\nexport const TransactionRunner = (): [TransactionRunner, SingleBar] => {\n    const singleBar = new SingleBar({\n        format: `{bar} {percentage}% | {value}/{total} | {database}`\n    }, Presets.shades_classic);\n\n    const [guard, trackError] = (() => {\n        const limit = LoadEnv().SAFE_GUARD;\n        let errorsCount = 0, open = false;\n\n        const guard = async () => {\n            if (open) {\n                throw new SafeGuardError();\n            }\n        }\n\n        const trackError = () => {\n            errorsCount++;\n            if (errorsCount >= limit) {\n                open = true;\n            }\n        }\n\n        return [guard, trackError];\n    })()\n\n    const runner = async <TParam, TReturn>({\n        connection: dc,\n        input,\n        fn,\n        onSuccess = () => { },\n        onError = () => { }\n    }: TransactionRunnerOptions<TParam, TReturn>): Promise<void> => {\n        return guard()\n            .then(() => {\n                if (singleBar && Bun.env.NODE_ENV !== 'test') {\n                    singleBar.update({ database: dc.database });\n                }\n            })\n            .then(() => dc.connection)\n            .then(opened => opened.transaction())\n            .then(tran => tran.begin()\n                .then(() => fn(tran, dc.database, input))\n                .then(result => onSuccess(result))\n                .then(() => tran.commit())\n                .then(() => {\n                    if (singleBar && Bun.env.NODE_ENV !== 'test') {\n                        singleBar.increment(1, { database: dc.database });\n                    }\n                })\n                .catch(error => tran.rollback().then(() => { throw error }))\n            )\n            .catch(async error => {\n                if (error instanceof SafeGuardError) {\n                    return;\n                }\n\n                trackError();\n                onError(error as ErrorType);\n            });\n    };\n\n    return [runner, singleBar];\n};\n",
+    "type Env = {\n    SAFE_GUARD: number;\n}\n\ntype StringEnv = {\n    [P in keyof Env]?: string\n}\n\ndeclare module \"bun\" {\n    interface Env extends StringEnv { }\n}\n\nexport const LoadEnv = (): Env => {\n    const SAFE_GUARD = Number.parseInt(Bun.env.SAFE_GUARD || '1', 10);\n    return {\n        SAFE_GUARD: SAFE_GUARD\n    }\n}",
+    "import type { Transaction } from 'mssql';\nimport type { DatabaseConnection } from \"../connect/types\";\nimport { TransactionRunner } from '../shared/transaction-runner';\nimport type { ExecutionError } from './types';\n\nexport const Execute = <TParam>(\n    connections$: (databases: string[]) => Generator<DatabaseConnection[]>,\n    databases$: Promise<string[]>,\n    input: TParam\n) => {\n    return async (\n        fn: (transaction: Transaction, database: string, params: TParam) => Promise<void>\n    ): Promise<ExecutionError[]> => {\n        const errors: ExecutionError[] = [];\n\n        const [runner, singleBar] = TransactionRunner();\n\n        const executeFn = (dc: DatabaseConnection) => runner({\n            connection: dc,\n            input,\n            fn,\n            onError: async (error) => {\n                errors.push({\n                    database: dc.database,\n                    error: {\n                        name: error.name,\n                        message: error.message,\n                        stack: error.stack,\n                        code: (error as any).code || undefined,\n                        number: (error as any).number || undefined,\n                        state: (error as any).state || undefined,\n                        class: (error as any).class || undefined,\n                        serverName: (error as any).serverName || undefined,\n                        procName: (error as any).procName || undefined,\n                        lineNumber: (error as any).lineNumber || undefined\n                    }\n                });\n            }\n        });\n\n        const databases = await databases$;\n\n        if (Bun.env.NODE_ENV !== 'test') {\n            singleBar.start(databases.length, 0);\n        }\n\n        for await (const connectionBatch of connections$(databases)) {\n            const executions = connectionBatch.map(executeFn);\n            await Promise.allSettled(executions);\n        }\n\n        if (Bun.env.NODE_ENV !== 'test') {\n            singleBar.stop();\n        }\n\n        return errors;\n    };\n};",
+    "import type { ExecutionError } from \"../execute/types\";\nimport type { OutputStrategy } from \"./strategies/types\";\n\nexport const Output =\n    <TReturn, TOutput = void>(\n        data: ReadableStream<Record<string, TReturn>>,\n        error: ReadableStream<ExecutionError>\n    ) =>\n        async (strategy: OutputStrategy<TReturn, TOutput>): Promise<[ExecutionError[], TOutput]> => {\n            const errors: ExecutionError[] = [];\n            const output = await strategy(data);\n            for await (const item of error) {\n                errors.push(item);\n            }\n            return [errors, output];\n        };\n",
+    "import type { Transaction } from \"mssql\";\nimport { Output } from \"../output\"\nimport type { DatabaseConnection } from \"../connect/types\";\nimport type { RetrieveChain } from \"./types\";\nimport { TransactionRunner } from \"../shared/transaction-runner\";\nimport type { ExecutionError } from \"../execute/types\";\n\nexport const Retrieve = <TParam>(\n    connections$: (databases: string[]) => Generator<DatabaseConnection[]>,\n    databases$: Promise<string[]>,\n    input: TParam\n) => {\n    return <TReturn>(fn: (transaction: Transaction, database: string, params: TParam) => Promise<TReturn>): RetrieveChain<TReturn> => {\n        const { readable: readableData, writable: writableData } = new TransformStream<Record<string, TReturn>, Record<string, TReturn>>();\n        const { readable: readableError, writable: writableError } = new TransformStream<ExecutionError, ExecutionError>();\n        const dataWriter = writableData.getWriter();\n        const errorWriter = writableError.getWriter();\n\n        const [runner, singleBar] = TransactionRunner();\n\n        const executeFn = (dc: DatabaseConnection) => runner({\n            connection: dc,\n            input,\n            fn,\n            onSuccess: async (result) => {\n                await dataWriter.write({ [dc.database]: result });\n            },\n            onError: async (error) => {\n                await errorWriter.write({ database: dc.database, error });\n            }\n        });\n\n        // Process all connections and close the stream when done\n        (async () => {\n            const databases = await databases$;\n\n            if (Bun.env.NODE_ENV !== 'test') {\n                singleBar.start(databases.length, 0);\n            }\n\n            for await (const connectionBatch of connections$(databases)) {\n                const executions = connectionBatch.map(executeFn);\n                await Promise.allSettled(executions);\n            }\n\n            if (Bun.env.NODE_ENV !== 'test') {\n                singleBar.stop();\n            }\n\n            await dataWriter.close();\n            await errorWriter.close();\n        })();\n\n        return {\n            Output: Output(readableData, readableError)\n        };\n    }\n}",
+    "import { Execute } from \"../execute\";\nimport type { DatabaseConnection } from \"../connect/types\";\nimport { Retrieve } from \"../retrieve\";\nimport type { InputChain } from \"./types\";\n\nexport const Input = (connections$: (databases: string[]) => Generator<DatabaseConnection[]>, databases$: Promise<string[]>) => {\n    return <TParam>(fn: () => TParam): InputChain<TParam> => {\n        const params = fn();\n        return {\n            Execute: Execute(connections$, databases$, params),\n            Retrieve: Retrieve(connections$, databases$, params)\n        }\n    }\n}\n",
+    "import type { Pool } from \"../../pool\";\nimport { Input } from \"../input\";\nimport { Execute } from \"../execute\";\nimport { Retrieve } from \"../retrieve\";\n\nimport type { ConnectOverloads, ConnectionOptions, ConnectionChain, DatabaseConnection } from \"./types\";\nimport { LoadEnv } from \"../../utils/load-env\";\n\nexport const Connect = (pool: Pool): ConnectOverloads => (param: string | string[] | ConnectionOptions, concurrent?: number): ConnectionChain => {\n    let connections$: (databases: string[]) => Generator<DatabaseConnection[]>;\n    let databases$: Promise<string[]>;\n\n    function connections(concurrent: number = Number.MAX_VALUE): (databases: string[]) => Generator<DatabaseConnection[]> {\n        return function* (databases: string[]) {\n            const _databases = [...databases];\n            const safe_guard = LoadEnv().SAFE_GUARD;\n\n            if (safe_guard > 0) {\n                const guard_test = _databases.splice(0, safe_guard);\n\n                for (const database of guard_test) {\n                    yield [{\n                        database,\n                        connection: pool.connect({ database })\n                    }];\n                }\n            }\n\n            const databases_result_chunks = Array.from(\n                { length: Math.ceil(_databases.length / concurrent) },\n                (_, i) => _databases.slice(i * concurrent, (i + 1) * concurrent)\n            );\n\n            for (const databases_result_chunk of databases_result_chunks) {\n                yield databases_result_chunk.map(database => ({\n                    database,\n                    connection: pool.connect({ database })\n                }));\n            }\n        }\n    }\n\n    if (typeof param === 'string') {\n        databases$ = Promise.resolve([param]);\n    }\n\n    else if (Array.isArray(param)) {\n        databases$ = Promise.resolve(param);\n    }\n\n    else if (typeof param === 'object' && 'query' in param) {\n        databases$ = pool\n            .connect({ database: param.database, arrayRowMode: true })\n            .then(conn => conn\n                .request()\n                .query<string[]>(param.query)\n            )\n            .then(result => result.recordset.flat())\n    }\n\n    else {\n        throw new Error(\"Invalid parameter\");\n    }\n\n    connections$ = connections(concurrent);\n\n    return {\n        Input: Input(connections$, databases$),\n        Execute: Execute(connections$, databases$, null),\n        Retrieve: Retrieve(connections$, databases$, null)\n    }\n}",
+    "import type { ServerConfig } from \"../server/types\";\nimport { Pool } from \"../../pool\";\nimport { Connect } from \"../connect\";\nimport type { AuthenticationChain } from \"./types\";\nimport type { AuthStrategy } from \"./strategies/types\";\n\nexport const Auth = (config: ServerConfig) => (strategy: AuthStrategy): AuthenticationChain => {\n    const configWithAuth = strategy(config);\n    const pool = Pool(configWithAuth);\n\n    return {\n        Connect: Connect(pool),\n        Close: () => pool.closeAll(),\n    }\n}",
+    "import { Auth } from \"../auth\";\nimport type { ServerChain, ServerConfig } from \"./types\";\n\nexport const Server = (config: ServerConfig): ServerChain => ({\n    Auth: Auth(config),\n});"
+  ],
+  "mappings": "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",
+  "debugId": "7B64C9FB2CADE14664756E2164756E21",
+  "names": []
+}

package/dist/pipes/auth/strategies/index.d.ts

@@ -0,0 +1,8 @@
+import { config } from "mssql";
+type ServerConfig = Omit<config, "authentication" | "user" | "password">;
+import { config as config2 } from "mssql";
+type AuthStrategy = (config2: ServerConfig) => config2;
+declare const UserAndPassword: (username: string, password: string) => AuthStrategy;
+import { NodeAuthOptions } from "@azure/msal-node";
+declare const ActiveDirectoryAccessToken: (config: NodeAuthOptions) => Promise<AuthStrategy>;
+export { UserAndPassword, AuthStrategy, ActiveDirectoryAccessToken };

package/dist/pipes/auth/strategies/index.js

@@ -0,0 +1,133 @@
+// @bun
+import {
+  __require,
+  __toESM
+} from "../../../shared/chunk-s3vw82k6.js";
+
+// src/pipes/auth/strategies/userAndPassword.ts
+var UserAndPassword = (username, password) => (config) => {
+  return {
+    ...config,
+    user: username,
+    password
+  };
+};
+// src/pipes/auth/strategies/msal.ts
+import {
+  LogLevel,
+  PublicClientApplication
+} from "@azure/msal-node";
+import * as path from "path";
+import { cwd } from "process";
+var SCOPES = ["https://database.windows.net//.default"];
+var cacheAccess = (hash) => {
+  const cacheFilePath = path.join(cwd(), `./.active-directory-cache/${hash}.json`);
+  const before = async (cacheContext) => {
+    try {
+      const cacheFile = await Bun.file(cacheFilePath).text();
+      cacheContext.tokenCache.deserialize(cacheFile);
+    } catch (err) {
+      await Bun.write(cacheFilePath, "");
+      cacheContext.tokenCache.deserialize("");
+    }
+  };
+  const after = async (cacheContext) => {
+    if (cacheContext.cacheHasChanged) {
+      try {
+        await Bun.write(cacheFilePath, cacheContext.tokenCache.serialize());
+      } catch (err) {
+        console.error(err);
+      }
+    }
+  };
+  return {
+    beforeCacheAccess: before,
+    afterCacheAccess: after
+  };
+};
+var msalConfig = (config, cachePlugin) => ({
+  auth: config,
+  cache: {
+    cachePlugin
+  },
+  system: {
+    loggerOptions: {
+      loggerCallback(loglevel, message) {
+        console.log(message);
+      },
+      piiLoggingEnabled: false,
+      logLevel: LogLevel.Error
+    }
+  }
+});
+var GetToken = async (config) => {
+  const tenantId = config.authority?.replace("https://login.microsoftonline.com/", "");
+  const clientId = config.clientId;
+  const pca = new PublicClientApplication(msalConfig(config, cacheAccess(`${tenantId}-${clientId}`)));
+  const tokenCache = pca.getTokenCache();
+  async function getAccount() {
+    return await tokenCache.getAllAccounts();
+  }
+  const accounts = await getAccount();
+  let result;
+  if (accounts.length > 0 && accounts[0]) {
+    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 = {
+    scopes: SCOPES,
+    openBrowser: async (url) => {
+      const { default: open } = await import("open");
+      open(url);
+    },
+    successTemplate: `
+            <html lang="HTML5">
+                <head>
+                    <title>Authentication Success</title>
+                </head>
+                <script>
+                    setTimeout(() => {
+                        window.close();
+                    }, 1000);
+                </script>
+                <body>
+                    <h1>Authentication Success</h1>
+                    <p>This window will be closed now</p>
+                </body>
+            </html>
+        `
+  };
+  result = await pca.acquireTokenInteractive(interactiveRequest);
+  return result?.accessToken;
+};
+var ActiveDirectoryAccessToken = async (config) => {
+  const accessToken = await GetToken(config);
+  return (config2) => {
+    return {
+      ...config2,
+      authentication: {
+        type: "azure-active-directory-access-token",
+        options: {
+          token: accessToken
+        }
+      }
+    };
+  };
+};
+export {
+  UserAndPassword,
+  ActiveDirectoryAccessToken
+};
+
+//# debugId=2C8A578FAEFB90EA64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/pipes/auth/strategies/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["src/pipes/auth/strategies/userAndPassword.ts", "src/pipes/auth/strategies/msal.ts"],
+  "sourcesContent": [
+    "import type { AuthStrategy } from \"./types\"\nimport type { ServerConfig } from \"../../server/types\"\n\nexport const UserAndPassword = (username: string, password: string): AuthStrategy => (config: ServerConfig) => {\n    return {\n        ...config,\n        user: username,\n        password\n    }\n}",
+    "import {\n    type AuthenticationResult,\n    type Configuration,\n    type ICachePlugin,\n    type InteractiveRequest,\n    LogLevel,\n    type NodeAuthOptions,\n    PublicClientApplication,\n    type TokenCache,\n    type TokenCacheContext,\n} from \"@azure/msal-node\";\n\nimport * as path from \"path\";\nimport type { ServerConfig } from \"../../server/types\";\nimport type { AuthStrategy } from \"./types\";\nimport { cwd } from \"process\";\n\nconst SCOPES = [\"https://database.windows.net//.default\"];\n\nconst cacheAccess = (hash: string) => {\n    const cacheFilePath = path.join(cwd(), `./.active-directory-cache/${hash}.json`);\n\n    const before = async (cacheContext: TokenCacheContext) => {\n        try {\n            const cacheFile = await Bun.file(cacheFilePath).text();\n            cacheContext.tokenCache.deserialize(cacheFile);\n        } catch (err) {\n            await Bun.write(cacheFilePath, \"\");\n            cacheContext.tokenCache.deserialize(\"\");\n        }\n    };\n\n    const after = async (cacheContext: TokenCacheContext) => {\n        if (cacheContext.cacheHasChanged) {\n            try {\n                await Bun.write(cacheFilePath, cacheContext.tokenCache.serialize());\n            } catch (err) {\n                console.error(err);\n            }\n        }\n    };\n\n    return {\n        beforeCacheAccess: before,\n        afterCacheAccess: after,\n    };\n};\n\nconst msalConfig = (config: NodeAuthOptions, cachePlugin: ICachePlugin) => ({\n    auth: config,\n    cache: {\n        cachePlugin,\n    },\n    system: {\n        loggerOptions: {\n            loggerCallback(loglevel, message) {\n                console.log(message);\n            },\n            piiLoggingEnabled: false,\n            logLevel: LogLevel.Error,\n        },\n    },\n} as Configuration);\n\nexport const GetToken = async (config: NodeAuthOptions): Promise<string> => {\n    const tenantId = config.authority?.replace(\"https://login.microsoftonline.com/\", \"\");\n    const clientId = config.clientId;\n\n    const pca: PublicClientApplication = new PublicClientApplication(\n        msalConfig(config, cacheAccess(`${tenantId}-${clientId}`)),\n    );\n\n    const tokenCache: TokenCache = pca.getTokenCache();\n\n    async function getAccount() {\n        return await tokenCache.getAllAccounts();\n    }\n\n    const accounts = await getAccount();\n    let result: AuthenticationResult | null;\n\n    if (accounts.length > 0 && accounts[0]) {\n        try {\n            result = await pca.acquireTokenSilent({\n                scopes: SCOPES,\n                account: accounts[0],\n            });\n\n            return result?.accessToken;\n        } catch (error) {\n            if (error instanceof Error) {\n                console.error('Silent token acquisition failed:', error.message);\n            }\n            console.log(\"Proceeding to interactive authentication\");\n        }\n    }\n\n    const interactiveRequest: InteractiveRequest = {\n        scopes: SCOPES,\n        openBrowser: async (url) => {\n            const { default: open } = await import(\"open\");\n            open(url);\n        },\n        successTemplate: `\n            <html lang=\"HTML5\">\n                <head>\n                    <title>Authentication Success</title>\n                </head>\n                <script>\n                    setTimeout(() => {\n                        window.close();\n                    }, 1000);\n                </script>\n                <body>\n                    <h1>Authentication Success</h1>\n                    <p>This window will be closed now</p>\n                </body>\n            </html>\n        `,\n    };\n\n    result = await pca.acquireTokenInteractive(interactiveRequest);\n\n    return result?.accessToken;\n};\n\nexport const ActiveDirectoryAccessToken = async (config: NodeAuthOptions): Promise<AuthStrategy> => {\n    const accessToken = await GetToken(config);\n    return (config: ServerConfig) => {\n        return {\n            ...config,\n            authentication: {\n                type: 'azure-active-directory-access-token',\n                options: {\n                    token: accessToken\n                }\n            }\n        }\n    }\n}\n"
+  ],
+  "mappings": ";;;;;;;AAGO,IAAM,kBAAkB,CAAC,UAAkB,aAAmC,CAAC,WAAyB;AAAA,EAC3G,OAAO;AAAA,OACA;AAAA,IACH,MAAM;AAAA,IACN;AAAA,EACJ;AAAA;;ACRJ;AAAA;AAAA;AAAA;AAYA;AAGA;AAEA,IAAM,SAAS,CAAC,wCAAwC;AAExD,IAAM,cAAc,CAAC,SAAiB;AAAA,EAClC,MAAM,gBAAqB,UAAK,IAAI,GAAG,6BAA6B,WAAW;AAAA,EAE/E,MAAM,SAAS,OAAO,iBAAoC;AAAA,IACtD,IAAI;AAAA,MACA,MAAM,YAAY,MAAM,IAAI,KAAK,aAAa,EAAE,KAAK;AAAA,MACrD,aAAa,WAAW,YAAY,SAAS;AAAA,MAC/C,OAAO,KAAK;AAAA,MACV,MAAM,IAAI,MAAM,eAAe,EAAE;AAAA,MACjC,aAAa,WAAW,YAAY,EAAE;AAAA;AAAA;AAAA,EAI9C,MAAM,QAAQ,OAAO,iBAAoC;AAAA,IACrD,IAAI,aAAa,iBAAiB;AAAA,MAC9B,IAAI;AAAA,QACA,MAAM,IAAI,MAAM,eAAe,aAAa,WAAW,UAAU,CAAC;AAAA,QACpE,OAAO,KAAK;AAAA,QACV,QAAQ,MAAM,GAAG;AAAA;AAAA,IAEzB;AAAA;AAAA,EAGJ,OAAO;AAAA,IACH,mBAAmB;AAAA,IACnB,kBAAkB;AAAA,EACtB;AAAA;AAGJ,IAAM,aAAa,CAAC,QAAyB,iBAA+B;AAAA,EACxE,MAAM;AAAA,EACN,OAAO;AAAA,IACH;AAAA,EACJ;AAAA,EACA,QAAQ;AAAA,IACJ,eAAe;AAAA,MACX,cAAc,CAAC,UAAU,SAAS;AAAA,QAC9B,QAAQ,IAAI,OAAO;AAAA;AAAA,MAEvB,mBAAmB;AAAA,MACnB,UAAU,SAAS;AAAA,IACvB;AAAA,EACJ;AACJ;AAEO,IAAM,WAAW,OAAO,WAA6C;AAAA,EACxE,MAAM,WAAW,OAAO,WAAW,QAAQ,sCAAsC,EAAE;AAAA,EACnF,MAAM,WAAW,OAAO;AAAA,EAExB,MAAM,MAA+B,IAAI,wBACrC,WAAW,QAAQ,YAAY,GAAG,YAAY,UAAU,CAAC,CAC7D;AAAA,EAEA,MAAM,aAAyB,IAAI,cAAc;AAAA,EAEjD,eAAe,UAAU,GAAG;AAAA,IACxB,OAAO,MAAM,WAAW,eAAe;AAAA;AAAA,EAG3C,MAAM,WAAW,MAAM,WAAW;AAAA,EAClC,IAAI;AAAA,EAEJ,IAAI,SAAS,SAAS,KAAK,SAAS,IAAI;AAAA,IACpC,IAAI;AAAA,MACA,SAAS,MAAM,IAAI,mBAAmB;AAAA,QAClC,QAAQ;AAAA,QACR,SAAS,SAAS;AAAA,MACtB,CAAC;AAAA,MAED,OAAO,QAAQ;AAAA,MACjB,OAAO,OAAO;AAAA,MACZ,IAAI,iBAAiB,OAAO;AAAA,QACxB,QAAQ,MAAM,oCAAoC,MAAM,OAAO;AAAA,MACnE;AAAA,MACA,QAAQ,IAAI,0CAA0C;AAAA;AAAA,EAE9D;AAAA,EAEA,MAAM,qBAAyC;AAAA,IAC3C,QAAQ;AAAA,IACR,aAAa,OAAO,QAAQ;AAAA,MACxB,QAAQ,SAAS,SAAS,MAAa;AAAA,MACvC,KAAK,GAAG;AAAA;AAAA,IAEZ,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBrB;AAAA,EAEA,SAAS,MAAM,IAAI,wBAAwB,kBAAkB;AAAA,EAE7D,OAAO,QAAQ;AAAA;AAGZ,IAAM,6BAA6B,OAAO,WAAmD;AAAA,EAChG,MAAM,cAAc,MAAM,SAAS,MAAM;AAAA,EACzC,OAAO,CAAC,YAAyB;AAAA,IAC7B,OAAO;AAAA,SACA;AAAA,MACH,gBAAgB;AAAA,QACZ,MAAM;AAAA,QACN,SAAS;AAAA,UACL,OAAO;AAAA,QACX;AAAA,MACJ;AAAA,IACJ;AAAA;AAAA;",
+  "debugId": "2C8A578FAEFB90EA64756E2164756E21",
+  "names": []
+}

package/dist/pipes/output/strategies/index.d.ts

@@ -0,0 +1,12 @@
+type OutputStrategy<
+	TReturn,
+	TOutput = void
+> = (data: ReadableStream<Record<string, TReturn>>) => Promise<TOutput>;
+declare const MergeOutputStrategy: <
+	TData extends Array<unknown>,
+	TMerged = TData extends Array<infer TItem> ? TItem : TData
+>() => OutputStrategy<TData, TMerged[]>;
+declare const ConsoleOutputStrategy: <TData>() => OutputStrategy<TData, void>;
+declare const JsonOutputStrategy: <TData>() => OutputStrategy<TData, string>;
+declare const XlsOutputStrategy: <TData>(unique?: boolean) => OutputStrategy<TData, string>;
+export { XlsOutputStrategy, OutputStrategy, MergeOutputStrategy, JsonOutputStrategy, ConsoleOutputStrategy };