@getstrata/core 0.5.15 → 0.5.16

package/dist/bootstrap/http/securedRouteModelBinding.d.ts

@@ -0,0 +1,11 @@
+import type { Policy } from "../../core/auth/policy";
+import type { RouteRequest } from "../../core/http/route";
+interface RouteModelAuthorization {
+    resource: string;
+    action: keyof Policy;
+    requireIfMatch?: boolean;
+}
+declare function securedBindRouteModel<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (id: number, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+declare function securedBindRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
+export type { RouteModelAuthorization };
+export { securedBindRouteModel, securedBindRouteModelByKey };

package/dist/core/http/securedRouteModelBinding.d.ts

@@ -1,11 +1,2 @@
-import type { Policy } from "../auth/policy";
-import type { RouteRequest } from "./route";
-interface RouteModelAuthorization {
-    resource: string;
-    action: keyof Policy;
-    requireIfMatch?: boolean;
-}
-declare function securedBindRouteModel<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (id: number, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
-declare function securedBindRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: RouteModelAuthorization, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): (request: RouteRequest<TParams>) => Promise<Response>;
-export type { RouteModelAuthorization };
-export { securedBindRouteModel, securedBindRouteModelByKey };
+export type { RouteModelAuthorization } from "../../bootstrap/http/securedRouteModelBinding.ts";
+export { securedBindRouteModel, securedBindRouteModelByKey, } from "../../bootstrap/http/securedRouteModelBinding.ts";

package/dist/entries/cache/createCacheStore.js

@@ -0,0 +1,376 @@
+// @bun
+// ../../src/core/cache/redisCacheStore.ts
+var {RedisClient } = globalThis.Bun;
+var KEY_PREFIX = "workhub:cache:";
+var TAG_PREFIX = "workhub:cache:tag:";
+
+class RedisCacheStore {
+  ttlMs;
+  maxEntries;
+  client;
+  inflight = new Map;
+  keyTags = new Map;
+  constructor(redisUrl, ttlMs, maxEntries) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    this.client = new RedisClient(redisUrl);
+  }
+  async get(key) {
+    const raw = await this.client.get(this.storageKey(key));
+    if (raw === null) {
+      return;
+    }
+    return JSON.parse(raw);
+  }
+  async set(key, value, ttlMs) {
+    const resolvedTtlMs = ttlMs ?? this.ttlMs;
+    const payload = JSON.stringify(value);
+    if (resolvedTtlMs > 0) {
+      await this.client.psetex(this.storageKey(key), resolvedTtlMs, payload);
+    } else {
+      await this.client.set(this.storageKey(key), payload);
+    }
+    await this.enforceMaxEntries();
+  }
+  async getOrSet(key, loader, ttlMs) {
+    const cached = await this.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const inflightRequest = this.inflight.get(key);
+    if (inflightRequest) {
+      return inflightRequest;
+    }
+    const pendingRequest = loader().then(async (value) => {
+      await this.set(key, value, ttlMs);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, pendingRequest);
+    return pendingRequest;
+  }
+  async attachTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    let tagsForKey = this.keyTags.get(key);
+    if (!tagsForKey) {
+      tagsForKey = new Set;
+      this.keyTags.set(key, tagsForKey);
+    }
+    for (const tag of tags) {
+      tagsForKey.add(tag);
+      await this.client.sadd(this.tagKey(tag), key);
+    }
+  }
+  async flushTags(tags) {
+    const keysToRemove = new Set;
+    for (const tag of tags) {
+      const members = await this.client.smembers(this.tagKey(tag));
+      for (const member of members) {
+        keysToRemove.add(member);
+      }
+    }
+    let removed = 0;
+    for (const key of keysToRemove) {
+      if (await this.invalidate(key)) {
+        removed += 1;
+      }
+    }
+    for (const tag of tags) {
+      await this.client.del(this.tagKey(tag));
+    }
+    return removed;
+  }
+  async invalidate(key) {
+    const deleted = await this.client.del(this.storageKey(key));
+    await this.detachKeyFromTags(key);
+    return deleted > 0;
+  }
+  async invalidateByPrefix(prefix) {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    let removed = 0;
+    for (const storageKey of keys) {
+      const key = storageKey.slice(KEY_PREFIX.length);
+      if (key === prefix || key.startsWith(`${prefix}?`)) {
+        if (await this.invalidate(key)) {
+          removed += 1;
+        }
+      }
+    }
+    return removed;
+  }
+  async clear() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+    const tagKeys = await this.client.keys(`${TAG_PREFIX}*`);
+    if (tagKeys.length > 0) {
+      await this.client.del(...tagKeys);
+    }
+    this.inflight.clear();
+    this.keyTags.clear();
+  }
+  async size() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    return keys.length;
+  }
+  storageKey(key) {
+    return `${KEY_PREFIX}${key}`;
+  }
+  tagKey(tag) {
+    return `${TAG_PREFIX}${tag}`;
+  }
+  async detachKeyFromTags(key) {
+    const tags = this.keyTags.get(key);
+    if (!tags) {
+      return;
+    }
+    for (const tag of tags) {
+      await this.client.srem(this.tagKey(tag), key);
+    }
+    this.keyTags.delete(key);
+  }
+  async enforceMaxEntries() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    if (keys.length <= this.maxEntries) {
+      return;
+    }
+    const overflow = keys.length - this.maxEntries;
+    const keysToRemove = keys.slice(0, overflow);
+    if (keysToRemove.length > 0) {
+      await this.client.del(...keysToRemove);
+    }
+  }
+}
+var redisCacheStore_default = RedisCacheStore;
+
+// ../../src/core/cache/simpleCache.ts
+class SimpleCache {
+  ttlMs;
+  maxEntries;
+  cache = new Map;
+  inflight = new Map;
+  tagIndex = new Map;
+  keyTags = new Map;
+  constructor(ttlMs = 3600000, maxEntries = 100) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+      throw new RangeError("ttlMs must be a non-negative number.");
+    }
+    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+      throw new RangeError("maxEntries must be a positive integer.");
+    }
+  }
+  get(key) {
+    return this.getFreshEntry(key)?.value;
+  }
+  set(key, value, ttlMs) {
+    const now = Date.now();
+    const resolvedTtlMs = ttlMs ?? this.ttlMs;
+    this.cache.set(key, {
+      value,
+      expiresAt: now + resolvedTtlMs,
+      lastAccessedAt: now
+    });
+    this.evictOverflow();
+  }
+  async getOrSet(key, loader, ttlMs) {
+    this.pruneExpired();
+    const cachedEntry = this.getFreshEntry(key);
+    if (cachedEntry) {
+      return cachedEntry.value;
+    }
+    const inflightRequest = this.inflight.get(key);
+    if (inflightRequest) {
+      return inflightRequest;
+    }
+    const pendingRequest = loader().then((value) => {
+      this.set(key, value, ttlMs);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, pendingRequest);
+    return pendingRequest;
+  }
+  attachTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    let tagsForKey = this.keyTags.get(key);
+    if (!tagsForKey) {
+      tagsForKey = new Set;
+      this.keyTags.set(key, tagsForKey);
+    }
+    for (const tag of tags) {
+      tagsForKey.add(tag);
+      let keysForTag = this.tagIndex.get(tag);
+      if (!keysForTag) {
+        keysForTag = new Set;
+        this.tagIndex.set(tag, keysForTag);
+      }
+      keysForTag.add(key);
+    }
+  }
+  flushTags(tags) {
+    const keysToRemove = new Set;
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
+      }
+      for (const key of keys) {
+        keysToRemove.add(key);
+      }
+    }
+    let removed = 0;
+    for (const key of keysToRemove) {
+      if (this.invalidate(key)) {
+        removed += 1;
+      }
+    }
+    for (const tag of tags) {
+      this.tagIndex.delete(tag);
+    }
+    return removed;
+  }
+  invalidate(key) {
+    const removed = this.cache.delete(key);
+    if (removed) {
+      this.detachKeyFromTags(key);
+    }
+    return removed;
+  }
+  invalidateByPrefix(prefix) {
+    let removed = 0;
+    for (const key of [...this.cache.keys()]) {
+      if (key === prefix || key.startsWith(`${prefix}?`)) {
+        if (this.invalidate(key)) {
+          removed += 1;
+        }
+      }
+    }
+    return removed;
+  }
+  clear() {
+    this.cache.clear();
+    this.inflight.clear();
+    this.tagIndex.clear();
+    this.keyTags.clear();
+  }
+  size() {
+    this.pruneExpired();
+    return this.cache.size;
+  }
+  detachKeyFromTags(key) {
+    const tags = this.keyTags.get(key);
+    if (!tags) {
+      return;
+    }
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
+      }
+      keys.delete(key);
+      if (keys.size === 0) {
+        this.tagIndex.delete(tag);
+      }
+    }
+    this.keyTags.delete(key);
+  }
+  getFreshEntry(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      this.invalidate(key);
+      return;
+    }
+    entry.lastAccessedAt = Date.now();
+    return entry;
+  }
+  pruneExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this.invalidate(key);
+      }
+    }
+  }
+  evictOverflow() {
+    while (this.cache.size > this.maxEntries) {
+      let oldestKey;
+      let oldestAccessTime = Number.POSITIVE_INFINITY;
+      for (const [key, entry] of this.cache.entries()) {
+        if (entry.lastAccessedAt < oldestAccessTime) {
+          oldestAccessTime = entry.lastAccessedAt;
+          oldestKey = key;
+        }
+      }
+      if (!oldestKey) {
+        return;
+      }
+      this.invalidate(oldestKey);
+    }
+  }
+}
+var simpleCache_default = SimpleCache;
+
+// ../../src/core/cache/simpleCacheStore.ts
+class SimpleCacheStore {
+  cache;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  get(key) {
+    return Promise.resolve(this.cache.get(key));
+  }
+  set(key, value, ttlMs) {
+    this.cache.set(key, value, ttlMs);
+    return Promise.resolve();
+  }
+  getOrSet(key, loader, ttlMs) {
+    return this.cache.getOrSet(key, loader, ttlMs);
+  }
+  attachTags(key, tags) {
+    this.cache.attachTags(key, tags);
+    return Promise.resolve();
+  }
+  flushTags(tags) {
+    return Promise.resolve(this.cache.flushTags(tags));
+  }
+  invalidate(key) {
+    return Promise.resolve(this.cache.invalidate(key));
+  }
+  invalidateByPrefix(prefix) {
+    return Promise.resolve(this.cache.invalidateByPrefix(prefix));
+  }
+  clear() {
+    this.cache.clear();
+    return Promise.resolve();
+  }
+  size() {
+    return Promise.resolve(this.cache.size());
+  }
+}
+var simpleCacheStore_default = SimpleCacheStore;
+
+// ../../src/core/cache/createCacheStore.ts
+function createCacheStore(options) {
+  if (options.driver === "redis") {
+    if (!options.redisUrl) {
+      throw new Error('CACHE_DRIVER="redis" requires REDIS_URL to be set.');
+    }
+    return new redisCacheStore_default(options.redisUrl, options.ttlMs, options.maxEntries);
+  }
+  return new simpleCacheStore_default(new simpleCache_default(options.ttlMs, options.maxEntries));
+}
+export {
+  createCacheStore
+};

