@gomomento/sdk-core 1.16.2 → 1.18.0

package/dist/src/internal/clients/cache/ICacheClient.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ICacheClient.js","sourceRoot":"","sources":["../../../../../src/internal/clients/cache/ICacheClient.ts"],"names":[],"mappings":"","sourcesContent":["import {IControlClient} from './IControlClient';\nimport {\n  CacheDelete,\n  CacheGet,\n  CacheIncrement,\n  CacheSet,\n  CacheSetIfNotExists,\n  CacheSetFetch,\n  CacheSetAddElements,\n  CacheSetAddElement,\n  CacheSetRemoveElements,\n  CacheSetRemoveElement,\n  CacheListFetch,\n  CacheListLength,\n  CacheListPushFront,\n  CacheListPushBack,\n  CacheListConcatenateBack,\n  CacheListConcatenateFront,\n  CacheListPopBack,\n  CacheListPopFront,\n  CacheListRemoveValue,\n  CacheListRetain,\n  CacheDictionarySetField,\n  CacheDictionarySetFields,\n  CacheDictionaryGetField,\n  CacheDictionaryFetch,\n  CacheDictionaryIncrement,\n  CacheDictionaryRemoveField,\n  CacheDictionaryRemoveFields,\n  CacheSortedSetFetch,\n  CacheSortedSetPutElement,\n  CacheSortedSetPutElements,\n  CacheSortedSetGetRank,\n  CacheSortedSetGetScore,\n  CacheSortedSetGetScores,\n  CacheSortedSetIncrementScore,\n  CacheSortedSetRemoveElement,\n  ItemGetType,\n} from '../../../index';\nimport {\n  ScalarCallOptions,\n  ListFetchCallOptions,\n  ListRetainCallOptions,\n  BackTruncatableCallOptions,\n  FrontTruncatableCallOptions,\n  CollectionCallOptions,\n  SortedSetFetchByRankCallOptions,\n  SortedSetFetchByScoreCallOptions,\n} from '../../../utils';\n\n// Type aliases to differentiate the different methods' optional arguments.\nexport type SetOptions = ScalarCallOptions;\nexport type SetIfNotExistsOptions = ScalarCallOptions;\nexport type ListConcatenateBackOptions = FrontTruncatableCallOptions;\nexport type ListConcatenateFrontOptions = BackTruncatableCallOptions;\nexport type ListPushBackOptions = FrontTruncatableCallOptions;\nexport type ListPushFrontOptions = BackTruncatableCallOptions;\nexport type SetAddElementOptions = CollectionCallOptions;\nexport type SetAddElementsOptions = CollectionCallOptions;\nexport type DictionarySetFieldOptions = CollectionCallOptions;\nexport type DictionarySetFieldsOptions = CollectionCallOptions;\nexport type DictionaryIncrementOptions = CollectionCallOptions;\nexport type IncrementOptions = ScalarCallOptions;\nexport type SortedSetPutElementOptions = CollectionCallOptions;\nexport type SortedSetPutElementsOptions = CollectionCallOptions;\nexport type SortedSetFetchByRankOptions = SortedSetFetchByRankCallOptions;\nexport type SortedSetFetchByScoreOptions = SortedSetFetchByScoreCallOptions;\nexport type SortedSetIncrementOptions = CollectionCallOptions;\n\nexport interface ICacheClient extends IControlClient {\n  get(cacheName: string, key: string | Uint8Array): Promise<CacheGet.Response>;\n  set(\n    cacheName: string,\n    key: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: SetOptions\n  ): Promise<CacheSet.Response>;\n  delete(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<CacheDelete.Response>;\n  increment(\n    cacheName: string,\n    field: string | Uint8Array,\n    amount: number,\n    options?: IncrementOptions\n  ): Promise<CacheIncrement.Response>;\n  setIfNotExists(\n    cacheName: string,\n    key: string | Uint8Array,\n    field: string | Uint8Array,\n    options?: SetIfNotExistsOptions\n  ): Promise<CacheSetIfNotExists.Response>;\n  setFetch(cacheName: string, setName: string): Promise<CacheSetFetch.Response>;\n  setAddElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array,\n    options?: SetAddElementsOptions\n  ): Promise<CacheSetAddElement.Response>;\n  setAddElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[],\n    options?: SetAddElementsOptions\n  ): Promise<CacheSetAddElements.Response>;\n  setRemoveElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array\n  ): Promise<CacheSetRemoveElement.Response>;\n  setRemoveElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[]\n  ): Promise<CacheSetRemoveElements.Response>;\n  listFetch(\n    cacheName: string,\n    listName: string,\n    options?: ListFetchCallOptions\n  ): Promise<CacheListFetch.Response>;\n  listLength(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListLength.Response>;\n  listPushFront(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushFrontOptions\n  ): Promise<CacheListPushFront.Response>;\n  listPushBack(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushBackOptions\n  ): Promise<CacheListPushBack.Response>;\n  listConcatenateBack(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateBackOptions\n  ): Promise<CacheListConcatenateBack.Response>;\n  listConcatenateFront(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateFrontOptions\n  ): Promise<CacheListConcatenateFront.Response>;\n  listPopBack(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopBack.Response>;\n  listPopFront(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopFront.Response>;\n  listRemoveValue(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array\n  ): Promise<CacheListRemoveValue.Response>;\n  listRetain(\n    cacheName: string,\n    listName: string,\n    options?: ListRetainCallOptions\n  ): Promise<CacheListRetain.Response>;\n  dictionarySetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: DictionarySetFieldOptions\n  ): Promise<CacheDictionarySetField.Response>;\n  dictionarySetFields(\n    cacheName: string,\n    dictionaryName: string,\n    elements:\n      | Map<string | Uint8Array, string | Uint8Array>\n      | Record<string, string | Uint8Array>,\n    options?: DictionarySetFieldsOptions\n  ): Promise<CacheDictionarySetFields.Response>;\n  dictionaryGetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryGetField.Response>;\n  dictionaryGetFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryGetField.Response>;\n  dictionaryFetch(\n    cacheName: string,\n    dictionaryName: string\n  ): Promise<CacheDictionaryFetch.Response>;\n  dictionaryIncrement(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    amount?: number,\n    options?: DictionaryIncrementOptions\n  ): Promise<CacheDictionaryIncrement.Response>;\n  dictionaryRemoveField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryRemoveField.Response>;\n  dictionaryRemoveFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryRemoveFields.Response>;\n  sortedSetFetchByRank(\n    cacheName: string,\n    sortedSetName: string,\n    options?: SortedSetFetchByRankOptions\n  ): Promise<CacheSortedSetFetch.Response>;\n  sortedSetFetchByScore(\n    cacheName: string,\n    sortedSetName: string,\n    options?: SortedSetFetchByScoreOptions\n  ): Promise<CacheSortedSetFetch.Response>;\n  sortedSetPutElement(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array,\n    score: number,\n    options?: SortedSetPutElementOptions\n  ): Promise<CacheSortedSetPutElement.Response>;\n  sortedSetPutElements(\n    cacheName: string,\n    sortedSetName: string,\n    elements: Map<string | Uint8Array, number> | Record<string, number>,\n    options?: SortedSetPutElementsOptions\n  ): Promise<CacheSortedSetPutElements.Response>;\n  sortedSetGetRank(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetGetRank.Response>;\n  sortedSetGetScore(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetGetScore.Response>;\n  sortedSetGetScores(\n    cacheName: string,\n    sortedSetName: string,\n    values: string[] | Uint8Array[]\n  ): Promise<CacheSortedSetGetScores.Response>;\n  sortedSetIncrementScore(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array,\n    amount?: number,\n    options?: SortedSetIncrementOptions\n  ): Promise<CacheSortedSetIncrementScore.Response>;\n  sortedSetRemoveElement(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetRemoveElement.Response>;\n  sortedSetRemoveElements(\n    cacheName: string,\n    sortedSetName: string,\n    values: string[] | Uint8Array[]\n  ): Promise<CacheSortedSetRemoveElement.Response>;\n  itemGetType(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<ItemGetType.Response>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ICacheClient.js","sourceRoot":"","sources":["../../../../../src/internal/clients/cache/ICacheClient.ts"],"names":[],"mappings":"","sourcesContent":["import {IControlClient} from './IControlClient';\nimport {IPingClient} from './IPingClient';\nimport {\n  CacheDelete,\n  CacheGet,\n  CacheIncrement,\n  CacheSet,\n  CacheSetIfNotExists,\n  CacheSetFetch,\n  CacheSetAddElements,\n  CacheSetAddElement,\n  CacheSetRemoveElements,\n  CacheSetRemoveElement,\n  CacheListFetch,\n  CacheListLength,\n  CacheListPushFront,\n  CacheListPushBack,\n  CacheListConcatenateBack,\n  CacheListConcatenateFront,\n  CacheListPopBack,\n  CacheListPopFront,\n  CacheListRemoveValue,\n  CacheListRetain,\n  CacheDictionarySetField,\n  CacheDictionarySetFields,\n  CacheDictionaryGetField,\n  CacheDictionaryFetch,\n  CacheDictionaryIncrement,\n  CacheDictionaryRemoveField,\n  CacheDictionaryRemoveFields,\n  CacheSortedSetFetch,\n  CacheSortedSetPutElement,\n  CacheSortedSetPutElements,\n  CacheSortedSetGetRank,\n  CacheSortedSetGetScore,\n  CacheSortedSetGetScores,\n  CacheSortedSetIncrementScore,\n  CacheSortedSetRemoveElement,\n  ItemGetType,\n} from '../../../index';\nimport {\n  ScalarCallOptions,\n  ListFetchCallOptions,\n  ListRetainCallOptions,\n  BackTruncatableCallOptions,\n  FrontTruncatableCallOptions,\n  CollectionCallOptions,\n  SortedSetFetchByRankCallOptions,\n  SortedSetFetchByScoreCallOptions,\n} from '../../../utils';\n\n// Type aliases to differentiate the different methods' optional arguments.\nexport type SetOptions = ScalarCallOptions;\nexport type SetIfNotExistsOptions = ScalarCallOptions;\nexport type ListConcatenateBackOptions = FrontTruncatableCallOptions;\nexport type ListConcatenateFrontOptions = BackTruncatableCallOptions;\nexport type ListPushBackOptions = FrontTruncatableCallOptions;\nexport type ListPushFrontOptions = BackTruncatableCallOptions;\nexport type SetAddElementOptions = CollectionCallOptions;\nexport type SetAddElementsOptions = CollectionCallOptions;\nexport type DictionarySetFieldOptions = CollectionCallOptions;\nexport type DictionarySetFieldsOptions = CollectionCallOptions;\nexport type DictionaryIncrementOptions = CollectionCallOptions;\nexport type IncrementOptions = ScalarCallOptions;\nexport type SortedSetPutElementOptions = CollectionCallOptions;\nexport type SortedSetPutElementsOptions = CollectionCallOptions;\nexport type SortedSetFetchByRankOptions = SortedSetFetchByRankCallOptions;\nexport type SortedSetFetchByScoreOptions = SortedSetFetchByScoreCallOptions;\nexport type SortedSetIncrementOptions = CollectionCallOptions;\n\nexport interface ICacheClient extends IControlClient, IPingClient {\n  get(cacheName: string, key: string | Uint8Array): Promise<CacheGet.Response>;\n  set(\n    cacheName: string,\n    key: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: SetOptions\n  ): Promise<CacheSet.Response>;\n  delete(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<CacheDelete.Response>;\n  increment(\n    cacheName: string,\n    field: string | Uint8Array,\n    amount: number,\n    options?: IncrementOptions\n  ): Promise<CacheIncrement.Response>;\n  setIfNotExists(\n    cacheName: string,\n    key: string | Uint8Array,\n    field: string | Uint8Array,\n    options?: SetIfNotExistsOptions\n  ): Promise<CacheSetIfNotExists.Response>;\n  setFetch(cacheName: string, setName: string): Promise<CacheSetFetch.Response>;\n  setAddElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array,\n    options?: SetAddElementsOptions\n  ): Promise<CacheSetAddElement.Response>;\n  setAddElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[],\n    options?: SetAddElementsOptions\n  ): Promise<CacheSetAddElements.Response>;\n  setRemoveElement(\n    cacheName: string,\n    setName: string,\n    element: string | Uint8Array\n  ): Promise<CacheSetRemoveElement.Response>;\n  setRemoveElements(\n    cacheName: string,\n    setName: string,\n    elements: string[] | Uint8Array[]\n  ): Promise<CacheSetRemoveElements.Response>;\n  listFetch(\n    cacheName: string,\n    listName: string,\n    options?: ListFetchCallOptions\n  ): Promise<CacheListFetch.Response>;\n  listLength(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListLength.Response>;\n  listPushFront(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushFrontOptions\n  ): Promise<CacheListPushFront.Response>;\n  listPushBack(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array,\n    options?: ListPushBackOptions\n  ): Promise<CacheListPushBack.Response>;\n  listConcatenateBack(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateBackOptions\n  ): Promise<CacheListConcatenateBack.Response>;\n  listConcatenateFront(\n    cacheName: string,\n    listName: string,\n    values: string[] | Uint8Array[],\n    options?: ListConcatenateFrontOptions\n  ): Promise<CacheListConcatenateFront.Response>;\n  listPopBack(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopBack.Response>;\n  listPopFront(\n    cacheName: string,\n    listName: string\n  ): Promise<CacheListPopFront.Response>;\n  listRemoveValue(\n    cacheName: string,\n    listName: string,\n    value: string | Uint8Array\n  ): Promise<CacheListRemoveValue.Response>;\n  listRetain(\n    cacheName: string,\n    listName: string,\n    options?: ListRetainCallOptions\n  ): Promise<CacheListRetain.Response>;\n  dictionarySetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    value: string | Uint8Array,\n    options?: DictionarySetFieldOptions\n  ): Promise<CacheDictionarySetField.Response>;\n  dictionarySetFields(\n    cacheName: string,\n    dictionaryName: string,\n    elements:\n      | Map<string | Uint8Array, string | Uint8Array>\n      | Record<string, string | Uint8Array>,\n    options?: DictionarySetFieldsOptions\n  ): Promise<CacheDictionarySetFields.Response>;\n  dictionaryGetField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryGetField.Response>;\n  dictionaryGetFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryGetField.Response>;\n  dictionaryFetch(\n    cacheName: string,\n    dictionaryName: string\n  ): Promise<CacheDictionaryFetch.Response>;\n  dictionaryIncrement(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array,\n    amount?: number,\n    options?: DictionaryIncrementOptions\n  ): Promise<CacheDictionaryIncrement.Response>;\n  dictionaryRemoveField(\n    cacheName: string,\n    dictionaryName: string,\n    field: string | Uint8Array\n  ): Promise<CacheDictionaryRemoveField.Response>;\n  dictionaryRemoveFields(\n    cacheName: string,\n    dictionaryName: string,\n    fields: string[] | Uint8Array[]\n  ): Promise<CacheDictionaryRemoveFields.Response>;\n  sortedSetFetchByRank(\n    cacheName: string,\n    sortedSetName: string,\n    options?: SortedSetFetchByRankOptions\n  ): Promise<CacheSortedSetFetch.Response>;\n  sortedSetFetchByScore(\n    cacheName: string,\n    sortedSetName: string,\n    options?: SortedSetFetchByScoreOptions\n  ): Promise<CacheSortedSetFetch.Response>;\n  sortedSetPutElement(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array,\n    score: number,\n    options?: SortedSetPutElementOptions\n  ): Promise<CacheSortedSetPutElement.Response>;\n  sortedSetPutElements(\n    cacheName: string,\n    sortedSetName: string,\n    elements: Map<string | Uint8Array, number> | Record<string, number>,\n    options?: SortedSetPutElementsOptions\n  ): Promise<CacheSortedSetPutElements.Response>;\n  sortedSetGetRank(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetGetRank.Response>;\n  sortedSetGetScore(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetGetScore.Response>;\n  sortedSetGetScores(\n    cacheName: string,\n    sortedSetName: string,\n    values: string[] | Uint8Array[]\n  ): Promise<CacheSortedSetGetScores.Response>;\n  sortedSetIncrementScore(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array,\n    amount?: number,\n    options?: SortedSetIncrementOptions\n  ): Promise<CacheSortedSetIncrementScore.Response>;\n  sortedSetRemoveElement(\n    cacheName: string,\n    sortedSetName: string,\n    value: string | Uint8Array\n  ): Promise<CacheSortedSetRemoveElement.Response>;\n  sortedSetRemoveElements(\n    cacheName: string,\n    sortedSetName: string,\n    values: string[] | Uint8Array[]\n  ): Promise<CacheSortedSetRemoveElement.Response>;\n  itemGetType(\n    cacheName: string,\n    key: string | Uint8Array\n  ): Promise<ItemGetType.Response>;\n}\n"]}

