@bgord/bun 1.20.4 → 1.21.0

package/src/shield-maintenance.strategy.ts

@@ -1,17 +1,53 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+import type { HasRequestPath } from "./request-context.port";
 
-export type ShieldMaintenanceConfig = { enabled: boolean; RetryAfter?: tools.Duration };
+export const Maintenance = v.object({ enabled: tools.FeatureFlagValue });
+
+export type MaintenanceType = v.InferOutput<typeof Maintenance>;
+
+export type ShieldMaintenanceConfig = {
+  MaintenanceConfig: ReactiveConfigPort<MaintenanceType>;
+  RetryAfter?: tools.Duration;
+  skip?: ReadonlyArray<string | URLPattern>;
+};
+
+export type ShieldMaintenanceResult = {
+  enabled: boolean;
+  code: 503;
+  body: { reason: string };
+  headers: Record<string, string>;
+};
 
 export class ShieldMaintenanceStrategy {
-  private readonly enabled: boolean;
+  private readonly rounding = new tools.RoundingUpStrategy();
+  private readonly MaintenanceConfig?: ReactiveConfigPort<MaintenanceType>;
   private readonly RetryAfter: tools.Duration;
 
-  constructor(config?: ShieldMaintenanceConfig) {
-    this.enabled = config?.enabled ?? false;
+  constructor(private readonly config?: ShieldMaintenanceConfig) {
+    this.MaintenanceConfig = config?.MaintenanceConfig;
     this.RetryAfter = config?.RetryAfter ?? tools.Duration.Hours(1);
   }
 
-  evaluate(): { enabled: boolean; RetryAfter: tools.Duration } {
-    return { enabled: this.enabled, RetryAfter: this.RetryAfter };
+  shouldSkip(context: HasRequestPath): boolean {
+    return (
+      this.config?.skip?.some((rule) => {
+        if (rule instanceof URLPattern) return rule.test({ pathname: context.request.path });
+        return context.request.path.startsWith(rule);
+      }) ?? false
+    );
+  }
+
+  async evaluate(): Promise<ShieldMaintenanceResult> {
+    const maintenance = await this.MaintenanceConfig?.get();
+    const enabled = maintenance ? tools.FeatureFlag.from(maintenance.enabled).isEnabled() : false;
+
+    return {
+      enabled,
+      code: 503,
+      body: { reason: "maintenance" },
+      headers: { "Retry-After": this.rounding.round(this.RetryAfter.seconds).toString() },
+    };
   }
 }

package/src/shield-rate-limit.strategy.ts

@@ -4,7 +4,7 @@ import type { ClockPort } from "./clock.port";
 import type { RequestContext } from "./request-context.port";
 import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
-export type ShieldRateLimitConfig = { resolver: SubjectRequestResolver; window: tools.Duration };
+export type ShieldRateLimitConfig = { resolver: SubjectRequestResolver; interval: tools.Duration };
 type ShieldRateLimitResult = { allowed: true } | { allowed: false; retryAfter: tools.Duration };
 
 type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverStrategy };
@@ -24,7 +24,7 @@ export class ShieldRateLimitStrategy {
 
     const limiter = await this.deps.CacheResolver.resolve(
       subject.hex,
-      async () => new tools.RateLimiter(this.config.window),
+      async () => new tools.RateLimiter(this.config.interval),
     );
 
     const decision = limiter.verify(this.deps.Clock.now());

package/src/shield-recaptcha.strategy.ts

@@ -2,7 +2,7 @@
 import * as tools from "@bgord/tools";
 import * as v from "valibot";
 import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
-import type { HasRequestForm, HasRequestHeader, HasRequestQuery } from "./request-context.port";
+import type { HasIdentityIp, HasRequestForm, HasRequestJson } from "./request-context.port";
 
 export type ShieldRecaptchaConfig = { secretKey: RecaptchaSecretKeyType; threshold?: number };
 export type RecaptchaResult = { success: boolean; score: number };
@@ -21,21 +21,25 @@ export class ShieldRecaptchaStrategy {
 
   constructor(private readonly config: ShieldRecaptchaConfig) {}
 
-  async evaluate(context: HasRequestHeader & HasRequestQuery & HasRequestForm): Promise<boolean> {
+  async evaluate(context: HasIdentityIp & HasRequestForm & HasRequestJson): Promise<boolean> {
     const threshold = this.config.threshold ?? ShieldRecaptchaStrategy.DEFAULT_THRESHOLD;
 
     try {
-      const header = context.request.header("x-recaptcha-token");
-      const query = context.request.query()["recaptchaToken"];
-      const remoteip = context.request.header("x-forwarded-for")?.split(",")[0] ?? "";
       const form = await context.request.form();
-      const formToken = form.get(ShieldRecaptchaStrategyField)?.toString();
+      const json = await context.request.json();
 
-      const token = header ?? query ?? formToken;
+      const fromForm = form.get(ShieldRecaptchaStrategyField)?.toString();
+      const fromJson = json[ShieldRecaptchaStrategyField];
+
+      const token = fromForm ?? (typeof fromJson === "string" ? fromJson : undefined);
 
       if (!token) return false;
 
-      const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
+      const remoteip = context.identity.ip();
+
+      const params = new URLSearchParams({ secret: this.config.secretKey, response: token });
+
+      if (remoteip) params.set("remoteip", remoteip);
 
       const response = await fetch(ShieldRecaptchaStrategy.URL, {
         method: "POST",
@@ -45,7 +49,9 @@ export class ShieldRecaptchaStrategy {
 
       const result: RecaptchaResult = await response.json();
 
-      if (!result.success || result.score < threshold) return false;
+      if (!result.success) return false;
+      if (typeof result.score !== "number" || result.score < threshold) return false;
+
       return true;
     } catch {
       return false;

package/src/shield-timeout-hono.strategy.ts

@@ -13,7 +13,7 @@ export class ShieldTimeoutHonoStrategy implements MiddlewareHonoPort {
 
     this.timeout = timeout(
       strategy.config.ms,
-      new HTTPException(408, { message: ShieldTimeoutStrategyError.Rejected }),
+      new HTTPException(504, { message: ShieldTimeoutStrategyError.Rejected }),
     );
   }
 

package/src/shield-webhook-hono.strategy.ts

@@ -20,7 +20,7 @@ export class ShieldWebhookHonoStrategy implements MiddlewareHonoPort {
       const context = new RequestContextHonoAdapter(c);
 
       if (await this.strategy.evaluate(context)) return next();
-      throw new HTTPException(403, { message: ShieldWebhookStrategyError.Rejected });
+      throw new HTTPException(401, { message: ShieldWebhookStrategyError.Rejected });
     };
   }
 }

package/src/shield-webhook.strategy.ts

@@ -1,4 +1,4 @@
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader, HasRequestText } from "./request-context.port";
 import type { WebhookBodyBuilderStrategy } from "./webhook-body-builder.strategy";
 import type { WebhookSignatureExtractorStrategy } from "./webhook-signature-extractor.strategy";
 import type { WebhookVerifierStrategy } from "./webhook-verifier.strategy";
@@ -14,7 +14,7 @@ export type ShieldWebhookStrategyConfig = {
 export class ShieldWebhookStrategy {
   constructor(private readonly config: ShieldWebhookStrategyConfig) {}
 
-  async evaluate(context: RequestContext): Promise<boolean> {
+  async evaluate(context: HasRequestHeader & HasRequestText): Promise<boolean> {
     const signature = this.config.WebhookSignatureExtractor.extract(context);
 
     if (!signature) return false;

package/src/simulated-error.middleware.ts

@@ -1,5 +1,7 @@
+export const SimulatedErrorMiddlewareError = { Simulated: "simulated.error" };
+
 export class SimulatedErrorMiddleware {
   evaluate(): never {
-    throw new Error("Simulated error");
+    throw new Error(SimulatedErrorMiddlewareError.Simulated);
   }
 }

package/src/sitemap-entry.vo.ts

@@ -28,7 +28,7 @@ export class SitemapEntry {
     const lastmod = this.entry.lastmod ? `<lastmod>${this.entry.lastmod}</lastmod>` : "";
     const changefreq = this.entry.changefreq ? `<changefreq>${this.entry.changefreq}</changefreq>` : "";
     const priority =
-      this.entry.priority !== undefined ? `<priority>${this.entry.priority.toFixed(1)}</priority>` : "";
+      this.entry.priority !== undefined ? `<priority>${this.entry.priority.toFixed(2)}</priority>` : "";
 
     return ["<url>", loc, lastmod, changefreq, priority, "</url>"].join("");
   }

package/src/sitemap-priority.vo.ts

@@ -6,6 +6,7 @@ export const SitemapPriority = v.pipe(
   v.number(SitemapPriorityError.Invalid),
   v.minValue(0, SitemapPriorityError.Invalid),
   v.maxValue(1, SitemapPriorityError.Invalid),
+  v.check((value) => Number(value.toFixed(2)) === value, SitemapPriorityError.Invalid),
   // Stryker disable next-line StringLiteral
   v.brand("SitemapPriority"),
 );

package/src/slower-hono.middleware.ts

@@ -1,15 +1,12 @@
 import type * as tools from "@bgord/tools";
 import type { MiddlewareHandler } from "hono";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
-import type { SleeperPort } from "./sleeper.port";
-import { SlowerMiddleware } from "./slower.middleware";
-
-type Dependencies = { Sleeper: SleeperPort };
+import { SlowerMiddleware, type SlowerMiddlewareDependencies } from "./slower.middleware";
 
 export class SlowerHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: SlowerMiddleware;
 
-  constructor(offset: tools.Duration, deps: Dependencies) {
+  constructor(offset: tools.Duration, deps: SlowerMiddlewareDependencies) {
     this.middleware = new SlowerMiddleware(offset, deps);
   }
 

package/src/slower.middleware.ts

@@ -1,12 +1,12 @@
 import type * as tools from "@bgord/tools";
 import type { SleeperPort } from "./sleeper.port";
 
-type Dependencies = { Sleeper: SleeperPort };
+export type SlowerMiddlewareDependencies = { Sleeper: SleeperPort };
 
 export class SlowerMiddleware {
   constructor(
     private readonly offset: tools.Duration,
-    private readonly deps: Dependencies,
+    private readonly deps: SlowerMiddlewareDependencies,
   ) {}
 
   async evaluate(): Promise<void> {

package/src/sms-with-logger.adapter.ts

@@ -19,7 +19,7 @@ export class SmsWithLoggerAdapter implements SmsPort {
       this.deps.Logger.info({
         message: "SMS attempt",
         correlationId: CorrelationStorage.get(),
-        metadata: message.toJSON(),
+        metadata: { message: message.toJSON() },
         ...this.base,
       });
 

package/src/sse-hono.handler.ts

@@ -34,13 +34,15 @@ export class SseHonoHandler<Messages extends Message> implements HandlerHonoPort
           await stream.writeSSE({ event: message.name, data: JSON.stringify(message) });
         };
 
-        this.deps.registry.register(subject.hex.get(), send);
+        const registered = this.deps.registry.register(subject.hex.get(), send);
+
+        if (!registered) return;
 
         // Stryker disable all
         stream.onAbort(() => this.deps.registry.unregister(subject.hex.get(), send));
         // Stryker restore all
 
-        while (!stream.closed) {
+        while (!(stream.closed || stream.aborted)) {
           await stream.sleep(this.config.keepalive.ms);
           await stream.writeSSE({ event: "ping", data: JSON.stringify({ keepalive: true }) });
         }

package/src/sse-registry-collecting.adapter.ts

@@ -5,7 +5,9 @@ import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 export class SseRegistryCollectingAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   public emitted: Array<{ identity: HashValueType; message: Messages }> = [];
 
-  register(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
+  register(_identity: HashValueType, _sender: SseSenderType<Messages>): boolean {
+    return true;
+  }
 
   unregister(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
 

package/src/sse-registry-noop.adapter.ts

@@ -3,7 +3,9 @@ import type { Message } from "./message.types";
 import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 
 export class SseRegistryNoopAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
-  register(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
+  register(_identity: HashValueType, _sender: SseSenderType<Messages>): boolean {
+    return true;
+  }
 
   unregister(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
 

package/src/sse-registry-with-limit.adapter.ts

@@ -11,10 +11,10 @@ type Dependencies<Messages extends Message> = {
 export class SseRegistryWithLimitAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   constructor(private readonly deps: Dependencies<Messages>) {}
 
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void {
-    if (this.deps.inner.count(identity) >= this.deps.limit) return;
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean {
+    if (this.deps.inner.count(identity) >= this.deps.limit) return false;
 
-    this.deps.inner.register(identity, sender);
+    return this.deps.inner.register(identity, sender);
   }
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void {

package/src/sse-registry-with-logger.adapter.ts

@@ -11,15 +11,17 @@ export class SseRegistryWithLoggerAdapter<Messages extends Message> implements S
 
   constructor(private readonly deps: Dependencies<Messages>) {}
 
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void {
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean {
+    const registered = this.deps.inner.register(identity, sender);
+
     this.deps.Logger.info({
-      message: "SSE sender registered",
-      metadata: { identity },
+      message: registered ? "SSE sender registered" : "SSE sender rejected",
+      metadata: { identity, registered },
       correlationId: CorrelationStorage.get(),
       ...this.base,
     });
 
-    this.deps.inner.register(identity, sender);
+    return registered;
   }
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void {

package/src/sse-registry.adapter.ts

@@ -5,14 +5,22 @@ import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 export class SseRegistryAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   private readonly senders = new Map<HashValueType, Set<SseSenderType<Messages>>>();
 
-  register(identity: HashValueType, connection: SseSenderType<Messages>): void {
+  register(identity: HashValueType, connection: SseSenderType<Messages>): boolean {
     if (!this.senders.has(identity)) this.senders.set(identity, new Set());
 
     this.senders.get(identity)?.add(connection);
+
+    return true;
   }
 
   unregister(identity: HashValueType, connection: SseSenderType<Messages>): void {
-    this.senders.get(identity)?.delete(connection);
+    const senders = this.senders.get(identity);
+
+    if (!senders) return;
+
+    senders.delete(connection);
+
+    if (senders.size === 0) this.senders.delete(identity);
   }
 
   async emit<M extends Messages>(identity: HashValueType, message: M): Promise<void> {

package/src/sse-registry.port.ts

@@ -4,7 +4,7 @@ import type { Message } from "./message.types";
 export type SseSenderType<Messages extends Message> = <M extends Messages>(message: M) => Promise<void>;
 
 export interface SseRegistryPort<Messages extends Message> {
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void;
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean;
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void;
 

package/src/ssr-bun.service.ts

@@ -13,7 +13,7 @@ export class SSRBun {
     const service = new SSRService(deps, config);
 
     return async (request: Request): Promise<Response> => {
-      const nonce = service.nonce;
+      const nonce = service.generateNonce();
 
       const response = await handler(request, nonce);
 

package/src/ssr.service.ts

@@ -33,7 +33,7 @@ export class SSRService {
     private readonly config?: SSRConfig,
   ) {}
 
-  get nonce(): NonceValueType {
+  generateNonce(): NonceValueType {
     return this.deps.NonceProvider.generate();
   }
 

package/src/standard-schema-validator.service.ts

@@ -8,7 +8,7 @@ export class StandardSchemaValidator {
   static validate<Output>(schema: StandardSchemaV1<unknown, Output>, raw: unknown): Output {
     const result = schema["~standard"].validate(raw);
 
-    if (result instanceof Promise) throw new Error(StandardSchemaValidatorError.NoAsyncSchema);
+    if ("then" in result) throw new Error(StandardSchemaValidatorError.NoAsyncSchema);
     if (result.issues) throw new Error(result.issues[0]?.message);
     return result.value;
   }

package/src/static-config.adapter.ts

@@ -4,6 +4,6 @@ export class StaticConfigAdapter<T> implements StaticConfigPort<T> {
   constructor(private readonly value: T) {}
 
   get(): Readonly<T> {
-    return this.value;
+    return Object.freeze(this.value);
   }
 }

package/src/static-files-hono.service.ts

@@ -73,8 +73,8 @@ export class StaticFilesHono {
 
           const contentType = context.res.headers.get("Content-Type");
 
-          if (contentType?.startsWith("text/html")) staticDocumentHeaders(context, noop);
-          else staticAssetHeaders(context, noop);
+          if (contentType?.startsWith("text/html")) await staticDocumentHeaders(context, noop);
+          else await staticAssetHeaders(context, noop);
         },
         etag(),
         serveStatic({ root, precompressed: true, onFound: strategy }),

package/src/subject-application-resolver.vo.ts

@@ -1,7 +1,7 @@
 import type { Hash } from "./hash.vo";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { SubjectSegmentApplicationStrategy } from "./subject-segment-application.strategy";
-import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+import type { SubjectSegmentsRawType } from "./subject-segment-request.strategy";
 
 type Dependencies = { HashContent: HashContentStrategy };
 
@@ -19,8 +19,8 @@ export class SubjectApplicationResolver {
     if (this.segments.length > 10) throw new Error(SubjectApplicationResolverError.TooManySegments);
   }
 
-  async resolve(): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
-    const segments = this.segments.map((segment) => segment.create());
+  async resolve(): Promise<{ hex: Hash; raw: SubjectSegmentsRawType }> {
+    const segments = this.segments.map((segment) => [segment.label, segment.create()] as const);
     const subject = JSON.stringify(segments);
 
     const hex = await this.deps.HashContent.hash(subject);

package/src/subject-request-resolver.vo.ts

@@ -1,7 +1,10 @@
 import type { Hash } from "./hash.vo";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { RequestContext } from "./request-context.port";
-import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+import type {
+  SubjectSegmentRequestStrategy,
+  SubjectSegmentsRawType,
+} from "./subject-segment-request.strategy";
 
 type Dependencies = { HashContent: HashContentStrategy };
 
@@ -19,8 +22,8 @@ export class SubjectRequestResolver {
     if (this.segments.length > 10) throw new Error(SubjectRequestResolverError.TooManySegments);
   }
 
-  async resolve(context: RequestContext): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
-    const segments = this.segments.map((segment) => segment.create(context));
+  async resolve(context: RequestContext): Promise<{ hex: Hash; raw: SubjectSegmentsRawType }> {
+    const segments = this.segments.map((segment) => [segment.label, segment.create(context)] as const);
     const subject = JSON.stringify(segments);
 
     const hex = await this.deps.HashContent.hash(subject);

package/src/subject-segment-application.strategy.ts

@@ -1,7 +1,8 @@
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
-export const SubjectSegmentApplicationEmpty: SubjectSegmentType = "__absent__";
+export const SubjectSegmentApplicationEmpty: SubjectSegmentType = null;
 
 export interface SubjectSegmentApplicationStrategy {
+  readonly label: string;
   create(): SubjectSegmentType;
 }

package/src/subject-segment-build.strategy.ts

@@ -6,6 +6,8 @@ import {
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentBuildStrategy implements SubjectSegmentApplicationStrategy {
+  readonly label = "build";
+
   constructor(private readonly build?: tools.PackageVersion) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-cookie.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentCookieStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly name: string) {}
 
+  get label(): string {
+    return `cookie:${this.name}`;
+  }
+
   create(context: HasRequestCookie): SubjectSegmentType {
     return context.request.cookie(this.name) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-env.strategy.ts

@@ -3,6 +3,8 @@ import type { SubjectSegmentApplicationStrategy } from "./subject-segment-applic
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentEnvStrategy implements SubjectSegmentApplicationStrategy {
+  readonly label = "env";
+
   constructor(private readonly type: NodeEnvironmentEnum) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-fixed.strategy.ts

@@ -4,6 +4,8 @@ import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subjec
 export class SubjectSegmentFixedStrategy
   implements SubjectSegmentRequestStrategy, SubjectSegmentApplicationStrategy
 {
+  readonly label = "fixed";
+
   constructor(private readonly value: string) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-header.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentHeaderStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly name: string) {}
 
+  get label(): string {
+    return `header:${this.name}`;
+  }
+
   create(context: HasRequestHeader): SubjectSegmentType {
     return context.request.header(this.name) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-ip.strategy.ts

@@ -6,6 +6,8 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentIpStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "ip";
+
   create(context: HasIdentityIp): SubjectSegmentType {
     return context.identity.ip() ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-method.strategy.ts

@@ -0,0 +1,10 @@
+import type { HasRequestMethod } from "./request-context.port";
+import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentMethodStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "method";
+
+  create(context: HasRequestMethod): SubjectSegmentType {
+    return context.request.method;
+  }
+}

package/src/subject-segment-param.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentParamStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly param: string) {}
 
+  get label(): string {
+    return `param:${this.param}`;
+  }
+
   create(context: HasRequestParam): SubjectSegmentType {
     return context.request.param(this.param) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-path.strategy.ts

@@ -2,6 +2,8 @@ import type { HasRequestPath } from "./request-context.port";
 import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentPathStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "path";
+
   create(context: HasRequestPath): SubjectSegmentType {
     return context.request.path;
   }

package/src/subject-segment-query.strategy.ts

@@ -1,4 +1,4 @@
-import type { HasRequestQuery } from "./request-context.port";
+import type { HasRequestQueries } from "./request-context.port";
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 import {
   SubjectSegmentRequestEmpty,
@@ -6,14 +6,14 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentQueryStrategy implements SubjectSegmentRequestStrategy {
-  create(context: HasRequestQuery): SubjectSegmentType {
-    const query = context.request.query();
+  readonly label = "query";
 
-    const keys = Object.keys(query).toSorted();
+  create(context: HasRequestQueries): SubjectSegmentType {
+    const queries = context.request.queries();
 
-    const result = keys.map((key) => `${key}=${query[key]}`).join("&");
+    const keys = Object.keys(queries).toSorted();
 
-    if (!result) return SubjectSegmentRequestEmpty;
-    return result;
+    if (keys.length === 0) return SubjectSegmentRequestEmpty;
+    return JSON.stringify(keys.map((key) => [key, queries[key]]));
   }
 }

package/src/subject-segment-request.strategy.ts

@@ -3,23 +3,27 @@ import type {
   HasIdentityUserId,
   HasRequestCookie,
   HasRequestHeader,
+  HasRequestMethod,
   HasRequestParam,
   HasRequestPath,
-  HasRequestQuery,
+  HasRequestQueries,
 } from "./request-context.port";
 
-export type SubjectSegmentType = string;
+export type SubjectSegmentType = string | null;
+export type SubjectSegmentsRawType = ReadonlyArray<readonly [string, SubjectSegmentType]>;
 
-export const SubjectSegmentRequestEmpty: SubjectSegmentType = "__absent__";
+export const SubjectSegmentRequestEmpty: SubjectSegmentType = null;
 
 type RequestContextCapabilities = HasRequestCookie &
   HasRequestHeader &
+  HasRequestMethod &
   HasRequestPath &
-  HasRequestQuery &
+  HasRequestQueries &
   HasRequestParam &
   HasIdentityIp &
   HasIdentityUserId;
 
 export interface SubjectSegmentRequestStrategy {
+  readonly label: string;
   create(context: RequestContextCapabilities): SubjectSegmentType;
 }

package/src/subject-segment-user.strategy.ts

@@ -6,6 +6,8 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentUserStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "user";
+
   create(context: HasIdentityUserId): SubjectSegmentType {
     return context.identity.userId() ?? SubjectSegmentRequestEmpty;
   }