package/dist/framework/public-api.d.ts

@@ -19,6 +19,7 @@ export { appendOrganizationScope, appendProjectScope, assertOrganizationReadable
 export { default as MembershipService, resolveMembershipService, } from "../core/auth/membershipService.ts";
 export { Policy, PolicyGate } from "../core/auth/policy.ts";
 export { createScimAuthMiddleware } from "../core/auth/scimAuthMiddleware.ts";
+export { type CacheDriver, type CreateCacheStoreOptions, createCacheStore, } from "../core/cache/createCacheStore.ts";
 export { default as CacheRepository } from "../core/cache/repository.ts";
 export { CACHE_TAGS } from "../core/cache/tags.ts";
 export type { DatabaseConnection } from "../core/database/baseRepository.ts";

package/dist/index.js

@@ -3526,6 +3526,378 @@ function jsonScimError(detail, status) {
     headers: { "content-type": "application/scim+json" }
   });
 }
+// ../../src/core/cache/redisCacheStore.ts
+var {RedisClient } = globalThis.Bun;
+var KEY_PREFIX = "workhub:cache:";
+var TAG_PREFIX = "workhub:cache:tag:";
+
+class RedisCacheStore {
+  ttlMs;
+  maxEntries;
+  client;
+  inflight = new Map;
+  keyTags = new Map;
+  constructor(redisUrl, ttlMs, maxEntries) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    this.client = new RedisClient(redisUrl);
+  }
+  async get(key) {
+    const raw = await this.client.get(this.storageKey(key));
+    if (raw === null) {
+      return;
+    }
+    return JSON.parse(raw);
+  }
+  async set(key, value, ttlMs) {
+    const resolvedTtlMs = ttlMs ?? this.ttlMs;
+    const payload = JSON.stringify(value);
+    if (resolvedTtlMs > 0) {
+      await this.client.psetex(this.storageKey(key), resolvedTtlMs, payload);
+    } else {
+      await this.client.set(this.storageKey(key), payload);
+    }
+    await this.enforceMaxEntries();
+  }
+  async getOrSet(key, loader, ttlMs) {
+    const cached = await this.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const inflightRequest = this.inflight.get(key);
+    if (inflightRequest) {
+      return inflightRequest;
+    }
+    const pendingRequest = loader().then(async (value) => {
+      await this.set(key, value, ttlMs);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, pendingRequest);
+    return pendingRequest;
+  }
+  async attachTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    let tagsForKey = this.keyTags.get(key);
+    if (!tagsForKey) {
+      tagsForKey = new Set;
+      this.keyTags.set(key, tagsForKey);
+    }
+    for (const tag of tags) {
+      tagsForKey.add(tag);
+      await this.client.sadd(this.tagKey(tag), key);
+    }
+  }
+  async flushTags(tags) {
+    const keysToRemove = new Set;
+    for (const tag of tags) {
+      const members = await this.client.smembers(this.tagKey(tag));
+      for (const member of members) {
+        keysToRemove.add(member);
+      }
+    }
+    let removed = 0;
+    for (const key of keysToRemove) {
+      if (await this.invalidate(key)) {
+        removed += 1;
+      }
+    }
+    for (const tag of tags) {
+      await this.client.del(this.tagKey(tag));
+    }
+    return removed;
+  }
+  async invalidate(key) {
+    const deleted = await this.client.del(this.storageKey(key));
+    await this.detachKeyFromTags(key);
+    return deleted > 0;
+  }
+  async invalidateByPrefix(prefix) {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    let removed = 0;
+    for (const storageKey of keys) {
+      const key = storageKey.slice(KEY_PREFIX.length);
+      if (key === prefix || key.startsWith(`${prefix}?`)) {
+        if (await this.invalidate(key)) {
+          removed += 1;
+        }
+      }
+    }
+    return removed;
+  }
+  async clear() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    if (keys.length > 0) {
+      await this.client.del(...keys);
+    }
+    const tagKeys = await this.client.keys(`${TAG_PREFIX}*`);
+    if (tagKeys.length > 0) {
+      await this.client.del(...tagKeys);
+    }
+    this.inflight.clear();
+    this.keyTags.clear();
+  }
+  async size() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    return keys.length;
+  }
+  storageKey(key) {
+    return `${KEY_PREFIX}${key}`;
+  }
+  tagKey(tag) {
+    return `${TAG_PREFIX}${tag}`;
+  }
+  async detachKeyFromTags(key) {
+    const tags = this.keyTags.get(key);
+    if (!tags) {
+      return;
+    }
+    for (const tag of tags) {
+      await this.client.srem(this.tagKey(tag), key);
+    }
+    this.keyTags.delete(key);
+  }
+  async enforceMaxEntries() {
+    const keys = await this.client.keys(`${KEY_PREFIX}*`);
+    if (keys.length <= this.maxEntries) {
+      return;
+    }
+    const overflow = keys.length - this.maxEntries;
+    const keysToRemove = keys.slice(0, overflow);
+    if (keysToRemove.length > 0) {
+      await this.client.del(...keysToRemove);
+    }
+  }
+}
+var redisCacheStore_default = RedisCacheStore;
+
+// ../../src/core/cache/simpleCache.ts
+class SimpleCache {
+  ttlMs;
+  maxEntries;
+  cache = new Map;
+  inflight = new Map;
+  tagIndex = new Map;
+  keyTags = new Map;
+  constructor(ttlMs = 3600000, maxEntries = 100) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+      throw new RangeError("ttlMs must be a non-negative number.");
+    }
+    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+      throw new RangeError("maxEntries must be a positive integer.");
+    }
+  }
+  get(key) {
+    return this.getFreshEntry(key)?.value;
+  }
+  set(key, value, ttlMs) {
+    const now = Date.now();
+    const resolvedTtlMs = ttlMs ?? this.ttlMs;
+    this.cache.set(key, {
+      value,
+      expiresAt: now + resolvedTtlMs,
+      lastAccessedAt: now
+    });
+    this.evictOverflow();
+  }
+  async getOrSet(key, loader, ttlMs) {
+    this.pruneExpired();
+    const cachedEntry = this.getFreshEntry(key);
+    if (cachedEntry) {
+      return cachedEntry.value;
+    }
+    const inflightRequest = this.inflight.get(key);
+    if (inflightRequest) {
+      return inflightRequest;
+    }
+    const pendingRequest = loader().then((value) => {
+      this.set(key, value, ttlMs);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, pendingRequest);
+    return pendingRequest;
+  }
+  attachTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    let tagsForKey = this.keyTags.get(key);
+    if (!tagsForKey) {
+      tagsForKey = new Set;
+      this.keyTags.set(key, tagsForKey);
+    }
+    for (const tag of tags) {
+      tagsForKey.add(tag);
+      let keysForTag = this.tagIndex.get(tag);
+      if (!keysForTag) {
+        keysForTag = new Set;
+        this.tagIndex.set(tag, keysForTag);
+      }
+      keysForTag.add(key);
+    }
+  }
+  flushTags(tags) {
+    const keysToRemove = new Set;
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
+      }
+      for (const key of keys) {
+        keysToRemove.add(key);
+      }
+    }
+    let removed = 0;
+    for (const key of keysToRemove) {
+      if (this.invalidate(key)) {
+        removed += 1;
+      }
+    }
+    for (const tag of tags) {
+      this.tagIndex.delete(tag);
+    }
+    return removed;
+  }
+  invalidate(key) {
+    const removed = this.cache.delete(key);
+    if (removed) {
+      this.detachKeyFromTags(key);
+    }
+    return removed;
+  }
+  invalidateByPrefix(prefix) {
+    let removed = 0;
+    for (const key of [...this.cache.keys()]) {
+      if (key === prefix || key.startsWith(`${prefix}?`)) {
+        if (this.invalidate(key)) {
+          removed += 1;
+        }
+      }
+    }
+    return removed;
+  }
+  clear() {
+    this.cache.clear();
+    this.inflight.clear();
+    this.tagIndex.clear();
+    this.keyTags.clear();
+  }
+  size() {
+    this.pruneExpired();
+    return this.cache.size;
+  }
+  detachKeyFromTags(key) {
+    const tags = this.keyTags.get(key);
+    if (!tags) {
+      return;
+    }
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
+      }
+      keys.delete(key);
+      if (keys.size === 0) {
+        this.tagIndex.delete(tag);
+      }
+    }
+    this.keyTags.delete(key);
+  }
+  getFreshEntry(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      this.invalidate(key);
+      return;
+    }
+    entry.lastAccessedAt = Date.now();
+    return entry;
+  }
+  pruneExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this.invalidate(key);
+      }
+    }
+  }
+  evictOverflow() {
+    while (this.cache.size > this.maxEntries) {
+      let oldestKey;
+      let oldestAccessTime = Number.POSITIVE_INFINITY;
+      for (const [key, entry] of this.cache.entries()) {
+        if (entry.lastAccessedAt < oldestAccessTime) {
+          oldestAccessTime = entry.lastAccessedAt;
+          oldestKey = key;
+        }
+      }
+      if (!oldestKey) {
+        return;
+      }
+      this.invalidate(oldestKey);
+    }
+  }
+}
+var simpleCache_default = SimpleCache;
+
+// ../../src/core/cache/simpleCacheStore.ts
+class SimpleCacheStore {
+  cache;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  get(key) {
+    return Promise.resolve(this.cache.get(key));
+  }
+  set(key, value, ttlMs) {
+    this.cache.set(key, value, ttlMs);
+    return Promise.resolve();
+  }
+  getOrSet(key, loader, ttlMs) {
+    return this.cache.getOrSet(key, loader, ttlMs);
+  }
+  attachTags(key, tags) {
+    this.cache.attachTags(key, tags);
+    return Promise.resolve();
+  }
+  flushTags(tags) {
+    return Promise.resolve(this.cache.flushTags(tags));
+  }
+  invalidate(key) {
+    return Promise.resolve(this.cache.invalidate(key));
+  }
+  invalidateByPrefix(prefix) {
+    return Promise.resolve(this.cache.invalidateByPrefix(prefix));
+  }
+  clear() {
+    this.cache.clear();
+    return Promise.resolve();
+  }
+  size() {
+    return Promise.resolve(this.cache.size());
+  }
+}
+var simpleCacheStore_default = SimpleCacheStore;
+
+// ../../src/core/cache/createCacheStore.ts
+function createCacheStore(options) {
+  if (options.driver === "redis") {
+    if (!options.redisUrl) {
+      throw new Error('CACHE_DRIVER="redis" requires REDIS_URL to be set.');
+    }
+    return new redisCacheStore_default(options.redisUrl, options.ttlMs, options.maxEntries);
+  }
+  return new simpleCacheStore_default(new simpleCache_default(options.ttlMs, options.maxEntries));
+}
 // ../../src/core/cache/taggedCache.ts
 class TaggedCache {
   store;
@@ -4894,7 +5266,7 @@ function bindRouteModel(param, resolver, handler) {
     return await handler(request, model);
   };
 }
