@getstrata/core 2.2.13 → 2.2.15

package/CHANGELOG.md

@@ -1,8 +1,28 @@
 # @getstrata/core changelog
 
+## 2.2.15
+
+- Batch legacy list-queue priority polling while retaining recovery and ownership contracts.
+- Batch dialect-portable pivot writes with framework transaction/savepoint composition and consistent numeric/string ID toggle semantics. Noncanonical or textual IDs use sequential database comparisons to preserve coercion and collation behavior.
+- New Redis scaffolds explicitly select Streams; existing unset transport settings continue to select lists.
+- Generate the SQL outbox migration, listener registry and managed worker command. Durable publication and cache-invalidation activation remain explicit.
+
+- Primary-key ascending `chunk` queries reuse the existing keyset walk, including default primary-key ordering; projections, joins, grouping, locks and other orders retain OFFSET behavior.
+- Empty filtered pagination totals skip the row query. Nonempty page-number pagination preserves OFFSET semantics and its count-plus-row-query budget; explicit cursor/keyset APIs remain available for deep traversal.
+- Independent hashed write casts run concurrently. Deterministic regressions prove concurrent start, complete awaiting and failure before model observers or SQL writes; hydration and existing-hash behavior are preserved.
+- Streams workers poll retry promotion, pending recovery and new delivery across priorities in one bounded Redis script, preserving priority, ownership fencing and at-least-once delivery contracts.
+- Clarify historical 2.1.0–2.2.13 release notes and database/queue documentation. Remove the consolidated 1.x-to-2.x migration guide; existing projects are upgraded individually.
+
+## 2.2.14
+
+Complete the scoped HTML rendering starter adoption: generated apps inject ViewRenderer through createViewProvider instead of copying renderPage; welcome pages opt into HTMX fragments with full-page fallbacks, auth retains existing contracts, and CORS preserves representation Vary headers. Includes generator, runtime auth and cache-header regressions.
+
+Add optional typed resourceRoutes and strict mergeRouteMaps composition, preserving native Bun routing and app-owned middleware. Add explicit ViewRenderer.namespace prefixes with unchanged layout/Response/HTMX contracts; generated auth controllers use the namespace. Includes native HTTP, compile-time, rendering isolation and generator regressions.
+
 ## 2.2.13
 
-- Improve view rendering and better htmx support
+- Add a typed per-app HTML renderer on top of the native response path.
+- Add explicit HTMX page and fragment responses. A fragment can fall back to the full page. Layout and auth response contracts stay the same.
 
 ## 2.2.12
 
@@ -24,42 +44,47 @@ Add independently interruptible read-only SQLite and MySQL observations; extend
 
 ## 2.2.9
 
-- Support native cancellable transaction acquisition
+- Pool checkout can be cancelled. `reserve({ signal })` on the native driver aborts while it is still waiting for a connection. Drivers without that method are not given a fake one.
 
 ## 2.2.8
 
-- Add bounded read-only Postgres outbox metrics
+- Add bounded, read-only Postgres outbox metrics.
+- Add bounded, opt-in Redis queue metrics. List and Streams depth stay separate.
 
 ## 2.2.7
 
-- Where an ordinary operation needs SQL because the framework cannot express it
+- `ORDER BY` accepts explicit `nulls: "first" | "last"`. Postgres and SQLite emit `NULLS FIRST` / `NULLS LAST`. MySQL has no `NULLS FIRST` / `NULLS LAST` clause, so it orders nulls with an `IS NULL` discriminator and leaves the rest of the sort unchanged.
 
 ## 2.2.6
 
--  fix(cli): relay shutdown to children and simplify container launcher
+- The CLI, when it supervises the app or worker as a child, forwards shutdown signals to that child and waits for it. The container launcher no longer exits while the child is still running.
 
 ## 2.2.5
 
--  fix(starter): keep container readiness independent of API admission
+- Container readiness no longer means the API is admitting traffic. Database readiness no longer provisions roles or creates a missing database. A failed configured admin connection does not fall back to a generated password.
 
 ## 2.2.4
 
