@absolutejs/sync 2.2.1 → 2.3.0

package/dist/index.js

@@ -82,6 +82,323 @@ var createWriteBehindCache = (options) => {
     }
   };
 };
+// node_modules/@absolutejs/telemetry/dist/index.js
+var NOOP_SPAN_CONTEXT = {
+  spanId: "0000000000000000",
+  traceFlags: 0,
+  traceId: "00000000000000000000000000000000"
+};
+var noopSpan = {
+  addEvent: () => noopSpan,
+  end: () => {},
+  isRecording: () => false,
+  recordException: () => {},
+  setAttribute: () => noopSpan,
+  setAttributes: () => noopSpan,
+  setStatus: () => noopSpan,
+  spanContext: () => NOOP_SPAN_CONTEXT,
+  updateName: () => noopSpan
+};
+var startActiveSpanNoop = (_name, optionsOrFn, maybeFn) => {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  return fn(noopSpan);
+};
+var noopTracer = {
+  startActiveSpan: startActiveSpanNoop,
+  startSpan: () => noopSpan
+};
+var tracerOrNoop = (provider, name, version) => provider !== undefined ? provider.getTracer(name, version) : noopTracer;
+var ABS_ATTRS = {
+  tenant: "abs.tenant",
+  shardId: "abs.shard.id",
+  engineId: "abs.engine.id",
+  collection: "abs.collection",
+  mutation: "abs.mutation",
+  mutationAttempt: "abs.mutation.attempt",
+  subscriptionId: "abs.subscription.id",
+  batchSize: "abs.batch.size",
+  clusterMessageOrigin: "abs.cluster.origin",
+  jobId: "abs.job.id",
+  jobKind: "abs.job.kind",
+  jobAttempt: "abs.job.attempt",
+  jobMaxAttempts: "abs.job.max_attempts",
+  workerId: "abs.worker.id",
+  runtimeKey: "abs.runtime.key",
+  runtimePid: "abs.runtime.pid",
+  runtimePort: "abs.runtime.port",
+  runtimeExitReason: "abs.runtime.exit_reason",
+  runtimeReadinessMs: "abs.runtime.readiness_ms",
+  routeShard: "abs.route.shard",
+  routeDecision: "abs.route.decision",
+  secretName: "abs.secret.name",
+  secretFingerprint: "abs.secret.fingerprint",
+  auditKind: "abs.audit.kind"
+};
+
+// src/connectionBroker.ts
+class LeaseTimeoutError extends Error {
+  tenant;
+  timeoutMs;
+  constructor(tenant, timeoutMs) {
+    super(`Lease for tenant "${tenant}" timed out after ${timeoutMs}ms; ` + `the broker is at its connection caps and nothing freed up ` + `in time. Raise maxTotal/maxPerTenant or shed load upstream.`);
+    this.name = "LeaseTimeoutError";
+    this.tenant = tenant;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class ConnectionBrokerDrainedError extends Error {
+  constructor() {
+    super("Connection broker is drained; no new leases are issued. " + "Construct a fresh broker to resume leasing.");
+    this.name = "ConnectionBrokerDrainedError";
+  }
+}
+var QUEUE_WAIT_ATTR = "abs.broker.queue_wait_ms";
+var createConnectionBroker = (options) => {
+  if (!Number.isFinite(options.maxTotal) || options.maxTotal <= 0) {
+    throw new RangeError(`createConnectionBroker requires maxTotal > 0 (got ${options.maxTotal})`);
+  }
+  const now = options.now ?? Date.now;
+  const tracer = tracerOrNoop(options.tracerProvider, "@absolutejs/sync");
+  const idle = [];
+  const queue = [];
+  const inUseByTenant = new Map;
+  let inUse = 0;
+  let drained = false;
+  let disposed = false;
+  let drainPromise;
+  let resolveDrain;
+  const cumulative = {
+    created: 0,
+    destroyed: 0,
+    leases: 0,
+    releases: 0,
+    timeouts: 0,
+    validationFailures: 0
+  };
+  const destroyConn = async (conn) => {
+    cumulative.destroyed += 1;
+    try {
+      await options.destroy?.(conn);
+    } catch (error) {
+      options.onError?.(error, "destroy");
+    }
+  };
+  const sweepIdle = () => {
+    const idleReleaseMs = options.idleReleaseMs;
+    if (idleReleaseMs === undefined)
+      return;
+    const cutoff = now() - idleReleaseMs;
+    while (idle.length > 0 && idle[0] !== undefined) {
+      const oldest = idle[0];
+      if (oldest.idleSince > cutoff)
+        break;
+      idle.shift();
+      destroyConn(oldest.conn);
+    }
+  };
+  const sweepTimer = options.idleReleaseMs === undefined ? undefined : setInterval(sweepIdle, options.idleReleaseMs);
+  sweepTimer?.unref?.();
+  const canGrant = (tenant) => inUse < options.maxTotal && (options.maxPerTenant === undefined || (inUseByTenant.get(tenant) ?? 0) < options.maxPerTenant);
+  const reserve = (tenant) => {
+    inUse += 1;
+    inUseByTenant.set(tenant, (inUseByTenant.get(tenant) ?? 0) + 1);
+  };
+  const unreserve = (tenant) => {
+    inUse -= 1;
+    const count = inUseByTenant.get(tenant) ?? 0;
+    if (count <= 1)
+      inUseByTenant.delete(tenant);
+    else
+      inUseByTenant.set(tenant, count - 1);
+    if (drained && inUse === 0 && queue.length === 0) {
+      resolveDrain?.();
+    }
+  };
+  const acquireConn = async () => {
+    let entry = idle.pop();
+    while (entry !== undefined) {
+      if (options.validate === undefined)
+        return entry.conn;
+      let healthy = false;
+      try {
+        healthy = await options.validate(entry.conn);
+      } catch (error) {
+        options.onError?.(error, "validate");
+      }
+      if (healthy)
+        return entry.conn;
+      cumulative.validationFailures += 1;
+      await destroyConn(entry.conn);
+      entry = idle.pop();
+    }
+    try {
+      const conn = await options.create();
+      cumulative.created += 1;
+      return conn;
+    } catch (error) {
+      options.onError?.(error, "create");
+      throw error;
+    }
+  };
+  const endSpanWithError = (span, error) => {
+    const spanError = error instanceof Error ? error : new Error(String(error));
+    span.recordException(spanError);
+    span.setStatus({
+      code: 2,
+      message: spanError.message
+    });
+    span.end();
+  };
+  const makeLease = (tenant, conn) => {
+    cumulative.leases += 1;
+    let released = false;
+    return {
+      conn,
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        cumulative.releases += 1;
+        if (disposed) {
+          destroyConn(conn);
+        } else {
+          idle.push({ conn, idleSince: now() });
+        }
+        unreserve(tenant);
+        pump();
+      }
+    };
+  };
+  const grantTo = async (waiter) => {
+    try {
+      const conn = await acquireConn();
+      waiter.span.setAttribute(QUEUE_WAIT_ATTR, now() - waiter.enqueuedAt);
+      waiter.span.end();
+      waiter.resolve(makeLease(waiter.tenant, conn));
+    } catch (error) {
+      unreserve(waiter.tenant);
+      endSpanWithError(waiter.span, error);
+      waiter.reject(error);
+      pump();
+    }
+  };
+  const pump = () => {
+    if (disposed)
+      return;
+    let index = 0;
+    while (index < queue.length) {
+      const waiter = queue[index];
+      if (waiter === undefined)
+        break;
+      if (!canGrant(waiter.tenant)) {
+        index += 1;
+        continue;
+      }
+      queue.splice(index, 1);
+      if (waiter.timer !== undefined)
+        clearTimeout(waiter.timer);
+      reserve(waiter.tenant);
+      grantTo(waiter);
+    }
+  };
+  const rejectQueued = (error) => {
+    const waiting = queue.splice(0, queue.length);
+    for (const waiter of waiting) {
+      if (waiter.timer !== undefined)
+        clearTimeout(waiter.timer);
+      const rejection = error();
+      endSpanWithError(waiter.span, rejection);
+      waiter.reject(rejection);
+    }
+  };
+  const lease = async (tenant) => {
+    if (drained)
+      throw new ConnectionBrokerDrainedError;
+    sweepIdle();
+    const span = tracer.startSpan("sync.broker_lease", {
+      attributes: { [ABS_ATTRS.tenant]: tenant }
+    });
+    const startedAt = now();
+    if (canGrant(tenant)) {
+      reserve(tenant);
+      try {
+        const conn = await acquireConn();
+        span.setAttribute(QUEUE_WAIT_ATTR, now() - startedAt);
+        span.end();
+        return makeLease(tenant, conn);
+      } catch (error) {
+        unreserve(tenant);
+        endSpanWithError(span, error);
+        pump();
+        throw error;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        enqueuedAt: startedAt,
+        reject,
+        resolve,
+        span,
+        tenant,
+        timer: undefined
+      };
+      if (options.acquireTimeoutMs !== undefined) {
+        const timeoutMs = options.acquireTimeoutMs;
+        waiter.timer = setTimeout(() => {
+          const position = queue.indexOf(waiter);
+          if (position === -1)
+            return;
+          queue.splice(position, 1);
+          cumulative.timeouts += 1;
+          const timeout = new LeaseTimeoutError(tenant, timeoutMs);
+          endSpanWithError(span, timeout);
+          reject(timeout);
+        }, timeoutMs);
+      }
+      queue.push(waiter);
+    });
+  };
+  const drain = () => {
+    drained = true;
+    if (drainPromise === undefined) {
+      drainPromise = inUse === 0 && queue.length === 0 ? Promise.resolve() : new Promise((resolve) => {
+        resolveDrain = resolve;
+      });
+    }
+    return drainPromise;
+  };
+  return {
+    dispose: async () => {
+      drained = true;
+      disposed = true;
+      if (sweepTimer !== undefined)
+        clearInterval(sweepTimer);
+      rejectQueued(() => new ConnectionBrokerDrainedError);
+      const pooled = idle.splice(0, idle.length);
+      await Promise.all(pooled.map((entry) => destroyConn(entry.conn)));
+      if (inUse === 0)
+        resolveDrain?.();
+    },
+    drain,
+    lease,
+    metrics: () => ({
+      byTenant: Object.fromEntries(inUseByTenant),
+      cumulative: { ...cumulative },
+      idle: idle.length,
+      inUse,
+      queued: queue.length
+    }),
+    withLease: async (tenant, fn) => {
+      const { conn, release } = await lease(tenant);
+      try {
+        return await fn(conn);
+      } finally {
+        release();
+      }
+    }
+  };
+};
 // src/reactiveHub.ts
 var SYNC_OPEN_TOPIC = "@absolutejs/sync:open";
 var createReactiveHub = () => {
@@ -564,59 +881,6 @@ var syncSocket = ({
     }
   });
 };
