@jayfong/x-server 1.8.0

package/lib/index.js

@@ -0,0 +1,41 @@
+"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 });
+// @index(['./**/*.ts', '!**/*.test.ts', '!./cli/**'], f => `export * from '${f.path}'`)
+__exportStar(require("./core/define_bus"), exports);
+__exportStar(require("./core/define_handler"), exports);
+__exportStar(require("./core/define_hook"), exports);
+__exportStar(require("./core/define_server"), exports);
+__exportStar(require("./core/define_task"), exports);
+__exportStar(require("./core/handler"), exports);
+__exportStar(require("./core/http_error"), exports);
+__exportStar(require("./core/server"), exports);
+__exportStar(require("./core/types"), exports);
+__exportStar(require("./plugins/base"), exports);
+__exportStar(require("./plugins/cors"), exports);
+__exportStar(require("./plugins/file_parser"), exports);
+__exportStar(require("./plugins/ws_parser"), exports);
+__exportStar(require("./plugins/xml_parser"), exports);
+__exportStar(require("./services/base"), exports);
+__exportStar(require("./services/cache"), exports);
+__exportStar(require("./services/captcha"), exports);
+__exportStar(require("./services/dispose"), exports);
+__exportStar(require("./services/jwt"), exports);
+__exportStar(require("./services/redis"), exports);
+__exportStar(require("./x"), exports);
+// @endindex
+// @ts-ignore
+__exportStar(require(".x/models"), exports);

package/lib/plugins/base.d.ts

@@ -0,0 +1,4 @@
+import { FastifyInstance } from 'fastify';
+export interface BasePlugin {
+    readonly register: (fastify: FastifyInstance) => void;
+}

package/lib/plugins/base.js

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

package/lib/plugins/cors.d.ts

@@ -0,0 +1,21 @@
+import { BasePlugin } from './base';
+import { FastifyInstance } from 'fastify';
+import { MsValue } from 'vtils/date';
+export interface CorsPluginOptions {
+    /**
+     * 允许的来源，支持位于开头的 * 通配符
+     */
+    allow: string[];
+    /**
+     * 预检请求缓存时长
+     */
+    ttl: MsValue;
+}
+/**
+ * CORS 支持插件
+ */
+export declare class CorsPlugin implements BasePlugin {
+    private options;
+    constructor(options: CorsPluginOptions);
+    register(fastify: FastifyInstance): void;
+}

package/lib/plugins/cors.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsPlugin = void 0;
+const fastify_cors_1 = __importDefault(require("fastify-cors"));
+const vtils_1 = require("vtils");
+const date_1 = require("vtils/date");
+/**
+ * CORS 支持插件
+ */
+class CorsPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    register(fastify) {
+        const allows = this.options.allow.map(item => ({
+            type: item.startsWith('*.') ? 'endsWith' : 'equal',
+            domain: item.startsWith('*.') ? item.replace('*.', '.') : item,
+        }));
+        const check = (0, vtils_1.memoize)((origin) => {
+            let i = origin.indexOf(':');
+            let j = origin.indexOf(':', i + 1);
+            i += 3;
+            j = j === -1 ? origin.length : j;
+            const domain = origin.substring(i, j);
+            const pass = allows.some(item => item.type === 'equal'
+                ? domain === item.domain
+                : domain.endsWith(item.domain));
+            return pass;
+        });
+        fastify.register(fastify_cors_1.default, {
+            origin: (origin, cb) => cb(null, origin ? check(origin) : true),
+            maxAge: (0, date_1.ms)(this.options.ttl, true),
+        });
+    }
+}
+exports.CorsPlugin = CorsPlugin;

package/lib/plugins/file_parser.d.ts

@@ -0,0 +1,13 @@
+import { FastifyMultipartOptions } from 'fastify-multipart';
+import { BasePlugin } from './base';
+import { FastifyInstance } from 'fastify';
+export interface FileParserPluginOptions extends FastifyMultipartOptions {
+}
+/**
+ * file 解析器插件
+ */
+export declare class FileParserPlugin implements BasePlugin {
+    private options?;
+    constructor(options?: FileParserPluginOptions | undefined);
+    register(fastify: FastifyInstance): void;
+}