--  perf(database): seek Postgres composite keyset bounds
+- Composite keyset pages on Postgres seek with a row comparison (`(a, b) > (cursor)`), so the planner can start at the index bound instead of expanding the cursor into a chain of OR predicates.
 
 ## 2.2.3
 
-- feat(database): add scoped composite keyset pagination
+- Add scoped composite keyset pagination. The order must end with the primary key. Global scopes and caller filters stay in force across the cursor. Joins, grouping, and offset queries are rejected.
 
 ## 2.2.2
 
-- orm improvments
+- Schema `bigId` emits an explicit 64-bit generated identity.
+- Repository writes can be conditional and set-based.
+- Repositories and models can take a typed row lock inside the current transaction.
+- Generated Postgres query handles keep tagged-SQL typing.
 
 ## 2.2.1
 
-F02 — complete queue durability. Queues have leased reservations, recovery and fenced acknowledgement, but still use Redis lists. Persisted retry schedules, execution deadlines, cancellation and the planned Streams migration remain unfinished. Retries currently wait inside the running worker.
-F10 — production public-route tenancy. Separate anonymous access from development tenant headers, support a trusted-host resolver, reject unknown hosts, and accept forwarded hosts only through configured trusted proxies. The shop still lacks the approved-domain mapping.
-F12 — initial administrator provisioning and migration guidance. Automatic demo seeding is fixed. Secure initial-admin provisioning and a consolidated upgrade/operations guide remain.
-Distributed qualification. Cache generations/fill leases, scheduler ownership, OpenTelemetry, body limits and lifecycle controls now exist. Their implementation should no longer be described as entirely pending, but broader failure and capacity qualification is still required.
+- Opt-in Redis Streams (`QUEUE_REDIS_TRANSPORT=streams`). Lists stay the default. Streams adds consumer-group recovery, persisted retry schedules, total job deadlines, opt-in cancellation, and a stable job id across replay. Conversion from lists is a stopped maintenance step.
+- Failed jobs stay recorded until retry admission succeeds. Manual replay keeps `failed_job.job_id` when the row has one.
+- Public reads and tenant host selection are separate. Unknown hosts fail closed. Forwarded hosts are accepted only from configured trusted proxies.
+- Generated apps can provision one initial administrator with `auth:provision-admin` and a one-time claim migration. Demo seeding stays explicit and is rejected in production and staging.
+- Quota and in-memory throttle docs match the code: memory throttles stay process-local, and a Redis failure does not fall back to them.
 
 ## 2.2.0
 
@@ -96,7 +121,9 @@ Bounded memory throttling.
 
 ## 2.1.0
 
-- refactor(starter): reuse shared config and base repositories - fix(database): await password casts before model writes - fix(database): preserve concrete model types in query results
+- Generated apps reuse the shared config store and base repositories instead of a copied stack.
+- Password casts are awaited before the write reaches SQL or observers. Hydration does not hash.
+- Model queries keep the concrete model type in their results. Service tokens, route handlers, and the starter's generated infrastructure were tightened in the same release.
 
 ## 2.0.9
 

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

@@ -69,6 +69,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     softDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
+    private primaryKeySeekDirection;
     withConnection(connection: DatabaseConnection): this;
     getConnection(): DatabaseConnection;
     getTable(): TableDefinition<TEntity, PrimaryKey>;

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

@@ -2,5 +2,6 @@ import type { SqlDatabaseConnection } from "./baseRepository";
 declare function registerDefaultDatabasePool(connection: SqlDatabaseConnection): void;
 declare function getDefaultDatabasePool(): SqlDatabaseConnection;
 declare function getDefaultDatabaseQuery(): SqlDatabaseConnection;
+declare function isDefaultDatabaseConnection(connection: unknown): boolean;
 declare function resetDefaultDatabasePoolForTests(): void;
-export { getDefaultDatabasePool, getDefaultDatabaseQuery, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };
+export { getDefaultDatabasePool, getDefaultDatabaseQuery, isDefaultDatabaseConnection, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };

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

