@gomomento/sdk-core 1.37.0 → 1.39.0

package/dist/src/auth/credential-provider.d.ts

@@ -1,23 +1,13 @@
+import { AllEndpoints } from '../internal/utils';
+export interface BaseEndpointOverride {
+    baseEndpoint: string;
+}
+export type EndpointOverrides = BaseEndpointOverride | AllEndpoints;
 /**
  * Encapsulates arguments for instantiating an EnvMomentoTokenProvider
  */
 interface CredentialProviderProps {
-    /**
-     * optionally overrides the default controlEndpoint
-     */
-    controlEndpoint?: string;
-    /**
-     * optionally overrides the default cacheEndpoint
-     */
-    cacheEndpoint?: string;
-    /**
-     * optionally overrides the default vectorEndpoint
-     */
-    tokenEndpoint?: string;
-    /**
-     * optionally overrides the default vectorEndpoint
-     */
-    vectorEndpoint?: string;
+    endpointOverrides?: EndpointOverrides;
 }
 /**
  * Provides information that the CacheClient needs in order to establish a connection to and authenticate with
@@ -47,21 +37,9 @@ export declare abstract class CredentialProvider {
      */
     abstract getVectorEndpoint(): string;
     /**
-     * @returns {boolean} true if the cache endpoint was manually overridden at construction time; false otherwise
+     * @returns {boolean} true if the endpoints were manually overridden at construction time; false otherwise
      */
-    abstract isCacheEndpointOverridden(): boolean;
-    /**
-     * @returns {boolean} true if the control endpoint was manually overridden at construction time; false otherwise
-     */
-    abstract isControlEndpointOverridden(): boolean;
-    /**
-     * @returns {boolean} true if the token endpoint was manually overridden at construction time; false otherwise
-     */
-    abstract isTokenEndpointOverridden(): boolean;
-    /**
-     * @returns {boolean} true if the vector endpoint was manually overridden at construction time; false otherwise
-     */
-    abstract isVectorEndpointOverridden(): boolean;
+    abstract areEndpointsOverridden(): boolean;
     static fromEnvironmentVariable(props: EnvMomentoTokenProviderProps): CredentialProvider;
     static fromString(props: StringMomentoTokenProviderProps): CredentialProvider;
 }
@@ -71,33 +49,31 @@ declare abstract class CredentialProviderBase implements CredentialProvider {
     abstract getControlEndpoint(): string;
     abstract getTokenEndpoint(): string;
     abstract getVectorEndpoint(): string;
-    abstract isCacheEndpointOverridden(): boolean;
-    abstract isControlEndpointOverridden(): boolean;
-    abstract isTokenEndpointOverridden(): boolean;
-    abstract isVectorEndpointOverridden(): boolean;
+    abstract areEndpointsOverridden(): boolean;
     valueOf(): object;
 }
