@absolutejs/sync 1.20.0 → 1.20.1

package/dist/engine/devtools.d.ts

@@ -82,6 +82,14 @@ export type EngineMetrics = {
         total: number;
         /** Per-collection breakdown — the values sum to `total`. */
         byCollection: Record<string, number>;
+        /**
+         * Per-tenant tally — populated only when
+         * `SyncEngineOptions.subscriptionLimit` is set; otherwise `{}`. The
+         * key is whatever `subscriptionLimit.key(ctx, args)` returns; the
+         * value is the count of active subscriptions for that key. Added
+         * in 1.20.1.
+         */
+        byTenant: Record<string, number>;
     };
     reactiveCache: {
         entries: number;

package/dist/engine/index.d.ts

@@ -47,7 +47,7 @@ export type { MutationActions, MutationDefinition, MutationHandler, TableWriter,
 export type { BridgeFetchConfig, BridgeFetchEndpoint, BridgeFetchResponse, HandlerMetricsHook, HandlerMetricsRecord, SandboxConfig } from './sandbox';
 export { exponentialBackoff, isSerializationFailure, RetriesExhaustedError } from './retry';
 export type { ExponentialBackoffOptions, RetryPolicy } from './retry';
-export { CdcConsumerSlowError, createSyncEngine, MissedChangesError, MutationQueueOverflowError, SchemaError, UnauthorizedError } from './syncEngine';
+export { CdcConsumerSlowError, createSyncEngine, MissedChangesError, MutationQueueOverflowError, SchemaError, SubscriptionLimitError, UnauthorizedError } from './syncEngine';
 export type { ChangeLogSnapshot, CrdtFields, LoggedChange, StreamChangesOptions, SubscribeArgs, Subscription, SyncEngine, SyncEngineOptions } from './syncEngine';
 export { syncCdc } from './cdc';
 export type { SyncCdcOptions } from './cdc';

package/dist/engine/index.js

@@ -1419,6 +1419,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 shallowEqual4 = (a, b) => {
   if (a === b) {
@@ -1569,6 +1582,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;
@@ -2406,84 +2444,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;
@@ -2948,6 +3005,7 @@ var createSyncEngine = (options = {}) => {
         },
         subscriptions: {
           byCollection,
+          byTenant: Object.fromEntries(subscriptionsByTenant),
           total: totalSubscriptions
         },
         uptimeMs: now - engineStartedAt,
@@ -3476,6 +3534,7 @@ export {
   chain,
   aggregateOp,
   UnauthorizedError,
+  SubscriptionLimitError,
   SchemaError,
   SEARCH_SCORE_FIELD,
   RetriesExhaustedError,
@@ -3486,5 +3545,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=E104F5FFDBD631C764756E2164756E21
+//# debugId=251EC576E67A0CAF64756E2164756E21
 //# sourceMappingURL=index.js.map