orcaq 1.1.1 → 1.1.2

package/.output/server/node_modules/@redis/client/dist/lib/RESP/encoder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CRLF = '\r\n';
+function encodeCommand(args) {
+    const toWrite = [];
+    let strings = '*' + args.length + CRLF;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg === 'string') {
+            strings += '$' + Buffer.byteLength(arg) + CRLF + arg + CRLF;
+        }
+        else if (arg instanceof Buffer) {
+            toWrite.push(strings + '$' + arg.length.toString() + CRLF, arg);
+            strings = CRLF;
+        }
+        else {
+            throw new TypeError(`"arguments[${i}]" must be of type "string | Buffer", got ${typeof arg} instead.`);
+        }
+    }
+    toWrite.push(strings);
+    return toWrite;
+}
+exports.default = encodeCommand;
+//# sourceMappingURL=encoder.js.map

package/.output/server/node_modules/@redis/client/dist/lib/RESP/verbatim-string.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerbatimString = void 0;
+class VerbatimString extends String {
+    format;
+    constructor(format, value) {
+        super(value);
+        this.format = format;
+    }
+}
+exports.VerbatimString = VerbatimString;
+//# sourceMappingURL=verbatim-string.js.map

package/.output/server/node_modules/@redis/client/dist/lib/authx/credentials-provider.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnableToObtainNewCredentialsError = exports.CredentialsError = void 0;
+/**
+ * Thrown when re-authentication fails with provided credentials .
+ * e.g. when the credentials are invalid, expired or revoked.
+ *
+ */
+class CredentialsError extends Error {
+    constructor(message) {
+        super(`Re-authentication with latest credentials failed: ${message}`);
+        this.name = 'CredentialsError';
+    }
+}
+exports.CredentialsError = CredentialsError;
+/**
+ * Thrown when new credentials cannot be obtained before current ones expire
+ */
+class UnableToObtainNewCredentialsError extends Error {
+    constructor(message) {
+        super(`Unable to obtain new credentials : ${message}`);
+        this.name = 'UnableToObtainNewCredentialsError';
+    }
+}
+exports.UnableToObtainNewCredentialsError = UnableToObtainNewCredentialsError;
+//# sourceMappingURL=credentials-provider.js.map

