@decohere/http 0.0.1-dev.126 → 0.0.1-dev.5

package/types/src/routing/services/route-registry.d.ts

@@ -1,20 +0,0 @@
-import type { Constructable } from "@decohere/core/reflection";
-import type { HttpOptions } from "../../http/http.options.js";
-import type { MappedRoute } from "../anvil.types.js";
-export declare class RouteRegistry {
-    private readonly routeMap;
-    private readonly httpOptions?;
-    constructor(httpOptions?: HttpOptions);
-    addController(controller: Constructable): void;
-    get routes(): MapIterator<MappedRoute>;
-    getRoute(key: string): MappedRoute;
-    private addControllerRoute;
-    /** `@Controller({ globalPrefix: false })` opts out, unless the app put it back under. */
-    private takesGlobalPrefix;
-    private getControllerPrefix;
-    private getRouteArguments;
-    private getRouteArgument;
-    private getFields;
-    private enrichField;
-    private getDefaultPipes;
-}

package/types/src/routing/services/router.d.ts

@@ -1,22 +0,0 @@
-import { type LifetimeScope } from "@decohere/crucible";
-import type { IAuthorizationService } from "../../auth/auth.types.js";
-import type { HttpOptions } from "../../http/http.options.js";
-import type { HttpRequest } from "../anvil.types.js";
-import { RouteRegistry } from "./route-registry.js";
-export declare class Router {
-    private readonly argResolver;
-    private readonly lifetimeScope;
-    private readonly routeRegistry;
-    private readonly authService?;
-    private readonly httpOptions?;
-    private readonly logger;
-    constructor(routeRegistry: RouteRegistry, lifetimeScope: LifetimeScope, authService?: IAuthorizationService, httpOptions?: HttpOptions);
-    /**
-     * Without an authorization service nothing checks tokens, so a route marked @Authorize
-     * would be served to anyone. Refuse to start instead of failing open.
-     */
-    private assertAuthConfiguredForProtectedRoutes;
-    route(routeKey: string, httpRequest: HttpRequest): Promise<any>;
-    private resolveMiddlewares;
-    private authorize;
-}

package/types/src/sse/sse.decorator.d.ts

@@ -1,17 +0,0 @@
-import type { SseOptions } from "./sse.types.js";
-/**
- * Mark a route as a server-sent event stream. The method returns an `AsyncIterable` of
- * {@link SseMessage}s (an `async *` method is the usual shape) and the HTTP package writes it as
- * `text/event-stream`. Auth, validation and middleware run first, exactly as on any route,
- * so an unauthorised caller gets a normal 401/403 and no event is ever sent.
- *
- * Combine with `@Get()` (EventSource only issues GET).
- */
-export declare function Sse(options?: SseOptions): (_target: object, _methodName: string, descriptor: PropertyDescriptor) => void;
-/**
- * Inject an `AbortSignal` that aborts when the client disconnects or the app stops. Pass it to
- * whatever the producer waits on (timers, subscriptions, queries) so it stops promptly.
- */
-export declare const Signal: () => (target: object, propertyKey: string, parameterIndex: number) => void;
-/** Inject the `Last-Event-ID` header the browser sends when it reconnects, or `undefined`. */
-export declare const LastEventId: () => (target: object, propertyKey: string, parameterIndex: number) => void;

package/types/src/sse/sse.encoder.d.ts

@@ -1,16 +0,0 @@
-export type SseEncodeOptions = {
-    /** Aborted when the client disconnects or the app stops. */
-    signal: AbortSignal;
-    heartbeatMs: number;
-    /**
-     * Called once, as the stream ends, with a promise that settles when the producer has
-     * actually stopped (its `finally` blocks have run).
-     */
-    onProducerStopped: (stopped: Promise<void>) => void;
-};
-/**
- * Turn the handler's events into SSE text. Writes an opening comment so the browser sees the
- * response headers at once, a heartbeat whenever the producer is quiet, and stops as soon as the
- * signal aborts, without waiting for a producer that is stuck.
- */
-export declare function encodeSse(source: AsyncIterable<unknown>, options: SseEncodeOptions): AsyncGenerator<string>;

package/types/src/sse/sse.types.d.ts

