@grest-ts/http 0.0.5

package/src/server/GGHttpSchema.startServer.ts

@@ -0,0 +1,161 @@
+/**
+ * Server extension for HttpApiSchema - adds register method.
+ * This file should only be imported in server (Node.js) context.
+ */
+
+import http from "http";
+import {GGLocator} from "@grest-ts/locator";
+import {ClientHttpRouteToRpcTransformServerCodec, GGHttpCodec, GGHttpSchema} from "../schema/GGHttpSchema";
+import {ERROR, GGContractApiDefinition, GGContractImplementation, GGContractMethod, OK, SERVER_ERROR} from "@grest-ts/schema";
+import {HttpMethod} from "@grest-ts/common";
+import {GG_DISCOVERY} from "@grest-ts/discovery";
+import {GGContext, GGContextStore} from "@grest-ts/context";
+import {GG_TRACE} from "@grest-ts/trace";
+import {GG_HTTP_REQUEST} from "./GG_HTTP_REQUEST";
+import {GG_METRICS} from "@grest-ts/metrics";
+import {GGHttpMetrics} from "./GGHttpMetrics";
+import {GG_HTTP_SERVER} from "./GG_HTTP_SERVER";
+import {GGHttpServer} from "./GGHttpServer";
+import {GGLog} from "@grest-ts/logger";
+
+export interface GGHttpSchemaConfig {
+    /**
+     * The HTTP request handler to register with.
+     */
+    http?: GGHttpServer;
+    /**
+     * Additional middlewares to apply to all routes.
+     */
+    middlewares?: GGHttpServerMiddleware[];
+}
+
+export interface GGHttpServerMiddleware {
+    process?(): Promise<void>
+}
+
+declare module "../schema/GGHttpSchema" {
+    interface GGHttpSchema<TContract extends GGContractApiDefinition> {
+        /**
+         * Start server with direct implementation.
+         * Uses parseRequest from use classes without transform.
+         * For custom transforms, use createServer() instead.
+         */
+        register(implementation: GGContractImplementation<TContract>, config?: GGHttpSchemaConfig): void
+    }
+}
+
+GGHttpSchema.prototype.register = function <TContract extends GGContractApiDefinition>(
+    this: GGHttpSchema<TContract>,
+    implementation: GGContractImplementation<TContract>,
+    config?: GGHttpSchemaConfig
+) {
+    return setupRoutes(this, implementation, config)
+}
+
+function setupRoutes<TContract extends GGContractApiDefinition>(
+    httpSchema: GGHttpSchema<TContract>,
+    implementation: GGContractImplementation<TContract>,
+    config?: GGHttpSchemaConfig
+) {
+    config ??= {};
+    config.middlewares ??= [];
+
+    if (!httpSchema.contract) throw new Error(`HttpApiSchema "${httpSchema.name}" has no contract.`);
+
+    const server = config.http ?? GGLocator.getScope().get(GG_HTTP_SERVER);
+    if (!server) throw new Error(`No HTTP server found. Make sure to register GGHttpServerAdapter in the scope or pass handler via config`)
+
+    const pathPrefix = "/" + httpSchema.pathPrefix + "/"
+    const apiMiddlewares = httpSchema.apiMiddlewares;
+    const scope = GGLocator.getScope();
+    const parentContext = GGContextStore.tryGetContext();
+
+    server.onStart(() => {
+        GG_DISCOVERY.tryGet()?.registerRoutes([{
+            runtime: scope.serviceName,
+            api: httpSchema.name,
+            pathPrefix: pathPrefix,
+            protocol: "http",
+            port: server.port
+        }]);
+    })
+
+    // Info: Contract instance is auto-registered in GGLocator via patched implement()
+    // @TODO This is not really used and only for testkit so it would register implementation of the contract... Not cool
+    httpSchema.contract.implement(implementation);
+
+    for (const methodName in httpSchema.codec) {
+        // Wire format.
+        const codec: GGHttpCodec = httpSchema.codec[methodName]
+        if (!codec) throw new Error(`Contract for "${httpSchema.name}.${methodName}" is missing wire format!`)
+
+        // Implementation function
+        const implFn = implementation[methodName]?.bind(implementation)
+        if (!implFn) throw new Error(`Implementation for "${httpSchema.name}.${methodName}" is missing implementation method!`)
+
+        // Input schema
+        const contractFunctionSchema: GGContractMethod = httpSchema.contract.methods[methodName as keyof TContract]
+        if (!contractFunctionSchema) throw new Error(`Contract for "${httpSchema.name}.${methodName}" is missing contract function schema!`)
+
+        // build request mapping
+        const requestParser: ClientHttpRouteToRpcTransformServerCodec = codec.createForServer({
+            contract: contractFunctionSchema,
+            apiMiddlewares: apiMiddlewares,
+            serverMiddlewares: config.middlewares
+        })
+        server.registerRoute(codec.method, pathPrefix + codec.path, async (req: http.IncomingMessage, res: http.ServerResponse): Promise<void> => {
+            scope.ensureEntered();
+            return new GGContext("REQ", parentContext).run(async () => {
+                GG_TRACE.init();
+                GG_HTTP_REQUEST.set({port: server.port, method: req.method, path: req.url});
+                const startTime = performance.now()
+                let rpcResult: ERROR<string, unknown> | OK<unknown>
+                try {
+                    const rpcInput = await requestParser.parseRequest(req)
+                    try {
+                        rpcResult = {success: true, type: "OK", data: await implFn(rpcInput)}
+                        // GGLog.debug(httpSchema, "Response", rpcResult) // This is very slow to log this (like 3x performance loss)
+                    } catch (error: unknown) {
+                        rpcResult = ERROR.fromUnknown(error);
+                        if (rpcResult instanceof SERVER_ERROR) {
+                            GGLog.error(httpSchema, rpcResult)
+                        } else {
+                            // GGLog.debug(httpSchema, "Response", rpcResult) // This is very slow to log this (like 3x performance loss)
+                        }
+                    }
+                    await requestParser.sendResponse(res, rpcResult) // can throw
+                } catch (error: unknown) {
+                    rpcResult = ERROR.fromUnknown(error)
+                    await requestParser.sendResponse(res, rpcResult) // Does not throw
+                    GGLog.error(httpSchema, rpcResult)
+                } finally {
+                    metrics(rpcResult?.type, httpSchema.name, codec.method, pathPrefix, codec.path, startTime)
+                }
+            });
+        })
+    }
+}
+
+function metrics(
+    resultType: string,
+    apiName: string,
+    method: HttpMethod,
+    pathPrefix: string,
+    pathSuffix: string,
+    startTime: number
+) {
+    if (GG_METRICS.has()) {
+        const path = method + " " + pathPrefix + pathSuffix;
+        GGHttpMetrics.requests.inc(1, {
+            api: apiName,
+            method: pathSuffix,
+            path: path,
+            result: resultType
+        });
+        GGHttpMetrics.requestDuration.observe(performance.now() - startTime, {
+            api: apiName,
+            method: pathSuffix,
+            path: path
+        });
+    }
+}

