@xfcfam/xf-server-http 0.1.0

package/dist/src/api/utils/SseUtils.d.ts

@@ -0,0 +1,57 @@
+import type { HttpResponse } from '../../business/transfers/HttpResponse.js';
+/**
+ * A single Server-Sent Event. `data` is sent as-is when a string, or
+ * JSON-encoded when an object. The optional fields map to the SSE
+ * wire fields (`event:`, `id:`, `retry:`).
+ */
+export interface ServerSentEvent {
+    /** Event payload. Strings are sent verbatim; objects are JSON-encoded. */
+    readonly data: string | object;
+    /** Named event type (`event:` field). */
+    readonly event?: string;
+    /** Event id (`id:` field) — clients echo it as `Last-Event-ID` on reconnect. */
+    readonly id?: string;
+    /** Reconnection hint in milliseconds (`retry:` field). */
+    readonly retry?: number;
+}
+/**
+ * Interaction-Layer Utility — turn an async stream of events into a
+ * `text/event-stream` {@link HttpResponse}.
+ *
+ * SSE is plain HTTP (a long-lived `GET` whose body is a stream), so it
+ * needs no plugin and works on any `RestService`. This helper does the
+ * tedious part: setting the right headers and formatting each event per
+ * the SSE wire protocol (multi-line `data:`, `event:`, `id:`, `retry:`,
+ * blank-line terminator).
+ *
+ * @example
+ * ```ts
+ * import { RestService, SseUtils } from '@xfcfam/xf-server-http'
+ *
+ * export class ClockService extends RestService {
+ *   override async init() { B.server.get('/clock', this.wrap(this.clock)) }
+ *
+ *   private async clock(): Promise<HttpResponse> {
+ *     async function* ticks() {
+ *       while (true) {
+ *         yield { event: 'tick', data: { now: Date.now() } }
+ *         await new Promise((r) => setTimeout(r, 1000))
+ *       }
+ *     }
+ *     return SseUtils.stream(ticks())
+ *   }
+ * }
+ * ```
+ */
+export declare class SseUtils {
+    private constructor();
+    /**
+     * Build a streaming `text/event-stream` response from an async
+     * iterable of events. The stream stays open until the source is
+     * exhausted or the client disconnects.
+     */
+    static stream(source: AsyncIterable<ServerSentEvent>, headers?: Readonly<Record<string, string>>): HttpResponse<ReadableStream<Uint8Array>>;
+    /** Format a single event into its SSE wire representation. */
+    static format(event: ServerSentEvent): string;
+}
+//# sourceMappingURL=SseUtils.d.ts.map

package/dist/src/api/utils/SseUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseUtils.d.ts","sourceRoot":"","sources":["../../../../src/api/utils/SseUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAA;AAE5E;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,gFAAgF;IAChF,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,QAAQ;IACnB,OAAO;IAEP;;;;OAIG;IACH,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,aAAa,CAAC,eAAe,CAAC,EACtC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACzC,YAAY,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IA0B3C,8DAA8D;IAC9D,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM;CAS9C"}

package/dist/src/api/utils/SseUtils.js

@@ -0,0 +1,78 @@
+/**
+ * Interaction-Layer Utility — turn an async stream of events into a
+ * `text/event-stream` {@link HttpResponse}.
+ *
+ * SSE is plain HTTP (a long-lived `GET` whose body is a stream), so it
+ * needs no plugin and works on any `RestService`. This helper does the
+ * tedious part: setting the right headers and formatting each event per
+ * the SSE wire protocol (multi-line `data:`, `event:`, `id:`, `retry:`,
+ * blank-line terminator).
+ *
+ * @example
+ * ```ts
+ * import { RestService, SseUtils } from '@xfcfam/xf-server-http'
+ *
+ * export class ClockService extends RestService {
+ *   override async init() { B.server.get('/clock', this.wrap(this.clock)) }
+ *
+ *   private async clock(): Promise<HttpResponse> {
+ *     async function* ticks() {
+ *       while (true) {
+ *         yield { event: 'tick', data: { now: Date.now() } }
+ *         await new Promise((r) => setTimeout(r, 1000))
+ *       }
+ *     }
+ *     return SseUtils.stream(ticks())
+ *   }
+ * }
+ * ```
+ */
+export class SseUtils {
+    constructor() { }
+    /**
+     * Build a streaming `text/event-stream` response from an async
+     * iterable of events. The stream stays open until the source is
+     * exhausted or the client disconnects.
+     */
+    static stream(source, headers) {
+        const encoder = new TextEncoder();
+        const body = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const event of source) {
+                        controller.enqueue(encoder.encode(SseUtils.format(event)));
+                    }
+                    controller.close();
+                }
+                catch (err) {
+                    controller.error(err);
+                }
+            },
+        });
+        return {
+            status: 200,
+            headers: {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                'connection': 'keep-alive',
+                ...headers,
+            },
+            body,
+        };
+    }
+    /** Format a single event into its SSE wire representation. */
+    static format(event) {
+        const lines = [];
+        if (event.event !== undefined)
+            lines.push(`event: ${event.event}`);
+        if (event.id !== undefined)
+            lines.push(`id: ${event.id}`);
+        if (event.retry !== undefined)
+            lines.push(`retry: ${event.retry}`);
+        const data = typeof event.data === 'string' ? event.data : JSON.stringify(event.data);
+        for (const line of data.split('\n'))
+            lines.push(`data: ${line}`);
+        return `${lines.join('\n')}\n\n`;
+    }
+}
+//# sourceMappingURL=SseUtils.js.map

