@jayfong/x-server 1.8.0

package/lib/cli/templates/routes.ts

@@ -0,0 +1,26 @@
+import * as handlers from './handlers'
+import { Handler, XServer } from '@jayfong/x-server'
+
+const basePathWithHandlers: Array<[string, Record<string, Handler>]> = [
+  // @index('../../src/handlers/**/*.ts', (f, _) => `['${('/'+_.snake(f.path.replace('handlers', '')).replace(/_/g, '/')+'/').replace(/\/{2,}/g, '/')}', handlers.__${_.pascal(f.path.replace('handlers', ''))}__ as any],`)
+  // @endindex
+]
+
+export const routes: XServer.Route[] = basePathWithHandlers.reduce<
+  XServer.Route[]
+>((res, item) => {
+  const validHandlerNames = Object.keys(item[1]).filter(
+    name => !name.startsWith('_') && name !== 'default',
+  )
+  for (const handlerName of validHandlerNames) {
+    const path = item[1][handlerName].options.requestPath || handlerName
+    const paths = Array.isArray(path) ? path : [path]
+    for (const path of paths) {
+      res.push({
+        path: `${item[0]}${path}`,
+        handler: item[1][handlerName],
+      })
+    }
+  }
+  return res
+}, [])

package/lib/cli/templates/tasks.ts

@@ -0,0 +1,2 @@
+// @index('../../src/tasks/**/*.ts', (f, _) => `import '${f.path}'`)
+// @endindex

package/lib/core/define_bus.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+declare class EventBus extends EventEmitter {
+    onReturnOff(event: string, listener: (...args: any[]) => any): () => any;
+}
+export declare function defineBus<T extends Record<string, any>>(): StrictEventEmitter<EventBus, T, T, "addEventListener" | "removeEventListener", "on" | "addListener" | "removeListener" | "once" | "emit" | "off" | "onReturnOff">;
+declare const assignmentCompatibilityHack: unique symbol;
+interface TypeRecord<T, U, V> {
+    ' _emitterType'?: T;
+    ' _eventsType'?: U;
+    ' _emitType'?: V;
+}
+declare type InnerEEMethodReturnType<T, TValue, FValue> = T extends (...args: any[]) => any ? ReturnType<T> extends void | undefined ? FValue : TValue : FValue;
+declare type EEMethodReturnType<T, S extends string, TValue, FValue = void> = S extends keyof T ? InnerEEMethodReturnType<T[S], TValue, FValue> : FValue;
+declare type ListenerType<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+declare type OverriddenMethods<TEmitter, TEventRecord, TEmitRecord = TEventRecord> = {
+    on<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'on', T>;
+    on(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    addListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'addListener', T>;
+    addListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    addEventListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'addEventListener', T>;
+    addEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    removeListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType<TEmitter, 'removeListener', T>;
+    removeListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    removeEventListener<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: any[]) => any): EEMethodReturnType<TEmitter, 'removeEventListener', T>;
+    removeEventListener(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    once<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'once', T>;
+    once(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    emit<P extends keyof TEmitRecord, T>(this: T, event: P, ...args: ListenerType<TEmitRecord[P]>): EEMethodReturnType<TEmitter, 'emit', T>;
+    emit(event: typeof assignmentCompatibilityHack, ...args: any[]): void;
+    off<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): EEMethodReturnType<TEmitter, 'off', T>;
+    off(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): void;
+    onReturnOff<P extends keyof TEventRecord, T>(this: T, event: P, listener: (...args: ListenerType<TEventRecord[P]>) => void): () => any;
+    onReturnOff(event: typeof assignmentCompatibilityHack, listener: (...args: any[]) => any): () => any;
+};
+declare type OverriddenKeys = keyof OverriddenMethods<any, any, any>;
+declare type StrictEventEmitter<TEmitterType, TEventRecord, TEmitRecord = TEventRecord, UnneededMethods extends Exclude<OverriddenKeys, keyof TEmitterType> = Exclude<OverriddenKeys, keyof TEmitterType>, NeededMethods extends Exclude<OverriddenKeys, UnneededMethods> = Exclude<OverriddenKeys, UnneededMethods>> = TypeRecord<TEmitterType, TEventRecord, TEmitRecord> & Pick<TEmitterType, Exclude<keyof TEmitterType, OverriddenKeys>> & Pick<OverriddenMethods<TEmitterType, TEventRecord, TEmitRecord>, NeededMethods>;
+export {};

