• Home
• org.mvnpm.at.gomomento
• sdk
• 1.98.1
• source code
• pubsub-client.js

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

package.dist.src.internal.pubsub-client.js Maven / Gradle / Ivy

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PubsubClient = void 0;
const generated_types_1 = require("@gomomento/generated-types");
var grpcPubsub = generated_types_1.pubsub.cache_client.pubsub;
// older versions of node don't have the global util variables https://github.com/nodejs/node/issues/20365
const headers_interceptor_1 = require("./grpc/headers-interceptor");
const cache_service_error_mapper_1 = require("../errors/cache-service-error-mapper");
const grpc_js_1 = require("@grpc/grpc-js");
const package_json_1 = require("../../package.json");
const middlewares_interceptor_1 = require("./grpc/middlewares-interceptor");
const __1 = require("../");
const utils_1 = require("@gomomento/sdk-core/dist/src/internal/utils");
const AbstractPubsubClient_1 = require("@gomomento/sdk-core/dist/src/internal/clients/pubsub/AbstractPubsubClient");
const grpc_channel_options_1 = require("./grpc/grpc-channel-options");
const retry_interceptor_1 = require("./grpc/retry-interceptor");
class PubsubClient extends AbstractPubsubClient_1.AbstractPubsubClient {
    // private static readonly RST_STREAM_NO_ERROR_MESSAGE =
    //   'Received RST_STREAM with code 0';
    /**
     * @param {TopicClientProps} props
     */
    constructor(props) {
        super(props.configuration.getLoggerFactory(), props.configuration.getLoggerFactory().getLogger(PubsubClient.name), new cache_service_error_mapper_1.CacheServiceErrorMapper(props.configuration.getThrowOnErrors()));
        this.credentialProvider = props.credentialProvider;
        this.unaryRequestTimeoutMs = PubsubClient.DEFAULT_REQUEST_TIMEOUT_MS;
        this.getLogger().debug(`Creating topic client using endpoint: '${this.credentialProvider.getCacheEndpoint()}'`);
        const topicGrpcConfig = props.configuration
            .getTransportStrategy()
            .getGrpcConfig();
        // NOTE: This is hard-coded for now but we may want to expose it via TopicConfiguration in the
        // future, as we do with some of the other clients.
        const grpcConfig = new __1.StaticGrpcConfiguration({
            deadlineMillis: this.unaryRequestTimeoutMs,
            maxSessionMemoryMb: PubsubClient.DEFAULT_MAX_SESSION_MEMORY_MB,
            keepAlivePermitWithoutCalls: topicGrpcConfig.getKeepAlivePermitWithoutCalls(),
            keepAliveTimeMs: topicGrpcConfig.getKeepAliveTimeMS(),
            keepAliveTimeoutMs: topicGrpcConfig.getKeepAliveTimeoutMS(),
        });
        const channelOptions = (0, grpc_channel_options_1.grpcChannelOptionsFromGrpcConfig)(grpcConfig);
        this.getLogger().debug(`Creating pubsub client with channel options: ${JSON.stringify(channelOptions, null, 2)}`);
        this.client = new grpcPubsub.PubsubClient(this.credentialProvider.getCacheEndpoint(), this.credentialProvider.isCacheEndpointSecure()
            ? grpc_js_1.ChannelCredentials.createSsl()
            : grpc_js_1.ChannelCredentials.createInsecure(), channelOptions);
        const headers = [
            new headers_interceptor_1.Header('Authorization', this.credentialProvider.getAuthToken()),
            new headers_interceptor_1.Header('agent', `nodejs:topic:${package_json_1.version}`),
            new headers_interceptor_1.Header('runtime-version', `nodejs:${process.versions.node}`),
        ];
        this.unaryInterceptors = PubsubClient.initializeUnaryInterceptors(headers, props.configuration, this.unaryRequestTimeoutMs);
        this.streamingInterceptors =
            PubsubClient.initializeStreamingInterceptors(headers);
    }
    getEndpoint() {
        const endpoint = this.credentialProvider.getCacheEndpoint();
        this.getLogger().debug(`Using cache endpoint: ${endpoint}`);
        return endpoint;
    }
    async sendPublish(cacheName, topicName, value) {
        const topicValue = new grpcPubsub._TopicValue();
        if (typeof value === 'string') {
            topicValue.text = value;
        }
        else {
            topicValue.binary = value;
        }
        const request = new grpcPubsub._PublishRequest({
            cache_name: cacheName,
            topic: topicName,
            value: topicValue,
        });
        return await new Promise((resolve, reject) => {
            this.client.Publish(request, {
                interceptors: this.unaryInterceptors,
            }, (err, resp) => {
                if (resp) {
                    resolve(new __1.TopicPublish.Success());
                }
                else {
                    this.getCacheServiceErrorMapper().resolveOrRejectError({
                        err: err,
                        errorResponseFactoryFn: e => new __1.TopicPublish.Error(e),
                        resolveFn: resolve,
                        rejectFn: reject,
                    });
                }
            });
        });
    }
    /**
     * @remark This method is responsible for restarting the stream if it ends unexpectedly.
     * Since we return a single subscription object to the user, we need to update it with the
     * unsubscribe function should we restart the stream. This is why we pass the subscription
     * state and subscription object to this method.
     *
     * Handling a cache not exists requires special care as well. In the most likely case,
     * when the subscription starts and the cache does not exist, we receive an error immediately.
     * We return an error from the subscribe method and do immediately unsubscribe. In a distinct,
     * unlikely but possible case, the user deletes the cache while the stream is running. In this
     * case we already returned a subscription object to the user, so we instead cancel the stream and
     * propagate an error to the user via the error handler.
     */
    sendSubscribe(options) {
        const request = new grpcPubsub._SubscriptionRequest({
            cache_name: options.cacheName,
            topic: options.topicName,
            resume_at_topic_sequence_number: options.subscriptionState.resumeAtTopicSequenceNumber,
        });
        this.getLogger().trace('Subscribing to topic with resume_at_topic_sequence_number: %s', options.subscriptionState.resumeAtTopicSequenceNumber);
        const call = this.client.Subscribe(request, {
            interceptors: this.streamingInterceptors,
        });
        options.subscriptionState.setSubscribed();
        // Allow the caller to cancel the stream.
        // Note that because we restart the stream on error or stream end,
        // we need to ensure we keep the same subscription object. That way
        // stream restarts are transparent to the caller.
        options.subscriptionState.unsubscribeFn = () => {
            call.cancel();
        };
        return new Promise((resolve, _reject) => {
            const prepareCallbackOptions = {
                ...options,
                resolve,
            };
            call.on('data', this.prepareDataCallback(prepareCallbackOptions));
            call.on('error', this.prepareErrorCallback(prepareCallbackOptions));
            call.on('end', this.prepareEndCallback(prepareCallbackOptions));
        });
    }
    prepareDataCallback(options) {
        return (resp) => {
            if (options.firstMessage) {
                options.resolve(options.subscription);
            }
            options.firstMessage = false;
            if (resp.item) {
                const sequenceNumber = resp.item.topic_sequence_number;
                options.subscriptionState.lastTopicSequenceNumber = sequenceNumber;
                this.getLogger().trace('Received an item on subscription stream; topic: %s; sequence number: %s', (0, utils_1.truncateString)(options.topicName), sequenceNumber);
                if (resp.item.value.text) {
                    options.onItem(new __1.TopicItem(resp.item.value.text, sequenceNumber, {
                        tokenId: resp.item.publisher_id,
                    }));
                }
                else if (resp.item.value.binary) {
                    options.onItem(new __1.TopicItem(resp.item.value.binary, sequenceNumber, {
                        tokenId: resp.item.publisher_id,
                    }));
                }
                else {
                    this.getLogger().error('Received subscription item with unknown type; topic: %s', (0, utils_1.truncateString)(options.topicName));
                    options.onError(new __1.TopicSubscribe.Error(new __1.UnknownError('Unknown item value type')), options.subscription);
                }
            }
            else if (resp.heartbeat) {
                this.getLogger().trace('Received heartbeat from subscription stream; topic: %s', (0, utils_1.truncateString)(options.topicName));
                options.onHeartbeat(new __1.TopicHeartbeat());
            }
            else if (resp.discontinuity) {
                this.getLogger().trace('Received discontinuity from subscription stream; topic: %s', (0, utils_1.truncateString)(options.topicName));
                options.onDiscontinuity(new __1.TopicDiscontinuity(resp.discontinuity.last_topic_sequence, resp.discontinuity.new_topic_sequence));
            }
            else {
                this.getLogger().error('Received unknown subscription item; topic: %s', (0, utils_1.truncateString)(options.topicName));
                options.onError(new __1.TopicSubscribe.Error(new __1.UnknownError('Unknown item type')), options.subscription);
            }
        };
    }
    prepareErrorCallback(options) {
        return (err) => {
            // When the caller unsubscribes, we may get a follow on error, which we ignore.
            if (!options.subscriptionState.isSubscribed) {
                return;
            }
            const serviceError = err;
            this.getLogger().trace(`Subscription encountered an error: ${serviceError.code}: ${serviceError.message}: ${serviceError.details}`);
            const shouldReconnectSubscription = 
            // previously, we were only attempting a reconnect on this one very specific case, but our current expectation is that
            // we should err on the side of retrying. This may become a sort of "deny list" of error types to *not* retry on
            // in the future, but for now we will be aggressive about retrying.
            // // serviceError.code === Status.INTERNAL &&
            //  // serviceError.details === PubsubClient.RST_STREAM_NO_ERROR_MESSAGE;
            true;
            const momentoError = new __1.TopicSubscribe.Error(this.getCacheServiceErrorMapper().convertError(serviceError));
            this.handleSubscribeError(options, momentoError, shouldReconnectSubscription);
        };
    }
    static initializeUnaryInterceptors(headers, configuration, requestTimeoutMs) {
        return [
            (0, middlewares_interceptor_1.middlewaresInterceptor)(configuration.getLoggerFactory(), [], {}),
            headers_interceptor_1.HeaderInterceptor.createHeadersInterceptor(headers),
            retry_interceptor_1.RetryInterceptor.createRetryInterceptor({
                clientName: 'PubSubClient',
                loggerFactory: configuration.getLoggerFactory(),
                overallRequestTimeoutMs: requestTimeoutMs,
            }),
        ];
    }
    // TODO https://github.com/momentohq/client-sdk-nodejs/issues/349
    // decide on streaming interceptors and middlewares
    static initializeStreamingInterceptors(headers) {
        return [headers_interceptor_1.HeaderInterceptor.createHeadersInterceptor(headers)];
    }
}
exports.PubsubClient = PubsubClient;
PubsubClient.DEFAULT_REQUEST_TIMEOUT_MS = 5 * 1000;
PubsubClient.DEFAULT_MAX_SESSION_MEMORY_MB = 256;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pubsub-client.js","sourceRoot":"","sources":["../../../src/internal/pubsub-client.ts"],"names":[],"mappings":";;;AAAA,gEAAkD;AAClD,IAAO,UAAU,GAAG,wBAAM,CAAC,YAAY,CAAC,MAAM,CAAC;AAC/C,0GAA0G;AAC1G,oEAAqE;AACrE,qFAA6E;AAC7E,2CAA4E;AAC5E,qDAA2C;AAC3C,4EAAsE;AACtE,2BAUa;AACb,uEAA2E;AAC3E,oHAImF;AAGnF,sEAA6E;AAC7E,gEAA0D;AAE1D,MAAa,YAAa,SAAQ,2CAAkC;IASlE,wDAAwD;IACxD,uCAAuC;IAEvC;;OAEG;IACH,YAAY,KAA0B;QACpC,KAAK,CACH,KAAK,CAAC,aAAa,CAAC,gBAAgB,EAAE,EACtC,KAAK,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,EACnE,IAAI,oDAAuB,CAAC,KAAK,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC,CACpE,CAAC;QACF,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;QACnD,IAAI,CAAC,qBAAqB,GAAG,YAAY,CAAC,0BAA0B,CAAC;QACrE,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,0CAA0C,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,GAAG,CACxF,CAAC;QAEF,MAAM,eAAe,GAA2B,KAAK,CAAC,aAAa;aAChE,oBAAoB,EAAE;aACtB,aAAa,EAAE,CAAC;QAEnB,8FAA8F;QAC9F,mDAAmD;QACnD,MAAM,UAAU,GAAG,IAAI,2BAAuB,CAAC;YAC7C,cAAc,EAAE,IAAI,CAAC,qBAAqB;YAC1C,kBAAkB,EAAE,YAAY,CAAC,6BAA6B;YAC9D,2BAA2B,EACzB,eAAe,CAAC,8BAA8B,EAAE;YAClD,eAAe,EAAE,eAAe,CAAC,kBAAkB,EAAE;YACrD,kBAAkB,EAAE,eAAe,CAAC,qBAAqB,EAAE;SAC5D,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,IAAA,uDAAgC,EAAC,UAAU,CAAC,CAAC;QAEpE,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,gDAAgD,IAAI,CAAC,SAAS,CAC5D,cAAc,EACd,IAAI,EACJ,CAAC,CACF,EAAE,CACJ,CAAC;QAEF,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC,YAAY,CACvC,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,EAC1C,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,EAAE;YAC7C,CAAC,CAAC,4BAAkB,CAAC,SAAS,EAAE;YAChC,CAAC,CAAC,4BAAkB,CAAC,cAAc,EAAE,EACvC,cAAc,CACf,CAAC;QAEF,MAAM,OAAO,GAAa;YACxB,IAAI,4BAAM,CAAC,eAAe,EAAE,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;YACnE,IAAI,4BAAM,CAAC,OAAO,EAAE,gBAAgB,sBAAO,EAAE,CAAC;YAC9C,IAAI,4BAAM,CAAC,iBAAiB,EAAE,UAAU,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;SACjE,CAAC;QACF,IAAI,CAAC,iBAAiB,GAAG,YAAY,CAAC,2BAA2B,CAC/D,OAAO,EACP,KAAK,CAAC,aAAa,EACnB,IAAI,CAAC,qBAAqB,CAC3B,CAAC;QACF,IAAI,CAAC,qBAAqB;YACxB,YAAY,CAAC,+BAA+B,CAAC,OAAO,CAAC,CAAC;IAC1D,CAAC;IAEM,WAAW;QAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;QAC5D,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAC;QAC5D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAES,KAAK,CAAC,WAAW,CACzB,SAAiB,EACjB,SAAiB,EACjB,KAA0B;QAE1B,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC;QAChD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC;SACzB;aAAM;YACL,UAAU,CAAC,MAAM,GAAG,KAAK,CAAC;SAC3B;QAED,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,eAAe,CAAC;YAC7C,UAAU,EAAE,SAAS;YACrB,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,UAAU;SAClB,CAAC,CAAC;QAEH,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,IAAI,CAAC,MAAM,CAAC,OAAO,CACjB,OAAO,EACP;gBACE,YAAY,EAAE,IAAI,CAAC,iBAAiB;aACrC,EACD,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;gBACZ,IAAI,IAAI,EAAE;oBACR,OAAO,CAAC,IAAI,gBAAY,CAAC,OAAO,EAAE,CAAC,CAAC;iBACrC;qBAAM;oBACL,IAAI,CAAC,0BAA0B,EAAE,CAAC,oBAAoB,CAAC;wBACrD,GAAG,EAAE,GAAG;wBACR,sBAAsB,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,gBAAY,CAAC,KAAK,CAAC,CAAC,CAAC;wBACtD,SAAS,EAAE,OAAO;wBAClB,QAAQ,EAAE,MAAM;qBACjB,CAAC,CAAC;iBACJ;YACH,CAAC,CACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;OAYG;IACgB,aAAa,CAC9B,OAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,oBAAoB,CAAC;YAClD,UAAU,EAAE,OAAO,CAAC,SAAS;YAC7B,KAAK,EAAE,OAAO,CAAC,SAAS;YACxB,+BAA+B,EAC7B,OAAO,CAAC,iBAAiB,CAAC,2BAA2B;SACxD,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,+DAA+D,EAC/D,OAAO,CAAC,iBAAiB,CAAC,2BAA2B,CACtD,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE;YAC1C,YAAY,EAAE,IAAI,CAAC,qBAAqB;SACzC,CAAC,CAAC;QACH,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;QAE1C,yCAAyC;QACzC,kEAAkE;QAClE,mEAAmE;QACnE,iDAAiD;QACjD,OAAO,CAAC,iBAAiB,CAAC,aAAa,GAAG,GAAG,EAAE;YAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC,CAAC;QAEF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;YACtC,MAAM,sBAAsB,GAAoC;gBAC9D,GAAG,OAAO;gBACV,OAAO;aACR,CAAC;YACF,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,sBAAsB,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,sBAAsB,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,mBAAmB,CACzB,OAAwC;QAExC,OAAO,CAAC,IAAkC,EAAE,EAAE;YAC5C,IAAI,OAAO,CAAC,YAAY,EAAE;gBACxB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;aACvC;YACD,OAAO,CAAC,YAAY,GAAG,KAAK,CAAC;YAE7B,IAAI,IAAI,CAAC,IAAI,EAAE;gBACb,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC;gBACvD,OAAO,CAAC,iBAAiB,CAAC,uBAAuB,GAAG,cAAc,CAAC;gBACnE,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,yEAAyE,EACzE,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,EACjC,cAAc,CACf,CAAC;gBACF,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;oBACxB,OAAO,CAAC,MAAM,CACZ,IAAI,aAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,EAAE;wBAClD,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY;qBAChC,CAAC,CACH,CAAC;iBACH;qBAAM,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;oBACjC,OAAO,CAAC,MAAM,CACZ,IAAI,aAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,cAAc,EAAE;wBACpD,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY;qBAChC,CAAC,CACH,CAAC;iBACH;qBAAM;oBACL,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,yDAAyD,EACzD,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAClC,CAAC;oBACF,OAAO,CAAC,OAAO,CACb,IAAI,kBAAc,CAAC,KAAK,CACtB,IAAI,gBAAY,CAAC,yBAAyB,CAAC,CAC5C,EACD,OAAO,CAAC,YAAY,CACrB,CAAC;iBACH;aACF;iBAAM,IAAI,IAAI,CAAC,SAAS,EAAE;gBACzB,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,wDAAwD,EACxD,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAClC,CAAC;gBACF,OAAO,CAAC,WAAW,CAAC,IAAI,kBAAc,EAAE,CAAC,CAAC;aAC3C;iBAAM,IAAI,IAAI,CAAC,aAAa,EAAE;gBAC7B,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,4DAA4D,EAC5D,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAClC,CAAC;gBACF,OAAO,CAAC,eAAe,CACrB,IAAI,sBAAkB,CACpB,IAAI,CAAC,aAAa,CAAC,mBAAmB,EACtC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CACtC,CACF,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,+CAA+C,EAC/C,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAClC,CAAC;gBACF,OAAO,CAAC,OAAO,CACb,IAAI,kBAAc,CAAC,KAAK,CAAC,IAAI,gBAAY,CAAC,mBAAmB,CAAC,CAAC,EAC/D,OAAO,CAAC,YAAY,CACrB,CAAC;aACH;QACH,CAAC,CAAC;IACJ,CAAC;IAEO,oBAAoB,CAC1B,OAAwC;QAExC,OAAO,CAAC,GAAU,EAAE,EAAE;YACpB,+EAA+E;YAC/E,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,YAAY,EAAE;gBAC3C,OAAO;aACR;YAED,MAAM,YAAY,GAAG,GAA8B,CAAC;YACpD,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CACpB,sCAAsC,YAAY,CAAC,IAAI,KAAK,YAAY,CAAC,OAAO,KAAK,YAAY,CAAC,OAAO,EAAE,CAC5G,CAAC;YACF,MAAM,2BAA2B;YAC/B,sHAAsH;YACtH,gHAAgH;YAChH,mEAAmE;YACnE,8CAA8C;YAC9C,yEAAyE;YACzE,IAAI,CAAC;YACP,MAAM,YAAY,GAAG,IAAI,kBAAc,CAAC,KAAK,CAC3C,IAAI,CAAC,0BAA0B,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAC7D,CAAC;YACF,IAAI,CAAC,oBAAoB,CACvB,OAAO,EACP,YAAY,EACZ,2BAA2B,CAC5B,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,2BAA2B,CACxC,OAAiB,EACjB,aAAiC,EACjC,gBAAwB;QAExB,OAAO;YACL,IAAA,gDAAsB,EAAC,aAAa,CAAC,gBAAgB,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;YAChE,uCAAiB,CAAC,wBAAwB,CAAC,OAAO,CAAC;YACnD,oCAAgB,CAAC,sBAAsB,CAAC;gBACtC,UAAU,EAAE,cAAc;gBAC1B,aAAa,EAAE,aAAa,CAAC,gBAAgB,EAAE;gBAC/C,uBAAuB,EAAE,gBAAgB;aAC1C,CAAC;SACH,CAAC;IACJ,CAAC;IAED,iEAAiE;IACjE,mDAAmD;IAC3C,MAAM,CAAC,+BAA+B,CAC5C,OAAiB;QAEjB,OAAO,CAAC,uCAAiB,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/D,CAAC;;AAvSH,oCAwSC;AApSyB,uCAA0B,GAAW,CAAC,GAAG,IAAI,CAAC;AAC9C,0CAA6B,GAAW,GAAG,CAAC","sourcesContent":["import {pubsub} from '@gomomento/generated-types';\nimport grpcPubsub = pubsub.cache_client.pubsub;\n// older versions of node don't have the global util variables https://github.com/nodejs/node/issues/20365\nimport {Header, HeaderInterceptor} from './grpc/headers-interceptor';\nimport {CacheServiceErrorMapper} from '../errors/cache-service-error-mapper';\nimport {ChannelCredentials, Interceptor, ServiceError} from '@grpc/grpc-js';\nimport {version} from '../../package.json';\nimport {middlewaresInterceptor} from './grpc/middlewares-interceptor';\nimport {\n  CredentialProvider,\n  StaticGrpcConfiguration,\n  TopicDiscontinuity,\n  TopicHeartbeat,\n  TopicGrpcConfiguration,\n  TopicItem,\n  TopicPublish,\n  TopicSubscribe,\n  UnknownError,\n} from '../';\nimport {truncateString} from '@gomomento/sdk-core/dist/src/internal/utils';\nimport {\n  AbstractPubsubClient,\n  SendSubscribeOptions,\n  PrepareSubscribeCallbackOptions,\n} from '@gomomento/sdk-core/dist/src/internal/clients/pubsub/AbstractPubsubClient';\nimport {TopicConfiguration} from '../config/topic-configuration';\nimport {TopicClientAllProps} from './topic-client-all-props';\nimport {grpcChannelOptionsFromGrpcConfig} from './grpc/grpc-channel-options';\nimport {RetryInterceptor} from './grpc/retry-interceptor';\n\nexport class PubsubClient extends AbstractPubsubClient<ServiceError> {\n  private readonly client: grpcPubsub.PubsubClient;\n  protected readonly credentialProvider: CredentialProvider;\n  private readonly unaryRequestTimeoutMs: number;\n  private static readonly DEFAULT_REQUEST_TIMEOUT_MS: number = 5 * 1000;\n  private static readonly DEFAULT_MAX_SESSION_MEMORY_MB: number = 256;\n  private readonly unaryInterceptors: Interceptor[];\n  private readonly streamingInterceptors: Interceptor[];\n\n  // private static readonly RST_STREAM_NO_ERROR_MESSAGE =\n  //   'Received RST_STREAM with code 0';\n\n  /**\n   * @param {TopicClientProps} props\n   */\n  constructor(props: TopicClientAllProps) {\n    super(\n      props.configuration.getLoggerFactory(),\n      props.configuration.getLoggerFactory().getLogger(PubsubClient.name),\n      new CacheServiceErrorMapper(props.configuration.getThrowOnErrors())\n    );\n    this.credentialProvider = props.credentialProvider;\n    this.unaryRequestTimeoutMs = PubsubClient.DEFAULT_REQUEST_TIMEOUT_MS;\n    this.getLogger().debug(\n      `Creating topic client using endpoint: '${this.credentialProvider.getCacheEndpoint()}'`\n    );\n\n    const topicGrpcConfig: TopicGrpcConfiguration = props.configuration\n      .getTransportStrategy()\n      .getGrpcConfig();\n\n    // NOTE: This is hard-coded for now but we may want to expose it via TopicConfiguration in the\n    // future, as we do with some of the other clients.\n    const grpcConfig = new StaticGrpcConfiguration({\n      deadlineMillis: this.unaryRequestTimeoutMs,\n      maxSessionMemoryMb: PubsubClient.DEFAULT_MAX_SESSION_MEMORY_MB,\n      keepAlivePermitWithoutCalls:\n        topicGrpcConfig.getKeepAlivePermitWithoutCalls(),\n      keepAliveTimeMs: topicGrpcConfig.getKeepAliveTimeMS(),\n      keepAliveTimeoutMs: topicGrpcConfig.getKeepAliveTimeoutMS(),\n    });\n\n    const channelOptions = grpcChannelOptionsFromGrpcConfig(grpcConfig);\n\n    this.getLogger().debug(\n      `Creating pubsub client with channel options: ${JSON.stringify(\n        channelOptions,\n        null,\n        2\n      )}`\n    );\n\n    this.client = new grpcPubsub.PubsubClient(\n      this.credentialProvider.getCacheEndpoint(),\n      this.credentialProvider.isCacheEndpointSecure()\n        ? ChannelCredentials.createSsl()\n        : ChannelCredentials.createInsecure(),\n      channelOptions\n    );\n\n    const headers: Header[] = [\n      new Header('Authorization', this.credentialProvider.getAuthToken()),\n      new Header('agent', `nodejs:topic:${version}`),\n      new Header('runtime-version', `nodejs:${process.versions.node}`),\n    ];\n    this.unaryInterceptors = PubsubClient.initializeUnaryInterceptors(\n      headers,\n      props.configuration,\n      this.unaryRequestTimeoutMs\n    );\n    this.streamingInterceptors =\n      PubsubClient.initializeStreamingInterceptors(headers);\n  }\n\n  public getEndpoint(): string {\n    const endpoint = this.credentialProvider.getCacheEndpoint();\n    this.getLogger().debug(`Using cache endpoint: ${endpoint}`);\n    return endpoint;\n  }\n\n  protected async sendPublish(\n    cacheName: string,\n    topicName: string,\n    value: string | Uint8Array\n  ): Promise<TopicPublish.Response> {\n    const topicValue = new grpcPubsub._TopicValue();\n    if (typeof value === 'string') {\n      topicValue.text = value;\n    } else {\n      topicValue.binary = value;\n    }\n\n    const request = new grpcPubsub._PublishRequest({\n      cache_name: cacheName,\n      topic: topicName,\n      value: topicValue,\n    });\n\n    return await new Promise((resolve, reject) => {\n      this.client.Publish(\n        request,\n        {\n          interceptors: this.unaryInterceptors,\n        },\n        (err, resp) => {\n          if (resp) {\n            resolve(new TopicPublish.Success());\n          } else {\n            this.getCacheServiceErrorMapper().resolveOrRejectError({\n              err: err,\n              errorResponseFactoryFn: e => new TopicPublish.Error(e),\n              resolveFn: resolve,\n              rejectFn: reject,\n            });\n          }\n        }\n      );\n    });\n  }\n\n  /**\n   * @remark This method is responsible for restarting the stream if it ends unexpectedly.\n   * Since we return a single subscription object to the user, we need to update it with the\n   * unsubscribe function should we restart the stream. This is why we pass the subscription\n   * state and subscription object to this method.\n   *\n   * Handling a cache not exists requires special care as well. In the most likely case,\n   * when the subscription starts and the cache does not exist, we receive an error immediately.\n   * We return an error from the subscribe method and do immediately unsubscribe. In a distinct,\n   * unlikely but possible case, the user deletes the cache while the stream is running. In this\n   * case we already returned a subscription object to the user, so we instead cancel the stream and\n   * propagate an error to the user via the error handler.\n   */\n  protected override sendSubscribe(\n    options: SendSubscribeOptions\n  ): Promise<TopicSubscribe.Response> {\n    const request = new grpcPubsub._SubscriptionRequest({\n      cache_name: options.cacheName,\n      topic: options.topicName,\n      resume_at_topic_sequence_number:\n        options.subscriptionState.resumeAtTopicSequenceNumber,\n    });\n\n    this.getLogger().trace(\n      'Subscribing to topic with resume_at_topic_sequence_number: %s',\n      options.subscriptionState.resumeAtTopicSequenceNumber\n    );\n    const call = this.client.Subscribe(request, {\n      interceptors: this.streamingInterceptors,\n    });\n    options.subscriptionState.setSubscribed();\n\n    // Allow the caller to cancel the stream.\n    // Note that because we restart the stream on error or stream end,\n    // we need to ensure we keep the same subscription object. That way\n    // stream restarts are transparent to the caller.\n    options.subscriptionState.unsubscribeFn = () => {\n      call.cancel();\n    };\n\n    return new Promise((resolve, _reject) => {\n      const prepareCallbackOptions: PrepareSubscribeCallbackOptions = {\n        ...options,\n        resolve,\n      };\n      call.on('data', this.prepareDataCallback(prepareCallbackOptions));\n      call.on('error', this.prepareErrorCallback(prepareCallbackOptions));\n      call.on('end', this.prepareEndCallback(prepareCallbackOptions));\n    });\n  }\n\n  private prepareDataCallback(\n    options: PrepareSubscribeCallbackOptions\n  ): (resp: grpcPubsub._SubscriptionItem) => void {\n    return (resp: grpcPubsub._SubscriptionItem) => {\n      if (options.firstMessage) {\n        options.resolve(options.subscription);\n      }\n      options.firstMessage = false;\n\n      if (resp.item) {\n        const sequenceNumber = resp.item.topic_sequence_number;\n        options.subscriptionState.lastTopicSequenceNumber = sequenceNumber;\n        this.getLogger().trace(\n          'Received an item on subscription stream; topic: %s; sequence number: %s',\n          truncateString(options.topicName),\n          sequenceNumber\n        );\n        if (resp.item.value.text) {\n          options.onItem(\n            new TopicItem(resp.item.value.text, sequenceNumber, {\n              tokenId: resp.item.publisher_id,\n            })\n          );\n        } else if (resp.item.value.binary) {\n          options.onItem(\n            new TopicItem(resp.item.value.binary, sequenceNumber, {\n              tokenId: resp.item.publisher_id,\n            })\n          );\n        } else {\n          this.getLogger().error(\n            'Received subscription item with unknown type; topic: %s',\n            truncateString(options.topicName)\n          );\n          options.onError(\n            new TopicSubscribe.Error(\n              new UnknownError('Unknown item value type')\n            ),\n            options.subscription\n          );\n        }\n      } else if (resp.heartbeat) {\n        this.getLogger().trace(\n          'Received heartbeat from subscription stream; topic: %s',\n          truncateString(options.topicName)\n        );\n        options.onHeartbeat(new TopicHeartbeat());\n      } else if (resp.discontinuity) {\n        this.getLogger().trace(\n          'Received discontinuity from subscription stream; topic: %s',\n          truncateString(options.topicName)\n        );\n        options.onDiscontinuity(\n          new TopicDiscontinuity(\n            resp.discontinuity.last_topic_sequence,\n            resp.discontinuity.new_topic_sequence\n          )\n        );\n      } else {\n        this.getLogger().error(\n          'Received unknown subscription item; topic: %s',\n          truncateString(options.topicName)\n        );\n        options.onError(\n          new TopicSubscribe.Error(new UnknownError('Unknown item type')),\n          options.subscription\n        );\n      }\n    };\n  }\n\n  private prepareErrorCallback(\n    options: PrepareSubscribeCallbackOptions\n  ): (err: Error) => void {\n    return (err: Error) => {\n      // When the caller unsubscribes, we may get a follow on error, which we ignore.\n      if (!options.subscriptionState.isSubscribed) {\n        return;\n      }\n\n      const serviceError = err as unknown as ServiceError;\n      this.getLogger().trace(\n        `Subscription encountered an error: ${serviceError.code}: ${serviceError.message}: ${serviceError.details}`\n      );\n      const shouldReconnectSubscription =\n        // previously, we were only attempting a reconnect on this one very specific case, but our current expectation is that\n        // we should err on the side of retrying. This may become a sort of \"deny list\" of error types to *not* retry on\n        // in the future, but for now we will be aggressive about retrying.\n        // // serviceError.code === Status.INTERNAL &&\n        //  // serviceError.details === PubsubClient.RST_STREAM_NO_ERROR_MESSAGE;\n        true;\n      const momentoError = new TopicSubscribe.Error(\n        this.getCacheServiceErrorMapper().convertError(serviceError)\n      );\n      this.handleSubscribeError(\n        options,\n        momentoError,\n        shouldReconnectSubscription\n      );\n    };\n  }\n\n  private static initializeUnaryInterceptors(\n    headers: Header[],\n    configuration: TopicConfiguration,\n    requestTimeoutMs: number\n  ): Interceptor[] {\n    return [\n      middlewaresInterceptor(configuration.getLoggerFactory(), [], {}),\n      HeaderInterceptor.createHeadersInterceptor(headers),\n      RetryInterceptor.createRetryInterceptor({\n        clientName: 'PubSubClient',\n        loggerFactory: configuration.getLoggerFactory(),\n        overallRequestTimeoutMs: requestTimeoutMs,\n      }),\n    ];\n  }\n\n  // TODO https://github.com/momentohq/client-sdk-nodejs/issues/349\n  // decide on streaming interceptors and middlewares\n  private static initializeStreamingInterceptors(\n    headers: Header[]\n  ): Interceptor[] {\n    return [HeaderInterceptor.createHeadersInterceptor(headers)];\n  }\n}\n"]}