@gomomento/sdk-core 1.65.4 → 1.67.0

package/dist/src/messages/responses/cache-batch-get.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Success = exports.Response = void 0;
+const response_base_1 = require("./response-base");
+const TEXT_DECODER = new TextDecoder();
+/**
+ * Parent response type for a cache get batch request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof BatchGet.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `BatchGet.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+class Response extends response_base_1.ResponseBase {
+    values() {
+        if (this instanceof Success) {
+            return this.values();
+        }
+        return undefined;
+    }
+    results() {
+        if (this instanceof Success) {
+            return this.results();
+        }
+        return undefined;
+    }
+}
+exports.Response = Response;
+class _Success extends Response {
+    constructor(items, keys) {
+        super();
+        this.items = items;
+        this.keys = keys;
+    }
+    /**
+     * Returns the status for each request in the batch as a list of CacheGet.Response objects.
+     * @returns {CacheGet.Response[]}
+     */
+    results() {
+        return this.items;
+    }
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.  This is a convenience alias for
+     * {valueRecordStringString}.
+     * @returns {Record<string, string>}
+     */
+    values() {
+        return this.valuesRecordStringString();
+    }
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.  This is a convenience alias for
+     * {valueRecordStringString}.
+     * @returns {Record<string, string>}
+     */
+    valuesRecord() {
+        return this.valuesRecordStringString();
+    }
+    /**
+     * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This can be used in most places where an Object is desired.
+     * @returns {Record<string, string>}
+     */
+    valuesRecordStringString() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.value() !== undefined) {
+                acc[TEXT_DECODER.decode(this.keys[index])] = item.valueString();
+            }
+            return acc;
+        }, {});
+    }
+    /**
+     * Returns the data as a Record whose keys are utf-8 strings, decoded from the underlying byte array, and whose
+     * values are byte arrays.  This can be used in most places where an Object is desired.
+     * @returns {Record<string, Uint8Array>}
+     */
+    valuesRecordStringUint8Array() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.value() !== undefined) {
+                acc[TEXT_DECODER.decode(this.keys[index])] = item.valueUint8Array();
+            }
+            return acc;
+        }, {});
+    }
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * This is a convenience alias for {valueMapStringString}.
+     * @returns {Map<string, string>}
+     */
+    valuesMap() {
+        return this.valuesMapStringString();
+    }
+    /**
+     * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.
+     * @returns {Map<string, string>}
+     */
+    valuesMapStringString() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.value() !== undefined) {
+                acc.set(TEXT_DECODER.decode(this.keys[index]), item.valueString());
+            }
+            return acc;
+        }, new Map());
+    }
+    /**
+     * Returns the data as a Map whose keys and values are byte arrays.
+     * @returns {Map<Uint8Array, Uint8Array>}
+     */
+    valuesMapUint8ArrayUint8Array() {
+        return this.items.reduce((acc, item, index) => {
+            if (item.value() !== undefined) {
+                acc.set(this.keys[index], item.valueUint8Array());
+            }
+            return acc;
+        }, new Map());
+    }
+    toString() {
+        const display = this.results()
+            .map(result => result.toString())
+            .toString();
+        return `${super.toString()}: ${display}`;
+    }
+}
+/**
+ * Indicates that the requested data was successfully retrieved from the cache.  Provides
+ * `value*` accessors to retrieve the data in the appropriate format.
+ */
+class Success extends (0, response_base_1.ResponseSuccess)(_Success) {
+}
+exports.Success = Success;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the cache get request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+class Error extends (0, response_base_1.ResponseError)(_Error) {
+}
+exports.Error = Error;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-batch-get.js","sourceRoot":"","sources":["../../../../src/messages/responses/cache-batch-get.ts"],"names":[],"mappings":"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","sourcesContent":["import {SdkError} from '../../errors';\nimport {ResponseBase, ResponseError, ResponseSuccess} from './response-base';\nimport {CacheGet} from '../..';\n\nconst TEXT_DECODER = new TextDecoder();\n\n/**\n * Parent response type for a cache get batch request.  The\n * response object is resolved to a type-safe object of one of\n * the following subtypes:\n *\n * - {Success}\n * - {Error}\n *\n * `instanceof` type guards can be used to operate on the appropriate subtype.\n * @example\n * For example:\n * ```\n * if (response instanceof BatchGet.Error) {\n *   // Handle error as appropriate.  The compiler will smart-cast `response` to type\n *   // `BatchGet.Error` in this block, so you will have access to the properties\n *   // of the Error class; e.g. `response.errorCode()`.\n * }\n * ```\n */\nexport abstract class Response extends ResponseBase {\n  public values(): Record<string, string> | undefined {\n    if (this instanceof Success) {\n      return (this as Success).values();\n    }\n    return undefined;\n  }\n\n  public results(): CacheGet.Response[] | undefined {\n    if (this instanceof Success) {\n      return (this as Success).results();\n    }\n    return undefined;\n  }\n}\n\nclass _Success extends Response {\n  private readonly items: CacheGet.Response[];\n  private readonly keys: Uint8Array[];\n\n  constructor(items: CacheGet.Response[], keys: Uint8Array[]) {\n    super();\n    this.items = items;\n    this.keys = keys;\n  }\n\n  /**\n   * Returns the status for each request in the batch as a list of CacheGet.Response objects.\n   * @returns {CacheGet.Response[]}\n   */\n  public results(): CacheGet.Response[] {\n    return this.items;\n  }\n\n  /**\n   * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This can be used in most places where an Object is desired.  This is a convenience alias for\n   * {valueRecordStringString}.\n   * @returns {Record<string, string>}\n   */\n  public values(): Record<string, string> {\n    return this.valuesRecordStringString();\n  }\n\n  /**\n   * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This can be used in most places where an Object is desired.  This is a convenience alias for\n   * {valueRecordStringString}.\n   * @returns {Record<string, string>}\n   */\n  public valuesRecord(): Record<string, string> {\n    return this.valuesRecordStringString();\n  }\n\n  /**\n   * Returns the data as a Record whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This can be used in most places where an Object is desired.\n   * @returns {Record<string, string>}\n   */\n  public valuesRecordStringString(): Record<string, string> {\n    return this.items.reduce<Record<string, string>>((acc, item, index) => {\n      if (item.value() !== undefined) {\n        acc[TEXT_DECODER.decode(this.keys[index])] = (\n          item as CacheGet.Hit\n        ).valueString();\n      }\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Returns the data as a Record whose keys are utf-8 strings, decoded from the underlying byte array, and whose\n   * values are byte arrays.  This can be used in most places where an Object is desired.\n   * @returns {Record<string, Uint8Array>}\n   */\n  public valuesRecordStringUint8Array(): Record<string, Uint8Array> {\n    return this.items.reduce<Record<string, Uint8Array>>((acc, item, index) => {\n      if (item.value() !== undefined) {\n        acc[TEXT_DECODER.decode(this.keys[index])] = (\n          item as CacheGet.Hit\n        ).valueUint8Array();\n      }\n      return acc;\n    }, {});\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * This is a convenience alias for {valueMapStringString}.\n   * @returns {Map<string, string>}\n   */\n  public valuesMap(): Map<string, string> {\n    return this.valuesMapStringString();\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are utf-8 strings, decoded from the underlying byte arrays.\n   * @returns {Map<string, string>}\n   */\n  public valuesMapStringString(): Map<string, string> {\n    return this.items.reduce((acc, item, index) => {\n      if (item.value() !== undefined) {\n        acc.set(\n          TEXT_DECODER.decode(this.keys[index]),\n          (item as CacheGet.Hit).valueString()\n        );\n      }\n      return acc;\n    }, new Map<string, string>());\n  }\n\n  /**\n   * Returns the data as a Map whose keys and values are byte arrays.\n   * @returns {Map<Uint8Array, Uint8Array>}\n   */\n  public valuesMapUint8ArrayUint8Array(): Map<Uint8Array, Uint8Array> {\n    return this.items.reduce((acc, item, index) => {\n      if (item.value() !== undefined) {\n        acc.set(this.keys[index], (item as CacheGet.Hit).valueUint8Array());\n      }\n      return acc;\n    }, new Map<Uint8Array, Uint8Array>());\n  }\n\n  public override toString(): string {\n    const display = this.results()\n      .map(result => result.toString())\n      .toString();\n    return `${super.toString()}: ${display}`;\n  }\n}\n\n/**\n * Indicates that the requested data was successfully retrieved from the cache.  Provides\n * `value*` accessors to retrieve the data in the appropriate format.\n */\nexport class Success extends ResponseSuccess(_Success) {}\n\nclass _Error extends Response {\n  constructor(protected _innerException: SdkError) {\n    super();\n  }\n}\n\n/**\n * Indicates that an error occurred during the cache get request.\n *\n * This response object includes the following fields that you can use to determine\n * how you would like to handle the error:\n *\n * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.\n * - `message()` - a human-readable description of the error\n * - `innerException()` - the original error that caused the failure; can be re-thrown.\n */\nexport class Error extends ResponseError(_Error) {}\n"]}

package/dist/src/messages/responses/cache-batch-set.d.ts

@@ -0,0 +1,73 @@
+import { CacheSet } from '../..';
+import { SdkError } from '../../errors';
+import { ResponseBase } from './response-base';
+/**
+ * Parent response type for a cache set batch request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof SetBatch.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `SetBatch.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+export declare abstract class Response extends ResponseBase {
+    results(): CacheSet.Response[] | undefined;
+}
+declare class _Success extends Response {
+    private readonly body;
+    constructor(body: CacheSet.Response[]);
+    /**
+     * Returns the status for each request in the batch as a list of CacheGet.Response objects.
+     * @returns {CacheSet.Response[]}
+     */
+    results(): CacheSet.Response[];
+}
+declare const Success_base: {
+    new (...args: any[]): {
+        readonly is_success: boolean;
+    };
+} & typeof _Success;
+/**
+ * Indicates a Successful cache set request.
+ */
+export declare class Success extends Success_base {
+}
+declare class _Error extends Response {
+    protected _innerException: SdkError;
+    constructor(_innerException: SdkError);
+}
+declare const Error_base: {
+    new (...args: any[]): {
+        _innerException: SdkError;
+        message(): string;
+        innerException(): SdkError; /**
+         * Returns the status for each request in the batch as a list of CacheGet.Response objects.
+         * @returns {CacheSet.Response[]}
+         */
+        errorCode(): import("../..").MomentoErrorCode;
+        toString(): string;
+    };
+} & typeof _Error;
+/**
+ * Indicates that an error occurred during the cache set request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+export declare class Error extends Error_base {
+}
+export {};

package/dist/src/messages/responses/cache-batch-set.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.Success = exports.Response = void 0;
+const response_base_1 = require("./response-base");
+/**
+ * Parent response type for a cache set batch request.  The
+ * response object is resolved to a type-safe object of one of
+ * the following subtypes:
+ *
+ * - {Success}
+ * - {Error}
+ *
+ * `instanceof` type guards can be used to operate on the appropriate subtype.
+ * @example
+ * For example:
+ * ```
+ * if (response instanceof SetBatch.Error) {
+ *   // Handle error as appropriate.  The compiler will smart-cast `response` to type
+ *   // `SetBatch.Error` in this block, so you will have access to the properties
+ *   // of the Error class; e.g. `response.errorCode()`.
+ * }
+ * ```
+ */
+class Response extends response_base_1.ResponseBase {
+    results() {
+        if (this instanceof Success) {
+            return this.results();
+        }
+        return undefined;
+    }
+}
+exports.Response = Response;
+class _Success extends Response {
+    constructor(body) {
+        super();
+        this.body = body;
+    }
+    /**
+     * Returns the status for each request in the batch as a list of CacheGet.Response objects.
+     * @returns {CacheSet.Response[]}
+     */
+    results() {
+        return this.body;
+    }
+}
+/**
+ * Indicates a Successful cache set request.
+ */
+class Success extends (0, response_base_1.ResponseSuccess)(_Success) {
+}
+exports.Success = Success;
+class _Error extends Response {
+    constructor(_innerException) {
+        super();
+        this._innerException = _innerException;
+    }
+}
+/**
+ * Indicates that an error occurred during the cache set request.
+ *
+ * This response object includes the following fields that you can use to determine
+ * how you would like to handle the error:
+ *
+ * - `errorCode()` - a unique Momento error code indicating the type of error that occurred.
+ * - `message()` - a human-readable description of the error
+ * - `innerException()` - the original error that caused the failure; can be re-thrown.
+ */
+class Error extends (0, response_base_1.ResponseError)(_Error) {
+}
+exports.Error = Error;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/collection-ttl.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionTtl = void 0;
+const utils_1 = require("../internal/utils");
 /** Represents the desired behavior for managing the TTL on collection
  *  objects (dictionaries, lists, sets) in your cache.
  *
@@ -26,6 +27,9 @@ class CollectionTtl {
      * @param {boolean} [refreshTtl=true]
      */
     constructor(ttlSeconds = null, refreshTtl = true) {
+        if (ttlSeconds !== null) {
+            (0, utils_1.validateTtlSeconds)(ttlSeconds);
+        }
         this._refreshTtl = refreshTtl;
         this._ttlSeconds = ttlSeconds;
     }
@@ -99,4 +103,4 @@ class CollectionTtl {
     }
 }
 exports.CollectionTtl = CollectionTtl;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gomomento/sdk-core",
-  "version": "1.65.4",
+  "version": "1.67.0",
   "description": "Common code for Momento JS SDKs",
   "main": "dist/src/index.js",
   "files": [