@daiso-tech/core 0.41.1 → 0.43.2

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/consecutive-breaker-lua.js

@@ -0,0 +1,75 @@
+/**
+ * @module CircuitBreaker
+ */
+import { CIRCUIT_BREAKER_STATE, CLOSED_TRANSITIONS, HALF_OPEN_TRANSITIONS, } from "../../../../../circuit-breaker/contracts/_module.js";
+/**
+ * @internal
+ */
+export const consecutiveBreakerLua = `
+-- @param settings Required<ConsecutiveBreakerSettings>
+-- @return ICircuitBreakerPolicy<ConsecutiveBreakerState>
+local function ConsecutiveBreaker(settings)
+    return {
+        -- @return ConsecutiveBreakerState
+        initialMetrics = function()
+            return {
+                failureCount = 0,
+                successCount = 0,
+            }
+        end,
+
+        -- @param currentMetrics ConsecutiveBreakerState
+        -- @param _currentDate number
+        -- @return ClosedTransitions
+        whenClosed = function(currentMetrics, _currentDate)
+            local hasFailed = currentMetrics.failureCount >= settings.failureThreshold
+            if hasFailed then
+                return "${CLOSED_TRANSITIONS.TO_OPEN}"
+            end
+            return "${CLOSED_TRANSITIONS.NONE}"
+        end,
+
+        -- @param currentMetrics ConsecutiveBreakerState
+        -- @param _currentDate number
+        -- @return HalfOpenTransitions
+        whenHalfOpened = function(currentMetrics, _currentDate)
+            local hasFailed = currentMetrics.failureCount > 0
+            if hasFailed then
+                return "${HALF_OPEN_TRANSITIONS.TO_OPEN}"
+            end
+
+            local hasSucceeded = currentMetrics.successCount >= settings.successThreshold
+            if hasSucceeded then
+                return "${HALF_OPEN_TRANSITIONS.TO_CLOSED}"
+            end
+
+            return "${HALF_OPEN_TRANSITIONS.NONE}"
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<ConsecutiveBreakerState>
+        -- @param _settings CircuitBreakerTrackSettings<ConsecutiveBreakerState>
+        -- @return ConsecutiveBreakerState
+        trackFailure = function(currentState, _settings)
+            return {
+                failureCount = currentState.metrics.failureCount + 1,
+                successCount = currentState.metrics.successCount,
+            }
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<ConsecutiveBreakerState>
+        -- @param _settings CircuitBreakerTrackSettings<ConsecutiveBreakerState>
+        -- @return ConsecutiveBreakerState
+        trackSuccess = function(currentState, settings)
+            if currentState.type == "${CIRCUIT_BREAKER_STATE.CLOSED}" then
+                return settings.initialMetrics
+            end
+    
+            return {
+                failureCount = currentState.metrics.failureCount,
+                successCount = currentState.metrics.successCount + 1,
+            }
+        end
+    }
+end
+`;
+//# sourceMappingURL=consecutive-breaker-lua.js.map

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/consecutive-breaker-lua.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consecutive-breaker-lua.js","sourceRoot":"","sources":["../../../../../../src/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/consecutive-breaker-lua.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,GACxB,MAAM,wCAAwC,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;0BAmBX,kBAAkB,CAAC,OAAO;;sBAE9B,kBAAkB,CAAC,IAAI;;;;;;;;;0BASnB,qBAAqB,CAAC,OAAO;;;;;0BAK7B,qBAAqB,CAAC,SAAS;;;sBAGnC,qBAAqB,CAAC,IAAI;;;;;;;;;;;;;;;;;uCAiBT,qBAAqB,CAAC,MAAM;;;;;;;;;;;CAWlE,CAAC"}

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/count-breaker-lua.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module CircuitBreaker
+ */
+/**
+ * @internal
+ */
+export declare const countBreakerLua: string;

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/count-breaker-lua.js