-// node_modules/@absolutejs/telemetry/dist/index.js
-var NOOP_SPAN_CONTEXT = {
-  spanId: "0000000000000000",
-  traceFlags: 0,
-  traceId: "00000000000000000000000000000000"
-};
-var noopSpan = {
-  addEvent: () => noopSpan,
-  end: () => {},
-  isRecording: () => false,
-  recordException: () => {},
-  setAttribute: () => noopSpan,
-  setAttributes: () => noopSpan,
-  setStatus: () => noopSpan,
-  spanContext: () => NOOP_SPAN_CONTEXT,
-  updateName: () => noopSpan
-};
-var startActiveSpanNoop = (_name, optionsOrFn, maybeFn) => {
-  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
-  return fn(noopSpan);
-};
-var noopTracer = {
-  startActiveSpan: startActiveSpanNoop,
-  startSpan: () => noopSpan
-};
-var tracerOrNoop = (provider, name, version) => provider !== undefined ? provider.getTracer(name, version) : noopTracer;
-var ABS_ATTRS = {
-  tenant: "abs.tenant",
-  shardId: "abs.shard.id",
-  engineId: "abs.engine.id",
-  collection: "abs.collection",
-  mutation: "abs.mutation",
-  mutationAttempt: "abs.mutation.attempt",
-  subscriptionId: "abs.subscription.id",
-  batchSize: "abs.batch.size",
-  clusterMessageOrigin: "abs.cluster.origin",
-  jobId: "abs.job.id",
-  jobKind: "abs.job.kind",
-  jobAttempt: "abs.job.attempt",
-  jobMaxAttempts: "abs.job.max_attempts",
-  workerId: "abs.worker.id",
-  runtimeKey: "abs.runtime.key",
-  runtimePid: "abs.runtime.pid",
-  runtimePort: "abs.runtime.port",
-  runtimeExitReason: "abs.runtime.exit_reason",
-  runtimeReadinessMs: "abs.runtime.readiness_ms",
-  routeShard: "abs.route.shard",
-  routeDecision: "abs.route.decision",
-  secretName: "abs.secret.name",
-  secretFingerprint: "abs.secret.fingerprint",
-  auditKind: "abs.audit.kind"
-};
-
 // src/engine/equiJoin.ts
 var shallowEqual = (a, b) => {
   if (a === b) {
@@ -3507,8 +3771,11 @@ export {
   jsonSerializer,
   createWriteBehindCache,
   createReactiveHub,
-  createPresenceHub
+  createPresenceHub,
+  createConnectionBroker,
+  LeaseTimeoutError,
+  ConnectionBrokerDrainedError
 };
 
-//# debugId=A1FB7830183D82D164756E2164756E21
+//# debugId=AF6701BD8B8BEA7364756E2164756E21
 //# sourceMappingURL=index.js.map