package/lib/core/define_bus.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineBus = void 0;
+const node_events_1 = require("node:events");
+class EventBus extends node_events_1.EventEmitter {
+    onReturnOff(event, listener) {
+        this.on(event, listener);
+        return () => this.off(event, listener);
+    }
+}
+function defineBus() {
+    const eventEmitter = new EventBus();
+    return eventEmitter;
+}
+exports.defineBus = defineBus;

package/lib/core/define_handler.d.ts

@@ -0,0 +1,16 @@
+import { Handler } from './handler';
+import type { XHandler } from './types';
+export declare function defineHandler<TReqData extends any = void, TResData extends any = void>(options: XHandler.Options<TReqData, TResData, 'POST'>): Handler<TReqData, TResData, "POST">;
+export declare namespace defineHandler {
+    var POST: typeof defineHandler;
+    var GET: <TReqData extends unknown = void, TResData extends unknown = void>(options: XHandler.Options<TReqData, TResData, "GET">) => Handler<TReqData, TResData, "GET">;
+    var FILE: <TReqData extends unknown = void, TResData extends unknown = void>(options: XHandler.Options<TReqData, TResData, "FILE">) => Handler<TReqData, TResData, "FILE">;
+    var WS: <TReqData extends Record<string, [any, any]>>(options: XHandler.Options<{ [K in keyof TReqData]: {
+        request: TReqData[K][0];
+        response: TReqData[K][1];
+    }; }, void, "WS">) => Handler<{ [K in keyof TReqData]: {
+        request: TReqData[K][0];
+        response: TReqData[K][1];
+    }; }, void, "WS">;
+    var XML: <TReqData extends unknown = void, TResData extends unknown = void>(options: XHandler.Options<TReqData, TResData, "XML">) => Handler<TReqData, TResData, "XML">;
+}

package/lib/core/define_handler.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineHandler = void 0;
+const handler_1 = require("./handler");
+function defineHandler(options) {
+    const handler = new handler_1.Handler({
+        ...options,
+        requestMethod: 'POST',
+    });
+    return handler;
+}
+exports.defineHandler = defineHandler;
+defineHandler.POST = defineHandler;
+defineHandler.GET = (options) => {
+    const handler = new handler_1.Handler({
+        ...options,
+        requestMethod: 'GET',
+    });
+    return handler;
+};
+defineHandler.FILE = (options) => {
+    const handler = new handler_1.Handler({
+        ...options,
+        requestMethod: 'FILE',
+    });
+    return handler;
+};
+defineHandler.WS = (options) => {
+    const handler = new handler_1.Handler({
+        ...options,
+        requestMethod: 'WS',
+    });
+    return handler;
+};
+defineHandler.XML = (options) => {
+    const handler = new handler_1.Handler({
+        ...options,
+        requestMethod: 'XML',
+    });
+    return handler;
+};

package/lib/core/define_hook.d.ts

@@ -0,0 +1,2 @@
+import type { XHandler } from './types';
+export declare function defineHook(hook: XHandler.Hook): void;

package/lib/core/define_hook.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineHook = void 0;
+const handler_1 = require("./handler");
+function defineHook(hook) {
+    handler_1.Handler.addHook(hook);
+}
+exports.defineHook = defineHook;

package/lib/core/define_server.d.ts

@@ -0,0 +1,3 @@
+import { Server } from './server';
+import type { XServer } from './types';
+export declare function defineServer(options: XServer.Options): Promise<Server>;

package/lib/core/define_server.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineServer = void 0;
+const server_1 = require("./server");
+async function defineServer(options) {
+    const server = new server_1.Server(options);
+    await server.start();
+    return server;
+}
+exports.defineServer = defineServer;

package/lib/core/define_task.d.ts