@@ -0,0 +1,136 @@
+/**
+ * @module CircuitBreaker
+ */
+import { CLOSED_TRANSITIONS, HALF_OPEN_TRANSITIONS, } from "../../../../../circuit-breaker/contracts/_module.js";
+/**
+ * @internal
+ */
+export const countBreakerLua = `
+-- @param settings Required<CountBreakerSettings>
+-- @return ICircuitBreakerPolicy<CountBreakerState>
+local function CountBreaker(settings)
+    
+    -- @param currentMetrics CountBreakerState
+    -- @return number
+    local function getFailureCount(currentMetrics)
+        local count = 0
+        
+        for _index, isSuccess in ipairs(currentMetrics.samples) do
+            if not isSuccess then
+                count = count + 1
+            end
+        end
+
+        return count
+    end
+
+    -- @param currentMetrics CountBreakerState
+    -- @return number
+    local function getSuccessCount(currentMetrics)
+        local count = 0
+        
+        for _index, isSuccess in ipairs(currentMetrics.samples) do
+            if isSuccess then
+                count = count + 1
+            end
+        end
+
+        return count
+    end
+
+    -- @param currentMetrics CountBreakerState
+    -- @return boolean
+    local function isMinimumNotMet(currentMetrics)
+        return #currentMetrics.samples <= settings.minimumNumberOfCalls
+    end 
+
+    -- @template TItem
+    -- @param list Array<TItem>
+    -- @return Array<TItem>
+    local function copyList(list)
+        local newList = {}
+        
+        for i = 1, #list do
+            newList[i] = list[i]
+        end
+
+        return newList
+    end
+
+    -- @param success boolean
+    -- @param currentState CircuitBreakerTrackState<CountBreakerState>
+    -- @return CountBreakerState
+    local function track(success, currentState)
+        local newSamples = copyList(currentState.metrics.samples)
+        table.insert(newSamples, success)
+
+        if #currentState.metrics.samples >= settings.size then
+            table.remove(newSamples, 1)
+        end
+
+        return {
+            samples = newSamples
+        }
+    end
+
+    return {
+        -- @return CountBreakerState
+        initialMetrics = function()
+            return {
+                samples = {}
+            }
+        end,
+
+        -- @param currentMetrics CountBreakerState
+        -- @param _currentDate number
+        -- @return ClosedTransitions
+        whenClosed = function(currentMetrics, _currentDate)
+            if isMinimumNotMet(currentMetrics) then
+                return "${CLOSED_TRANSITIONS.NONE}"
+            end
+
+            local allowedFailureCount = math.ceil(
+                settings.failureThreshold * #currentMetrics.samples
+            )
+            local hasFailed = getFailureCount(currentMetrics) > allowedFailureCount
+
+            if hasFailed then
+                return "${CLOSED_TRANSITIONS.TO_OPEN}"
+            end
+
+            return "${CLOSED_TRANSITIONS.NONE}"
+        end,
+
+        -- @param currentMetrics CountBreakerState
+        -- @param _currentDate number
+        -- @return HalfOpenTransitions
+        whenHalfOpened = function(currentMetrics, _currentDate)
+            if isMinimumNotMet(currentMetrics) then
+                return "${CLOSED_TRANSITIONS.NONE}"
+            end
+
+            local allowedSuccessCount = math.ceil(settings.successThreshold * #currentMetrics.samples)
+            local hasSucceeded = getSuccessCount(currentMetrics) >= allowedSuccessCount
+            if hasSucceeded then
+                return "${HALF_OPEN_TRANSITIONS.TO_CLOSED}"
+            end
+            return "${HALF_OPEN_TRANSITIONS.TO_OPEN}"
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<CountBreakerState>
+        -- @param _settings CircuitBreakerTrackSettings<CountBreakerState>
+        -- @return CountBreakerState
+        trackFailure = function(currentState, _settings)
+            return track(false, currentState)
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<CountBreakerState>
+        -- @param _settings CircuitBreakerTrackSettings<CountBreakerState>
+        -- @return CountBreakerState
+        trackSuccess = function(currentState, _settings)
+            return track(true, currentState)
+        end
+    }
+end
+`;
+//# sourceMappingURL=count-breaker-lua.js.map

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/count-breaker-lua.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-breaker-lua.js","sourceRoot":"","sources":["../../../../../../src/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/count-breaker-lua.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,kBAAkB,EAClB,qBAAqB,GACxB,MAAM,wCAAwC,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAiFL,kBAAkB,CAAC,IAAI;;;;;;;;;0BASvB,kBAAkB,CAAC,OAAO;;;sBAG9B,kBAAkB,CAAC,IAAI;;;;;;;;0BAQnB,kBAAkB,CAAC,IAAI;;;;;;0BAMvB,qBAAqB,CAAC,SAAS;;sBAEnC,qBAAqB,CAAC,OAAO;;;;;;;;;;;;;;;;;;CAkBlD,CAAC"}

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/sampling-breaker-lua.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module CircuitBreaker
+ */
+/**
+ * @internal
+ */
+export declare const samplingBreakerLua: string;

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/sampling-breaker-lua.js

