@getstrata/core 2.1.0 → 2.2.1

package/dist/entries/database/repositoryQuery.js

@@ -815,6 +815,7 @@ class RepositoryQuery {
   queryOptions;
   eagerLoads = [];
   whereNodes = [];
+  protectedWhere = [];
   constructor(repository, whereClause = {}, queryOptions = {}) {
     this.repository = repository;
     this.whereClause = whereClause;
@@ -824,10 +825,23 @@ class RepositoryQuery {
     if (typeof input === "function") {
       const builder = new WhereBuilder;
       input(builder);
-      this.whereNodes.push(...builder.nodes);
+      if (builder.nodes.length > 0)
+        this.whereNodes.push({ kind: "and", group: builder.nodes });
       return this;
     }
-    this.whereClause = { ...this.whereClause, ...input };
+    this.whereNodes.push({ kind: "and", where: { ...input } });
+    return this;
+  }
+  protectWhere() {
+    const nodes = [];
+    if (Object.keys(this.whereClause).length > 0) {
+      nodes.push({ kind: "and", where: this.whereClause });
+    }
+    nodes.push(...this.whereNodes);
+    if (nodes.length > 0)
+      this.protectedWhere.push({ kind: "and", group: nodes });
+    this.whereClause = {};
+    this.whereNodes.length = 0;
     return this;
   }
   orWhere(input) {
@@ -941,9 +955,10 @@ class RepositoryQuery {
     });
     return this;
   }
-  withMorphTo(as, relation, repositoriesByType, options = {}) {
+  withMorphTo(as, relation, repositoriesByType, options = {}, optionsByType) {
     this.eagerLoads.push({
       kind: "morphTo",
+      morphOptions: optionsByType,
       as,
       relation,
       repository: this.repository,
@@ -1014,6 +1029,19 @@ class RepositoryQuery {
     }
     return row[column];
   }
+  async project(columns, limit) {
+    if (columns.length === 0)
+      throw new RangeError("A projection requires at least one column.");
+    const table = this.repository.getTable();
+    for (const column of columns)
+      if (!table.columns.includes(column))
+        throw new TypeError(`Unknown projection column: ${column}`);
+    return await this.repository.findAll({
+      ...this.buildOptions(),
+      ...limit === undefined ? {} : { limit },
+      select: uniqueColumnSelect(table.name, columns)
+    });
+  }
   async attachToRows(rows) {
     return await this.attach(rows);
   }
@@ -1024,11 +1052,24 @@ class RepositoryQuery {
       perPage: options.perPage
     });
   }
+  async chunk(count, callback) {
+    await this.repository.chunk(count, async (rows) => callback(await this.attach(rows)), this.buildOptions());
+  }
+  async cursorPaginate(options) {
+    const page = await this.repository.cursorPaginate({ ...this.buildOptions(), ...options });
+    return { ...page, data: await this.attach(page.data) };
+  }
+  getOptions() {
+    return this.buildOptions();
+  }
   buildOptions() {
+    if (this.protectedWhere.length === 0) {
+      return { ...this.queryOptions, where: this.whereClause, whereNodes: this.whereNodes };
+    }
     return {
       ...this.queryOptions,
-      where: this.whereClause,
-      whereNodes: this.whereNodes
+      where: {},
+      whereNodes: [...this.protectedWhere, { kind: "and", group: [...this.whereNodes] }]
     };
   }
   addJoin(type, left, right) {
@@ -1105,10 +1146,27 @@ class RepositoryQuery {
     }
     if (load.kind === "morphTo") {
       const relation = load.relation;
-      const grouped = await this.repository.loadMorphToForChildren(rows, relation, load.morphRepositories ?? new Map, load.options);
-      for (const row of result) {
-        row[load.as] = getByRelationKey(grouped, row[relation.morphIdKey]);
-      }
+      const repositories = load.morphRepositories ?? new Map;
+      const partitions = new Map;
+      rows.forEach((row, index) => {
+        const type = String(row[relation.morphTypeKey]);
+        const target = result[index];
+        if (!target || !repositories.has(type))
+          return;
+        const partition = partitions.get(type) ?? { rows: [], targets: [] };
+        partition.rows.push(row);
+        partition.targets.push(target);
+        partitions.set(type, partition);
+      });
+      await Promise.all([...partitions.entries()].map(async ([type, partition]) => {
+        const repository = repositories.get(type);
+        if (!repository)
+          return;
+        const grouped = await this.repository.loadMorphToForChildren(partition.rows, relation, new Map([[type, repository]]), load.morphOptions?.get(type) ?? load.options);
+        for (const row of partition.targets) {
+          row[load.as] = getByRelationKey(grouped, row[relation.morphIdKey]);
+        }
+      }));
       return;
     }
     const relation = load.relation;

package/dist/entries/http/bodySizeLimitMiddleware.js

@@ -1,29 +1,95 @@
 // @bun
 // ../../src/core/http/bodySizeLimitMiddleware.ts
 import { PayloadTooLargeError } from "@getstrata/core/errors/http";
+var guards = new WeakMap;
+function guardBody(request, maxBytes) {
+  const existing = guards.get(request);
+  if (existing && existing.maxBytes <= maxBytes)
+    return existing;
+  const state = { maxBytes, exceeded: false };
+  const body = request.body;
+  if (!body)
+    return state;
+  let consumed = 0;
+  const stream = body.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+      consumed += bytes.byteLength;
+      if (consumed > maxBytes) {
+        state.exceeded = true;
+        throw new PayloadTooLargeError(`Request body exceeds the ${maxBytes} byte limit.`);
+      }
+      controller.enqueue(bytes);
+    }
+  }));
+  const bounded = new Request(request, { body: stream });
+  const decorateClone = (clone) => {
+    for (const field of ["params", "cookies"]) {
+      if (field in request)
+        Object.defineProperty(clone, field, { value: Reflect.get(request, field) });
+    }
+    const nativeClone = () => Reflect.apply(Request.prototype.clone, clone, []);
+    Object.defineProperty(clone, "clone", {
+      value: () => decorateClone(nativeClone())
+    });
+    guards.set(clone, state);
+    return clone;
+  };
+  const descriptors = {
+    body: { configurable: true, get: () => bounded.body },
+    bodyUsed: { configurable: true, get: () => bounded.bodyUsed },
+    clone: {
+      configurable: true,
+      value: () => decorateClone(Reflect.apply(Request.prototype.clone, bounded, []))
+    }
+  };
+  for (const method of [
+    "text",
+    "json",
+    "formData",
+    "arrayBuffer",
+    "blob",
+    "bytes",
+    "textStream"
+  ]) {
+    descriptors[method] = { configurable: true, value: bounded[method].bind(bounded) };
+  }
+  Object.defineProperties(request, descriptors);
+  guards.set(request, state);
+  return state;
+}
 var DEFAULT_MAX_BODY_BYTES = 1048576;
 function resolveMaxBodyBytes() {
   const raw = process.env.MAX_REQUEST_BODY_BYTES?.trim();
   if (!raw) {
     return DEFAULT_MAX_BODY_BYTES;
   }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
     return DEFAULT_MAX_BODY_BYTES;
   }
   return parsed;
 }
 function createBodySizeLimitMiddleware(maxBytes = resolveMaxBodyBytes()) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)