package/lib/plugins/file_parser.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileParserPlugin = void 0;
+const fastify_multipart_1 = __importDefault(require("fastify-multipart"));
+/**
+ * file 解析器插件
+ */
+class FileParserPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    register(fastify) {
+        fastify.register(fastify_multipart_1.default, this.options);
+    }
+}
+exports.FileParserPlugin = FileParserPlugin;

package/lib/plugins/ws_parser.d.ts

@@ -0,0 +1,13 @@
+import { WebsocketPluginOptions } from 'fastify-websocket';
+import { BasePlugin } from './base';
+import { FastifyInstance } from 'fastify';
+export interface WsParserPluginOptions extends WebsocketPluginOptions {
+}
+/**
+ * websocket 解析器插件
+ */
+export declare class WsParserPlugin implements BasePlugin {
+    private options?;
+    constructor(options?: WsParserPluginOptions | undefined);
+    register(fastify: FastifyInstance): void;
+}

package/lib/plugins/ws_parser.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsParserPlugin = void 0;
+const fastify_websocket_1 = __importDefault(require("fastify-websocket"));
+/**
+ * websocket 解析器插件
+ */
+class WsParserPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    register(fastify) {
+        fastify.register(fastify_websocket_1.default, this.options);
+    }
+}
+exports.WsParserPlugin = WsParserPlugin;

package/lib/plugins/xml_parser.d.ts

@@ -0,0 +1,19 @@
+import fxp from 'fast-xml-parser';
+import { BasePlugin } from './base';
+import { FastifyInstance } from 'fastify';
+export interface XmlParserPluginOptions extends Partial<fxp.X2jOptions> {
+    /**
+     * 要处理的 `Content-Type`
+     */
+    contentType?: string | RegExp | string[];
+}
+/**
+ * XML 解析器插件
+ *
+ * 底层解析器是 [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser)
+ */
+export declare class XmlParserPlugin implements BasePlugin {
+    private options?;
+    constructor(options?: XmlParserPluginOptions | undefined);
+    register(fastify: FastifyInstance): void;
+}

package/lib/plugins/xml_parser.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlParserPlugin = void 0;
+const fast_xml_parser_1 = __importDefault(require("fast-xml-parser"));
+/**
+ * XML 解析器插件
+ *
+ * 底层解析器是 [fast-xml-parser](https://github.com/NaturalIntelligence/fast-xml-parser)
+ */
+class XmlParserPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    register(fastify) {
+        const { contentType = ['text/xml', 'application/xml'], ...parseOptions } = this.options || {};
+        fastify.addContentTypeParser(contentType, (req, payload, done) => {
+            let body = '';
+            const handleError = (err) => done(err);
+            const handleData = (data) => (body += data);
+            const handleEnd = () => {
+                let data;
+                let err;
+                try {
+                    data = fast_xml_parser_1.default.parse(body, parseOptions);
+                }
+                catch (_err) {
+                    err = _err;
+                }
+                payload.removeListener('error', handleError);
+                payload.removeListener('data', handleData);
+                payload.removeListener('end', handleEnd);
+                if (err) {
+                    done(err);
+                }
+                else {
+                    done(null, data);
+                }
+            };
+            payload.on('error', handleError);
+            payload.on('data', handleData);
+            payload.on('end', handleEnd);
+        });
+    }
+}
+exports.XmlParserPlugin = XmlParserPlugin;

package/lib/services/base.d.ts

@@ -0,0 +1,4 @@
+export interface BaseService {
+    /** 服务名称 */
+    readonly serviceName: string;
+}

package/lib/services/base.js

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

package/lib/services/cache.d.ts

