@versori/run 0.2.28 → 0.3.0-veta.1

package/esm/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts

@@ -0,0 +1,129 @@
+import type { MemoizationCache } from "./memoize.js";
+/**
+ * Time-to-live cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Automatically removes entries after the configured amount of time elapses.
+ *
+ * @typeParam K The type of the cache keys.
+ * @typeParam V The type of the cache values.
+ *
+ * @example Usage
+ * ```ts
+ * import { TtlCache } from "@std/cache/ttl-cache";
+ * import { assertEquals } from "@std/assert/equals";
+ * import { delay } from "@std/async/delay";
+ *
+ * const cache = new TtlCache<string, number>(1000);
+ *
+ * cache.set("a", 1);
+ * assertEquals(cache.size, 1);
+ * await delay(2000);
+ * assertEquals(cache.size, 0);
+ * ```
+ */
+export declare class TtlCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param defaultTtl The default time-to-live in milliseconds. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     */
+    constructor(defaultTtl: number);
+    /**
+     * Set a value in the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The cache key
+     * @param value The value to set
+     * @param ttl A custom time-to-live. If supplied, overrides the cache's
+     * default TTL for this entry. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     * @returns `this` for chaining.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { delay } from "@std/async/delay";
+     *
+     * const cache = new TtlCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assertEquals(cache.get("a"), 1);
+     *
+     * await delay(200);
+     * assertEquals(cache.get("a"), undefined);
+     * ```
+     */
+    set(key: K, value: V, ttl?: number): this;
+    /**
+     * Deletes the value associated with the given key.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to delete.
+     * @returns `true` if the key was deleted, `false` otherwise.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.delete("a");
+     * assertEquals(cache.has("a"), false);
+     * ```
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear(): void;
+    /**
+     * Automatically clears all remaining timeouts once the cache goes out of
+     * scope if the cache is declared with `using`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * let c: TtlCache<string, number>;
+     * {
+     *  using cache = new TtlCache<string, number>(1000);
+     *  cache.set("a", 1);
+     *  c = cache;
+     * }
+     * assertEquals(c.size, 0);
+     * ```
+     */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=ttl_cache.d.ts.map

package/esm/deps/jsr.io/@std/cache/0.2.0/ttl_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl_cache.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/ttl_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IAIjC;;;;;;;;OAQG;gBACS,UAAU,EAAE,MAAM;IAK9B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAyB,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;OAmBG;IACM,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAMhC;;;;;;;;;;;;;;;;;OAiBG;IACM,KAAK,IAAI,IAAI;IAQtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB"}

package/esm/deps/jsr.io/@std/cache/0.2.0/ttl_cache.js

