@jayfong/x-server 2.119.0 → 3.1.1

package/lib/core/define_task.js

@@ -1,107 +0,0 @@
-import assert from 'node:assert';
-import Queue from 'bull';
-import { ms } from 'vtils';
-import { x } from "../x";
-export function defineTask(options) {
-  const queue = new Queue(options.name, {
-    redis: {
-      ...x.redis.options,
-      // https://github.com/OptimalBits/bull/issues/2186
-      maxRetriesPerRequest: null,
-      enableReadyCheck: false
-    },
-    prefix: `${x.appId}_task`,
-    defaultJobOptions: {
-      // 都设为 true 防止占用内存
-      removeOnComplete: true,
-      removeOnFail: true
-    }
-  });
-  queue.process(options.concurrency || 1, async job => {
-    return options.handle(job.data);
-  });
-  return queue;
-}
-export function defineSliceTask(options) {
-  const task = defineTask({
-    name: options.name,
-    concurrency: 1,
-    handle: async data => {
-      const res = data.count ? await x.redis.multi([['lrange', data.redisKey, `-${data.count}`, '-1'], ['ltrim', data.redisKey, '0', `-${data.count + 1}`]]).exec() : await x.redis.multi([['lrange', data.redisKey, '0', '-1'], ['del', data.redisKey]]).exec();
-      const list = res[0][1].reverse().map(item => JSON.parse(item));
-      if (list.length) {
-        return options.handle(list, data.key);
-      }
-    }
-  });
-  const addAction = async (data, addOptions) => {
-    const redisKeyPrefix = `${x.appId}_batch_task_${options.name}`;
-    const key = addOptions?.key || '';
-    const duration = addOptions?.duration != null ? ms(addOptions.duration) : typeof options.duration === 'function' ? ms(options.duration(key)) : options.duration && ms(options.duration);
-    const threshold = addOptions?.threshold || typeof options.threshold && (typeof options.threshold === 'function' ? options.threshold(key) : options.threshold);
-    const thresholdTimeout = addOptions?.thresholdTimeout != null ? ms(addOptions.thresholdTimeout) : typeof options.thresholdTimeout === 'function' ? ms(options.thresholdTimeout(key)) : options.thresholdTimeout && ms(options.thresholdTimeout);
-    assert(duration != null || threshold != null, '参数 threshold 和 duration 必须至少设置 1 个');
-    const redisKey = !key ? redisKeyPrefix : `${redisKeyPrefix}_${key}`;
-    const res = await x.redis.multi([['llen', redisKey], ['lpush', redisKey, JSON.stringify(data)]]).exec();
-    const count = parseInt(res[0][1], 10) + 1;
-
-    // 仅时段
-    // 1分钟内的合并推送
-    if (duration != null) {
-      if (count === 1) {
-        await task.add({
-          key: key,
-          redisKey: redisKey
-        }, {
-          delay: duration
-        });
-      }
-    }
-    // 仅阈值
-    // 满10条推送
-    else if (threshold != null) {
-      const delayTaskId = redisKey;
-      const prevJob = await task.getJob(delayTaskId);
-
-      // 到达阈值，立即发送
-      if (count === threshold) {
-        await prevJob?.remove();
-        await task.add({
-          key: key,
-          redisKey: redisKey
-        });
-      }
-      // 存在超时设置
-      else if (thresholdTimeout) {
-        if (!prevJob) {
-          await task.add({
-            key: key,
-            redisKey: redisKey
-          }, {
-            jobId: delayTaskId,
-            delay: thresholdTimeout
-          });
-        }
-      }
-    }
-  };
-  const addTask = defineTask({
-    name: `${options.name}_add`,
-    concurrency: 1,
-    handle: async payload => {
-      await addAction(payload.data, payload.options);
-    }
-  });
-  const res = {
-    add: async (data, addOptions) => {
-      const delay = addOptions.delay && ms(addOptions.delay) || 0;
-      await addTask.add({
-        data: data,
-        options: addOptions
-      }, {
-        delay: delay
-      });
-    }
-  };
-  return res;
-}

package/lib/core/get_handler_url.d.ts

@@ -1,2 +0,0 @@
-import type { HandlerPath, HandlerPayloadMap } from '.x/routes';
-export declare function getHandlerUrl<T extends HandlerPath>(path: T, query?: Partial<HandlerPayloadMap[T]>): string;

