@jayfong/x-server 2.119.0 → 3.1.1

package/lib/_cjs/plugins/xml_parser.js

@@ -1,48 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.XmlParserPlugin = void 0;
-var _fastXmlParser = 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 || {};
-    const xmlParser = new _fastXmlParser.XMLParser(parseOptions);
-    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 = xmlParser.parse(body);
-        } 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/_cjs/services/ai.js

@@ -1,48 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.AiService = void 0;
-var _xRequest = require("@jayfong/x-request");
-var _vtils = require("vtils");
-class AiService {
-  static async ask(payload) {
-    const res = await _xRequest.xr.postJson({
-      url: `${payload.baseUrl}/chat/completions`,
-      headers: {
-        Authorization: `Bearer ${payload.apiKey}`,
-        ...payload.headers
-      },
-      data: {
-        model: payload.model,
-        messages: [...(payload.prompt ? [{
-          role: 'system',
-          content: payload.prompt
-        }] : []), {
-          role: 'user',
-          content: payload.question
-        }],
-        stream: false
-      },
-      timeoutMs: (0, _vtils.ms)('1m'),
-      noThrowHttpErrors: true
-    });
-    if (res.status !== 200) {
-      console.error(res.data);
-      throw new Error(JSON.stringify(res.data));
-    }
-    return {
-      answer: res.data.choices[0].message.content
-    };
-  }
-  constructor(options) {
-    this.options = options;
-    this.serviceName = 'ai';
-  }
-  ask(payload) {
-    return AiService.ask({
-      ...this.options,
-      ...payload
-    });
-  }
-}
-exports.AiService = AiService;

package/lib/_cjs/services/base.js

@@ -1,3 +0,0 @@
-"use strict";
-
-exports.__esModule = true;

package/lib/_cjs/services/cache.js

