@zyno-io/dk-server-foundation 26.216.430

package/src/http/auth.ts

@@ -0,0 +1,156 @@
+import { timingSafeEqual } from 'crypto';
+import { HttpRequest, HttpUnauthorizedError, RouteParameterResolver, RouteParameterResolverContext } from '@deepkit/http';
+import { ScopedLogger } from '@deepkit/logger';
+import { ActiveRecordClassType } from '@deepkit/orm';
+
+// can't import app here or bad things happen!!
+import type { BaseAppConfig } from '../app';
+import { JWT, ParsedJwt } from '../auth';
+import { getEntity, getEntityOrUndefined } from '../database';
+import { HttpMiddleware } from './middleware';
+import { createCachingParameterResolver, getCompositeCacheKey, getOrCacheValue } from './store';
+
+/**
+ * base request JWT lookup
+ */
+export async function getJwtFromRequest(request: HttpRequest): Promise<ParsedJwt | undefined> {
+    return getOrCacheValue(request, ParsedJwt, _getJwtFromRequest);
+}
+
+async function _getJwtFromRequest(request: HttpRequest): Promise<ParsedJwt | undefined> {
+    const jwt = await JWT.processWithRequest(request);
+    if (!jwt) return undefined;
+    if (!jwt.isValid) {
+        if (!jwt.isSignatureValid) throw new HttpUnauthorizedError('Invalid JWT signature');
+        if (!jwt.isNotExpired) throw new HttpUnauthorizedError('Expired JWT');
+        throw new HttpUnauthorizedError('Invalid JWT');
+    }
+    return jwt;
+}
+
+export class ParsedJwtResolver implements RouteParameterResolver {
+    async resolve(context: RouteParameterResolverContext): Promise<ParsedJwt | undefined> {
+        const jwt = await getJwtFromRequest(context.request);
+        if (!jwt && !context.type.isOptional()) {
+            throw new HttpUnauthorizedError('Request does not contain required JWT');
+        }
+        return jwt;
+    }
+}
+
+/**
+ * base request JWT user ID lookup
+ */
+const EntityIdSymbol = Symbol('EntityId');
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function getEntityIdFromRequestJwt(request: HttpRequest): Promise<any> {
+    const jwt = await getJwtFromRequest(request);
+    return jwt?.subject;
+}
+
+/**
+ * request JWT user ID to user object
+ */
+export async function getEntityFromRequestJwt<T extends ActiveRecordClassType>(
+    request: HttpRequest,
+    EntityClass: T
+): Promise<InstanceType<T> | undefined> {
+    const entityId = await getEntityIdFromRequestJwt(request);
+    return entityId ? getEntity(EntityClass, entityId) : undefined;
+}
+
+/**
+ * auth middleware generator
+ */
+interface EntityValidator<T extends ActiveRecordClassType> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getEntityIdFromRequest(request: HttpRequest): Promise<any>;
+    validateEntity?(request: HttpRequest, entity: InstanceType<T>): Promise<void>;
+}
+export function createAuthMiddleware<T extends ActiveRecordClassType>(EntityClass: T) {
+    return class extends HttpMiddleware implements EntityValidator<T> {
+        async handle(request: HttpRequest) {
+            const entityId = await getOrCacheValue(
+                request,
+                getCompositeCacheKey(EntityClass, EntityIdSymbol),
+                this.getEntityIdFromRequest.bind(this)
+            );
+            await this.loadAndValidateEntity(request, entityId);
+        }
+
+        async getEntityIdFromRequest(request: HttpRequest) {
+            const id = await getEntityIdFromRequestJwt(request);
+            if (!id) throw new HttpUnauthorizedError();
+            return id;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async loadAndValidateEntity(request: HttpRequest, id: any) {
+            const validateFn = (this as EntityValidator<T>).validateEntity;
+            if (validateFn) {
+                const entity = await getOrCacheValue(request, EntityClass, () => getEntityOrUndefined(EntityClass, id));
+                if (!entity) throw new HttpUnauthorizedError();
+                await validateFn(request, entity);
+            }
+        }
+    };
+}
+
+/**
+ * HTTP basic auth middleware
+ */
+export function createBasicAuthMiddleware(expectedUsername?: string) {
+    return class extends HttpMiddleware {
+        public config: BaseAppConfig;
+
+        constructor(public logger: ScopedLogger) {
+            super();
+
+            // todo:figure this out
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            this.config = require('../app').getAppConfig();
+            if (!this.config.AUTH_BASIC_SECRET) {
+                this.logger.error('No AUTH_BASIC_SECRET provided');
+            }
+        }
+
+        async handle(request: HttpRequest) {
+            const authHeader = request.headers['authorization'];
+            if (!authHeader) {
+                throw new HttpUnauthorizedError();
+            }
+
+            const [scheme, credentials] = authHeader.split(' ');
+            if (scheme.toLowerCase() !== 'basic') {
+                throw new HttpUnauthorizedError('Invalid authorization scheme');
+            }
+
+            const [username, password] = Buffer.from(credentials, 'base64').toString().split(':');
+            const secret = this.config.AUTH_BASIC_SECRET ?? '';
+            const usernameInvalid = expectedUsername && expectedUsername !== username;
+            const passwordBuf = Buffer.from(password);
+            const secretBuf = Buffer.from(secret);
+            const passwordInvalid = passwordBuf.length !== secretBuf.length || !timingSafeEqual(passwordBuf, secretBuf);
+            if (usernameInvalid || passwordInvalid) {
+                throw new HttpUnauthorizedError('Invalid credentials');
+            }
+        }
+    };
+}
+
+/**
+ * standard authed entity resolver
+ */
+export async function resolveEntityFromRequestJwt<T extends ActiveRecordClassType>(context: RouteParameterResolverContext, EntityClass: T) {
+    const ent = await getEntityFromRequestJwt(context.request, EntityClass);
+    if (!ent && !context.type.isOptional()) {
+        throw new HttpUnauthorizedError();
+    }
+    return ent;
+}
+
+export function createEntityFromRequestJwtParameterResolver<T extends ActiveRecordClassType>(EntityClass: T) {
+    return createCachingParameterResolver(EntityClass, async (context: RouteParameterResolverContext) => {
+        return resolveEntityFromRequestJwt(context, EntityClass);
+    });
+}

package/src/http/context.ts

@@ -0,0 +1,15 @@
+import { HttpRequest } from '@deepkit/http';
+import { uuid } from '@deepkit/type';
+
+export const DefaultHttpContextProvider: (request: HttpRequest) => Record<string, string> = () => ({
+    reqId: uuid()
+});
+
+let httpContextProvider: (request: HttpRequest) => Record<string, string> = DefaultHttpContextProvider;
+export function setHttpContextResolver(provider: (request: HttpRequest) => Record<string, string>) {
+    httpContextProvider = provider;
+}
+
+export function getHttpContextResolver() {
+    return httpContextProvider;
+}

package/src/http/cors.ts

@@ -0,0 +1,159 @@
+import { eventDispatcher } from '@deepkit/event';
+import { HttpRequest, HttpResponse, HttpRouter, httpWorkflow } from '@deepkit/http';
+
+export const CorsHeaders = Symbol('CorsHeaders');
+
+export class HttpCorsOptionsMulti {
+    constructor(public readonly options: HttpCorsOptions[]) {}
+}
+
+export class HttpCorsOptions {
+    hosts!: (string | RegExp)[];
+    paths?: (string | RegExp)[];
+    methods?: string[];
+    credentials?: boolean;
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+}
+
+export class HttpCors {
+    static getResponseHeaders(response: HttpResponse): Record<string, string> | undefined {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (response as any)[CorsHeaders];
+    }
+}
+
+export class HttpCorsDescriptor {
+    cachedPreflightHeaders: Record<string, string> = {};
+    cachedResponseCorsHeaders: Record<string, string> = {};
+
+    constructor(public readonly options: HttpCorsOptions) {
+        this.cachedPreflightHeaders['Access-Control-Allow-Methods'] = options.methods?.join(',') ?? 'GET,HEAD,PUT,PATCH,POST,DELETE';
+
+        if (options.allowHeaders) {
+            this.cachedPreflightHeaders['Access-Control-Allow-Headers'] = options.allowHeaders.join(', ');
+        }
+
+        if (options.credentials) {
+            this.cachedPreflightHeaders['Access-Control-Allow-Credentials'] = 'true';
+            this.cachedResponseCorsHeaders['Access-Control-Allow-Credentials'] = 'true';
+        }
+
+        if (options.exposeHeaders) {
+            this.cachedResponseCorsHeaders['Access-Control-Expose-Headers'] = options.exposeHeaders.join(', ');
+        }
+    }
+}
+
+export class HttpCorsListener {
+    descriptors: HttpCorsDescriptor[];
+
+    constructor(
+        protected router: HttpRouter,
+        protected corsOptionsMulti: HttpCorsOptionsMulti
+    ) {
+        this.descriptors = corsOptionsMulti.options.map(options => new HttpCorsDescriptor(options));
+    }
+
+    // because DK's middleware implemtnation only aborts executing middleware when it encounters a finshed response,
+    // we perform writeHead+end in our HttpMiddleware wrapper. this means that the response is already finished
+    // by the time it would reach an onResponse handler, and would prevent us from injecting CORS headers into
+    // a response such as an HTTP 401. to work around this, we precompute the CORS response headers so they can
+    // be used in the normal response flow, or in our HttpMiddleware wrapper
+    // note we already have a listener at priority 99, so we use 98 here since it needs to run before that one
+    @eventDispatcher.listen(httpWorkflow.onRoute, 98)
+    async onRoute(event: typeof httpWorkflow.onRoute.event): Promise<void> {
+        if (event.sent) return;
+        if (event.hasNext()) return;
+
+        const descriptor = this.findMatchingDescriptor(event.request);
+        if (descriptor) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (event.response as any)[CorsHeaders] = this.getCorsResponseHeaders(event.request, descriptor);
+        }
+    }
+
+    @eventDispatcher.listen(httpWorkflow.onRouteNotFound, 99)
+    async routeNotFound(event: typeof httpWorkflow.onRouteNotFound.event): Promise<void> {
+        if (event.sent) return;
+        if (event.hasNext()) return;
+
+        if (event.request.method === 'OPTIONS') {
+            const descriptor = this.findMatchingDescriptor(event.request);
+            if (descriptor) {
+                // DK's response requires a content-type, which doesn't make sense here, so we go around it
+                // by using Node's built-in server response
+                event.response.writeHead(204, this.getCorsPreflightHeaders(event.request, descriptor));
+                event.response.end();
+                event.send(event.response);
+            }
+        }
+    }
+
+    @eventDispatcher.listen(httpWorkflow.onResponse, -101)
+    async onResponse(event: typeof httpWorkflow.onResponse.event): Promise<void> {
+        if (event.response.headersSent) return;
+        if (event.hasNext()) return;
+
+        if (CorsHeaders in event.response) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const key in (event.response as any)[CorsHeaders]) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                event.response.setHeader(key, (event.response as any)[CorsHeaders][key]);
+            }
+        }
+    }
+
+    private findMatchingDescriptor(request: HttpRequest) {
+        const originHeader = request.headers.origin;
+        if (!originHeader) return null;
+        if (!request.url) return null;
+
+        return this.descriptors.find(descriptor => {
+            const hostMatches = descriptor.options.hosts.some(host => {
+                if (host === '*') {
+                    return true;
+                }
+                if (host instanceof RegExp) {
+                    return host.test(originHeader);
+                }
+                return host === request.headers.origin;
+            });
+
+            const patchMatches =
+                !descriptor.options.paths ||
+                descriptor.options.paths.some(path => {
+                    if (path instanceof RegExp) {
+                        return path.test(request.url!);
+                    }
+                    return request.url!.startsWith(path);
+                });
+
+            return hostMatches && patchMatches;
+        });
+    }
+
+    private getCorsPreflightHeaders(request: HttpRequest, descriptor: HttpCorsDescriptor): Record<string, string> {
+        const headers: Record<string, string> = {
+            ...descriptor.cachedPreflightHeaders,
+            'Access-Control-Allow-Origin': request.headers.origin ?? '*',
+            'Access-Control-Allow-Credentials': 'true',
+            'Content-Length': '0'
+        };
+
+        if (!('Access-Control-Allow-Headers' in headers)) {
+            if (request.headers['access-control-request-headers']) {
+                headers['Access-Control-Allow-Headers'] = request.headers['access-control-request-headers'];
+            }
+        }
+
+        return headers;
+    }
+
+    private getCorsResponseHeaders(request: HttpRequest, descriptor: HttpCorsDescriptor): Record<string, string> {
+        return {
+            ...descriptor.cachedResponseCorsHeaders,
+            'Access-Control-Allow-Origin': request.headers.origin ?? '*'
+        };
+    }
+}