+    throw new RangeError("Body limit must be a positive safe integer.");
   return async (request, next) => {
-    const contentLength = request.headers.get("content-length");
-    if (contentLength) {
-      const bytes = Number.parseInt(contentLength, 10);
-      if (Number.isInteger(bytes) && bytes > maxBytes) {
-        const error = new PayloadTooLargeError(`Request body exceeds the ${maxBytes} byte limit.`);
-        return Response.json({ error: error.message }, { status: error.status });
-      }
+    const tooLarge = () => {
+      const error = new PayloadTooLargeError(`Request body exceeds the ${maxBytes} byte limit.`);
+      return Response.json({ error: error.message }, { status: error.status });
+    };
+    const length = Number(request.headers.get("content-length"));
+    if (Number.isFinite(length) && length > maxBytes)
+      return tooLarge();
+    const state = guardBody(request, maxBytes);
+    try {
+      const response = await next();
+      return state.exceeded ? tooLarge() : response;
+    } catch (error) {
+      if (state.exceeded || error instanceof PayloadTooLargeError)
+        return tooLarge();
+      throw error;
     }
-    return await next();
   };
 }
 export {

package/dist/entries/http/memoryThrottleMiddleware.js

@@ -1,4 +1,98 @@
 // @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+var init_asyncContextStore = () => {};
+
+// ../../src/core/runtime/boundedThrottleStore.ts
+class BoundedThrottleStore {
+  decayMs;
+  now;
+  buckets = new Map;
+  maxBuckets;
+  pruneBatchSize;
+  disposed = false;
+  pruned = 0;
+  constructor(decayMs, options = {}, now = () => performance.now()) {
+    this.decayMs = decayMs;
+    this.now = now;
+    this.maxBuckets = options.maxBuckets ?? 1e4;
+    this.pruneBatchSize = options.pruneBatchSize ?? 32;
+    if (!Number.isFinite(decayMs) || decayMs < 0 || decayMs > 2147483647) {
+      throw new Error("Invalid memory throttle window.");
+    }
+    if (!Number.isSafeInteger(this.maxBuckets) || this.maxBuckets < 1 || this.maxBuckets > 1e6 || !Number.isSafeInteger(this.pruneBatchSize) || this.pruneBatchSize < 1 || this.pruneBatchSize > 1024) {
+      throw new Error("Invalid memory throttle storage bounds.");
+    }
+  }
+  consume(key) {
+    this.pruned = 0;
+    if (this.disposed)
+      return null;
+    const now = this.now();
+    const entries = this.buckets.entries();
+    for (let i = 0;i < this.pruneBatchSize; i++) {
+      const oldest = entries.next().value;
+      if (!oldest || oldest[1].resetAt > now)
+        break;
+      this.buckets.delete(oldest[0]);
+      this.pruned++;
+    }
+    const existing = this.buckets.get(key);
+    if (existing && existing.resetAt > now) {
+      existing.count = Math.min(Number.MAX_SAFE_INTEGER, existing.count + 1);
+      return existing.count;
+    }
+    this.buckets.delete(key);
+    if (this.buckets.size >= this.maxBuckets)
+      return null;
+    this.buckets.set(key, { count: 1, resetAt: now + this.decayMs });
+    return 1;
+  }
+  clear() {
+    this.buckets.clear();
+  }
+  dispose() {
+    this.disposed = true;
+    this.clear();
+  }
+  stats() {
+    return {
+      retainedBuckets: this.buckets.size,
+      prunedOnLastConsume: this.pruned,
+      disposed: this.disposed
+    };
+  }
+}
+
+// ../../src/core/http/throttleMiddleware.ts
+import { createHash } from "crypto";
+import { currentAuthUser } from "@getstrata/core/auth/authContext";
+import { currentTenant } from "@getstrata/core/tenant/tenantContext";
+var {RedisClient } = globalThis.Bun;
+
 // ../../src/core/runtime/appEnv.ts
 var NON_PRODUCTION_APP_ENVS = new Set(["local", "development", "dev", "test", "testing", "ci"]);
 function normalizeEnvValue(value) {
@@ -117,6 +211,19 @@ function readClientIp(request, env = process.env) {
   return currentRequestMeta().ipAddress ?? undefined;
 }
 
+// ../../src/core/http/requestMetaContext.ts
+init_asyncContextStore();
+var requestMetaContext = createAsyncContextStore("@getstrata/requestMetaContext");
+function runWithRequestMeta(meta, callback) {
+  return requestMetaContext.run(meta, callback);
+}
+function currentRequestMeta2() {
+  return requestMetaContext.getStore() ?? {
+    ipAddress: null,
+    userAgent: null
+  };
+}
+
 // ../../src/core/runtime/frontendMode.ts
 var FRONTEND_MODES = ["api", "server-htmx", "spa-react", "hybrid"];
 var DEFAULT_SPA_PREFIX = "/app";
@@ -157,7 +264,7 @@ function readSpaPrefix() {
 }
 
 // ../../src/core/view/webErrorView.ts
-import { currentRequestMeta as currentRequestMeta2 } from "@getstrata/core/http/requestMetaContext";
+import { currentRequestMeta as currentRequestMeta3 } from "@getstrata/core/http/requestMetaContext";
 
 // ../../src/core/http/safeInternalPath.ts
 var NESTED_REDIRECT_KEYS = new Set(["redirect", "next", "return", "returnTo", "return_to"]);
@@ -276,7 +383,7 @@ async function renderWebErrorHtml(input) {
   try {
     return await render({
       ...input,
-      request: input.request ?? currentRequestMeta2().request
+      request: input.request ?? currentRequestMeta3().request
     });
   } catch {
     return renderKernelErrorChrome(input);
@@ -332,33 +439,181 @@ async function tooManyRequestsResponse(request, message, decaySeconds) {
   return new Response(html.body, { status: 429, headers });
 }
 
+// ../../src/core/http/throttleMiddleware.ts
+function resolveThrottleIdentity(request) {
+  const user = currentAuthUser();
+  if (user?.tokenId !== undefined) {
+    return `token:${user.tokenId}`;
+  }
+  if (user) {
+    return `user:${user.id}`;
+  }
+  return readClientIp(request) ?? "unknown";
+}
+var CONSUME_THROTTLE = `
+local count = redis.call('INCR', KEYS[1])
+local ttl = redis.call('PTTL', KEYS[1])
+if ttl < 0 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[1])
+end
+return count
+`;
+function redisThrottleKey(request, prefix, identity, tenantId = currentTenant()?.id ?? null) {
+  const bucket = JSON.stringify([
+    tenantId,
+    request.method,
+    currentRequestMeta2().routeTemplate ?? "__unmatched__",
+    identity
+  ]);
+  return namespacedRedisKey(`${prefix}:${createHash("sha256").update(bucket).digest("hex")}`);
+}
+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([
+      cancelled,
+      client.send("EVAL", [CONSUME_THROTTLE, "1", key, String(expiryMs)]),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("Throttle store deadline exceeded.")), timeoutMs);
+      })
+    ]);
+    const count = Number(result);
+    if (!Number.isSafeInteger(count) || count < 1)
+      throw new Error("Invalid throttle store response.");
+    return count;
+  } finally {
+    clearTimeout(timer);
+    if (onAbort)
+      signal?.removeEventListener("abort", onAbort);
+  }
+}
+function createRedisThrottleConsumer(options) {
+  let ownedClient;
+  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 });
+    }
+    const client = options.redisClient ?? ownedClient;
+    if (!client)
+      throw new Error("Throttle client is required.");
+    try {
+      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();
+        ownedClient = undefined;
+      }
+      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." }, {
+    status: 503,
+    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";
+  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();
+    }
+    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() });
+}
+
 // ../../src/core/http/memoryThrottleMiddleware.ts
