@x-9lab/xlab 1.0.0-alpha.2 → 1.0.1

package/@types/components/cache/lru.d.ts

@@ -6,6 +6,13 @@
  */
 declare function create(cacheName: string, conf: Record<string, XLab.JsonValue>): any;
 export { create };
+/**
+ * 获取一个缓存实例
+ * @param name 缓存名称
+ * @param conf 缓存配置
+ */
+declare function get(name: string, conf?: Record<string, XLab.JsonValue>): any;
+export { get };
 /**
  * 获取当前缓存实例数量
  * @return 缓存数量

package/@types/components/{common.d.ts → common/index.d.ts}

@@ -57,33 +57,49 @@ export { fix0 };
 /**
  * 格式化时间
  * @param  format 日期格式
- * @param  date   时间戳
+ * @param  ts     时间戳
  * @return        格式化后的时间
  */
 declare function date(format: string, ts: number): string;
 /**
  * 格式化时间
  * @param  format 日期格式
- * @param  date   日期字符串
+ * @param  ts     日期字符串
  * @return        格式化后的时间
  */
 declare function date(format: string, ts: string): string;
 /**
  * 格式化时间
  * @param  format 日期格式
- * @param  date   日期对象
+ * @param  ts     日期对象
  * @return        格式化后的时间
  */
 declare function date(format: string, ts: Date): string;
 export { date };
 /**
  * 生成操作结果数据对象
- * @param  status 布尔，操作结果
+ * @param  status 返回码
  * @param  result 返回的数据，数据格式根据具体模块而定
  * @param  msg    返回的提示性信息
  * @return        数据对象
  */
-declare function responseResult<T = any>(status: boolean, result?: T, msg?: string): XLab.IStdRes<any>;
+declare function responseResult<T = any>(status: number, result?: T, msg?: string): XLab.IStdRes;
+/**
+ * 生成操作结果数据对象
+ * @param  status 操作结果
+ * @param  result 返回的数据，数据格式根据具体模块而定
+ * @param  msg    返回的提示性信息
+ * @return        数据对象
+ */
+declare function responseResult<T = any>(status: boolean, result?: T, msg?: string): XLab.IStdRes;
+/**
+ * 生成操作结果数据对象
+ * @param  status 返回结果数据
+ * @param  result 返回的数据，数据格式根据具体模块而定
+ * @param  msg    返回的提示性信息
+ * @return        数据对象
+ */
+declare function responseResult<T = any>(status: XLab.ICodeItem, result?: T, msg?: string): XLab.IStdRes;
 export { responseResult };
 /**
  * 根据传入的参数生成一个 MD5 值
@@ -109,6 +125,7 @@ declare function promiseWapper(...args: any[]): Promise<unknown>;
 export { promiseWapper };
 /**
  * 封装一个 promise 形式的 request 方法
+ * @deprecated 请直接使用 component 中的 request 模块
  */
 declare function requestWapper<T = any>(...args: any[]): Promise<unknown>;
 export { requestWapper };
@@ -151,3 +168,16 @@ export { checkFileStat };
 /**获取真正可执行的模块 */
 declare function getRealDefaultMod(mod: any): any;
 export { getRealDefaultMod };
+/**
+* 休眠随机时间
+* @param time 随机时间范围
+* @property min 最小时间(ms)
+* @property max 最大时间(ms)
+*/
+declare function sleep(time: [min: number, max: number]): Promise<boolean>;
+/**
+ * 休眠
+ * @param time 休眠时间(ms)
+ */
+declare function sleep(time: number): Promise<boolean>;
+export { sleep };

package/@types/components/request/index.d.ts