package/src/http/errors.ts

@@ -0,0 +1,9 @@
+import { createHttpError } from '@deepkit/http';
+
+export const HttpUserError = createHttpError(422);
+
+// todo: Deepkit has added the original error prop to the event and we can use normal workflow to handle this now
+
+// Deepkit's built in HttpAccessDeniedError fires a special workflow event
+// that doesn't contain the original error or the message that was attached to it
+export const HttpDetailedAccessDeniedError = createHttpError(403);

package/src/http/index.ts

@@ -0,0 +1,19 @@
+import './overrides';
+
+export * from './auth';
+export * from './context';
+export * from './kernel';
+export * from './workflow';
+export { HttpCors } from './cors';
+export * from './errors';
+export * from './middleware';
+export * from './store';
+export * from './uploads';
+
+export const OkResponse = { ok: true };
+export type OkResponse = Promise<{ ok: true }>;
+
+export type RedirectResponse = Promise<void>;
+export type EmptyResponse = Promise<void>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyResponse = Promise<any>;

package/src/http/kernel.ts

@@ -0,0 +1,138 @@
+import { HttpKernel, HttpRequest, HttpResponse } from '@deepkit/http';
+import { LoggerInterface } from '@deepkit/logger';
+
+import { getAppConfig } from '../app/resolver';
+import { withContextData } from '../helpers';
+import { createLogger } from '../services';
+import { getHttpContextResolver } from './context';
+
+interface RequestLogger {
+    start?: (logger: LoggerInterface, request: HttpRequest) => void;
+    finish?: (logger: LoggerInterface, request: HttpRequest, response: HttpResponse) => void;
+    abort?: (logger: LoggerInterface, request: HttpRequest) => void;
+}
+
+export class CustomHttpKernel extends HttpKernel {
+    private activeRequestCount = 0;
+    private scopedLogger = createLogger('http');
+
+    private shouldSkipRequestLogging(request: HttpRequest) {
+        return request.url === '/healthz' || request.url === '/metrics';
+    }
+
+    private buildRequestLogger(): RequestLogger {
+        const logMode = getAppConfig().HTTP_REQUEST_LOGGING_MODE;
+
+        const abortFn: RequestLogger['abort'] = (logger, request) => {
+            logger.warn('Request aborted during processing', {
+                method: request.method,
+                url: request.url,
+                duration: Date.now() - request.store['$RequestTime']
+            });
+        };
+
+        const finishFn: RequestLogger['finish'] = (logger, request, response) => {
+            const msg =
+                response.statusCode >= 400 ? 'Request failed' : response.writableEnded ? 'Request completed' : 'Response stream hooked by controller';
+            logger.info(msg, {
+                method: request.method,
+                url: request.url,
+                statusCode: response.statusCode,
+                duration: Date.now() - request.store['$RequestTime']
+            });
+        };
+
+        if (logMode === 'e2e') {
+            return {
+                start: (logger, request) => {
+                    request.store['$RequestTime'] = Date.now();
+                    if (!this.shouldSkipRequestLogging(request)) {
+                        logger.info('Request started', {
+                            method: request.method,
+                            url: request.url,
+                            remoteAddress: request.getRemoteAddress(),
+                            contentLength: request.headers['content-length']
+                        });
+                    }
+                },
+                finish: (logger, request, response) => {
+                    if (response.statusCode >= 400 || !this.shouldSkipRequestLogging(request)) {
+                        finishFn(logger, request, response);
+                    }
+                },
+                abort: abortFn
+            };
+        }
+
+        if (logMode === 'finish') {
+            return {
+                start: (_logger, request) => {
+                    request.store['$RequestTime'] = Date.now();
+                },
+                finish: (logger, request, response) => {
+                    if (response.statusCode >= 400 || !this.shouldSkipRequestLogging(request)) {
+                        finishFn(logger, request, response);
+                    }
+                }
+            };
+        }
+
+        if (logMode === 'errors') {
+            return {
+                start: (_logger, request) => {
+                    request.store['$RequestTime'] = Date.now();
+                },
+                finish: (logger, request, response) => {
+                    if (response.statusCode >= 400) {
+                        finishFn(logger, request, response);
+                    }
+                },
+                abort: abortFn
+            };
+        }
+
+        return {
+            start: (_logger, request) => {
+                request.store['$RequestTime'] = Date.now();
+            },
+            abort: abortFn
+        };
+    }
+
+    get requestLogger(): RequestLogger {
+        const logger = this.buildRequestLogger();
+        Object.defineProperty(this, 'requestLogger', { value: logger });
+        return logger;
+    }
+
+    async handleRequest(req: HttpRequest, res: HttpResponse): Promise<void> {
+        try {
+            this.activeRequestCount++;
+            const httpCtx = getHttpContextResolver()(req);
+            await withContextData({ http: httpCtx }, async () => {
+                this.requestLogger.start?.(this.scopedLogger, req);
+
+                await new Promise<void>((resolve, reject) => {
+                    const onClose = () => {
+                        if (res.destroyed && !res.writableFinished) {
+                            this.requestLogger.abort?.(this.scopedLogger, req);
+                            resolve();
+                        }
+                    };
+                    res.on('close', onClose);
+
+                    super
+                        .handleRequest(req, res)
+                        .then(() => {
+                            res.removeListener('close', onClose);
+                            this.requestLogger.finish?.(this.scopedLogger, req, res);
+                            resolve();
+                        })
+                        .catch(reject);
+                });
+            });
+        } finally {
+            this.activeRequestCount--;
+        }
+    }
+}

