@shiprev/server-sdk-node 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/client/shiprev-client.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShipRevClient = void 0;
 const token_verifier_1 = require("../auth/token-verifier");
 const usage_buffer_1 = require("../metering/usage-buffer");
+const degradation_1 = require("../mirror/degradation");
 const entitlement_mirror_1 = require("../mirror/entitlement-mirror");
 const adjudicator_1 = require("../ruling/adjudicator");
 const http_transport_1 = require("../transport/http.transport");
@@ -23,6 +24,10 @@ class ShipRevClient {
     expectations = null;
     /** Amounts reserved by this client, so `confirm()` without an amount confirms what was reserved. */
     reservedAmounts = new Map();
+    /** Effective levels last reported through `on_level_change`. */
+    reportedLevels = new Map();
+    /** Fires when the earliest `valid_until` passes while disconnected, to report the expiry. */
+    expiryTimer = null;
     constructor(options) {
         this.options = options;
         this.transport = new http_transport_1.HttpTransport({
@@ -30,7 +35,7 @@ class ShipRevClient {
             connectTimeoutMs: options.presets?.connect_timeout_ms,
         });
         this.tokenVerifier = new token_verifier_1.TokenVerifier(this.transport);
-        this.mirror = new entitlement_mirror_1.EntitlementMirror();
+        this.mirror = new entitlement_mirror_1.EntitlementMirror((organizationIds) => this.onMirrorChange(organizationIds));
         this.adjudicator = new adjudicator_1.Adjudicator(this.mirror, options.presets);
         this.supervisor = new connection_supervisor_1.ConnectionSupervisor({
             transport: this.transport,
@@ -74,6 +79,10 @@ class ShipRevClient {
      */
     async stop() {
         this.supervisor.stop();
+        if (this.expiryTimer) {
+            clearTimeout(this.expiryTimer);
+            this.expiryTimer = null;
+        }
         await this.usageBuffer.stop();
         this.active = false;
         this.isOnline = false;
@@ -115,9 +124,12 @@ class ShipRevClient {
         if (ruling.allowed || ruling.source === 'degraded' || !this.isOnline) {
             return ruling;
         }
-        // When the mirror misses the organization or capability and the client is online, ask the
-        // service for an authoritative ruling, then refill that organization from the snapshot endpoint.
-        if (this.supervisor.currentToken() && ruling.reason === 'capability_not_granted') {
+        // Two cases are not decided by the mirror, and the service is asked for an authoritative ruling:
+        // the mirror misses the organization or capability, or the write goes beyond the allowance the mirror
+        // counts (credits and overdraft are the service's state). The mirror's refusal stands when no ruling comes.
+        const beyondAllowance = (ruling.reason === 'quota_exhausted' || ruling.reason === 'plan_upgrade_required') &&
+            ruling.source === 'realtime';
+        if (this.supervisor.currentToken() && (ruling.reason === 'capability_not_granted' || beyondAllowance)) {
             try {
                 const remote = await this.supervisor.authorized((token) => this.transport.lookupAdjudication({
                     organization_id: options.organization_id,
@@ -145,12 +157,77 @@ class ShipRevClient {
         return ruling;
     }
     /**
-     * Guard for write operations (fail-closed).
-     * Intercepts action if write operation is denied (e.g. disconnected).
+     * The effective degradation level of an organization: the level of the mirror entry while the instance
+     * answers; without an answer, the entry's level until its `valid_until`, then at least `RESTRICT_USAGE`
+     * (marked `expired`). `undefined` when the mirror does not hold the organization. Synchronous, no I/O.
+     *
+     * It does not change `adjudicate()` or `guardWrite()`: a disconnected write is refused whatever the level.
+     */
+    effectiveLevel(organizationId) {
+        const entry = this.mirror.getOrganization(organizationId);
+        return entry ? (0, degradation_1.combineLevel)(entry, this.isOnline, Date.now()) : undefined;
+    }
+    /**
+     * Pulls one organization now (sharing a pull already in flight for it) and resolves with the level of the
+     * answer, `source: 'answer'`. When the pull fails or does not finish within `timeout_ms` (default: the
+     * connect timeout), resolves with `effectiveLevel()` as it stands. `undefined` when the instance no longer
+     * holds the organization, or the mirror never did.
+     */
+    async refresh(organizationId, options) {
+        const timeoutMs = options?.timeout_ms ?? this.options.presets?.connect_timeout_ms ?? 5000;
+        let timer;
+        try {
+            const pulled = await Promise.race([
+                this.supervisor.pullOrganization(organizationId),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('refresh timed out')), timeoutMs);
+                    timer.unref();
+                }),
+            ]);
+            // Only an answer the mirror took is an answer; a stale or unsupported one leaves the level as it stands.
+            if (pulled.outcome === 'applied' && pulled.entry)
+                return (0, degradation_1.combineLevel)(pulled.entry, true, Date.now());
+            if (pulled.outcome === 'removed')
+                return undefined;
+            return this.effectiveLevel(organizationId);
+        }
+        catch {
+            return this.effectiveLevel(organizationId);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * Sends a batch of usage events at once, outside the buffer and the backlog, and resolves with what the
+     * instance did with each. A 401 renews the token once, as every request does. Throws `UsageDeliveryError`
+     * when the batch did not reach the instance or it failed to process it (network error, timeout, 5xx); any
+     * other refusal throws as it came. Sending the same batch again is safe: events are deduplicated by key.
+     */
+    async sendUsage(events) {
+        try {
+            return await this.supervisor.authorized((token) => this.transport.sendUsageEvents(events, token));
+        }
+        catch (error) {
+            if (error instanceof http_transport_1.HttpError && error.status < 500)
+                throw error;
+            throw new types_1.UsageDeliveryError(error instanceof Error ? error.message : 'Usage events could not be delivered');
+        }
+    }
+    /**
+     * Guard for write operations (fail-closed): runs `action` only when the local ruling allows the write.
+     * A refusal for funds throws `QuotaExhaustedError` (`quota_exhausted`) or `PlanUpgradeRequiredError`
+     * (`plan_upgrade_required`, PROMPT_UPGRADE); any other refusal, a disconnected write included, throws
+     * `DisconnectedWriteError` as before.
      */
     async guardWrite(options, action) {
         const ruling = this.adjudicate({ ...options, operation: 'write' });
         if (!ruling.allowed) {
+            if (ruling.reason === 'quota_exhausted')
+                throw new types_1.QuotaExhaustedError();
+            if (ruling.reason === 'plan_upgrade_required')
+                throw new types_1.PlanUpgradeRequiredError();
             throw new types_1.DisconnectedWriteError(ruling.reason === 'disconnected_write'
                 ? 'Write operation denied while client is disconnected'
                 : `Write operation denied: ${ruling.reason ?? 'not allowed'}`);
@@ -245,7 +322,70 @@ class ShipRevClient {
         return this.transport;
     }
     applyOnline(online) {
+        const changed = this.isOnline !== online;
         this.isOnline = online;
+        if (changed) {
+            this.notifyLevels(this.mirror.organizationIds());
+            this.armExpiryTimer();
+        }
+    }
+    onMirrorChange(organizationIds) {
+        if (organizationIds === null) {
+            // The whole mirror was replaced: organizations that left it are forgotten.
+            for (const organizationId of [...this.reportedLevels.keys()]) {
+                if (!this.mirror.hasOrganization(organizationId))
+                    this.reportedLevels.delete(organizationId);
+            }
+        }
+        this.notifyLevels(organizationIds ?? this.mirror.organizationIds());
+        this.armExpiryTimer();
+        this.supervisor?.scheduleRenewals();
+    }
+    /** Reports every organization whose effective level differs from what was last reported. */
+    notifyLevels(organizationIds) {
+        const listener = this.options.on_level_change;
+        if (!listener)
+            return;
+        for (const organizationId of organizationIds) {
+            const level = this.effectiveLevel(organizationId);
+            if (!level) {
+                this.reportedLevels.delete(organizationId);
+                continue;
+            }
+            if ((0, degradation_1.sameLevel)(level, this.reportedLevels.get(organizationId)))
+                continue;
+            this.reportedLevels.set(organizationId, level);
+            try {
+                listener(organizationId, level);
+            }
+            catch {
+                // A listener failure never reaches the connection.
+            }
+        }
+    }
+    /** While disconnected, wakes up when the earliest entry still valid expires, to report it. */
+    armExpiryTimer() {
+        if (this.expiryTimer) {
+            clearTimeout(this.expiryTimer);
+            this.expiryTimer = null;
+        }
+        if (!this.options.on_level_change || this.isOnline || !this.active)
+            return;
+        const now = Date.now();
+        let next = Number.POSITIVE_INFINITY;
+        for (const organizationId of this.mirror.organizationIds()) {
+            const validUntil = (0, degradation_1.validUntilOf)(this.mirror.getOrganization(organizationId));
+            if (validUntil !== undefined && validUntil > now)
+                next = Math.min(next, validUntil);
+        }
+        if (next === Number.POSITIVE_INFINITY)
+            return;
+        this.expiryTimer = setTimeout(() => {
+            this.expiryTimer = null;
+            this.notifyLevels(this.mirror.organizationIds());
+            this.armExpiryTimer();
+        }, next - now);
+        this.expiryTimer.unref();
     }
     learnExpectations(token) {
         const expectations = (0, token_verifier_1.expectationsFromMachineToken)(token);

package/dist/mirror/degradation.d.ts

@@ -0,0 +1,22 @@
+import { DegradationLevel, EffectiveLevel, OrganizationSnapshot } from '../types';
+/** The five levels in their strict order; each blocks what the one before it blocks, and more. */
+export declare const DEGRADATION_LEVELS: readonly DegradationLevel[];
+/** What a replica past its `valid_until` is tightened to, at least. */
+export declare const EXPIRED_FLOOR: DegradationLevel;
+/**
+ * The level an organization entry carries. Anything that is not one of the five values (missing, another
+ * string, not a string) is read as RESTRICT_USAGE: a level this client does not know is never read as looser.
+ */
+export declare function levelOf(entry: OrganizationSnapshot): DegradationLevel;
+/** `valid_until` in epoch milliseconds, or undefined when missing or unparsable (read as already expired). */
+export declare function validUntilOf(entry: OrganizationSnapshot): number | undefined;
+/**
+ * Combines an entry with what the client observes:
+ *
+ * - answered (online, or a pull of this organization just succeeded): the entry's level;
+ * - not answered and `now < valid_until`: the entry's level, marked degraded;
+ * - not answered and `now >= valid_until` (or no usable `valid_until`): at least RESTRICT_USAGE, marked expired.
+ */
+export declare function combineLevel(entry: OrganizationSnapshot, answered: boolean, now: number): EffectiveLevel;
+/** True when two effective levels are the same triple. */
+export declare function sameLevel(a: EffectiveLevel | undefined, b: EffectiveLevel | undefined): boolean;

package/dist/mirror/degradation.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPIRED_FLOOR = exports.DEGRADATION_LEVELS = void 0;
+exports.levelOf = levelOf;
+exports.validUntilOf = validUntilOf;
+exports.combineLevel = combineLevel;
+exports.sameLevel = sameLevel;
+/** The five levels in their strict order; each blocks what the one before it blocks, and more. */
+exports.DEGRADATION_LEVELS = [
+    'NONE',
+    'RESTRICT_NEW',
+    'RESTRICT_USAGE',
+    'RESTRICT_READ',
+    'SUSPENDED',
+];
+/** What a replica past its `valid_until` is tightened to, at least. */
+exports.EXPIRED_FLOOR = 'RESTRICT_USAGE';
+function rank(level) {
+    return exports.DEGRADATION_LEVELS.indexOf(level);
+}
+/**
+ * The level an organization entry carries. Anything that is not one of the five values (missing, another
+ * string, not a string) is read as RESTRICT_USAGE: a level this client does not know is never read as looser.
+ */
+function levelOf(entry) {
+    const raw = entry.degradation_level;
+    return typeof raw === 'string' && exports.DEGRADATION_LEVELS.includes(raw)
+        ? raw
+        : exports.EXPIRED_FLOOR;
+}
+/** `valid_until` in epoch milliseconds, or undefined when missing or unparsable (read as already expired). */
+function validUntilOf(entry) {
+    const raw = entry.valid_until;
+    if (typeof raw !== 'string')
+        return undefined;
+    const at = Date.parse(raw);
+    return Number.isFinite(at) ? at : undefined;
+}
+/**
+ * Combines an entry with what the client observes:
+ *
+ * - answered (online, or a pull of this organization just succeeded): the entry's level;
+ * - not answered and `now < valid_until`: the entry's level, marked degraded;
+ * - not answered and `now >= valid_until` (or no usable `valid_until`): at least RESTRICT_USAGE, marked expired.
+ */
+function combineLevel(entry, answered, now) {
+    const level = levelOf(entry);
+    if (answered) {
+        return { level, source: 'answer', expired: false };
+    }
+    const validUntil = validUntilOf(entry);
+    if (validUntil !== undefined && now < validUntil) {
+        return { level, source: 'degraded', expired: false };
+    }
+    return {
+        level: rank(level) >= rank(exports.EXPIRED_FLOOR) ? level : exports.EXPIRED_FLOOR,
+        source: 'degraded',
+        expired: true,
+    };
+}
+/** True when two effective levels are the same triple. */
+function sameLevel(a, b) {
+    if (!a || !b)
+        return a === b;
+    return a.level === b.level && a.source === b.source && a.expired === b.expired;
+}
+//# sourceMappingURL=degradation.js.map

package/dist/mirror/entitlement-mirror.d.ts

@@ -1,14 +1,22 @@
-import { Snapshot, SnapshotItem } from '../types';
+import { OrganizationSnapshot, Snapshot, SnapshotItem } from '../types';
 export declare const MAX_SUPPORTED_SCHEMA_VERSION = 1;
 /**
  * In-memory replica of the application-level entitlement snapshot served by
  * `GET /sdk/v1/entitlements/snapshot`, indexed by organization and capability.
  */
 export declare class EntitlementMirror {
+    private readonly onChange?;
     private readonly organizations;
+    /** When each organization's entry was received (local clock). */
+    private readonly receivedAt;
     private currentSchemaVersion;
     private projectId;
     private lastUpdatedAt;
+    /**
+     * @param onChange called after the mirror changed: with the organizations whose entry was replaced or
+     *   removed, or with `null` when the whole mirror was replaced.
+     */
+    constructor(onChange?: ((organizationIds: string[] | null) => void) | undefined);
     /**
      * Replaces the mirror with an application-level snapshot envelope.
      * If schema_version is higher than supported, the update is rejected and the existing mirror is retained.
@@ -23,6 +31,12 @@ export declare class EntitlementMirror {
      * Removes an organization, for a refill whose envelope no longer holds it (unsubscribed or deleted).
      */
     removeOrganization(organizationId: string): void;
+    /** The entry of one organization, or `undefined` when the mirror does not hold it. */
+    getOrganization(organizationId: string): OrganizationSnapshot | undefined;
+    /** When the entry of one organization was received (local clock), or `undefined`. */
+    getReceivedAt(organizationId: string): number | undefined;
+    /** The organizations the mirror holds. */
+    organizationIds(): string[];
     /**
      * Revision of one organization, or `undefined` when the mirror does not hold it.
      */

package/dist/mirror/entitlement-mirror.js

@@ -7,10 +7,20 @@ exports.MAX_SUPPORTED_SCHEMA_VERSION = 1;
  * `GET /sdk/v1/entitlements/snapshot`, indexed by organization and capability.
  */
 class EntitlementMirror {
+    onChange;
     organizations = new Map();
+    /** When each organization's entry was received (local clock). */
+    receivedAt = new Map();
     currentSchemaVersion = exports.MAX_SUPPORTED_SCHEMA_VERSION;
     projectId = '';
     lastUpdatedAt = 0;
+    /**
+     * @param onChange called after the mirror changed: with the organizations whose entry was replaced or
+     *   removed, or with `null` when the whole mirror was replaced.
+     */
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
     /**
      * Replaces the mirror with an application-level snapshot envelope.
      * If schema_version is higher than supported, the update is rejected and the existing mirror is retained.
@@ -19,13 +29,17 @@ class EntitlementMirror {
         if (!this.acceptsEnvelope(snapshot)) {
             return false;
         }
+        const now = Date.now();
         this.organizations.clear();
+        this.receivedAt.clear();
         this.projectId = snapshot.project_id;
         this.currentSchemaVersion = snapshot.schema_version;
         for (const [organizationId, organization] of Object.entries(snapshot.organizations ?? {})) {
             this.organizations.set(organizationId, organization);
+            this.receivedAt.set(organizationId, now);
         }
-        this.lastUpdatedAt = Date.now();
+        this.lastUpdatedAt = now;
+        this.onChange?.(null);
         return true;
     }
     /**
@@ -39,14 +53,20 @@ class EntitlementMirror {
         if (this.projectId && snapshot.project_id !== this.projectId) {
             return false;
         }
+        const now = Date.now();
+        const changed = [];
         this.projectId = snapshot.project_id;
         for (const [organizationId, organization] of Object.entries(snapshot.organizations ?? {})) {
             const known = this.organizations.get(organizationId);
             if (!known || organization.revision >= known.revision) {
                 this.organizations.set(organizationId, organization);
+                this.receivedAt.set(organizationId, now);
+                changed.push(organizationId);
             }
         }
-        this.lastUpdatedAt = Date.now();
+        this.lastUpdatedAt = now;
+        if (changed.length > 0)
+            this.onChange?.(changed);
         return true;
     }
     /**
@@ -54,9 +74,23 @@ class EntitlementMirror {
      */
     removeOrganization(organizationId) {
         if (this.organizations.delete(organizationId)) {
+            this.receivedAt.delete(organizationId);
             this.lastUpdatedAt = Date.now();
+            this.onChange?.([organizationId]);
         }
     }
+    /** The entry of one organization, or `undefined` when the mirror does not hold it. */
+    getOrganization(organizationId) {
+        return this.organizations.get(organizationId);
+    }
+    /** When the entry of one organization was received (local clock), or `undefined`. */
+    getReceivedAt(organizationId) {
+        return this.receivedAt.get(organizationId);
+    }
+    /** The organizations the mirror holds. */
+    organizationIds() {
+        return [...this.organizations.keys()];
+    }
     /**
      * Revision of one organization, or `undefined` when the mirror does not hold it.
      */

package/dist/ruling/adjudicator.js

@@ -86,23 +86,16 @@ class Adjudicator {
                     adjudicated_at: now,
                 };
             }
-            // Beyond the remaining allowance only ALLOW_AND_BILL lets the call through locally; any other
-            // policy depends on prices and wallet state the mirror does not hold, so it is refused.
-            if (item.overage_policy === 'ALLOW_AND_BILL') {
-                return {
-                    allowed: true,
-                    remaining: 0,
-                    limit,
-                    source: 'realtime',
-                    adjudicated_at: now,
-                };
-            }
+            // Beyond the remaining allowance the call is not decided here, whatever the policy: whether credits (and, for
+            // ALLOW_AND_BILL, an overdraft) cover it is state the mirror does not hold. The local answer is a refusal;
+            // adjudicateAsync() asks the service on it, and without an answer the call stays refused (fail closed).
             return {
                 allowed: false,
                 remaining: (0, decimal_1.decimalToNumber)(item.remaining),
                 limit,
                 source: 'realtime',
-                reason: 'quota_exhausted',
+                // Under PROMPT_UPGRADE the way on is a larger plan, not more credits; the service rules the same way.
+                reason: item.overage_policy === 'PROMPT_UPGRADE' ? 'plan_upgrade_required' : 'quota_exhausted',
                 adjudicated_at: now,
             };
         }

package/dist/transport/http.transport.d.ts

@@ -1,4 +1,4 @@
-import { AdjudicationLookupRequest, AdjudicationLookupResponse, ConfirmReservationResult, JwksResponse, ReleaseReservationResult, ReservationResult, ReserveOptions, Snapshot, UsageEventItem, UsageEventsResponse } from '../types';
+import { AdjudicationLookupRequest, AdjudicationLookupResponse, ConfirmReservationResult, JwksResponse, ReleaseReservationResult, ReservationResult, ReserveOptions, Snapshot, UsageEventItem, UsageEventsResponse, UsageSendEvent, UsageSendResult } from '../types';
 /** A non-success HTTP answer from the instance; `status` lets callers tell a refused token from an outage. */
 export declare class HttpError extends Error {
     readonly status: number;
@@ -37,6 +37,11 @@ export declare class HttpTransport {
      * Quantities are sent as decimal strings; `properties` travel as the event's `dimensions`.
      */
     reportUsageEvents(events: UsageEventItem[], token: string): Promise<UsageEventsResponse>;
+    /**
+     * Sends a batch of usage events as they are: POST /sdk/v1/usage-events. A string quantity travels unchanged,
+     * so decimals keep every digit.
+     */
+    sendUsageEvents(events: UsageSendEvent[], token: string): Promise<UsageSendResult>;
     /**
      * Authoritative ruling when the mirror misses an organization or capability: POST /sdk/v1/adjudicate.
      */

package/dist/transport/http.transport.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpTransport = exports.HttpError = void 0;
 exports.isHttpStatus = isHttpStatus;
+const types_1 = require("../types");
 const decimal_1 = require("../util/decimal");
 /** A non-success HTTP answer from the instance; `status` lets callers tell a refused token from an outage. */
 class HttpError extends Error {
@@ -17,6 +18,25 @@ exports.HttpError = HttpError;
 function isHttpStatus(error, ...statuses) {
     return error instanceof HttpError && statuses.includes(error.status);
 }
+/**
+ * The typed error of a refusal for funds, read from `error.code` of the instance's error envelope; undefined for any
+ * other answer. Only the code decides: the message text is never parsed for meaning.
+ */
+function fundsRefusal(errorText, status, message) {
+    let error;
+    try {
+        error = JSON.parse(errorText)?.error;
+    }
+    catch {
+        return undefined;
+    }
+    const details = { status, request_id: typeof error?.request_id === 'string' ? error.request_id : undefined };
+    if (error?.code === 'QUOTA_EXHAUSTED')
+        return new types_1.QuotaExhaustedError(message, details);
+    if (error?.code === 'PLAN_UPGRADE_REQUIRED')
+        return new types_1.PlanUpgradeRequiredError(message, details);
+    return undefined;
+}
 class HttpTransport {
     baseUrl;
     timeoutMs;
@@ -97,6 +117,26 @@ class HttpTransport {
             rejected: body.rejected ?? [],
         };
     }
+    /**
+     * Sends a batch of usage events as they are: POST /sdk/v1/usage-events. A string quantity travels unchanged,
+     * so decimals keep every digit.
+     */
+    async sendUsageEvents(events, token) {
+        const wireEvents = events.map((event) => ({
+            usage_event_id: event.usage_event_id,
+            organization_id: event.organization_id,
+            capability_key: event.capability_key,
+            quantity: typeof event.quantity === 'string' ? event.quantity.trim() : (0, decimal_1.toDecimalString)(event.quantity),
+            occurred_at: event.occurred_at,
+            ...(event.properties !== undefined ? { dimensions: event.properties } : {}),
+        }));
+        const body = await this.postJson('/sdk/v1/usage-events', { events: wireEvents }, token, 'Failed to send usage events');
+        return {
+            accepted_count: body.accepted_count,
+            duplicates_dropped: body.duplicates_dropped,
+            rejected: body.rejected ?? [],
+        };
+    }
     /**
      * Authoritative ruling when the mirror misses an organization or capability: POST /sdk/v1/adjudicate.
      */
@@ -129,7 +169,7 @@ class HttpTransport {
         const body = await this.postJson('/sdk/v1/reservations/reserve', wireRequest, token, 'Reservation failed');
         return {
             reservation_id: body.reservation_id,
-            status: body.status === 'RESERVED' ? 'PENDING' : body.status,
+            status: body.status,
             expires_at: body.expires_at,
         };
     }
@@ -185,7 +225,8 @@ class HttpTransport {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new HttpError(`${failure}: HTTP ${response.status} - ${errorText}`, response.status);
+            const message = `${failure}: HTTP ${response.status} - ${errorText}`;
+            throw fundsRefusal(errorText, response.status, message) ?? new HttpError(message, response.status);
         }
         return (await response.json());
     }