@absolutejs/sync 1.20.0 → 1.20.1

package/dist/engine/syncEngine.d.ts

@@ -425,6 +425,18 @@ export declare class MutationQueueOverflowError extends Error {
     readonly queueLimit: number;
     constructor(queueLimit: number);
 }
+/**
+ * Thrown by `engine.subscribe` when the calling tenant's active-subscription
+ * count is already at the configured `subscriptionLimit.max`. The caller sees
+ * this immediately — BEFORE authorize, hydrate, or any subscription state
+ * allocation — so a rejected call leaks nothing. Added in 1.20.1.
+ */
+export declare class SubscriptionLimitError extends Error {
+    readonly tenantKey: string;
+    readonly limit: number;
+    readonly active: number;
+    constructor(tenantKey: string, limit: number, active: number);
+}
 /**
  * Serializable snapshot of an engine's change log + monotonic version, returned
  * by {@link SyncEngine.exportChangeLog} and consumed by
@@ -597,6 +609,30 @@ export type SyncEngineOptions = {
      * Added in 1.20.0.
      */
     mutationQueueLimit?: number;
+    /**
+     * Per-tenant active-subscription cap. Symmetric to
+     * {@link SyncEngineOptions.mutationConcurrency} on the read side: a
+     * single tenant opening thousands of subscriptions would otherwise
+     * exhaust the engine's per-subscription bookkeeping
+     * (`active`/`tableIndex` Maps, the reactive cache, per-row diff
+     * computation cost).
+     *
+     * `key` derives a tenant identifier from `(ctx, args)`; returning
+     * `undefined` skips the cap for that call (e.g. internal/system
+     * subscriptions). When the active count for a key reaches `max`, the
+     * next `subscribe` throws {@link SubscriptionLimitError} BEFORE any
+     * authorize, hydrate, or state allocation — so a denied call leaks
+     * nothing.
+     *
+     * Active counts are surfaced through `engine.metrics().subscriptions.byTenant`
+     * for tier monitoring. Added in 1.20.1.
+     */
+    subscriptionLimit?: {
+        max: number;
+        key: (ctx: unknown, args: {
+            collection: string;
+        }) => string | undefined;
+    };
 };
 /**
  * The Tier 3 sync engine: a registry of collections plus the view syncer. It is

package/dist/index.js

@@ -1161,6 +1161,19 @@ class MutationQueueOverflowError extends Error {
     this.queueLimit = queueLimit;
   }
 }
+
+class SubscriptionLimitError extends Error {
+  tenantKey;
+  limit;
+  active;
+  constructor(tenantKey, limit, active) {
+    super(`Tenant "${tenantKey}" is at the subscription cap ` + `(${active}/${limit}). Close an existing subscription before opening another.`);
+    this.name = "SubscriptionLimitError";
+    this.tenantKey = tenantKey;
+    this.limit = limit;
+    this.active = active;
+  }
+}
 var defaultKey = (row) => row.id;
 var shallowEqual3 = (a, b) => {
   if (a === b) {
@@ -1311,6 +1324,31 @@ var createSyncEngine = (options = {}) => {
     if (next !== undefined)
       next();
   };
+  const subscriptionsByTenant = new Map;
+  const acquireSubscriptionSlot = (ctx, args) => {
+    const cap = options.subscriptionLimit;
+    if (cap === undefined)
+      return;
+    const tenantKey = cap.key(ctx, args);
+    if (tenantKey === undefined)
+      return;
+    const active2 = subscriptionsByTenant.get(tenantKey) ?? 0;
+    if (active2 >= cap.max) {
+      throw new SubscriptionLimitError(tenantKey, cap.max, active2);
+    }
+    subscriptionsByTenant.set(tenantKey, active2 + 1);
+    return tenantKey;
+  };
+  const releaseSubscriptionSlot = (tenantKey) => {
+    if (tenantKey === undefined)
+      return;
+    const active2 = subscriptionsByTenant.get(tenantKey);
+    if (active2 === undefined || active2 <= 1) {
+      subscriptionsByTenant.delete(tenantKey);
+    } else {
+      subscriptionsByTenant.set(tenantKey, active2 - 1);
+    }
+  };
   const reactiveCacheMax = options.reactiveCache?.max ?? 256;
   const reactiveCacheTtlMs = options.reactiveCache?.ttlMs ?? 60000;
   const cachedReruns = new Map;
@@ -2148,84 +2186,103 @@ var createSyncEngine = (options = {}) => {
       if (registered === undefined) {
         throw new Error(`Unknown collection "${collection}"`);
       }
-      const typedOnDiff = onDiff;
-      const subscribeSet = subsFor(collection);
-      const wrapReturn = (sub) => {
-        checkAborted(signal);
-        linkAbortToUnsubscribe(signal, sub.unsubscribe);
-        return sub;
-      };
-      const registeredKind = registered.kind;
-      if (registeredKind === "join") {
-        const joined = await subscribeJoin(collection, registered, params, ctx, typedOnDiff, subscribeSet);
-        return wrapReturn(joined);
-      }
-      if (registeredKind === "graph") {
-        const graphed = await subscribeGraph(collection, registered, params, ctx, typedOnDiff, subscribeSet);
-        return wrapReturn(graphed);
-      }
-      if (registeredKind === "reactive") {
-        const reactived = await subscribeReactive(collection, registered, params, ctx, typedOnDiff, subscribeSet);
-        return wrapReturn(reactived);
-      }
-      if (registeredKind === "search") {
-        const searched = await subscribeSearch(collection, registered, params, ctx, typedOnDiff, subscribeSet);
-        return wrapReturn(searched);
-      }
-      const definition = registered;
-      if (definition.authorize !== undefined) {
-        const allowed = await definition.authorize(params, ctx);
-        if (!allowed) {
-          throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      const tenantSlot = acquireSubscriptionSlot(ctx, { collection });
+      let slotHandedOff = false;
+      try {
+        const typedOnDiff = onDiff;
+        const subscribeSet = subsFor(collection);
+        const wrapReturn = (sub) => {
+          checkAborted(signal);
+          const innerUnsubscribe = sub.unsubscribe;
+          let released = false;
+          const wrappedUnsubscribe = () => {
+            if (released)
+              return;
+            released = true;
+            releaseSubscriptionSlot(tenantSlot);
+            innerUnsubscribe();
+          };
+          const wrapped = { ...sub, unsubscribe: wrappedUnsubscribe };
+          linkAbortToUnsubscribe(signal, wrappedUnsubscribe);
+          slotHandedOff = true;
+          return wrapped;
+        };
+        const registeredKind = registered.kind;
+        if (registeredKind === "join") {
+          const joined = await subscribeJoin(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+          return wrapReturn(joined);
+        }
+        if (registeredKind === "graph") {
+          const graphed = await subscribeGraph(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+          return wrapReturn(graphed);
+        }
+        if (registeredKind === "reactive") {
+          const reactived = await subscribeReactive(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+          return wrapReturn(reactived);
+        }
+        if (registeredKind === "search") {
+          const searched = await subscribeSearch(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+          return wrapReturn(searched);
+        }
+        const definition = registered;
+        if (definition.authorize !== undefined) {
+          const allowed = await definition.authorize(params, ctx);
+          if (!allowed) {
+            throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+          }
+        }
+        const key = definition.key ?? defaultKey;
+        const match = definition.match;
+        const tables = definition.tables ?? [collection];
+        const scopedTable = tables.length === 1 ? tables[0] : undefined;
+        const readRule = scopedTable !== undefined ? readRuleFor(scopedTable) : undefined;
+        const rehydrate = async () => {
+          const raw = [...await definition.hydrate(params, ctx)];
+          const rows = scopedTable !== undefined ? raw.map((row) => migrateRow(scopedTable, row)) : raw;
+          return readRule ? rows.filter((row) => readRule(ctx, row)) : rows;
+        };
+        const incremental = match !== undefined && tables.length === 1;
+        const boundMatch = incremental ? (row) => match(row, params, ctx) && (readRule ? readRule(ctx, row) : true) : () => true;
+        const view = createMaterializedView({
+          key,
+          match: boundMatch
+        });
+        const resuming = since !== undefined && canResume(since, incremental);
+        view.hydrate([...await rehydrate()]);
+        const atVersion = version;
+        const subscription = {
+          kind: "view",
+          collection,
+          view,
+          incremental,
+          rehydrate,
+          key,
+          onDiff: typedOnDiff
+        };
+        subscribeSet.add(subscription);
+        const unsubscribe = () => {
+          subscribeSet.delete(subscription);
+        };
+        if (resuming) {
+          return wrapReturn({
+            initial: [],
+            catchup: buildCatchup(since, tables, key, boundMatch),
+            cursor: currentCursor(),
+            version: atVersion,
+            unsubscribe
+          });
         }
-      }
-      const key = definition.key ?? defaultKey;
-      const match = definition.match;
-      const tables = definition.tables ?? [collection];
-      const scopedTable = tables.length === 1 ? tables[0] : undefined;
-      const readRule = scopedTable !== undefined ? readRuleFor(scopedTable) : undefined;
-      const rehydrate = async () => {
-        const raw = [...await definition.hydrate(params, ctx)];
-        const rows = scopedTable !== undefined ? raw.map((row) => migrateRow(scopedTable, row)) : raw;
-        return readRule ? rows.filter((row) => readRule(ctx, row)) : rows;
-      };
-      const incremental = match !== undefined && tables.length === 1;
-      const boundMatch = incremental ? (row) => match(row, params, ctx) && (readRule ? readRule(ctx, row) : true) : () => true;
-      const view = createMaterializedView({
-        key,
-        match: boundMatch
-      });
-      const resuming = since !== undefined && canResume(since, incremental);
-      view.hydrate([...await rehydrate()]);
-      const atVersion = version;
-      const subscription = {
-        kind: "view",
-        collection,
-        view,
-        incremental,
-        rehydrate,
-        key,
-        onDiff: typedOnDiff
-      };
-      subscribeSet.add(subscription);
-      const unsubscribe = () => {
-        subscribeSet.delete(subscription);
-      };
-      if (resuming) {
         return wrapReturn({
-          initial: [],
-          catchup: buildCatchup(since, tables, key, boundMatch),
+          initial: view.rows(),
           cursor: currentCursor(),
           version: atVersion,
           unsubscribe
         });
+      } catch (error) {
+        if (!slotHandedOff)
+          releaseSubscriptionSlot(tenantSlot);
+        throw error;
       }
-      return wrapReturn({
-        initial: view.rows(),
-        cursor: currentCursor(),
-        version: atVersion,
-        unsubscribe
-      });
     },
     hydrate: async (collection, params, ctx, options2) => {
       const signal = options2?.signal;
@@ -2690,6 +2747,7 @@ var createSyncEngine = (options = {}) => {
         },
         subscriptions: {
           byCollection,
+          byTenant: Object.fromEntries(subscriptionsByTenant),
           total: totalSubscriptions
         },
         uptimeMs: now - engineStartedAt,
@@ -3072,5 +3130,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=9DD57DF563EB9CB564756E2164756E21
+//# debugId=27A5DE0DF43D569D64756E2164756E21
 //# sourceMappingURL=index.js.map