@versori/run 0.2.28 → 0.3.0-veta.1

package/script/src/connection/DirectConnectionFactory.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectConnectionFactory = void 0;
+const connect_1 = require("@connectrpc/connect");
+const connect_node_1 = require("@connectrpc/connect-node");
+const mod_js_1 = require("../services/credentials/mod.js");
+const HttpClientFactory_js_1 = require("./internal/HttpClientFactory.js");
+const InboundConnectionFactory_js_1 = require("./internal/InboundConnectionFactory.js");
+const OutboundConnectionFactory_js_1 = require("./internal/OutboundConnectionFactory.js");
+const constants_js_1 = require("../internal/constants.js");
+/**
+ * DirectConnectionFactory is used by actual {@link FetchFactory} and {@link ExpressHandlers} implementations to build a
+ * fetchers and handlers for a given connection.
+ *
+ * This should be used by the internal runtime to construct either a static or dynamic {@link ConnectionFactory} (or
+ * some other implementation that implements {@link ConnectionFactory}), which can be used to build a {@link FetchLike}
+ * or {@link RequestHandler} for a given {@link Context}.
+ */
+class DirectConnectionFactory {
+    constructor(httpClientFactory, credentials, tokens, oauth1, logger) {
+        Object.defineProperty(this, "httpClientFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: httpClientFactory
+        });
+        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, "oauth1", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: oauth1
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logger
+        });
+        Object.defineProperty(this, "outboundConnectionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "expressInboundConnectionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // the only real reason the outbound and inbound implementations are separate is to keep the code separate
+        // since both classes are fairly large and complex.
+        this.outboundConnectionFactory = new OutboundConnectionFactory_js_1.OutboundConnectionFactory(httpClientFactory, credentials, tokens, oauth1, logger);
+        this.expressInboundConnectionFactory = new InboundConnectionFactory_js_1.ExpressInboundConnectionFactory(credentials, tokens, logger);
+    }
+    fetcher(cnx) {
+        return this.outboundConnectionFactory.fetcher(cnx);
+    }
+    handler(cnx) {
+        return this.expressInboundConnectionFactory.handler(cnx);
+    }
+    static fromEnv(logger) {
+        const baseUrl = Deno.env.get(constants_js_1.envVarCredsBaseURL) || 'http://localhost:9000';
+        const transport = (0, connect_node_1.createGrpcTransport)({
+            baseUrl,
+        });
+        const credentials = (0, connect_1.createClient)(mod_js_1.credentialv1alpha1.CredentialService, transport);
+        const tokens = (0, connect_1.createClient)(mod_js_1.tokensv1.TokenService, transport);
+        const oauth1 = (0, connect_1.createClient)(mod_js_1.oauth1v1.AuthorizationService, transport);
+        const httpClientFactory = new HttpClientFactory_js_1.HttpClientFactory();
+        return new DirectConnectionFactory(httpClientFactory, credentials, tokens, oauth1, logger);
+    }
+}
+exports.DirectConnectionFactory = DirectConnectionFactory;

package/script/src/connection/DynamicFetchFactory.d.ts

@@ -0,0 +1,30 @@
+import { RequestHandler } from 'express';
+import { Context } from '../context/Context.js';
+import { PlatformApi } from '../services/platform/mod.js';
+import { ConnectionFactory } from './types.js';
+import { FetchLike, RuntimeConnectionFactory } from './types.js';
+export declare class DynamicFetchFactory implements RuntimeConnectionFactory {
+    private readonly factory;
+    private readonly platformApi;
+    private readonly organisationId;
+    private readonly envSystemId;
+    private readonly cache;
+    private readonly cnxCache;
+    private readonly handlerCache;
+    constructor(factory: ConnectionFactory, platformApi: PlatformApi, organisationId: string, envSystemId: string);
+    fetcher(ctx: Context<unknown>): Promise<FetchLike>;
+    baseUrl(ctx: Context<unknown>): Promise<string>;
+    handler(ctx: Context<unknown>): Promise<RequestHandler>;
+    purgeCache(): void;
+    /**
+     * getConnection is a synchronous function that is used to get a connection from the cache. It reads and writes
+     * a promise to the connection cache within the same tick, ensuring that concurrent requests for the same
+     * activation does not swamp the API with requests.
+     *
+     * @param activationId
+     * @returns
+     */
+    private getConnection;
+    private loadConnection;
+}
+//# sourceMappingURL=DynamicFetchFactory.d.ts.map

