@depup/apollo__server 5.5.0-depup.0

package/dist/cjs/plugin/schemaReporting/schemaReporter.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from '@apollo/utils.logger';
+import type { SchemaReport, ReportSchemaResponse } from './generated/operations';
+import type { Fetcher } from '@apollo/utils.fetcher';
+export declare const schemaReportGql = "#graphql\n  mutation SchemaReport($report: SchemaReport!, $coreSchema: String) {\n    reportSchema(report: $report, coreSchema: $coreSchema) {\n      __typename\n      ... on ReportSchemaError {\n        message\n        code\n      }\n      ... on ReportSchemaResponse {\n        inSeconds\n        withCoreSchema\n      }\n    }\n  }\n";
+export declare class SchemaReporter {
+    private readonly schemaReport;
+    private readonly coreSchema;
+    private readonly endpointUrl;
+    private readonly logger;
+    private readonly initialReportingDelayInMs;
+    private readonly fallbackReportingDelayInMs;
+    private readonly fetcher;
+    private isStopped;
+    private pollTimer?;
+    private readonly headers;
+    constructor(options: {
+        schemaReport: SchemaReport;
+        coreSchema: string;
+        apiKey: string;
+        endpointUrl: string | undefined;
+        logger: Logger;
+        initialReportingDelayInMs: number;
+        fallbackReportingDelayInMs: number;
+        fetcher?: Fetcher;
+    });
+    stopped(): boolean;
+    start(): void;
+    stop(): void;
+    private sendOneReportAndScheduleNext;
+    reportSchema(withCoreSchema: boolean): Promise<ReportSchemaResponse | null>;
+    private apolloQuery;
+}
+//# sourceMappingURL=schemaReporter.d.ts.map

package/dist/cjs/plugin/schemaReporting/schemaReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaReporter.d.ts","sourceRoot":"","sources":["../../../../src/plugin/schemaReporting/schemaReporter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EACV,YAAY,EAGZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAKrD,eAAO,MAAM,eAAe,sVAc3B,CAAC;AAGF,qBAAa,cAAc;IAEzB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAS;IACnD,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAS;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;gBAErC,OAAO,EAAE;QACnB,YAAY,EAAE,YAAY,CAAC;QAC3B,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;QAChC,MAAM,EAAE,MAAM,CAAC;QACf,yBAAyB,EAAE,MAAM,CAAC;QAClC,0BAA0B,EAAE,MAAM,CAAC;QACnC,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;IAqBM,OAAO,IAAI,OAAO;IAIlB,KAAK;IAOL,IAAI;YAQG,4BAA4B;IAiC7B,YAAY,CACvB,cAAc,EAAE,OAAO,GACtB,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;YAwCzB,WAAW;CAsC1B"}

