@halooj/framework 0.3.0

package/interface.ts

@@ -0,0 +1,44 @@
+import type { ApiHandler } from './api';
+import type { ConnectionHandler, Handler, NotFoundHandler } from './server';
+
+export interface KnownHandlers {
+    NotFound: NotFoundHandler;
+}
+
+type MapHandlerEvents<N extends string, H extends Handler> =
+    Record<`handler/${HookType}/${N}`, (thisArg: H) => VoidReturn>
+    & Record<`handler/${HookWithMethod}/${N}/${Methods}`, (thisArg: H) => VoidReturn>;
+
+type KnownHandlerEvents = {
+    [key in keyof KnownHandlers]: MapHandlerEvents<key, KnownHandlers[key]>
+}[keyof KnownHandlers];
+
+type HandlerEvents =
+    Record<`handler/${HookType}`, (thisArg: Handler) => VoidReturn>
+    & Record<`connection/${'create' | 'active' | 'close'}`, (thisArg: any) => VoidReturn>;
+
+export type VoidReturn = Promise<any> | any;
+export type HookType = 'before-prepare' | 'before' | 'before-operation' | 'after' | 'finish';
+export type Methods = 'get' | 'post' | 'put' | 'delete' | 'patch';
+export type HookWithMethod = Exclude<HookType, 'before-operation'>;
+
+export interface ServerEvents extends KnownHandlerEvents, HandlerEvents {
+    'handler/create': (thisArg: Handler | ConnectionHandler, type: 'ws' | 'http') => VoidReturn;
+    'handler/create/http': (thisArg: Handler) => VoidReturn;
+    'handler/create/ws': (thisArg: ConnectionHandler) => VoidReturn;
+    'handler/init': (thisArg: Handler) => VoidReturn;
+    'handler/error': (thisArg: Handler | ConnectionHandler, e: Error) => VoidReturn;
+    'handler/api/before': (thisArg: ApiHandler) => VoidReturn;
+    'api/before': (args: any) => VoidReturn;
+    [k: `handler/${HookType}/${string}`]: (thisArg: any) => VoidReturn;
+    [k: `handler/${HookWithMethod}/${string}/${Methods}`]: (thisArg: any) => VoidReturn;
+    [k: `handler/register/${string}`]: (HandlerClass: new (...args: any[]) => any) => VoidReturn;
+    [k: `handler/error/${string}`]: (thisArg: Handler, e: Error) => VoidReturn;
+    [k: `handler/api/before/${string}`]: (thisArg: ApiHandler) => VoidReturn;
+    [k: `api/before/${string}`]: (args: any) => VoidReturn;
+}
+
+declare module 'cordis' {
+    interface Events extends ServerEvents {
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@halooj/framework",
+    "version": "0.3.0",
+    "main": "index.ts",
+    "license": "MIT",
+    "repository": "https://github.com/hydro-dev/Hydro",
+    "peerDependencies": {
+        "cordis": "*"
+    },
+    "dependencies": {
+        "@koa/router": "^15.6.0",
+        "@mongodb-js/saslprep": "^1.4.11",
+        "emoji-regex": "^10.6.0",
+        "fs-extra": "^11.3.5",
+        "koa": "^3.2.1",
+        "koa-body": "^8.0.0",
+        "koa-compress": "5.2.1",
+        "path-to-regexp": "^8.4.2",
+        "sanitize-filename": "^1.6.4",
+        "schemastery": "^3.18.0",
+        "shorty.js": "^1.0.1",
+        "ws": "^8.21.0",
+        "@halooj/utils": "^1.5.6"
+    },
+    "devDependencies": {
+        "@types/fs-extra": "^11.0.4",
+        "@types/koa": "^3.0.3",
+        "@types/koa-compress": "^4.0.7",
+        "@types/koa__router": "^12.0.5",
+        "@types/ws": "^8.18.1"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/router.ts

@@ -0,0 +1,69 @@
+import { IncomingMessage } from 'http';
+import KoaRouter, { type RouterInstance } from '@koa/router';
+import { Keys, pathToRegexp } from 'path-to-regexp';
+import type WebSocket from 'ws';
+import type { KoaContext } from './server';
+
+type WebSocketCallback = (socket: WebSocket, request: IncomingMessage, ctx: KoaContext) => void;
+function remove<T>(list: T[], item: T) {
+    const index = list.indexOf(item);
+    if (index >= 0) list.splice(index, 1);
+}
+
+export class WebSocketLayer {
+    clients = new Set<WebSocket>();
+    regexp: RegExp;
+    keys: Keys;
+
+    constructor(path: Parameters<typeof pathToRegexp>[0], public callback?: WebSocketCallback) {
+        const r = pathToRegexp(path);
+        this.regexp = r.regexp;
+        this.keys = r.keys;
+    }
+
+    accept(socket: WebSocket, request: IncomingMessage, ctx: KoaContext) {
+        const match = this.regexp.exec(new URL(request.url, `http://${request.headers.host}`).pathname);
+        if (!match) return false;
+        ctx.params ||= {};
+        for (let i = 0; i < this.keys.length; i++) {
+            ctx.params[this.keys[i].name] = match[i + 1];
+            ctx.HydroContext.args[this.keys[i].name] = match[i + 1];
+        }
+        this.clients.add(socket);
+        socket.on('close', () => {
+            this.clients.delete(socket);
+        });
+        this.callback?.(socket, request, ctx);
+        return true;
+    }
+
+    close() {
+        for (const socket of this.clients) {
+            socket.close();
+        }
+    }
+}
+
+export class Router extends KoaRouter {
+    wsStack: WebSocketLayer[] = [];
+    disposeLastOp = () => null;
+
+    /**
+     * hack into router methods to make sure that koa middlewares are disposable
+     */
+    register(...args: Parameters<RouterInstance['register']>) {
+        const layer = super.register(...args);
+        this.disposeLastOp = () => remove(this.stack, layer);
+        return layer;
+    }
+
+    ws(path: Parameters<typeof pathToRegexp>[0], callback?: WebSocketCallback) {
+        const layer = new WebSocketLayer(path, callback);
+        this.wsStack.push(layer);
+        this.disposeLastOp = () => {
+            layer.close();
+            remove(this.wsStack, layer);
+        };
+        return layer;
+    }
+}

package/serializer.ts

@@ -0,0 +1,11 @@
+import type { HandlerCommon } from './server';
+
+export default function serializer(ignoreSerializeFunction = false, h?: HandlerCommon) {
+    return (k: string, v: any) => {
+        if (k.startsWith('_') && k !== '_id') return undefined;
+        if (typeof v === 'bigint') return `BigInt::${v.toString()}`;
+        if (!ignoreSerializeFunction && v && typeof v === 'object'
+            && 'serialize' in v && typeof v.serialize === 'function') return v.serialize(h);
+        return v;
+    };
+}