@@ -0,0 +1,119 @@
+import { AsyncOrSync, IsEmptyArray, NonEmptyArray } from 'vtils/types';
+import { BaseService } from './base';
+import { MsValue } from 'vtils/date';
+export declare type CacheTTL = MsValue;
+export interface CacheOptions {
+    /** 默认过期时间 */
+    defaultTTL: CacheTTL;
+    /** 存储键前缀 */
+    prefix: string;
+}
+declare type Data = {
+    [K in string]: (...args: any[]) => any;
+};
+declare type Key<T extends Data> = keyof T;
+declare type KeyPath<T extends Data> = {
+    [K in keyof T]: T[K] extends (...args: infer X) => any ? IsEmptyArray<X> extends true ? K : [K, ...X] : never;
+}[keyof T];
+declare type KeyPathForNumberValue<T extends Data> = {
+    [K in keyof T]: T[K] extends (...args: infer X) => number ? IsEmptyArray<X> extends true ? K : [K, ...X] : never;
+}[keyof T];
+declare type Value<T extends Data, P extends KeyPath<T>> = ReturnType<T[P extends any[] ? P[0] : P]>;
+export declare class CacheService<TData extends Data = Data, TKey extends Key<TData> = any, TKeyPath extends KeyPath<TData> = any, TKeyPathForNumberValue extends KeyPathForNumberValue<TData> = any> implements BaseService {
+    options: CacheOptions;
+    serviceName: string;
+    private prefix;
+    constructor(options: CacheOptions);
+    private toRedisKey;
+    /**
+     * 设置缓存内容。对象类内容尽量避免使用，以免造成问题。
+     *
+     * @param key 键
+     * @param value 值
+     * @param ttl 缓存时间（单位：时）
+     * @returns 返回设置的缓存内容
+     */
+    set<K extends TKeyPath, V extends Value<TData, K>>(key: K, value: V, ttl?: CacheTTL | ((data: V, defaultTTL: CacheTTL) => CacheTTL)): Promise<V>;
+    /**
+     * 存储值然后返回其对应的键，该键 URL 友好。
+     *
+     * @param value 值
+     * @param ttl 存活时间
+     */
+    save<T>(value: T | ((key: string) => AsyncOrSync<T>), ttl?: CacheTTL): Promise<string>;
+    /**
+     * 获取缓存内容。
+     *
+     * @param key 键
+     * @returns 返回获取到的缓存内容
+     */
+    get<K extends TKeyPath, V extends Value<TData, K>>(key: K): Promise<V | null>;
+    /**
+     * 获取多个缓存内容。
+     *
+     * @param keys 键
+     * @returns 返回获取到的缓存内容
+     */
+    getMany<K extends TKeyPath, V extends Value<TData, K>>(...keys: K[]): Promise<Array<V | null>>;
+    /**
+     * 缓存内容。
+     *
+     * @param key 键
+     * @param action 获取缓存内容的操作
+     * @param ttl 缓存时间（单位：时）
+     * @returns 返回获取到的内容
+     */
+    remember<K extends TKeyPath, V extends Value<TData, K>>(key: K, action: () => V | Promise<V>, ttl?: CacheTTL | ((data: V, defaultTTL: CacheTTL) => CacheTTL)): Promise<V>;
+    /**
+     * 自增。
+     *
+     * @param key 键
+     * @param increment 增量
+     */
+    increase<K extends TKeyPathForNumberValue>(key: K, increment?: number): Promise<number>;
+    /**
+     * 自减。
+     *
+     * @param key 键
+     * @param decrement 减量
+     */
+    decrease<K extends TKeyPathForNumberValue>(key: K, decrement?: number): Promise<number>;
+    /**
+     * 新增元素。
+     *
+     * @param key 键
+     * @param values 元素列表
+     */
+    push<K extends TKeyPath, V extends Value<TData, K>>(key: K, ...values: V[]): Promise<any>;
+    /**
+     * 从头部弹出元素并返回。
+     *
+     * @param key 键
+     * @param count 弹出元素个数
+     */
+    shift<K extends TKeyPath, V extends Value<TData, K>>(key: K, count?: number): Promise<V[]>;
+    /**
+     * 删除缓存。
+     *
+     * @param keys 键列表
+     */
+    remove<K extends TKeyPath>(...keys: K[]): Promise<any>;
+    /**
+     * 清空全部缓存。
+     */
+    clearAll(): Promise<number>;
+    /**
+     * 清空指定前缀的缓存。
+     */
+    clear<K extends TKey>(...prefixes: NonEmptyArray<K>): Promise<number>;
+    /**
+     * 派生出一个指定类型的缓存服务。
+     */
+    fork<TNextData extends Data>(options?: Partial<CacheOptions>): CacheService<TNextData, Key<TNextData>, KeyPath<TNextData>, KeyPathForNumberValue<TNextData>>;
+}
+declare module '../x' {
+    interface X {
+        cache: CacheService;
+    }
+}
+export {};