@@ -0,0 +1,153 @@
+/**
+ * @module CircuitBreaker
+ */
+import { CLOSED_TRANSITIONS, HALF_OPEN_TRANSITIONS, } from "../../../../../circuit-breaker/contracts/circuit-breaker-policy.contract.js";
+/**
+ * @internal
+ */
+export const samplingBreakerLua = `
+-- @param settings Required<SerializedSamplingBreakerSettings>
+-- @return ICircuitBreakerPolicy<SamplingBreakerState>
+local function SamplingBreaker(settings)
+    -- @param currentMetrics SamplingBreakerState
+    -- @return ProccesedMetricData
+    local function getProccesedMetricData(currentMetrics)
+        local totalFailures = 0
+        local totalSuccesses = 0
+                
+        for _index, sample in ipairs(currentMetrics.samples) do
+            totalFailures = totalFailures + sample.failures
+            totalSuccesses = totalSuccesses + sample.successes
+        end
+        local total = totalFailures + totalSuccesses
+        return {
+            total = total,
+            totalFailures = totalFailures,
+            totalSuccesses = totalSuccesses
+        }
+    end
+
+    -- @param total number
+    -- @return boolean
+    local function isMiniumNotMet(total)
+        -- settings.timeSpan is in ms
+        return total < math.ceil(settings.timeSpan / 1000) * settings.minimumRps
+    end
+
+    -- @param currentDate number
+    -- @return InvokableFn<[sample: Sample], boolean>
+    local function isNotOverLapping(currentDate)
+        return function(sample)
+            local windowStart = currentDate - settings.timeSpan
+            local sampleEnd = settings.sampleTimeSpan + sample.startedAt
+            return sampleEnd < windowStart
+        end
+    end
+
+    -- @param success boolean
+    -- @param currentState CircuitBreakerTrackState<SamplingBreakerState>
+    -- @param settings CircuitBreakerTrackSettings<SamplingBreakerState>
+    -- @return SamplingBreakerState
+    local function track(success, currentState, trackSettings)
+        local samples = {}
+
+        for _index, sample in ipairs(currentMetrics.samples)(sample) do
+            if isNotOverlapping(trackSettings.currentDate) then
+                table.insert(samples, sample)
+            end
+        end
+
+        local currentSample = samples[#samples]
+        if currentSample == nil or currentSample == cjson.null then
+            currentSample = {
+                failures = 0,
+                successes = 0,
+                startedAt = trackSettings.currentDate
+            }
+        end
+
+        local currentSampleEnd = settings.sampleTimeSpan + trackSettings.currentDate
+        local hasCurrentSampleEnded = currentSampleEnd < trackSettings.currentDate
+        if hasCurrentSampleEnded then
+            currentSample = {
+                failures = 0,
+                successes = 0,
+                startedAt = trackSettings.currentDate
+            }
+            table.insert(samples, currentSample)
+        end
+
+        if success then
+            currentSample.failures = currentSample.failures + 1
+        else
+            currentSample.successes = currentSample.successes + 1
+        end
+
+        return {
+            samples = samples
+        }
+    end
+    
+    return {
+        -- @return SamplingBreakerState
+        initialMetrics = function()
+            return {
+                samples = {}
+            }
+        end,
+
+        -- @param currentMetrics SamplingBreakerState
+        -- @param _currentDate number
+        -- @return ClosedTransitions
+        whenClosed = function(currentMetrics, _currentDate)
+            local proccesedMetricData = getProccesedMetricData(currentMetrics)
+            
+            if isMiniumNotMet(proccesedMetricData.total) then
+                return "${CLOSED_TRANSITIONS.NONE}"
+            end
+
+            local failureCount = math.ceil(settings.failureThreshold * proccesedMetricData.total)
+            local hasFailed = proccesedMetricData.totalFailures > failureCount
+            if hasFailed then
+                return "${CLOSED_TRANSITIONS.TO_OPEN}"
+            end
+
+            return "${CLOSED_TRANSITIONS.NONE}"
+        end,
+
+        -- @param currentMetrics SamplingBreakerState
+        -- @param _currentDate number
+        -- @return HalfOpenTransitions
+        whenHalfOpened = function(currentMetrics, _currentDate)
+             local proccesedMetricData = getProccesedMetricData(currentMetrics)
+            
+            if isMiniumNotMet(proccesedMetricData.total) then
+                return "${HALF_OPEN_TRANSITIONS.NONE}"
+            end
+
+            local successCount = math.ceil(settings.successThreshold * proccesedMetricData.total)
+            local hasSucceeded = proccesedMetricData.totalSuccesses > successCount
+            if hasSucceeded then
+                return "${HALF_OPEN_TRANSITIONS.TO_CLOSED}"
+            end
+
+            return "${HALF_OPEN_TRANSITIONS.TO_OPEN}"
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<SamplingBreakerState>
+        -- @param settings CircuitBreakerTrackSettings<SamplingBreakerState>
+        -- @return SamplingBreakerState
+        trackFailure = function(currentState, settings)
+            return track(false, currentState, settings)
+        end,
+
+        -- @param currentState CircuitBreakerTrackState<SamplingBreakerState>
+        -- @param settings CircuitBreakerTrackSettings<SamplingBreakerState>
+        -- @return SamplingBreakerState
+        trackSuccess = function(currentState, settings)
+            return track(true, currentState, settings)
+        end
+    }
+end
+`;
+//# sourceMappingURL=sampling-breaker-lua.js.map

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/sampling-breaker-lua.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling-breaker-lua.js","sourceRoot":"","sources":["../../../../../../src/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/sampling-breaker-lua.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,kBAAkB,EAClB,qBAAqB,GACxB,MAAM,gEAAgE,CAAC;AAExE;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkGR,kBAAkB,CAAC,IAAI;;;;;;0BAMvB,kBAAkB,CAAC,OAAO;;;sBAG9B,kBAAkB,CAAC,IAAI;;;;;;;;;;0BAUnB,qBAAqB,CAAC,IAAI;;;;;;0BAM1B,qBAAqB,CAAC,SAAS;;;sBAGnC,qBAAqB,CAAC,OAAO;;;;;;;;;;;;;;;;;;CAkBlD,CAAC"}

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/redis-circuit-breaker-adapter.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @module CircuitBreaker
+ */
+import { type Redis, type Result } from "ioredis";
+import { type BackoffSettingsEnum } from "../../../../backoff-policies/_module.js";
+import { type CircuitBreakerStateTransition, type ICircuitBreakerAdapter, type CircuitBreakerState } from "../../../../circuit-breaker/contracts/_module.js";
+import { type CircuitBreakerPolicySettingsEnum } from "../../../../circuit-breaker/implementations/policies/_module.js";
+/**
+ * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker/redis-circuit-breaker-adapter"`
+ * @group Adapters
+ */
+export type RedisCircuitBreakerAdapterSettings = {
+    database: Redis;
+    /**
+     * You can choose between different types of predefined backoff policies.
+     * @default
+     * ```ts
+     * { type: BACKOFFS.EXPONENTIAL }
+     * ```
+     */
+    backoff?: BackoffSettingsEnum;
+    /**
+     * You can choose between different types of predefined circuit breaker policies.
+     * @default
+     * ```ts
+     * { type: POLICIES.CONSECUTIVE }
+     * ```
+     */
+    policy?: CircuitBreakerPolicySettingsEnum;
+};
+declare module "ioredis" {
+    interface RedisCommander<Context> {
+        daiso_circuit_breaker_update_state(key: string, backoffSettings: string, policySettings: string, currentDate: number): Result<string, Context>;
+        daiso_circuit_breaker_track_failure(key: string, backoffSettings: string, policySettings: string, currentDate: number): Result<void, Context>;
+        daiso_circuit_breaker_track_success(key: string, backoffSettings: string, policySettings: string, currentDate: number): Result<void, Context>;
+    }
+}
+/**
+ * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker/redis-circuit-breaker-adapter"`
+ * @group Adapters
+ */
+export declare class RedisCircuitBreakerAdapter implements ICircuitBreakerAdapter {
+    private readonly backoff;
+    private readonly policy;
+    private readonly database;
+    /**
+     * @example
+     * ```ts
+     * import { RedisCircuitBreakerAdapter } from "@daiso-tech/core/circuit-breaker/redis-circuit-breaker-adapter";
+     * import Redis from "ioredis";
+     *
+     * const database = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const circuitBreakerAdapter = new RedisCircuitBreakerAdapter({
+     *   database
+     * });
+     * ```
+     */
+    constructor(settings: RedisCircuitBreakerAdapterSettings);
+    private initUpdateStateCommmand;
+    private initTrackFailureCommmand;
+    private initTrackSuccessCommmand;
+    getState(key: string): Promise<CircuitBreakerState>;
+    updateState(key: string): Promise<CircuitBreakerStateTransition>;
+    isolate(key: string): Promise<void>;
+    trackFailure(key: string): Promise<void>;
+    trackSuccess(key: string): Promise<void>;
+    reset(key: string): Promise<void>;
+}

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/redis-circuit-breaker-adapter.js