@@ -112,6 +112,7 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     private connection;
+    private atomically;
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
@@ -123,6 +124,9 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     attach(ids: unknown | readonly unknown[]): Promise<void>;
     toggle(ids: unknown | readonly unknown[]): Promise<void>;
     detach(ids?: unknown | readonly unknown[]): Promise<void>;
+    private toggleOne;
+    private insertPivotRows;
+    private deletePivotRows;
     sync(ids: readonly unknown[]): Promise<void>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }

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

@@ -14,8 +14,8 @@ export { parseMultipartUpload, sanitizeUploadFileName, validateUploadFile, } fro
 export { createRequireAuthMiddleware } from "./requireAuthMiddleware";
 export { serializeDate, toPaginatedResourceCollection, toResourceCollection } from "./resources";
 export { createdResponse, errorResponse, jsonResponse, noContentResponse, withErrorHandling, } from "./response";
-export type { RouteRequest } from "./route";
-export { getRouteParams } from "./route";
+export type { ResourceActions, ResourceMemberHandler, ResourceRouteMap, RouteRequest, } from "./route";
+export { getRouteParams, mergeRouteMaps, resourceRoutes } from "./route";
 export { withMiddleware } from "./routeMiddleware";
 export { bindRouteModel } from "./routeModelBinding";
 export { securedBindRouteModel, securedBindRouteModelByKey, } from "./securedRouteModelBinding";

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

@@ -1,3 +1,67 @@
+import type { RouteHandler } from "./middleware";
+type ResourceMemberHandler = RouteHandler<RouteRequest<{
+    id: string;
+}>>;
+interface ResourceActions {
+    index?: RouteHandler;
+    create?: RouteHandler;
+    store?: RouteHandler;
+    show?: ResourceMemberHandler;
+    edit?: ResourceMemberHandler;
+    update?: ResourceMemberHandler;
+    destroy?: ResourceMemberHandler;
+}
+type ResourceRouteMap<P extends string, A extends ResourceActions> = (A extends {
+    index: infer H;
+} ? {
+    [K in P]: {
+        GET: H;
+    };
+} : Record<never, never>) & (A extends {
+    store: infer H;
+} ? {
+    [K in P]: {
+        POST: H;
+    };
+} : Record<never, never>) & (A extends {
+    create: infer H;
+} ? {
+    [K in `${P}/create`]: {
+        GET: H;
+    };
+} : Record<never, never>) & (A extends {
+    show: infer H;
+} ? {
+    [K in `${P}/:id`]: {
+        GET: H;
+    };
+} : Record<never, never>) & (A extends {
+    edit: infer H;
+} ? {
+    [K in `${P}/:id/edit`]: {
+        GET: H;
+    };
+} : Record<never, never>) & (A extends {
+    update: infer H;
+} ? {
+    [K in `${P}/:id`]: {
+        PUT: H;
+        PATCH: H;
+    };
+} : Record<never, never>) & (A extends {
+    destroy: infer H;
+} ? {
+    [K in `${P}/:id`]: {
+        DELETE: H;
+    };
+} : Record<never, never>);
+/** Expand only explicitly supplied actions into native Bun routes. */
+declare function resourceRoutes<const P extends string, const A extends ResourceActions>(path: P, actions: A & Record<Exclude<keyof A, keyof ResourceActions>, never>): ResourceRouteMap<P, A>;
+type Intersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+/** Strict composition: duplicate paths fail rather than silently replacing handlers. */
+declare function mergeRouteMaps<const T extends readonly Record<string, unknown>[]>(...maps: T): Intersection<T[number]>;
+export type { ResourceActions, ResourceMemberHandler, ResourceRouteMap };
+export { mergeRouteMaps, resourceRoutes };
 type RouteRequest<TParams extends Record<string, string>> = Request & {
     params: TParams;
 };

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