@@ -0,0 +1,51 @@
+import type { RequestInit } from "node-fetch";
+/**支持的返回数据类型 */
+declare type IFetchType = "text" | "json" | "blob" | "buffer" | "arrayBuffer";
+/**请求配置 */
+interface IFetchConfig extends Partial<Omit<RequestInit, "body" | "method">> {
+    /**数据返回类型 */
+    type?: IFetchType;
+    /**是否强制同源 */
+    sameOrigin?: boolean;
+    /**请求自动重试次数 */
+    retry?: number;
+    /**自动重试间隔时间 */
+    retryDelay?: number;
+    /**是否自动追加随机数retry，默认 false */
+    random?: boolean;
+    /**数据返回时的钩子 */
+    onResponse?: (res?: Response) => Promise<unknown>;
+}
+export type { IFetchConfig };
+/**给指定对象增加一个随机字符串 */
+declare function setRandomStr(query: any): void;
+export { setRandomStr };
+/**设置默认 Headers */
+declare function setDefHeaders(headers: Record<string, any>): void;
+export { setDefHeaders };
+/**
+ * 获取数据
+ * @param type              请求类型
+ * @param uri               请求地址
+ * @param query             请求参数
+ * @param data              发送数据
+ * @param config            请求配置
+ * @param needProcessConfig 是否需要处理配置
+ */
+declare function httpFetch<T = unknown>(type: string, uri: string, query?: Record<string, any>, data?: any, config?: IFetchConfig, retry?: number, needProcessConfig?: boolean): any;
+export { httpFetch as fetch };
+/**
+ * 发起一个 get 请求
+ * @param uri   请求地址
+ * @param query 请求参数
+ */
+declare function requsetGet<T = unknown>(uri: string, query?: Record<string, any>, config?: IFetchConfig): Promise<any>;
+export { requsetGet as get };
+/**
+ * 发起一个 post 请求
+ * @param uri   请求地址
+ * @param query 请求参数
+ * @param data  请求数据
+ */
+declare function requestPost<T>(uri: string, query?: any, data?: any, config?: IFetchConfig): Promise<any>;
+export { requestPost as post };

package/@types/components/request/resolve-uri.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 解析请求别名
+ * @param uri 请求地址
+ */
+declare function resolve(uri: string): string;
+export default resolve;

package/@types/global.d.ts

@@ -1,27 +1,6 @@
+import type { InternalComponents } from "./components";
 export type { IPlat } from "./components/platform";
 import type Koa from "koa";