package/lib/services/cache.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+const cuid_1 = __importDefault(require("cuid"));
+const date_1 = require("vtils/date");
+const x_1 = require("../x");
+class CacheService {
+    constructor(options) {
+        this.options = options;
+        this.serviceName = 'cache';
+        this.prefix = `${options.prefix}:`;
+    }
+    toRedisKey(key) {
+        return `${this.prefix}${Array.isArray(key) ? key.join('_') : String(key)}`;
+    }
+    /**
+     * 设置缓存内容。对象类内容尽量避免使用，以免造成问题。
+     *
+     * @param key 键
+     * @param value 值
+     * @param ttl 缓存时间（单位：时）
+     * @returns 返回设置的缓存内容
+     */
+    async set(key, value, ttl = this.options
+        .defaultTTL) {
+        const redisKey = this.toRedisKey(key);
+        const redisValue = JSON.stringify(value);
+        const redisTtl = typeof ttl === 'function' ? ttl(value, this.options.defaultTTL) : ttl;
+        await x_1.x.redis.set(redisKey, redisValue, 
+        // 毫秒
+        'PX', (0, date_1.ms)(redisTtl));
+        return value;
+    }
+    /**
+     * 存储值然后返回其对应的键，该键 URL 友好。
+     *
+     * @param value 值
+     * @param ttl 存活时间
+     */
+    async save(value, ttl = this.options.defaultTTL) {
+        const key = `X__${(0, cuid_1.default)()}`;
+        await this.set(key, typeof value === 'function' ? await value(key) : value, ttl);
+        return key;
+    }
+    /**
+     * 获取缓存内容。
+     *
+     * @param key 键
+     * @returns 返回获取到的缓存内容
+     */
+    async get(key) {
+        const redisKey = this.toRedisKey(key);
+        const gotValue = await x_1.x.redis.get(redisKey);
+        if (gotValue) {
+            try {
+                return JSON.parse(gotValue);
+            }
+            catch { }
+        }
+        return null;
+    }
+    /**
+     * 获取多个缓存内容。
+     *
+     * @param keys 键
+     * @returns 返回获取到的缓存内容
+     */
+    async getMany(...keys) {
+        const redisKeys = keys.map(key => this.toRedisKey(key));
+        if (!redisKeys.length)
+            return [];
+        const gotValues = await x_1.x.redis.mget(...redisKeys);
+        return gotValues.map(value => {
+            if (value == null)
+                return null;
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    /**
+     * 缓存内容。
+     *
+     * @param key 键
+     * @param action 获取缓存内容的操作
+     * @param ttl 缓存时间（单位：时）
+     * @returns 返回获取到的内容
+     */
+    async remember(key, action, ttl = this.options
+        .defaultTTL) {
+        let value = await this.get(key);
+        if (value === null) {
+            value = await action();
+            await this.set(key, value, ttl);
+        }
+        return value;
+    }
+    /**
+     * 自增。
+     *
+     * @param key 键
+     * @param increment 增量
+     */
+    async increase(key, increment = 1) {
+        const redisKey = this.toRedisKey(key);
+        return x_1.x.redis.incrby(redisKey, increment);
+    }
+    /**
+     * 自减。
+     *
+     * @param key 键
+     * @param decrement 减量
+     */
+    async decrease(key, decrement = 1) {
+        return this.increase(key, -decrement);
+    }
+    /**
+     * 新增元素。
+     *
+     * @param key 键
+     * @param values 元素列表
+     */
+    async push(key, ...values) {
+        const redisKey = this.toRedisKey(key);
+        return x_1.x.redis.rpush(redisKey, ...values.map(value => JSON.stringify(value)));
+    }
+    /**
+     * 从头部弹出元素并返回。
+     *
+     * @param key 键
+     * @param count 弹出元素个数
+     */
+    async shift(key, count = 1) {
+        const redisKey = this.toRedisKey(key);
+        const res = [];
+        for (let i = 0; i < count; i++) {
+            const item = await x_1.x.redis.lpop(redisKey);
+            if (item) {
+                res.push(JSON.parse(item));
+            }
+            else {
+                break;
+            }
+        }
+        return res;
+    }
+    /**
+     * 删除缓存。
+     *
+     * @param keys 键列表
+     */
+    async remove(...keys) {
+        return Promise.all(keys.map(async (key) => {
+            const redisKey = this.toRedisKey(key);
+            return x_1.x.redis.del(redisKey);
+        }));
+    }
+    /**
+     * 清空全部缓存。
+     */
+    async clearAll() {
+        const keys = await x_1.x.redis.keys(`${this.prefix}*`);
+        if (keys.length) {
+            return x_1.x.redis.del(...keys);
+        }
+        return 0;
+    }
+    /**
+     * 清空指定前缀的缓存。
+     */
+    async clear(...prefixes) {
+        const keys = (await Promise.all(prefixes.map(prefix => x_1.x.redis.keys(`${this.toRedisKey(prefix)}*`)))).flat();
+        if (keys.length) {
+            return x_1.x.redis.del(...keys);
+        }
+        return 0;
+    }
+    /**
+     * 派生出一个指定类型的缓存服务。
+     */
+    fork(options) {
+        return options
+            ? new CacheService({
+                ...this.options,
+                ...options,
+            })
+            : this;
+    }
+}
+exports.CacheService = CacheService;

package/lib/services/captcha.d.ts

@@ -0,0 +1,33 @@
+import { BaseService } from './base';
+import type { MsValue } from 'vtils/date';
+export interface CaptchaOptions {
+    /**
+     * 验证码长度
+     */
+    size: number;
+    /**
+     * 验证码存活时长
+     */
+    ttl: MsValue;
+}
+export interface CaptchaGenerateResult {
+    text: string;
+    svg: string;
+    token: string;
+}
+export interface CaptchaVerifyOptions {
+    text: string;
+    token: string;
+}
+export declare class CaptchaService implements BaseService {
+    private options;
+    serviceName: string;
+    constructor(options: CaptchaOptions);
+    generate(): Promise<CaptchaGenerateResult>;
+    verify(options: CaptchaVerifyOptions): Promise<boolean>;
+}
+declare module '../x' {
+    interface X {
+        captcha: CaptchaService;
+    }
+}

package/lib/services/captcha.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptchaService = void 0;
+const svg_captcha_1 = __importDefault(require("svg-captcha"));
+const x_1 = require("../x");
+class CaptchaService {
+    constructor(options) {
+        this.options = options;
+        this.serviceName = 'captcha';
+    }
+    async generate() {
+        const res = svg_captcha_1.default.create({
+            size: this.options.size,
+        });
+        const token = await x_1.x.cache.save(res.text, this.options.ttl);
+        return {
+            text: res.text,
+            svg: res.data,
+            token: token,
+        };
+    }
+    async verify(options) {
+        if (options.text?.length !== this.options.size) {
+            return false;
+        }
+        const expectedText = await x_1.x.cache.get(options.token);
+        await x_1.x.cache.remove(options.token);
+        return options.text === expectedText;
+    }
+}
+exports.CaptchaService = CaptchaService;

package/lib/services/dispose.d.ts

@@ -0,0 +1,17 @@
+import { BaseService } from './base';
+export interface DisposeOptions {
+    disposeOnExit?: boolean;
+}
+export declare class DisposeService implements BaseService {
+    private options?;
+    serviceName: string;
+    constructor(options?: DisposeOptions | undefined);
+    private disposes;
+    add(fn: () => any): void;
+    dispose(): Promise<any[]>;
+}
+declare module '../x' {
+    interface X {
+        dispose: DisposeService;
+    }
+}