@drunkcod/express-kit 0.0.8 → 0.0.9

package/lib/express-async/index.d.ts

@@ -0,0 +1,39 @@
+import type express from 'express';
+type WithReturn<Type extends (...args: any) => any, R> = Type extends (...args: infer Args) => any ? (...args: Args) => R : never;
+type IsEmptyObject<T extends Record<PropertyKey, unknown>> = [keyof T] extends [never] ? true : false;
+type RequestHandler<T, Req extends express.Request<any> = express.Request<any>> = ((req: Req, res: express.Response<any>) => Promise<T>) | ((req: Req, res: express.Response<any>, next: express.NextFunction) => Promise<T>);
+type RequestParams = [
+    express.Request<any>,
+    express.Response
+] | [express.Request<any>, express.Response, express.NextFunction];
+type ErrorParams = [Error, express.Request<any>, express.Response, express.NextFunction];
+type IsRequestHandler<T, P extends keyof T> = T[P] extends (...args: any) => any ? Parameters<T[P]> extends RequestParams ? P : never : never;
+type IsErrorHandler<T, P extends keyof T> = T[P] extends (...args: any) => any ? Parameters<T[P]> extends ErrorParams ? P : never : never;
+type ErrorHandler<T> = WithReturn<express.ErrorRequestHandler, Promise<T>>;
+type HandlerFns<C> = {
+    [P in keyof C as IsRequestHandler<C, P>]: C[P];
+};
+type HandlerErrorFns<C> = {
+    [P in keyof C as IsErrorHandler<C, P>]: C[P];
+};
+type ControllerHandlerFns<C> = IsEmptyObject<HandlerFns<C>> extends true ? never : HandlerFns<C>;
+type ControllerErrorFns<C> = IsEmptyObject<HandlerErrorFns<C>> extends true ? never : HandlerErrorFns<C>;
+type ControllerFns<C> = ControllerHandlerFns<C> | ControllerErrorFns<C>;
+type HandlerFn<Req, T> = Req extends [never] ? never : ((...args: [request: Req, response: express.Response]) => Promise<T>) | ((...args: [request: Req, response: express.Response, next: express.NextFunction]) => Promise<T>);
+type ErrorHandlerFn<Req, T> = Req extends [never] ? never : ((...args: [errpr: Error, request: Req, response: express.Response, next: express.NextFunction]) => Promise<T>);
+export declare const as: <T>(x: T) => T;
+export declare function asyncHandler<T, Req extends express.Request = express.Request<any>>(fn: HandlerFn<Req, T>): RequestHandler<T>;
+export declare function asyncHandler<T, Req extends express.Request = express.Request<any>>(fn: ErrorHandlerFn<Req, T>): ErrorHandler<T>;
+export declare function boundAsyncHandler<C extends ControllerHandlerFns<C>, T>(x: C, m: keyof ControllerHandlerFns<C>): RequestHandler<unknown>;
+export declare function boundAsyncHandler<C extends ControllerErrorFns<C>, T>(x: C, m: keyof ControllerErrorFns<C>): ErrorHandler<unknown>;
+export declare class AsyncBinder<Controller extends ControllerFns<Controller>> {
+    private controller;
+    static for<Controller extends ControllerFns<Controller>>(controller: Controller): {
+        (m: keyof ControllerHandlerFns<Controller>): RequestHandler<unknown>;
+        (m: keyof ControllerErrorFns<Controller>): ErrorHandler<unknown>;
+    };
+    constructor(controller: Controller);
+    bind(m: keyof ControllerHandlerFns<Controller>): RequestHandler<unknown>;
+    bind(m: keyof ControllerErrorFns<Controller>): ErrorHandler<unknown>;
+}
+export {};

package/lib/express-async/index.js

