@stigg/cache-runtime 2.0.0

package/dist/services/inMemoryEntitlementsService.js

@@ -0,0 +1,152 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryEntitlementsService = void 0;
+const entitlementsService_1 = require("./entitlementsService");
+const cache_core_1 = require("@stigg/cache-core");
+const lodash_1 = require("lodash");
+const WS_ERROR_RECONNECT_INTERVAL_MS = 5 * 1000;
+class InMemoryEntitlementsService extends entitlementsService_1.EntitlementsService {
+    constructor(cacheService, entitlementsApi, hooks, loggerService, entitlementsTimeout, evaluator, offline, errorHandler) {
+        super(entitlementsApi, loggerService, cacheService, entitlementsTimeout, evaluator, offline, errorHandler);
+        this.cacheService = cacheService;
+        this.hooks = hooks;
+        this.entitlementsSubscription = null;
+        this.usageSubscription = null;
+        this.packagePublishedSubscription = null;
+    }
+    init() {
+        this.loggerService.log('Subscribing to real-time updates');
+        this.cleanup();
+        this.entitlementsSubscription = this.entitlementsApi.subscribeEntitlementsUpdated().subscribe((value) => this.onEntitlementsUpdated(value), (err) => this.websocketErrorHandling(err));
+        this.usageSubscription = this.entitlementsApi.subscribeUsageUpdated().subscribe((value) => this.onUsageUpdated(value), (err) => this.websocketErrorHandling(err));
+        this.packagePublishedSubscription = this.entitlementsApi.subscribePackagePublished().subscribe((value) => this.onPackagePublished(value), (err) => this.websocketErrorHandling(err));
+        this.isInitialized = true;
+    }
+    websocketErrorHandling(err) {
+        const isErrorRecoverable = this.isErrorRecoverable(err);
+        const actionDescription = isErrorRecoverable ? 'retrying to connect' : 'giving up permanently';
+        const errorReason = err.message || err.reason;
+        const logMessage = `Received error while handling websocket events. Error: ${errorReason} - ${actionDescription}`;
+        const isThrottleError = errorReason.includes('ThrottlerException');
+        if (isThrottleError) {
+            this.loggerService.log(logMessage);
+        }
+        else {
+            this.loggerService.error(logMessage);
+        }
+        if (isErrorRecoverable) {
+            this.cleanup();
+            setTimeout(() => this.init(), WS_ERROR_RECONNECT_INTERVAL_MS);
+        }
+    }
+    cleanup() {
+        var _a, _b, _c;
+        (_a = this.entitlementsSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this.entitlementsSubscription = null;
+        (_b = this.usageSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        this.usageSubscription = null;
+        (_c = this.packagePublishedSubscription) === null || _c === void 0 ? void 0 : _c.unsubscribe();
+        this.packagePublishedSubscription = null;
+        this.cacheService.clearCache();
+        this.isInitialized = false;
+    }
+    onEntitlementsUpdated(event) {
+        const { customerId, resourceId, accessDeniedReason, entitlements } = event;
+        this.loggerService.debug(`Entitlements updated event arrived.`, {
+            customerId,
+            resourceId,
+            accessDeniedReason,
+            entitlementsCount: entitlements.length,
+        });
+        // Check for empty entitlements before mapping/caching
+        if (entitlements.length === 0 && !accessDeniedReason) {
+            this.loggerService.debug(`entitlements updated event contains no entitlements and no accessDeniedReason.`, {
+                customerId,
+                resourceId,
+                accessDeniedReason,
+            });
+            // we don't know the reason for empty entitlements, so we invalidate the cache to fetch
+            // fresh accessDeniedReason on next request
+            this.cacheService.purge({ customerId, resourceId });
+            return;
+        }
+        const entitlementsTimestamp = this.getEntitlementsUpdatedAtTimestamp({
+            entitlements,
+            customerId,
+            resourceId,
+        });
+        this.cacheService.setCustomer({
+            customerId,
+            resourceId,
+            entitlements,
+            accessDeniedReason,
+            entitlementsTimestamp: entitlementsTimestamp.getTime(),
+        });
+        this.hooks.onEntitlementsUpdated(event);
+    }
+    onUsageUpdated(event) {
+        const { customerId, resourceId, entitlementReference, usage } = event;
+        const { currentUsage, usagePeriodStart, usagePeriodEnd, usageUpdatedAt } = usage;
+        this.loggerService.debug(`Usage updated event arrived.`, {
+            customerId,
+            resourceId,
+            entitlementType: entitlementReference.type,
+            entitlementId: entitlementReference.id,
+            currentUsage,
+            usagePeriodStart,
+            usagePeriodEnd,
+        });
+        // Typed as a Date by the cache contract; the GraphQL fragment's `any` used to hide that
+        // a raw epoch was being passed here.
+        const usageTimestamp = new Date(usageUpdatedAt !== null && usageUpdatedAt !== void 0 ? usageUpdatedAt : Date.now());
+        this.cacheService.updateUsage({
+            customerId,
+            resourceId,
+            entitlementReference,
+            usageTimestamp,
+            usage: {
+                currentUsage,
+                usagePeriodStart,
+                usagePeriodEnd,
+            },
+        });
+        const updatedEntitlement = this.cacheService.getCustomerEntitlement({
+            query: entitlementReference,
+            customerId,
+            resourceId,
+        });
+        // Only feature entitlements carry a usage the host can report on
+        if (updatedEntitlement.entitlement && (0, cache_core_1.isFeatureEntitlement)(updatedEntitlement.entitlement)) {
+            this.hooks.onUsageUpdated(customerId, resourceId !== null && resourceId !== void 0 ? resourceId : null, updatedEntitlement.entitlement);
+        }
+    }
+    isErrorRecoverable(err) {
+        const isInvalidAPIKeyError = err.reason === 'Invalid API key';
+        return !isInvalidAPIKeyError;
+    }
+    clearCache() {
+        return this.cacheService.clearCache();
+    }
+    onPackagePublished(event) {
+        this.loggerService.debug(`Package published event arrived.`, { data: event.payload });
+        if (event.affectsAllCustomers) {
+            this.loggerService.log('Clearing cache due to package published event');
+            this.clearCache();
+        }
+        this.hooks.onPackagePublished(event.payload);
+    }
+    async refetchEntityEntitlementsAfterCacheMiss(params) {
+        return this.refetchEntitlements(params);
+    }
+}
+exports.InMemoryEntitlementsService = InMemoryEntitlementsService;
+__decorate([
+    (0, cache_core_1.ReuseOngoingExecution)(({ customerId, resourceId }) => (0, lodash_1.compact)([customerId, resourceId]).join(':'))
+], InMemoryEntitlementsService.prototype, "refetchEntityEntitlementsAfterCacheMiss", null);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/inMemoryLruCacheService.d.ts

@@ -0,0 +1,6 @@
+import { InMemoryCacheService, CacheInstrumentation, CacheMapper } from '@stigg/cache-core';
+export declare class InMemoryLruCacheService<Input> extends InMemoryCacheService<Input> {
+    private static readonly textEncoder;
+    static getApproxSizeBytes(obj: any): number;
+    constructor(maxSizeBytes: number, instrumentation: CacheInstrumentation, cacheMapper: CacheMapper<Input>);
+}

package/dist/services/inMemoryLruCacheService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryLruCacheService = void 0;
+const lru_cache_1 = require("lru-cache");
+const cache_core_1 = require("@stigg/cache-core");
+class InMemoryLruCacheService extends cache_core_1.InMemoryCacheService {
+    static getApproxSizeBytes(obj) {
+        return InMemoryLruCacheService.textEncoder.encode(typeof obj === 'string' ? obj : JSON.stringify(obj)).length;
+    }
+    constructor(maxSizeBytes, instrumentation, cacheMapper) {
+        const store = new lru_cache_1.LRUCache({
+            maxSize: maxSizeBytes,
+            sizeCalculation: (value) => InMemoryLruCacheService.getApproxSizeBytes(value),
+        });
+        super(store, instrumentation, cacheMapper);
+    }
+}
+exports.InMemoryLruCacheService = InMemoryLruCacheService;
+InMemoryLruCacheService.textEncoder = new TextEncoder();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5NZW1vcnlMcnVDYWNoZVNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5NZW1vcnlMcnVDYWNoZVNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEseUNBQXFDO0FBQ3JDLGtEQUF3SDtBQUV4SCxNQUFhLHVCQUErQixTQUFRLGlDQUEyQjtJQUc3RSxNQUFNLENBQUMsa0JBQWtCLENBQUMsR0FBUTtRQUNoQyxPQUFPLHVCQUF1QixDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsT0FBTyxHQUFHLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDaEgsQ0FBQztJQUVELFlBQVksWUFBb0IsRUFBRSxlQUFxQyxFQUFFLFdBQStCO1FBQ3RHLE1BQU0sS0FBSyxHQUFHLElBQUksb0JBQVEsQ0FBcUM7WUFDN0QsT0FBTyxFQUFFLFlBQVk7WUFDckIsZUFBZSxFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyx1QkFBdUIsQ0FBQyxrQkFBa0IsQ0FBQyxLQUFLLENBQUM7U0FDOUUsQ0FBQyxDQUFDO1FBQ0gsS0FBSyxDQUFDLEtBQUssRUFBRSxlQUFlLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDN0MsQ0FBQzs7QUFiSCwwREFjQztBQWJ5QixtQ0FBVyxHQUFHLElBQUksV0FBVyxFQUFFLENBQUMifQ==

package/dist/services/initializationStateTracker.d.ts

@@ -0,0 +1,25 @@
+export declare enum InitializationState {
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESS = "READY",
+    FAILED = "FAILED"
+}
+/**
+ * How the tracker reports initialization outcome to the host. node-server-sdk's event emitter
+ * implements this, so consumers keep receiving the public `initializeSuccessfully` /
+ * `initializeFailed` events.
+ */
+export interface InitializationHooks {
+    onInitialized(): void;
+    onInitializationFailed(err: any): void;
+}
+export declare class InitializationStateTracker {
+    private readonly hooks;
+    initializationStatus: InitializationState;
+    initFailureError: Error | null;
+    private initializationPromise;
+    private settle;
+    constructor(hooks: InitializationHooks);
+    getInitializationPromise(): Promise<void>;
+    signalSuccessInit(): void;
+    signalFailedInit(err: any): void;
+}

package/dist/services/initializationStateTracker.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializationStateTracker = exports.InitializationState = void 0;
+var InitializationState;
+(function (InitializationState) {
+    InitializationState["IN_PROGRESS"] = "IN_PROGRESS";
+    InitializationState["SUCCESS"] = "READY";
+    InitializationState["FAILED"] = "FAILED";
+})(InitializationState || (exports.InitializationState = InitializationState = {}));
+class InitializationStateTracker {
+    constructor(hooks) {
+        this.hooks = hooks;
+        this.initializationStatus = InitializationState.IN_PROGRESS;
+        this.initFailureError = null;
+        this.initializationPromise = null;
+        this.settle = null;
+    }
+    getInitializationPromise() {
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        if (this.initializationStatus === InitializationState.SUCCESS) {
+            return Promise.resolve();
+        }
+        if (this.initializationStatus === InitializationState.FAILED) {
+            return Promise.reject(this.initFailureError);
+        }
+        this.initializationPromise = new Promise((resolve, reject) => {
+            this.settle = { resolve, reject };
+        });
+        return this.initializationPromise;
+    }
+    signalSuccessInit() {
+        var _a;
+        this.initializationStatus = InitializationState.SUCCESS;
+        (_a = this.settle) === null || _a === void 0 ? void 0 : _a.resolve();
+        this.hooks.onInitialized();
+    }
+    signalFailedInit(err) {
+        var _a;
+        // onInitialized() runs host listeners, and one of them throwing lands back here through the
+        // caller's catch. Callers have already seen the promise resolve, so this cannot become a failure.
+        if (this.initializationStatus === InitializationState.SUCCESS) {
+            return;
+        }
+        this.initializationStatus = InitializationState.FAILED;
+        this.initFailureError = err;
+        (_a = this.settle) === null || _a === void 0 ? void 0 : _a.reject(err);
+        this.hooks.onInitializationFailed(err);
+    }
+}
+exports.InitializationStateTracker = InitializationStateTracker;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/loggerService.d.ts

@@ -0,0 +1,27 @@
+import { LoggerExtra, SlimLogger } from '@stigg/cache-core';
+export type Extra = LoggerExtra;
+/** Aliases SlimLogger so the services taking a cache-core logger accept this by declaration, not by structural coincidence. */
+export type Logger = SlimLogger;
+export interface LogConfiguration {
+    logger: Logger;
+    logLevel: LogLevel;
+}
+export declare enum LogLevel {
+    ALL = "ALL",
+    NONE = "NONE",
+    LOG = "LOG",
+    ERROR = "ERROR"
+}
+export declare class LoggerService implements Logger {
+    private readonly logger;
+    private readonly logLevel;
+    private readonly prefix;
+    private instanceId?;
+    constructor(logger: Logger, logLevel: LogLevel, prefix: string);
+    error(message: string, error?: Extra): void;
+    log(message: string, object?: Extra): void;
+    debug(message: string, object?: Extra): void;
+    prependPrefix(message: string): string;
+    setInstanceId(instanceId: string): void;
+    getInstanceId(): string | undefined;
+}

package/dist/services/loggerService.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = exports.LogLevel = void 0;
+const includes_1 = __importDefault(require("lodash/includes"));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ALL"] = "ALL";
+    LogLevel["NONE"] = "NONE";
+    LogLevel["LOG"] = "LOG";
+    LogLevel["ERROR"] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class LoggerService {
+    constructor(logger, logLevel, prefix) {
+        this.logger = logger;
+        this.logLevel = logLevel;
+        this.prefix = prefix;
+    }
+    error(message, error) {
+        if (this.logLevel !== LogLevel.NONE) {
+            const aMessage = this.prependPrefix(message);
+            if (error) {
+                this.logger.error(aMessage, error);
+            }
+            else {
+                this.logger.error(aMessage);
+            }
+        }
+    }
+    log(message, object) {
+        if (!(0, includes_1.default)([LogLevel.ERROR, LogLevel.NONE], this.logLevel)) {
+            const aMessage = this.prependPrefix(message);
+            if (object) {
+                this.logger.log(aMessage, object);
+            }
+            else {
+                this.logger.log(aMessage);
+            }
+        }
+    }
+    debug(message, object) {
+        if ((0, includes_1.default)([LogLevel.LOG, LogLevel.ALL], this.logLevel)) {
+            const aMessage = this.prependPrefix(message);
+            if (object) {
+                this.logger.debug(aMessage, object);
+            }
+            else {
+                this.logger.debug(aMessage);
+            }
+        }
+    }
+    prependPrefix(message) {
+        return `${this.prefix} [iid:${this.instanceId || '-'}] ${message}`;
+    }
+    setInstanceId(instanceId) {
+        this.instanceId = instanceId;
+    }
+    getInstanceId() {
+        return this.instanceId;
+    }
+}
+exports.LoggerService = LoggerService;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/redisEntitlementsService.d.ts

@@ -0,0 +1,16 @@
+import { RuntimeErrorHandler } from './runtimeErrorHandler';
+import { EntitlementsService } from './entitlementsService';
+import { RefetchEntityEntitlementsAfterCacheMissParams } from './entitlementsService.utils';
+import { RedisCacheService } from '@stigg/cache-redis-store';
+import { SlimLogger } from '@stigg/cache-core';
+import { EntitlementEvaluator } from '@stigg/entitlements-runtime';
+import { CacheableInput, EntitlementsTransport } from '../types/transport';
+export declare class RedisEntitlementsService<Input extends CacheableInput, TPackagePublished = unknown> extends EntitlementsService<Input, TPackagePublished> {
+    protected readonly cacheService: RedisCacheService<Input>;
+    protected readonly loggerService: SlimLogger;
+    constructor(cacheService: RedisCacheService<Input>, entitlementsApi: EntitlementsTransport<Input, TPackagePublished>, loggerService: SlimLogger, entitlementsTimeout: number, evaluator: EntitlementEvaluator, offline: boolean, errorHandler: RuntimeErrorHandler);
+    protected refetchEntityEntitlementsAfterCacheMiss(params: RefetchEntityEntitlementsAfterCacheMissParams): Promise<import("@stigg/cache-core").EntitlementsResponse>;
+    clearCache(): Promise<void>;
+    init(): void | Promise<void>;
+    cleanup(): void | Promise<void>;
+}

package/dist/services/redisEntitlementsService.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisEntitlementsService = void 0;
+const entitlementsService_1 = require("./entitlementsService");
+const cache_core_1 = require("@stigg/cache-core");
+const lodash_1 = require("lodash");
+class RedisEntitlementsService extends entitlementsService_1.EntitlementsService {
+    constructor(cacheService, entitlementsApi, loggerService, entitlementsTimeout, evaluator, offline, errorHandler) {
+        super(entitlementsApi, loggerService, cacheService, entitlementsTimeout, evaluator, offline, errorHandler);
+        this.cacheService = cacheService;
+        this.loggerService = loggerService;
+        this.isInitialized = true; // redis is always considered as initialized
+    }
+    async refetchEntityEntitlementsAfterCacheMiss(params) {
+        if (!this.cacheService.isClientConnected()) {
+            throw new Error('Redis is not connected. Cannot refetch entitlements.');
+        }
+        const { distributedRefetchEntitlementsService } = this.cacheService;
+        if (!distributedRefetchEntitlementsService) {
+            return this.refetchEntitlements(params);
+        }
+        const { customerId, resourceId } = params;
+        const reloadFromApi = () => this.refetchEntitlements(params);
+        const loadFromCache = () => this.cacheService.getCustomerEntitlements({ customerId, resourceId });
+        return distributedRefetchEntitlementsService.executeOnceAcrossMultipleProcesses({
+            customerId,
+            resourceId,
+            reloadFromApi,
+            loadFromCache,
+        });
+    }
+    clearCache() {
+        // Clearing persisted cache is not supported
+        return Promise.resolve();
+    }
+    init() {
+        // Real time updated via sdk is not supported with persisted cache
+        return;
+    }
+    cleanup() {
+        return this.cacheService.cleanup();
+    }
+}
+exports.RedisEntitlementsService = RedisEntitlementsService;
+__decorate([
+    (0, cache_core_1.ReuseOngoingExecution)(({ customerId, resourceId }) => (0, lodash_1.compact)([customerId, resourceId]).join(':'))
+], RedisEntitlementsService.prototype, "refetchEntityEntitlementsAfterCacheMiss", null);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/services/runtimeErrorHandler.d.ts

@@ -0,0 +1,43 @@
+import { SlimLogger } from '@stigg/cache-core';
+import { ClassifiedError, TransportErrorClassifier } from '../types/errors';
+/** Carries the failure's code and trace so hosts can map it onto their own error vocabulary. */
+export declare class RuntimeError extends Error {
+    readonly errorCode?: string | undefined;
+    readonly traceId?: string | undefined;
+    constructor(message: string, errorCode?: string | undefined, traceId?: string | undefined);
+}
+/**
+ * How a host is told about a transport failure. Exactly one of the two fires per failure —
+ * `onUnauthenticated` for an invalid key, `onNetworkRequestFailed` for anything else — so a host
+ * that only wants counters never has to wrap anything itself.
+ */
+export interface RuntimeErrorHooks {
+    onUnauthenticated(): void;
+    onNetworkRequestFailed(error: ClassifiedError): void;
+}
+/**
+ * The failure contract shared by every host of the runtime: classify once, report once, then either
+ * answer with the caller's fallback or rethrow as a `RuntimeError`.
+ */
+export declare class RuntimeErrorHandler {
+    private readonly loggerService;
+    private readonly hooks;
+    private readonly classifier;
+    constructor(loggerService: SlimLogger, hooks: RuntimeErrorHooks, classifier: TransportErrorClassifier);
+    /**
+     * A read never fails the caller: the failure is reported — which is what feeds any host counters —
+     * and the caller is answered with its fallback. This is the runtime's never-throw promise, so
+     * every host reads through here rather than reimplementing it.
+     */
+    readOrFallback<T>(errorMessagePrefix: string, read: () => Promise<T>, fallback: () => T): Promise<T>;
+    /** Startup has no fallback answer, so it throws — but reports first, onto a read's own counters. */
+    runOrThrow<T>(errorMessagePrefix: string, run: () => Promise<T>): Promise<T>;
+    /**
+     * An invalid key is reported on its own channel; the message it reads by is fixed here too.
+     * Classification and the host's listeners are both fallible, and neither may replace the failure
+     * the caller is being told about — so each is tolerated and the classification still stands.
+     */
+    private report;
+    /** Each reporting channel fails alone, so one bad listener cannot silence the other. */
+    private tolerate;
+}

package/dist/services/runtimeErrorHandler.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeErrorHandler = exports.RuntimeError = void 0;
+/** Carries the failure's code and trace so hosts can map it onto their own error vocabulary. */
+class RuntimeError extends Error {
+    constructor(message, errorCode, traceId) {
+        super(message);
+        this.errorCode = errorCode;
+        this.traceId = traceId;
+    }
+}
+exports.RuntimeError = RuntimeError;
+/**
+ * The failure contract shared by every host of the runtime: classify once, report once, then either
+ * answer with the caller's fallback or rethrow as a `RuntimeError`.
+ */
+class RuntimeErrorHandler {
+    constructor(loggerService, hooks, classifier) {
+        this.loggerService = loggerService;
+        this.hooks = hooks;
+        this.classifier = classifier;
+    }
+    /**
+     * A read never fails the caller: the failure is reported — which is what feeds any host counters —
+     * and the caller is answered with its fallback. This is the runtime's never-throw promise, so
+     * every host reads through here rather than reimplementing it.
+     */
+    async readOrFallback(errorMessagePrefix, read, fallback) {
+        try {
+            return await read();
+        }
+        catch (err) {
+            this.report(err);
+            this.tolerate(() => this.loggerService.error(`${errorMessagePrefix}: ${toErrorMessage(err)}`, err));
+            return fallback();
+        }
+    }
+    /** Startup has no fallback answer, so it throws — but reports first, onto a read's own counters. */
+    async runOrThrow(errorMessagePrefix, run) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            const { errorMessage, errorCode, traceId, isTimeout } = this.report(err);
+            if (isTimeout) {
+                throw new RuntimeError(`${errorMessagePrefix}: Request timed out`, 'RequestTimeout');
+            }
+            throw new RuntimeError(`${errorMessagePrefix}: ${errorMessage}`, errorCode, traceId);
+        }
+    }
+    /**
+     * An invalid key is reported on its own channel; the message it reads by is fixed here too.
+     * Classification and the host's listeners are both fallible, and neither may replace the failure
+     * the caller is being told about — so each is tolerated and the classification still stands.
+     */
+    report(err) {
+        let classified = {
+            errorMessage: toErrorMessage(err),
+            isUnauthenticated: false,
+            isTimeout: false,
+        };
+        this.tolerate(() => {
+            classified = this.classifier.classify(err);
+        });
+        if (classified.isUnauthenticated) {
+            this.tolerate(() => this.hooks.onUnauthenticated());
+            return Object.assign(Object.assign({}, classified), { errorMessage: 'Authentication failed. Double check your API key.' });
+        }
+        this.tolerate(() => this.hooks.onNetworkRequestFailed(classified));
+        return classified;
+    }
+    /** Each reporting channel fails alone, so one bad listener cannot silence the other. */
+    tolerate(report) {
+        try {
+            report();
+        }
+        catch (_a) {
+            // a host listener or the logger itself threw — there is nowhere left to report that
+        }
+    }
+}
+exports.RuntimeErrorHandler = RuntimeErrorHandler;
+/** A rejected read can carry anything, and `.message` on a string or on null would throw. */
+function toErrorMessage(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    const message = err === null || err === void 0 ? void 0 : err.message;
+    return typeof message === 'string' ? message : String(err);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * What a transport reports about a failure, in terms the read policy can act on.
+ * The wire-level shape of an error — GraphQL error arrays, network envelopes, HTTP
+ * responses — is the transport's business.
+ */
+export type ClassifiedError = {
+    errorMessage: string;
+    errorCode?: string;
+    traceId?: string;
+    /** Credentials were rejected, so retrying will not help. */
+    isUnauthenticated: boolean;
+    /** The request exceeded its deadline rather than being refused. */
+    isTimeout: boolean;
+    /**
+     * Carried through to the host untouched. The GraphQL transport puts the raw axios
+     * request and response here, and those carry the `X-API-KEY` header — so read named
+     * fields off them, never log or serialise one wholesale.
+     */
+    request?: unknown;
+    response?: unknown;
+};
+export interface TransportErrorClassifier {
+    classify(err: unknown): ClassifiedError;
+}

package/dist/types/errors.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=