package/src/http/middleware.ts

@@ -0,0 +1,59 @@
+import { HttpError, HttpMiddleware as BaseHttpMiddleware, HttpRequest, HttpResponse } from '@deepkit/http';
+import { ScopedLogger } from '@deepkit/logger';
+
+import { CorsHeaders } from './cors';
+
+// Deepkit's middleware code returns a 404 if the middleware throws an error
+// we want to properly handle HTTP errors, so we need to wrap the middleware
+export abstract class HttpMiddleware implements BaseHttpMiddleware {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async execute(request: HttpRequest, response: HttpResponse, next: (err?: any) => void) {
+        try {
+            await this.handle(request, response);
+            next();
+        } catch (err) {
+            if (err instanceof HttpError) {
+                response.writeHead(err.httpCode, {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    ...(response as any)[CorsHeaders],
+                    'content-type': 'application/json'
+                });
+                response.end(
+                    JSON.stringify({
+                        error: err.message
+                    })
+                );
+
+                // there's some quirk in Deepkit testing where the finish event isn't emitted
+                // on ended responses during Jest testing, but works as expected in production
+                // will submit a PR for this later. meanwhile, emit the finish event in Jest testing
+                if (process.env.NODE_ENV === 'test') {
+                    response.emit('finish');
+                }
+            } else {
+                response.writeHead(500);
+                response.end('Internal Server Error');
+
+                throw err;
+            }
+        }
+    }
+
+    abstract handle(request: HttpRequest, response: HttpResponse): Promise<void> | void;
+}
+
+export class HttpLogPayloadMiddleware extends HttpMiddleware {
+    constructor(private logger: ScopedLogger) {
+        super();
+    }
+
+    async handle(request: HttpRequest, _response: HttpResponse) {
+        const body = await request.readBodyText();
+        this.logger.info('Logging request', {
+            method: request.method,
+            url: request.url,
+            contentType: request.headers['content-type'] ?? '',
+            body: body ?? ''
+        });
+    }
+}