-// ../../src/core/http/securedRouteModelBinding.ts
+// ../../src/bootstrap/http/securedRouteModelBinding.ts
 function isMutatingPolicyAction(action) {
   return action === "update" || action === "delete";
 }
@@ -5050,7 +5422,7 @@ function withErrorHandling(handler) {
   };
 }
 // ../../src/core/http/loginThrottleMiddleware.ts
-var {RedisClient } = globalThis.Bun;
+var {RedisClient: RedisClient2 } = globalThis.Bun;
 function resolveLoginIdentity(request) {
   return request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "unknown";
 }
@@ -5069,7 +5441,7 @@ async function resolveLoginEmail(request) {
   }
 }
 function createLoginThrottleMiddleware(options) {
-  const client = new RedisClient(options.redisUrl);
+  const client = new RedisClient2(options.redisUrl);
   const prefix = options.keyPrefix ?? "workhub:login-throttle:";
   return async (request, next) => {
     const identity = resolveLoginIdentity(request);
@@ -5249,9 +5621,9 @@ function createRequireWebAuthMiddleware(auth2) {
   };
 }
 // ../../src/core/http/scimThrottleMiddleware.ts
-var {RedisClient: RedisClient2 } = globalThis.Bun;
+var {RedisClient: RedisClient3 } = globalThis.Bun;
 function createScimThrottleMiddleware(options) {
-  const client = options.redisUrl ? new RedisClient2(options.redisUrl) : null;
+  const client = options.redisUrl ? new RedisClient3(options.redisUrl) : null;
   return async (request, next) => {
     const identity = request.headers.get("authorization")?.slice("Bearer ".length, "Bearer ".length + 16) ?? request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "unknown";
     const key = `workhub:scim-throttle:${identity}`;
@@ -5341,7 +5713,7 @@ function createSecurityHeadersMiddleware() {
   };
 }
 // ../../src/core/http/throttleMiddleware.ts
-var {RedisClient: RedisClient3 } = globalThis.Bun;
+var {RedisClient: RedisClient4 } = globalThis.Bun;
 function resolveThrottleIdentity(request) {
   const user = currentAuthUser();
   if (user?.tokenId !== undefined) {
@@ -5353,7 +5725,7 @@ function resolveThrottleIdentity(request) {
   return request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "unknown";
 }
 function createThrottleMiddleware(options) {
-  const client = new RedisClient3(options.redisUrl);
+  const client = new RedisClient4(options.redisUrl);
   const prefix = options.keyPrefix ?? "workhub:throttle:";
   return async (request, next) => {
     const identity = resolveThrottleIdentity(request);
@@ -5772,7 +6144,7 @@ async function runQueueJob(envelope, failedJobs) {
 }
 
 // ../../src/core/queue/redisQueue.ts
-var {RedisClient: RedisClient4 } = globalThis.Bun;
+var {RedisClient: RedisClient5 } = globalThis.Bun;
 var QUEUE_LIST_KEY = "workhub:queue:default";
 var QUEUE_HIGH_KEY = "workhub:queue:high";
 var QUEUE_LOW_KEY = "workhub:queue:low";
@@ -5822,7 +6194,7 @@ function parseQueueJobEnvelope(rawPayload) {
 class RedisQueue {
   client;
   constructor(redisUrl) {
-    this.client = new RedisClient4(redisUrl);
+    this.client = new RedisClient5(redisUrl);
   }
   async dispatch(job, payload) {
     const name = jobRegistry.resolveName(job);
@@ -5848,7 +6220,7 @@ class QueueWorker {
   constructor(redisUrl, failedJobs, timeoutSeconds = 5) {
     this.failedJobs = failedJobs;
     this.timeoutSeconds = timeoutSeconds;
-    this.client = new RedisClient4(redisUrl);
+    this.client = new RedisClient5(redisUrl);
   }
   requestStop() {
     this.stopping = true;
@@ -5946,7 +6318,7 @@ function createQueueWorker(redisUrl, failedJobs = createFailedJobService()) {
   return new QueueWorker(redisUrl, failedJobs);
 }
 // ../../src/core/queue/queueMetrics.ts
-var {RedisClient: RedisClient5 } = globalThis.Bun;
+var {RedisClient: RedisClient6 } = globalThis.Bun;
 
 // ../../src/core/security/safeUrl.ts
 var BLOCKED_HOSTNAMES = new Set([
@@ -5959,7 +6331,7 @@ var BLOCKED_HOSTNAMES = new Set([
 
 // ../../src/core/queue/queueMetrics.ts
 async function readRedisQueueDepth(redisUrl) {
-  const client = new RedisClient5(redisUrl);
+  const client = new RedisClient6(redisUrl);
   const [high, defaultQueue, low] = await Promise.all([
     client.llen(QUEUE_HIGH_KEY),
     client.llen(QUEUE_LIST_KEY),
@@ -6452,6 +6824,7 @@ export {
   createCsrfProtection,
   createCsrfMiddleware,
   createCorsMiddleware,
+  createCacheStore,
   createBodySizeLimitMiddleware,
   createAuthorizeMiddleware,
   createAuthMiddleware,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",
@@ -90,6 +90,11 @@
       "import": "./dist/entries/cache/tags.js",
       "default": "./dist/entries/cache/tags.js"
     },
+    "./cache/createCacheStore": {
+      "types": "./dist/core/cache/createCacheStore.d.ts",
+      "import": "./dist/entries/cache/createCacheStore.js",
+      "default": "./dist/entries/cache/createCacheStore.js"
+    },
     "./crypto/fieldEncryption": {
       "types": "./dist/core/crypto/fieldEncryption.d.ts",
       "import": "./dist/entries/crypto/fieldEncryption.js",
@@ -312,7 +317,7 @@
     "build:bundle": "bun build index.ts --outdir dist --target bun --external bun --external eta",
     "build:types": "tsc -p tsconfig.types.json",
     "prepublishOnly": "bun run build && bun ../../scripts/prepare-core-package-publish.ts",
-    "build:subpaths": "bun build entries/auth/oauth/oidcProvider.ts entries/auth/oauth/providers.ts entries/auth/oauth/samlProvider.ts entries/auth/oauth/types.ts entries/auth/password.ts entries/auth/sessionCookie.ts entries/auth/tokenHash.ts entries/cache/tags.ts entries/crypto/fieldEncryption.ts entries/crypto/mfaSecret.ts entries/database/factory.ts entries/database/seeders.ts entries/database/types.ts entries/errors/http.ts entries/http/contentNegotiation.ts entries/http/csrfToken.ts entries/http/etag.ts entries/http/flashSession.ts entries/http/parseFormBody.ts entries/http/resources.ts entries/http/webErrorResponse.ts entries/http/webFormRequest.ts entries/jobs/dispatchWebhookJob.ts entries/lifecycle/gracefulShutdown.ts entries/metrics/prometheus.ts entries/pagination.ts entries/queue/createAppQueue.ts entries/queue/failedJobService.ts entries/queue/jobRegistry.ts entries/queue/jobRunner.ts entries/queue/queueMetrics.ts entries/queue/publicQueue.ts entries/queue/types.ts entries/security/oauthState.ts entries/security/publicReads.ts entries/security/safeUrl.ts entries/security/stripeWebhook.ts entries/security/tokenExpiry.ts entries/security/totp.ts entries/storage/storage.ts entries/validation/rules.ts entries/view.ts --outdir dist --root . --target bun --external bun --external eta",
+    "build:subpaths": "bun build entries/auth/oauth/oidcProvider.ts entries/auth/oauth/providers.ts entries/auth/oauth/samlProvider.ts entries/auth/oauth/types.ts entries/auth/password.ts entries/auth/sessionCookie.ts entries/auth/tokenHash.ts entries/cache/tags.ts entries/cache/createCacheStore.ts entries/crypto/fieldEncryption.ts entries/crypto/mfaSecret.ts entries/database/factory.ts entries/database/seeders.ts entries/database/types.ts entries/errors/http.ts entries/http/contentNegotiation.ts entries/http/csrfToken.ts entries/http/etag.ts entries/http/flashSession.ts entries/http/parseFormBody.ts entries/http/resources.ts entries/http/webErrorResponse.ts entries/http/webFormRequest.ts entries/jobs/dispatchWebhookJob.ts entries/lifecycle/gracefulShutdown.ts entries/metrics/prometheus.ts entries/pagination.ts entries/queue/createAppQueue.ts entries/queue/failedJobService.ts entries/queue/jobRegistry.ts entries/queue/jobRunner.ts entries/queue/queueMetrics.ts entries/queue/publicQueue.ts entries/queue/types.ts entries/security/oauthState.ts entries/security/publicReads.ts entries/security/safeUrl.ts entries/security/stripeWebhook.ts entries/security/tokenExpiry.ts entries/security/totp.ts entries/storage/storage.ts entries/validation/rules.ts entries/view.ts --outdir dist --root . --target bun --external bun --external eta",
     "build:shims": "bun ../../scripts/write-core-shared-shims.ts"
   },
   "publishConfig": {