package/lib/core/get_handler_url.js

@@ -1,7 +0,0 @@
-// @ts-ignore
-
-import { createUrlQueryString } from 'vtils';
-import { x } from "../x";
-export function getHandlerUrl(path, query) {
-  return `${x.env.APP_URL.replace(/\/+$/, '')}${path}${query ? `?${createUrlQueryString(query)}` : ''}`;
-}

package/lib/core/handler.d.ts

@@ -1,16 +0,0 @@
-import type { RequiredDeep } from 'vtils/types';
-import * as vae from 'vtils/vae';
-import type { XHandler } from './types';
-export type { HandlerMethodMap, HandlerPath, HandlerPayloadMap, HandlerResultMap, } from '.x/routes';
-export declare class Handler<TReqData extends any = void, TResData extends any = void, TReqMethod extends XHandler.Method = XHandler.Method, TReqDataRequired = RequiredDeep<TReqData>> {
-    readonly options: XHandler.Options<TReqData, TResData, TReqMethod>;
-    private requestDataSchema;
-    readonly requestDataSchemaVae: vae.VaeSchemaOf<TReqDataRequired>;
-    private requestHandle;
-    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

@@ -1,209 +0,0 @@
-import { HTTPError as GotHTTPError, ParseError as GotParseError, RequestError as GotRequestError, TimeoutError as GotTimeoutError } from 'got';
-import LZString from 'lz-string';
-import { asyncLimit, base64UrlEncode, DataPacker, rot13, toSingleLineString } from 'vtils';
-import * as vae from 'vtils/vae';
-import { getZhCN, yup } from 'vtils/validator';
-import { HttpError } from "../core/http_error";
-import { DisposeService } from "../services/dispose";
-import { ctxStorage } from "./ctx_storage";
-import { HttpRedirect } from "./http_redirect";
-import { Server } from "./server";
-yup.setLocale(getZhCN({
-  getLabel: params => params.label || params.path
-}));
-export class Handler {
-  constructor(options) {
-    this.options = options;
-    this.requestDataSchema = void 0;
-    this.requestDataSchemaVae = void 0;
-    this.requestHandle = void 0;
-    this.handle = async (data, ctx) => {
-      // 前置 hook
-      if (Handler.hooks.length) {
-        await Promise.all(Handler.hooks.map(hook => hook(this.options, data, ctx)));
-      }
-      let useAsyncContext = !!Server.options.useAsyncContext;
-      if (this.options.useAsyncContext != null) {
-        useAsyncContext = this.options.useAsyncContext;
-      }
-      ctx.setHeader('x-trace-id', ctx.traceId);
-      if (this.options.requestMethod === 'WS') {
-        return useAsyncContext ? ctxStorage.run(ctx, () => this.handleWs(data, ctx)) : this.handleWs(data, ctx);
-      }
-      return useAsyncContext ? ctxStorage.run(ctx, () => this.handleHttp(data, ctx)) : this.handleHttp(data, ctx);
-    };
-    this.handleHttp = async (data, ctx) => {
-      // 请求数据解析
-      if (this.options.parseRequestData) {
-        data = await this.options.parseRequestData(data, ctx);
-      }
-      // 请求数据验证
-      // vae
-      if (this.requestDataSchemaVae) {
-        const res = this.requestDataSchemaVae.parse(
-        // @ts-ignore
-        data, {
-          abortEarly: true,
-          preserveUnknownKeys: false
-        });
-        if (res.success) {
-          // @ts-ignore
-          data = res.data;
-        } else {
-          throw new HttpError.BadRequest(
-          // @ts-ignore
-          res.issues[0].message);
-        }
-      }
-      // yup
-      else if (this.requestDataSchema) {
-        try {
-          data = await this.requestDataSchema.validate(data, {
-            abortEarly: true,
-            stripUnknown: true
-          });
-        } catch (err) {
-          throw new HttpError.BadRequest(err.message);
-        }
-      }
-      try {
-        let res = await this.requestHandle(data, ctx);
-        if (res instanceof HttpRedirect) {
-          ctx.redirect(res.url, res.permanently);
-          return {};
-        }
-
-        // 设置响应的 Content-Type 头
-        if (this.options.responseContentType) {
-          ctx.setHeader('Content-Type', this.options.responseContentType);
-        }
-
-        // 打包返回数据
-        if (this.options.responseDataPack) {
-          res = DataPacker.packAsRawType(res);
-        }
-
-        // 混淆返回数据
-        if (this.options.responseDataObfuscate) {
-          res = {
-            '_#': LZString.compress(JSON.stringify(res))
-          };
-        }
-
-        // 加密返回数据
-        if (this.options.responseDataEncrypt && Server.options.responseEncryptAlgorithm) {
-          if (Server.options.responseEncryptAlgorithm === 'simple') {
-            res = {
-              _$: rot13(base64UrlEncode(`${Date.now()}${JSON.stringify(res)}`))
-            };
-          }
-        }
-        return res == null ? {} : res;
-      } catch (err) {
-        // 业务错误
-        if (HttpError.isHttpError(err)) {
-          throw err;
-        }
-        // 网络错误
-        if (err instanceof GotHTTPError || err instanceof GotRequestError || err instanceof GotTimeoutError || err instanceof GotParseError) {
-          console.error('网络请求错误', {
-            error: `${err.code || ''}__${err.name || ''}__${err.message || ''}`,
-            response: err.response?.body && err.options.responseType !== 'buffer' ? toSingleLineString(String(err.response.body), 100) : '',
-            method: err.options.method,
-            url: err.options.url.toString(),
-            headers: JSON.stringify(err.options.headers || {}),
-            query: (err.options.search ?? err.options.searchParams?.toString()) || '',
-            body: (err.options.json ? JSON.stringify(err.options.json) : err.options.form ? new URLSearchParams(err.options.form).toString() : err.options.body?.toString()) || ''
-          });
-        }
-        // 服务器错误
-        else {
-          console.error('服务器错误', err);
-        }
-        throw new HttpError.InternalServerError('服务异常，请稍后再试');
-      }
-    };
-    this.handleWs = async (_data, ctx) => {
-      const dispose = new DisposeService();
-      ctx.ws.on('message', async payload => {
-        try {
-          const _ = JSON.parse(payload.toString('utf8'));
-          const send = data => {
-            ctx.ws.send(JSON.stringify({
-              id: _.id,
-              data: data
-            }));
-          };
-          const process = async (type, fn) => {
-            if (_.type === type) {
-              let sent = false;
-              try {
-                await fn({
-                  data: _.data,
-                  send: data => {
-                    sent = true;
-                    return send(data);
-                  },
-                  dispose: dispose
-                });
-                if (!sent) {
-                  send();
-                }
-              } catch (err) {
-                const _err = HttpError.isHttpError(err) ? err : new HttpError.InternalServerError();
-                send({
-                  statusCode: _err.statusCode,
-                  error: _err.name,
-                  message: _err.message
-                });
-              }
-            }
-          };
-          if (_.type === 'ping') {
-            send();
-          } else {
-            await this.options.handle(process, ctx);
-          }
-        } catch (err) {
-          const _err = HttpError.isHttpError(err) ? err : new HttpError.InternalServerError();
-          ctx.ws.send(JSON.stringify({
-            statusCode: _err.statusCode,
-            error: _err.name,
-            message: _err.message
-          }));
-        }
-      });
-      ctx.ws.on('close', () => {
-        dispose.dispose();
-      });
-    };
-    if (options.requestDataSchemaVae) {
-      const res = typeof options.requestDataSchemaVae === 'function' ? options.requestDataSchemaVae(new vae.VaeSchemaBuilder()) : options.requestDataSchemaVae;
-      this.requestDataSchemaVae = res instanceof vae.VaeSchema ? res : new vae.VaeObjectSchema(res);
-    } else if (options.requestDataSchema) {
-      this.requestDataSchema = options.requestDataSchema(yup);
-    }
-    if (options.concurrency != null) {
-      if (typeof options.concurrency === 'number') {
-        this.requestHandle = asyncLimit(async (data, ctx) => options.handle(data, ctx), {
-          concurrency: options.concurrency
-        });
-      } else {
-        const {
-          count,
-          groupBy
-        } = options.concurrency;
-        this.requestHandle = asyncLimit(async (data, ctx) => options.handle(data, ctx), {
-          concurrency: count,
-          groupBy: groupBy
-        });
-      }
-    } else {
-      this.requestHandle = options.handle;
-    }
-  }
-  static addHook(hook) {
-    this.hooks.push(hook);
-  }
-}
-Handler.hooks = [];

package/lib/core/http_error.d.ts

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

package/lib/core/http_error.js

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