package.dist.src.config.configurations.js Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sdk Show documentation
Client SDK for Momento services
The newest version!
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InRegion = exports.Lambda = exports.Laptop = void 0;
const configuration_1 = require("./configuration");
const fixed_count_retry_strategy_1 = require("./retry/fixed-count-retry-strategy");
const sdk_core_1 = require("@gomomento/sdk-core");
const __1 = require("..");
const default_momento_logger_1 = require("./logging/default-momento-logger");
// 4 minutes.  We want to remain comfortably underneath the idle timeout for AWS NLB, which is 350s.
const defaultMaxIdleMillis = 4 * 60 * 1000;
const defaultMaxSessionMemoryMb = 256;
const defaultLoggerFactory = new default_momento_logger_1.DefaultMomentoLoggerFactory();
const defaultMiddlewares = [];
function defaultRetryStrategy(loggerFactory) {
    return new fixed_count_retry_strategy_1.FixedCountRetryStrategy({
        loggerFactory: loggerFactory,
        maxAttempts: 3,
    });
}
/**
 * Laptop config provides defaults suitable for a medium-to-high-latency dev environment.  Permissive timeouts, retries, and
 * relaxed latency and throughput targets.
 * @export
 * @class Laptop
 */
class Laptop extends configuration_1.CacheConfiguration {
    /**
     * Provides the latest recommended configuration for a laptop development environment.  NOTE: this configuration may
     * change in future releases to take advantage of improvements we identify for default configurations.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static latest(loggerFactory = defaultLoggerFactory) {
        return Laptop.v1(loggerFactory);
    }
    /**
     * Provides v1 recommended configuration for a laptop development environment.  This configuration is guaranteed not
     * to change in future releases of the Momento node.js SDK.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static v1(loggerFactory = defaultLoggerFactory) {
        const deadlineMillis = 5000;
        const grpcConfig = new __1.StaticGrpcConfiguration({
            deadlineMillis: deadlineMillis,
            maxSessionMemoryMb: defaultMaxSessionMemoryMb,
            keepAlivePermitWithoutCalls: 1,
            keepAliveTimeMs: 5000,
            keepAliveTimeoutMs: 1000,
        });
        const transportStrategy = new __1.StaticTransportStrategy({
            grpcConfiguration: grpcConfig,
            maxIdleMillis: defaultMaxIdleMillis,
        });
        return new Laptop({
            loggerFactory: loggerFactory,
            retryStrategy: defaultRetryStrategy(loggerFactory),
            transportStrategy: transportStrategy,
            middlewares: defaultMiddlewares,
            throwOnErrors: false,
            readConcern: sdk_core_1.ReadConcern.BALANCED,
            compression: undefined,
        });
    }
}
exports.Laptop = Laptop;
class Lambda extends configuration_1.CacheConfiguration {
    /**
     * Provides the latest recommended configuration for a lambda environment.  NOTE: this configuration may
     * change in future releases to take advantage of improvements we identify for default configurations.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static latest(loggerFactory = defaultLoggerFactory) {
        const deadlineMillis = 1100;
        const grpcConfig = new __1.StaticGrpcConfiguration({
            deadlineMillis: deadlineMillis,
            maxSessionMemoryMb: defaultMaxSessionMemoryMb,
            numClients: 1,
        });
        const transportStrategy = new __1.StaticTransportStrategy({
            grpcConfiguration: grpcConfig,
            maxIdleMillis: defaultMaxIdleMillis,
        });
        return new Lambda({
            loggerFactory: loggerFactory,
            retryStrategy: defaultRetryStrategy(loggerFactory),
            transportStrategy: transportStrategy,
            middlewares: defaultMiddlewares,
            throwOnErrors: false,
            readConcern: sdk_core_1.ReadConcern.BALANCED,
            compression: undefined,
        });
    }
}
exports.Lambda = Lambda;
class InRegionDefault extends configuration_1.CacheConfiguration {
    /**
     * Provides the latest recommended configuration for a typical in-region environment.  NOTE: this configuration may
     * change in future releases to take advantage of improvements we identify for default configurations.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static latest(loggerFactory = defaultLoggerFactory) {
        return InRegionDefault.v1(loggerFactory);
    }
    /**
     * Provides v1 recommended configuration for a typical in-region environment.  This configuration is guaranteed not
     * to change in future releases of the Momento node.js SDK.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static v1(loggerFactory = defaultLoggerFactory) {
        const deadlineMillis = 1100;
        const grpcConfig = new __1.StaticGrpcConfiguration({
            deadlineMillis: deadlineMillis,
            maxSessionMemoryMb: defaultMaxSessionMemoryMb,
            keepAlivePermitWithoutCalls: 1,
            keepAliveTimeMs: 5000,
            keepAliveTimeoutMs: 1000,
        });
        const transportStrategy = new __1.StaticTransportStrategy({
            grpcConfiguration: grpcConfig,
            maxIdleMillis: defaultMaxIdleMillis,
        });
        return new InRegionDefault({
            loggerFactory: loggerFactory,
            retryStrategy: defaultRetryStrategy(loggerFactory),
            transportStrategy: transportStrategy,
            middlewares: defaultMiddlewares,
            throwOnErrors: false,
            readConcern: sdk_core_1.ReadConcern.BALANCED,
            compression: undefined,
        });
    }
}
class InRegionLowLatency extends configuration_1.CacheConfiguration {
    /**
     * Provides the latest recommended configuration for an in-region environment with aggressive low-latency requirements.
     * NOTE: this configuration may change in future releases to take advantage of improvements we identify for default
     * configurations.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static latest(loggerFactory = defaultLoggerFactory) {
        return InRegionLowLatency.v1(loggerFactory);
    }
    /**
     * Provides v1 recommended configuration for an in-region environment with aggressive low-latency requirements.
     * This configuration is guaranteed not to change in future releases of the Momento node.js SDK.
     * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]
     * @returns {CacheConfiguration}
     */
    static v1(loggerFactory = defaultLoggerFactory) {
        const deadlineMillis = 500;
        const grpcConfig = new __1.StaticGrpcConfiguration({
            deadlineMillis: deadlineMillis,
            maxSessionMemoryMb: defaultMaxSessionMemoryMb,
            keepAlivePermitWithoutCalls: 1,
            keepAliveTimeMs: 5000,
            keepAliveTimeoutMs: 1000,
        });
        const transportStrategy = new __1.StaticTransportStrategy({
            grpcConfiguration: grpcConfig,
            maxIdleMillis: defaultMaxIdleMillis,
        });
        return new InRegionDefault({
            loggerFactory: loggerFactory,
            retryStrategy: defaultRetryStrategy(loggerFactory),
            transportStrategy: transportStrategy,
            middlewares: defaultMiddlewares,
            throwOnErrors: false,
            readConcern: sdk_core_1.ReadConcern.BALANCED,
            compression: undefined,
        });
    }
}
/**
 * InRegion provides defaults suitable for an environment where your client is running in the same region as the Momento
 * service.  It has more aggressive timeouts and retry behavior than the Laptop config.
 * @export
 * @class InRegion
 */
