@versori/run 0.2.29 → 0.3.0-beta.2

package/script/src/connection/internal/FetchBuilder.js

@@ -0,0 +1,93 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FetchBuilder_base, _FetchBuilder_cnx;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchBuilder = void 0;
+const helpers_js_1 = require("../../dsl/http/versori/helpers.js");
+/**
+ * FetchBuilder is used to build a fetch function which can be composed by multiple middlewares for
+ * modifying the request/response and makes the implementation of {@link ConnectionFetchFactory}
+ * easier to understand.
+ */
+class FetchBuilder {
+    constructor(fetch, cnx) {
+        Object.defineProperty(this, "middlewares", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _FetchBuilder_base.set(this, void 0);
+        _FetchBuilder_cnx.set(this, void 0);
+        __classPrivateFieldSet(this, _FetchBuilder_base, fetch, "f");
+        __classPrivateFieldSet(this, _FetchBuilder_cnx, cnx, "f");
+        this.middlewares = [changeRequestbaseURLMiddleware(cnx)];
+    }
+    use(fn) {
+        this.middlewares.push(fn);
+    }
+    build() {
+        let fetch = __classPrivateFieldGet(this, _FetchBuilder_base, "f");
+        for (let i = this.middlewares.length - 1; i >= 0; i--) {
+            // apply middlewares in reverse order so that the actual middleware executes in the
+            // order they were added
+            fetch = this.middlewares[i](fetch);
+        }
+        return fetch;
+    }
+}
+exports.FetchBuilder = FetchBuilder;
+_FetchBuilder_base = new WeakMap(), _FetchBuilder_cnx = new WeakMap();
+function changeBaseUrl(pathname, conn) {
+    const connBaseURL = conn.baseUrl;
+    // if the connection has no baseUrl set, but the pathname is a valid URL, return it as is
+    if (!connBaseURL && (0, helpers_js_1.isValidURL)(pathname)) {
+        return pathname;
+    }
+    // if connBaseURL is undefined, we can't create a URL object
+    if (!connBaseURL) {
+        throw new Error('Connection baseUrl is required but not provided');
+    }
+    const connBaseURLObj = new URL(connBaseURL);
+    let _pathname = pathname;
+    if ((0, helpers_js_1.isValidURL)(pathname)) {
+        const pathnameObj = new URL(pathname);
+        _pathname = pathnameObj.pathname;
+    }
+    const newURL = new URL(_pathname, connBaseURLObj.origin);
+    return newURL.toString();
+}
+function changeRequestInit(info, conn) {
+    if (typeof info === 'string') {
+        if ((0, helpers_js_1.isValidURL)(info)) {
+            return info;
+        }
+        return changeBaseUrl(info, conn);
+    }
+    else if (info instanceof URL) {
+        return info;
+    }
+    else if (info instanceof Request) {
+        const url = changeBaseUrl(info.url, conn);
+        return new Request(url, info);
+    }
+    return info;
+}
+function changeRequestbaseURLMiddleware(conn) {
+    return (fetch) => {
+        return async (input, init = {}) => {
+            const newInput = changeRequestInit(input, conn);
+            return fetch(newInput, init);
+        };
+    };
+}

package/script/src/connection/internal/HttpClientFactory.d.ts

@@ -0,0 +1,14 @@
+import { credentialv1alpha1 } from '../../services/credentials/mod.js';
+/**
+ * HttpClientFactory is used to create a {@link Deno.HttpClient} for a given {@link credentialv1alpha1.Credential}.
+ *
+ * This is build to support being provided any credential type, and if the credential does not require a specific
+ * client then the factory will return undefined.
+ */
+export declare class HttpClientFactory {
+    private readonly cache;
+    constructor();
+    getClient(credential: credentialv1alpha1.Credential): Deno.HttpClient | undefined;
+    private newMtlsClient;
+}
+//# sourceMappingURL=HttpClientFactory.d.ts.map

package/script/src/connection/internal/HttpClientFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpClientFactory.d.ts","sourceRoot":"","sources":["../../../../src/src/connection/internal/HttpClientFactory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE;;;;;GAKG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;;IAM1D,SAAS,CAAC,UAAU,EAAE,kBAAkB,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,SAAS;IAcjF,OAAO,CAAC,aAAa;CAaxB"}

package/script/src/connection/internal/HttpClientFactory.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientFactory = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const lru_cache_1 = require("lru-cache");
+const mod_js_1 = require("../../services/credentials/mod.js");
+/**
+ * HttpClientFactory is used to create a {@link Deno.HttpClient} for a given {@link credentialv1alpha1.Credential}.
+ *
+ * This is build to support being provided any credential type, and if the credential does not require a specific
+ * client then the factory will return undefined.
+ */
+class HttpClientFactory {
+    constructor() {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new lru_cache_1.LRUCache({ max: 100 });
+    }
+    getClient(credential) {
+        const cached = this.cache.get(credential.id);
+        if (cached) {
+            return cached;
+        }
+        switch (credential.type) {
+            case mod_js_1.credentialv1alpha1.Credential_Type.Certificate:
+                return this.newMtlsClient(credential);
+            default:
+                return undefined;
+        }
+    }
+    newMtlsClient(credential) {
+        const data = (0, protobuf_1.create)(mod_js_1.credentialv1alpha1.CredentialDataCertificateSchema, credential.data);
+        const client = Deno.createHttpClient({
+            cert: new TextDecoder().decode(data.certificate),
+            key: new TextDecoder().decode(data.key),
+            caCerts: data.ca ? [new TextDecoder().decode(data.ca)] : [],
+        });
+        this.cache.set(credential.id, client);
+        return client;
+    }
+}
+exports.HttpClientFactory = HttpClientFactory;

package/script/src/connection/internal/InboundConnectionFactory.d.ts

@@ -0,0 +1,19 @@
+import { Client } from '@connectrpc/connect';
+import { Logger } from '../../observability/logging/Logger.js';
+import { credentialv1alpha1, tokensv1 } from '../../services/credentials/mod.js';
+import type * as express from 'express';
+import { Connection } from '../../services/platform/mod.js';
+export declare class ExpressInboundConnectionFactory {
+    private readonly credentials;
+    private readonly tokens;
+    private readonly logger;
+    private readonly cache;
+    constructor(credentials: Client<typeof credentialv1alpha1.CredentialService>, tokens: Client<typeof tokensv1.TokenService>, logger: Logger);
+    handler(cnx: Connection): Promise<express.RequestHandler>;
+    private buildHandlers;
+    private buildHandler;
+    private buildApiKeyHandler;
+    private buildBasicAuthHandler;
+    private buildHmacHandler;
+}
+//# sourceMappingURL=InboundConnectionFactory.d.ts.map

package/script/src/connection/internal/InboundConnectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InboundConnectionFactory.d.ts","sourceRoot":"","sources":["../../../../src/src/connection/internal/InboundConnectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,KAAK,KAAK,OAAO,MAAM,SAAS,CAAC;AACxC,OAAO,EAIH,UAAU,EAGb,MAAM,gCAAgC,CAAC;AAQxC,qBAAa,+BAA+B;IAGpC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJ3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoD;gBAErD,WAAW,EAAE,MAAM,CAAC,OAAO,kBAAkB,CAAC,iBAAiB,CAAC,EAChE,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,EAC5C,MAAM,EAAE,MAAM;IAKnC,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC;YAa3C,aAAa;IAc3B,OAAO,CAAC,YAAY;YAuDN,kBAAkB;YAiIlB,qBAAqB;YA2FrB,gBAAgB;CAsJjC"}

package/script/src/connection/internal/InboundConnectionFactory.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressInboundConnectionFactory = void 0;
+const mod_js_1 = require("../../services/credentials/mod.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const CredentialHolder_js_1 = require("./CredentialHolder.js");
+const isTokenValid_js_1 = require("../../services/credentials/isTokenValid.js");
+const lru_cache_1 = require("lru-cache");
+class ExpressInboundConnectionFactory {
+    constructor(credentials, tokens, logger) {
+        Object.defineProperty(this, "credentials", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: credentials
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: tokens
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logger
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new lru_cache_1.LRUCache({ max: 100 });
+    }
+    handler(cnx) {
+        const cached = this.cache.get(cnx.id);
+        if (cached) {
+            return cached;
+        }
+        const handler = this.buildHandlers(cnx);
+        this.cache.set(cnx.id, handler);
+        return handler;
+    }
+    async buildHandlers(cnx) {
+        const handlers = [];
+        for (const [index, cnxCredential] of cnx.credentials.entries()) {
+            const handler = await this.buildHandler(cnxCredential, index, cnx);
+            if (handler) {
+                handlers.push(handler);
+            }
+        }
+        return composeHandlers(handlers);
+    }
+    buildHandler(cnxCredential, index, cnx) {
+        const asc = cnxCredential.authSchemeConfig;
+        const redactedCredential = cnxCredential.credential;
+        if (!asc || !redactedCredential) {
+            this.logger.warn('Connection credential is missing authSchemeConfig or credential', {
+                connectionId: cnx.id,
+                index,
+                asc,
+                redactedCredential,
+            });
+            return Promise.resolve(undefined);
+        }
+        switch (asc.type) {
+            case 'api-key':
+                if (!asc.apiKey) {
+                    this.logger.warn('api-key auth has missing apiKey config', {
+                        connectionId: cnx.id,
+                        index,
+                    });
+                    return Promise.resolve(undefined);
+                }
+                return this.buildApiKeyHandler(asc.apiKey, redactedCredential);
+            case 'basic-auth':
+                return this.buildBasicAuthHandler(redactedCredential);
+            case 'hmac':
+                if (!asc.hmac) {
+                    this.logger.warn('hmac auth has missing hmac config', {
+                        connectionId: cnx.id,
+                        index,
+                    });
+                    return Promise.resolve(undefined);
+                }
+                return this.buildHmacHandler(asc.hmac, redactedCredential);
+            default:
+                this.logger.warn('Unsupported inbound authSchemeConfig type', {
+                    connectionId: cnx.id,
+                    index,
+                    type: asc.type,
+                });
+                return Promise.resolve(undefined);
+        }
+    }
+    async buildApiKeyHandler(cfg, redactedCredential) {
+        const initial = await this.tokens.getToken({
+            credentialId: redactedCredential.id,
+            forceRefresh: false,
+        });
+        if (!initial || !initial.token) {
+            this.logger.error('API key token not found for credential when building handler', {
+                credentialId: redactedCredential.id,
+            });
+            return (_req, res) => {
+                this.logger.warn('API key not configured before deployment, please redeploy your project', { credentialId: redactedCredential.id });
+                res.status(401).json({ error: 'Unauthorised' });
+            };
+        }
+        const holder = new CredentialHolder_js_1.CredentialHolder(initial.token, isTokenValid_js_1.isTokenValid, async () => {
+            const refreshed = await this.tokens.getToken({
+                credentialId: redactedCredential.id,
+                forceRefresh: false,
+            });
+            return refreshed.token;
+        });
+        let extractor;
+        switch (cfg.in) {
+            case 'header': {
+                const headerKey = cfg.name.toLowerCase();
+                extractor = (req) => {
+                    const headerVal = req.headers[headerKey];
+                    if (Array.isArray(headerVal)) {
+                        return headerVal[0];
+                    }
+                    if (typeof headerVal === 'string') {
+                        return headerVal;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            case 'query': {
+                const name = cfg.name;
+                extractor = (req) => {
+                    const q = req.query?.[name];
+                    if (typeof q === 'string') {
+                        return q;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            case 'cookie': {
+                const name = cfg.name;
+                extractor = (req) => {
+                    const c = req.cookies?.[name];
+                    if (typeof c === 'string') {
+                        return c;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            default:
+                throw new Error('Unsupported apiKey.in value: ' + cfg.in);
+        }
+        async function verify(apiKey) {
+            const expected = await holder.get();
+            if (!expected) {
+                return false;
+            }
+            let expectedKey = expected.tokenType
+                ? `${expected.tokenType} ${expected.accessToken}`
+                : expected.accessToken;
+            if (apiKey === expectedKey || apiKey === expected.accessToken) {
+                return true;
+            }
+            // TODO: Is this a DDOS if they just provide the wrong credential?
+            holder.refresh();
+            expectedKey = expected.tokenType
+                ? `${expected.tokenType} ${expected.accessToken}`
+                : expected.accessToken;
+            return apiKey === expectedKey || apiKey === expected.accessToken;
+        }
+        return async (req, res, next) => {
+            try {
+                const gotKey = extractor(req);
+                if (!gotKey) {
+                    return res.status(401).json({ error: 'Unauthorised' });
+                }
+                if (await verify(gotKey)) {
+                    return next();
+                }
+                return res.status(401).json({ error: 'Unauthorised' });
+            }
+            catch (err) {
+                this.logger.error('Error verifying API key', { err });
+                res.status(401).json({ error: 'Unauthorised' });
+            }
+        };
+    }
+    async buildBasicAuthHandler(redactedCredential) {
+        const response = await this.credentials.get({ id: redactedCredential.id });
+        if (!response || !response.credential) {
+            this.logger.error('BasicAuth credential not found when building handler', {
+                credentialId: redactedCredential.id,
+            });
+            return (_req, res) => {
+                this.logger.warn('BasicAuth not configured before deployment, please redeploy your project', {
+                    credentialId: redactedCredential.id,
+                });
+                res.status(401).json({ error: 'Unauthorised' });
+            };
+        }
+        const holder = new CredentialHolder_js_1.CredentialHolder(response.credential, CredentialHolder_js_1.alwaysValid, async () => {
+            const refreshed = await this.credentials.get({ id: redactedCredential.id });
+            return refreshed.credential;
+        });
+        // Build parser once
+        const parseAuth = (req) => {
+            const headerVal = req.headers['authorization'];
+            const header = Array.isArray(headerVal) ? headerVal[0] : headerVal;
+            if (!header || typeof header !== 'string') {
+                return undefined;
+            }
+            const [scheme, encoded] = header.split(' ');
+            if (!scheme || scheme.toLowerCase() !== 'basic' || !encoded) {
+                return undefined;
+            }
+            let decoded = '';
+            try {
+                decoded = node_buffer_1.Buffer.from(encoded, 'base64').toString('utf8');
+            }
+            catch (err) {
+                this.logger.warn('Error decoding BasicAuth header', { encoded, error: err });
+                return undefined;
+            }
+            const sep = decoded.indexOf(':');
+            if (sep === -1) {
+                return undefined;
+            }
+            return { username: decoded.slice(0, sep), password: decoded.slice(sep + 1) };
+        };
+        return async (req, res, next) => {
+            try {
+                const parsed = parseAuth(req);
+                if (!parsed) {
+                    return res.status(401).json({ error: 'Unauthorised' });
+                }
+                const c1 = await holder.get();
+                const data1 = (0, protobuf_1.create)(mod_js_1.credentialv1alpha1.CredentialDataBasicAuthSchema, c1.data);
+                if (parsed.username === data1.username && parsed.password === data1.password) {
+                    return next();
+                }
+                const c2 = await holder.get(true);
+                const data2 = (0, protobuf_1.create)(mod_js_1.credentialv1alpha1.CredentialDataBasicAuthSchema, c2.data);
+                if (parsed.username === data2.username && parsed.password === data2.password) {
+                    return next();
+                }
+                return res.status(401).json({ error: 'Unauthorised' });
+            }
+            catch (err) {
+                this.logger.error('Error verifying BasicAuth', { err });
+                res.status(401).json({ error: 'Unauthorised' });
+            }
+        };
+    }
+    async buildHmacHandler(cfg, redactedCredential) {
+        const response = await this.credentials.get({ id: redactedCredential.id });
+        if (!response || !response.credential) {
+            this.logger.error('HMAC credential not found', { credentialId: redactedCredential.id });
+            return (_req, res) => {
+                res.status(401).json({ error: 'Unauthorised' });
+            };
+        }
+        const holder = new CredentialHolder_js_1.CredentialHolder(response.credential, CredentialHolder_js_1.alwaysValid, async () => {
+            const refreshed = await this.credentials.get({ id: redactedCredential.id });
+            return refreshed.credential;
+        });
+        let extractor;
+        switch (cfg.in) {
+            case 'query': {
+                const name = cfg.name;
+                extractor = (req) => {
+                    const q = req.query?.[name];
+                    if (typeof q === 'string') {
+                        return q;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            case 'header': {
+                const headerKey = cfg.name.toLowerCase();
+                extractor = (req) => {
+                    const hv = req.headers[headerKey];
+                    if (Array.isArray(hv)) {
+                        return hv[0];
+                    }
+                    if (typeof hv === 'string') {
+                        return hv;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            case 'cookie': {
+                const name = cfg.name;
+                extractor = (req) => {
+                    const c = req.cookies?.[name];
+                    if (typeof c === 'string') {
+                        return c;
+                    }
+                    return undefined;
+                };
+                break;
+            }
+            default:
+                throw new Error('Unsupported hmac.in value: ' + cfg.in);
+        }
+        const logger = this.logger;
+        async function computeDigest(req) {
+            const cred = await holder.get();
+            const raw = (0, protobuf_1.create)(mod_js_1.credentialv1alpha1.CredentialDataRawSchema, cred.data);
+            const secret = node_buffer_1.Buffer.from(raw.raw).toString('utf8');
+            const hmac = (0, node_crypto_1.createHmac)(cfg.algorithm, secret);
+            for (const input of cfg.digestInputs) {
+                switch (input) {
+                    case 'body': {
+                        if (typeof req.rawBody === 'undefined') {
+                            const { body: _body, ...rest } = req;
+                            // NOTE: address this in future, at the moment only the JSON body-parser is populating the
+                            // rawBody property, so this should only happen if the user is not using JSON.
+                            logger.warn('request.rawBody missing from request, HMAC signature is likely going to fail, this can happen if the payload is not application/json', { req: { ...rest, body: '**redacted**' } });
+                            return '';
+                        }
+                        hmac.update(req.rawBody);
+                        break;
+                    }
+                    case 'url':
+                        hmac.update(req.originalUrl ?? req.url);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            return hmac.digest(cfg.encoding);
+        }
+        return async (req, res, next) => {
+            try {
+                const provided = extractor(req);
+                if (!provided) {
+                    return res.status(401).json({ error: 'Unauthorised' });
+                }
+                const digest1 = await computeDigest(req);
+                if (provided === digest1) {
+                    return next();
+                }
+                // TODO: Is this a DDOS if they just provide the wrong credential?
+                holder.refresh();
+                const digest2 = await computeDigest(req);
+                if (provided === digest2) {
+                    return next();
+                }
+                return res.status(401).json({ error: 'Unauthorised' });
+            }
+            catch (err) {
+                this.logger.error('Error verifying HMAC', { err });
+                res.status(401).json({ error: 'Unauthorised' });
+            }
+        };
+    }
+}
+exports.ExpressInboundConnectionFactory = ExpressInboundConnectionFactory;
+function composeHandlers(handlers) {
+    return (req, res, next) => {
+        let index = -1;
+        const dispatch = (i, err) => {
+            if (err) {
+                return next(err);
+            }
+            if (i <= index) {
+                return next(new Error('next() called multiple times'));
+            }
+            index = i;
+            if (i === handlers.length) {
+                return next();
+            }
+            const handler = handlers[i];
+            try {
+                handler(req, res, (err2) => dispatch(i + 1, err2));
+            }
+            catch (e) {
+                next(e);
+            }
+        };
+        dispatch(0);
+    };
+}

package/script/src/connection/internal/OutboundConnectionFactory.d.ts

@@ -0,0 +1,31 @@
+import { Client } from '@connectrpc/connect';
+import { Logger } from '../../mod.js';
+import { credentialv1alpha1, tokensv1, oauth1v1 } from '../../services/credentials/mod.js';
+import { Connection } from '../../services/platform/mod.js';
+import { FetchLike } from '../types.js';
+import { HttpClientFactory } from './HttpClientFactory.js';
+export declare class OutboundConnectionFactory {
+    private readonly httpClientFactory;
+    private readonly credentials;
+    private readonly tokens;
+    private readonly oauth1;
+    private readonly logger;
+    private readonly cache;
+    constructor(httpClientFactory: HttpClientFactory, credentials: Client<typeof credentialv1alpha1.CredentialService>, tokens: Client<typeof tokensv1.TokenService>, oauth1: Client<typeof oauth1v1.AuthorizationService>, logger: Logger);
+    fetcher(cnx: Connection): Promise<FetchLike>;
+    private buildFetcher;
+    private buildMiddleware;
+    private buildCertificateMiddleware;
+    private buildApiKeyMiddleware;
+    private buildApiKeyHeaderMiddleware;
+    private buildApiKeyQueryMiddleware;
+    private buildApiKeyCookieMiddleware;
+    private buildBasicAuthMiddleware;
+    private buildOAuth1Middleware;
+    private buildBasicAuthHeaderMiddleware;
+    private buildOAuth1HeaderMiddleware;
+    private buildJwtBearerMiddleware;
+    private buildOAuth2Middleware;
+    private buildAuthorizationHeaderMiddleware;
+}
+//# sourceMappingURL=OutboundConnectionFactory.d.ts.map

package/script/src/connection/internal/OutboundConnectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutboundConnectionFactory.d.ts","sourceRoot":"","sources":["../../../../src/src/connection/internal/OutboundConnectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,EAGH,UAAU,EAGb,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAsB,MAAM,aAAa,CAAC;AAG5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAI3D,qBAAa,yBAAyB;IAI9B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAP3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;gBAGxC,iBAAiB,EAAE,iBAAiB,EACpC,WAAW,EAAE,MAAM,CAAC,OAAO,kBAAkB,CAAC,iBAAiB,CAAC,EAChE,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,YAAY,CAAC,EAC5C,MAAM,EAAE,MAAM,CAAC,OAAO,QAAQ,CAAC,oBAAoB,CAAC,EACpD,MAAM,EAAE,MAAM;IAKnC,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;YAkB9B,YAAY;IAmB1B,OAAO,CAAC,eAAe;YAiDT,0BAA0B;YAwB1B,qBAAqB;IA4DnC,OAAO,CAAC,2BAA2B;IAuBnC,OAAO,CAAC,0BAA0B;IAkDlC,OAAO,CAAC,2BAA2B;YA0BrB,wBAAwB;YAkCxB,qBAAqB;IAiCnC,OAAO,CAAC,8BAA8B;IAuBtC,OAAO,CAAC,2BAA2B;YA2ErB,wBAAwB;YAkCxB,qBAAqB;IA6CnC,OAAO,CAAC,kCAAkC;CAyB7C"}