package/dist/cjs/plugin/schemaReporting/schemaReporter.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaReporter = exports.schemaReportGql = void 0;
+const packageVersion_js_1 = require("../../generated/packageVersion.js");
+exports.schemaReportGql = `#graphql
+  mutation SchemaReport($report: SchemaReport!, $coreSchema: String) {
+    reportSchema(report: $report, coreSchema: $coreSchema) {
+      __typename
+      ... on ReportSchemaError {
+        message
+        code
+      }
+      ... on ReportSchemaResponse {
+        inSeconds
+        withCoreSchema
+      }
+    }
+  }
+`;
+class SchemaReporter {
+    schemaReport;
+    coreSchema;
+    endpointUrl;
+    logger;
+    initialReportingDelayInMs;
+    fallbackReportingDelayInMs;
+    fetcher;
+    isStopped;
+    pollTimer;
+    headers;
+    constructor(options) {
+        this.headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': options.apiKey,
+            'apollographql-client-name': 'ApolloServerPluginSchemaReporting',
+            'apollographql-client-version': packageVersion_js_1.packageVersion,
+        };
+        this.endpointUrl =
+            options.endpointUrl ||
+                'https://schema-reporting.api.apollographql.com/api/graphql';
+        this.schemaReport = options.schemaReport;
+        this.coreSchema = options.coreSchema;
+        this.isStopped = false;
+        this.logger = options.logger;
+        this.initialReportingDelayInMs = options.initialReportingDelayInMs;
+        this.fallbackReportingDelayInMs = options.fallbackReportingDelayInMs;
+        this.fetcher = options.fetcher ?? fetch;
+    }
+    stopped() {
+        return this.isStopped;
+    }
+    start() {
+        this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(false), this.initialReportingDelayInMs);
+    }
+    stop() {
+        this.isStopped = true;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+    }
+    async sendOneReportAndScheduleNext(sendNextWithCoreSchema) {
+        this.pollTimer = undefined;
+        if (this.stopped())
+            return;
+        try {
+            const result = await this.reportSchema(sendNextWithCoreSchema);
+            if (!result) {
+                return;
+            }
+            if (!this.stopped()) {
+                this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(result.withCoreSchema), result.inSeconds * 1000);
+            }
+            return;
+        }
+        catch (error) {
+            this.logger.error(`Error reporting server info to Apollo during schema reporting: ${error}`);
+            if (!this.stopped()) {
+                this.pollTimer = setTimeout(() => this.sendOneReportAndScheduleNext(false), this.fallbackReportingDelayInMs);
+            }
+        }
+    }
+    async reportSchema(withCoreSchema) {
+        const { data, errors } = await this.apolloQuery({
+            report: this.schemaReport,
+            coreSchema: withCoreSchema ? this.coreSchema : null,
+        });
+        if (errors) {
+            throw new Error(errors.map((x) => x.message).join('\n'));
+        }
+        function msgForUnexpectedResponse(data) {
+            return [
+                'Unexpected response shape from Apollo when',
+                'reporting schema. If this continues, please reach',
+                'out to support@apollographql.com.',
+                'Received response:',
+                JSON.stringify(data),
+            ].join(' ');
+        }
+        if (!data || !data.reportSchema) {
+            throw new Error(msgForUnexpectedResponse(data));
+        }
+        if (data.reportSchema.__typename === 'ReportSchemaResponse') {
+            return data.reportSchema;
+        }
+        else if (data.reportSchema.__typename === 'ReportSchemaError') {
+            this.logger.error([
+                'Received input validation error from Apollo:',
+                data.reportSchema.message,
+                'Stopping reporting. Please fix the input errors.',
+            ].join(' '));
+            this.stop();
+            return null;
+        }
+        throw new Error(msgForUnexpectedResponse(data));
+    }
+    async apolloQuery(variables) {
+        const request = {
+            query: exports.schemaReportGql,
+            variables,
+        };
+        const httpResponse = await this.fetcher(this.endpointUrl, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(request),
+        });
+        if (!httpResponse.ok) {
+            throw new Error([
+                `An unexpected HTTP status code (${httpResponse.status}) was`,
+                'encountered during schema reporting.',
+            ].join(' '));
+        }
+        try {
+            return await httpResponse.json();
+        }
+        catch (error) {
+            throw new Error([
+                "Couldn't report schema to Apollo.",
+                'Parsing response as JSON failed.',
+                'If this continues please reach out to support@apollographql.com',
+                error,
+            ].join(' '));
+        }
+    }
+}
+exports.SchemaReporter = SchemaReporter;
+//# sourceMappingURL=schemaReporter.js.map

package/dist/cjs/plugin/schemaReporting/schemaReporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaReporter.js","sourceRoot":"","sources":["../../../../src/plugin/schemaReporting/schemaReporter.ts"],"names":[],"mappings":"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"}

package/dist/cjs/plugin/subscriptionCallback/index.d.ts

@@ -0,0 +1,12 @@
+import { type Fetcher } from '@apollo/utils.fetcher';
+import type { Logger } from '@apollo/utils.logger';
+import retry from 'async-retry';
+import type { ApolloServerPlugin } from '../../externalTypes/index.js';
+export interface ApolloServerPluginSubscriptionCallbackOptions {
+    maxConsecutiveHeartbeatFailures?: number;
+    logger?: Logger;
+    retry?: retry.Options;
+    fetcher?: Fetcher;
+}
+export declare function ApolloServerPluginSubscriptionCallback(options?: ApolloServerPluginSubscriptionCallbackOptions): ApolloServerPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/plugin/subscriptionCallback/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugin/subscriptionCallback/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,MAAM,aAAa,CAAC;AAIhC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,MAAM,WAAW,6CAA6C;IAC5D,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IAItB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,sCAAsC,CACpD,OAAO,GAAE,6CAAmE,GAC3E,kBAAkB,CAuLpB"}