@@ -0,0 +1,131 @@
+/**
+ * @module CircuitBreaker
+ */
+import {} from "ioredis";
+import { BACKOFFS, resolveBackoffSettingsEnum, serializeBackoffSettingsEnum, } from "../../../../backoff-policies/_module.js";
+import { CIRCUIT_BREAKER_STATE, } from "../../../../circuit-breaker/contracts/_module.js";
+import {} from "../../../../circuit-breaker/implementations/adapters/database-circuit-breaker-adapter/circuit-breaker-policy.js";
+import { circuitBreakerFactoryLua } from "../../../../circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/_module.js";
+import { BREAKER_POLICIES, resolveCircuitBreakerPolicySettings, serializeCircuitBreakerPolicySettingsEnum, } from "../../../../circuit-breaker/implementations/policies/_module.js";
+/**
+ * IMPORT_PATH: `"@daiso-tech/core/circuit-breaker/redis-circuit-breaker-adapter"`
+ * @group Adapters
+ */
+export class RedisCircuitBreakerAdapter {
+    backoff;
+    policy;
+    database;
+    /**
+     * @example
+     * ```ts
+     * import { RedisCircuitBreakerAdapter } from "@daiso-tech/core/circuit-breaker/redis-circuit-breaker-adapter";
+     * import Redis from "ioredis";
+     *
+     * const database = new Redis("YOUR_REDIS_CONNECTION_STRING");
+     * const circuitBreakerAdapter = new RedisCircuitBreakerAdapter({
+     *   database
+     * });
+     * ```
+     */
+    constructor(settings) {
+        const { database, backoff = {
+            type: BACKOFFS.EXPONENTIAL,
+        }, policy = {
+            type: BREAKER_POLICIES.CONSECUTIVE,
+        }, } = settings;
+        this.database = database;
+        this.backoff = resolveBackoffSettingsEnum(backoff);
+        this.policy = resolveCircuitBreakerPolicySettings(policy);
+        this.initUpdateStateCommmand();
+        this.initTrackFailureCommmand();
+        this.initTrackSuccessCommmand();
+    }
+    initUpdateStateCommmand() {
+        if (typeof this.database.daiso_circuit_breaker_update_state ===
+            "function") {
+            return;
+        }
+        this.database.defineCommand("daiso_circuit_breaker_update_state", {
+            numberOfKeys: 1,
+            lua: `
+            ${circuitBreakerFactoryLua}
+
+            local key = KEYS[1];
+            local backoffSettings = cjson.decode(ARGV[1]);
+            local policySettings = cjson.decode(ARGV[2]);
+            local currentDate = tonumber(ARGV[3]);
+
+            local circuitBreaker = circuitBreakerFactory(backoffSettings, policySettings, currentDate)
+            local transition = circuitBreaker.updateState(key)
+            return cjson.encode(transition)
+            `,
+        });
+    }
+    initTrackFailureCommmand() {
+        if (typeof this.database.daiso_circuit_breaker_track_failure ===
+            "function") {
+            return;
+        }
+        this.database.defineCommand("daiso_circuit_breaker_track_failure", {
+            numberOfKeys: 1,
+            lua: `
+            ${circuitBreakerFactoryLua}
+
+            local key = KEYS[1];
+            local backoffSettings = cjson.decode(ARGV[1]);
+            local policySettings = cjson.decode(ARGV[2]);
+            local currentDate = tonumber(ARGV[3]);
+
+            local circuitBreaker = circuitBreakerFactory(backoffSettings, policySettings, currentDate)
+            circuitBreaker.trackFailure(key)
+            `,
+        });
+    }
+    initTrackSuccessCommmand() {
+        if (typeof this.database.daiso_circuit_breaker_track_success ===
+            "function") {
+            return;
+        }
+        this.database.defineCommand("daiso_circuit_breaker_track_success", {
+            numberOfKeys: 1,
+            lua: `
+            ${circuitBreakerFactoryLua}
+
+            local key = KEYS[1];
+            local backoffSettings = cjson.decode(ARGV[1]);
+            local policySettings = cjson.decode(ARGV[2]);
+            local currentDate = tonumber(ARGV[3]);
+
+            local circuitBreaker = circuitBreakerFactory(backoffSettings, policySettings, currentDate)
+            circuitBreaker.trackSuccess(key)
+            `,
+        });
+    }
+    async getState(key) {
+        const value = await this.database.get(key);
+        if (value === null) {
+            return CIRCUIT_BREAKER_STATE.CLOSED;
+        }
+        const state = JSON.parse(value);
+        return state.type;
+    }
+    async updateState(key) {
+        const value = await this.database.daiso_circuit_breaker_update_state(key, JSON.stringify(serializeBackoffSettingsEnum(this.backoff)), JSON.stringify(serializeCircuitBreakerPolicySettingsEnum(this.policy)), Date.now());
+        return JSON.parse(value);
+    }
+    async isolate(key) {
+        await this.database.set(key, JSON.stringify({
+            type: CIRCUIT_BREAKER_STATE.ISOLATED,
+        }));
+    }
+    async trackFailure(key) {
+        await this.database.daiso_circuit_breaker_track_failure(key, JSON.stringify(serializeBackoffSettingsEnum(this.backoff)), JSON.stringify(serializeCircuitBreakerPolicySettingsEnum(this.policy)), Date.now());
+    }
+    async trackSuccess(key) {
+        await this.database.daiso_circuit_breaker_track_success(key, JSON.stringify(serializeBackoffSettingsEnum(this.backoff)), JSON.stringify(serializeCircuitBreakerPolicySettingsEnum(this.policy)), Date.now());
+    }
+    async reset(key) {
+        await this.database.del(key);
+    }
+}
+//# sourceMappingURL=redis-circuit-breaker-adapter.js.map

