@jayfong/x-server 1.11.0 → 1.11.3

package/lib/_cjs/services/cache.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.CacheService = void 0;
+
+var _cuid = _interopRequireDefault(require("cuid"));
+
+var _date = require("vtils/date");
+
+var _x = require("../x");
+
+class CacheService {
+  constructor(options) {
+    this.options = options;
+    this.serviceName = 'cache';
+    this.prefix = void 0;
+    this.prefix = `${_x.x.appName}:`;
+  }
+
+  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.ttl) {
+    const redisKey = this.toRedisKey(key);
+    const redisValue = JSON.stringify(value);
+    const redisTtl = typeof ttl === 'function' ? ttl(value, this.options.ttl) : ttl;
+    await _x.x.redis.set(redisKey, redisValue, // 毫秒
+    'PX', (0, _date.ms)(redisTtl));
+    return value;
+  }
+  /**
+   * 存储值然后返回其对应的键，该键 URL 友好。
+   *
+   * @param value 值
+   * @param ttl 存活时间
+   */
+
+
+  async save(value, ttl = this.options.ttl) {
+    const key = `X__${(0, _cuid.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.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.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.ttl) {
+    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.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.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.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.x.redis.del(redisKey);
+    }));
+  }
+  /**
+   * 清空全部缓存。
+   */
+
+
+  async clearAll() {
+    const keys = await _x.x.redis.keys(`${this.prefix}*`);
+
+    if (keys.length) {
+      return _x.x.redis.del(...keys);
+    }
+
+    return 0;
+  }
+  /**
+   * 清空指定前缀的缓存。
+   */
+
+
+  async clear(...prefixes) {
+    const keys = (await Promise.all(prefixes.map(prefix => _x.x.redis.keys(`${this.toRedisKey(prefix)}*`)))).flat();
+
+    if (keys.length) {
+      return _x.x.redis.del(...keys);
+    }
+
+    return 0;
+  }
+  /**
+   * 派生出一个指定类型的缓存服务。
+   */
+
+
+  fork(options) {
+    return options ? new CacheService({ ...this.options,
+      ...options
+    }) : this;
+  }
+
+}
+
+exports.CacheService = CacheService;

package/lib/_cjs/services/captcha.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.CaptchaService = void 0;
+
+var _svgCaptcha = _interopRequireDefault(require("svg-captcha"));
+
+var _x = require("../x");
+
+class CaptchaService {
+  constructor(options) {
+    this.options = options;
+    this.serviceName = 'captcha';
+  }
+
+  async generate() {
+    const res = _svgCaptcha.default.create({
+      size: this.options.size
+    });
+
+    const token = await _x.x.cache.save(res.text, this.options.ttl);
+    return {
+      text: res.text,
+      svg: res.data,
+      token: token
+    };
+  }
+
+  async verify(options) {
+    var _options$text;
+
+    if (((_options$text = options.text) == null ? void 0 : _options$text.length) !== this.options.size) {
+      return false;
+    }
+
+    const expectedText = await _x.x.cache.get(options.token);
+    await _x.x.cache.remove(options.token);
+    return options.text === expectedText;
+  }
+
+}
+
+exports.CaptchaService = CaptchaService;

package/lib/_cjs/services/dispose.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.DisposeService = void 0;
+
+var _exitHook = _interopRequireDefault(require("exit-hook"));
+
+class DisposeService {
+  constructor(options) {
+    var _this$options;
+
+    this.options = options;
+    this.serviceName = 'dispose';
+    this.disposes = [];
+
+    if ((_this$options = this.options) != null && _this$options.disposeOnExit) {
+      (0, _exitHook.default)(() => this.dispose());
+    }
+  }
+
+  add(fn) {
+    this.disposes.push(fn);
+  }
+
+  dispose() {
+    return Promise.all(this.disposes.map(dispose => dispose()));
+  }
+
+}
+
+exports.DisposeService = DisposeService;

package/lib/_cjs/services/jwt.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.JwtService = void 0;
+
+var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
+
+var _http_error = require("../core/http_error");
+
+var _date = require("vtils/date");
+
+class JwtService {
+  constructor(options) {
+    this.options = options;
+    this.serviceName = 'jwt';
+  }
+
+  sign(payload) {
+    return _jsonwebtoken.default.sign(payload, this.options.secret, {
+      expiresIn: (0, _date.ms)(this.options.ttl, true)
+    });
+  }
+
+  async verify(token) {
+    return new Promise((resolve, reject) => {
+      _jsonwebtoken.default.verify(token, this.options.secret, {
+        ignoreExpiration: false
+      }, (err, data) => {
+        if (err) {
+          console.log(err);
+          reject(new _http_error.HttpError.Unauthorized());
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  }
+
+  async verifyFromHttpHeaders(headers) {
+    const authorization = headers.authorization || headers['sec-websocket-protocol'] && `Bearer ${headers['sec-websocket-protocol']}` || '';
+
+    if (!authorization) {
+      throw new _http_error.HttpError.Unauthorized();
+    }
+
+    const [scheme, token] = authorization.split(' ');
+
+    if (scheme.toLowerCase() !== 'bearer') {
+      throw new _http_error.HttpError.Unauthorized();
+    }
+
+    return this.verify(token);
+  }
+
+}
+
+exports.JwtService = JwtService;

package/lib/_cjs/services/redis.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.RedisService = void 0;
+
+var _ioredis = _interopRequireDefault(require("ioredis"));
+
+class RedisService extends _ioredis.default {
+  constructor(...args) {
+    super(...args);
+    this.serviceName = 'redis';
+  }
+
+}
+
+exports.RedisService = RedisService;

package/lib/_cjs/x.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.x = void 0;
+
+var _dispose = require("./services/dispose");
+
+const x = {
+  appName: process.env.APP_NAME,
+  register: (...services) => {
+    for (const service of services) {
+      // @ts-ignore
+      x[service.serviceName] = service;
+    }
+  }
+};
+exports.x = x;
+x.register(new _dispose.DisposeService({
+  disposeOnExit: true
+}));