@@ -0,0 +1,37 @@
+const safeResolve = (fn, ...args) => {
+    try {
+        return Promise.resolve(fn(...args));
+    }
+    catch (reason) {
+        return Promise.reject(reason);
+    }
+};
+export const as = (x) => x;
+export function asyncHandler(fn) {
+    switch (fn.length) {
+        case 2:
+        case 3: return (req, res, next) => safeResolve(fn, req, res, next).catch(next);
+        case 4: return (error, req, res, next) => safeResolve(fn, error, req, res, next).catch(next);
+        default: return (...args) => {
+            const next = args.pop();
+            return safeResolve(fn, ...args, next).catch(next);
+        };
+    }
+}
+export function boundAsyncHandler(x, m) {
+    return asyncHandler(as(x[m]).bind(x));
+}
+export class AsyncBinder {
+    controller;
+    static for(controller) {
+        const self = new AsyncBinder(controller);
+        return self.bind.bind(self);
+    }
+    constructor(controller) {
+        this.controller = controller;
+    }
+    bind(m) {
+        const x = this.controller;
+        return asyncHandler(as(x[m]).bind(x));
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+import type express from 'express';
+export * from '@drunkcod/express-async';
+export * from './loggable.js';
+type AsyncFn<T> = () => Promise<T>;
+type ExpressServer = ReturnType<express.Application['listen']>;
+export type ErrorHandler = (error: Error, request: express.Request, response: express.Response, next: express.NextFunction) => void;
+export declare function onceAsync<T>(fn: AsyncFn<T>): AsyncFn<T>;
+export declare function mergeCallsAsync<T>(fn: AsyncFn<T>): AsyncFn<T>;
+interface Listener<T> {
+    listen(cb: () => void): T;
+    listen(port: number, cb: () => void): T;
+}
+export declare function listenAsync<T>(server: Listener<T>, options?: {
+    port?: number;
+}): Promise<T>;
+export declare function closeAsync(server: {
+    close: (cb: (error?: Error) => void) => void;
+}): Promise<void>;
+export declare function registerShutdown<Server extends ExpressServer = ExpressServer>(server: Server, shutdown?: () => Promise<void>): void;

package/lib/index.js

@@ -0,0 +1,59 @@
+export * from '@drunkcod/express-async';
+export * from './loggable.js';
+export function onceAsync(fn) {
+    let p;
+    return () => {
+        if (p)
+            return p;
+        p = fn();
+        fn = () => p;
+        return p;
+    };
+}
+export function mergeCallsAsync(fn) {
+    let p;
+    return async () => {
+        if (!p)
+            p = fn();
+        try {
+            return await p;
+        }
+        finally {
+            p = null;
+        }
+    };
+}
+export function listenAsync(server, options) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (options?.port) {
+                const r = server.listen(options.port, () => resolve(r));
+            }
+            else {
+                const r = server.listen(() => resolve(r));
+            }
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+export function closeAsync(server) {
+    return new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+export function registerShutdown(server, shutdown) {
+    const onShutdown = onceAsync(async () => {
+        await closeAsync(server);
+        if (shutdown)
+            await shutdown();
+    });
+    process.on('SIGINT', onShutdown);
+    process.on('SIGTERM', onShutdown);
+}

package/lib/loggable.d.ts

@@ -0,0 +1,2 @@
+export declare function at(message?: string): string;
+export declare function asLoggableError(error: unknown): object;

package/lib/loggable.js

@@ -0,0 +1,36 @@
+import { hasOwn } from "@drunkcod/argis";
+export function at(message) {
+    const old = Error.stackTraceLimit;
+    try {
+        const r = { stack: '' };
+        Error.stackTraceLimit = 1;
+        Error.captureStackTrace(r, at);
+        message = message ? `${message} ` : '';
+        return message + r.stack.substring(10);
+    }
+    finally {
+        Error.stackTraceLimit = old;
+    }
+}
+function asLoggableCause(cause) {
+    if (cause == null || typeof cause !== 'object')
+        return cause;
+    if (cause instanceof Error) {
+        const { message, stack, cause: innerCause, ...rest } = cause;
+        return innerCause
+            ? { message, stack, cause: asLoggableCause(innerCause), ...rest }
+            : { message, stack, ...rest };
+    }
+    if (hasOwn(cause, 'cause')) {
+        const { cause: innerCause, ...rest } = cause;
+        return { ...rest, cause: asLoggableCause(innerCause) };
+    }
+    return { ...cause };
+}
+export function asLoggableError(error) {
+    if (error instanceof Error)
+        return asLoggableCause(error);
+    const r = (error && typeof error === 'object') ? asLoggableCause(error) : { message: error };
+    Error.captureStackTrace(r, asLoggableError);
+    return Object.defineProperty(r, 'stack', { enumerable: true });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drunkcod/express-kit",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Express4 utility things",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -26,7 +26,7 @@
   ],
   "dependencies": {
     "@drunkcod/argis": "^0.0.5",
-    "@drunkcod/express-async": "^0.0.7"
+    "@drunkcod/express-async": "^0.0.9"
   },
   "devDependencies": {
     "@drunkcod/ts-jest-esm": "^0.0.1",