@getstrata/core 1.1.9 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @getstrata/core changelog
 
+## 2.0.0
+
+- Strata 2.0: compose business transactions and tenant scopes
+
+## Unreleased
+
+- 2.0 Redis throttle keys use application, tenant and registered route identities; atomic counter/expiry consumption repairs missing TTLs. API and login throttles fail closed with 503 on store errors or deadlines and recreate failed owned connections. Memory pruning and app quota policies remain follow-up work.
+
+- 2.0 metrics contract: HTTP middleware uses registered route templates and an unmatched bucket. Fixed duration histograms, bounded method/status labels, escaping, and a 4,096-series cap plus aggregate overflow bound retention and scrape work. Removed `normalizeMetricPath()`; expose storage statistics for operational checks.
+
+- 2.0 transaction contract: implicit repository queries use the active transaction; nested scopes use SQL savepoints without requiring a driver-specific helper. Cross-tenant nesting and concurrent sibling savepoints are rejected. Nested bypass scopes restore tenant, bypass, and identifier settings on the same connection.
+
+- `runWithTenantDatabase()` / `runInTransaction()` roll back when `withJsonErrorHandling()` (or `requestTransactionRollback()`) turns a thrown error into a response. Nested tenant scopes use a savepoint and restore `app.tenant_id` on the way out.
+- Redis workers atomically reserve jobs with unique reservation IDs and renewable owner leases. Recovery and acknowledgement are atomic and ownership checked; a failed failure-record write retains the reservation. Invalid/unregistered payloads are quarantined for inspection. Stop old workers before rollout. `QUEUE_VISIBILITY_MS` defaults to 60s and must be at least 30ms. Handlers must be idempotent; Streams and persisted retries remain follow-up work.
+
 ## 1.1.9
 
 - Defer model events until the surrounding transaction commits

package/dist/core/database/transaction.d.ts

@@ -1,3 +1,4 @@
 import type { DatabaseConnection } from "./baseRepository.ts";
+import { requestTransactionRollback } from "./transactionControl.ts";
 declare function runInTransaction<TValue>(operation: (connection: DatabaseConnection) => Promise<TValue>): Promise<TValue>;
-export { runInTransaction };
+export { requestTransactionRollback, runInTransaction };

package/dist/core/database/transactionControl.d.ts

@@ -0,0 +1,5 @@
+declare function requestTransactionRollback(): void;
+declare function commitOrRollbackScope<T>(result: T): Promise<T>;
+declare function settleTransaction<T>(work: () => Promise<T>): Promise<T>;
+declare function runWithTransactionScope<T>(callback: () => T | Promise<T>): Promise<T>;
+export { commitOrRollbackScope, requestTransactionRollback, runWithTransactionScope, settleTransaction, };

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

@@ -1,9 +1,12 @@
 import type { Middleware } from "./middleware";
+import { type RedisThrottleClient } from "./throttleMiddleware";
 interface LoginThrottleOptions {
     redisUrl?: string;
     maxAttempts: number;
     decaySeconds: number;
     keyPrefix?: string;
+    commandTimeoutMs?: number;
+    redisClient?: RedisThrottleClient;
 }
 declare function resolveLoginIdentity(request: Request): string;
 declare function resolveLoginEmail(request: Request): Promise<string>;

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

@@ -1,4 +1,3 @@
 import type { Middleware } from "./middleware";
-declare function normalizeMetricPath(pathname: string): string;
 declare function createMetricsMiddleware(): Middleware;
-export { createMetricsMiddleware, normalizeMetricPath };
+export { createMetricsMiddleware };

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