package/.output/server/node_modules/@redis/client/dist/lib/authx/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = exports.CredentialsError = exports.UnableToObtainNewCredentialsError = exports.IDPError = exports.TokenManager = void 0;
+var token_manager_1 = require("./token-manager");
+Object.defineProperty(exports, "TokenManager", { enumerable: true, get: function () { return token_manager_1.TokenManager; } });
+Object.defineProperty(exports, "IDPError", { enumerable: true, get: function () { return token_manager_1.IDPError; } });
+var credentials_provider_1 = require("./credentials-provider");
+Object.defineProperty(exports, "UnableToObtainNewCredentialsError", { enumerable: true, get: function () { return credentials_provider_1.UnableToObtainNewCredentialsError; } });
+Object.defineProperty(exports, "CredentialsError", { enumerable: true, get: function () { return credentials_provider_1.CredentialsError; } });
+var token_1 = require("./token");
+Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return token_1.Token; } });
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redis/client/dist/lib/authx/token-manager.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = exports.IDPError = void 0;
+const token_1 = require("./token");
+/**
+ * IDPError indicates a failure from the identity provider.
+ *
+ * The `isRetryable` flag is determined by the RetryPolicy's error classification function - if an error is
+ * classified as retryable, it will be marked as transient and the token manager will attempt to recover.
+ */
+class IDPError extends Error {
+    message;
+    isRetryable;
+    constructor(message, isRetryable) {
+        super(message);
+        this.message = message;
+        this.isRetryable = isRetryable;
+        this.name = 'IDPError';
+    }
+}
+exports.IDPError = IDPError;
+/**
+ * TokenManager is responsible for obtaining/refreshing tokens and notifying listeners about token changes.
+ * It uses an IdentityProvider to request tokens. The token refresh is scheduled based on the token's TTL and
+ * the expirationRefreshRatio configuration.
+ *
+ * The TokenManager should be disposed when it is no longer needed by calling the dispose method on the Disposable
+ * returned by start.
+ */
+class TokenManager {
+    identityProvider;
+    config;
+    currentToken = null;
+    refreshTimeout = null;
+    listener = null;
+    retryAttempt = 0;
+    constructor(identityProvider, config) {
+        this.identityProvider = identityProvider;
+        this.config = config;
+        if (this.config.expirationRefreshRatio > 1) {
+            throw new Error('expirationRefreshRatio must be less than or equal to 1');
+        }
+        if (this.config.expirationRefreshRatio < 0) {
+            throw new Error('expirationRefreshRatio must be greater or equal to 0');
+        }
+    }
+    /**
+     * Starts the token manager and returns a Disposable that can be used to stop the token manager.
+     *
+     * @param listener The listener that will receive token updates.
+     * @param initialDelayMs The initial delay in milliseconds before the first token refresh.
+     */
+    start(listener, initialDelayMs = 0) {
+        if (this.listener) {
+            this.stop();
+        }
+        this.listener = listener;
+        this.retryAttempt = 0;
+        this.scheduleNextRefresh(initialDelayMs);
+        return {
+            dispose: () => this.stop()
+        };
+    }
+    calculateRetryDelay() {
+        if (!this.config.retry)
+            return 0;
+        const { initialDelayMs, maxDelayMs, backoffMultiplier, jitterPercentage } = this.config.retry;
+        let delay = initialDelayMs * Math.pow(backoffMultiplier, this.retryAttempt - 1);
+        delay = Math.min(delay, maxDelayMs);
+        if (jitterPercentage) {
+            const jitterRange = delay * (jitterPercentage / 100);
+            const jitterAmount = Math.random() * jitterRange - (jitterRange / 2);
+            delay += jitterAmount;
+        }
+        let result = Math.max(0, Math.floor(delay));
+        return result;
+    }
+    shouldRetry(error) {
+        if (!this.config.retry)
+            return false;
+        const { maxAttempts, isRetryable } = this.config.retry;
+        if (this.retryAttempt >= maxAttempts) {
+            return false;
+        }
+        if (isRetryable) {
+            return isRetryable(error, this.retryAttempt);
+        }
+        return false;
+    }
+    isRunning() {
+        return this.listener !== null;
+    }
+    async refresh() {
+        if (!this.listener) {
+            throw new Error('TokenManager is not running, but refresh was called');
+        }
+        try {
+            await this.identityProvider.requestToken().then(this.handleNewToken);
+            this.retryAttempt = 0;
+        }
+        catch (error) {
+            if (this.shouldRetry(error)) {
+                this.retryAttempt++;
+                const retryDelay = this.calculateRetryDelay();
+                this.notifyError(`Token refresh failed (attempt ${this.retryAttempt}), retrying in ${retryDelay}ms: ${error}`, true);
+                this.scheduleNextRefresh(retryDelay);
+            }
+            else {
+                this.notifyError(error, false);
+                this.stop();
+            }
+        }
+    }
+    handleNewToken = async ({ token: nativeToken, ttlMs }) => {
+        if (!this.listener) {
+            throw new Error('TokenManager is not running, but a new token was received');
+        }
+        const token = this.wrapAndSetCurrentToken(nativeToken, ttlMs);
+        this.listener.onNext(token);
+        this.scheduleNextRefresh(this.calculateRefreshTime(token));
+    };
+    /**
+     * Creates a Token object from a native token and sets it as the current token.
+     *
+     * @param nativeToken - The raw token received from the identity provider
+     * @param ttlMs - Time-to-live in milliseconds for the token
+     *
+     * @returns A new Token instance containing the wrapped native token and expiration details
+     *
+     */
+    wrapAndSetCurrentToken(nativeToken, ttlMs) {
+        const now = Date.now();
+        const token = new token_1.Token(nativeToken, now + ttlMs, now);
+        this.currentToken = token;
+        return token;
+    }
+    scheduleNextRefresh(delayMs) {
+        if (this.refreshTimeout) {
+            clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = null;
+        }
+        if (delayMs === 0) {
+            this.refresh();
+        }
+        else {
+            this.refreshTimeout = setTimeout(() => this.refresh(), delayMs);
+        }
+    }
+    /**
+     * Calculates the time in milliseconds when the token should be refreshed
+     * based on the token's TTL and the expirationRefreshRatio configuration.
+     *
+     * @param token The token to calculate the refresh time for.
+     * @param now The current time in milliseconds. Defaults to Date.now().
+     */
+    calculateRefreshTime(token, now = Date.now()) {
+        const ttlMs = token.getTtlMs(now);
+        return Math.floor(ttlMs * this.config.expirationRefreshRatio);
+    }
+    stop() {
+        if (this.refreshTimeout) {
+            clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = null;
+        }
+        this.listener = null;
+        this.currentToken = null;
+        this.retryAttempt = 0;
+    }
+    /**
+     * Returns the current token or null if no token is available.
+     */
+    getCurrentToken() {
+        return this.currentToken;
+    }
+    notifyError(error, isRetryable) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!this.listener) {
+            throw new Error(`TokenManager is not running but received an error: ${errorMessage}`);
+        }
+        this.listener.onError(new IDPError(errorMessage, isRetryable));
+    }
+}
+exports.TokenManager = TokenManager;
+//# sourceMappingURL=token-manager.js.map

package/.output/server/node_modules/@redis/client/dist/lib/authx/token.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+/**
+ * A token that can be used to authenticate with a service.
+ */
+class Token {
+    value;
+    expiresAtMs;
+    receivedAtMs;
+    constructor(value, 
+    //represents the token deadline - the time in milliseconds since the Unix epoch at which the token expires
+    expiresAtMs, 
+    //represents the time in milliseconds since the Unix epoch at which the token was received
+    receivedAtMs) {
+        this.value = value;
+        this.expiresAtMs = expiresAtMs;
+        this.receivedAtMs = receivedAtMs;
+    }
+    /**
+     * Returns the time-to-live of the token in milliseconds.
+     * @param now The current time in milliseconds since the Unix epoch.
+     */
+    getTtlMs(now) {
+        if (this.expiresAtMs < now) {
+            return 0;
+        }
+        return this.expiresAtMs - now;
+    }
+}
+exports.Token = Token;
+//# sourceMappingURL=token.js.map