@grest-ts/http 0.0.5 → 0.0.7

package/src/schema/httpSchema.ts

@@ -1,99 +1,99 @@
-import type http from "http";
-import {GGHttpCodec, GGHttpSchema} from "./GGHttpSchema";
-import {GGHttpRequest, GGHttpTransportMiddleware} from "./GGHttpSchema";
-import {GGContractApiDefinition, GGContractClass} from "@grest-ts/schema";
-import {GGContextKey} from "@grest-ts/context";
-
-/**
- * Create an HTTP API schema builder from a contract.
- *
- * @example
- * export const MyApiContract = defineApi("MyApi", () => ({
- *     list: {
- *         success: IsArray(IsItem),
- *         errors: [NOT_AUTHORIZED, SERVER_ERROR]
- *     },
- *     create: {
- *         input: IsCreateRequest,
- *         success: IsItem,
- *         errors: [NOT_AUTHORIZED, VALIDATION_ERROR, SERVER_ERROR]
- *     }
- * }))
- *
- * export const MyApi = httpApi(MyApiContract)
- *     .pathPrefix("api/items")
- *     .use(AuthMiddleware)
- *     .routes({
- *         list: GGRpc.GET("list"),
- *         create: GGRpc.POST("create")
- *     })
- */
-export function httpSchema<TContract extends GGContractApiDefinition>(
-    contract: GGContractClass<TContract>
-): GGHttpSchemaBuilder<TContract> {
-    return new GGHttpSchemaBuilder(contract)
-}
-
-class GGHttpSchemaBuilder<TContract extends GGContractApiDefinition, TContext = undefined> {
-
-    private readonly _contract: GGContractClass<TContract>
-    private _pathPrefix: string = ""
-    private _middlewares: GGHttpTransportMiddleware[] = []
-
-    constructor(contract: GGContractClass<TContract>) {
-        this._contract = contract;
-    }
-
-    pathPrefix(prefix: string): this {
-        this._pathPrefix = prefix
-        return this
-    }
-
-    use<M extends GGHttpTransportMiddleware>(middleware: M): GGHttpSchemaBuilder<TContract, TContext | M> {
-        this._middlewares.push(middleware)
-        return this as unknown as GGHttpSchemaBuilder<TContract, TContext | M>
-    }
-
-    useHeader<Input>(contextKey: GGContextKey<Input>): GGHttpSchemaBuilder<TContract, TContext | Input> {
-        const codec = contextKey.getCodec("http");
-        if (!codec) {
-            throw new Error(`Context key '${contextKey.name}' does not have an 'http-header' codec registered.`);
-        }
-
-        const middleware: GGHttpTransportMiddleware = {
-            updateRequest(req: GGHttpRequest) {
-                // Client-side: context -> headers
-                const contextValue = contextKey.get();
-                if (contextValue !== undefined) {
-                    const result = codec.decode(contextValue);
-                    if (result.success) {
-                        Object.assign(req.headers, result.value);
-                    }
-                } else {
-                    // Clear any default headers by decoding an empty context
-                    const emptyResult = codec.decode({} as Input);
-                    if (emptyResult.success) {
-                        for (const key of Object.keys(emptyResult.value as object)) {
-                            delete req.headers[key];
-                        }
-                    }
-                }
-            },
-            parseRequest(req: http.IncomingMessage) {
-                // Server-side: headers -> context
-                const headers = req.headers as Record<string, string>;
-                const result = codec.encode(headers);
-                if (result.success) {
-                    contextKey.set(result.value);
-                }
-            }
-        };
-
-        this._middlewares.push(middleware);
-        return this as unknown as GGHttpSchemaBuilder<TContract, TContext | Input>;
-    }
-
-    routes(mapping: { [K in keyof TContract]: GGHttpCodec }): GGHttpSchema<TContract, TContext> {
-        return new GGHttpSchema(this._pathPrefix, this._contract, mapping, this._middlewares)
-    }
-}
+import type http from "http";
+import {GGHttpCodec, GGHttpSchema} from "./GGHttpSchema";
+import {GGHttpRequest, GGHttpTransportMiddleware} from "./GGHttpSchema";
+import {GGContractApiDefinition, GGContractClass} from "@grest-ts/schema";
+import {GGContextKey} from "@grest-ts/context";
+
+/**
+ * Create an HTTP API schema builder from a contract.
+ *
+ * @example
+ * export const MyApiContract = defineApi("MyApi", () => ({
+ *     list: {
+ *         success: IsArray(IsItem),
+ *         errors: [NOT_AUTHORIZED, SERVER_ERROR]
+ *     },
+ *     create: {
+ *         input: IsCreateRequest,
+ *         success: IsItem,
+ *         errors: [NOT_AUTHORIZED, VALIDATION_ERROR, SERVER_ERROR]
+ *     }
+ * }))
+ *
+ * export const MyApi = httpApi(MyApiContract)
+ *     .pathPrefix("api/items")
+ *     .use(AuthMiddleware)
+ *     .routes({
+ *         list: GGRpc.GET("list"),
+ *         create: GGRpc.POST("create")
+ *     })
+ */
+export function httpSchema<TContract extends GGContractApiDefinition>(
+    contract: GGContractClass<TContract>
+): GGHttpSchemaBuilder<TContract> {
+    return new GGHttpSchemaBuilder(contract)
+}
+
+class GGHttpSchemaBuilder<TContract extends GGContractApiDefinition, TContext = undefined> {
+
+    private readonly _contract: GGContractClass<TContract>
+    private _pathPrefix: string = ""
+    private _middlewares: GGHttpTransportMiddleware[] = []
+
+    constructor(contract: GGContractClass<TContract>) {
+        this._contract = contract;
+    }
+
+    pathPrefix(prefix: string): this {
+        this._pathPrefix = prefix
+        return this
+    }
+
+    use<M extends GGHttpTransportMiddleware>(middleware: M): GGHttpSchemaBuilder<TContract, TContext | M> {
+        this._middlewares.push(middleware)
+        return this as unknown as GGHttpSchemaBuilder<TContract, TContext | M>
+    }
+
+    useHeader<Input>(contextKey: GGContextKey<Input>): GGHttpSchemaBuilder<TContract, TContext | Input> {
+        const codec = contextKey.getCodec("http");
+        if (!codec) {
+            throw new Error(`Context key '${contextKey.name}' does not have an 'http-header' codec registered.`);
+        }
+
+        const middleware: GGHttpTransportMiddleware = {
+            updateRequest(req: GGHttpRequest) {
+                // Client-side: context -> headers
+                const contextValue = contextKey.get();
+                if (contextValue !== undefined) {
+                    const result = codec.decode(contextValue);
+                    if (result.success) {
+                        Object.assign(req.headers, result.value);
+                    }
+                } else {
+                    // Clear any default headers by decoding an empty context
+                    const emptyResult = codec.decode({} as Input);
+                    if (emptyResult.success) {
+                        for (const key of Object.keys(emptyResult.value as object)) {
+                            delete req.headers[key];
+                        }
+                    }
+                }
+            },
+            parseRequest(req: http.IncomingMessage) {
+                // Server-side: headers -> context
+                const headers = req.headers as Record<string, string>;
+                const result = codec.encode(headers);
+                if (result.success) {
+                    contextKey.set(result.value);
+                }
+            }
+        };
+
+        this._middlewares.push(middleware);
+        return this as unknown as GGHttpSchemaBuilder<TContract, TContext | Input>;
+    }
+
+    routes(mapping: { [K in keyof TContract]: GGHttpCodec }): GGHttpSchema<TContract, TContext> {
+        return new GGHttpSchema(this._pathPrefix, this._contract, mapping, this._middlewares)
+    }
+}