@@ -1,400 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.CacheService = void 0;
-var _cuid = _interopRequireDefault(require("cuid"));
-var _superjson = _interopRequireDefault(require("superjson"));
-var _vtils = require("vtils");
-var _x = require("../x");
-const nativeJsonSerializer = {
-  stringify: JSON.stringify,
-  parse: JSON.parse
-};
-const superJsonSerializer = {
-  stringify: _superjson.default.stringify,
-  parse: _superjson.default.parse
-};
-class CacheService {
-  constructor(options) {
-    this.options = options;
-    this.serviceName = 'cache';
-    this.prefix = void 0;
-    this.hasMemoryCache = false;
-    this.hasMemoryCacheOnly = false;
-    this.memoryCache = void 0;
-    this.serializer = void 0;
-    this.prefix = `${_x.x.appId}:`;
-    this.hasMemoryCache = !!options.memory;
-    this.hasMemoryCacheOnly = options.memory === 'only';
-    this.serializer = options.serializer == null || options.serializer === 'nativeJson' ? nativeJsonSerializer : options.serializer === 'superJson' ? superJsonSerializer : options.serializer;
-    this.memoryCache = !this.hasMemoryCache ? undefined : new Map();
-  }
-  toRedisKey(key) {
-    return `${this.prefix}${Array.isArray(key) ? key.join('_') : String(key)}`;
-  }
-  serialize(value) {
-    return this.serializer.stringify(value);
-  }
-  deserialize(value) {
-    return this.serializer.parse(value);
-  }
-
-  /**
-   * 设置缓存内容。对象类内容尽量避免使用，以免造成问题。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param value 值
-   * @param ttlOrOptions 缓存时间或选项
-   * @returns 返回设置的缓存内容
-   */
-  async set(key, value, ttlOrOptions) {
-    const ttl = ttlOrOptions == null ? this.options.ttl : typeof ttlOrOptions === 'object' ? ttlOrOptions.ttl : ttlOrOptions;
-    const redisTtl = typeof ttl === 'function' ? ttl(value, this.options.ttl) : ttl;
-    if (redisTtl) {
-      const redisTtlMs = (0, _vtils.ms)(redisTtl);
-      // Redis 的 TTL 不能小于等于 0
-      if (redisTtlMs > 0) {
-        const redisKey = this.toRedisKey(key);
-        if (!this.hasMemoryCacheOnly) {
-          const redisValue = this.serialize(value);
-          await _x.x.redis.set(redisKey, redisValue,
-          // 毫秒
-          'PX', redisTtlMs);
-        }
-        if (this.hasMemoryCache) {
-          this.memoryCache.set(redisKey, value);
-        }
-      }
-    }
-    return value;
-  }
-
-  /**
-   * 存储值然后返回其对应的键，该键 URL 友好。
-   *
-   * @memory 支持
-   * @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;
-  }
-
-  /**
-   * 获取缓存内容。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param options 选项
-   * @returns 返回获取到的缓存内容
-   */
-  async get(key) {
-    const redisKey = this.toRedisKey(key);
-    if (this.hasMemoryCache) {
-      if (this.memoryCache.has(redisKey)) {
-        return this.memoryCache.get(redisKey);
-      } else if (this.hasMemoryCacheOnly) {
-        return null;
-      }
-    }
-    const gotValue = await _x.x.redis.get(redisKey);
-    if (gotValue) {
-      try {
-        const parsedValue = this.deserialize(gotValue);
-        if (this.hasMemoryCache) {
-          this.memoryCache.set(redisKey, parsedValue);
-        }
-        return parsedValue;
-      } catch {}
-    }
-    return null;
-  }
-
-  /**
-   * 获取多个缓存内容。
-   *
-   * @memory 支持
-   * @param keys 键
-   * @returns 返回获取到的缓存内容
-   */
-  async getMany(...keys) {
-    const redisKeys = keys.map(key => this.toRedisKey(key));
-    if (!redisKeys.length) return [];
-    if (this.hasMemoryCacheOnly) {
-      return redisKeys.map(redisKey => this.memoryCache.has(redisKey) ? this.memoryCache.get(redisKey) : null);
-    }
-    if (this.hasMemoryCache) {
-      const result = new Array(keys.length).fill(null);
-      const missIndexes = [];
-      const missRedisKeys = [];
-      for (let i = 0; i < redisKeys.length; i++) {
-        if (this.memoryCache.has(redisKeys[i])) {
-          result[i] = this.memoryCache.get(redisKeys[i]);
-        } else {
-          missIndexes.push(i);
-          missRedisKeys.push(redisKeys[i]);
-        }
-      }
-      if (missRedisKeys.length) {
-        const gotValues = await _x.x.redis.mget(...missRedisKeys);
-        gotValues.forEach((value, idx) => {
-          if (value != null) {
-            try {
-              const parsed = this.deserialize(value);
-              this.memoryCache.set(missRedisKeys[idx], parsed);
-              result[missIndexes[idx]] = parsed;
-            } catch {}
-          }
-        });
-      }
-      return result;
-    }
-    const gotValues = await _x.x.redis.mget(...redisKeys);
-    return gotValues.map(value => {
-      if (value == null) return null;
-      try {
-        return this.deserialize(value);
-      } catch {
-        return null;
-      }
-    });
-  }
-
-  /**
-   * 获取距离过期时间的毫秒数（未设置过期时间返回-1，键不存在返回-2）。
-   * memory=only 模式下内存缓存无 TTL 概念，始终返回-1。
-   *
-   * @memory 支持
-   * @param key 键
-   * @returns 返回距离过期时间的毫秒数
-   */
-  async ttl(key) {
-    if (this.hasMemoryCacheOnly) {
-      return -1;
-    }
-    const redisKey = this.toRedisKey(key);
-    return _x.x.redis.pttl(redisKey);
-  }
-
-  /**
-   * 缓存内容。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param action 获取缓存内容的操作
-   * @param ttlOrOptions 缓存时间或选项
-   * @returns 返回获取到的内容
-   */
-  async remember(key, action, ttlOrOptions) {
-    let value = await this.get(key);
-    if (value === null) {
-      value = await action();
-      await this.set(key, value, ttlOrOptions);
-    }
-    return value;
-  }
-  async rememberMany(raws, key, action, ttlOrOptions) {
-    const keys = raws.map(key);
-    const values = await this.getMany(...keys);
-    const shouldUpdateIndexes = [];
-    for (let i = 0, len = values.length; i < len; i++) {
-      if (values[i] === null) {
-        shouldUpdateIndexes.push(i);
-      }
-    }
-    if (shouldUpdateIndexes.length) {
-      const nextValues = await action(shouldUpdateIndexes.map(i => raws[i]));
-      await Promise.all(nextValues.map(async (nextValue, index) => {
-        values[shouldUpdateIndexes[index]] = nextValue;
-        await this.set(keys[shouldUpdateIndexes[index]], nextValue, ttlOrOptions);
-      }));
-    }
-    return values;
-  }
-
-  /**
-   * 自增。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param increment 增量
-   */
-  async increase(key, increment = 1) {
-    const redisKey = this.toRedisKey(key);
-    if (this.hasMemoryCacheOnly) {
-      const current = this.memoryCache.get(redisKey) ?? 0;
-      const next = current + increment;
-      this.memoryCache.set(redisKey, next);
-      return next;
-    }
-    const result = await _x.x.redis.incrby(redisKey, increment);
-    if (this.hasMemoryCache) {
-      this.memoryCache.delete(redisKey);
-    }
-    return result;
-  }
-
-  /**
-   * 自减。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param decrement 减量
-   */
-  async decrease(key, decrement = 1) {
-    return this.increase(key, -decrement);
-  }
-
-  /**
-   * 新增元素。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param values 元素列表
-   */
-  async push(key, ...values) {
-    const redisKey = this.toRedisKey(key);
-    if (this.hasMemoryCacheOnly) {
-      const arr = this.memoryCache.get(redisKey) ?? [];
-      arr.push(...values);
-      this.memoryCache.set(redisKey, arr);
-      return arr.length;
-    }
-    const result = await _x.x.redis.rpush(redisKey, ...values.map(value => this.serialize(value)));
-    if (this.hasMemoryCache) {
-      this.memoryCache.delete(redisKey);
-    }
-    return result;
-  }
-
-  /**
-   * 从头部弹出元素并返回。
-   *
-   * @memory 支持
-   * @param key 键
-   * @param count 弹出元素个数
-   */
-  async shift(key, count = 1) {
-    const redisKey = this.toRedisKey(key);
-    if (this.hasMemoryCacheOnly) {
-      const arr = this.memoryCache.get(redisKey) ?? [];
-      const res = arr.splice(0, count);
-      if (arr.length) {
-        this.memoryCache.set(redisKey, arr);
-      } else {
-        this.memoryCache.delete(redisKey);
-      }
-      return res;
-    }
-    const res = [];
-    for (let i = 0; i < count; i++) {
-      const item = await _x.x.redis.lpop(redisKey);
-      if (item) {
-        res.push(this.deserialize(item));
-      } else {
-        break;
-      }
-    }
-    if (this.hasMemoryCache && res.length) {
-      this.memoryCache.delete(redisKey);
-    }
-    return res;
-  }
-
-  /**
-   * 删除缓存。
-   *
-   * @memory 支持
-   * @param keys 键列表
-   */
-  async remove(...keys) {
-    if (!keys.length) {
-      return 0;
-    }
-    const redisKeys = keys.map(key => this.toRedisKey(key));
-    let count = 0;
-    if (!this.hasMemoryCacheOnly) {
-      count = await _x.x.redis.del(...redisKeys);
-    }
-    if (this.hasMemoryCache) {
-      let deletedCount = 0;
-      redisKeys.forEach(redisKey => {
-        const isDeleted = this.memoryCache.delete(redisKey);
-        if (isDeleted) {
-          deletedCount++;
-        }
-      });
-      if (this.hasMemoryCacheOnly) {
-        count = deletedCount;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * 清空全部缓存。
-   *
-   * @memory 支持
-   */
-  async clearAll() {
-    let count = 0;
-    if (!this.hasMemoryCacheOnly) {
-      const keys = await _x.x.redis.keys(`${this.prefix}*`);
-      count = keys.length ? await _x.x.redis.del(...keys) : 0;
-    }
-    if (this.hasMemoryCache) {
-      const memoryCacheSize = this.memoryCache.size;
-      this.memoryCache.clear();
-      if (this.hasMemoryCacheOnly) {
-        count = memoryCacheSize;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * 清空指定前缀的缓存。
-   *
-   * @memory 支持
-   */
-  async clear(...prefixes) {
-    if (!prefixes.length) {
-      return 0;
-    }
-    let count = 0;
-    if (!this.hasMemoryCacheOnly) {
-      const keys = (await Promise.all(prefixes.map(prefix => _x.x.redis.keys(`${this.toRedisKey(prefix)}*`)))).flat();
-      count = keys.length ? await _x.x.redis.del(...keys) : 0;
-    }
-    if (this.options.memory) {
-      let deletedCount = 0;
-      this.memoryCache.forEach((_v, k) => {
-        if (prefixes.some(prefix => k.startsWith(this.toRedisKey(prefix)))) {
-          const isDeleted = this.memoryCache.delete(k);
-          if (isDeleted) {
-            deletedCount++;
-          }
-        }
-      });
-      if (this.hasMemoryCacheOnly) {
-        count = deletedCount;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * 派生出一个指定类型的缓存服务。
-   */
-  fork(options) {
-    return options ? new CacheService({
-      ...this.options,
-      ...options
-    }) : this;
-  }
-}
-exports.CacheService = CacheService;

package/lib/_cjs/services/captcha.js

@@ -1,78 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.CaptchaService = void 0;
-var _miniSvgDataUri = _interopRequireDefault(require("mini-svg-data-uri"));
-var _svgCaptcha = _interopRequireDefault(require("svg-captcha"));
-var _vtils = require("vtils");
-var _x = require("../x");
-class CaptchaService {
-  constructor() {
-    this.serviceName = 'captcha';
-    this.charsetMap = {
-      '09': '0123456789'.split(''),
-      '19': '123456789'.split(''),
-      az: 'abcdefghijklmnopqrstuvwxyz'.split(''),
-      AZ: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''),
-      aZ: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''),
-      '0z': '0123456789abcdefghijklmnopqrstuvwxyz'.split(''),
-      '0Z': '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''),
-      '1z': '123456789abcdefghijklmnopqrstuvwxyz'.split(''),
-      '1Z': '123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('')
-    };
-  }
-  async generate(payload) {
-    const chars = this.charsetMap[payload.charset];
-    let code = '';
-    for (let i = 0; i < payload.size; i++) {
-      code += (0, _vtils.sample)(chars);
-    }
-    const token = await _x.x.cache.save({
-      code: code,
-      scene: payload.scene,
-      retryCount: payload.retryCount ?? 0,
-      extra: payload.extra
-    }, payload.ttl);
-    return {
-      token: token,
-      code: code
-    };
-  }
-  async generateDataUrl(payload) {
-    const {
-      text: code,
-      data: svg
-    } = _svgCaptcha.default.create({
-      size: payload.size,
-      charPreset: this.charsetMap[payload.charset].join('')
-    });
-    const token = await _x.x.cache.save({
-      code: code,
-      scene: payload.scene,
-      retryCount: payload.retryCount || 0,
-      extra: payload.extra
-    }, payload.ttl);
-    const dataUrl = (0, _miniSvgDataUri.default)(svg);
-    return {
-      token: token,
-      code: code,
-      dataUrl: dataUrl
-    };
-  }
-  async verify(options) {
-    const expected = await _x.x.cache.get(options.token);
-    if (expected == null) {
-      return false;
-    }
-    if (expected.retryCount === 0) {
-      await _x.x.cache.remove(options.token);
-    } else {
-      expected.retryCount--;
-      const ttl = await _x.x.cache.ttl(options.token);
-      await _x.x.cache.set(options.token, expected, ttl);
-    }
-    return expected.scene === options.scene && options.code.toLowerCase() === expected.code.toLowerCase() && (options.extra ? options.extra(expected.extra) : true);
-  }
-}
-exports.CaptchaService = CaptchaService;