@drunkcod/express-kit 0.0.10 → 0.0.12

package/lib/cjs/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/cjs/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onceAsync = onceAsync;
+exports.mergeCallsAsync = mergeCallsAsync;
+exports.listenAsync = listenAsync;
+exports.closeAsync = closeAsync;
+exports.registerShutdown = registerShutdown;
+__exportStar(require("@drunkcod/express-async"), exports);
+__exportStar(require("./loggable.js"), exports);
+function onceAsync(fn) {
+    let p;
+    return () => {
+        if (p)
+            return p;
+        p = fn();
+        fn = () => p;
+        return p;
+    };
+}
+function mergeCallsAsync(fn) {
+    let p;
+    return async () => {
+        if (!p)
+            p = fn();
+        try {
+            return await p;
+        }
+        finally {
+            p = null;
+        }
+    };
+}
+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);
+        }
+    });
+}
+function closeAsync(server) {
+    return new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+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/cjs/loggable.d.ts

@@ -0,0 +1,5 @@
+export declare function at(message?: string): string;
+export declare function asLoggableError(error: unknown): object;
+export declare function hasOwnJSON(x: object): x is {
+    toJSON(): unknown;
+};

package/lib/cjs/loggable.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.at = at;
+exports.asLoggableError = asLoggableError;
+exports.hasOwnJSON = hasOwnJSON;
+const argis_1 = require("@drunkcod/argis");
+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 (hasOwnJSON(cause))
+        return asLoggableCause(cause.toJSON());
+    if (cause instanceof Error) {
+        const { message, stack, cause: innerCause, ...rest } = cause;
+        return innerCause
+            ? { message, stack, cause: asLoggableCause(innerCause), ...rest }
+            : { message, stack, ...rest };
+    }
+    if ((0, argis_1.hasOwn)(cause, 'cause')) {
+        const { cause: innerCause, ...rest } = cause;
+        return { ...rest, cause: asLoggableCause(innerCause) };
+    }
+    return { ...cause };
+}
+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 });
+}
+function hasOwnJSON(x) {
+    return 'toJSON' in x && typeof x.toJSON === 'function';
+}

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/lib/loggable.d.ts

@@ -1,2 +1,5 @@
 export declare function at(message?: string): string;
 export declare function asLoggableError(error: unknown): object;
+export declare function hasOwnJSON(x: object): x is {
+    toJSON(): unknown;
+};

package/lib/loggable.js

@@ -15,6 +15,8 @@ export function at(message) {
 function asLoggableCause(cause) {
     if (cause == null || typeof cause !== 'object')
         return cause;
+    if (hasOwnJSON(cause))
+        return asLoggableCause(cause.toJSON());
     if (cause instanceof Error) {
         const { message, stack, cause: innerCause, ...rest } = cause;
         return innerCause
@@ -34,3 +36,6 @@ export function asLoggableError(error) {
     Error.captureStackTrace(r, asLoggableError);
     return Object.defineProperty(r, 'stack', { enumerable: true });
 }
+export function hasOwnJSON(x) {
+    return 'toJSON' in x && typeof x.toJSON === 'function';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@drunkcod/express-kit",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Express4 utility things",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -9,12 +9,26 @@
     "lib/**/*",
     "!lib/**/*.spec.*"
   ],
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./lib/index.js",
+        "types": "./lib/index.d.ts"
+      },
+      "require": {
+        "default": "./lib/cjs/index.js",
+        "types": "./lib/cjs/index.d.ts"
+      }
+    }
+  },
   "scripts": {
     "clean": "rimraf lib",
     "compile": "tsc",
+    "cjs:compile": "tsc --module commonjs --outdir lib/cjs",
+    "cjs:fixup": "echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json",
     "test": "NODE_OPTIONS=\"--experimental-vm-modules --no-warnings\" jest",
     "test:all": "npm-run-all \"test --workspaces --include-workspace-root\" --silent",
-    "build": "npm-run-all clean compile --silent"
+    "build": "npm-run-all clean -p compile cjs:compile -s cjs:fixup --silent"
   },
   "keywords": [
     "express"
@@ -25,8 +39,8 @@
     "express-async"
   ],
   "dependencies": {
-    "@drunkcod/argis": "^0.0.5",
-    "@drunkcod/express-async": "^0.0.10"
+    "@drunkcod/argis": "^0.0.7",
+    "@drunkcod/express-async": "^0.0.11"
   },
   "devDependencies": {
     "@drunkcod/ts-jest-esm": "^0.0.1",
@@ -36,6 +50,6 @@
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   }
 }

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

@@ -1,39 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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));
-    }
-}