package/src/server/GGHttp.ts

@@ -1,27 +1,27 @@
-import {GGHttpSchema} from "../schema/GGHttpSchema";
-import {GGContractApiDefinition, GGContractImplementation} from "@grest-ts/schema";
-import {GGHttpServerMiddleware} from "./GGHttpSchema.startServer";
-import {GGHttpServer} from "./GGHttpServer";
-
-export class GGHttp<TContext = undefined> {
-
-    private readonly httpServer: GGHttpServer
-    private readonly middlewares: GGHttpServerMiddleware[] = [];
-
-    constructor(httpServer: GGHttpServer) {
-        this.httpServer = httpServer;
-    }
-
-    public use<M extends GGHttpServerMiddleware>(middleware: M): GGHttp<TContext | M> {
-        this.middlewares.push(middleware);
-        return this as any;
-    }
-
-    public http<TContract extends GGContractApiDefinition, TSchemaContext>(
-        schema: GGHttpSchema<TContract, TSchemaContext>,
-        implementation: GGContractImplementation<TContract>
-    ): this {
-        schema.register(implementation, {http: this.httpServer, middlewares: this.middlewares});
-        return this as any;
-    }
-}
+import {GGHttpSchema} from "../schema/GGHttpSchema";
+import {GGContractApiDefinition, GGContractImplementation} from "@grest-ts/schema";
+import {GGHttpServerMiddleware} from "./GGHttpSchema.startServer";
+import {GGHttpServer} from "./GGHttpServer";
+
+export class GGHttp<TContext = undefined> {
+
+    private readonly httpServer: GGHttpServer
+    private readonly middlewares: GGHttpServerMiddleware[] = [];
+
+    constructor(httpServer: GGHttpServer) {
+        this.httpServer = httpServer;
+    }
+
+    public use<M extends GGHttpServerMiddleware>(middleware: M): GGHttp<TContext | M> {
+        this.middlewares.push(middleware);
+        return this as any;
+    }
+
+    public http<TContract extends GGContractApiDefinition, TSchemaContext>(
+        schema: GGHttpSchema<TContract, TSchemaContext>,
+        implementation: GGContractImplementation<TContract>
+    ): this {
+        schema.register(implementation, {http: this.httpServer, middlewares: this.middlewares});
+        return this as any;
+    }
+}