@@ -1,37 +0,0 @@
-/**
- * One server-sent event. A bare `string` yielded by a handler is shorthand for `{ data }`.
- *
- * `data` is written as-is when it is a string and as JSON otherwise.
- */
-export type SseMessage<T = unknown> = {
-    data: T;
-    /** Becomes the `event:` field; the browser dispatches it to `addEventListener(event, ...)`. */
-    event?: string;
-    /** Becomes the `id:` field; the browser sends the last one back as `Last-Event-ID` on reconnect. */
-    id?: string;
-    /** Tells the browser how many milliseconds to wait before reconnecting. */
-    retry?: number;
-};
-/** What a `@Sse()` handler returns: any async iterable of messages (an `async *` method is the usual shape). */
-export type SseStream<T = unknown> = AsyncIterable<SseMessage<T> | string>;
-export type SseOptions = {
-    /**
-     * Milliseconds of silence before the HTTP package writes a `: heartbeat` comment, which keeps proxies
-     * and load balancers from closing an idle connection. Default 15000. `0` turns heartbeats off.
-     */
-    heartbeatMs?: number;
-};
-export declare const DEFAULT_SSE_HEARTBEAT_MS = 15000;
-/**
- * What the router hands the HTTP provider for an `@Sse()` route. The request-scoped services the
- * handler uses must stay alive for as long as the stream runs, so the provider calls `release()`
- * once the stream is over, instead of the router disposing them as soon as the handler returns.
- */
-export declare class SseResponse {
-    readonly events: AsyncIterable<unknown>;
-    private readonly onRelease;
-    private released;
-    constructor(events: AsyncIterable<unknown>, onRelease: () => Promise<void>);
-    /** Safe to call more than once. */
-    release(): Promise<void>;
-}

package/types/src/sse/sse.wire.d.ts

@@ -1,9 +0,0 @@
-/** Encode one event as the text a browser's `EventSource` parses. */
-declare function formatMessage(item: unknown): string;
-/** A comment line: ignored by `EventSource`, but it is traffic on the wire. */
-declare function formatComment(text: string): string;
-export declare const sseWire: {
-    formatMessage: typeof formatMessage;
-    formatComment: typeof formatComment;
-};
-export {};

package/types/src/testing/boot-module.d.ts

@@ -1,34 +0,0 @@
-import type { ContainerBuilder } from "@decohere/crucible";
-import type { Constructable } from "@decohere/core/reflection";
-import type { App } from "../app/app.js";
-import { Builder } from "../builder/builder.js";
-import "../http/http.extensions.js";
-import type { HttpProvider } from "../routing/anvil.types.js";
-import { type EventStreamRead, type ReadEventsOptions } from "./sse-reader.js";
-export type BootModuleOptions = {
-    controllers: Constructable[];
-    /** Register services the controllers need. */
-    services?: (containerBuilder: ContainerBuilder) => void;
-    /** Add anything else to the builder (`withAuth()`, `withOpenApi()`, ...) before the app is built. */
-    configure?: (builder: Builder) => unknown;
-    /** Defaults to the Fastify provider. */
-    provider?: Constructable<HttpProvider>;
-};
-export type BootedModule = AsyncDisposable & {
-    app: App;
-    /** Origin of the listening app, e.g. `http://127.0.0.1:41233`. */
-    baseUrl: string;
-    /** `GET path` as an `EventSource` would, and collect the first `count` events. */
-    readEvents(path: string, options?: ReadEventsOptions): Promise<EventStreamRead>;
-    /** Stop the app (closing any open streams). Same as `await using`. */
-    stop(): Promise<void>;
-};
-/**
- * Boot the given controllers as a real app on a free loopback port, so a test can call it over
- * HTTP. The app runs the full pipeline: routing, auth, middleware, and the real provider.
- *
- * @example
- * await using api = await bootModule({ controllers: [PriceController] });
- * const { events } = await api.readEvents("/prices/stream", { count: 3 });
- */
-export declare function bootModule(options: BootModuleOptions): Promise<BootedModule>;

package/types/src/testing/sse-reader.d.ts

@@ -1,29 +0,0 @@
-export type ReceivedEvent = {
-    /** The `data:` lines joined with `\n`, as `EventSource` would give them. */
-    data: string;
-    event?: string;
-    id?: string;
-    retry?: number;
-};
-export type EventStreamRead = {
-    status: number;
-    headers: Headers;
-    /** The events received, at most the requested count. */
-    events: ReceivedEvent[];
-    /** Comment lines (`: heartbeat` and the like) seen before the read ended. */
-    comments: string[];
-    /** True when the server ended the stream (as opposed to the reader stopping at the count). */
-    ended: boolean;
-};
-export type ReadEventsOptions = {
-    /** Stop and close the connection after this many events. Default 1. `Infinity` reads until the server ends the stream. */
-    count?: number;
-    headers?: Record<string, string>;
-    /** Give up (and fail) if the read has not finished after this many milliseconds. Default 5000. */
-    timeoutMs?: number;
-};
-/**
- * GET `url` as an `EventSource` would and collect events until `count` have arrived or the
- * server ends the stream. A non-200 answer (401, 403, ...) returns at once with no events.
- */
-export declare function readEventStream(url: string, options?: ReadEventsOptions): Promise<EventStreamRead>;