@@ -0,0 +1,2 @@
+import type { XTask } from './types';
+export declare function defineTask<T>(options: XTask.Options<T>): Promise<XTask.Task<T>>;

package/lib/core/define_task.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTask = void 0;
+const bull_1 = __importDefault(require("bull"));
+const server_1 = require("./server");
+const x_1 = require("../x");
+async function defineTask(options) {
+    const queue = new bull_1.default(options.name, {
+        redis: x_1.x.redis.options,
+        prefix: `${server_1.Server.options.name}_task`,
+    });
+    queue.process(async (job) => {
+        return options.handle(job.data);
+    });
+    if (options.cron) {
+        queue.add({}, {
+            repeat: {
+                cron: options.cron,
+            },
+        });
+    }
+    return queue;
+}
+exports.defineTask = defineTask;

package/lib/core/handler.d.ts

@@ -0,0 +1,10 @@
+import type { XHandler } from './types';
+export declare class Handler<TReqData extends any = void, TResData extends any = void, TReqMethod extends XHandler.Method = XHandler.Method> {
+    readonly options: XHandler.Options<TReqData, TResData, TReqMethod>;
+    constructor(options: XHandler.Options<TReqData, TResData, TReqMethod>);
+    handle: XHandler.Handle<TReqData, TResData, TReqMethod>;
+    private handleHttp;
+    private handleWs;
+    private static hooks;
+    static addHook(hook: XHandler.Hook): void;
+}

package/lib/core/handler.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+const vtils_1 = require("vtils");
+const dispose_1 = require("../services/dispose");
+const http_error_1 = require("../core/http_error");
+class Handler {
+    constructor(options) {
+        this.options = options;
+        this.handle = async (data, ctx) => {
+            // 前置 hook
+            if (Handler.hooks.length) {
+                await Promise.all(Handler.hooks.map(hook => hook(this.options, data, ctx)));
+            }
+            if (this.options.requestMethod === 'WS') {
+                return this.handleWs(data, ctx);
+            }
+            return this.handleHttp(data, ctx);
+        };
+        this.handleHttp = async (data, ctx) => {
+            let res = await this.options.handle(data, ctx);
+            // 打包返回数据
+            if (this.options.responseDataPack) {
+                res = vtils_1.DataPacker.packAsRawType(res);
+            }
+            return res;
+        };
+        this.handleWs = async (data, ctx) => {
+            const dispose = new dispose_1.DisposeService();
+            ctx.ws.socket.on('message', async (payload) => {
+                try {
+                    const _ = JSON.parse(payload.toString('utf8'));
+                    const send = (data) => {
+                        ctx.ws.socket.send(JSON.stringify({
+                            id: _.id,
+                            data: data,
+                        }));
+                    };
+                    const process = async (type, fn) => {
+                        if (_.type === type) {
+                            await fn({
+                                data: _.data,
+                                send: send,
+                                dispose: dispose,
+                            });
+                        }
+                    };
+                    if (_.type === 'ping') {
+                        send();
+                    }
+                    else {
+                        await this.options.handle(process, ctx);
+                    }
+                }
+                catch (err) {
+                    const _err = http_error_1.HttpError.isHttpError(err)
+                        ? err
+                        : new http_error_1.HttpError.InternalServerError();
+                    ctx.ws.socket.send(JSON.stringify({
+                        statusCode: _err.statusCode,
+                        error: _err.name,
+                        message: _err.message,
+                    }));
+                }
+            });
+            ctx.ws.socket.on('close', () => {
+                dispose.dispose();
+            });
+        };
+    }
+    static addHook(hook) {
+        this.hooks.push(hook);
+    }
+}
+exports.Handler = Handler;
+Handler.hooks = [];

package/lib/core/http_error.d.ts

@@ -0,0 +1,2 @@
+import { default as HttpError } from 'http-errors';
+export { HttpError };

package/lib/core/http_error.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+const http_errors_1 = __importDefault(require("http-errors"));
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return http_errors_1.default; } });

package/lib/core/http_method.d.ts