@@ -15,6 +15,10 @@ type QueueReservation = {
 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 pollListPriorities(client: RedisClient, queueKeys: readonly string[], owner: string, reservationId: string, reclaim: boolean): Promise<{
+    queueKey: string;
+    reservation: QueueReservation;
+} | null>;
 declare function reclaimExpiredQueueReservations(client: RedisClient, queueKeys?: readonly string[]): Promise<number>;
 declare class RedisQueue implements Queue {
     private readonly client;
@@ -42,4 +46,4 @@ declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
 export type { StreamReservation, StreamsEnqueueOptions } from "./redisStreams";
 export { migrateLegacyQueueToStreams, RedisStreamsQueue, RedisStreamsWorker, STREAM_GROUP, streamDeadLetterKey, streamQueueKey, updateStreamReservation, } from "./redisStreams";
 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, };
+export { countPendingQueueJobs, parseQueueJobEnvelope, pollListPriorities, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueInvalidKey, queueKeyForPriority, queueProcessingKey, queueProcessingLeaseKey, RedisQueue, reclaimExpiredQueueReservations, reservationExpired, reserveQueueJob, updateQueueReservation, };

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

@@ -18,6 +18,13 @@ declare function readStreamTime(client: RedisClient): Promise<number>;
 declare function watchStreamDeadline(client: RedisClient, deadlineAtMs: number, remainingMs: number, expire: () => void, fail: (error: unknown) => void): () => void;
 declare function scheduleStreamRetry(client: RedisClient, key: string, reservation: StreamReservation, envelope: QueueJobEnvelope, delayMs: number): Promise<void>;
 declare function promoteStreamRetries(client: RedisClient, key: string): Promise<number>;
+declare function pollStreamPriorities(client: RedisClient, queueKeys: readonly string[], owner: string, cursors: readonly string[]): Promise<{
+    cursors: string[];
+    hit: {
+        index: number;
+        reservation: StreamReservation;
+    } | null;
+}>;
 declare function readStreamQueueDepth(client: RedisClient, key: string): Promise<number>;
 type StreamReservation = {
     id: string;
@@ -58,7 +65,6 @@ declare class RedisStreamsWorker {
     isRunning(): boolean;
     close(): void;
     private initialize;
-    private reserve;
     processNext(): Promise<boolean>;
     private processOne;
     private handle;
@@ -70,4 +76,4 @@ declare function migrateLegacyQueueToStreams(client: RedisClient, options: {
     queueKeys?: readonly string[];
 }): Promise<number>;
 export type { StreamReservation, StreamsEnqueueOptions };
-export { cancelStreamJob, ensureStreamGroup, migrateLegacyQueueToStreams, promoteStreamRetries, RedisStreamsQueue, RedisStreamsWorker, readStreamCancellation, readStreamEntry, readStreamQueueDepth, readStreamTime, reserveStreamJob, STREAM_GROUP, scheduleStreamRetry, streamControlKey, streamDeadLetterKey, streamQueueKey, streamRetryKey, updateStreamReservation, watchStreamDeadline, };
+export { cancelStreamJob, ensureStreamGroup, migrateLegacyQueueToStreams, pollStreamPriorities, promoteStreamRetries, RedisStreamsQueue, RedisStreamsWorker, readStreamCancellation, readStreamEntry, readStreamQueueDepth, readStreamTime, reserveStreamJob, STREAM_GROUP, scheduleStreamRetry, streamControlKey, streamDeadLetterKey, streamQueueKey, streamRetryKey, updateStreamReservation, watchStreamDeadline, };

package/dist/core/view/index.d.ts

@@ -2,7 +2,7 @@ export type { LayoutDataResolver, RenderOptions } from "./etaViewEngine";
 export { DEFAULT_VIEWS_DIRECTORY, EtaViewEngine } from "./etaViewEngine";
 export { htmlResponse, isHtmxRequest, redirectResponse, rssResponse, textResponse, xmlResponse, } from "./htmlResponse";
 export type { ViewEngine } from "./viewEngine";
-export type { HtmxViewResponseOptions, ViewResponseOptions } from "./viewRenderer";
+export type { HtmxViewResponseOptions, NamespacedViewRenderer, ViewResponseOptions, } from "./viewRenderer";
 export { CORE_VIEW_RENDERER_TOKEN, ViewRenderer } from "./viewRenderer";
 export type { WebErrorViewInput, WebErrorViewOptions } from "./webErrorView";
 export { configureWebErrorView, errorTemplateName, htmlErrorResponse, notFoundHtmlResponse, renderKernelErrorChrome, renderWebErrorHtml, } from "./webErrorView";

package/dist/core/view/viewRenderer.d.ts

@@ -10,15 +10,21 @@ interface HtmxViewResponseOptions extends ViewResponseOptions {
     /** Optional fragment template; otherwise render the page template without its layout. */
     fragment?: string;
 }
+interface NamespacedViewRenderer {
+    render: ViewRenderer["render"];
+    renderHtmx: ViewRenderer["renderHtmx"];
+}
 /** App-owned renderer; request data stays in the engine's async resolver. */
 declare class ViewRenderer {
     private readonly engine;
     private readonly defaultLayout?;
     constructor(engine: ViewEngine, defaultLayout?: string | false | undefined);
+    /** Explicit template prefix; layout names and response contracts remain unchanged. */
+    namespace(prefix: string): NamespacedViewRenderer;
     render(name: string, data?: Record<string, unknown>, options?: ViewResponseOptions): Promise<Response>;
     /** Opt-in representation selection; auth/CSRF/tenancy remain the route's responsibility. */
     renderHtmx(name: string, data?: Record<string, unknown>, options?: HtmxViewResponseOptions): Promise<Response>;
 }
 declare const CORE_VIEW_RENDERER_TOKEN: import("../contracts/container").ServiceToken<ViewRenderer>;
-export type { HtmxViewResponseOptions, ViewResponseOptions };
+export type { HtmxViewResponseOptions, NamespacedViewRenderer, ViewResponseOptions };
 export { CORE_VIEW_RENDERER_TOKEN, ViewRenderer };

package/dist/entries/http/corsMiddleware.js

@@ -141,7 +141,16 @@ function createCorsMiddleware(options = {}) {
     const response = await next();
     const headers = new Headers(response.headers);
     for (const [key, value] of buildCorsHeaders(request, captured)) {
-      headers.set(key, value);
+      if (key === "vary") {
+        const fields = (headers.get("Vary") ?? "").split(",").map((field) => field.trim()).filter(Boolean);
+        if (fields.includes("*"))
+          continue;
+        if (!fields.some((field) => field.toLowerCase() === "origin"))
+          fields.push(value);
+        headers.set("Vary", fields.join(", "));
+      } else {
+        headers.set(key, value);
+      }
     }
     return new Response(response.body, {
       status: response.status,

package/dist/entries/http/route.js

@@ -1,8 +1,52 @@
 // @bun
 // ../../src/core/http/route.ts
+function resourceRoutes(path, actions) {
+  if (!/^\/[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)*$/.test(path) || path.split("/").some((part) => part === "." || part === "..")) {
+    throw new TypeError("Resource path must be a static absolute path without a trailing slash.");
+  }
+  const routes = {};
+  const definitions = {
+    index: [path, ["GET"]],
+    create: [`${path}/create`, ["GET"]],
+    store: [path, ["POST"]],
+    show: [`${path}/:id`, ["GET"]],
+    edit: [`${path}/:id/edit`, ["GET"]],
+    update: [`${path}/:id`, ["PUT", "PATCH"]],
+    destroy: [`${path}/:id`, ["DELETE"]]
+  };
+  for (const [action, handler] of Object.entries(actions)) {
+    if (!Object.hasOwn(definitions, action) || typeof handler !== "function") {
+      throw new TypeError(`Invalid resource action: ${action}`);
+    }
+    const [route, methods] = definitions[action];
+    const methodMap = routes[route] ?? {};
+    routes[route] = methodMap;
+    for (const method of methods)
+      methodMap[method] = handler;
+  }
+  return routes;
+}
+function mergeRouteMaps(...maps) {
+  const routes = {};
+  for (const map of maps) {
+    for (const [path, handler] of Object.entries(map)) {
+      if (Object.hasOwn(routes, path))
+        throw new Error(`Duplicate route path: ${path}`);
+      Object.defineProperty(routes, path, {
+        value: handler,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  return routes;
+}
 function getRouteParams(request) {
   return request.params;
 }
 export {
-  getRouteParams
+  getRouteParams,
+  mergeRouteMaps,
+  resourceRoutes
 };