@getstrata/core 2.1.0 → 2.2.0

package/dist/entries/http/throttleMiddleware.js

@@ -29,7 +29,7 @@ var init_asyncContextStore = () => {};
 // ../../src/core/http/throttleMiddleware.ts
 import { createHash } from "crypto";
 import { currentAuthUser } from "@getstrata/core/auth/authContext";
-import { currentTenant, rateLimitMultiplierForPlan } from "@getstrata/core/tenant/tenantContext";
+import { currentTenant } from "@getstrata/core/tenant/tenantContext";
 var {RedisClient } = globalThis.Bun;
 
 // ../../src/core/runtime/appEnv.ts
@@ -397,28 +397,32 @@ if ttl < 0 then
 end
 return count
 `;
-function redisThrottleKey(request, prefix, identity) {
+function redisThrottleKey(request, prefix, identity, tenantId = currentTenant()?.id ?? null) {
   const bucket = JSON.stringify([
-    currentTenant()?.id ?? null,
+    tenantId,
     request.method,
     currentRequestMeta2().routeTemplate ?? "__unmatched__",
     identity
   ]);
   return namespacedRedisKey(`${prefix}:${createHash("sha256").update(bucket).digest("hex")}`);
 }
-async function consumeRedisThrottle(client, key, decaySeconds, timeoutMs = 1000) {
-  if (!Number.isFinite(decaySeconds) || decaySeconds < 0 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
+async function consumeRedisThrottle(client, key, decaySeconds, timeoutMs = 1000, signal) {
+  const expiryMs = Math.max(1, Math.ceil(decaySeconds * 1000));
+  if (!Number.isFinite(decaySeconds) || decaySeconds < 0 || !Number.isSafeInteger(expiryMs) || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
     throw new Error("Invalid throttle expiry or command timeout.");
   }
+  if (signal?.aborted)
+    throw new Error("Throttle consumer is disposed.");
+  let onAbort;
   let timer;
   try {
+    const cancelled = new Promise((_resolve, reject) => {
+      onAbort = () => reject(new Error("Throttle consumer is disposed."));
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
     const result = await Promise.race([
-      client.send("EVAL", [
-        CONSUME_THROTTLE,
-        "1",
-        key,
-        String(Math.max(1, Math.ceil(decaySeconds * 1000)))
-      ]),
+      cancelled,
+      client.send("EVAL", [CONSUME_THROTTLE, "1", key, String(expiryMs)]),
       new Promise((_resolve, reject) => {
         timer = setTimeout(() => reject(new Error("Throttle store deadline exceeded.")), timeoutMs);
       })
@@ -429,11 +433,16 @@ async function consumeRedisThrottle(client, key, decaySeconds, timeoutMs = 1000)
     return count;
   } finally {
     clearTimeout(timer);
+    if (onAbort)
+      signal?.removeEventListener("abort", onAbort);
   }
 }
 function createRedisThrottleConsumer(options) {
   let ownedClient;
-  return async (key, decaySeconds) => {
+  const controller = new AbortController;
+  const consume = async (key, decaySeconds) => {
+    if (controller.signal.aborted)
+      throw new Error("Throttle consumer is disposed.");
     if (!options.redisClient && !ownedClient) {
       ownedClient = new RedisClient(options.redisUrl, { autoReconnect: false, maxRetries: 0 });
     }
@@ -441,7 +450,10 @@ function createRedisThrottleConsumer(options) {
     if (!client)
       throw new Error("Throttle client is required.");
     try {
-      return await consumeRedisThrottle(client, key, decaySeconds, options.commandTimeoutMs);
+      const attempts = await consumeRedisThrottle(client, key, decaySeconds, options.commandTimeoutMs, controller.signal);
+      if (controller.signal.aborted)
+        throw new Error("Throttle consumer is disposed.");
+      return attempts;
     } catch (error) {
       if (client === ownedClient) {
         ownedClient.close();
@@ -450,6 +462,17 @@ function createRedisThrottleConsumer(options) {
       throw error;
     }
   };
+  return Object.assign(consume, {
+    isDisposed: () => controller.signal.aborted,
+    dispose() {
+      if (controller.signal.aborted)
+        return;
+      controller.abort();
+      const client = ownedClient;
+      ownedClient = undefined;
+      client?.close();
+    }
+  });
 }
 function throttleUnavailableResponse() {
   return Response.json({ error: "Rate limiting is temporarily unavailable." }, {
@@ -457,23 +480,48 @@ function throttleUnavailableResponse() {
     headers: { "retry-after": "1" }
   });
 }
+function resolveThrottleQuota(request, options, identity = resolveThrottleIdentity(request)) {
+  const limit = options.quotaPolicy ? options.quotaPolicy({
+    request,
+    tenant: currentTenant(),
+    identity,
+    routeTemplate: currentRequestMeta2().routeTemplate ?? "__unmatched__",
+    maxAttempts: options.maxAttempts
+  }) : options.maxAttempts;
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    throw new Error("Invalid application quota.");
+  }
+  return limit;
+}
 function createThrottleMiddleware(options) {
+  if (!Number.isSafeInteger(options.maxAttempts) || options.maxAttempts < 0) {
+    throw new Error("Throttle maxAttempts must be a non-negative safe integer.");
+  }
   const consume = createRedisThrottleConsumer(options);
   const prefix = options.keyPrefix ?? "throttle";
-  return async (request, next) => {
-    const key = redisThrottleKey(request, prefix, resolveThrottleIdentity(request));
+  const middleware = async (request, next) => {
+    const identity = resolveThrottleIdentity(request);
+    let maxAttempts;
+    try {
+      maxAttempts = resolveThrottleQuota(request, options, identity);
+    } catch {
+      return throttleUnavailableResponse();
+    }
+    const key = redisThrottleKey(request, prefix, identity);
     let attempts;
     try {
       attempts = await consume(key, options.decaySeconds);
     } catch {
       return throttleUnavailableResponse();
     }
-    const maxAttempts = options.maxAttempts * rateLimitMultiplierForPlan(currentTenant()?.plan ?? "free");
+    if (consume.isDisposed())
+      return throttleUnavailableResponse();
     if (attempts > maxAttempts) {
       return await tooManyRequestsResponse(request, "Too many requests.", options.decaySeconds);
     }
     return await next();
   };
+  return Object.assign(middleware, { dispose: () => consume.dispose() });
 }
 export {
   consumeRedisThrottle,
@@ -481,5 +529,6 @@ export {
   createThrottleMiddleware,
   redisThrottleKey,
   resolveThrottleIdentity,
+  resolveThrottleQuota,
   throttleUnavailableResponse
 };

package/dist/entries/jobs/exportAuditLogsJob.js

@@ -306,9 +306,12 @@ async function runWithDeferredModelEvents(callback) {
   const existing = deferredModelEvents.getStore();
   if (existing) {
     existing.frames.push([]);
+    existing.rollbackFrames.push([]);
     try {
       const result = await callback();
       const nested = existing.frames.pop() ?? [];
+      const rollback = existing.rollbackFrames.pop() ?? [];
+      existing.rollbackFrames.at(-1)?.push(...rollback);
       const parent = existing.frames[existing.frames.length - 1];
       if (parent) {
         parent.push(...nested);
@@ -316,11 +319,20 @@ async function runWithDeferredModelEvents(callback) {
       return result;
     } catch (error) {
       existing.frames.pop();
+      for (const rollback of (existing.rollbackFrames.pop() ?? []).reverse())
+        rollback();
       throw error;
     }
   }
-  const state = { frames: [[]] };
-  const result = await deferredModelEvents.run(state, callback);
+  const state = { frames: [[]], rollbackFrames: [[]] };
+  let result;
+  try {
+    result = await deferredModelEvents.run(state, callback);
+  } catch (error) {
+    for (const rollback of (state.rollbackFrames[0] ?? []).reverse())
+      rollback();
+    throw error;
+  }
   await dispatchQueuedModelEvents(state.frames[0] ?? []);
   return result;
 }
@@ -1450,12 +1462,37 @@ class SyncQueue {
 }
 
 class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
   async dispatch(job, payload) {
-    setTimeout(() => {
-      job.handle(payload).catch((error) => {
-        console.error("[AsyncQueue] Job failed:", error);
-      });
-    }, 0);
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
   }
 }
 function createQueue(driver) {

package/dist/entries/jobs/invalidateCacheTagsJob.js

@@ -57,12 +57,37 @@ class SyncQueue {
 }
 
 class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
   async dispatch(job, payload) {
-    setTimeout(() => {
-      job.handle(payload).catch((error) => {
-        console.error("[AsyncQueue] Job failed:", error);
-      });
-    }, 0);
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
   }
 }
 function createQueue(driver) {

package/dist/entries/queue/createAppQueue.js

@@ -451,6 +451,9 @@ class RedisQueue {
   constructor(redisUrl) {
     this.client = new RedisClient(redisUrl);
   }
+  close() {
+    this.client.close();
+  }
   async dispatch(job, payload) {
     const name = jobRegistry.resolveName(job);
     if (!name) {
@@ -579,15 +582,75 @@ async function countPendingQueueJobs(redisUrl) {
   }
 }
 
+// ../../src/core/queue/index.ts
+class Job {
+  static jobName;
+  maxAttempts;
+  backoffMs;
+  priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
+}
+
+class SyncQueue {
+  async dispatch(job, payload) {
+    await job.handle(payload);
+  }
+}
+
+class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
+  async dispatch(job, payload) {
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
+  }
+}
+function createQueue(driver) {
+  return driver === "async" ? new AsyncQueue : new SyncQueue;
+}
+
 // ../../src/core/queue/resilientQueue.ts
-class ResilientQueue {
+class ResilientQueue extends AsyncQueue {
   failedJobs;
   asyncDispatch;
   constructor(failedJobs, asyncDispatch = false) {
+    super();
     this.failedJobs = failedJobs;
     this.asyncDispatch = asyncDispatch;
   }
   async dispatch(job, payload) {
+    this.assertOpen();
     const name = jobRegistry.resolveName(job);
     if (!name) {
       throw new Error("Job is not registered with the queue worker registry.");
@@ -598,11 +661,9 @@ class ResilientQueue {
       attempts: 0
     };
     if (this.asyncDispatch) {
-      setTimeout(() => {
-        runQueueJob(envelope, this.failedJobs).catch((error) => {
-          console.error("[ResilientQueue] Job failed:", error);
-        });
-      }, 0);
+      this.enqueue(() => runQueueJob(envelope, this.failedJobs), (error) => {
+        console.error("[ResilientQueue] Job failed:", error);
+      });
       return;
     }
     await runQueueJob(envelope, this.failedJobs);

package/dist/entries/queue/publicQueue.js

@@ -451,6 +451,9 @@ class RedisQueue {
   constructor(redisUrl) {
     this.client = new RedisClient(redisUrl);
   }
+  close() {
+    this.client.close();
+  }
   async dispatch(job, payload) {
     const name = jobRegistry.resolveName(job);
     if (!name) {
@@ -579,15 +582,75 @@ async function countPendingQueueJobs(redisUrl) {
   }
 }
 
+// ../../src/core/queue/index.ts
+class Job {
+  static jobName;
+  maxAttempts;
+  backoffMs;
+  priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
+}
+
+class SyncQueue {
+  async dispatch(job, payload) {
+    await job.handle(payload);
+  }
+}
+
+class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
+  async dispatch(job, payload) {
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
+  }
+}
+function createQueue(driver) {
+  return driver === "async" ? new AsyncQueue : new SyncQueue;
+}
+
 // ../../src/core/queue/resilientQueue.ts
-class ResilientQueue {
+class ResilientQueue extends AsyncQueue {
   failedJobs;
   asyncDispatch;
   constructor(failedJobs, asyncDispatch = false) {
+    super();
     this.failedJobs = failedJobs;
     this.asyncDispatch = asyncDispatch;
   }
   async dispatch(job, payload) {
+    this.assertOpen();
     const name = jobRegistry.resolveName(job);
     if (!name) {
       throw new Error("Job is not registered with the queue worker registry.");
@@ -598,11 +661,9 @@ class ResilientQueue {
       attempts: 0
     };
     if (this.asyncDispatch) {
-      setTimeout(() => {
-        runQueueJob(envelope, this.failedJobs).catch((error) => {
-          console.error("[ResilientQueue] Job failed:", error);
-        });
-      }, 0);
+      this.enqueue(() => runQueueJob(envelope, this.failedJobs), (error) => {
+        console.error("[ResilientQueue] Job failed:", error);
+      });
       return;
     }
     await runQueueJob(envelope, this.failedJobs);

package/dist/entries/queue/queueMetrics.js

@@ -454,6 +454,9 @@ class RedisQueue {
   constructor(redisUrl) {
     this.client = new RedisClient(redisUrl);
   }
+  close() {
+    this.client.close();
+  }
   async dispatch(job, payload) {
     const name = jobRegistry.resolveName(job);
     if (!name) {
@@ -582,15 +585,75 @@ async function countPendingQueueJobs(redisUrl) {
   }
 }
 
+// ../../src/core/queue/index.ts
+class Job {
+  static jobName;
+  maxAttempts;
+  backoffMs;
+  priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
+}
+
+class SyncQueue {
+  async dispatch(job, payload) {
+    await job.handle(payload);
+  }
+}
+
+class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
+  async dispatch(job, payload) {
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
+  }
+}
+function createQueue(driver) {
+  return driver === "async" ? new AsyncQueue : new SyncQueue;
+}
+
 // ../../src/core/queue/resilientQueue.ts
-class ResilientQueue {
+class ResilientQueue extends AsyncQueue {
   failedJobs;
   asyncDispatch;
   constructor(failedJobs, asyncDispatch = false) {
+    super();
     this.failedJobs = failedJobs;
     this.asyncDispatch = asyncDispatch;
   }
   async dispatch(job, payload) {
+    this.assertOpen();
     const name = jobRegistry.resolveName(job);
     if (!name) {
       throw new Error("Job is not registered with the queue worker registry.");
@@ -601,11 +664,9 @@ class ResilientQueue {
       attempts: 0
     };
     if (this.asyncDispatch) {
-      setTimeout(() => {
-        runQueueJob(envelope, this.failedJobs).catch((error) => {
-          console.error("[ResilientQueue] Job failed:", error);
-        });
-      }, 0);
+      this.enqueue(() => runQueueJob(envelope, this.failedJobs), (error) => {
+        console.error("[ResilientQueue] Job failed:", error);
+      });
       return;
     }
     await runQueueJob(envelope, this.failedJobs);

package/dist/entries/queue/redisQueue.js

@@ -387,6 +387,9 @@ class RedisQueue {
   constructor(redisUrl) {
     this.client = new RedisClient(redisUrl);
   }
+  close() {
+    this.client.close();
+  }
   async dispatch(job, payload) {
     const name = jobRegistry.resolveName(job);
     if (!name) {

package/dist/entries/queue.js

@@ -57,12 +57,37 @@ class SyncQueue {
 }
 
 class AsyncQueue {
+  active = new Set;
+  closing;
+  closed = false;
+  assertOpen() {
+    if (this.closed)
+      throw new Error("Async queue is closed.");
+  }
+  enqueue(task, onError) {
+    this.assertOpen();
+    const running = new Promise((resolve) => {
+      setTimeout(() => {
+        Promise.resolve().then(task).catch(onError).finally(resolve);
+      }, 0);
+    });
+    this.active.add(running);
+    running.then(() => {
+      this.active.delete(running);
+    });
+  }
   async dispatch(job, payload) {
-    setTimeout(() => {
-      job.handle(payload).catch((error) => {
-        console.error("[AsyncQueue] Job failed:", error);
-      });
-    }, 0);
+    this.enqueue(() => job.handle(payload), (error) => {
+      console.error("[AsyncQueue] Job failed:", error);
+    });
+  }
+  close() {
+    this.closing ??= (async () => {
+      while (this.active.size)
+        await Promise.all([...this.active]);
+      this.closed = true;
+    })();
+    return this.closing;
   }
 }
 function createQueue(driver) {