package/dist/src/internal/clients/cache/IPingClient.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVBpbmdDbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9jYWNoZS9JUGluZ0NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJUGluZ0NsaWVudCB7XG4gIHBpbmcoKTogUHJvbWlzZTx2b2lkPjtcbn1cbiJdfQ==

package/dist/src/internal/clients/cache/index.d.ts

@@ -2,3 +2,4 @@ export * from './AbstractCacheClient';
 export * from './ICacheClient';
 export * from './IControlClient';
 export * from './IDataClient';
+export * from './IPingClient';

package/dist/src/internal/clients/cache/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./AbstractCacheClient"), exports);
 __exportStar(require("./ICacheClient"), exports);
 __exportStar(require("./IControlClient"), exports);
 __exportStar(require("./IDataClient"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9jYWNoZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0RBQXNDO0FBQ3RDLGlEQUErQjtBQUMvQixtREFBaUM7QUFDakMsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdENhY2hlQ2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vSUNhY2hlQ2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vSUNvbnRyb2xDbGllbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9JRGF0YUNsaWVudCc7XG4iXX0=
+__exportStar(require("./IPingClient"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9jYWNoZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0RBQXNDO0FBQ3RDLGlEQUErQjtBQUMvQixtREFBaUM7QUFDakMsZ0RBQThCO0FBQzlCLGdEQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vQWJzdHJhY3RDYWNoZUNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL0lDYWNoZUNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL0lDb250cm9sQ2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vSURhdGFDbGllbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9JUGluZ0NsaWVudCc7XG4iXX0=

package/dist/src/internal/clients/index.d.ts

@@ -1,3 +1,3 @@
-export * from './ping';
 export * from './cache';
 export * from './auth';
+export * from './pubsub';

package/dist/src/internal/clients/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ping"), exports);
 __exportStar(require("./cache"), exports);
 __exportStar(require("./auth"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCO0FBQ3ZCLDBDQUF3QjtBQUN4Qix5Q0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BpbmcnO1xuZXhwb3J0ICogZnJvbSAnLi9jYWNoZSc7XG5leHBvcnQgKiBmcm9tICcuL2F1dGgnO1xuIl19
+__exportStar(require("./pubsub"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUN2QiwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NhY2hlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL3B1YnN1Yic7XG4iXX0=

package/dist/src/internal/clients/pubsub/AbstractPubsubClient.d.ts

@@ -0,0 +1,43 @@
+import { CredentialProvider, TopicPublish, TopicItem, MomentoLogger, TopicSubscribe, SubscribeCallOptions } from '../../../index';
+import { SubscriptionState } from '../../subscription-state';
+import { IPubsubClient } from './IPubsubClient';
+/**
+ * Encapsulates parameters for the `sendSubscribe` method.
+ */
+export interface SendSubscribeOptions {
+    cacheName: string;
+    topicName: string;
+    onItem: (item: TopicItem) => void;
+    onError: (error: TopicSubscribe.Error, subscription: TopicSubscribe.Subscription) => void;
+    subscriptionState: SubscriptionState;
+    subscription: TopicSubscribe.Subscription;
+}
+/**
+ * Encapsulates parameters for the subscribe callback prepare methods.
+ */
+export interface PrepareSubscribeCallbackOptions extends SendSubscribeOptions {
+    /**
+     * The promise resolve function.
+     */
+    resolve: (value: TopicSubscribe.Response | PromiseLike<TopicSubscribe.Subscription>) => void;
+    /**
+     * Whether the stream was restarted due to an error. If so, we skip the end stream handler
+     * logic as the error handler will have restarted the stream.
+     */
+    restartedDueToError: boolean;
+    /**
+     * If the first message is an error, we return an error immediately and do not subscribe.
+     */
+    firstMessage: boolean;
+}
+export declare abstract class AbstractPubsubClient implements IPubsubClient {
+    protected readonly logger: MomentoLogger;
+    protected readonly credentialProvider: CredentialProvider;
+    getEndpoint(): string;
+    publish(cacheName: string, topicName: string, value: string | Uint8Array): Promise<TopicPublish.Response>;
+    protected abstract sendPublish(cacheName: string, topicName: string, value: string | Uint8Array): Promise<TopicPublish.Response>;
+    subscribe(cacheName: string, topicName: string, options: SubscribeCallOptions): Promise<TopicSubscribe.Response>;
+    protected abstract sendSubscribe(options: SendSubscribeOptions): Promise<TopicSubscribe.Response>;
+    protected prepareEndCallback(options: PrepareSubscribeCallbackOptions): () => void;
+    protected handleSubscribeError(options: PrepareSubscribeCallbackOptions, momentoError: TopicSubscribe.Error, isRstStreamNoError: boolean): void;
+}

package/dist/src/internal/clients/pubsub/AbstractPubsubClient.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPubsubClient = void 0;
+const utils_1 = require("../../utils");
+const errors_1 = require("../../../errors");
+const index_1 = require("../../../index");
+const subscription_state_1 = require("../../subscription-state");
+class AbstractPubsubClient {
+    getEndpoint() {
+        const endpoint = this.credentialProvider.getCacheEndpoint();
+        this.logger.debug(`Using cache endpoint: ${endpoint}`);
+        return endpoint;
+    }
+    async publish(cacheName, topicName, value) {
+        try {
+            (0, utils_1.validateCacheName)(cacheName);
+            (0, utils_1.validateTopicName)(topicName);
+        }
+        catch (err) {
+            return new index_1.TopicPublish.Error((0, errors_1.normalizeSdkError)(err));
+        }
+        this.logger.trace('Issuing publish request; topic: %s, message length: %s', (0, utils_1.truncateString)(topicName), value.length);
+        return await this.sendPublish(cacheName, topicName, value);
+    }
+    async subscribe(cacheName, topicName, options) {
+        var _a, _b;
+        try {
+            (0, utils_1.validateCacheName)(cacheName);
+            (0, utils_1.validateTopicName)(topicName);
+        }
+        catch (err) {
+            return new index_1.TopicSubscribe.Error((0, errors_1.normalizeSdkError)(err));
+        }
+        this.logger.trace('Issuing subscribe request; topic: %s', (0, utils_1.truncateString)(topicName));
+        const onItem = (_a = options.onItem) !== null && _a !== void 0 ? _a : (() => {
+            return;
+        });
+        const onError = (_b = options.onError) !== null && _b !== void 0 ? _b : (() => {
+            return;
+        });
+        const subscriptionState = new subscription_state_1.SubscriptionState();
+        const subscription = new index_1.TopicSubscribe.Subscription(subscriptionState);
+        return await this.sendSubscribe({
+            cacheName: cacheName,
+            topicName: topicName,
+            onItem: onItem,
+            onError: onError,
+            subscriptionState: subscriptionState,
+            subscription: subscription,
+        });
+    }
+    prepareEndCallback(options) {
+        return () => {
+            // We want to restart on stream end, except if:
+            // 1. The stream was cancelled by the caller.
+            // 2. The stream was restarted following an error.
+            if (options.restartedDueToError) {
+                this.logger.trace('Stream ended after error but was restarted on topic: %s', options.topicName);
+                return;
+            }
+            else if (!options.subscriptionState.isSubscribed) {
+                this.logger.trace('Stream ended after unsubscribe on topic: %s', options.topicName);
+                return;
+            }
+            this.logger.trace('Stream ended on topic: %s; restarting.', options.topicName);
+            // When restarting the stream we do not do anything with the promises,
+            // because we should have already returned the subscription object to the user.
+            this.sendSubscribe(options)
+                .then(() => {
+                return;
+            })
+                .catch(() => {
+                return;
+            });
+        };
+    }
+    handleSubscribeError(options, momentoError, isRstStreamNoError) {
+        // When the first message is an error, an irrecoverable error has happened,
+        // eg the cache does not exist. The user should not receive a subscription
+        // object but an error.
+        if (options.firstMessage) {
+            this.logger.trace('Received subscription stream error; topic: %s', (0, utils_1.truncateString)(options.topicName));
+            options.resolve(momentoError);
+            options.subscription.unsubscribe();
+            return;
+        }
+        // The service cuts the stream after a period of time.
+        // Transparently restart the stream instead of propagating an error.
+        if (isRstStreamNoError) {
+            this.logger.trace('Server closed stream due to idle activity. Restarting.');
+            // When restarting the stream we do not do anything with the promises,
+            // because we should have already returned the subscription object to the user.
+            this.sendSubscribe(options)
+                .then(() => {
+                return;
+            })
+                .catch(() => {
+                return;
+            });
+            options.restartedDueToError = true;
+            return;
+        }
+        // Another special case is when the cache is not found.
+        // This happens here if the user deletes the cache in the middle of
+        // a subscription.
+        if (momentoError.errorCode() === errors_1.MomentoErrorCode.NOT_FOUND_ERROR) {
+            this.logger.trace('Stream ended due to cache not found error on topic: %s', options.topicName);
+            options.subscription.unsubscribe();
+            options.onError(momentoError, options.subscription);
+            return;
+        }
+        else {
+            options.onError(momentoError, options.subscription);
+        }
+    }
+}
+exports.AbstractPubsubClient = AbstractPubsubClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractPubsubClient.js","sourceRoot":"","sources":["../../../../../src/internal/clients/pubsub/AbstractPubsubClient.ts"],"names":[],"mappings":";;;AAAA,uCAIqB;AACrB,4CAAoE;AACpE,0CAOwB;AACxB,iEAA2D;AAuC3D,MAAsB,oBAAoB;IAIjC,WAAW;QAChB,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;QAC5D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAC;QACvD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,SAAiB,EACjB,SAAiB,EACjB,KAA0B;QAE1B,IAAI;YACF,IAAA,yBAAiB,EAAC,SAAS,CAAC,CAAC;YAC7B,IAAA,yBAAiB,EAAC,SAAS,CAAC,CAAC;SAC9B;QAAC,OAAO,GAAG,EAAE;YACZ,OAAO,IAAI,oBAAY,CAAC,KAAK,CAAC,IAAA,0BAAiB,EAAC,GAAY,CAAC,CAAC,CAAC;SAChE;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,wDAAwD,EACxD,IAAA,sBAAc,EAAC,SAAS,CAAC,EACzB,KAAK,CAAC,MAAM,CACb,CAAC;QAEF,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC;IAQM,KAAK,CAAC,SAAS,CACpB,SAAiB,EACjB,SAAiB,EACjB,OAA6B;;QAE7B,IAAI;YACF,IAAA,yBAAiB,EAAC,SAAS,CAAC,CAAC;YAC7B,IAAA,yBAAiB,EAAC,SAAS,CAAC,CAAC;SAC9B;QAAC,OAAO,GAAG,EAAE;YACZ,OAAO,IAAI,sBAAc,CAAC,KAAK,CAAC,IAAA,0BAAiB,EAAC,GAAY,CAAC,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,sCAAsC,EACtC,IAAA,sBAAc,EAAC,SAAS,CAAC,CAC1B,CAAC;QAEF,MAAM,MAAM,GACV,MAAA,OAAO,CAAC,MAAM,mCACd,CAAC,GAAG,EAAE;YACJ,OAAO;QACT,CAAC,CAAC,CAAC;QACL,MAAM,OAAO,GACX,MAAA,OAAO,CAAC,OAAO,mCACf,CAAC,GAAG,EAAE;YACJ,OAAO;QACT,CAAC,CAAC,CAAC;QAEL,MAAM,iBAAiB,GAAG,IAAI,sCAAiB,EAAE,CAAC;QAClD,MAAM,YAAY,GAAG,IAAI,sBAAc,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QACxE,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC;YAC9B,SAAS,EAAE,SAAS;YACpB,SAAS,EAAE,SAAS;YACpB,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,OAAO;YAChB,iBAAiB,EAAE,iBAAiB;YACpC,YAAY,EAAE,YAAY;SAC3B,CAAC,CAAC;IACL,CAAC;IAMS,kBAAkB,CAC1B,OAAwC;QAExC,OAAO,GAAG,EAAE;YACV,+CAA+C;YAC/C,6CAA6C;YAC7C,kDAAkD;YAClD,IAAI,OAAO,CAAC,mBAAmB,EAAE;gBAC/B,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,yDAAyD,EACzD,OAAO,CAAC,SAAS,CAClB,CAAC;gBACF,OAAO;aACR;iBAAM,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,YAAY,EAAE;gBAClD,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,6CAA6C,EAC7C,OAAO,CAAC,SAAS,CAClB,CAAC;gBACF,OAAO;aACR;YAED,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,wCAAwC,EACxC,OAAO,CAAC,SAAS,CAClB,CAAC;YAEF,sEAAsE;YACtE,+EAA+E;YAC/E,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;iBACxB,IAAI,CAAC,GAAG,EAAE;gBACT,OAAO;YACT,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,OAAO;YACT,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;IACJ,CAAC;IAES,oBAAoB,CAC5B,OAAwC,EACxC,YAAkC,EAClC,kBAA2B;QAE3B,2EAA2E;QAC3E,0EAA0E;QAC1E,uBAAuB;QACvB,IAAI,OAAO,CAAC,YAAY,EAAE;YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,+CAA+C,EAC/C,IAAA,sBAAc,EAAC,OAAO,CAAC,SAAS,CAAC,CAClC,CAAC;YAEF,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAC9B,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YACnC,OAAO;SACR;QAED,sDAAsD;QACtD,oEAAoE;QACpE,IAAI,kBAAkB,EAAE;YACtB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,wDAAwD,CACzD,CAAC;YACF,sEAAsE;YACtE,+EAA+E;YAC/E,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;iBACxB,IAAI,CAAC,GAAG,EAAE;gBACT,OAAO;YACT,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,OAAO;YACT,CAAC,CAAC,CAAC;YACL,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;YACnC,OAAO;SACR;QAED,uDAAuD;QACvD,mEAAmE;QACnE,kBAAkB;QAClB,IAAI,YAAY,CAAC,SAAS,EAAE,KAAK,yBAAgB,CAAC,eAAe,EAAE;YACjE,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,wDAAwD,EACxD,OAAO,CAAC,SAAS,CAClB,CAAC;YACF,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YACnC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;YACpD,OAAO;SACR;aAAM;YACL,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;SACrD;IACH,CAAC;CACF;AA1KD,oDA0KC","sourcesContent":["import {\n  truncateString,\n  validateCacheName,\n  validateTopicName,\n} from '../../utils';\nimport {MomentoErrorCode, normalizeSdkError} from '../../../errors';\nimport {\n  CredentialProvider,\n  TopicPublish,\n  TopicItem,\n  MomentoLogger,\n  TopicSubscribe,\n  SubscribeCallOptions,\n} from '../../../index';\nimport {SubscriptionState} from '../../subscription-state';\nimport {IPubsubClient} from './IPubsubClient';\n\n/**\n * Encapsulates parameters for the `sendSubscribe` method.\n */\nexport interface SendSubscribeOptions {\n  cacheName: string;\n  topicName: string;\n  onItem: (item: TopicItem) => void;\n  onError: (\n    error: TopicSubscribe.Error,\n    subscription: TopicSubscribe.Subscription\n  ) => void;\n  subscriptionState: SubscriptionState;\n  subscription: TopicSubscribe.Subscription;\n}\n\n/**\n * Encapsulates parameters for the subscribe callback prepare methods.\n */\nexport interface PrepareSubscribeCallbackOptions extends SendSubscribeOptions {\n  /**\n   * The promise resolve function.\n   */\n  resolve: (\n    value: TopicSubscribe.Response | PromiseLike<TopicSubscribe.Subscription>\n  ) => void;\n  /**\n   * Whether the stream was restarted due to an error. If so, we skip the end stream handler\n   * logic as the error handler will have restarted the stream.\n   */\n  restartedDueToError: boolean;\n  /**\n   * If the first message is an error, we return an error immediately and do not subscribe.\n   */\n  firstMessage: boolean;\n}\n\nexport abstract class AbstractPubsubClient implements IPubsubClient {\n  protected readonly logger: MomentoLogger;\n  protected readonly credentialProvider: CredentialProvider;\n\n  public getEndpoint(): string {\n    const endpoint = this.credentialProvider.getCacheEndpoint();\n    this.logger.debug(`Using cache endpoint: ${endpoint}`);\n    return endpoint;\n  }\n\n  public async publish(\n    cacheName: string,\n    topicName: string,\n    value: string | Uint8Array\n  ): Promise<TopicPublish.Response> {\n    try {\n      validateCacheName(cacheName);\n      validateTopicName(topicName);\n    } catch (err) {\n      return new TopicPublish.Error(normalizeSdkError(err as Error));\n    }\n    this.logger.trace(\n      'Issuing publish request; topic: %s, message length: %s',\n      truncateString(topicName),\n      value.length\n    );\n\n    return await this.sendPublish(cacheName, topicName, value);\n  }\n\n  protected abstract sendPublish(\n    cacheName: string,\n    topicName: string,\n    value: string | Uint8Array\n  ): Promise<TopicPublish.Response>;\n\n  public async subscribe(\n    cacheName: string,\n    topicName: string,\n    options: SubscribeCallOptions\n  ): Promise<TopicSubscribe.Response> {\n    try {\n      validateCacheName(cacheName);\n      validateTopicName(topicName);\n    } catch (err) {\n      return new TopicSubscribe.Error(normalizeSdkError(err as Error));\n    }\n    this.logger.trace(\n      'Issuing subscribe request; topic: %s',\n      truncateString(topicName)\n    );\n\n    const onItem =\n      options.onItem ??\n      (() => {\n        return;\n      });\n    const onError =\n      options.onError ??\n      (() => {\n        return;\n      });\n\n    const subscriptionState = new SubscriptionState();\n    const subscription = new TopicSubscribe.Subscription(subscriptionState);\n    return await this.sendSubscribe({\n      cacheName: cacheName,\n      topicName: topicName,\n      onItem: onItem,\n      onError: onError,\n      subscriptionState: subscriptionState,\n      subscription: subscription,\n    });\n  }\n\n  protected abstract sendSubscribe(\n    options: SendSubscribeOptions\n  ): Promise<TopicSubscribe.Response>;\n\n  protected prepareEndCallback(\n    options: PrepareSubscribeCallbackOptions\n  ): () => void {\n    return () => {\n      // We want to restart on stream end, except if:\n      // 1. The stream was cancelled by the caller.\n      // 2. The stream was restarted following an error.\n      if (options.restartedDueToError) {\n        this.logger.trace(\n          'Stream ended after error but was restarted on topic: %s',\n          options.topicName\n        );\n        return;\n      } else if (!options.subscriptionState.isSubscribed) {\n        this.logger.trace(\n          'Stream ended after unsubscribe on topic: %s',\n          options.topicName\n        );\n        return;\n      }\n\n      this.logger.trace(\n        'Stream ended on topic: %s; restarting.',\n        options.topicName\n      );\n\n      // When restarting the stream we do not do anything with the promises,\n      // because we should have already returned the subscription object to the user.\n      this.sendSubscribe(options)\n        .then(() => {\n          return;\n        })\n        .catch(() => {\n          return;\n        });\n    };\n  }\n\n  protected handleSubscribeError(\n    options: PrepareSubscribeCallbackOptions,\n    momentoError: TopicSubscribe.Error,\n    isRstStreamNoError: boolean\n  ): void {\n    // When the first message is an error, an irrecoverable error has happened,\n    // eg the cache does not exist. The user should not receive a subscription\n    // object but an error.\n    if (options.firstMessage) {\n      this.logger.trace(\n        'Received subscription stream error; topic: %s',\n        truncateString(options.topicName)\n      );\n\n      options.resolve(momentoError);\n      options.subscription.unsubscribe();\n      return;\n    }\n\n    // The service cuts the stream after a period of time.\n    // Transparently restart the stream instead of propagating an error.\n    if (isRstStreamNoError) {\n      this.logger.trace(\n        'Server closed stream due to idle activity. Restarting.'\n      );\n      // When restarting the stream we do not do anything with the promises,\n      // because we should have already returned the subscription object to the user.\n      this.sendSubscribe(options)\n        .then(() => {\n          return;\n        })\n        .catch(() => {\n          return;\n        });\n      options.restartedDueToError = true;\n      return;\n    }\n\n    // Another special case is when the cache is not found.\n    // This happens here if the user deletes the cache in the middle of\n    // a subscription.\n    if (momentoError.errorCode() === MomentoErrorCode.NOT_FOUND_ERROR) {\n      this.logger.trace(\n        'Stream ended due to cache not found error on topic: %s',\n        options.topicName\n      );\n      options.subscription.unsubscribe();\n      options.onError(momentoError, options.subscription);\n      return;\n    } else {\n      options.onError(momentoError, options.subscription);\n    }\n  }\n}\n"]}

package/dist/src/internal/clients/pubsub/AbstractTopicClient.d.ts

@@ -0,0 +1,31 @@
+import { ITopicClient } from './ITopicClient';
+import { MomentoLogger, SubscribeCallOptions, TopicPublish, TopicSubscribe } from '../../../index';
+import { IPubsubClient } from './IPubsubClient';
+export declare abstract class AbstractTopicClient implements ITopicClient {
+    protected readonly logger: MomentoLogger;
+    protected readonly client: IPubsubClient;
+    /**
+     * Publishes a value to a topic.
+     *
+     * @param {string} cacheName - The name of the cache to containing the topic to publish to.
+     * @param {string} topicName - The name of the topic to publish to.
+     * @param {string | Uint8Array} value - The value to publish.
+     * @returns {Promise<TopicPublish.Response>} -
+     * {@link TopicPublish.Success} on success.
+     * {@link TopicPublish.Error} on failure.
+     */
+    publish(cacheName: string, topicName: string, value: string | Uint8Array): Promise<TopicPublish.Response>;
+    /**
+     * Subscribes to a topic.
+     *
+     * @param {string} cacheName - The name of the cache to containing the topic to subscribe to.
+     * @param {string} topicName - The name of the topic to subscribe to.
+     * @param {SubscribeCallOptions} options - The options for the subscription. Defaults to no-op handlers.
+     * @param {function} options.onItem - The callback to invoke when data is received. Defaults to no-op.
+     * @param {function} options.onError - The callback to invoke when an error is received. Defaults to no-op.
+     * @returns {Promise<TopicSubscribe.Response>} -
+     * {@link TopicSubscribe.Subscription} on success.
+     * {@link TopicSubscribe.Error} on failure.
+     */
+    subscribe(cacheName: string, topicName: string, options: SubscribeCallOptions): Promise<TopicSubscribe.Response>;
+}

package/dist/src/internal/clients/pubsub/AbstractTopicClient.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTopicClient = void 0;
+class AbstractTopicClient {
+    /**
+     * Publishes a value to a topic.
+     *
+     * @param {string} cacheName - The name of the cache to containing the topic to publish to.
+     * @param {string} topicName - The name of the topic to publish to.
+     * @param {string | Uint8Array} value - The value to publish.
+     * @returns {Promise<TopicPublish.Response>} -
+     * {@link TopicPublish.Success} on success.
+     * {@link TopicPublish.Error} on failure.
+     */
+    async publish(cacheName, topicName, value) {
+        return await this.client.publish(cacheName, topicName, value);
+    }
+    /**
+     * Subscribes to a topic.
+     *
+     * @param {string} cacheName - The name of the cache to containing the topic to subscribe to.
+     * @param {string} topicName - The name of the topic to subscribe to.
+     * @param {SubscribeCallOptions} options - The options for the subscription. Defaults to no-op handlers.
+     * @param {function} options.onItem - The callback to invoke when data is received. Defaults to no-op.
+     * @param {function} options.onError - The callback to invoke when an error is received. Defaults to no-op.
+     * @returns {Promise<TopicSubscribe.Response>} -
+     * {@link TopicSubscribe.Subscription} on success.
+     * {@link TopicSubscribe.Error} on failure.
+     */
+    async subscribe(cacheName, topicName, options) {
+        return await this.client.subscribe(cacheName, topicName, options);
+    }
+}
+exports.AbstractTopicClient = AbstractTopicClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/internal/clients/pubsub/IPubsubClient.d.ts

@@ -0,0 +1,6 @@
+import { TopicPublish, TopicSubscribe, SubscribeCallOptions } from '../../../index';
+export interface IPubsubClient {
+    getEndpoint(): string;
+    publish(cacheName: string, topicName: string, value: string | Uint8Array): Promise<TopicPublish.Response>;
+    subscribe(cacheName: string, topicName: string, options: SubscribeCallOptions): Promise<TopicSubscribe.Response>;
+}

package/dist/src/internal/clients/pubsub/IPubsubClient.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVB1YnN1YkNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9pbnRlcm5hbC9jbGllbnRzL3B1YnN1Yi9JUHVic3ViQ2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBUb3BpY1B1Ymxpc2gsXG4gIFRvcGljU3Vic2NyaWJlLFxuICBTdWJzY3JpYmVDYWxsT3B0aW9ucyxcbn0gZnJvbSAnLi4vLi4vLi4vaW5kZXgnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElQdWJzdWJDbGllbnQge1xuICBnZXRFbmRwb2ludCgpOiBzdHJpbmc7XG4gIHB1Ymxpc2goXG4gICAgY2FjaGVOYW1lOiBzdHJpbmcsXG4gICAgdG9waWNOYW1lOiBzdHJpbmcsXG4gICAgdmFsdWU6IHN0cmluZyB8IFVpbnQ4QXJyYXlcbiAgKTogUHJvbWlzZTxUb3BpY1B1Ymxpc2guUmVzcG9uc2U+O1xuICBzdWJzY3JpYmUoXG4gICAgY2FjaGVOYW1lOiBzdHJpbmcsXG4gICAgdG9waWNOYW1lOiBzdHJpbmcsXG4gICAgb3B0aW9uczogU3Vic2NyaWJlQ2FsbE9wdGlvbnNcbiAgKTogUHJvbWlzZTxUb3BpY1N1YnNjcmliZS5SZXNwb25zZT47XG59XG4iXX0=

package/dist/src/internal/clients/pubsub/ITopicClient.d.ts

@@ -0,0 +1,5 @@
+import { TopicPublish, TopicSubscribe, SubscribeCallOptions } from '../../../index';
+export interface ITopicClient {
+    publish(cacheName: string, topicName: string, value: string | Uint8Array): Promise<TopicPublish.Response>;
+    subscribe(cacheName: string, topicName: string, options: SubscribeCallOptions): Promise<TopicSubscribe.Response>;
+}

package/dist/src/internal/clients/pubsub/ITopicClient.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVRvcGljQ2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2ludGVybmFsL2NsaWVudHMvcHVic3ViL0lUb3BpY0NsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgVG9waWNQdWJsaXNoLFxuICBUb3BpY1N1YnNjcmliZSxcbiAgU3Vic2NyaWJlQ2FsbE9wdGlvbnMsXG59IGZyb20gJy4uLy4uLy4uL2luZGV4JztcblxuZXhwb3J0IGludGVyZmFjZSBJVG9waWNDbGllbnQge1xuICBwdWJsaXNoKFxuICAgIGNhY2hlTmFtZTogc3RyaW5nLFxuICAgIHRvcGljTmFtZTogc3RyaW5nLFxuICAgIHZhbHVlOiBzdHJpbmcgfCBVaW50OEFycmF5XG4gICk6IFByb21pc2U8VG9waWNQdWJsaXNoLlJlc3BvbnNlPjtcblxuICBzdWJzY3JpYmUoXG4gICAgY2FjaGVOYW1lOiBzdHJpbmcsXG4gICAgdG9waWNOYW1lOiBzdHJpbmcsXG4gICAgb3B0aW9uczogU3Vic2NyaWJlQ2FsbE9wdGlvbnNcbiAgKTogUHJvbWlzZTxUb3BpY1N1YnNjcmliZS5SZXNwb25zZT47XG59XG4iXX0=

package/dist/src/internal/clients/pubsub/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ITopicClient';
+export * from './IPubsubClient';

package/dist/src/internal/clients/{ping → pubsub}/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./AbstractPingClient"), exports);
-__exportStar(require("./IPingClient"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9waW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1REFBcUM7QUFDckMsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9BYnN0cmFjdFBpbmdDbGllbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9JUGluZ0NsaWVudCc7XG4iXX0=
+__exportStar(require("./ITopicClient"), exports);
+__exportStar(require("./IPubsubClient"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZXJuYWwvY2xpZW50cy9wdWJzdWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlEQUErQjtBQUMvQixrREFBZ0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL0lUb3BpY0NsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL0lQdWJzdWJDbGllbnQnO1xuIl19

package/dist/src/internal/utils/auth.d.ts

@@ -13,8 +13,8 @@ export interface Base64DecodedV1Token {
     endpoint: string;
 }
 interface TokenAndEndpoints {
-    controlEndpoint: string;
-    cacheEndpoint: string;
+    controlEndpoint: string | undefined;
+    cacheEndpoint: string | undefined;
     authToken: string;
 }
 /**

package/dist/src/internal/utils/auth.js

@@ -34,6 +34,9 @@ const decodeAuthToken = (token) => {
             };
         }
         else {
+            // This decode function uses generics to advertise that we will usually expect to find the LegacyClaims.  However,
+            // if the token is a valid JWT but not actually one of our legacy tokens, the endpoint claims will be undefined,
+            // which is why the return type for this function specifies that the controlEndpoint/cacheEndpoint may be undefined.
             const decodedLegacyToken = decodeAuthTokenClaims(token);
             return {
                 controlEndpoint: decodedLegacyToken.cp,
@@ -47,4 +50,4 @@ const decodeAuthToken = (token) => {
     }
 };
 exports.decodeAuthToken = decodeAuthToken;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/messages/responses/generate-auth-token.d.ts

@@ -8,10 +8,7 @@ declare class _Success extends Response {
     readonly refreshToken: string;
     readonly endpoint: string;
     readonly expiresAt: ExpiresAt;
-    constructor(authToken: string, refreshToken: string, endpoint: string, expiresAt: ExpiresAt);
-    getAuthToken(): string;
-    getRefreshToken(): string;
-    getExpiresAt(): ExpiresAt;
+    constructor(apiKey: string, refreshToken: string, endpoint: string, expiresAt: ExpiresAt);
 }
 declare const Success_base: {
     new (...args: any[]): {

package/dist/src/messages/responses/generate-auth-token.js

@@ -7,22 +7,13 @@ class Response extends response_base_1.ResponseBase {
 }
 exports.Response = Response;
 class _Success extends Response {
-    constructor(authToken, refreshToken, endpoint, expiresAt) {
+    constructor(apiKey, refreshToken, endpoint, expiresAt) {
         super();
-        this.authToken = authToken;
+        this.authToken = (0, utils_1.encodeToBase64)(JSON.stringify({ endpoint: endpoint, api_key: apiKey }));
         this.refreshToken = refreshToken;
         this.endpoint = endpoint;
         this.expiresAt = expiresAt;
     }
-    getAuthToken() {
-        return (0, utils_1.encodeToBase64)(JSON.stringify({ endpoint: this.endpoint, api_key: this.authToken }));
-    }
-    getRefreshToken() {
-        return this.refreshToken;
-    }
-    getExpiresAt() {
-        return this.expiresAt;
-    }
 }
 /**
  * Indicates a Successful generate api token request.
@@ -49,4 +40,4 @@ class _Error extends Response {
 class Error extends (0, response_base_1.ResponseError)(_Error) {
 }
 exports.Error = Error;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/utils/expiration.js

@@ -86,7 +86,7 @@ class ExpiresIn extends Expiration {
 exports.ExpiresIn = ExpiresIn;
 class ExpiresAt extends Expiration {
     constructor(epochTimestamp) {
-        super(epochTimestamp !== undefined);
+        super(epochTimestamp !== undefined && epochTimestamp !== 0);
         if (this.doesExpire()) {
             this.validUntil = epochTimestamp;
         }
@@ -112,4 +112,4 @@ class ExpiresAt extends Expiration {
     }
 }
 exports.ExpiresAt = ExpiresAt;
-//# 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.16.2",
+  "version": "1.18.0",
   "description": "Common code for Momento JS SDKs",
   "main": "dist/src/index.js",
   "files": [

package/dist/src/internal/clients/ping/AbstractPingClient.d.ts

@@ -1,25 +0,0 @@
-import { IPingClient } from './IPingClient';
-export interface BasePingClientProps {
-    createPingClient: () => IPingClient;
-}
-/**
- * Momento Cache Client.
- *
- * Features include:
- * - Get, set, and delete data
- * - Create, delete, and list caches
- * - Create, revoke, and list signing keys
- */
-export declare abstract class AbstractPingClient implements IPingClient {
-    private readonly pingClient;
-    /**
-     * Creates an instance of CacheClient.
-     */
-    protected constructor(props: BasePingClientProps);
-    /**
-     * Simple ping api
-     *
-     * @returns {Promise<void>} -
-     */
-    ping(): Promise<void>;
-}