class InRegion {
}
exports.InRegion = InRegion;
/**
 * This config prioritizes throughput and client resource utilization.  It has a slightly relaxed client-side timeout
 * setting to maximize throughput.
 * @type {InRegionDefault}
 */
InRegion.Default = InRegionDefault;
/**
 * This config prioritizes keeping p99.9 latencies as low as possible, potentially sacrificing
 * some throughput to achieve this.  It has a very aggressive client-side timeout.  Use this
 * configuration if the most important factor is to ensure that cache unavailability doesn't force
 * unacceptably high latencies for your own application.
 * @type {InRegionLowLatency}
 */
InRegion.LowLatency = InRegionLowLatency;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configurations.js","sourceRoot":"","sources":["../../../src/config/configurations.ts"],"names":[],"mappings":";;;AAAA,mDAAmD;AACnD,mFAA2E;AAG3E,kDAAsE;AACtE,0BAKY;AACZ,6EAA6E;AAE7E,oGAAoG;AACpG,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAK,CAAC;AAC5C,MAAM,yBAAyB,GAAG,GAAG,CAAC;AACtC,MAAM,oBAAoB,GACxB,IAAI,oDAA2B,EAAE,CAAC;AACpC,MAAM,kBAAkB,GAAiB,EAAE,CAAC;AAE5C,SAAS,oBAAoB,CAC3B,aAAmC;IAEnC,OAAO,IAAI,oDAAuB,CAAC;QACjC,aAAa,EAAE,aAAa;QAC5B,WAAW,EAAE,CAAC;KACf,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAa,MAAO,SAAQ,kCAAkB;IAC5C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CACX,gBAAsC,oBAAoB;QAE1D,OAAO,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CACP,gBAAsC,oBAAoB;QAE1D,MAAM,cAAc,GAAG,IAAI,CAAC;QAC5B,MAAM,UAAU,GAAsB,IAAI,2BAAuB,CAAC;YAChE,cAAc,EAAE,cAAc;YAC9B,kBAAkB,EAAE,yBAAyB;YAC7C,2BAA2B,EAAE,CAAC;YAC9B,eAAe,EAAE,IAAI;YACrB,kBAAkB,EAAE,IAAI;SACzB,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAsB,IAAI,2BAAuB,CAAC;YACvE,iBAAiB,EAAE,UAAU;YAC7B,aAAa,EAAE,oBAAoB;SACpC,CAAC,CAAC;QACH,OAAO,IAAI,MAAM,CAAC;YAChB,aAAa,EAAE,aAAa;YAC5B,aAAa,EAAE,oBAAoB,CAAC,aAAa,CAAC;YAClD,iBAAiB,EAAE,iBAAiB;YACpC,WAAW,EAAE,kBAAkB;YAC/B,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,sBAAW,CAAC,QAAQ;YACjC,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AA5CD,wBA4CC;AAED,MAAa,MAAO,SAAQ,kCAAkB;IAC5C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CACX,gBAAsC,oBAAoB;QAE1D,MAAM,cAAc,GAAG,IAAI,CAAC;QAC5B,MAAM,UAAU,GAAsB,IAAI,2BAAuB,CAAC;YAChE,cAAc,EAAE,cAAc;YAC9B,kBAAkB,EAAE,yBAAyB;YAC7C,UAAU,EAAE,CAAC;SACd,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAsB,IAAI,2BAAuB,CAAC;YACvE,iBAAiB,EAAE,UAAU;YAC7B,aAAa,EAAE,oBAAoB;SACpC,CAAC,CAAC;QACH,OAAO,IAAI,MAAM,CAAC;YAChB,aAAa,EAAE,aAAa;YAC5B,aAAa,EAAE,oBAAoB,CAAC,aAAa,CAAC;YAClD,iBAAiB,EAAE,iBAAiB;YACpC,WAAW,EAAE,kBAAkB;YAC/B,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,sBAAW,CAAC,QAAQ;YACjC,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AA9BD,wBA8BC;AAED,MAAM,eAAgB,SAAQ,kCAAkB;IAC9C;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CACX,gBAAsC,oBAAoB;QAE1D,OAAO,eAAe,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CACP,gBAAsC,oBAAoB;QAE1D,MAAM,cAAc,GAAG,IAAI,CAAC;QAC5B,MAAM,UAAU,GAAsB,IAAI,2BAAuB,CAAC;YAChE,cAAc,EAAE,cAAc;YAC9B,kBAAkB,EAAE,yBAAyB;YAC7C,2BAA2B,EAAE,CAAC;YAC9B,eAAe,EAAE,IAAI;YACrB,kBAAkB,EAAE,IAAI;SACzB,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAsB,IAAI,2BAAuB,CAAC;YACvE,iBAAiB,EAAE,UAAU;YAC7B,aAAa,EAAE,oBAAoB;SACpC,CAAC,CAAC;QACH,OAAO,IAAI,eAAe,CAAC;YACzB,aAAa,EAAE,aAAa;YAC5B,aAAa,EAAE,oBAAoB,CAAC,aAAa,CAAC;YAClD,iBAAiB,EAAE,iBAAiB;YACpC,WAAW,EAAE,kBAAkB;YAC/B,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,sBAAW,CAAC,QAAQ;YACjC,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,kBAAmB,SAAQ,kCAAkB;IACjD;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CACX,gBAAsC,oBAAoB;QAE1D,OAAO,kBAAkB,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CACP,gBAAsC,oBAAoB;QAE1D,MAAM,cAAc,GAAG,GAAG,CAAC;QAC3B,MAAM,UAAU,GAAsB,IAAI,2BAAuB,CAAC;YAChE,cAAc,EAAE,cAAc;YAC9B,kBAAkB,EAAE,yBAAyB;YAC7C,2BAA2B,EAAE,CAAC;YAC9B,eAAe,EAAE,IAAI;YACrB,kBAAkB,EAAE,IAAI;SACzB,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAsB,IAAI,2BAAuB,CAAC;YACvE,iBAAiB,EAAE,UAAU;YAC7B,aAAa,EAAE,oBAAoB;SACpC,CAAC,CAAC;QACH,OAAO,IAAI,eAAe,CAAC;YACzB,aAAa,EAAE,aAAa;YAC5B,aAAa,EAAE,oBAAoB,CAAC,aAAa,CAAC;YAClD,iBAAiB,EAAE,iBAAiB;YACpC,WAAW,EAAE,kBAAkB;YAC/B,aAAa,EAAE,KAAK;YACpB,WAAW,EAAE,sBAAW,CAAC,QAAQ;YACjC,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAa,QAAQ;;AAArB,4BAeC;AAdC;;;;GAIG;AACI,gBAAO,GAAG,eAAe,CAAC;AACjC;;;;;;GAMG;AACI,mBAAU,GAAG,kBAAkB,CAAC","sourcesContent":["import {CacheConfiguration} from './configuration';\nimport {FixedCountRetryStrategy} from './retry/fixed-count-retry-strategy';\nimport {RetryStrategy} from './retry/retry-strategy';\nimport {Middleware} from './middleware/middleware';\nimport {MomentoLoggerFactory, ReadConcern} from '@gomomento/sdk-core';\nimport {\n  GrpcConfiguration,\n  StaticGrpcConfiguration,\n  StaticTransportStrategy,\n  TransportStrategy,\n} from '..';\nimport {DefaultMomentoLoggerFactory} from './logging/default-momento-logger';\n\n// 4 minutes.  We want to remain comfortably underneath the idle timeout for AWS NLB, which is 350s.\nconst defaultMaxIdleMillis = 4 * 60 * 1_000;\nconst defaultMaxSessionMemoryMb = 256;\nconst defaultLoggerFactory: MomentoLoggerFactory =\n  new DefaultMomentoLoggerFactory();\nconst defaultMiddlewares: Middleware[] = [];\n\nfunction defaultRetryStrategy(\n  loggerFactory: MomentoLoggerFactory\n): RetryStrategy {\n  return new FixedCountRetryStrategy({\n    loggerFactory: loggerFactory,\n    maxAttempts: 3,\n  });\n}\n\n/**\n * Laptop config provides defaults suitable for a medium-to-high-latency dev environment.  Permissive timeouts, retries, and\n * relaxed latency and throughput targets.\n * @export\n * @class Laptop\n */\nexport class Laptop extends CacheConfiguration {\n  /**\n   * Provides the latest recommended configuration for a laptop development environment.  NOTE: this configuration may\n   * change in future releases to take advantage of improvements we identify for default configurations.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static latest(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    return Laptop.v1(loggerFactory);\n  }\n\n  /**\n   * Provides v1 recommended configuration for a laptop development environment.  This configuration is guaranteed not\n   * to change in future releases of the Momento node.js SDK.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static v1(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    const deadlineMillis = 5000;\n    const grpcConfig: GrpcConfiguration = new StaticGrpcConfiguration({\n      deadlineMillis: deadlineMillis,\n      maxSessionMemoryMb: defaultMaxSessionMemoryMb,\n      keepAlivePermitWithoutCalls: 1,\n      keepAliveTimeMs: 5000,\n      keepAliveTimeoutMs: 1000,\n    });\n    const transportStrategy: TransportStrategy = new StaticTransportStrategy({\n      grpcConfiguration: grpcConfig,\n      maxIdleMillis: defaultMaxIdleMillis,\n    });\n    return new Laptop({\n      loggerFactory: loggerFactory,\n      retryStrategy: defaultRetryStrategy(loggerFactory),\n      transportStrategy: transportStrategy,\n      middlewares: defaultMiddlewares,\n      throwOnErrors: false,\n      readConcern: ReadConcern.BALANCED,\n      compression: undefined,\n    });\n  }\n}\n\nexport class Lambda extends CacheConfiguration {\n  /**\n   * Provides the latest recommended configuration for a lambda environment.  NOTE: this configuration may\n   * change in future releases to take advantage of improvements we identify for default configurations.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static latest(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    const deadlineMillis = 1100;\n    const grpcConfig: GrpcConfiguration = new StaticGrpcConfiguration({\n      deadlineMillis: deadlineMillis,\n      maxSessionMemoryMb: defaultMaxSessionMemoryMb,\n      numClients: 1,\n    });\n    const transportStrategy: TransportStrategy = new StaticTransportStrategy({\n      grpcConfiguration: grpcConfig,\n      maxIdleMillis: defaultMaxIdleMillis,\n    });\n    return new Lambda({\n      loggerFactory: loggerFactory,\n      retryStrategy: defaultRetryStrategy(loggerFactory),\n      transportStrategy: transportStrategy,\n      middlewares: defaultMiddlewares,\n      throwOnErrors: false,\n      readConcern: ReadConcern.BALANCED,\n      compression: undefined,\n    });\n  }\n}\n\nclass InRegionDefault extends CacheConfiguration {\n  /**\n   * Provides the latest recommended configuration for a typical in-region environment.  NOTE: this configuration may\n   * change in future releases to take advantage of improvements we identify for default configurations.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static latest(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    return InRegionDefault.v1(loggerFactory);\n  }\n\n  /**\n   * Provides v1 recommended configuration for a typical in-region environment.  This configuration is guaranteed not\n   * to change in future releases of the Momento node.js SDK.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static v1(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    const deadlineMillis = 1100;\n    const grpcConfig: GrpcConfiguration = new StaticGrpcConfiguration({\n      deadlineMillis: deadlineMillis,\n      maxSessionMemoryMb: defaultMaxSessionMemoryMb,\n      keepAlivePermitWithoutCalls: 1,\n      keepAliveTimeMs: 5000,\n      keepAliveTimeoutMs: 1000,\n    });\n    const transportStrategy: TransportStrategy = new StaticTransportStrategy({\n      grpcConfiguration: grpcConfig,\n      maxIdleMillis: defaultMaxIdleMillis,\n    });\n    return new InRegionDefault({\n      loggerFactory: loggerFactory,\n      retryStrategy: defaultRetryStrategy(loggerFactory),\n      transportStrategy: transportStrategy,\n      middlewares: defaultMiddlewares,\n      throwOnErrors: false,\n      readConcern: ReadConcern.BALANCED,\n      compression: undefined,\n    });\n  }\n}\n\nclass InRegionLowLatency extends CacheConfiguration {\n  /**\n   * Provides the latest recommended configuration for an in-region environment with aggressive low-latency requirements.\n   * NOTE: this configuration may change in future releases to take advantage of improvements we identify for default\n   * configurations.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static latest(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    return InRegionLowLatency.v1(loggerFactory);\n  }\n\n  /**\n   * Provides v1 recommended configuration for an in-region environment with aggressive low-latency requirements.\n   * This configuration is guaranteed not to change in future releases of the Momento node.js SDK.\n   * @param {MomentoLoggerFactory} [loggerFactory=defaultLoggerFactory]\n   * @returns {CacheConfiguration}\n   */\n  static v1(\n    loggerFactory: MomentoLoggerFactory = defaultLoggerFactory\n  ): CacheConfiguration {\n    const deadlineMillis = 500;\n    const grpcConfig: GrpcConfiguration = new StaticGrpcConfiguration({\n      deadlineMillis: deadlineMillis,\n      maxSessionMemoryMb: defaultMaxSessionMemoryMb,\n      keepAlivePermitWithoutCalls: 1,\n      keepAliveTimeMs: 5000,\n      keepAliveTimeoutMs: 1000,\n    });\n    const transportStrategy: TransportStrategy = new StaticTransportStrategy({\n      grpcConfiguration: grpcConfig,\n      maxIdleMillis: defaultMaxIdleMillis,\n    });\n    return new InRegionDefault({\n      loggerFactory: loggerFactory,\n      retryStrategy: defaultRetryStrategy(loggerFactory),\n      transportStrategy: transportStrategy,\n      middlewares: defaultMiddlewares,\n      throwOnErrors: false,\n      readConcern: ReadConcern.BALANCED,\n      compression: undefined,\n    });\n  }\n}\n\n/**\n * InRegion provides defaults suitable for an environment where your client is running in the same region as the Momento\n * service.  It has more aggressive timeouts and retry behavior than the Laptop config.\n * @export\n * @class InRegion\n */\nexport class InRegion {\n  /**\n   * This config prioritizes throughput and client resource utilization.  It has a slightly relaxed client-side timeout\n   * setting to maximize throughput.\n   * @type {InRegionDefault}\n   */\n  static Default = InRegionDefault;\n  /**\n   * This config prioritizes keeping p99.9 latencies as low as possible, potentially sacrificing\n   * some throughput to achieve this.  It has a very aggressive client-side timeout.  Use this\n   * configuration if the most important factor is to ensure that cache unavailability doesn't force\n   * unacceptably high latencies for your own application.\n   * @type {InRegionLowLatency}\n   */\n  static LowLatency = InRegionLowLatency;\n}\n"]}