@@ -2,6 +2,8 @@ type RequestMeta = {
     ipAddress: string | null;
     userAgent: string | null;
     request?: Request;
+    /** Registered route template; never a URL supplied by the client. */
+    routeTemplate?: string;
     flash?: {
         level: string;
         message: string;

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

@@ -1,11 +1,20 @@
+import { RedisClient } from "bun";
 import type { Middleware } from "./middleware";
 interface ThrottleOptions {
     redisUrl: string;
     maxAttempts: number;
     decaySeconds: number;
     keyPrefix?: string;
+    commandTimeoutMs?: number;
+    redisClient?: RedisThrottleClient;
 }
 declare function resolveThrottleIdentity(request: Request): string;
+type RedisThrottleClient = Pick<RedisClient, "send">;
+declare function redisThrottleKey(request: Request, prefix: string, identity: string): string;
+declare function consumeRedisThrottle(client: RedisThrottleClient, key: string, decaySeconds: number, timeoutMs?: number): Promise<number>;
+/** Reuse a healthy connection; failed owned connections are recreated on the next request. */
+declare function createRedisThrottleConsumer(options: Pick<ThrottleOptions, "redisUrl" | "redisClient" | "commandTimeoutMs">): (key: string, decaySeconds: number) => Promise<number>;
+declare function throttleUnavailableResponse(): Response;
 declare function createThrottleMiddleware(options: ThrottleOptions): Middleware;
-export type { ThrottleOptions };
-export { createThrottleMiddleware, resolveThrottleIdentity };
+export type { RedisThrottleClient, ThrottleOptions };
+export { consumeRedisThrottle, createRedisThrottleConsumer, createThrottleMiddleware, redisThrottleKey, resolveThrottleIdentity, throttleUnavailableResponse, };

package/dist/core/metrics/prometheus.d.ts

@@ -3,7 +3,11 @@ interface MetricLabels {
     path: string;
     status: string;
 }
+declare const HTTP_DURATION_BUCKETS_MS: readonly [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
 declare class PrometheusRegistry {
+    private readonly maxSeries;
+    private readonly seriesLabels;
+    constructor(maxSeries?: number);
     private readonly httpRequestsTotal;
     private readonly httpRequestDurationMs;
     incrementHttpRequest(labels: MetricLabels): void;
@@ -19,8 +23,14 @@ declare class PrometheusRegistry {
             count: number;
         }>;
     };
+    /** Storage and scrape work are capped at maxSeries plus one overflow series. */
+    getStorageStats(): {
+        series: number;
+        histograms: number;
+        bucketCounters: number;
+    };
     private metricKey;
 }
 declare const prometheusRegistry: PrometheusRegistry;
 export type { MetricLabels };
-export { PrometheusRegistry, prometheusRegistry };
+export { HTTP_DURATION_BUCKETS_MS, PrometheusRegistry, prometheusRegistry };

package/dist/core/queue/jobRunner.d.ts

@@ -4,6 +4,8 @@ interface QueueJobEnvelope {
     payload: Record<string, unknown>;
     attempts?: number;
 }
-declare function runQueueJob(envelope: QueueJobEnvelope, failedJobs: FailedJobService): Promise<void>;
+declare function runQueueJob(envelope: QueueJobEnvelope, failedJobs: FailedJobService, options?: {
+    onFailureRecorded?: () => void;
+}): Promise<void>;
 export type { QueueJobEnvelope };
 export { runQueueJob };

package/dist/core/queue/redisQueue.d.ts

@@ -1,11 +1,25 @@
+import { RedisClient } from "bun";
 import type FailedJobService from "./failedJobService";
 import type { Job, Queue, QueuePriority } from "./index";
 import { type QueueJobEnvelope } from "./jobRunner";
 declare const QUEUE_LIST_KEY: string;
 declare const QUEUE_HIGH_KEY: string;
 declare const QUEUE_LOW_KEY: string;
+declare function queueProcessingKey(queueKey: string): string;
+declare function queueProcessingLeaseKey(queueKey: string): string;
+declare function reservationExpired(lease: string | null, now: number, visibilityMs: number): boolean;
 declare function queueKeyForPriority(priority?: QueuePriority): string;
 declare function parseQueueJobEnvelope(rawPayload: string): QueueJobEnvelope | null;
+type QueueReservation = {
+    id: string;
+    owner: string;
+    payload: string;
+    record: string;
+};
+declare function queueInvalidKey(queueKey: string): string;
+declare function reserveQueueJob(client: RedisClient, queueKey: string, owner: string): Promise<QueueReservation | null>;
+declare function updateQueueReservation(client: RedisClient, queueKey: string, reservation: QueueReservation, action: "renew" | "ack" | "quarantine"): Promise<boolean>;
+declare function reclaimExpiredQueueReservations(client: RedisClient, queueKeys?: readonly string[]): Promise<number>;
 declare class RedisQueue implements Queue {
     private readonly client;
     constructor(redisUrl: string);
@@ -14,16 +28,19 @@ declare class RedisQueue implements Queue {
 declare class QueueWorker {
     private readonly failedJobs;
     private readonly timeoutSeconds;
+    private readonly queueKeys;
+    private readonly owner;
     private running;
     private stopping;
     private readonly client;
-    constructor(redisUrl: string, failedJobs: FailedJobService, timeoutSeconds?: number);
+    constructor(redisUrl: string, failedJobs: FailedJobService, timeoutSeconds?: number, queueKeys?: readonly string[]);
     requestStop(): void;
     isRunning(): boolean;
+    private reserve;
     processNext(): Promise<boolean>;
     run(): Promise<void>;
     close(): void;
 }
 declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
-export type { QueueJobEnvelope };
-export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueKeyForPriority, RedisQueue, };
+export type { QueueJobEnvelope, QueueReservation };
+export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueInvalidKey, queueKeyForPriority, queueProcessingKey, queueProcessingLeaseKey, RedisQueue, reclaimExpiredQueueReservations, reservationExpired, reserveQueueJob, updateQueueReservation, };

package/dist/core/tenant/databaseTenantContext.d.ts

@@ -1,3 +1,7 @@
+type TransactionHandle = {
+    unsafe(query: string, params?: readonly unknown[]): Promise<unknown[]>;
+};
+declare function runWithScopedTenantTransaction<T>(apply: (transaction: TransactionHandle) => Promise<void>, callback: () => T | Promise<T>): Promise<T>;
 declare function runWithMigrationBypass<T>(callback: () => T | Promise<T>): Promise<T>;
 declare function runWithMigrationBypassForIdentifier<T>(identifier: string | number, callback: () => T | Promise<T>): Promise<T>;
-export { runWithMigrationBypass, runWithMigrationBypassForIdentifier };
+export { runWithMigrationBypass, runWithMigrationBypassForIdentifier, runWithScopedTenantTransaction, };