package/src/http/overrides.ts

@@ -0,0 +1,20 @@
+import { HttpRequest } from '@deepkit/http';
+
+import { getAppConfig } from '../app/resolver';
+
+/**
+ * HttpRequest.getRemoteAddress
+ * override to enable x-real-ip header
+ */
+let useRealIpHeader: boolean | null = null;
+HttpRequest.prototype.getRemoteAddress = function () {
+    if (useRealIpHeader === null) {
+        useRealIpHeader = !!getAppConfig().USE_REAL_IP_HEADER;
+    }
+
+    if (this.headers['x-real-ip'] && useRealIpHeader) {
+        return this.headers['x-real-ip'] as string;
+    }
+
+    return this.socket.remoteAddress ?? '';
+};

package/src/http/store.ts

@@ -0,0 +1,86 @@
+import { ClassType } from '@deepkit/core';
+import { HttpRequest, RouteParameterResolver, RouteParameterResolverContext } from '@deepkit/http';
+
+type CacheKey = string | symbol | object;
+const ObjectRefSymbol = Symbol('ObjectRef');
+
+/**
+ * Key generator
+ */
+export function getCompositeCacheKey(target: ClassType, key: symbol) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if ((target as any)[key] === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (target as any)[key] = Symbol(`${target.name}_${key.description}`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (target as any)[key];
+}
+
+/**
+ * Cache implementation
+ */
+type ValueResolver<T> = (request: HttpRequest) => Promise<T>;
+export async function getOrCacheValue<T>(request: HttpRequest, key: CacheKey, resolver: ValueResolver<T>): Promise<T> {
+    if (typeof key === 'function' || typeof key === 'object') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (request.store[ObjectRefSymbol as any] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            request.store[ObjectRefSymbol as any] = new Map<object, T>();
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const map: Map<object, T> = request.store[ObjectRefSymbol as any];
+        if (!map.has(key)) {
+            const value = await resolver(request);
+            map.set(key, value);
+            return value;
+        }
+        return map.get(key) as T;
+    } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (request.store[key as any] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            request.store[key as any] = await resolver(request);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return request.store[key as any];
+    }
+}
+
+export function getCachedValue<T>(request: HttpRequest, key: CacheKey): T | undefined {
+    const isObjectRefKey = typeof key === 'function' || typeof key === 'object';
+    const resolvedKey = isObjectRefKey ? ObjectRefSymbol : key;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const rawValue = request.store[resolvedKey as any];
+    return isObjectRefKey ? rawValue.get(key) : rawValue;
+}
+
+export function getCachedValueOrThrow<T>(request: HttpRequest, key: CacheKey): T {
+    const value = getCachedValue<T>(request, key);
+    if (value === undefined) throw new Error(`Request does not contain cached value [${String(key)}]`);
+    return value;
+}
+
+/**
+ * Generic store value resolver
+ * Requires a previous listener to have attached data to the store
+ */
+export function createCachedValueResolver<T>(key: string | symbol | object, isRequired = true) {
+    const getter = isRequired ? getCachedValueOrThrow : getCachedValue;
+    return class implements RouteParameterResolver {
+        async resolve(context: RouteParameterResolverContext): Promise<T | undefined> {
+            return getter(context.request, key) ?? undefined;
+        }
+    };
+}
+
+/**
+ * Generic store value resolver with cache miss lookup
+ */
+export function createCachingParameterResolver<T>(key: string | symbol | object, lookupFn: (context: RouteParameterResolverContext) => Promise<T>) {
+    return class implements RouteParameterResolver {
+        async resolve(context: RouteParameterResolverContext): Promise<T | undefined> {
+            return getOrCacheValue(context.request, key, async () => lookupFn(context));
+        }
+    };
+}

package/src/http/uploads.ts

@@ -0,0 +1,6 @@
+export class FileUpload {
+    path!: string;
+    size!: number;
+    type!: string;
+    originalName!: string;
+}