@@ -0,0 +1,162 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+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 _TtlCache_defaultTtl, _TtlCache_timeouts;
+/**
+ * Time-to-live cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * Automatically removes entries after the configured amount of time elapses.
+ *
+ * @typeParam K The type of the cache keys.
+ * @typeParam V The type of the cache values.
+ *
+ * @example Usage
+ * ```ts
+ * import { TtlCache } from "@std/cache/ttl-cache";
+ * import { assertEquals } from "@std/assert/equals";
+ * import { delay } from "@std/async/delay";
+ *
+ * const cache = new TtlCache<string, number>(1000);
+ *
+ * cache.set("a", 1);
+ * assertEquals(cache.size, 1);
+ * await delay(2000);
+ * assertEquals(cache.size, 0);
+ * ```
+ */
+export class TtlCache extends Map {
+    /**
+     * Constructs a new instance.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param defaultTtl The default time-to-live in milliseconds. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     */
+    constructor(defaultTtl) {
+        super();
+        _TtlCache_defaultTtl.set(this, void 0);
+        _TtlCache_timeouts.set(this, new Map());
+        __classPrivateFieldSet(this, _TtlCache_defaultTtl, defaultTtl, "f");
+    }
+    /**
+     * Set a value in the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The cache key
+     * @param value The value to set
+     * @param ttl A custom time-to-live. If supplied, overrides the cache's
+     * default TTL for this entry. This value must
+     * be equal to or greater than 0. Its limit is determined by the current
+     * runtime's {@linkcode setTimeout} implementation.
+     * @returns `this` for chaining.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     * import { delay } from "@std/async/delay";
+     *
+     * const cache = new TtlCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assertEquals(cache.get("a"), 1);
+     *
+     * await delay(200);
+     * assertEquals(cache.get("a"), undefined);
+     * ```
+     */
+    set(key, value, ttl = __classPrivateFieldGet(this, _TtlCache_defaultTtl, "f")) {
+        clearTimeout(__classPrivateFieldGet(this, _TtlCache_timeouts, "f").get(key));
+        super.set(key, value);
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").set(key, setTimeout(() => this.delete(key), ttl));
+        return this;
+    }
+    /**
+     * Deletes the value associated with the given key.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to delete.
+     * @returns `true` if the key was deleted, `false` otherwise.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.delete("a");
+     * assertEquals(cache.has("a"), false);
+     * ```
+     */
+    delete(key) {
+        clearTimeout(__classPrivateFieldGet(this, _TtlCache_timeouts, "f").get(key));
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").delete(key);
+        return super.delete(key);
+    }
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { TtlCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new TtlCache<string, number>(1000);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear() {
+        for (const timeout of __classPrivateFieldGet(this, _TtlCache_timeouts, "f").values()) {
+            clearTimeout(timeout);
+        }
+        __classPrivateFieldGet(this, _TtlCache_timeouts, "f").clear();
+        super.clear();
+    }
+    /**
+     * Automatically clears all remaining timeouts once the cache goes out of
+     * scope if the cache is declared with `using`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { TtlCache } from "@std/cache/ttl-cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * let c: TtlCache<string, number>;
+     * {
+     *  using cache = new TtlCache<string, number>(1000);
+     *  cache.set("a", 1);
+     *  c = cache;
+     * }
+     * assertEquals(c.size, 0);
+     * ```
+     */
+    [(_TtlCache_defaultTtl = new WeakMap(), _TtlCache_timeouts = new WeakMap(), Symbol.dispose)]() {
+        this.clear();
+    }
+}

package/esm/src/connection/DirectConnectionFactory.d.ts

@@ -0,0 +1,29 @@
+import { Client } from '@connectrpc/connect';
+import { RequestHandler } from 'express';
+import { Logger } from '../observability/mod.js';
+import { credentialv1alpha1, tokensv1, oauth1v1 } from '../services/credentials/mod.js';
+import { Connection } from '../services/platform/mod.js';
+import { HttpClientFactory } from './internal/HttpClientFactory.js';
+import { ConnectionFactory, FetchLike } from './types.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}.
+ */
+export declare class DirectConnectionFactory implements ConnectionFactory {
+    private readonly httpClientFactory;
+    private readonly credentials;
+    private readonly tokens;
+    private readonly oauth1;
+    private readonly logger;
+    private readonly outboundConnectionFactory;
+    private readonly expressInboundConnectionFactory;
+    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>;
+    handler(cnx: Connection): Promise<RequestHandler>;
+    static fromEnv(logger: Logger): DirectConnectionFactory;
+}
+//# sourceMappingURL=DirectConnectionFactory.d.ts.map

package/esm/src/connection/DirectConnectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectConnectionFactory.d.ts","sourceRoot":"","sources":["../../../src/src/connection/DirectConnectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAGpE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG1D;;;;;;;GAOG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;IAKzD,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;IAR3B,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IACtE,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAA2B;gBAGtD,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;IAkBnC,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAI5C,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC;IAIjD,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB;CAqB1D"}

package/esm/src/connection/DirectConnectionFactory.js

@@ -0,0 +1,82 @@
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import { credentialv1alpha1, tokensv1, oauth1v1 } from '../services/credentials/mod.js';
+import { HttpClientFactory } from './internal/HttpClientFactory.js';
+import { ExpressInboundConnectionFactory as InboundConnectionFactory } from './internal/InboundConnectionFactory.js';
+import { OutboundConnectionFactory } from './internal/OutboundConnectionFactory.js';
+import { envVarCredsBaseURL } from '../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}.
+ */
+export 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(httpClientFactory, credentials, tokens, oauth1, logger);
+        this.expressInboundConnectionFactory = new InboundConnectionFactory(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(envVarCredsBaseURL) || 'http://localhost:9000';
+        const transport = createGrpcTransport({
+            baseUrl,
+        });
+        const credentials = createClient(credentialv1alpha1.CredentialService, transport);
+        const tokens = createClient(tokensv1.TokenService, transport);
+        const oauth1 = createClient(oauth1v1.AuthorizationService, transport);
+        const httpClientFactory = new HttpClientFactory();
+        return new DirectConnectionFactory(httpClientFactory, credentials, tokens, oauth1, logger);
+    }
+}

package/esm/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/esm/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/esm/src/connection/DynamicFetchFactory.js

@@ -0,0 +1,113 @@
+import { LruCache } from '../../deps/jsr.io/@std/cache/0.2.0/lru_cache.js';
+export 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 LruCache(100);
+        this.cnxCache = new LruCache(100);
+        this.handlerCache = new 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;
+    }
+}

package/esm/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/esm/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/esm/src/connection/StaticFetchFactory.js

@@ -0,0 +1,35 @@
+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;
+function passthroughHandler(_req, _res, next) {
+    next();
+}
+export 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");
+    }
+}
+_StaticFetchFactory_fetch = new WeakMap(), _StaticFetchFactory_baseUrl = new WeakMap(), _StaticFetchFactory_handler = new WeakMap();

package/esm/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/esm/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"}