@interopio/gateway-server 0.7.0-beta → 0.8.0-beta

package/types/web/server.d.ts

@@ -1,13 +1,18 @@
 import type {
-    HttpCookie,
     HttpMethod,
+    HttpInputMessage,
     HttpRequest,
     HttpResponse,
+    HttpOutputMessage,
+    HttpStatusCode,
     MutableHttpHeaders,
-    ReadonlyHttpHeaders
+    ReadonlyHttpHeaders,
+    ResponseCookie
 } from './http';
-import type {WebSocketHandler} from './ws';
+import type {WebSocketHandler} from './socket';
 import type {Principal, AuthorizationRule} from '../auth';
+import {AsyncLocalStorage} from 'node:async_hooks';
+import type {AddressInfo} from 'node:net';
 import {IOGateway} from '@interopio/gateway';
 
 export type OriginFilters = {
@@ -60,7 +65,7 @@ export type ServerWebSocketHandler = WebSocketHandler & {
 
 export type ServerConfigurerSocketSpec = {
     path?: string, options?: ServerWebSocketOptions
-    factory: (server: { endpoint: string }) => Promise<ServerWebSocketHandler>,
+    factory: (server: { endpoint: string, storage?: AsyncLocalStorage<{ }> }) => Promise<ServerWebSocketHandler>,
 }
 
 export interface ServerConfigurer {
@@ -74,35 +79,40 @@ export type Middleware<Request extends ServerHttpRequest = ServerHttpRequest, Re
 export type ServerWebExchange<Request extends ServerHttpRequest = ServerHttpRequest, Response extends ServerHttpResponse = ServerHttpResponse> = {
     readonly request: Request
     readonly response: Response;
+    attribute<T>(key: string): T | undefined;
     principal<P extends Principal>(): Promise<P | undefined>;
+    readonly logPrefix: string;
 }
 
-export type ResponseCookie = HttpCookie & {
-    maxAge: number,
-    domain?: string,
-    path?: string,
-    secure?: boolean,
-    httpOnly?: boolean,
-    sameSite?: 'strict' | 'lax' | 'none'
+export interface ServerWebExchangeBuilder<Request extends ServerHttpRequest = ServerHttpRequest, Response extends ServerHttpResponse = ServerHttpResponse> {
+    request(request: Request): this
+    response(response: Response): this
+    principal(principal: () => Promise<Principal>): this
+    build(): ServerWebExchange<Request, Response>
 }
 
-export type ServerHttpRequest = HttpRequest<ReadonlyHttpHeaders> & {
-    readonly cookies: HttpCookie[]
-    readonly formData: Promise<URLSearchParams>
-    // readonly text: Promise<string>
-    readonly json: Promise<unknown>
-    // readonly socket: http.IncomingMessage['socket']
-    // readonly _req: http.IncomingMessage
+
+export type ServerHttpRequest = HttpRequest<ReadonlyHttpHeaders> & HttpInputMessage<ReadonlyHttpHeaders> & {
+    readonly id: string
+    readonly path: string,
+    readonly protocol: string
+    /**
+     * hostname[:port]
+     */
+    readonly host?: string
+
+    formData(): Promise<URLSearchParams>
+    text(): Promise<string>
+    json(): Promise<unknown>
+
     readonly upgrade: boolean
+    readonly remoteAddress?: AddressInfo
 }
 
-export interface ServerHttpResponse extends HttpResponse<MutableHttpHeaders> {
-    statusCode: number
-    statusMessage?: string
-
-    readonly cookies: ResponseCookie[]
+export interface ServerHttpResponse extends HttpResponse<MutableHttpHeaders>, HttpOutputMessage<MutableHttpHeaders> {
+    readonly statusCode: HttpStatusCode
+    setStatusCode(statusCode: HttpStatusCode): boolean
 
     addCookie(cookie: ResponseCookie): this
 
-    end(chunk?: unknown): Promise<boolean>
 }

package/types/web/{ws.d.ts → socket.d.ts}

@@ -1,19 +1,21 @@
 import type {WebSocket} from 'ws';
 import type {ReadonlyHttpHeaders, HttpCookie} from './http';
 import type {Principal} from '../auth';
+import type {AddressInfo} from 'node:net';
 
 type WebSocketHandshakeInfo = {
     readonly url: URL;
+    readonly protocol?: string;
 
     // request headers for server and response headers for client
     readonly headers: ReadonlyHttpHeaders;
     readonly cookies: ReadonlyArray<HttpCookie>;
     principal<P extends Principal>(): Promise<P | undefined>;
-    readonly protocol?: string;
-    readonly remoteAddress?: string;
-    readonly remoteFamily?: string;
-    readonly remotePort?: number;
+    readonly remoteAddress?: AddressInfo;
     readonly logPrefix?: string;
 }
-
-type WebSocketHandler = (socket: WebSocket, handshake: WebSocketHandshakeInfo) => Promise<void>
+type WebSocketSession = {
+    socket: WebSocket;
+    handshake: WebSocketHandshakeInfo;
+};
+type WebSocketHandler = (session: WebSocketSession) => Promise<void>

package/types/web/test.d.ts

@@ -0,0 +1,14 @@
+import {GatewayServer} from '../../gateway-server';
+
+export interface TestClient {
+    readonly fetch: (input: string | URL, init?: RequestInit) => Promise<Response>;
+}
+
+export interface TestClientBuilder {
+    build(): Promise<TestClient>;
+}
+
+
+declare const TestClient: {
+    bindToApp(app: GatewayServer.ServerCustomizer): TestClientBuilder
+}