package/script/src/connection/DynamicFetchFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicFetchFactory.d.ts","sourceRoot":"","sources":["../../../src/src/connection/DynamicFetchFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAc,WAAW,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEjE,qBAAa,mBAAoB,YAAW,wBAAwB;IAQ5D,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAVhC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwC;IAEjE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4C;gBAGpD,OAAO,EAAE,iBAAiB,EAC1B,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM;IAOxC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;IAkB5C,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAQrD,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;IAiBvD,UAAU;IAMV;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;YAgBP,cAAc;CAY/B"}

package/script/src/connection/DynamicFetchFactory.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicFetchFactory = void 0;
+const lru_cache_js_1 = require("../../deps/jsr.io/@std/cache/0.2.0/lru_cache.js");
+class DynamicFetchFactory {
+    constructor(factory, platformApi, organisationId, envSystemId) {
+        Object.defineProperty(this, "factory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: factory
+        });
+        Object.defineProperty(this, "platformApi", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: platformApi
+        });
+        Object.defineProperty(this, "organisationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: organisationId
+        });
+        Object.defineProperty(this, "envSystemId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: envSystemId
+        });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cnxCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handlerCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cache = new lru_cache_js_1.LruCache(100);
+        this.cnxCache = new lru_cache_js_1.LruCache(100);
+        this.handlerCache = new lru_cache_js_1.LruCache(100);
+    }
+    fetcher(ctx) {
+        // This function must be synchronous, do not update to be async/await!!!
+        const { id: activationId } = ctx.activation;
+        const cached = this.cache.get(activationId);
+        if (cached) {
+            return cached;
+        }
+        const fetcher = this.getConnection(activationId)
+            .then((cnx) => this.factory.fetcher(cnx));
+        this.cache.set(activationId, fetcher);
+        return fetcher;
+    }
+    async baseUrl(ctx) {
+        const { id: activationId } = ctx.activation;
+        const cnx = await this.getConnection(activationId);
+        return cnx.baseUrl ?? '';
+    }
+    handler(ctx) {
+        const { id: activationId } = ctx.activation;
+        const cached = this.handlerCache.get(activationId);
+        if (cached) {
+            return cached;
+        }
+        const handler = this.getConnection(activationId)
+            .then((cnx) => this.factory.handler(cnx));
+        this.handlerCache.set(activationId, handler);
+        return handler;
+    }
+    purgeCache() {
+        this.cache.clear();
+        this.cnxCache.clear();
+        this.handlerCache.clear();
+    }
+    /**
+     * getConnection is a synchronous function that is used to get a connection from the cache. It reads and writes
+     * a promise to the connection cache within the same tick, ensuring that concurrent requests for the same
+     * activation does not swamp the API with requests.
+     *
+     * @param activationId
+     * @returns
+     */
+    getConnection(activationId) {
+        // see tsdoc comments, do not update to be async/await!!!
+        const key = `${this.organisationId}-${this.envSystemId}-${activationId}`;
+        const cached = this.cnxCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const cnx = this.loadConnection(activationId);
+        this.cnxCache.set(key, cnx);
+        return cnx;
+    }
+    async loadConnection(activationId) {
+        const response = await this.platformApi.getActivationConnection({
+            path: {
+                activation_id: activationId,
+                env_system_id: this.envSystemId,
+                organisation_id: this.organisationId,
+            },
+            throwOnError: true,
+        });
+        return response.data;
+    }
+}
+exports.DynamicFetchFactory = DynamicFetchFactory;

package/script/src/connection/StaticFetchFactory.d.ts