package/dist/src/api/utils/SseUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SseUtils.js","sourceRoot":"","sources":["../../../../src/api/utils/SseUtils.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,QAAQ;IACnB,gBAAuB,CAAC;IAExB;;;;OAIG;IACH,MAAM,CAAC,MAAM,CACX,MAAsC,EACtC,OAA0C;QAE1C,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;QACjC,MAAM,IAAI,GAAG,IAAI,cAAc,CAAa;YAC1C,KAAK,CAAC,KAAK,CAAC,UAAU;gBACpB,IAAI,CAAC;oBACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;wBACjC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;oBAC5D,CAAC;oBACD,UAAU,CAAC,KAAK,EAAE,CAAA;gBACpB,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;gBACvB,CAAC;YACH,CAAC;SACF,CAAC,CAAA;QACF,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE;gBACP,cAAc,EAAE,mBAAmB;gBACnC,eAAe,EAAE,UAAU;gBAC3B,YAAY,EAAE,YAAY;gBAC1B,GAAG,OAAO;aACX;YACD,IAAI;SACL,CAAA;IACH,CAAC;IAED,8DAA8D;IAC9D,MAAM,CAAC,MAAM,CAAC,KAAsB;QAClC,MAAM,KAAK,GAAa,EAAE,CAAA;QAC1B,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,UAAU,KAAK,CAAC,KAAK,EAAE,CAAC,CAAA;QAClE,IAAI,KAAK,CAAC,EAAE,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,CAAC,EAAE,EAAE,CAAC,CAAA;QACzD,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,UAAU,KAAK,CAAC,KAAK,EAAE,CAAC,CAAA;QAClE,MAAM,IAAI,GAAG,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACrF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAAE,KAAK,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;QAChE,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;IAClC,CAAC;CACF"}

package/dist/src/business/B.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Business Layer Injection — placeholder.
+ *
+ * `B` is the canonical injection of the Business Layer. `@xfcfam/xf-server`
+ * is a library that contributes Generalizations and Transfer objects to
+ * the Interaction Layer ( `ObjectRestService`,
+ * `HttpServerBusiness`); it does not own any Logical of this layer, so
+ * its own `B` declares no static slots. The class is kept structurally
+ * complete (private constructor + empty `init` / `terminate`) so the
+ * artefact passes XF validation. It is NOT exported from the package —
+ * consumers import `B` from their own artefact.
+ */
+export declare class B {
+    private constructor();
+    static init(): Promise<void>;
+    static terminate(): Promise<void>;
+}
+//# sourceMappingURL=B.d.ts.map

package/dist/src/business/B.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"B.d.ts","sourceRoot":"","sources":["../../../src/business/B.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,CAAC;IACZ,OAAO;WACM,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WACrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CACxC"}

package/dist/src/business/B.js

@@ -0,0 +1,18 @@
+/**
+ * Business Layer Injection — placeholder.
+ *
+ * `B` is the canonical injection of the Business Layer. `@xfcfam/xf-server`
+ * is a library that contributes Generalizations and Transfer objects to
+ * the Interaction Layer ( `ObjectRestService`,
+ * `HttpServerBusiness`); it does not own any Logical of this layer, so
+ * its own `B` declares no static slots. The class is kept structurally
+ * complete (private constructor + empty `init` / `terminate`) so the
+ * artefact passes XF validation. It is NOT exported from the package —
+ * consumers import `B` from their own artefact.
+ */
+export class B {
+    constructor() { }
+    static async init() { }
+    static async terminate() { }
+}
+//# sourceMappingURL=B.js.map

