brass-runtime 1.16.0 → 1.17.0

package/dist/chunk-62AZW6UT.cjs

@@ -0,0 +1,313 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJF5WGYJJcjs = require('./chunk-JF5WGYJJ.cjs');
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunkJF5WGYJJcjs.Scope)(runtime);
+    const acquireFiber = scope.fork(acquire);
+    acquireFiber.join((acquireExit) => {
+      if (acquireExit._tag === "Failure") {
+        scope.close(acquireExit);
+        cb(acquireExit);
+        return;
+      }
+      const resource2 = acquireExit.value;
+      const useFiber = scope.fork(use(resource2));
+      useFiber.join((useExit) => {
+        const releaseEffect = safeRelease(release, resource2, useExit);
+        const releaseFiber = runtime.fork(releaseEffect);
+        releaseFiber.join(() => {
+          scope.close(useExit);
+          cb(useExit);
+        });
+      });
+    });
+    return () => {
+      scope.close(_chunkMVGUEJ5Zcjs.Exit.failCause(_chunkMVGUEJ5Zcjs.Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource2, exit) {
+  return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    (() => {
+      try {
+        return release(resource2, exit);
+      } catch (e) {
+        return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+      }
+    })(),
+    () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+    () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+  );
+}
+function ensuring(effect, finalizer) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch (e2) {
+            return _chunkMVGUEJ5Zcjs.unit.call(void 0, );
+          }
+        })(),
+        () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+        () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+      );
+      runtime.fork(fin).join(() => {
+        cb(exit);
+      });
+    });
+    return () => {
+      fiber.interrupt();
+    };
+  });
+}
+function resource(acquire, release) {
+  return makeResourceFromUse((body) => bracket(acquire, body, release));
+}
+var makeResource = resource;
+function resourceSucceed(value) {
+  return makeResourceFromUse((body) => body(value));
+}
+function resourceFromManaged(m) {
+  return makeResourceFromUse((body) => useManaged(m, body));
+}
+function useResource(res, body) {
+  return res.use(body);
+}
+function resourceAll(resources) {
+  const build = (index) => {
+    if (index >= resources.length) return resourceSucceed([]);
+    return resources[index].flatMap(
+      (head) => build(index + 1).map((tail) => [head, ...tail])
+    );
+  };
+  return build(0).map((values) => values);
+}
+var Resource = Object.freeze({
+  make: resource,
+  succeed: resourceSucceed,
+  fromManaged: resourceFromManaged,
+  all: resourceAll,
+  use: useResource
+});
+function makeResourceFromUse(use) {
+  const self = {
+    _tag: "Resource",
+    use,
+    map: (f) => makeResourceFromUse((body) => self.use((a) => body(f(a)))),
+    flatMap: (f) => makeResourceFromUse((body) => self.use((a) => f(a).use(body))),
+    zip: (that) => self.flatMap((a) => that.map((b) => [a, b]))
+  };
+  return self;
+}
+function managed(acquire, release) {
+  return {
+    _tag: "Managed",
+    acquire,
+    release: (resource2, exit) => release(resource2, exit)
+  };
+}
+function useManaged(m, body) {
+  return bracket(m.acquire, body, m.release);
+}
+function managedAll(manageds) {
+  const acquire = _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const resources = [];
+    let i = 0;
+    const acquireNext = () => {
+      if (i >= manageds.length) {
+        cb({ _tag: "Success", value: resources });
+        return;
+      }
+      const m = manageds[i];
+      const fiber = runtime.fork(m.acquire);
+      fiber.join((exit) => {
+        if (exit._tag === "Failure") {
+          releaseAcquired(runtime, manageds, resources, exit).then(() => {
+            cb(exit);
+          });
+          return;
+        }
+        resources.push(exit.value);
+        i++;
+        acquireNext();
+      });
+    };
+    acquireNext();
+  });
+  const release = (resources, exit) => {
+    return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
+      const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+      releaseAcquired(runtime, manageds, resources, exit).then(() => {
+        cb({ _tag: "Success", value: void 0 });
+      });
+    });
+  };
+  return { _tag: "Managed", acquire, release };
+}
+async function releaseAcquired(runtime, manageds, resources, exit) {
+  for (let i = resources.length - 1; i >= 0; i--) {
+    try {
+      const m = manageds[i];
+      await new Promise((resolve) => {
+        const releaseEff = _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+          m.release(resources[i], exit),
+          () => _chunkMVGUEJ5Zcjs.unit.call(void 0, ),
+          () => _chunkMVGUEJ5Zcjs.unit.call(void 0, )
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch (e3) {
+    }
+  }
+}
+
+// src/core/runtime/circuitBreaker.ts
+function makeCircuitBreaker(config = {}) {
+  const failureThreshold = _nullishCoalesce(config.failureThreshold, () => ( 5));
+  const resetTimeoutMs = _nullishCoalesce(config.resetTimeoutMs, () => ( 3e4));
+  const successThreshold = _nullishCoalesce(config.successThreshold, () => ( 1));
+  const isFailure = _nullishCoalesce(config.isFailure, () => ( (() => true)));
+  const onStateChange = config.onStateChange;
+  let currentState = "closed";
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  let openedAt = 0;
+  let totalRequests = 0;
+  let totalFailures = 0;
+  let totalSuccesses = 0;
+  let totalRejected = 0;
+  let lastFailureTime = null;
+  let lastSuccessTime = null;
+  const transition = (to) => {
+    if (currentState === to) return;
+    const from = currentState;
+    currentState = to;
+    _optionalChain([onStateChange, 'optionalCall', _ => _(from, to)]);
+  };
+  const onSuccess = () => {
+    totalSuccesses++;
+    lastSuccessTime = Date.now();
+    consecutiveFailures = 0;
+    if (currentState === "half-open") {
+      consecutiveSuccesses++;
+      if (consecutiveSuccesses >= successThreshold) {
+        consecutiveSuccesses = 0;
+        transition("closed");
+      }
+    }
+  };
+  const onFailure = (error) => {
+    if (!isFailure(error)) {
+      onSuccess();
+      return;
+    }
+    totalFailures++;
+    lastFailureTime = Date.now();
+    consecutiveSuccesses = 0;
+    consecutiveFailures++;
+    if (currentState === "half-open") {
+      openedAt = Date.now();
+      transition("open");
+    } else if (currentState === "closed" && consecutiveFailures >= failureThreshold) {
+      openedAt = Date.now();
+      transition("open");
+    }
+  };
+  const shouldAllow = () => {
+    switch (currentState) {
+      case "closed":
+        return true;
+      case "open": {
+        const elapsed = Date.now() - openedAt;
+        if (elapsed >= resetTimeoutMs) {
+          transition("half-open");
+          return true;
+        }
+        return false;
+      }
+      case "half-open":
+        return true;
+    }
+  };
+  const protect = (effect) => {
+    totalRequests++;
+    if (!shouldAllow()) {
+      totalRejected++;
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, {
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (error) => {
+        onFailure(error);
+        return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+      },
+      (value) => {
+        onSuccess();
+        return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value);
+      }
+    );
+  };
+  const stats = () => ({
+    state: currentState,
+    failures: consecutiveFailures,
+    successes: consecutiveSuccesses,
+    totalRequests,
+    totalFailures,
+    totalSuccesses,
+    totalRejected,
+    lastFailureTime,
+    lastSuccessTime
+  });
+  const reset = () => {
+    consecutiveFailures = 0;
+    consecutiveSuccesses = 0;
+    transition("closed");
+  };
+  return {
+    state: () => currentState,
+    protect,
+    stats,
+    reset
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.bracket = bracket; exports.ensuring = ensuring; exports.resource = resource; exports.makeResource = makeResource; exports.resourceSucceed = resourceSucceed; exports.resourceFromManaged = resourceFromManaged; exports.useResource = useResource; exports.resourceAll = resourceAll; exports.Resource = Resource; exports.managed = managed; exports.useManaged = useManaged; exports.managedAll = managedAll; exports.makeCircuitBreaker = makeCircuitBreaker;