package/dist/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/redis-circuit-breaker-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-circuit-breaker-adapter.js","sourceRoot":"","sources":["../../../../../src/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/redis-circuit-breaker-adapter.ts"],"names":[],"mappings":"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"}

package/dist/circuit-breaker/implementations/derivables/_module-exports.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js";
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider-factory/_module.js";

package/dist/circuit-breaker/implementations/derivables/_module-exports.js

@@ -0,0 +1,3 @@
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js";
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider-factory/_module.js";
+//# sourceMappingURL=_module-exports.js.map

package/dist/circuit-breaker/implementations/derivables/_module-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module-exports.js","sourceRoot":"","sources":["../../../../src/circuit-breaker/implementations/derivables/_module-exports.ts"],"names":[],"mappings":"AAAA,cAAc,kFAAkF,CAAC;AACjG,cAAc,0FAA0F,CAAC"}

package/dist/circuit-breaker/implementations/derivables/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js";
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider-factory/_module.js";

package/dist/circuit-breaker/implementations/derivables/_module.js

@@ -0,0 +1,3 @@
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js";
+export * from "../../../circuit-breaker/implementations/derivables/circuit-breaker-provider-factory/_module.js";
+//# sourceMappingURL=_module.js.map

package/dist/circuit-breaker/implementations/derivables/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/circuit-breaker/implementations/derivables/_module.ts"],"names":[],"mappings":"AAAA,cAAc,kFAAkF,CAAC;AACjG,cAAc,0FAA0F,CAAC"}

package/dist/circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/circuit-breaker-provider.js";

package/dist/circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js

@@ -0,0 +1,2 @@
+export * from "../../../../circuit-breaker/implementations/derivables/circuit-breaker-provider/circuit-breaker-provider.js";
+//# sourceMappingURL=_module.js.map

package/dist/circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../../src/circuit-breaker/implementations/derivables/circuit-breaker-provider/_module.ts"],"names":[],"mappings":"AAAA,cAAc,mGAAmG,CAAC"}