@@ -0,0 +1,3 @@
+import { HTTPMethods } from 'fastify';
+import { XHandler } from './types';
+export declare const HandlerMethodToHttpMethod: Record<XHandler.Method, HTTPMethods>;

package/lib/core/http_method.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlerMethodToHttpMethod = void 0;
+exports.HandlerMethodToHttpMethod = {
+    GET: 'GET',
+    POST: 'POST',
+    FILE: 'POST',
+    WS: 'GET',
+    XML: 'POST',
+};

package/lib/core/server.d.ts

@@ -0,0 +1,16 @@
+import { XServer } from './types';
+export declare class Server {
+    readonly options: XServer.Options;
+    private fastify;
+    private routes;
+    static options: XServer.Options;
+    constructor(options: XServer.Options);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    private prepareFastify;
+    private startFastify;
+    private applyServices;
+    private applyPlugins;
+    private applyRoutes;
+    private applyAutoClose;
+}

package/lib/core/server.js

@@ -0,0 +1,137 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const vtils_1 = require("vtils");
+const dispose_1 = require("../services/dispose");
+const http_method_1 = require("./http_method");
+const x_1 = require("../x");
+// @ts-ignore
+const routes_1 = require(".x/routes");
+class Server {
+    constructor(options) {
+        this.options = options;
+        this.routes = routes_1.routes;
+        Server.options = options;
+    }
+    async start() {
+        this.applyServices();
+        await this.prepareFastify();
+        this.applyPlugins();
+        await this.applyRoutes();
+        // @ts-ignore
+        await Promise.resolve().then(() => __importStar(require('.x/hooks')));
+        await this.startFastify();
+        // @ts-ignore
+        await Promise.resolve().then(() => __importStar(require('.x/tasks')));
+        await this.applyAutoClose();
+    }
+    async close() {
+        await this.fastify?.close();
+    }
+    async prepareFastify() {
+        this.fastify = (0, fastify_1.default)({
+            logger: process.env.NODE_ENV === 'development'
+                ? {
+                    prettyPrint: true,
+                }
+                : false,
+        });
+    }
+    async startFastify() {
+        await this.fastify.listen({
+            host: this.options.host || '0.0.0.0',
+            port: this.options.port,
+        });
+    }
+    applyServices() {
+        x_1.x.register(new dispose_1.DisposeService({
+            disposeOnExit: true,
+        }), ...(this.options.services || []));
+    }
+    applyPlugins() {
+        const plugins = this.options.plugins || [];
+        for (const plugin of plugins) {
+            plugin.register(this.fastify);
+        }
+    }
+    async applyRoutes() {
+        for (const item of this.routes) {
+            const handlerOptions = item.handler.options;
+            const handlerMethod = handlerOptions.requestMethod || 'POST';
+            const isWS = handlerMethod === 'WS';
+            const serverMethod = isWS
+                ? 'GET'
+                : http_method_1.HandlerMethodToHttpMethod[handlerMethod];
+            this.fastify.route({
+                method: serverMethod,
+                url: item.path,
+                websocket: isWS,
+                handler: async (req, res) => {
+                    if (isWS) {
+                        await item.handler.handle(undefined, {
+                            headers: req.headers,
+                            redirect: undefined,
+                            ws: req,
+                        });
+                        return;
+                    }
+                    let files = {};
+                    if (handlerMethod === 'FILE') {
+                        const part = await req.file();
+                        files = Object.keys(part.fields).reduce((res, name) => {
+                            ;
+                            res[name] = (0, vtils_1.castArray)(part.fields[name]).map(item => item.file ? item : item.value)[0];
+                            return res;
+                        }, {});
+                    }
+                    const data = await item.handler.handle({
+                        // @ts-ignore
+                        ...req.params,
+                        // @ts-ignore
+                        ...req.query,
+                        // @ts-ignore
+                        ...req.body,
+                        ...files,
+                    }, {
+                        headers: req.headers,
+                        redirect: url => res.redirect(url),
+                        ws: undefined,
+                    });
+                    return data;
+                },
+            });
+        }
+    }
+    async applyAutoClose() {
+        x_1.x.dispose.add(() => this.close());
+    }
+}
+exports.Server = Server;
+Server.options = {};

