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

package/gateway-server.d.ts

@@ -1,43 +1,17 @@
 import {IOGateway} from '@interopio/gateway';
-import {FilePublisherConfig} from '@interopio/gateway/metrics/publisher/file';
-
+import type {ServerCorsConfig, ServerConfigurer, ServerWebSocketOptions} from './types/web/server';
 export default GatewayServer.Factory;
 
 export namespace GatewayServer {
     export const Factory: (options: ServerConfig) => Promise<Server>
-    export type SslConfig = { key?: string, cert?: string, ca?: string }
-    export type AuthorizationRule = { access: 'permitted' | 'denied' | 'authenticated' }
-    export type OriginFilters = {
-        non_matched?: IOGateway.Filtering.Action
-        missing?: IOGateway.Filtering.Action
-        block?: IOGateway.Filtering.Matcher[]
-        allow?: IOGateway.Filtering.Matcher[]
-        /**
-         * @deprecated
-         * @see block
-         */
-        blacklist?: IOGateway.Filtering.Matcher[]
-        /**
-         * @deprecated
-         * @see allow
-         */
-        whitelist?: IOGateway.Filtering.Matcher[]
-    }
+    export type SslConfig = Readonly<{ key?: string, cert?: string, ca?: string }>
+
     export import LoggerConfig = IOGateway.Logging.LogConfig;
     export type AuthConfig = Readonly<{
         type: 'none' | 'basic' | 'oauth2',
         basic?: { user?: {name: string, password?: string}, realm?: string }
         oauth2?: { jwt: { issuerUri: string, issuer?: string, audience?: string | string[] } }
     }>;
-    export type CorsConfig = Readonly<{
-        allowOrigin?: '*' | IOGateway.Filtering.Matcher[]
-        allowHeaders?: string[]
-        allowMethods?: string[]
-        exposeHeaders?: string[]
-        allowCredentials?: boolean
-        allowPrivateNetwork?: boolean
-        maxAge?: number
-    }>;
 
     export type ServerConfig = {
         /**
@@ -58,7 +32,7 @@ export namespace GatewayServer {
         /**
          * CORS configuration.
          */
-        cors?: CorsConfig,
+        cors?: ServerCorsConfig,
 
         memory?: {
             memory_limit?: number
@@ -68,24 +42,12 @@ export namespace GatewayServer {
             max_backups?: number,
         },
 
-        gateway?: IOGateway.GatewayConfig & {
+        app?: (configurer: ServerConfigurer, config: ServerConfig) => Promise<void>,
+        gateway?: IOGateway.GatewayConfig & ServerWebSocketOptions & {
             route?: string
-            ping?: number
-            origins?: OriginFilters
-            limits?: {
-                max_connections?: number
-            },
-            authorize?: AuthorizationRule
-        }
-        mesh?: {
+        },
+        mesh?: ServerWebSocketOptions & {
             timeout?: number // defaults to 60000
-            ping?: number // defaults to 30000
-            authorize?: AuthorizationRule
-            origins?: OriginFilters
-        }
-        metrics?: {
-            file: FilePublisherConfig
-            authorize?: AuthorizationRule
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@interopio/gateway-server",
-    "version": "0.6.1-beta",
+    "version": "0.7.0-beta",
     "keywords": [
         "gateway",
         "server",
@@ -32,6 +32,12 @@
             "node": "./dist/index.cjs",
             "require": "./dist/index.cjs"
         },
+        "./auth/api": {
+            "types": "./types/auth.d.ts"
+        },
+        "./web/server": {
+            "types": "./types/web/server.d.ts"
+        },
         "./metrics/publisher/rest": {
             "import": "./dist/metrics/publisher/rest.js",
             "node": "./dist/metrics/publisher/rest.cjs",
@@ -50,11 +56,11 @@
     "types": "gateway-server.d.ts",
     "type": "module",
     "engines": {
-        "node": ">=20"
+        "node": ">=20.10 || >= 22.12 || >= 24"
     },
     "dependencies": {
-        "@interopio/gateway": "^0.11.0-beta",
-        "ws": "^8.18.2",
+        "@interopio/gateway": "^0.11.1-beta",
+        "ws": "^8.18.3",
         "http-cookie-agent": "^7.0.1",
         "undici": "^6.21.3",
         "tough-cookie": "^5.1.2"

package/readme.md

@@ -28,9 +28,32 @@ const server: Server = await GatewayServer({
         ca: "intermediate.crt",
         key: "glue42.key"
     },
-    metrics: {
-        access: 'permitted'
-    }
+    app: async (configurer) => {
+        configurer
+            .authorize(['/api/metrics', {access: 'permitted'}]) // or 'authenticated'
+            .cors(['/api/metrics', {allowMethods: ['GET', 'POST']}]) // ensure 'GET' and 'POST' methods are allowed for CORS
+            .handle(
+                [
+                    {method: 'GET', path: '/api/metrics'},
+                    async ({response}) => {
+                        response.statusCode = 200; // OK
+                        await response.end();
+                    }
+                ],
+                [
+                    {method: 'POST', path: '/api/metrics'},
+                    async ({request, response}) => {
+                        response.statusCode = 202; // Accepted
+                        await response.end();
+                        try {
+                            const update = await request.json();
+                            console.log(`${JSON.stringify(update)}`);
+                        } catch (e) {
+                            console.error('Error processing metrics:', e);
+                        }
+                    }
+                ]);
+    },
 });
 
 await server.close();

package/types/auth.d.ts

@@ -0,0 +1,5 @@
+export type Principal = {
+    readonly name?: string
+}
+
+export type AuthorizationRule = { access: 'permitted' | 'denied' | 'authenticated' }

package/types/web/http.d.ts

@@ -0,0 +1,64 @@
+
+
+export type ReadonlyHeaderValue = string | undefined;
+export type HeaderValue = number | ReadonlyHeaderValue;
+export type ReadonlyHeaderValues = (readonly string[]) | ReadonlyHeaderValue
+export type HeaderValues = (readonly string[]) | HeaderValue
+
+export interface HttpHeaders {
+    get(name: string): HeaderValues
+    list(name: string): string[]
+    one(name: string): HeaderValue
+    has(name: string): boolean
+    keys(): IteratorObject<string>
+}
+
+export interface ReadonlyHttpHeaders extends HttpHeaders {
+    get(name: string): ReadonlyHeaderValues
+    one(name: string): string | undefined
+
+}
+export interface MutableHttpHeaders extends HttpHeaders {
+    get(name: string): HeaderValues
+    one(name: string): HeaderValue
+    set(name: string, value: HeaderValues): this
+    add(name: string, value: string | (readonly string[])): this
+}
+
+export type HttpMessage<Headers = HttpHeaders> = {
+    readonly headers: Headers
+}
+export type HttpMethod
+    = 'GET'
+    | 'HEAD'
+    | 'POST'
+    | 'PUT'
+    | 'DELETE'
+    | 'CONNECT'
+    | 'OPTIONS'
+    | 'TRACE'
+    | 'PATCH'
+    ;
+
+export type HttpRequest<Headers = HttpHeaders> = HttpMessage<Headers> & {
+    readonly path: string,
+    readonly method?: HttpMethod
+    readonly URL: URL
+    readonly protocol: string
+    /**
+     * hostname[:port]
+     */
+    readonly host?: string
+    readonly body: Promise<Blob>
+}
+
+export type HttpResponse<Headers = HttpHeaders> = HttpMessage<Headers> & {
+    readonly statusCode: number
+}
+
+export type HttpCookie = {
+    name: string,
+    value: string
+}
+
+

package/types/web/server.d.ts

@@ -0,0 +1,108 @@
+import type {
+    HttpCookie,
+    HttpMethod,
+    HttpRequest,
+    HttpResponse,
+    MutableHttpHeaders,
+    ReadonlyHttpHeaders
+} from './http';
+import type {WebSocketHandler} from './ws';
+import type {Principal, AuthorizationRule} from '../auth';
+import {IOGateway} from '@interopio/gateway';
+
+export type OriginFilters = {
+    non_matched?: IOGateway.Filtering.Action
+    missing?: IOGateway.Filtering.Action
+    block?: IOGateway.Filtering.Matcher[]
+    allow?: IOGateway.Filtering.Matcher[]
+    /**
+     * @deprecated
+     * @see block
+     */
+    blacklist?: IOGateway.Filtering.Matcher[]
+    /**
+     * @deprecated
+     * @see allow
+     */
+    whitelist?: IOGateway.Filtering.Matcher[]
+}
+
+export type ServerHttpRequestMatcher = { method?: HttpMethod, path: IOGateway.Filtering.Matcher };
+
+export type ServerCorsConfig = Readonly<{
+    allowOrigin?: '*' | IOGateway.Filtering.Matcher[]
+    allowHeaders?: string[]
+    allowMethods?: HttpMethod[]
+    exposeHeaders?: string[]
+    allowCredentials?: boolean
+    allowPrivateNetwork?: boolean
+    maxAge?: number
+}>;
+
+export type ServerExchangeOptions = {
+    authorize?: AuthorizationRule,
+    cors?: boolean | ServerCorsConfig,
+    origins?: OriginFilters,
+}
+export type ServerWebSocketOptions = ServerExchangeOptions & {
+    ping?: number,
+    maxConnections?: number
+}
+
+export type ServerConfigurerHandlerSpec<T extends string = string> = {
+    request: ServerHttpRequestMatcher, options?: ServerExchangeOptions
+    handler: (exchange: ServerWebExchange, variables: { [key in T]: string }) => Promise<void>,
+}
+
+export type ServerWebSocketHandler = WebSocketHandler & {
+    close?: () => Promise<void>
+}
+
+export type ServerConfigurerSocketSpec = {
+    path?: string, options?: ServerWebSocketOptions
+    factory: (server: { endpoint: string }) => Promise<ServerWebSocketHandler>,
+}
+
+export interface ServerConfigurer {
+    handle(...handler: Array<ServerConfigurerHandlerSpec>): void;
+
+    socket(...socket: Array<ServerConfigurerSocketSpec>): void;
+}
+
+export type Middleware<Request extends ServerHttpRequest = ServerHttpRequest, Response extends ServerHttpResponse = ServerHttpResponse> = ((context: ServerWebExchange<Request, Response>, next: () => Promise<void>) => Promise<void>)[];
+
+export type ServerWebExchange<Request extends ServerHttpRequest = ServerHttpRequest, Response extends ServerHttpResponse = ServerHttpResponse> = {
+    readonly request: Request
+    readonly response: Response;
+    principal<P extends Principal>(): Promise<P | undefined>;
+}
+
+export type ResponseCookie = HttpCookie & {
+    maxAge: number,
+    domain?: string,
+    path?: string,
+    secure?: boolean,
+    httpOnly?: boolean,
+    sameSite?: 'strict' | 'lax' | 'none'
+}
+
+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
+    readonly upgrade: boolean
+}
+
+export interface ServerHttpResponse extends HttpResponse<MutableHttpHeaders> {
+    statusCode: number
+    statusMessage?: string
+
+    readonly cookies: ResponseCookie[]
+
+    addCookie(cookie: ResponseCookie): this
+
+    end(chunk?: unknown): Promise<boolean>
+}

package/types/web/ws.d.ts

@@ -0,0 +1,19 @@
+import type {WebSocket} from 'ws';
+import type {ReadonlyHttpHeaders, HttpCookie} from './http';
+import type {Principal} from '../auth';
+
+type WebSocketHandshakeInfo = {
+    readonly url: URL;
+
+    // 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 logPrefix?: string;
+}
+
+type WebSocketHandler = (socket: WebSocket, handshake: WebSocketHandshakeInfo) => Promise<void>