package/dist/src/business/B.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"B.js","sourceRoot":"","sources":["../../../src/business/B.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,CAAC;IACZ,gBAAuB,CAAC;IACxB,MAAM,CAAC,KAAK,CAAC,IAAI,KAAmB,CAAC;IACrC,MAAM,CAAC,KAAK,CAAC,SAAS,KAAmB,CAAC;CAC3C"}

package/dist/src/business/general/HttpServerBusiness.d.ts

@@ -0,0 +1,190 @@
+import { ServerBusiness, type ServerState } from '@xfcfam/xf-server';
+import { type FastifyInstance } from 'fastify';
+import type { HttpRequest } from '../transfers/HttpRequest.js';
+import type { HttpResponse } from '../transfers/HttpResponse.js';
+import type { HttpMethod } from '../transfers/HttpMethod.js';
+import type { HttpAddress, HttpHandler } from '../transfers/Route.js';
+import type { WebSocketHandler } from '../transfers/WebSocketConnection.js';
+import type { GraphQLConfig } from '../transfers/GraphQLConfig.js';
+/** Internal record of a WebSocket endpoint pushed before `listen()`. */
+interface WsRoute {
+    readonly path: string;
+    readonly handler: WebSocketHandler;
+}
+/**
+ * Multipart upload configuration. Forwarded verbatim to
+ * `@fastify/multipart` (consult its docs for the full list). The most
+ * common knobs:
+ *
+ * - `maxFileSize`: per-file size limit in bytes (Fastify default 1 MiB).
+ * - `maxFiles`: maximum number of file parts per request.
+ * - `maxFields`: maximum number of non-file fields.
+ * - `maxFieldsSize`: total size limit for non-file fields.
+ */
+export interface MultipartConfig {
+    readonly maxFileSize?: number;
+    readonly maxFiles?: number;
+    readonly maxFields?: number;
+    readonly maxFieldsSize?: number;
+}
+/**
+ * Configuration accepted by {@link HttpServerBusiness}'s constructor.
+ */
+export interface ServerOptions {
+    /** TCP port to bind. */
+    readonly port: number;
+    /** Host to bind. Default `'0.0.0.0'`. */
+    readonly host?: string;
+    /**
+     * Opt-in `multipart/form-data` support. Pass `true` for defaults or
+     * a config object to tune limits.
+     *
+     * When enabled, the server activates multipart handling at `listen()`
+     * time and, for any request whose `Content-Type` is
+     * `multipart/form-data`, populates `req.body` with a
+     * `MultipartPart[]`. All underlying machinery is shipped as part
+     * of xf-server-http — the consumer does not install or import any
+     * extra package.
+     */
+    readonly multipart?: boolean | MultipartConfig;
+}
+/**
+ * Concrete server state: the abstract route registry plus the Fastify
+ * instance and the bind options.
+ */
+interface HttpServerState extends ServerState<HttpAddress, HttpRequest, HttpResponse> {
+    readonly options: ServerOptions;
+    /** The running Fastify instance; `undefined` before `listen()` and after `close()`. */
+    fastify: FastifyInstance | undefined;
+    /** WebSocket endpoints pushed via `ws()` before `listen()`. */
+    readonly wsRoutes: WsRoute[];
+    /** GraphQL endpoint pushed via `graphql()`, if any. */
+    graphql: GraphQLConfig | undefined;
+}
+/**
+ * Business-Layer Generalization for the artefact-level HTTP server
+ * orchestrator — the Fastify implementation of the transport-agnostic
+ * {@link ServerBusiness} contract from `@xfcfam/xf-server`.
+ *
+ * It is **technology-aware** (Fastify, HTTP) by design: the Business
+ * Layer in XF is the correct home for infrastructure concerns that are
+ * not domain rules — the HTTP server is infrastructure, not domain
+ * logic. The route registry and the request pipeline come from the
+ * core; this class supplies the HTTP address scheme (`{ method, path }`),
+ * the Fastify lifecycle (`listen` / `close`), body collection
+ * (including multipart) and the error → HTTP-status mapping.
+ *
+ * **Registration model — push, not pull.** Interaction Services register
+ * their routes by calling `B.server.get(path, handler)` (or `post`,
+ * `put`, `patch`, `del`, `call`) from within their own `init()`. The
+ * server MUST be created and available on `B` before `A.init()` runs;
+ * `listen()` is called by the start-point AFTER all services have
+ * registered.
+ *
+ * **Handler contract.** Handlers are `HttpHandler` functions
+ * (`(req: HttpRequest) => Promise<HttpResponse> | HttpResponse`). The
+ * server calls them with an `HttpRequest` whose `body` is the raw
+ * bytes/stream (or a `MultipartPart[]` for multipart requests).
+ * Serialisation (object → bytes) and parsing (bytes → object) are the
+ * Interaction Layer's responsibility — see `ObjectRestService.object()`.
+ *
+ * @example
+ * ```ts
+ * // business/logic/AppServerBusiness.ts
+ * import { HttpServerBusiness, type HttpRequest } from '@xfcfam/xf-server-http'
+ *
+ * export class AppServerBusiness extends HttpServerBusiness {
+ *   constructor() {
+ *     super({ port: Number.parseInt(process.env['PORT'] ?? '3000', 10) })
+ *   }
+ *
+ *   override async onRequest(req: HttpRequest): Promise<HttpRequest> {
+ *     console.log(`[server] → ${req.method} ${req.path}`)
+ *     return req
+ *   }
+ * }
+ *
+ * // business/B.ts
+ * export class B {
+ *   private constructor() {}
+ *   static readonly server = new AppServerBusiness()
+ *   static async init()      { await B.server.init() }
+ *   static async terminate() { await B.server.terminate() }
+ * }
+ *
+ * // main.ts (start-point): once the XF element has bootstrapped the
+ * // layers R → B → A and the services have pushed their routes, start
+ * // the transport explicitly:
+ * await B.server.listen()    // start Fastify after all routes are in
+ * // ...and on shutdown, before the XF element tears the layers down:
+ * await B.server.close()
+ * ```
+ */
+export declare abstract class HttpServerBusiness extends ServerBusiness<HttpAddress, HttpRequest, HttpResponse, HttpServerState> {
+    constructor(options: ServerOptions);
+    /** Register a GET endpoint. */
+    get(path: string, handler: HttpHandler): void;
+    /** Register a POST endpoint. */
+    post(path: string, handler: HttpHandler): void;
+    /** Register a PUT endpoint. */
+    put(path: string, handler: HttpHandler): void;
+    /** Register a PATCH endpoint. */
+    patch(path: string, handler: HttpHandler): void;
+    /** Register a DELETE endpoint. */
+    del(path: string, handler: HttpHandler): void;
+    /**
+     * Register an endpoint for an arbitrary HTTP method. Used for
+     * `HEAD`, `OPTIONS`, or any verb not covered by the convenience
+     * helpers.
+     */
+    call(method: HttpMethod, path: string, handler: HttpHandler): void;
+    /**
+     * Register a WebSocket endpoint. The handler receives a
+     * {@link WebSocketConnection} once the client upgrade completes. The
+     * WebSocket plugin runs on the same Fastify instance and port as the
+     * REST routes; like every registration, call this before `listen()`.
+     */
+    ws(path: string, handler: WebSocketHandler): void;
+    /**
+     * Register a GraphQL endpoint (schema + resolvers). The GraphQL
+     * engine (Mercurius) is mounted on the shared Fastify instance at
+     * `config.path` (default `/graphql`). At most one GraphQL endpoint per
+     * server; a later call replaces the earlier config.
+     */
+    graphql(config: GraphQLConfig): void;
+    /**
+     * Start accepting requests. Creates the Fastify instance, registers
+     * multipart support if configured, mounts every route that has been
+     * pushed so far, and begins listening.
+     *
+     * Call this from the start-point AFTER the Interaction layer has
+     * registered all routes — no new routes should be pushed after this
+     * point.
+     */
+    listen(): Promise<void>;
+    /**
+     * Stop accepting requests and release the Fastify instance. Waits
+     * for in-flight requests to complete before resolving.
+     */
+    close(): Promise<void>;
+    /**
+     * Get the underlying Fastify instance. Throws if `listen()` hasn't
+     * run. Exposed so protocol extensions (WebSocket, GraphQL) can
+     * register their plugins on the same instance.
+     */
+    protected fastifyInstance(): FastifyInstance;
+    private adapter;
+    private static request;
+    private static collectMultipart;
+    private static collectNodeStream;
+    private static registerMultipart;
+    private static registerWebSocket;
+    private static adaptSocket;
+    private static toFrame;
+    private static registerGraphQL;
+    private static sendResponse;
+    private static errorToResponse;
+    private static isReadableStream;
+}
+export {};
+//# sourceMappingURL=HttpServerBusiness.d.ts.map

package/dist/src/business/general/HttpServerBusiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpServerBusiness.d.ts","sourceRoot":"","sources":["../../../../src/business/general/HttpServerBusiness.ts"],"names":[],"mappings":"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"}