-export interface StringMomentoTokenProviderProps extends CredentialProviderProps {
+export interface StringMomentoApiKeyProviderProps extends CredentialProviderProps {
+    /**
+     * apiKey the momento API key
+     */
+    apiKey: string;
+}
+export interface StringMomentoAuthTokenProviderProps extends CredentialProviderProps {
     /**
      * authToken the momento auth token
      */
     authToken: string;
 }
+export type StringMomentoTokenProviderProps = StringMomentoApiKeyProviderProps | StringMomentoAuthTokenProviderProps;
 /**
  * Reads and parses a momento auth token stored in a String
  * @export
  * @class StringMomentoTokenProvider
  */
 export declare class StringMomentoTokenProvider extends CredentialProviderBase {
-    private readonly authToken;
-    private readonly controlEndpoint;
-    private readonly cacheEndpoint;
-    private readonly tokenEndpoint;
-    private readonly vectorEndpoint;
-    private readonly controlEndpointOverridden;
-    private readonly cacheEndpointOverridden;
-    private readonly tokenEndpointOverridden;
-    private readonly vectorEndpointOverridden;
+    private readonly apiKey;
+    private readonly allEndpoints;
+    private readonly endpointsOverridden;
     /**
      * @param {StringMomentoTokenProviderProps} props configuration options for the token provider
      */
@@ -107,10 +83,7 @@ export declare class StringMomentoTokenProvider extends CredentialProviderBase {
     getControlEndpoint(): string;
     getTokenEndpoint(): string;
     getVectorEndpoint(): string;
-    isControlEndpointOverridden(): boolean;
-    isCacheEndpointOverridden(): boolean;
-    isTokenEndpointOverridden(): boolean;
-    isVectorEndpointOverridden(): boolean;
+    areEndpointsOverridden(): boolean;
 }
 export interface EnvMomentoTokenProviderProps extends CredentialProviderProps {
     /**

package/dist/src/auth/credential-provider.js

@@ -2,6 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvMomentoTokenProvider = exports.StringMomentoTokenProvider = exports.CredentialProvider = void 0;
 const utils_1 = require("../internal/utils");
+function isBaseEndpointOverride(endpointOverrides) {
+    return endpointOverrides.baseEndpoint !== undefined;
+}
+function isAllEndpoints(endpointOverrides) {
+    const allEndpoints = endpointOverrides;
+    return (allEndpoints.cacheEndpoint !== undefined &&
+        allEndpoints.controlEndpoint !== undefined &&
+        allEndpoints.tokenEndpoint !== undefined &&
+        allEndpoints.vectorEndpoint !== undefined);
+}
 /**
  * Provides information that the CacheClient needs in order to establish a connection to and authenticate with
  * the Momento service.
@@ -35,61 +45,71 @@ class StringMomentoTokenProvider extends CredentialProviderBase {
      * @param {StringMomentoTokenProviderProps} props configuration options for the token provider
      */
     constructor(props) {
-        var _a, _b, _c, _d;
         super();
-        const decodedToken = (0, utils_1.decodeAuthToken)(props.authToken);
-        this.authToken = decodedToken.authToken;
-        this.controlEndpointOverridden = props.controlEndpoint !== undefined;
-        const controlEndpoint = (_a = props.controlEndpoint) !== null && _a !== void 0 ? _a : decodedToken.controlEndpoint;
-        if (controlEndpoint === undefined) {
-            throw new Error('Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.');
+        let key;
+        if ('authToken' in props) {
+            key = props.authToken;
+        }
+        else if ('apiKey' in props) {
+            key = props.apiKey;
+        }
+        else {
+            throw new Error('Missing required property: authToken or apiKey');
         }
-        this.cacheEndpointOverridden = props.cacheEndpoint !== undefined;
-        const cacheEndpoint = (_b = props.cacheEndpoint) !== null && _b !== void 0 ? _b : decodedToken.cacheEndpoint;
-        if (cacheEndpoint === undefined) {
-            throw new Error('Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.');
+        const decodedToken = (0, utils_1.decodeAuthToken)(key);
+        this.apiKey = decodedToken.authToken;
+        if (props.endpointOverrides === undefined) {
+            this.endpointsOverridden = false;
+            if (decodedToken.controlEndpoint === undefined) {
+                throw new Error('Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.');
+            }
+            if (decodedToken.cacheEndpoint === undefined) {
+                throw new Error('Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.');
+            }
+            if (decodedToken.tokenEndpoint === undefined) {
+                throw new Error('Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.');
+            }
+            if (decodedToken.vectorEndpoint === undefined) {
+                throw new Error('Malformed token; unable to determine vector endpoint.  Depending on the type of token you are using, you may need to specify the vectorEndpoint explicitly.');
+            }
+            this.allEndpoints = {
+                controlEndpoint: decodedToken.controlEndpoint,
+                cacheEndpoint: decodedToken.cacheEndpoint,
+                tokenEndpoint: decodedToken.tokenEndpoint,
+                vectorEndpoint: decodedToken.vectorEndpoint,
+            };
         }
-        this.tokenEndpointOverridden = props.tokenEndpoint !== undefined;
-        const tokenEndpoint = (_c = props.tokenEndpoint) !== null && _c !== void 0 ? _c : decodedToken.tokenEndpoint;
-        if (tokenEndpoint === undefined) {
-            throw new Error('Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.');
+        else if (isAllEndpoints(props.endpointOverrides)) {
+            this.endpointsOverridden = true;
+            this.allEndpoints = props.endpointOverrides;
         }
-        this.vectorEndpointOverridden = props.vectorEndpoint !== undefined;
-        const vectorEndpoint = (_d = props.vectorEndpoint) !== null && _d !== void 0 ? _d : decodedToken.vectorEndpoint;
-        if (vectorEndpoint === undefined) {
-            throw new Error('Malformed token; unable to determine vector endpoint.  Depending on the type of token you are using, you may need to specify the vectorEndpoint explicitly.');
+        else if (isBaseEndpointOverride(props.endpointOverrides)) {
+            this.endpointsOverridden = true;
+            this.allEndpoints = (0, utils_1.populateAllEndpointsFromBaseEndpoint)(props.endpointOverrides.baseEndpoint);
+        }
+        else {
+            throw new Error(
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Unsupported endpointOverrides: ${props.endpointOverrides}`);
         }
-        this.controlEndpoint = controlEndpoint;
-        this.cacheEndpoint = cacheEndpoint;
-        this.tokenEndpoint = decodedToken.tokenEndpoint || cacheEndpoint;
-        this.vectorEndpoint = vectorEndpoint;
     }
     getAuthToken() {
-        return this.authToken;
+        return this.apiKey;
     }
     getCacheEndpoint() {
-        return this.cacheEndpoint;
+        return this.allEndpoints.cacheEndpoint;
     }
     getControlEndpoint() {
-        return this.controlEndpoint;
+        return this.allEndpoints.controlEndpoint;
     }
     getTokenEndpoint() {
-        return this.tokenEndpoint;
+        return this.allEndpoints.tokenEndpoint;
     }
     getVectorEndpoint() {
-        return this.vectorEndpoint;
-    }
-    isControlEndpointOverridden() {
-        return this.controlEndpointOverridden;
-    }
-    isCacheEndpointOverridden() {
-        return this.cacheEndpointOverridden;
-    }
-    isTokenEndpointOverridden() {
-        return this.tokenEndpointOverridden;
+        return this.allEndpoints.vectorEndpoint;
     }
-    isVectorEndpointOverridden() {
-        return this.vectorEndpointOverridden;
+    areEndpointsOverridden() {
+        return this.endpointsOverridden;
     }
 }
 exports.StringMomentoTokenProvider = StringMomentoTokenProvider;
@@ -109,13 +129,10 @@ class EnvMomentoTokenProvider extends StringMomentoTokenProvider {
         }
         super({
             authToken: authToken,
-            controlEndpoint: props.controlEndpoint,
-            cacheEndpoint: props.cacheEndpoint,
-            tokenEndpoint: props.tokenEndpoint,
-            vectorEndpoint: props.vectorEndpoint,
+            endpointOverrides: props.endpointOverrides,
         });
         this.environmentVariableName = props.environmentVariableName;
     }
 }
 exports.EnvMomentoTokenProvider = EnvMomentoTokenProvider;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-provider.js","sourceRoot":"","sources":["../../../src/auth/credential-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import {decodeAuthToken, fromEntries} from '../internal/utils';\n\n/**\n * Encapsulates arguments for instantiating an EnvMomentoTokenProvider\n */\ninterface CredentialProviderProps {\n  /**\n   * optionally overrides the default controlEndpoint\n   */\n  controlEndpoint?: string;\n  /**\n   * optionally overrides the default cacheEndpoint\n   */\n  cacheEndpoint?: string;\n  /**\n   * optionally overrides the default vectorEndpoint\n   */\n  tokenEndpoint?: string;\n  /**\n   * optionally overrides the default vectorEndpoint\n   */\n  vectorEndpoint?: string;\n}\n\n/**\n * Provides information that the CacheClient needs in order to establish a connection to and authenticate with\n * the Momento service.\n * @export\n * @interface CredentialProvider\n */\nexport abstract class CredentialProvider {\n  /**\n   * @returns {string} Auth token provided by user, required to authenticate with the service\n   */\n  abstract getAuthToken(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento control plane operations\n   */\n  abstract getControlEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento data plane operations\n   */\n  abstract getCacheEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento token operations\n   */\n  abstract getTokenEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento vector index operations\n   */\n  abstract getVectorEndpoint(): string;\n\n  /**\n   * @returns {boolean} true if the cache endpoint was manually overridden at construction time; false otherwise\n   */\n  abstract isCacheEndpointOverridden(): boolean;\n\n  /**\n   * @returns {boolean} true if the control endpoint was manually overridden at construction time; false otherwise\n   */\n  abstract isControlEndpointOverridden(): boolean;\n\n  /**\n   * @returns {boolean} true if the token endpoint was manually overridden at construction time; false otherwise\n   */\n  abstract isTokenEndpointOverridden(): boolean;\n\n  /**\n   * @returns {boolean} true if the vector endpoint was manually overridden at construction time; false otherwise\n   */\n  abstract isVectorEndpointOverridden(): boolean;\n\n  static fromEnvironmentVariable(\n    props: EnvMomentoTokenProviderProps\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  static fromString(\n    props: StringMomentoTokenProviderProps\n  ): CredentialProvider {\n    return new StringMomentoTokenProvider(props);\n  }\n}\n\nabstract class CredentialProviderBase implements CredentialProvider {\n  abstract getAuthToken(): string;\n\n  abstract getCacheEndpoint(): string;\n\n  abstract getControlEndpoint(): string;\n\n  abstract getTokenEndpoint(): string;\n\n  abstract getVectorEndpoint(): string;\n\n  abstract isCacheEndpointOverridden(): boolean;\n  abstract isControlEndpointOverridden(): boolean;\n  abstract isTokenEndpointOverridden(): boolean;\n  abstract isVectorEndpointOverridden(): boolean;\n\n  valueOf(): object {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const entries = Object.entries(this).filter(([k]) => k !== 'authToken');\n    const clone = fromEntries(entries);\n    return clone.valueOf();\n  }\n}\n\nexport interface StringMomentoTokenProviderProps\n  extends CredentialProviderProps {\n  /**\n   * authToken the momento auth token\n   */\n  authToken: string;\n}\n\n/**\n * Reads and parses a momento auth token stored in a String\n * @export\n * @class StringMomentoTokenProvider\n */\nexport class StringMomentoTokenProvider extends CredentialProviderBase {\n  private readonly authToken: string;\n  private readonly controlEndpoint: string;\n  private readonly cacheEndpoint: string;\n  private readonly tokenEndpoint: string;\n  private readonly vectorEndpoint: string;\n  private readonly controlEndpointOverridden: boolean;\n  private readonly cacheEndpointOverridden: boolean;\n  private readonly tokenEndpointOverridden: boolean;\n  private readonly vectorEndpointOverridden: boolean;\n\n  /**\n   * @param {StringMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: StringMomentoTokenProviderProps) {\n    super();\n    const decodedToken = decodeAuthToken(props.authToken);\n    this.authToken = decodedToken.authToken;\n    this.controlEndpointOverridden = props.controlEndpoint !== undefined;\n    const controlEndpoint =\n      props.controlEndpoint ?? decodedToken.controlEndpoint;\n    if (controlEndpoint === undefined) {\n      throw new Error(\n        'Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.'\n      );\n    }\n    this.cacheEndpointOverridden = props.cacheEndpoint !== undefined;\n    const cacheEndpoint = props.cacheEndpoint ?? decodedToken.cacheEndpoint;\n    if (cacheEndpoint === undefined) {\n      throw new Error(\n        'Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.'\n      );\n    }\n\n    this.tokenEndpointOverridden = props.tokenEndpoint !== undefined;\n    const tokenEndpoint = props.tokenEndpoint ?? decodedToken.tokenEndpoint;\n    if (tokenEndpoint === undefined) {\n      throw new Error(\n        'Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.'\n      );\n    }\n\n    this.vectorEndpointOverridden = props.vectorEndpoint !== undefined;\n    const vectorEndpoint = props.vectorEndpoint ?? decodedToken.vectorEndpoint;\n    if (vectorEndpoint === undefined) {\n      throw new Error(\n        'Malformed token; unable to determine vector endpoint.  Depending on the type of token you are using, you may need to specify the vectorEndpoint explicitly.'\n      );\n    }\n\n    this.controlEndpoint = controlEndpoint;\n    this.cacheEndpoint = cacheEndpoint;\n    this.tokenEndpoint = decodedToken.tokenEndpoint || cacheEndpoint;\n    this.vectorEndpoint = vectorEndpoint;\n  }\n\n  getAuthToken(): string {\n    return this.authToken;\n  }\n\n  getCacheEndpoint(): string {\n    return this.cacheEndpoint;\n  }\n\n  getControlEndpoint(): string {\n    return this.controlEndpoint;\n  }\n\n  getTokenEndpoint(): string {\n    return this.tokenEndpoint;\n  }\n\n  getVectorEndpoint(): string {\n    return this.vectorEndpoint;\n  }\n\n  isControlEndpointOverridden(): boolean {\n    return this.controlEndpointOverridden;\n  }\n\n  isCacheEndpointOverridden(): boolean {\n    return this.cacheEndpointOverridden;\n  }\n\n  isTokenEndpointOverridden(): boolean {\n    return this.tokenEndpointOverridden;\n  }\n\n  isVectorEndpointOverridden(): boolean {\n    return this.vectorEndpointOverridden;\n  }\n}\n\nexport interface EnvMomentoTokenProviderProps extends CredentialProviderProps {\n  /**\n   * the name of the environment variable from which the auth token will be read\n   */\n  environmentVariableName: string;\n}\n\n/**\n * Reads and parses a momento auth token stored as an environment variable.\n * @export\n * @class EnvMomentoTokenProvider\n */\nexport class EnvMomentoTokenProvider extends StringMomentoTokenProvider {\n  environmentVariableName: string;\n  /**\n   * @param {EnvMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: EnvMomentoTokenProviderProps) {\n    const authToken = process.env[props.environmentVariableName];\n    if (!authToken) {\n      throw new Error(\n        `Missing required environment variable ${props.environmentVariableName}`\n      );\n    }\n    super({\n      authToken: authToken,\n      controlEndpoint: props.controlEndpoint,\n      cacheEndpoint: props.cacheEndpoint,\n      tokenEndpoint: props.tokenEndpoint,\n      vectorEndpoint: props.vectorEndpoint,\n    });\n    this.environmentVariableName = props.environmentVariableName;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-provider.js","sourceRoot":"","sources":["../../../src/auth/credential-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AllEndpoints,\n  decodeAuthToken,\n  fromEntries,\n  populateAllEndpointsFromBaseEndpoint,\n} from '../internal/utils';\n\nexport interface BaseEndpointOverride {\n  baseEndpoint: string;\n}\n\nexport type EndpointOverrides = BaseEndpointOverride | AllEndpoints;\n\nfunction isBaseEndpointOverride(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is BaseEndpointOverride {\n  return (endpointOverrides as BaseEndpointOverride).baseEndpoint !== undefined;\n}\n\nfunction isAllEndpoints(\n  endpointOverrides: EndpointOverrides\n): endpointOverrides is AllEndpoints {\n  const allEndpoints = endpointOverrides as AllEndpoints;\n  return (\n    allEndpoints.cacheEndpoint !== undefined &&\n    allEndpoints.controlEndpoint !== undefined &&\n    allEndpoints.tokenEndpoint !== undefined &&\n    allEndpoints.vectorEndpoint !== undefined\n  );\n}\n\n/**\n * Encapsulates arguments for instantiating an EnvMomentoTokenProvider\n */\ninterface CredentialProviderProps {\n  endpointOverrides?: EndpointOverrides;\n}\n\n/**\n * Provides information that the CacheClient needs in order to establish a connection to and authenticate with\n * the Momento service.\n * @export\n * @interface CredentialProvider\n */\nexport abstract class CredentialProvider {\n  /**\n   * @returns {string} Auth token provided by user, required to authenticate with the service\n   */\n  abstract getAuthToken(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento control plane operations\n   */\n  abstract getControlEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento data plane operations\n   */\n  abstract getCacheEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento token operations\n   */\n  abstract getTokenEndpoint(): string;\n\n  /**\n   * @returns {string} The host which the Momento client will connect to for Momento vector index operations\n   */\n  abstract getVectorEndpoint(): string;\n\n  /**\n   * @returns {boolean} true if the endpoints were manually overridden at construction time; false otherwise\n   */\n  abstract areEndpointsOverridden(): boolean;\n\n  static fromEnvironmentVariable(\n    props: EnvMomentoTokenProviderProps\n  ): CredentialProvider {\n    return new EnvMomentoTokenProvider(props);\n  }\n\n  static fromString(\n    props: StringMomentoTokenProviderProps\n  ): CredentialProvider {\n    return new StringMomentoTokenProvider(props);\n  }\n}\n\nabstract class CredentialProviderBase implements CredentialProvider {\n  abstract getAuthToken(): string;\n\n  abstract getCacheEndpoint(): string;\n\n  abstract getControlEndpoint(): string;\n\n  abstract getTokenEndpoint(): string;\n\n  abstract getVectorEndpoint(): string;\n\n  abstract areEndpointsOverridden(): boolean;\n\n  valueOf(): object {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const entries = Object.entries(this).filter(([k]) => k !== 'authToken');\n    const clone = fromEntries(entries);\n    return clone.valueOf();\n  }\n}\n\nexport interface StringMomentoApiKeyProviderProps\n  extends CredentialProviderProps {\n  /**\n   * apiKey the momento API key\n   */\n  apiKey: string;\n}\n\nexport interface StringMomentoAuthTokenProviderProps\n  extends CredentialProviderProps {\n  /**\n   * authToken the momento auth token\n   */\n  authToken: string;\n}\n\nexport type StringMomentoTokenProviderProps =\n  | StringMomentoApiKeyProviderProps\n  | StringMomentoAuthTokenProviderProps;\n\n/**\n * Reads and parses a momento auth token stored in a String\n * @export\n * @class StringMomentoTokenProvider\n */\nexport class StringMomentoTokenProvider extends CredentialProviderBase {\n  private readonly apiKey: string;\n  private readonly allEndpoints: AllEndpoints;\n  private readonly endpointsOverridden: boolean;\n\n  /**\n   * @param {StringMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: StringMomentoTokenProviderProps) {\n    super();\n    let key: string;\n    if ('authToken' in props) {\n      key = props.authToken;\n    } else if ('apiKey' in props) {\n      key = props.apiKey;\n    } else {\n      throw new Error('Missing required property: authToken or apiKey');\n    }\n    const decodedToken = decodeAuthToken(key);\n    this.apiKey = decodedToken.authToken;\n    if (props.endpointOverrides === undefined) {\n      this.endpointsOverridden = false;\n      if (decodedToken.controlEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine control endpoint.  Depending on the type of token you are using, you may need to specify the controlEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.cacheEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine cache endpoint.  Depending on the type of token you are using, you may need to specify the cacheEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.tokenEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine token endpoint.  Depending on the type of token you are using, you may need to specify the tokenEndpoint explicitly.'\n        );\n      }\n      if (decodedToken.vectorEndpoint === undefined) {\n        throw new Error(\n          'Malformed token; unable to determine vector endpoint.  Depending on the type of token you are using, you may need to specify the vectorEndpoint explicitly.'\n        );\n      }\n      this.allEndpoints = {\n        controlEndpoint: decodedToken.controlEndpoint,\n        cacheEndpoint: decodedToken.cacheEndpoint,\n        tokenEndpoint: decodedToken.tokenEndpoint,\n        vectorEndpoint: decodedToken.vectorEndpoint,\n      };\n    } else if (isAllEndpoints(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = props.endpointOverrides;\n    } else if (isBaseEndpointOverride(props.endpointOverrides)) {\n      this.endpointsOverridden = true;\n      this.allEndpoints = populateAllEndpointsFromBaseEndpoint(\n        props.endpointOverrides.baseEndpoint\n      );\n    } else {\n      throw new Error(\n        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n        `Unsupported endpointOverrides: ${props.endpointOverrides}`\n      );\n    }\n  }\n\n  getAuthToken(): string {\n    return this.apiKey;\n  }\n\n  getCacheEndpoint(): string {\n    return this.allEndpoints.cacheEndpoint;\n  }\n\n  getControlEndpoint(): string {\n    return this.allEndpoints.controlEndpoint;\n  }\n\n  getTokenEndpoint(): string {\n    return this.allEndpoints.tokenEndpoint;\n  }\n\n  getVectorEndpoint(): string {\n    return this.allEndpoints.vectorEndpoint;\n  }\n\n  areEndpointsOverridden(): boolean {\n    return this.endpointsOverridden;\n  }\n}\n\nexport interface EnvMomentoTokenProviderProps extends CredentialProviderProps {\n  /**\n   * the name of the environment variable from which the auth token will be read\n   */\n  environmentVariableName: string;\n}\n\n/**\n * Reads and parses a momento auth token stored as an environment variable.\n * @export\n * @class EnvMomentoTokenProvider\n */\nexport class EnvMomentoTokenProvider extends StringMomentoTokenProvider {\n  environmentVariableName: string;\n  /**\n   * @param {EnvMomentoTokenProviderProps} props configuration options for the token provider\n   */\n  constructor(props: EnvMomentoTokenProviderProps) {\n    const authToken = process.env[props.environmentVariableName];\n    if (!authToken) {\n      throw new Error(\n        `Missing required environment variable ${props.environmentVariableName}`\n      );\n    }\n    super({\n      authToken: authToken,\n      endpointOverrides: props.endpointOverrides,\n    });\n    this.environmentVariableName = props.environmentVariableName;\n  }\n}\n"]}

package/dist/src/auth/tokens/disposable-token-scope.d.ts

@@ -0,0 +1,24 @@
+import { AllCacheItems, CachePermission, Permission, Permissions, PredefinedScope } from './permission-scope';
+export interface CacheItemKey {
+    key: string;
+}
+export interface CacheItemKeyPrefix {
+    keyPrefix: string;
+}
+export declare function isCacheItemKey(cacheItem: CacheItemSelector): cacheItem is CacheItemKey;
+export declare function isCacheItemKeyPrefix(cacheItem: CacheItemSelector): cacheItem is CacheItemKeyPrefix;
+export type CacheItemSelector = typeof AllCacheItems | CacheItemKey | CacheItemKeyPrefix | string;
+export interface DisposableTokenCachePermission extends CachePermission {
+    /**
+     * Scope the token permissions to select cache items
+     */
+    item: CacheItemSelector;
+}
+export declare function isDisposableTokenCachePermission(p: Permission): boolean;
+export declare function asDisposableTokenCachePermission(p: Permission): DisposableTokenCachePermission;
+export interface DisposableTokenCachePermissions {
+    permissions: Array<DisposableTokenCachePermission>;
+}
+export type DisposableTokenScope = Permissions | PredefinedScope | DisposableTokenCachePermissions;
+export declare function isDisposableTokenPermissionsObject(scope: DisposableTokenScope): boolean;
+export declare function asDisposableTokenPermissionsObject(scope: DisposableTokenScope): DisposableTokenCachePermissions;

package/dist/src/auth/tokens/disposable-token-scope.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asDisposableTokenPermissionsObject = exports.isDisposableTokenPermissionsObject = exports.asDisposableTokenCachePermission = exports.isDisposableTokenCachePermission = exports.isCacheItemKeyPrefix = exports.isCacheItemKey = void 0;
+const permission_scope_1 = require("./permission-scope");
+function isCacheItemKey(cacheItem) {
+    if (cacheItem === permission_scope_1.AllCacheItems) {
+        return false;
+    }
+    if (typeof cacheItem === 'string') {
+        return true;
+    }
+    return 'key' in cacheItem;
+}
+exports.isCacheItemKey = isCacheItemKey;
+function isCacheItemKeyPrefix(cacheItem) {
+    if (cacheItem === permission_scope_1.AllCacheItems) {
+        return false;
+    }
+    if (typeof cacheItem === 'string') {
+        return false;
+    }
+    return 'keyPrefix' in cacheItem;
+}
+exports.isCacheItemKeyPrefix = isCacheItemKeyPrefix;
+function isDisposableTokenCachePermission(p) {
+    return 'role' in p && 'cache' in p && 'item' in p && !('topic' in p);
+}
+exports.isDisposableTokenCachePermission = isDisposableTokenCachePermission;
+function asDisposableTokenCachePermission(p) {
+    if (!isDisposableTokenCachePermission(p)) {
+        throw new Error(`permission is not a DisposableTokenCachePermission object: ${JSON.stringify(p)}`);
+    }
+    return p;
+}
+exports.asDisposableTokenCachePermission = asDisposableTokenCachePermission;
+function isDisposableTokenPermissionObject(p) {
+    return isDisposableTokenCachePermission(p);
+}
+function isDisposableTokenPermissionsObject(scope) {
+    if (!('permissions' in scope)) {
+        return false;
+    }
+    const permissions = scope.permissions;
+    return permissions.every(p => isDisposableTokenPermissionObject(p));
+}
+exports.isDisposableTokenPermissionsObject = isDisposableTokenPermissionsObject;
+function asDisposableTokenPermissionsObject(scope) {
+    console.log(`AS_DISPOSABLE_TOKEN_PERMISSIONS_OBJECT: ${JSON.stringify(scope)}`);
+    if (!isDisposableTokenPermissionsObject(scope)) {
+        throw new Error(`Token scope is not a DisposableTokenCachePermissions object: ${JSON.stringify(scope)}`);
+    }
+    return scope;
+}
+exports.asDisposableTokenPermissionsObject = asDisposableTokenPermissionsObject;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/auth/tokens/disposable-token-scopes.d.ts

@@ -1,5 +1,6 @@
-import { CacheSelector, DisposableTokenScope } from './token-scope';
-export * from './token-scopes';
+import { CacheSelector } from './permission-scope';
+import { DisposableTokenScope } from './disposable-token-scope';
+export * from './permission-scopes';
 export declare function cacheKeyReadWrite(cacheSelector: CacheSelector, key: string): DisposableTokenScope;
 export declare function cacheKeyPrefixReadWrite(cacheSelector: CacheSelector, keyPrefix: string): DisposableTokenScope;
 export declare function cacheKeyReadOnly(cacheSelector: CacheSelector, key: string): DisposableTokenScope;

package/dist/src/auth/tokens/disposable-token-scopes.js

@@ -15,11 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cacheKeyPrefixWriteOnly = exports.cacheKeyWriteOnly = exports.cacheKeyPrefixReadOnly = exports.cacheKeyReadOnly = exports.cacheKeyPrefixReadWrite = exports.cacheKeyReadWrite = void 0;
-const token_scope_1 = require("./token-scope");
-__exportStar(require("./token-scopes"), exports);
+const permission_scope_1 = require("./permission-scope");
+__exportStar(require("./permission-scopes"), exports);
 function cacheKeyReadWrite(cacheSelector, key) {
     return {
-        permissions: [{ role: token_scope_1.CacheRole.ReadWrite, cache: cacheSelector, item: key }],
+        permissions: [{ role: permission_scope_1.CacheRole.ReadWrite, cache: cacheSelector, item: key }],
     };
 }
 exports.cacheKeyReadWrite = cacheKeyReadWrite;
@@ -27,7 +27,7 @@ function cacheKeyPrefixReadWrite(cacheSelector, keyPrefix) {
     return {
         permissions: [
             {
-                role: token_scope_1.CacheRole.ReadWrite,
+                role: permission_scope_1.CacheRole.ReadWrite,
                 cache: cacheSelector,
                 item: { keyPrefix: keyPrefix },
             },
@@ -37,7 +37,7 @@ function cacheKeyPrefixReadWrite(cacheSelector, keyPrefix) {
 exports.cacheKeyPrefixReadWrite = cacheKeyPrefixReadWrite;
 function cacheKeyReadOnly(cacheSelector, key) {
     return {
-        permissions: [{ role: token_scope_1.CacheRole.ReadOnly, cache: cacheSelector, item: key }],
+        permissions: [{ role: permission_scope_1.CacheRole.ReadOnly, cache: cacheSelector, item: key }],
     };
 }
 exports.cacheKeyReadOnly = cacheKeyReadOnly;
@@ -45,7 +45,7 @@ function cacheKeyPrefixReadOnly(cacheSelector, keyPrefix) {
     return {
         permissions: [
             {
-                role: token_scope_1.CacheRole.ReadOnly,
+                role: permission_scope_1.CacheRole.ReadOnly,
                 cache: cacheSelector,
                 item: { keyPrefix: keyPrefix },
             },
@@ -55,7 +55,7 @@ function cacheKeyPrefixReadOnly(cacheSelector, keyPrefix) {
 exports.cacheKeyPrefixReadOnly = cacheKeyPrefixReadOnly;
 function cacheKeyWriteOnly(cacheSelector, key) {
     return {
-        permissions: [{ role: token_scope_1.CacheRole.WriteOnly, cache: cacheSelector, item: key }],
+        permissions: [{ role: permission_scope_1.CacheRole.WriteOnly, cache: cacheSelector, item: key }],
     };
 }
 exports.cacheKeyWriteOnly = cacheKeyWriteOnly;
@@ -63,7 +63,7 @@ function cacheKeyPrefixWriteOnly(cacheSelector, keyPrefix) {
     return {
         permissions: [
             {
-                role: token_scope_1.CacheRole.WriteOnly,
+                role: permission_scope_1.CacheRole.WriteOnly,
                 cache: cacheSelector,
                 item: { keyPrefix: keyPrefix },
             },
@@ -71,4 +71,4 @@ function cacheKeyPrefixWriteOnly(cacheSelector, keyPrefix) {
     };
 }
 exports.cacheKeyPrefixWriteOnly = cacheKeyPrefixWriteOnly;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/auth/tokens/{token-scope.d.ts → permission-scope.d.ts}

@@ -48,31 +48,12 @@ export interface Permissions {
     permissions: Array<Permission>;
 }
 export declare const AllDataReadWrite: Permissions;
-export declare function isPermissionsObject(scope: TokenScope): boolean;
-export declare function asPermissionsObject(scope: TokenScope): Permissions;
+export declare function isPermissionsObject(scope: PermissionScope): boolean;
+export declare function asPermissionsObject(scope: PermissionScope): Permissions;
 export declare abstract class PredefinedScope {
 }
-export type TokenScope = typeof AllDataReadWrite | Permissions | PredefinedScope;
-export interface CacheItemKey {
-    key: string;
-}
-export interface CacheItemKeyPrefix {
-    keyPrefix: string;
-}
-export declare function isCacheItemKey(cacheItem: CacheItemSelector): cacheItem is CacheItemKey;
-export declare function isCacheItemKeyPrefix(cacheItem: CacheItemSelector): cacheItem is CacheItemKeyPrefix;
-export type CacheItemSelector = typeof AllCacheItems | CacheItemKey | CacheItemKeyPrefix | string;
-export interface DisposableTokenCachePermission extends CachePermission {
-    /**
-     * Scope the token permissions to select cache items
-     */
-    item: CacheItemSelector;
-}
-export declare function isDisposableTokenCachePermission(p: Permission): boolean;
-export declare function asDisposableTokenCachePermission(p: Permission): DisposableTokenCachePermission;
-export interface DisposableTokenCachePermissions {
-    permissions: Array<DisposableTokenCachePermission>;
-}
-export type DisposableTokenScope = Permissions | PredefinedScope | DisposableTokenCachePermissions;
-export declare function isDisposableTokenPermissionsObject(scope: DisposableTokenScope): boolean;
-export declare function asDisposableTokenPermissionsObject(scope: DisposableTokenScope): DisposableTokenCachePermissions;
+export type PermissionScope = typeof AllDataReadWrite | Permissions | PredefinedScope;
+/**
+ * @deprecated please use PermissionScope instead
+ */
+export type TokenScope = PermissionScope;

package/dist/src/auth/tokens/permission-scope.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredefinedScope = exports.asPermissionsObject = exports.isPermissionsObject = exports.AllDataReadWrite = exports.asTopicPermission = exports.isTopicPermission = exports.isTopicName = exports.TopicRole = exports.asCachePermission = exports.isCachePermission = exports.isCacheName = exports.AllCacheItems = exports.AllTopics = exports.AllCaches = exports.CacheRole = void 0;
+var CacheRole;
+(function (CacheRole) {
+    CacheRole["ReadWrite"] = "readwrite";
+    CacheRole["ReadOnly"] = "readonly";
+    CacheRole["WriteOnly"] = "writeonly";
+})(CacheRole = exports.CacheRole || (exports.CacheRole = {}));
+exports.AllCaches = Symbol();
+exports.AllTopics = Symbol();
+exports.AllCacheItems = Symbol();
+function isCacheName(cache) {
+    if (cache === exports.AllCaches) {
+        return false;
+    }
+    return 'name' in cache;
+}
+exports.isCacheName = isCacheName;
+function isCachePermission(p) {
+    return 'role' in p && 'cache' in p && !('topic' in p);
+}
+exports.isCachePermission = isCachePermission;
+function asCachePermission(p) {
+    if (!isCachePermission(p)) {
+        throw new Error(`permission is not a CachePermission object: ${JSON.stringify(p)}`);
+    }
+    return p;
+}
+exports.asCachePermission = asCachePermission;
+var TopicRole;
+(function (TopicRole) {
+    TopicRole["PublishSubscribe"] = "publishsubscribe";
+    TopicRole["SubscribeOnly"] = "subscribeonly";
+    TopicRole["PublishOnly"] = "publishonly";
+})(TopicRole = exports.TopicRole || (exports.TopicRole = {}));
+function isTopicName(topic) {
+    if (topic === exports.AllTopics) {
+        return false;
+    }
+    return 'name' in topic;
+}
+exports.isTopicName = isTopicName;
+function isTopicPermission(p) {
+    return 'role' in p && 'cache' in p && 'topic' in p;
+}
+exports.isTopicPermission = isTopicPermission;
+function asTopicPermission(p) {
+    if (!isTopicPermission(p)) {
+        throw new Error(`permission is not a TopicPermission object: ${JSON.stringify(p)}`);
+    }
+    return p;
+}
+exports.asTopicPermission = asTopicPermission;
+exports.AllDataReadWrite = {
+    permissions: [
+        { role: CacheRole.ReadWrite, cache: exports.AllCaches },
+        { role: TopicRole.PublishSubscribe, cache: exports.AllCaches, topic: exports.AllTopics },
+    ],
+};
+function isPermissionObject(p) {
+    return isCachePermission(p) || isTopicPermission(p);
+}
+function isPermissionsObject(scope) {
+    if (!('permissions' in scope)) {
+        return false;
+    }
+    const permissions = scope.permissions;
+    return permissions.every(p => isPermissionObject(p));
+}
+exports.isPermissionsObject = isPermissionsObject;
+function asPermissionsObject(scope) {
+    if (!isPermissionsObject(scope)) {
+        throw new Error(`Token scope is not a Permissions object: ${JSON.stringify(scope)}`);
+    }
+    return scope;
+}
+exports.asPermissionsObject = asPermissionsObject;
+class PredefinedScope {
+}
+exports.PredefinedScope = PredefinedScope;
+//# sourceMappingURL=data:application/json;base64,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