package/dist/cjs/plugin/subscriptionCallback/index.js

@@ -0,0 +1,434 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApolloServerPluginSubscriptionCallback = ApolloServerPluginSubscriptionCallback;
+const async_retry_1 = __importDefault(require("async-retry"));
+const graphql_1 = require("graphql");
+const promises_1 = require("node:timers/promises");
+const errorNormalize_js_1 = require("../../errorNormalize.js");
+const HeaderMap_js_1 = require("../../utils/HeaderMap.js");
+function ApolloServerPluginSubscriptionCallback(options = Object.create(null)) {
+    const subscriptionManager = new SubscriptionManager(options);
+    const logger = options.logger
+        ? prefixedLogger(options.logger, 'SubscriptionCallback')
+        : undefined;
+    return {
+        async requestDidStart({ request }) {
+            const subscriptionExtension = request?.extensions?.subscription;
+            if (!subscriptionExtension)
+                return;
+            let { callbackUrl, subscriptionId: id, verifier, heartbeatIntervalMs, } = subscriptionExtension;
+            callbackUrl = callbackUrl || subscriptionExtension.callback_url;
+            id = id || subscriptionExtension.subscription_id;
+            heartbeatIntervalMs =
+                heartbeatIntervalMs ??
+                    subscriptionExtension.heartbeat_interval_ms ??
+                    5000;
+            return {
+                async responseForOperation() {
+                    logger?.debug('Received new subscription request', id);
+                    return {
+                        http: {
+                            status: 200,
+                            headers: new HeaderMap_js_1.HeaderMap([['content-type', 'application/json']]),
+                        },
+                        body: {
+                            kind: 'single',
+                            singleResult: {
+                                data: null,
+                            },
+                        },
+                    };
+                },
+                async willSendResponse({ request, schema, document, contextValue, operationName, response, }) {
+                    try {
+                        await subscriptionManager.checkRequest({
+                            callbackUrl,
+                            id,
+                            verifier,
+                        });
+                    }
+                    catch (e) {
+                        const graphqlError = (0, errorNormalize_js_1.ensureGraphQLError)(e);
+                        logger?.error(`\`check\` request failed: ${graphqlError.message}`, id);
+                        if (response.body.kind === 'single') {
+                            response.body.singleResult.errors = [graphqlError];
+                            response.http.status = 500;
+                        }
+                        return;
+                    }
+                    subscriptionManager.initHeartbeat({
+                        callbackUrl,
+                        id,
+                        verifier,
+                        heartbeatIntervalMs,
+                    });
+                    logger?.debug(`Starting graphql-js subscription`, id);
+                    let subscription;
+                    try {
+                        subscription = await (0, graphql_1.subscribe)({
+                            schema,
+                            document: document,
+                            variableValues: request.variables,
+                            contextValue: contextValue,
+                            operationName: operationName,
+                        });
+                    }
+                    catch (e) {
+                        const graphqlError = (0, errorNormalize_js_1.ensureGraphQLError)(e);
+                        logger?.error(`Programming error: graphql-js subscribe() threw unexpectedly! Please report this bug to Apollo. The error was: ${e}`, id);
+                        subscriptionManager.completeRequest({
+                            errors: [graphqlError],
+                            callbackUrl,
+                            id,
+                            verifier,
+                        });
+                        return;
+                    }
+                    if ('errors' in subscription) {
+                        logger?.error(`graphql-js subscription unsuccessful: [\n\t${subscription.errors
+                            ?.map((e) => e.message)
+                            .join(',\n\t')}\n]`, id);
+                        try {
+                            subscriptionManager.completeRequest({
+                                errors: subscription.errors,
+                                callbackUrl,
+                                id,
+                                verifier,
+                            });
+                        }
+                        catch (e) {
+                            logger?.error(`\`complete\` request failed: ${e}`, id);
+                        }
+                    }
+                    else if (isAsyncIterable(subscription)) {
+                        logger?.debug('graphql-js subscription successful', id);
+                        subscriptionManager.startConsumingSubscription({
+                            subscription,
+                            callbackUrl,
+                            id,
+                            verifier,
+                        });
+                    }
+                    logger?.debug(`Responding to original subscription request`, id);
+                },
+            };
+        },
+        async serverWillStart() {
+            return {
+                async drainServer() {
+                    logger?.debug('Server is shutting down. Cleaning up outstanding subscriptions and heartbeat intervals');
+                    await subscriptionManager.cleanup();
+                    await (0, promises_1.setImmediate)();
+                    logger?.debug('Successfully cleaned up outstanding subscriptions and heartbeat intervals.');
+                },
+            };
+        },
+    };
+}
+function isAsyncIterable(value) {
+    return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+class SubscriptionManager {
+    maxConsecutiveHeartbeatFailures;
+    logger;
+    retryConfig;
+    requestsInFlight = new Set();
+    subscriptionInfoByCallbackUrl = new Map();
+    fetcher;
+    constructor(options) {
+        this.maxConsecutiveHeartbeatFailures =
+            options.maxConsecutiveHeartbeatFailures ?? 5;
+        this.retryConfig = {
+            retries: 5,
+            minTimeout: 100,
+            maxTimeout: 1000,
+            ...options.retry,
+        };
+        this.logger = options.logger
+            ? prefixedLogger(options.logger, 'SubscriptionManager')
+            : undefined;
+        this.fetcher = options.fetcher ?? fetch;
+    }
+    async retryFetch({ url, action, id, verifier, payload, errors, headers, }) {
+        let response;
+        try {
+            const maybeWithErrors = errors?.length ? ` with errors` : '';
+            this.logger?.debug(`Sending \`${action}\` request to router` + maybeWithErrors, id);
+            return (0, async_retry_1.default)(async (bail) => {
+                response = this.fetcher(url, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...headers,
+                    },
+                    body: JSON.stringify({
+                        kind: 'subscription',
+                        action,
+                        id,
+                        verifier,
+                        ...(payload && { payload }),
+                        ...(errors?.length && { errors }),
+                    }),
+                });
+                this.requestsInFlight.add(response);
+                const result = await response;
+                if (!result.ok) {
+                    if (result.status >= 500) {
+                        throw new Error(`\`${action}\` request failed with unexpected status code: ${result.status}`);
+                    }
+                    else {
+                        if (result.status === 404) {
+                            this.logger?.debug(`\`${action}\` request received 404, terminating subscription`, id);
+                        }
+                        else {
+                            const errMsg = `\`${action}\` request failed with unexpected status code: ${result.status}, terminating subscription`;
+                            this.logger?.debug(errMsg, id);
+                            bail(new Error(errMsg));
+                        }
+                        this.terminateSubscription(id, url);
+                        return result;
+                    }
+                }
+                this.logger?.debug(`\`${action}\` request successful`, id);
+                return result;
+            }, {
+                ...this.retryConfig,
+                onRetry: (e, attempt) => {
+                    this.requestsInFlight.delete(response);
+                    this.logger?.warn(`Retrying \`${action}\` request (attempt ${attempt}) due to error: ${e.message}`, id);
+                    this.retryConfig?.onRetry?.(e, attempt);
+                },
+            });
+        }
+        finally {
+            this.requestsInFlight.delete(response);
+        }
+    }
+    async checkRequest({ callbackUrl, id, verifier, }) {
+        return this.retryFetch({
+            url: callbackUrl,
+            action: 'check',
+            id,
+            verifier,
+            headers: { 'subscription-protocol': 'callback/1.0' },
+        });
+    }
+    initHeartbeat({ callbackUrl, id, verifier, heartbeatIntervalMs, }) {
+        if (!this.subscriptionInfoByCallbackUrl.has(callbackUrl)) {
+            this.subscriptionInfoByCallbackUrl.set(callbackUrl, {});
+        }
+        if (heartbeatIntervalMs === 0) {
+            this.logger?.debug(`Heartbeat disabled for ${callbackUrl}`, id);
+            return;
+        }
+        this.logger?.debug(`Starting new heartbeat interval for ${callbackUrl}`, id);
+        let consecutiveHeartbeatFailureCount = 0;
+        const heartbeatInterval = setInterval(async () => {
+            let heartbeatRequest;
+            let resolveHeartbeatPromise;
+            const heartbeatPromise = new Promise((r) => {
+                resolveHeartbeatPromise = r;
+            });
+            const existingSubscriptionInfo = this.subscriptionInfoByCallbackUrl.get(callbackUrl);
+            if (!existingSubscriptionInfo?.heartbeat) {
+                clearInterval(heartbeatInterval);
+                this.logger?.error(`Programming error: Heartbeat interval unexpectedly missing for ${callbackUrl}. This is probably a bug in Apollo Server.`);
+                return;
+            }
+            const existingHeartbeat = existingSubscriptionInfo.heartbeat;
+            const { queue } = existingHeartbeat;
+            queue.push(heartbeatPromise);
+            if (queue.length > 1) {
+                const requestBeforeMe = queue[existingHeartbeat?.queue.length - 2];
+                await requestBeforeMe;
+            }
+            try {
+                this.logger?.debug(`Sending \`check\` request to ${callbackUrl} for ID: ${id}`);
+                heartbeatRequest = this.fetcher(callbackUrl, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        kind: 'subscription',
+                        action: 'check',
+                        id,
+                        verifier,
+                    }),
+                    headers: {
+                        'content-type': 'application/json',
+                        'subscription-protocol': 'callback/1.0',
+                    },
+                });
+                this.requestsInFlight.add(heartbeatRequest);
+                const result = await heartbeatRequest;
+                this.logger?.debug(`Heartbeat received response for ID: ${id}`);
+                if (result.ok) {
+                    this.logger?.debug(`Heartbeat request successful, ID: ${id}`);
+                }
+                else if (result.status === 400) {
+                    this.logger?.debug(`Heartbeat request received invalid ID: ${id}`);
+                    this.terminateSubscription(id, callbackUrl);
+                }
+                else if (result.status === 404) {
+                    this.logger?.debug(`Heartbeat request received invalid ID: ${id}`);
+                    this.terminateSubscription(id, callbackUrl);
+                }
+                else {
+                    throw new Error(`Unexpected status code: ${result.status}`);
+                }
+                consecutiveHeartbeatFailureCount = 0;
+            }
+            catch (e) {
+                const err = (0, errorNormalize_js_1.ensureError)(e);
+                this.logger?.error(`Heartbeat request failed (${++consecutiveHeartbeatFailureCount} consecutive): ${err.message}`, existingHeartbeat.id);
+                if (consecutiveHeartbeatFailureCount >=
+                    this.maxConsecutiveHeartbeatFailures) {
+                    this.logger?.error(`Heartbeat request failed ${consecutiveHeartbeatFailureCount} times, terminating subscriptions and heartbeat interval: ${err.message}`, existingHeartbeat.id);
+                    this.terminateSubscription(id, callbackUrl);
+                }
+                return;
+            }
+            finally {
+                if (heartbeatRequest) {
+                    this.requestsInFlight.delete(heartbeatRequest);
+                }
+                existingHeartbeat?.queue.shift();
+                resolveHeartbeatPromise();
+            }
+        }, heartbeatIntervalMs);
+        const subscriptionInfo = this.subscriptionInfoByCallbackUrl.get(callbackUrl);
+        subscriptionInfo.heartbeat = {
+            interval: heartbeatInterval,
+            id,
+            verifier,
+            queue: [],
+        };
+    }
+    terminateSubscription(id, callbackUrl) {
+        this.logger?.debug(`Terminating subscriptions for ID: ${id}`);
+        const subscriptionInfo = this.subscriptionInfoByCallbackUrl.get(callbackUrl);
+        if (!subscriptionInfo) {
+            this.logger?.error(`No subscriptions found for ${callbackUrl}, skipping termination`);
+            return;
+        }
+        const { subscription, heartbeat } = subscriptionInfo;
+        if (subscription) {
+            subscription.cancelled = true;
+            subscription.asyncIter?.return();
+        }
+        if (heartbeat) {
+            this.logger?.debug(`Terminating heartbeat interval for ${callbackUrl}`);
+            clearInterval(heartbeat.interval);
+        }
+        this.subscriptionInfoByCallbackUrl.delete(callbackUrl);
+    }
+    startConsumingSubscription({ subscription, callbackUrl, id, verifier, }) {
+        const self = this;
+        const subscriptionObject = {
+            asyncIter: subscription,
+            cancelled: false,
+            async startConsumingSubscription() {
+                self.logger?.debug(`Listening to graphql-js subscription`, id);
+                try {
+                    for await (const payload of subscription) {
+                        if (this.cancelled) {
+                            self.logger?.debug(`Subscription already cancelled, ignoring current and future payloads`, id);
+                            return;
+                        }
+                        try {
+                            await self.retryFetch({
+                                url: callbackUrl,
+                                action: 'next',
+                                id,
+                                verifier,
+                                payload,
+                            });
+                        }
+                        catch (e) {
+                            const originalError = (0, errorNormalize_js_1.ensureError)(e);
+                            self.logger?.error(`\`next\` request failed, terminating subscription: ${originalError.message}`, id);
+                            self.terminateSubscription(id, callbackUrl);
+                        }
+                    }
+                    self.logger?.debug(`Subscription completed without errors`, id);
+                    await this.completeSubscription();
+                }
+                catch (e) {
+                    const error = (0, errorNormalize_js_1.ensureGraphQLError)(e);
+                    self.logger?.error(`Generator threw an error, terminating subscription: ${error.message}`, id);
+                    this.completeSubscription([error]);
+                }
+            },
+            async completeSubscription(errors) {
+                if (this.cancelled)
+                    return;
+                this.cancelled = true;
+                try {
+                    await self.completeRequest({
+                        callbackUrl,
+                        id,
+                        verifier,
+                        ...(errors && { errors }),
+                    });
+                }
+                catch (e) {
+                    const error = (0, errorNormalize_js_1.ensureError)(e);
+                    self.logger?.error(`\`complete\` request failed: ${error.message}`, id);
+                }
+                finally {
+                    self.terminateSubscription(id, callbackUrl);
+                }
+            },
+        };
+        subscriptionObject.startConsumingSubscription();
+        const subscriptionInfo = this.subscriptionInfoByCallbackUrl.get(callbackUrl);
+        if (!subscriptionInfo) {
+            this.logger?.error(`No existing heartbeat found for ${callbackUrl}, skipping subscription`);
+        }
+        else {
+            subscriptionInfo.subscription = subscriptionObject;
+        }
+    }
+    async completeRequest({ errors, callbackUrl, id, verifier, }) {
+        return this.retryFetch({
+            url: callbackUrl,
+            action: 'complete',
+            id,
+            verifier,
+            errors,
+        });
+    }
+    collectAllSubscriptions() {
+        return Array.from(this.subscriptionInfoByCallbackUrl.values()).reduce((subscriptions, { subscription }) => {
+            if (subscription) {
+                subscriptions.push(subscription);
+            }
+            return subscriptions;
+        }, []);
+    }
+    async cleanup() {
+        await Promise.allSettled(Array.from(this.subscriptionInfoByCallbackUrl.values()).map(async ({ heartbeat }) => {
+            clearInterval(heartbeat?.interval);
+            await heartbeat?.queue[heartbeat.queue.length - 1];
+        }));
+        await Promise.allSettled(this.collectAllSubscriptions()
+            .filter((s) => !s.cancelled)
+            .map((s) => s.completeSubscription()));
+        await Promise.allSettled(this.requestsInFlight.values());
+    }
+}
+function prefixedLogger(logger, prefix) {
+    function log(level) {
+        return function (message, id) {
+            logger[level](`${prefix}${id ? `[${id}]` : ''}: ${message}`);
+        };
+    }
+    return {
+        debug: log('debug'),
+        error: log('error'),
+        info: log('info'),
+        warn: log('warn'),
+    };
+}
+//# sourceMappingURL=index.js.map