@daiso-tech/core 0.42.0 → 0.44.0

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/internal-circuit-breaker-policy-lua.d.ts

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

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

@@ -0,0 +1,144 @@
+/**
+ * @module CircuitBreaker
+ */
+import { CIRCUIT_BREAKER_STATE, CLOSED_TRANSITIONS, HALF_OPEN_TRANSITIONS, } from "../../../../../circuit-breaker/contracts/_module.js";
+/**
+ * @internal
+ */
+export const circuitBreakerPolicyLua = `
+-- @template TMetrics
+-- @param circuitBreakerPolicy ICircuitBreakerPolicy<TMetrics>
+local function InternalCircuitBreakerPolicy(circuitBreakerPolicy)
+    return {   
+        initialState = function()
+            return {
+                type = "${CIRCUIT_BREAKER_STATE.CLOSED}",
+                metrics = circuitBreakerPolicy.initialMetrics(),
+            }
+        end,
+
+        -- @param currentState ClosedState<TMetrics>
+        -- @param currentDate number
+        -- @return ClosedState<TMetrics> | OpenedState
+        whenClosed = function(currentState, currentDate)
+            local transition = circuitBreakerPolicy.whenClosed(currentState.metrics, currentDate)
+            
+            if transition == "${CLOSED_TRANSITIONS.NONE}" then
+                return currentState
+            end
+
+            return {
+                type = "${CIRCUIT_BREAKER_STATE.OPEN}",
+                attempt = 1,
+                startedAt = currentDate
+            }
+        end,
+
+        -- @param OpenedState
+        -- @param BackoffPolicySettings
+        -- @return OpenedState | HalfOpenedState<TMetrics>
+        whenOpened = function(currentState, settings)
+            local waitTime = settings.backoffPolicy(currentState.attempt, nil)
+            local endDate = currentState.startedAt + waitTime
+            local isWaitTimeOver = endDate <= settings.currentDate
+
+            if isWaitTimeOver then
+                return {
+                    type = "${CIRCUIT_BREAKER_STATE.HALF_OPEN}",
+                    attempt = currentState.attempt,
+                    metrics = circuitBreakerPolicy.initialMetrics(),
+                }
+            end
+
+            return currentState
+        end,
+
+        -- @param currentState HalfOpenedState<TMetrics>
+        -- @param currentDate number
+        -- @return ClosedState<TMetrics> | OpenedState | HalfOpenedState<TMetrics>
+        whenHalfOpened = function(currentState, currentDate)
+            local transition = circuitBreakerPolicy.whenHalfOpened(currentState.metrics, currentDate)
+
+            if transition == "${HALF_OPEN_TRANSITIONS.NONE}" then
+                return currentState
+            end
+
+            if transition == "${HALF_OPEN_TRANSITIONS.TO_CLOSED}" then
+                return {
+                    type = "${CIRCUIT_BREAKER_STATE.CLOSED}",
+                    metrics = circuitBreakerPolicy.initialMetrics(),
+                }
+            end
+            
+            return {
+                type = "${CIRCUIT_BREAKER_STATE.OPEN}",
+                attempt = currentState.attempt + 1,
+                startedAt = currentDate,
+            };
+        end,
+
+        -- @param currentState ClosedState<TMetrics>
+        -- @param currentDate number
+        -- @return ClosedState<TMetrics>
+        trackSuccessWhenClosed = function(currentState, currentDate)
+            local newMetrics = circuitBreakerPolicy.trackSuccess(currentState, {
+                currentDate = currentDate,
+                initialMetrics = circuitBreakerPolicy.initialMetrics()
+            })
+            
+            return {
+                type = currentState.type,
+                metrics = newMetrics
+            }
+        end,
+        
+        -- @param currentState ClosedState<TMetrics>
+        -- @param currentDate number
+        -- @return ClosedState<TMetrics>
+        trackFailureWhenClosed = function(currentState, currentDate)
+            local newMetrics = circuitBreakerPolicy.trackFailure(currentState, {
+                currentDate = currentDate,
+                initialMetrics = circuitBreakerPolicy.initialMetrics()
+            })
+            
+            return {
+                type = currentState.type,
+                metrics = newMetrics
+            }
+        end,
+
+        -- @param currentState HalfOpenedState<TMetrics>
+        -- @param currentDate number
+        -- @return HalfOpenedState<TMetrics>
+        trackSuccessWhenHalfOpened = function(currentState, currentDate)
+            local newMetrics = circuitBreakerPolicy.trackSuccess(currentState, {
+                currentDate = currentDate,
+                initialMetrics = circuitBreakerPolicy.initialMetrics()
+            })
+            
+            return {
+                type = currentState.type,
+                attempt = currentState.attempt,
+                metrics = newMetrics
+            }
+        end,
+
+        -- @param currentState HalfOpenedState<TMetrics>
+        -- @param currentDate number
+        -- @return HalfOpenedState<TMetrics>
+        trackFailureWhenHalfOpened = function(currentState, currentDate)
+            local newMetrics = circuitBreakerPolicy.trackFailure(currentState, {
+                currentDate = currentDate,
+                initialMetrics = circuitBreakerPolicy.initialMetrics()
+            })
+            
+            return {
+                type = currentState.type,
+                attempt = currentState.attempt,
+                metrics = newMetrics
+            }
+        end,
+    }
+end
+`;
+//# sourceMappingURL=internal-circuit-breaker-policy-lua.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal-circuit-breaker-policy-lua.js","sourceRoot":"","sources":["../../../../../../src/circuit-breaker/implementations/adapters/redis-circuit-breaker-adapter/lua/internal-circuit-breaker-policy-lua.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,GACxB,MAAM,wCAAwC,CAAC;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;0BAOb,qBAAqB,CAAC,MAAM;;;;;;;;;;;gCAWtB,kBAAkB,CAAC,IAAI;;;;;0BAK7B,qBAAqB,CAAC,IAAI;;;;;;;;;;;;;;;;8BAgBtB,qBAAqB,CAAC,SAAS;;;;;;;;;;;;;;;gCAe7B,qBAAqB,CAAC,IAAI;;;;gCAI1B,qBAAqB,CAAC,SAAS;;8BAEjC,qBAAqB,CAAC,MAAM;;;;;;0BAMhC,qBAAqB,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEnD,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 }
+     * ```
+     */
+    backoffPolicy?: BackoffSettingsEnum;
+    /**
+     * You can choose between different types of predefined circuit breaker policies.
+     * @default
+     * ```ts
+     * { type: POLICIES.CONSECUTIVE }
+     * ```
+     */
+    circuitBreakerPolicy?: 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/internal-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, backoffPolicy = {
+            type: BACKOFFS.EXPONENTIAL,
+        }, circuitBreakerPolicy = {
+            type: BREAKER_POLICIES.CONSECUTIVE,
+        }, } = settings;
+        this.database = database;
+        this.backoff = resolveBackoffSettingsEnum(backoffPolicy);
+        this.policy = resolveCircuitBreakerPolicySettings(circuitBreakerPolicy);
+        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":"AAAA;;GAEG;AAEH,OAAO,EAA2B,MAAM,SAAS,CAAC;AAElD,OAAO,EACH,QAAQ,EACR,0BAA0B,EAC1B,4BAA4B,GAE/B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAIH,qBAAqB,GACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAA+B,MAAM,gHAAgH,CAAC;AAC7J,OAAO,EAAE,wBAAwB,EAAE,MAAM,yFAAyF,CAAC;AACnI,OAAO,EACH,gBAAgB,EAChB,mCAAmC,EACnC,yCAAyC,GAE5C,MAAM,uDAAuD,CAAC;AAqD/D;;;GAGG;AACH,MAAM,OAAO,0BAA0B;IAClB,OAAO,CAAgC;IAEvC,MAAM,CAA6C;IAEnD,QAAQ,CAAQ;IAEjC;;;;;;;;;;;OAWG;IACH,YAAY,QAA4C;QACpD,MAAM,EACF,QAAQ,EACR,aAAa,GAAG;YACZ,IAAI,EAAE,QAAQ,CAAC,WAAW;SAC7B,EACD,oBAAoB,GAAG;YACnB,IAAI,EAAE,gBAAgB,CAAC,WAAW;SACrC,GACJ,GAAG,QAAQ,CAAC;QAEb,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,0BAA0B,CAAC,aAAa,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,GAAG,mCAAmC,CAAC,oBAAoB,CAAC,CAAC;QAExE,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACpC,CAAC;IAEO,uBAAuB;QAC3B,IACI,OAAO,IAAI,CAAC,QAAQ,CAAC,kCAAkC;YACvD,UAAU,EACZ,CAAC;YACC,OAAO;QACX,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,oCAAoC,EAAE;YAC9D,YAAY,EAAE,CAAC;YACf,GAAG,EAAE;cACH,wBAAwB;;;;;;;;;;aAUzB;SACJ,CAAC,CAAC;IACP,CAAC;IAEO,wBAAwB;QAC5B,IACI,OAAO,IAAI,CAAC,QAAQ,CAAC,mCAAmC;YACxD,UAAU,EACZ,CAAC;YACC,OAAO;QACX,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,qCAAqC,EAAE;YAC/D,YAAY,EAAE,CAAC;YACf,GAAG,EAAE;cACH,wBAAwB;;;;;;;;;aASzB;SACJ,CAAC,CAAC;IACP,CAAC;IAEO,wBAAwB;QAC5B,IACI,OAAO,IAAI,CAAC,QAAQ,CAAC,mCAAmC;YACxD,UAAU,EACZ,CAAC;YACC,OAAO;QACX,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,qCAAqC,EAAE;YAC/D,YAAY,EAAE,CAAC;YACf,GAAG,EAAE;cACH,wBAAwB;;;;;;;;;aASzB;SACJ,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,GAAW;QACtB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACjB,OAAO,qBAAqB,CAAC,MAAM,CAAC;QACxC,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAA2B,CAAC;QAC1D,OAAO,KAAK,CAAC,IAAI,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,GAAW;QACzB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAChE,GAAG,EACH,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAC1D,IAAI,CAAC,SAAS,CACV,yCAAyC,CAAC,IAAI,CAAC,MAAM,CAAC,CACzD,EACD,IAAI,CAAC,GAAG,EAAE,CACb,CAAC;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAkC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,GAAW;QACrB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CACnB,GAAG,EACH,IAAI,CAAC,SAAS,CAAC;YACX,IAAI,EAAE,qBAAqB,CAAC,QAAQ;SACvC,CAAC,CACL,CAAC;IACN,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,GAAW;QAC1B,MAAM,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CACnD,GAAG,EACH,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAC1D,IAAI,CAAC,SAAS,CACV,yCAAyC,CAAC,IAAI,CAAC,MAAM,CAAC,CACzD,EACD,IAAI,CAAC,GAAG,EAAE,CACb,CAAC;IACN,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,GAAW;QAC1B,MAAM,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CACnD,GAAG,EACH,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAC1D,IAAI,CAAC,SAAS,CACV,yCAAyC,CAAC,IAAI,CAAC,MAAM,CAAC,CACzD,EACD,IAAI,CAAC,GAAG,EAAE,CACb,CAAC;IACN,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,GAAW;QACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;CACJ"}

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"}