@@ -0,0 +1,11 @@
+import type { RequestHandler } from 'express';
+import { Context } from '../context/Context.js';
+import { FetchLike, RuntimeConnectionFactory } from './types.js';
+export declare class StaticFetchFactory implements RuntimeConnectionFactory {
+    #private;
+    constructor(fetch: FetchLike, baseUrl?: string, handler?: RequestHandler);
+    fetcher(_ctx: Context<unknown>): Promise<FetchLike>;
+    baseUrl(_ctx: Context<unknown>): Promise<string>;
+    handler(_ctx: Context<unknown>): Promise<RequestHandler>;
+}
+//# sourceMappingURL=StaticFetchFactory.d.ts.map

package/script/src/connection/StaticFetchFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticFetchFactory.d.ts","sourceRoot":"","sources":["../../../src/src/connection/StaticFetchFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmC,cAAc,EAAE,MAAM,SAAS,CAAC;AAC/E,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAMjE,qBAAa,kBAAmB,YAAW,wBAAwB;;gBAKnD,KAAK,EAAE,SAAS,EAAE,OAAO,GAAE,MAAW,EAAE,OAAO,CAAC,EAAE,cAAc;IAM5E,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;IAInD,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhD,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;CAG3D"}

package/script/src/connection/StaticFetchFactory.js

@@ -0,0 +1,39 @@
+"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 _StaticFetchFactory_fetch, _StaticFetchFactory_baseUrl, _StaticFetchFactory_handler;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticFetchFactory = void 0;
+function passthroughHandler(_req, _res, next) {
+    next();
+}
+class StaticFetchFactory {
+    constructor(fetch, baseUrl = '', handler) {
+        _StaticFetchFactory_fetch.set(this, void 0);
+        _StaticFetchFactory_baseUrl.set(this, void 0);
+        _StaticFetchFactory_handler.set(this, void 0);
+        __classPrivateFieldSet(this, _StaticFetchFactory_fetch, Promise.resolve(fetch), "f");
+        __classPrivateFieldSet(this, _StaticFetchFactory_baseUrl, Promise.resolve(baseUrl), "f");
+        __classPrivateFieldSet(this, _StaticFetchFactory_handler, Promise.resolve(handler ?? passthroughHandler), "f");
+    }
+    fetcher(_ctx) {
+        return __classPrivateFieldGet(this, _StaticFetchFactory_fetch, "f");
+    }
+    baseUrl(_ctx) {
+        return __classPrivateFieldGet(this, _StaticFetchFactory_baseUrl, "f");
+    }
+    handler(_ctx) {
+        return __classPrivateFieldGet(this, _StaticFetchFactory_handler, "f");
+    }
+}
+exports.StaticFetchFactory = StaticFetchFactory;
+_StaticFetchFactory_fetch = new WeakMap(), _StaticFetchFactory_baseUrl = new WeakMap(), _StaticFetchFactory_handler = new WeakMap();

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

@@ -0,0 +1,11 @@
+export declare function alwaysValid(): boolean;
+/**
+ * CredentialHolder is a class that holds a credential and provides a way to refresh it.
+ */
+export declare class CredentialHolder<T> {
+    #private;
+    constructor(initialValue: T, isValid: (t: T) => boolean, refresh: () => Promise<T | undefined>);
+    get(refresh?: boolean): Promise<T>;
+    refresh(): void;
+}
+//# sourceMappingURL=CredentialHolder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CredentialHolder.d.ts","sourceRoot":"","sources":["../../../../src/src/connection/internal/CredentialHolder.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;GAEG;AACH,qBAAa,gBAAgB,CAAC,CAAC;;gBAOf,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAMxF,GAAG,CAAC,OAAO,GAAE,OAAe,GAAG,OAAO,CAAC,CAAC,CAAC;IAkB/C,OAAO,IAAI,IAAI;CAgClB"}

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