-/**内置组件 */
-interface InternalComponents {
-    assets: typeof import("./components/assets");
-    cache: typeof import("./components/cache");
-    cluster: typeof import("./components/cluster");
-    combo: typeof import("./components/combo");
-    header: typeof import("./components/header");
-    "html-processor": typeof import("./components/html-processor");
-    injection: typeof import("./components/injection");
-    "js-processor": typeof import("./components/js-processor");
-    md5: typeof import("./components/md5");
-    mime: typeof import("./components/mime");
-    platform: typeof import("./components/platform");
-    querystring: typeof import("./components/querystring");
-    redirect: typeof import("./components/redirect");
-    uuid: typeof import("./components/uuid");
-    version: typeof import("./components/version");
-    cron: typeof import("./components/cron");
-    log: typeof import("./components/log");
-    "return-code": typeof import("./components/return-code");
-    common: typeof import("./components/common");
-}
 declare global {
     /**全局日志对象 */
     var log: any;
@@ -42,13 +21,13 @@ declare global {
     * @param  name model 名称
     * @return      model 模块
     */
-    function requireModel<T = any>(name: string): T;
+    function requireModel<T extends XLab.IModels[K], K extends keyof XLab.IModels>(name: K): T;
     /**
     * 全局获取 service 的方法
     * @param  name service 名称
     * @return      service 模块
     */
-    function requireService<T = any>(name: string): T;
+    function requireService<T extends XLab.IServices[K], K extends keyof XLab.IServices>(name: K): T;
     /**
      * 获取系统配置
      */
@@ -85,6 +64,12 @@ declare global {
         interface CompositeObject {
             [key: string]: CompositeValue;
         }
+        /**业务服务 */
+        interface IServices {
+        }
+        /**业务数据模型 */
+        interface IModels {
+        }
         /**标准返回数据 */
         interface IStdRes<T = any> {
             /**业务执行状态码 */
@@ -131,6 +116,10 @@ declare global {
             strictSSL?: boolean;
             /**页端注入的 api 设置 */
             apis?: Record<string, string>;
+            /**内部服务域名 */
+            internalServers?: Record<string, string>;
+            /**内部服务地址 */
+            internalApis?: Record<string, string>;
             /**服务 ip 地址 */
             ip?: string;
             /**本地是否存在本地开发配置文件 config.lo.json */
@@ -166,12 +155,14 @@ declare global {
             /**静态资源缓存时间 */
             staticResourceCacheTime?: number;
         }
+        /**业务错误数据对象 */
         interface ICodeItem {
             /**错误码 */
             errorcode: number;
             /**错误信息 */
             msg: string;
         }
+        /**业务错误定义 */
         type ICodeDetail = Record<string, ICodeItem>;
     }
 }

package/README.md

@@ -14,6 +14,19 @@ X-9lab 通用服务端
         }
     }
     ```
+- `watch` 模式
+    `xlab` 支持自动重启业务，开发中使用该功能可以减少大量手动重启业务的操作。
+    启用方式：
+    - 启动命令使用 `w` 参数
+    - 在配置文件中开启
+        ```js
+        const { NODE_ENV } = process.env;
+        module.exports = {
+            "watch": {
+                "enable": NODE_ENV === "development"
+            }
+        }
+        ```
 - 除了静态资源，服务端业务需要放在项目根目录下的 `@server` 目录中
 - 支持业务自定义以下内容 (无特殊说明的都是存放在 @server 目录中)
     - 配置项，存放于 `@config` 目录
@@ -83,14 +96,55 @@ X-9lab 通用服务端
     function setSysConfig(conf: XLab.IConfig): void;
     ```
 - `requireModel` 全局获取 model 的方法
+    该方法只是为获取 model 提供一个快捷方式，也可以通过正常的方式去 require
+    - 存放路径 `business/@models`
+    - 使用方式
+        ```js
+        const { testModel } = requireModel("test");
+        ```
+    - 类型支持
+        由于 `requireModel` 是一个 `xlab` 的内置方法没有业务本身的 model 定义，因此需要业务方自行追加。出于管理方面的考虑，建议将所有的 model 定义放在一个文件中
+        ```ts
+        declare global {
+            namespace XLab {
+                interface IModels {
+                    /**测试 model */
+                    test: typeof import("./business/@models/test");
+                }
+            }
+        }
+        export { }
+        ```
 - `requireService` 全局获取 service 的方法
+    该方法只是为获取 service 提供一个快捷方式，也可以通过正常的方式去 require
+    - 存放路径 `business/@services`
+    - 使用方式
+        ```js
+        const { testFn } = requireService("test");
+        ```
+    - 类型支持
+        由于 `requireService` 是一个 `xlab` 的内置方法没有业务本身的 service 定义，因此需要业务方自行追加。出于管理方面的考虑，建议将所有的 service 定义放在一个文件中
+        ```ts
+        declare global {
+            namespace XLab {
+                interface IServices {
+                    /**测试 model */
+                    test: typeof import("./business/@services/test");
+                }
+            }
+        }
+        export { }
+        ```
 
 #### Namespace `XLab`
 `XLab` 提供了一些标准化的定义及系统配置
 - `IStdRes` 标准返回数据
 - `IConfig` 系统配置对象
+    - 外部模块追加配置项
 - `ICodeItem` 错误信息对象
 - `ICodeDetail` 错误定义
+- `IServices` 业务 services 定义
+- `IModels` 业务 model 定义
 
 ### 配置项
 |名称|类型|默认值|说明|

package/dist/bin/watch.js

@@ -1,7 +1,7 @@
 "use strict";
 const { date  } = require("@x-drive/utils");
 const crossSpawn = require("cross-spawn");
-colors = require("colors/safe");
+const colors = require("colors/safe");
 const path = require("path");
 const fs = require("fs");
 /**输出内容名称 */ const X_LAB_STR = colors.bold(colors.cyan("🛸 XLab"));

package/dist/bin/xlab

@@ -16,34 +16,38 @@ const cli = new Liftoff({
 
 const hasWatch = argv.w || argv.watch;
 
-cli.launch(
+function onLaunch(env) {
+    let config = {
+        "watch": {
+            "enable": false
+        }
+    }
+    if (env.configPath) {
+        try {
+            let customConfig = require(env.configPath);
+            if (customConfig) {
+                merge(config, customConfig);
+            }
+        } catch (e) { }
+    }
+    if (hasWatch) {
+        config.watch.enable = true;
+    }
+    if (config.watch && config.watch.enable) {
+        const watch = require("./watch");
+        watch(config.watch);
+    } else {
+        const server = require("../server");
+        server.boot();
+    }
+}
+
+cli.prepare(
     {
         "cwd": argv.r || argv.root
         , "configPath": argv.f || argv.file
     }
     , function (env) {
-        let config = {
-            "watch": {
-                "enable": false
-            }
-        }
-        if (env.configPath) {
-            try {
-                let customConfig = require(env.configPath);
-                if (customConfig) {
-                    merge(config, customConfig);
-                }
-            } catch (e) { }
-        }
-        if (hasWatch) {
-            config.watch.enable = true;
-        }
-        if (config.watch && config.watch.enable) {
-            const watch = require("./watch");
-            watch(config.watch);
-        } else {
-            const server = require("../server");
-            server.boot();
-        }
+        cli.execute(env, onLaunch);
     }
 );

package/dist/components/cache/lru.js

@@ -10,8 +10,10 @@ function _export(target, all) {
 }
 _export(exports, {
     create: ()=>create,
+    get: ()=>get,
     len: ()=>len
 });
+const _utils = require("@x-drive/utils");
 const _lruCache = /*#__PURE__*/ _interopRequireDefault(require("lru-cache"));
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
@@ -67,6 +69,22 @@ const CACHE_LIST = [];
     }
     return LRU_CACHES[cacheName];
 }
+/**
+ * 获取一个缓存实例
+ * @param name 缓存名称
+ * @param conf 缓存配置
+ */ function get(name, conf) {
+    if (!(0, _utils.isString)(name)) {
+        throw new Error("必须指定缓存名称");
+    }
+    if (LRU_CACHES[name]) {
+        return LRU_CACHES[name];
+    }
+    if ((0, _utils.isObject)(conf)) {
+        return create(name, conf);
+    }
+    throw new Error(`找不到缓存 ${name}, 你可以先创建再调用本方法获取,或传入配置对象自动生成`);
+}
 /**
  * 获取当前缓存实例数量
  * @return 缓存数量

package/dist/components/{common.js → common/index.js}

@@ -26,11 +26,12 @@ _export(exports, {
     toJsonp: ()=>toJsonp,
     walk: ()=>walk,
     checkFileStat: ()=>checkFileStat,
-    getRealDefaultMod: ()=>getRealDefaultMod
+    getRealDefaultMod: ()=>getRealDefaultMod,
+    sleep: ()=>sleep
 });
-const _returnCode = require("./return-code");
+const _utils = require("@x-drive/utils");
+const _returnCode = require("../return-code");
 const _querystring = /*#__PURE__*/ _interopRequireDefault(require("querystring"));
-const _request = /*#__PURE__*/ _interopRequireDefault(require("request"));
 const _crypto = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
 const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
 const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
@@ -40,6 +41,12 @@ function _interopRequireDefault(obj) {
     };
 }
 var logger;
+function checkLogger() {
+    if (!logger) {
+        logger = log.getLogger("common");
+    }
+    return logger;
+}
 /**
  * ascii字符串转为base64字符串
  * @param  str 要转化的字符串
@@ -138,7 +145,7 @@ const format_exp = /[YymndjNwaAghGHis]/g;
 /**
  * 格式化时间
  * @param  format 日期格式
- * @param  date   日期数据(时间戳, 字符串)
+ * @param  ts     日期数据(时间戳, 字符串)
  * @return        格式化后的时间
  */ function date(format, ts) {
     ts = new Date(ts);
@@ -187,7 +194,7 @@ const format_exp = /[YymndjNwaAghGHis]/g;
  * @param  msg    返回的提示性信息
  * @return        数据对象
  */ function responseResult(status, result, msg) {
-    var code = (0, _returnCode.getReturnCode)(status);
+    var code = (0, _utils.isObject)(status) ? status : (0, _returnCode.getReturnCode)(status);
     var dat = {
         "success": code.errorcode === 0,
         "code": code.errorcode,
@@ -240,16 +247,10 @@ const format_exp = /[YymndjNwaAghGHis]/g;
 }
 /**
  * 封装一个 promise 形式的 request 方法
+ * @deprecated 请直接使用 component 中的 request 模块
  */ function requestWapper(...args) {
-    return new Promise(function(resolve, reject) {
-        args.push(function(err, res, body) {
-            if (err) {
-                reject(err);
-            } else {
-                resolve(body);
-            }
-        });
-        _request.default.apply(_request.default, args);
+    return new Promise(function(_, reject) {
+        reject(new Error("请直接使用 component 中的 request 模块"));
     });
 }
 /**
@@ -261,9 +262,7 @@ const format_exp = /[YymndjNwaAghGHis]/g;
     try {
         re = JSON.parse(data);
     } catch (err) {
-        if (!logger) {
-            log.getLogger("common");
-        }
+        checkLogger();
         logger.error("Pares create menu return data fail.", data);
         return null;
     }
@@ -322,3 +321,13 @@ const format_exp = /[YymndjNwaAghGHis]/g;
     }
     return mod;
 }
+async function sleep(time) {
+    const delay = (0, _utils.isArray)(time) ? (0, _utils.random)(time[1], time[0]) : time;
+    checkLogger();
+    logger.log(`Sleep ${delay} ms`);
+    return await new Promise((res)=>{
+        setTimeout(()=>{
+            res(true);
+        }, delay);
+    });
+}

package/dist/components/index.d.js

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

package/dist/components/request/index.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    setRandomStr: ()=>setRandomStr,
+    setDefHeaders: ()=>setDefHeaders,
+    fetch: ()=>httpFetch,
+    get: ()=>requsetGet,
+    post: ()=>requestPost
+});
+const _utils = require("@x-drive/utils");
+const _resolveUri = /*#__PURE__*/ _interopRequireDefault(require("./resolve-uri"));
+const _common = require("../common");
+const _nodeFetch = /*#__PURE__*/ _interopRequireDefault(require("node-fetch"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const reqLog = log.getLogger("Request");
+/**给指定对象增加一个随机字符串 */ function setRandomStr(query) {
+    if ((0, _utils.isObject)(query) && (0, _utils.isUndefined)(query._)) {
+        query._ = Date.now().toString(16);
+    }
+}
+/**
+ * 处理请求地址上的参数
+ * @param uri    待处理地址
+ * @param params 地址 param 参数
+ */ function processParams(uri, params) {
+    if ((0, _utils.isObject)(params)) {
+        uri = (0, _utils.labelReplace)(uri, params, true, true);
+    }
+    return uri;
+}
+/**
+ * 处理请求上的 search 参数
+ * @param uri    待处理地址
+ * @param query  参数对象
+ */ function processQuery(uri, query) {
+    if ((0, _utils.isObject)(query)) {
+        uri = (0, _utils.addQuery)(uri, query);
+    }
+    return uri;
+}
+/**
+ * 预处理请求地址
+ * @param uri   请求地址
+ * @param query 请求参数
+ */ function preProcessor(uri, query, random = false) {
+    if (random === true) {
+        setRandomStr(query);
+    }
+    return processQuery(processParams(uri, query), query);
+}
+/**默认 Headers */ const DEF_HEADERS = {};
+/**设置默认 Headers */ function setDefHeaders(headers) {
+    if ((0, _utils.isObject)(headers)) {
+        Object.keys(headers).forEach((key)=>DEF_HEADERS[key] = headers[key]);
+    }
+}
+/**获取待发送的请求的 headers */ function getHeaders(headers, uri) {
+    headers = (0, _utils.extend)((0, _utils.copy)(DEF_HEADERS), headers || {});
+    if ((0, _utils.isString)(uri)) {
+        const url = new URL(uri);
+        headers.Host = url.host;
+        headers.Origin = url.origin;
+    }
+    return headers;
+}
+const DEF_CONFIG = {
+    "type": "json",
+    "sameOrigin": false
+};
+/**
+ * 获取数据
+ * @param type              请求类型
+ * @param uri               请求地址
+ * @param query             请求参数
+ * @param data              发送数据
+ * @param config            请求配置
+ * @param needProcessConfig 是否需要处理配置
+ */ async function httpFetch(type, uri, query, data, config, retry, needProcessConfig = true) {
+    if (needProcessConfig) {
+        config = (0, _utils.extend)((0, _utils.copy)(DEF_CONFIG), config || {});
+        if ((0, _utils.isNumber)(config.retry) && config.retry > 0) {
+            retry = config.retry;
+        }
+    }
+    try {
+        const method = type.toUpperCase();
+        const options = {
+            method
+        };
+        Object.keys(config).forEach((key)=>{
+            if (key !== "headers") {
+                options[key] = config[key];
+            }
+        });
+        options.headers = getHeaders(config.headers, config.sameOrigin ? uri : null);
+        const url = preProcessor((0, _resolveUri.default)(uri), query, config === null || config === void 0 ? void 0 : config.random);
+        if (data) {
+            options.body = data;
+        }
+        const resp = await (0, _nodeFetch.default)(url, options);
+        if (resp) {
+            if ((0, _utils.isExecutable)(config.onResponse)) {
+                // @ts-ignore
+                await config.onResponse(resp);
+            }
+            const data1 = await resp[config.type]();
+            return data1;
+        }
+        return null;
+    } catch (e) {
+        reqLog.error(e);
+        if (retry && retry > 0) {
+            if ((0, _utils.isNumber)(config.retryDelay) && config.retryDelay > 0) {
+                await (0, _common.sleep)(config.retryDelay);
+            }
+            retry -= 1;
+            return await httpFetch(type, uri, query, data, config, retry, false);
+        }
+        return null;
+    }
+}
+/**
+ * 发起一个 get 请求
+ * @param uri   请求地址
+ * @param query 请求参数
+ */ async function requsetGet(uri, query, config) {
+    uri = preProcessor((0, _resolveUri.default)(uri), query, config === null || config === void 0 ? void 0 : config.random);
+    return await httpFetch("get", uri, query, null, config);
+}
+/**
+ * 发起一个 post 请求
+ * @param uri   请求地址
+ * @param query 请求参数
+ * @param data  请求数据
+ */ async function requestPost(uri, query, data, config) {
+    if (query && (0, _utils.isUndefined)(data)) {
+        data = query;
+        query = {};
+    }
+    if ((0, _utils.isUndefined)(query)) {
+        query = {};
+    }
+    if ((0, _utils.isUndefined)(data)) {
+        data = {};
+    }
+    uri = (0, _resolveUri.default)(uri);
+    uri = preProcessor((0, _resolveUri.default)(uri), query, config === null || config === void 0 ? void 0 : config.random);
+    return await httpFetch("post", uri, query, data, config);
+}

package/dist/components/request/resolve-uri.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _utils = require("@x-drive/utils");
+const internalServers = getSysConfig("internalServers");
+const Apis = getSysConfig("internalApis");
+const ApiMap = new Map();
+Object.keys(Apis).forEach((key)=>{
+    let url = Apis[key];
+    url = (0, _utils.labelReplace)(url, internalServers, true);
+    ApiMap.set(key, url);
+});
+/**
+ * 解析请求别名
+ * @param uri 请求地址
+ */ function resolve(uri) {
+    var url = ApiMap.get(uri);
+    if (url) {
+        return url;
+    }
+    return uri;
+}
+const _default = resolve;

package/dist/config/process-custom-config-files.js

@@ -53,7 +53,7 @@ function customConfigProcessor(conf, env, envAddConfPath) {
         if ((0, _common.checkFileStat)(APIS_PATH) && conf.passExtApis !== true) {
             let apis = [];
             _fs.default.readdirSync(APIS_PATH).forEach((file)=>{
-                if (_path.default.extname(file) === ".js") {
+                if (!file.startsWith(".") && _path.default.extname(file) === ".js") {
                     apis.push((0, _common.getRealDefaultMod)(require(`${APIS_PATH}/${file}`)));
                 }
             });

package/dist/config/process-def-config-file.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "default", {
 });
 const _common = require("../components/common");
 const _config = /*#__PURE__*/ _interopRequireDefault(require("../@config/config"));
+const _path = require("path");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -18,12 +19,13 @@ function defConfigProcessor(argv) {
         // 绑定 IP
         (_config.default).ip = argv.IP;
     }
+    const apiPath = (0, _path.resolve)("..", "@config", "@apis", "index.js");
     // api 配置文件处理
-    var hasCustomApiConf = (0, _common.checkFileStat)("../@config/@apis/index.js", true);
-    if (hasCustomApiConf) {
-        _config.default.apis = Object.assign(_config.default.apis || {}, (0, _common.getRealDefaultMod)(require("../conf/@conf/index.js")));
+    var hasDefApiConf = (0, _common.checkFileStat)(apiPath, true);
+    if (hasDefApiConf) {
+        _config.default.apis = Object.assign(_config.default.apis || {}, (0, _common.getRealDefaultMod)(require(apiPath)));
     }
-    hasCustomApiConf = null;
+    hasDefApiConf = null;
     return _config.default;
 }
 const _default = defConfigProcessor;

package/dist/middleware/service-mark.js

@@ -6,18 +6,22 @@ Object.defineProperty(exports, "default", {
     enumerable: true,
     get: ()=>_default
 });
+const serverPackge = require("../../package.json");
 var info = {};
 // 业务名称
 info.mark = getSysConfig("mark") || getSysConfig("name");
 // 业务版本
 info.version = getSysConfig("version");
 // 服务端版本
-info.serverVer = require("../../package.json").version;
+info.serverVer = serverPackge.version;
+info.serverName = serverPackge.name;
 // 业务启动时间
 // FIX ME : 服务器不是北京时间的时候这个数据跟实际启动的时间存在时差
-info.date = requireMod("common").date("Y-m-d h:i:s", Date.now());
+info.date = requireMod("common").date("Y-m-d H:i:s", new Date());
 // 模块版本信息
-const MARK = `${info.mark}@${info.version}&${info.serverVer} (${info.date})`;
+const CLIENT_MARK = `${info.mark}@${info.version}`;
+const SERVER_MARK = `${info.serverName}@${info.serverVer}`;
+const MARK = `${CLIENT_MARK},${SERVER_MARK};Startup@${info.date}`;
 info = null;
 /**
  * 处理函数

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@x-9lab/xlab",
-    "version": "1.0.0-alpha.2",
+    "version": "1.0.1",
     "description": "9lab 服务端模块",
-    "versionDesc": "",
+    "versionDesc": "替换 request",
     "scripts": {
         "dev": "swc src -D ./src/bin --config-file .swcrc -d dist -w",
         "compile": "swc src -D ./src/bin --config-file .swcrc -d dist",
@@ -20,20 +20,19 @@
         "@types"
     ],
     "dependencies": {
-        "koa": "2.13.1",
+        "koa": "2.13.4",
         "cron": "1.8.2",
-        "redis": "4.0.3",
-        "log4js": "1.1.1",
-        "liftoff": "3.1.0",
+        "log4js": "^1.1.1",
+        "liftoff": "4.0.0",
         "koa-ejs": "4.3.0",
-        "minimist": "1.2.5",
-        "request": "2.86.0",
-        "koa-body": "4.2.0",
-        "lru-cache": "6.0.0",
+        "minimist": "1.2.6",
+        "koa-body": "5.0.0",
+        "lru-cache": "^6.0.0",
+        "node-fetch": "3.0.0",
         "koa-static": "5.0.0",
-        "koa-router": "10.0.0",
+        "koa-router": "11.0.1",
         "http-proxy": "1.18.1",
-        "koa-compress": "5.0.1",
+        "koa-compress": "5.1.0",
         "@x-drive/utils": "1.1.19"
     },
     "devDependencies": {
@@ -43,7 +42,6 @@
         "colors": "1.4.0",
         "should": "11.2.1",
         "nodemon": "2.0.12",
-        "socket.io": "2.0.3",
         "chokidar": "3.5.3",
         "typescript": "4.3.4",
         "@types/node": "16.11.40",
@@ -56,5 +54,9 @@
     },
     "bin": {
         "xlab": "dist/bin/xlab"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/x-9lab/xlab.git"
     }
 }

package/@types/components/combo/index.d.ts

@@ -1,4 +0,0 @@
-import type Koa from "koa";
-declare function handle(ctx: Koa.Context, next: Koa.Next): Promise<void>;
-declare function init(): typeof handle;
-export { init };

package/@types/middleware/combo.d.ts

@@ -1,2 +0,0 @@
-declare function handler(): (ctx: import("koa").Context, next: import("koa").Next) => Promise<void>;
-export default handler;

package/dist/components/combo/index.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "init", {
-    enumerable: true,
-    get: ()=>init
-});
-const _cache = require("../cache");
-const _header = /*#__PURE__*/ _interopRequireWildcard(require("../header"));
-const _mime = require("../mime");
-const _md5 = require("../md5");
-const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
-const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interopRequireWildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {};
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-var conf;
-// combo 文件缓存时间单位
-// 默认一周
-// @todo 上 cdn 的话需要根据 cdn 的情况调整这个时间
-const COMBO_CACHE_TIME = 1000 * 60 * 60 * 24 * 7;
-// combo 组合缓存
-const comboCache = (0, _cache.local)("JS_CACHE", {
-    "maxAge": COMBO_CACHE_TIME,
-    "max": 200
-});
-// 单独的文件缓存
-// 因为会存在大量公共组件，且有多个入口，当用户从不同的入口进来时会因为组合问题多次调用文件读取
-// 增加单独缓存用于减少应用启动初期或 dns 回源时的瞬间压力
-const fileCache = (0, _cache.local)("JS_FILE_CACHE", {
-    "maxAge": COMBO_CACHE_TIME,
-    "max": 500
-});
-var logger;
-// 扩展名对应的 mime 头
-const extMap = {};
-Object.keys(_mime.MIME).forEach((ext)=>{
-    extMap["." + ext] = _mime.MIME[ext];
-});
-// 处理合并请求，合并请求以两个问号开头
-// 请求示例：http://127.0.0.1:5000/??page-manager/1.0.0/page-manager.js,router/1.0.0/router.js,event/1.0.0/event.js,mobile/1.0.0/message/message.js,envi/1.0.0/envi.js,underscore/1.5.2/underscore.js
-async function handle(ctx, next) {
-    let parsedUrl = ctx.url;
-    let search = ctx.query;
-    // combo 请求对应的缓存 key
-    let cacheKey;
-    // combo 返回内入
-    let content;
-    // 如果不是合并请求，则不进行处理，交给下一步
-    if (!search || parsedUrl.indexOf("??") < 0) {
-        await next();
-        return;
-    }
-    let filesStr = Object.keys(search)[0].substr(1);
-    // 设置文件类型，以便正确返回
-    if (filesStr.indexOf(".js") > -1) {
-        ctx.set("Content-Type", extMap[".js"]);
-    } else {
-        for(let ext in extMap){
-            if (filesStr.indexOf(ext) > -1) {
-                ctx.set("Content-Type", extMap[ext]);
-                break;
-            }
-        }
-    }
-    // 生成缓存 key
-    cacheKey = (0, _md5.md5)(filesStr);
-    // 检查是否有缓存
-    content = comboCache.get(cacheKey);
-    // 没有缓存内容，需要读取并且拼接
-    if (!content) {
-        // 按照逗号拆分成模块 uri
-        let uris = filesStr.split(",");
-        uris = uris.map((uri)=>{
-            let searchIndex = uri.indexOf("?");
-            if (searchIndex > -1) {
-                uri = uri.substring(0, searchIndex);
-            }
-            return uri;
-        });
-        // 根据 uri 查找文件并拼合
-        var files = [];
-        // 读取相关文件
-        uris.forEach((uri)=>{
-            // 优先从文件缓存中读
-            let file = fileCache.get(uri);
-            if (file) {
-                files.push(file);
-            } else {
-                try {
-                    file = _fs.default.readFileSync(_path.default.resolve(conf.root, "c", uri), "utf8");
-                } catch (e) {
-                    logger.error("READ COMBO FILE ERROR", uri, e);
-                }
-                if (file) {
-                    files.push(file);
-                    fileCache.set(uri, file);
-                }
-            }
-        });
-        // 合并文件
-        content = files.join("\n");
-        // 设置缓存
-        comboCache.set(cacheKey, content);
-    } else {
-        ctx.set("Hit-Combo", cacheKey);
-    }
-    // 无法正确读取文件
-    // 交给后续的 404 处理
-    if (content === undefined || content === null) {
-        await next();
-        return;
-    }
-    if (conf.enableComboCache) {
-        // 生产环境默认开启缓存
-        // 缓存时间固定为 6 天
-        _header.cacheControl("6d", ctx);
-        _header.expire("6d", ctx);
-        _header.lastModified(null, ctx);
-    }
-    // 返回数据
-    ctx.body = content;
-}
-function init() {
-    conf = getSysConfig();
-    logger = log.getLogger("common");
-    return handle;
-}

package/dist/middleware/combo.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: ()=>_default
-});
-const _combo = require("../components/combo");
-function handler() {
-    return (0, _combo.init)();
-}
-const _default = handler;