package/src/server/GGHttpMetrics.ts

@@ -1,31 +1,31 @@
-import {GGCounterKey, GGHistogramKey, GGMetrics} from "@grest-ts/metrics";
-import {EXISTS, FORBIDDEN, NOT_AUTHORIZED, NOT_FOUND, OK, ROUTE_NOT_FOUND, SERVER_ERROR, VALIDATION_ERROR} from "@grest-ts/schema";
-
-/**
- * Result type for HTTP operations.
- * Known types listed for documentation, but accepts any string for custom error types.
- */
-type ResultType =
-    | typeof OK.TYPE
-    | typeof VALIDATION_ERROR.TYPE
-    | typeof NOT_AUTHORIZED.TYPE
-    | typeof FORBIDDEN.TYPE
-    | typeof NOT_FOUND.TYPE
-    | typeof ROUTE_NOT_FOUND.TYPE
-    | typeof EXISTS.TYPE
-    | typeof SERVER_ERROR.TYPE
-    | string;
-
-export const GGHttpMetrics = GGMetrics.define('/http/', () => ({
-    requests: new GGCounterKey<{ api: string, method: string, path: string, result: ResultType }>('requests_total', {
-        help: 'Total HTTP requests after contract validation',
-        labelNames: ['api', 'method', 'path', 'result'],
-        groupBy: {labels: ["api", "method"], template: "{api}.{method}"}
-    }),
-    requestDuration: new GGHistogramKey<{ api: string, method: string, path: string }>('request_duration_ms', {
-        help: 'HTTP request duration in milliseconds',
-        labelNames: ['api', 'method', 'path'],
-        buckets: [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000],
-        groupBy: {labels: ["api", "method"], template: "{api}.{method}"}
-    }),
-}));
+import {GGCounterKey, GGHistogramKey, GGMetrics} from "@grest-ts/metrics";
+import {EXISTS, FORBIDDEN, NOT_AUTHORIZED, NOT_FOUND, OK, ROUTE_NOT_FOUND, SERVER_ERROR, VALIDATION_ERROR} from "@grest-ts/schema";
+
+/**
+ * Result type for HTTP operations.
+ * Known types listed for documentation, but accepts any string for custom error types.
+ */
+type ResultType =
+    | typeof OK.TYPE
+    | typeof VALIDATION_ERROR.TYPE
+    | typeof NOT_AUTHORIZED.TYPE
+    | typeof FORBIDDEN.TYPE
+    | typeof NOT_FOUND.TYPE
+    | typeof ROUTE_NOT_FOUND.TYPE
+    | typeof EXISTS.TYPE
+    | typeof SERVER_ERROR.TYPE
+    | string;
+
+export const GGHttpMetrics = GGMetrics.define('/http/', () => ({
+    requests: new GGCounterKey<{ api: string, method: string, path: string, result: ResultType }>('requests_total', {
+        help: 'Total HTTP requests after contract validation',
+        labelNames: ['api', 'method', 'path', 'result'],
+        groupBy: {labels: ["api", "method"], template: "{api}.{method}"}
+    }),
+    requestDuration: new GGHistogramKey<{ api: string, method: string, path: string }>('request_duration_ms', {
+        help: 'HTTP request duration in milliseconds',
+        labelNames: ['api', 'method', 'path'],
+        buckets: [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000],
+        groupBy: {labels: ["api", "method"], template: "{api}.{method}"}
+    }),
+}));

package/src/server/GGHttpSchema.startServer.ts

@@ -1,161 +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
-        });
-    }
-}
+/**
+ * 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
+        });
+    }
+}