package/src/server/GGHttpServer.ts

@@ -0,0 +1,133 @@
+import http from "http";
+import {HttpMethod, HttpStatusCode} from "@grest-ts/common";
+import {GGLocator, GGLocatorKey, GGLocatorScope, GGLocatorServiceType} from "@grest-ts/locator";
+import {GG_HTTP_SERVER} from "./GG_HTTP_SERVER";
+import {GGLog} from "@grest-ts/logger";
+import findMyWay, {HTTPMethod} from "find-my-way";
+
+export interface GGHttpServerAdapterConfig {
+    key?: GGLocatorKey<GGHttpServer>;
+    port?: number;
+}
+
+export class GGHttpServer {
+
+    protected _port: number | undefined;
+    protected teardownPromise: Promise<void> | undefined;
+    protected readonly scope: GGLocatorScope;
+    protected readonly runtimeName: string;
+    private readonly configuredPort: number;
+
+    private readonly _onStart: Array<() => void> = [];
+    private readonly _onTeardown: Array<() => void> = [];
+
+    public readonly httpServer: http.Server;
+    private activeRequests = 0;
+    private router = findMyWay<findMyWay.HTTPVersion.V1>();
+
+    constructor(config?: GGHttpServerAdapterConfig) {
+
+        this.runtimeName = GGLocator.getScope().serviceName;
+        this.scope = GGLocator.getScope();
+        this.configuredPort = config?.port ?? (process.env.PORT ? Number(process.env.PORT) : 0);
+
+        GGLocator.getScope().setWithLifecycle(config?.key ?? GG_HTTP_SERVER, this, {
+            type: GGLocatorServiceType.HTTP,
+            start: this.start.bind(this),
+            teardown: this.teardown.bind(this)
+        });
+
+        this.httpServer = http.createServer(async (req, res) => {
+            if (this.teardownPromise) {
+                res.statusCode = HttpStatusCode.ServerTemporarilyNotAvailable503;
+                res.end();
+                return;
+            }
+            this.activeRequests++;
+            try {
+                if (req.headers.origin) { // For browsers
+                    res.setHeader('Access-Control-Allow-Origin', '*');
+                    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+                    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-company-auth'); // @TODO Remove x-company-auth
+                    res.setHeader('Access-Control-Expose-Headers', 'Content-Disposition');
+                }
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                } else {
+                    const resolved = this.router.find(req.method as HTTPMethod, req.url)
+                    if (resolved) {
+                        await (resolved.handler as unknown as GGHttpRequestCallback)(req, res);
+                    } else {
+                        res.writeHead(404);
+                        res.end();
+                    }
+                }
+            } catch (error) {
+                GGLog.error(this, error);
+                res.writeHead(500);
+                res.end();
+            } finally {
+                this.activeRequests--;
+            }
+        });
+    }
+
+    /**
+     * Current port the server is listening to.
+     * May be undefined before start() is called.
+     */
+    get port(): number | undefined {
+        return this._port;
+    }
+
+    // =========================================================================
+    // Common implementation
+    // =========================================================================
+
+    public registerRoute(method: HttpMethod, path: string, handler: GGHttpRequestCallback): void {
+        this.router.on(method as HTTPMethod, path, handler as unknown as findMyWay.Handler<findMyWay.HTTPVersion.V1>);
+    }
+
+    public async start(): Promise<void> {
+        this._port = await new Promise((resolve) => {
+            this.httpServer.listen(this.configuredPort, '0.0.0.0', () => {
+                const port = (this.httpServer.address() as any).port;
+                resolve(port);
+            });
+        });
+        this._onStart.forEach(callback => callback());
+        GGLog.info(this, `HTTP server started`, {
+            port: this._port,
+            runtime: this.runtimeName
+        });
+    }
+
+    public async teardown(): Promise<void> {
+        if (this.teardownPromise) {
+            return this.teardownPromise;
+        }
+        return this.teardownPromise = (async () => {
+            await Promise.all(this._onTeardown.map(callback => callback()));
+            this.httpServer.close();
+            const maxWaitTime = 3000;
+            const deadline = performance.now() + maxWaitTime;
+            while (this.activeRequests > 0 && performance.now() < deadline) {
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+            GGLog.info(this, `HTTP server stopped`);
+        })();
+    }
+
+    public onStart(callback: () => Promise<void> | void): this {
+        this._onStart.push(callback);
+        return this;
+    }
+
+    public onTeardown(callback: () => Promise<void> | void): this {
+        this._onTeardown.push(callback);
+        return this;
+    }
+}
+
+export type GGHttpRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;

package/src/server/GG_HTTP_REQUEST.ts

@@ -0,0 +1,12 @@
+import {GGContextKey} from "@grest-ts/context";
+import {IsNumber, IsObject, IsString} from "@grest-ts/schema";
+
+const IsHttpRequestContext = IsObject({
+    port: IsNumber,
+    method: IsString,
+    path: IsString,
+    pathTemplate: IsString.orUndefined
+});
+export type HttpRequestContext = typeof IsHttpRequestContext.infer;
+
+export const GG_HTTP_REQUEST = new GGContextKey<HttpRequestContext>('http-request', IsHttpRequestContext);

package/src/server/GG_HTTP_SERVER.ts

@@ -0,0 +1,4 @@
+import {GGLocatorKey} from "@grest-ts/locator";
+import {GGHttpServer} from "./GGHttpServer";
+
+export const GG_HTTP_SERVER = new GGLocatorKey<GGHttpServer>("GGHttpServer");

package/src/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "//": "THIS FILE IS GENERATED - DO NOT EDIT",
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "**/*"
+  ]
+}