@@ -0,0 +1,71 @@
+"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 _CredentialHolder_value, _CredentialHolder_isValid, _CredentialHolder_refresh, _CredentialHolder_isRefreshing;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialHolder = void 0;
+exports.alwaysValid = alwaysValid;
+function alwaysValid() {
+    return true;
+}
+/**
+ * CredentialHolder is a class that holds a credential and provides a way to refresh it.
+ */
+class CredentialHolder {
+    constructor(initialValue, isValid, refresh) {
+        _CredentialHolder_value.set(this, void 0);
+        _CredentialHolder_isValid.set(this, void 0);
+        _CredentialHolder_refresh.set(this, void 0);
+        _CredentialHolder_isRefreshing.set(this, false);
+        __classPrivateFieldSet(this, _CredentialHolder_value, Promise.resolve(initialValue), "f");
+        __classPrivateFieldSet(this, _CredentialHolder_refresh, refresh, "f");
+        __classPrivateFieldSet(this, _CredentialHolder_isValid, isValid, "f");
+    }
+    async get(refresh = false) {
+        if (refresh) {
+            this.refresh();
+            return __classPrivateFieldGet(this, _CredentialHolder_value, "f");
+        }
+        const value = await __classPrivateFieldGet(this, _CredentialHolder_value, "f");
+        if (!__classPrivateFieldGet(this, _CredentialHolder_isValid, "f").call(this, value)) {
+            this.refresh();
+        }
+        // must return this.#value and not value, since calling `this.refresh()` above will replace
+        // the value with a new promise.
+        return __classPrivateFieldGet(this, _CredentialHolder_value, "f");
+    }
+    refresh() {
+        if (__classPrivateFieldGet(this, _CredentialHolder_isRefreshing, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CredentialHolder_isRefreshing, true, "f");
+        // refresh works by replacing the existing #value promise with a new one which is pending
+        // on a new promise which is refreshing the credential.
+        // multiple calls to refresh() will be ignored until the first refresh is complete.
+        __classPrivateFieldSet(this, _CredentialHolder_value, new Promise((resolve, reject) => __classPrivateFieldGet(this, _CredentialHolder_refresh, "f").call(this).then((refreshed) => {
+            if (!refreshed) {
+                reject(new Error('Refreshed credential is undefined'));
+                return;
+            }
+            if (!__classPrivateFieldGet(this, _CredentialHolder_isValid, "f").call(this, refreshed)) {
+                reject(new Error('Refreshed credential is invalid'));
+                return;
+            }
+            resolve(refreshed);
+        }).catch((error) => reject(error)).finally(() => {
+            __classPrivateFieldSet(this, _CredentialHolder_isRefreshing, false, "f");
+        })), "f");
+        return;
+    }
+}
+exports.CredentialHolder = CredentialHolder;
+_CredentialHolder_value = new WeakMap(), _CredentialHolder_isValid = new WeakMap(), _CredentialHolder_refresh = new WeakMap(), _CredentialHolder_isRefreshing = new WeakMap();

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

@@ -0,0 +1,15 @@
+import { OutboundMiddleware, FetchLike } from '../types.js';
+import { Connection } from '../../services/platform/mod.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.
+ */
+export declare class FetchBuilder {
+    #private;
+    middlewares: OutboundMiddleware[];
+    constructor(fetch: FetchLike, cnx: Connection);
+    use(fn: OutboundMiddleware): void;
+    build(): FetchLike;
+}
+//# sourceMappingURL=FetchBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FetchBuilder.d.ts","sourceRoot":"","sources":["../../../../src/src/connection/internal/FetchBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAI5D;;;;GAIG;AACH,qBAAa,YAAY;;IACrB,WAAW,EAAE,kBAAkB,EAAE,CAAC;gBAKtB,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,UAAU;IAM7C,GAAG,CAAC,EAAE,EAAE,kBAAkB;IAI1B,KAAK,IAAI,SAAS;CAWrB"}

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 mod_js_1 = require("../../../deps/jsr.io/@std/cache/0.2.0/mod.js");
+const mod_js_2 = 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 mod_js_1.LruCache(100);
+    }
+    getClient(credential) {
+        const cached = this.cache.get(credential.id);
+        if (cached) {
+            return cached;
+        }
+        switch (credential.type) {
+            case mod_js_2.credentialv1alpha1.Credential_Type.Certificate:
+                return this.newMtlsClient(credential);
+            default:
+                return undefined;
+        }
+    }
+    newMtlsClient(credential) {
+        const data = (0, protobuf_1.create)(mod_js_2.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"}