package/lib/core/types.d.ts

@@ -0,0 +1,123 @@
+/// <reference types="node" />
+import { BasePlugin } from '../plugins/base';
+import { BaseService } from '../services/base';
+import type { AsyncOrSync, OneOrMore } from 'vtils/types';
+import type { DisposeService } from '../services/dispose';
+import type { Handler } from './handler';
+import type { IncomingHttpHeaders } from 'http';
+import type { MultipartFile } from 'fastify-multipart';
+import type { Queue } from 'bull';
+import type { SocketStream } from 'fastify-websocket';
+export declare namespace XServer {
+    type Mode = 'development' | 'production';
+    interface Route {
+        /**
+         * 路径
+         */
+        path: string;
+        /**
+         * 处理器
+         */
+        handler: Handler;
+    }
+    interface Options {
+        /**
+         * 应用名称
+         */
+        name: string;
+        /**
+         * 监听主机
+         */
+        host?: string;
+        /**
+         * 监听端口
+         */
+        port: number;
+        /**
+         * 服务列表
+         */
+        services?: BaseService[];
+        /**
+         * 插件列表
+         */
+        plugins?: BasePlugin[];
+    }
+}
+export declare namespace XHandler {
+    type Method = 'GET' | 'POST' | 'FILE' | 'WS' | 'XML';
+    interface ExtraContext {
+    }
+    interface Context extends ExtraContext {
+        /**
+         * 请求头
+         */
+        headers: IncomingHttpHeaders;
+        /**
+         * HTTP 跳转
+         */
+        redirect: (url: string) => void;
+        /**
+         * WS
+         */
+        ws: SocketStream;
+    }
+    type Handle<TReqData extends any = void, TResData extends any = void, TReqMethod extends Method = Method> = (
+    /**
+     * 请求数据，WS 时为一个处理函数
+     */
+    data: TReqMethod extends 'WS' ? <T extends keyof TReqData>(type: T, fn: (payload: {
+        data: TReqData[T]['request'];
+        send: (data: TReqData[T]['response']) => void;
+        dispose: DisposeService;
+    }) => any) => void : TReqData, 
+    /**
+     * 请求上下文
+     */
+    ctx: Context) => AsyncOrSync<TResData>;
+    interface ExtraOptions {
+    }
+    interface Options<TReqData extends any = void, TResData extends any = void, TReqMethod extends Method = Method> extends ExtraOptions {
+        /**
+         * 请求方法
+         *
+         * @default POST
+         */
+        requestMethod?: TReqMethod;
+        /**
+         * 请求路径
+         */
+        requestPath?: OneOrMore<string>;
+        /**
+         * 是否打包返回数据
+         *
+         * @default false
+         */
+        responseDataPack?: boolean;
+        /**
+         * 处理器
+         */
+        handle: Handle<TReqData, TResData, TReqMethod>;
+    }
+    type Hook = (options: Options, ...args: Parameters<Handle>) => AsyncOrSync<void>;
+}
+export declare namespace XTask {
+    interface Options<T> {
+        /**
+         * 任务名称
+         */
+        name: string;
+        /**
+         * 是否作为定时任务
+         *
+         * @see https://crontab.guru/
+         */
+        cron?: string;
+        /**
+         * 处理器
+         */
+        handle: (data: T) => any;
+    }
+    interface Task<T> extends Queue<T> {
+    }
+}
+export declare type XFile = MultipartFile;

package/lib/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+export * from './core/define_bus';
+export * from './core/define_handler';
+export * from './core/define_hook';
+export * from './core/define_server';
+export * from './core/define_task';
+export * from './core/handler';
+export * from './core/http_error';
+export * from './core/server';
+export * from './core/types';
+export * from './plugins/base';
+export * from './plugins/cors';
+export * from './plugins/file_parser';
+export * from './plugins/ws_parser';
+export * from './plugins/xml_parser';
+export * from './services/base';
+export * from './services/cache';
+export * from './services/captcha';
+export * from './services/dispose';
+export * from './services/jwt';
+export * from './services/redis';
+export * from './x';
+export * from '.x/models';