-var throttleBucketRegistries = new Set;
+var resetGeneration = 0;
 function createMemoryThrottleMiddleware(options) {
-  const prefix = options.keyPrefix ?? namespacedRedisKey("memory-throttle:");
-  const buckets = new Map;
-  throttleBucketRegistries.add(buckets);
-  return async (request, next) => {
-    const path = new URL(request.url).pathname;
-    const identity = readClientIp(request) ?? request.headers.get("authorization")?.slice(0, 32) ?? "unknown";
-    const key = `${prefix}${identity}:${path}`;
-    const now = Date.now();
-    const existing = buckets.get(key);
-    if (!existing || existing.resetAt <= now) {
-      buckets.set(key, { count: 1, resetAt: now + options.decaySeconds * 1000 });
-      return await next();
+  const store = new BoundedThrottleStore(options.decaySeconds * 1000, options);
+  if (!Number.isSafeInteger(options.maxAttempts) || options.maxAttempts < 0)
+    throw new Error("Invalid memory throttle limit.");
+  let generation = resetGeneration;
+  const middleware = async (request, next) => {
+    if (generation !== resetGeneration) {
+      store.clear();
+      generation = resetGeneration;
     }
-    existing.count += 1;
-    if (existing.count > options.maxAttempts) {
-      return await tooManyRequestsResponse(request, "Too many requests.", options.decaySeconds);
+    let maxAttempts;
+    try {
+      maxAttempts = resolveThrottleQuota(request, options);
+    } catch {
+      return throttleUnavailableResponse();
     }
+    const attempts = store.consume(redisThrottleKey(request, options.keyPrefix ?? "memory-throttle", resolveThrottleIdentity(request)));
+    if (attempts === null)
+      return throttleUnavailableResponse();
+    if (attempts > maxAttempts)
+      return await tooManyRequestsResponse(request, "Too many requests.", options.decaySeconds);
     return await next();
   };
+  return Object.assign(middleware, { dispose: () => store.dispose(), stats: () => store.stats() });
 }
 function resetMemoryThrottleForTests() {
-  for (const buckets of throttleBucketRegistries) {
-    buckets.clear();
-  }
+  resetGeneration++;
 }
 export {
   createMemoryThrottleMiddleware,