@x-9lab/xlab 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 x-9lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,182 @@
+X-9lab 通用服务端
+=======
+
+## 开发环境配置
+1. 安装 [node](https://nodejs.org/) ,需要 10.0.0 以上版本
+
+## 使用
+- 将 `@x-9lab/xlab` 加入到依赖中
+- `package.json` 中调用 `xlab`
+    ```json
+    {
+        "scripts": {
+            "start-dev": "xlab"
+        }
+    }
+    ```
+- 除了静态资源，服务端业务需要放在项目根目录下的 `@server` 目录中
+- 支持业务自定义以下内容 (无特殊说明的都是存放在 @server 目录中)
+    - 配置项，存放于 `@config` 目录
+        - 支持不同环境配置文件
+            - 无中间词缀的 config 文件为生产环境配置文件
+            - 中间词缀为 `dev` 的 config 文件为开发环境配置文件
+            - 中间词缀为`sand` 的 config 文件为沙箱环境配置文件
+            - 中间词缀为`lo` 的 config 文件为本地环境配置文件，该文件不应被提交到仓库
+        - 配置文件按照中间词缀，合并优先级为 `lo > dev = sand > 无`
+            - 开发环境与沙箱环境同时只会根据当前环境取其中一个，因此优先级一样
+    - 服务接口，存放于 `business` 目录
+        - 接口地址
+            - 默认服务接口均以 `api` 开始
+            - 按照目录结构生成 api
+                - 文件名是 `index` 的会被从 api 上先强行去掉
+                - 默认都是 `get` 请求
+        - 支持以下形式定义接口
+            - 模块返回的是数组，则使用文件名做为方法名，并在 api 上去掉文件名
+            - 非数组则文件当作正常的 api 地址
+            - 模块返回为函数的则直接绑定为接口处理函数
+            - 返回是对象则取对应的字段
+                - `method` 接口类型，如 `get` 或 `post`
+                - `middleware` 接口中间件
+                - `handler` 接口处理函数
+    - 自定义逻辑，存放于 `custom` 目录，模块需要导出一个函数作为执行入口
+    - 中间件，存放于 `middleware` 目录
+    - 定时任务，存放于 `cron` 目录
+    - 静态资源，默认存放在项目根目录下的 `public` 目录中
+### 全局对象与函数
+
+#### 全局对象
+- `log` 全局日志对象
+- `masterLog` 只在 master 上输出的日志对象
+
+#### 全局函数
+- `getApp` 获取应用实例对象
+    ```ts
+    /**
+    * 获取应用实例对象
+    */
+    function getApp(): Koa;
+    ```
+- `requireMod` 获取内置组件
+    ```ts
+    /**
+    * 获取内置组件
+    * @param  name 模块名
+    * @return      模块对象
+    */
+    function requireMod<T extends InternalComponents[K], K extends keyof InternalComponents>(name: K): T;
+    ```
+- `getSysConfig` 获取系统配置
+    - 获取全部配置
+    ```js
+    const config = getSysConfig();
+    ```
+    - 获取指定配置
+    ```js
+    const allowCache = getSysConfig("allowCache");
+    ```
+- `setSysConfig` 更新系统配置
+    ```ts
+    /**
+    * 更新系统配置
+    * @param  conf 配置项
+    */
+    function setSysConfig(conf: XLab.IConfig): void;
+    ```
+- `requireModel` 全局获取 model 的方法
+- `requireService` 全局获取 service 的方法
+
+#### Namespace `XLab`
+`XLab` 提供了一些标准化的定义及系统配置
+- `IStdRes` 标准返回数据
+- `IConfig` 系统配置对象
+- `ICodeItem` 错误信息对象
+- `ICodeDetail` 错误定义
+
+### 配置项
+|名称|类型|默认值|说明|
+|-|-|-|-|
+|name|`string`| package.json 中的 name 字段 |服务(应用)名称|
+|version|`string`|package.json 中的 version 字段|版本|
+|env|`string`|development|环境标识|
+|host|`string`| |业务绑定的域名|
+|304|`boolean`| true |是否开启 304 协商缓存|
+|workers|`number`|0|Worker 数量|
+|biServer|`string`||业务服务器地址|
+|protocol|`string`|http|业务服务器协议|
+|debug|`boolean`|false|是否开启 debug 模式|
+|staticMaxage|`number`|1800000|静态文件缓存时间|
+|staticHtmlFileMaxage|`number`|0|静态 html 文件缓存时间|
+|enableComboCache|`boolean`|true|是否开启 Combo 缓存|
+|enableCron|`boolean`|false|是否开启定时任务|
+|middleware|`Array<string | (string | Record<string, any>)[]>`|[]|开启的中间件列表 |
+|custom|`string[]`||自定模块配置|
+|strictSSL|`boolean`||是否启用严格 ssl|
+|apis|`Record<string, string>`|{}|页端注入的 api 设置|
+|hasLo|`boolean`||本地是否存在本地开发配置文件|
+|passExtApis|`boolean`||不处理业务 api|
+|allowCache|`boolean`||是否允许页端缓存|
+|root|`string`|public|静态文件根目录|
+|port|`number`|5000|监听端口|
+|isMaster|`boolean`||是否是主进程|
+|clearLocalStorage|`boolean`||是否每次都强制清除 LocalStorage|
+|pathReplaceRegExp|`string`||处理代理过来多余的地址层级路径替换判断正则|
+|routeMobile|`string`||移动端入口文件地址(旧版逻辑)|
+|launchRouter|`Record<string, string>`||不同端入口地址设置|
+|cron|`{def?: number;}`|{"def": 60}|定时任务设置|
+|injection|`string[]`|[]|注入参数列表|
+|indexPageCacheTime|`number`||首页缓存时间|
+|staticResourceCacheTime|`number`||静态资源缓存时间|
+
+## 文件结构
+
+```
+├── README.md
+├── business
+│   └── @services
+│   └── @models
+│   │  └── forumUser.js
+│   └── ...
+├── components
+│   ├── cache
+│   ├── common.js
+│   └── ...
+├── @config
+│   ├── config.dev.ts
+│   └── config.ts
+├── middleware
+├── cron
+├── public
+├── test
+├── route
+├── private
+│   └── log
+├── package.json
+├── config.js
+├── router.js
+└── server.js
+```
+
+### 说明
+- ``business目录``：前端业务
+- ``@services目录``：业务services
+- ``@models目录``：存放model
+- ``components目录``： 存放当前项目组件
+- ``@config``：存放环境配置，不同环境在名称与文件后缀中间使用不同代号区分
+- ``middleware目录``：存放请求特殊处理模块，一般作为中间件
+- ``public目录``：存放前端资源文件
+- ``cron目录``：存放定时任务文件
+- ``test目录``：存放单元测试
+- ``route目录``：存放不同平台的路由配置
+- ``private目录``：存放业务 log ，或其他服务端相关的内容
+- ``package.json``：nodejs后端所需要的依赖描述文件，即npm的 [package.json](https://www.npmjs.org/doc/files/package.json.html) 文件
+- ``router.js``：路由模块
+- ``server.js``：服务器主模块
+- ``config.js``：配置处理模块
+
+## TODO
+
+- [ ] swc 支持 `--out-file-extension` 后转为直接输出 `.mjs` 文件
+    1. `packgae.json` 增加 `"type": "module"` 设置
+    1. `.swcrc` 中 `module.type` 改为 `es6`
+- [x] 配置文件由 `json` 改为 `ts`
+- [x] 支持各内置模块的完整类型推导

package/dist/@config/config.dev.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const CONFIG = {
+    "304": false,
+    "workers": 0
+};
+const _default = CONFIG;

package/dist/@config/config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const CONFIG = {
+    "host": "",
+    "304": true,
+    "workers": 0,
+    "biServer": "",
+    "protocol": "http",
+    "debug": false,
+    "staticMaxage": 1800000,
+    "staticHtmlFileMaxage": 0,
+    "enableComboCache": true,
+    "enableCron": false,
+    "middleware": [],
+    "strictSSL": false,
+    "launchRouter": {},
+    "root": "public"
+};
+const _default = CONFIG;

package/dist/@config/config.sand.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const CONFIG = {};
+const _default = CONFIG;

package/dist/bin/watch.js

@@ -0,0 +1,145 @@
+"use strict";
+const { date  } = require("@x-drive/utils");
+const crossSpawn = require("cross-spawn");
+colors = require("colors/safe");
+const path = require("path");
+const fs = require("fs");
+/**输出内容名称 */ const X_LAB_STR = colors.bold(colors.cyan("🛸 XLab"));
+/**
+ * 子进程对象
+ * @type child_process.ChildProcess
+ */ var childProcess = null;
+/**
+ * 获取 chokidar
+ * @return {FSWatcher}
+ */ function getChokidar() {
+    try {
+        return require("chokidar");
+    } catch (e) {
+        return null;
+    }
+}
+/**构建 Spawn 启动参数 */ function buildSpawnOptions() {
+    const argvs = process.argv.slice(2);
+    const options = [
+        path.resolve(__dirname, "..", "server.js")
+    ].concat(argvs);
+    return options;
+}
+/**停止 */ function stop() {
+    if (childProcess) {
+        childProcess.kill("SIGTERM");
+    }
+}
+/**启动 */ function start() {
+    childProcess = crossSpawn("node", buildSpawnOptions(), {
+        "stdio": "inherit"
+    }).on("error", (err)=>{
+        console.error(err);
+    }).on("close", (code)=>{
+        if (Number(code) !== 0) {
+            const err = new Error(`子进程退出, Code: ${code}`);
+            err.code = code;
+            // TODO: 自动拉起来？
+            console.error(err);
+        }
+    }).once("exit", ()=>{
+        childProcess.removeAllListeners();
+        childProcess = null;
+    });
+}
+/**日志 */ function log(...rest) {
+    console.log.apply(console, [
+        X_LAB_STR,
+        colors.green(`[${date(new Date(), "Y-m-d H:i:s.M")}]`),
+        ...rest
+    ]);
+}
+/**
+ * 初始化状态
+ * @type {boolean}
+ */ var inited = false;
+/**
+ * @typedef {object} WatchConfig 
+ * @property {string[]=} paths 需要监控的目录 
+ * @property {boolean=} enable 监控是否已启用 
+ */ /**
+ * 启动文件 watch
+ * @param {FSWatcher} chokidar 
+ * @param {WatchConfig} config 监控配置
+ * @param {number} wait 间隔时间
+ */ function watch(chokidar, config, wait = 250) {
+    let holding = false;
+    let initing = true;
+    chokidar.watch(config.paths).on("all", ()=>{
+        if (inited) {
+            if (!holding) {
+                holding = true;
+                setTimeout(async ()=>{
+                    holding = false;
+                    log("Restarting app...\n");
+                    if (childProcess) {
+                        childProcess.on("exit", start);
+                        stop();
+                    } else {
+                        start();
+                    }
+                }, wait);
+            }
+        } else {
+            if (initing) {
+                initing = false;
+                log("Watch 模式启动\n");
+                setTimeout(()=>{
+                    inited = true;
+                }, wait);
+            }
+        }
+    });
+}
+/**
+ * 设置 watch 模式
+ * @param {WatchConfig} config 
+ * @param {number} wait 
+ */ function setup(config, wait = 250) {
+    const chokidar = getChokidar();
+    if (config && config.enable) {
+        if (chokidar) {
+            if (!config.paths) {
+                // 默认业务自定义服务端业务文件夹
+                const customDir = path.resolve(process.cwd(), "@server");
+                config.paths = [
+                    customDir
+                ];
+            }
+            var stats = 0;
+            try {
+                for(let i = 0; i < config.paths.length; i++){
+                    fs.statSync(config.paths[i]);
+                    stats += 1;
+                }
+            } catch (e) {
+                log(e);
+            }
+            if (stats > 0) {
+                // 传递主进程 SIGTERM
+                process.on("SIGTERM", ()=>{
+                    if (childProcess && childProcess.connected) {
+                        childProcess.kill("SIGTERM");
+                    }
+                    process.exit(0);
+                });
+                watch(chokidar, config, wait);
+                start();
+            } else {
+                log("业务自定义目录不存在, watch 模式启动失败");
+            }
+            stats = null;
+        } else {
+            log("请将 chokidar 安装到开发依赖中以启用 watch 模式");
+        }
+    } else {
+        log("配置不存在或 watch.enable 为 false, watch 模式启动失败\n", config);
+    }
+}
+module.exports = setup;

package/dist/bin/xlab

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+const argv = require("minimist")(process.argv.slice(2));
+const { merge } = require("@x-drive/utils");
+const Liftoff = require("liftoff");
+
+const cli = new Liftoff({
+    "name": "x-lab"
+    , "processTitle": "X Lab"
+    , "moduleName": "xlab"
+    , "configName": "xlab-config"
+    , "extensions": {
+        ".js": null
+    }
+});
+
+const hasWatch = argv.w || argv.watch;
+
+cli.launch(
+    {
+        "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();
+        }
+    }
+);

package/dist/business/utils/cookie/1.1.0/clean/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+function onClean(ctx) {
+    var cookies = ctx.query.c && ctx.query.c.split(",") || null;
+    if (!cookies) {
+        cookies = [];
+        (ctx.headers.cookie || "").split("; ").forEach((item)=>{
+            cookies.push(item.split("=")[0]);
+        });
+    }
+    let len = 0;
+    if (cookies && cookies.length) {
+        let cookiePath = "/";
+        let expires = new Date(-1);
+        let httpOnly = false;
+        cookies.forEach((cookie)=>{
+            if (cookie) {
+                ctx.cookies.set(cookie, "", {
+                    "path": cookiePath,
+                    expires,
+                    httpOnly
+                });
+                len += 1;
+            }
+        });
+    }
+    ctx.body = `Clean ${len}`;
+}
+const _default = onClean;

package/dist/business/utils/cookie/1.1.0/clean/js/@tpls/js.tpl

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="HandheldFriendly" content="true">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="format-detection" content="telephone=no" />
+<script type="text/javascript">
+(function(){
+    var el = document.createElement("p");
+    var cookies = {cookies};
+    var expires = (new Date(-1)).toUTCString();
+    var len = 0;
+    if (cookies && cookies.length) {
+        cookies.forEach(item => {
+            if (item) {
+                document.cookie = item + "=''; path=/;expires=" + expires;
+                len += 1;
+            }
+        });
+    }
+    el.innerHTML = "Clean " + len;
+    setTimeout(function(){
+        document.body.append(el);
+        el = null;
+    }, 100)
+})()
+</script>
+</head>
+<body>
+</body>
+</html>

package/dist/business/utils/cookie/1.1.0/clean/js/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const JS_TPL = _fs.default.readFileSync(_path.default.resolve(__dirname, "./@tpls/js.tpl"), "utf8");
+function onJsClean(ctx) {
+    var cookies = ctx.query.c;
+    cookies = cookies && cookies.split(",") || null;
+    if (!cookies) {
+        cookies = [];
+        (ctx.headers.cookie || "").split("; ").forEach((item)=>{
+            if (item) {
+                cookies.push(item.split("=")[0]);
+            }
+        });
+    }
+    ctx.body = JS_TPL.replace("{cookies}", JSON.stringify(cookies));
+}
+const _default = onJsClean;

package/dist/cluster.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>_default
+});
+const _cluster = /*#__PURE__*/ _interopRequireWildcard(require("./components/cluster"));
+const _config = require("./config");
+const _cluster1 = /*#__PURE__*/ _interopRequireDefault(require("cluster"));
+const _server = /*#__PURE__*/ _interopRequireDefault(require("./server"));
+const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
+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;
+}
+const logger = log.getLogger("cluster");
+const CPUnum = _os.default.cpus().length;
+const config = (0, _config.get)();
+/**
+ * 消息处理函数
+ * @param  msg 消息配置对象
+ */ function masterMessageHandler(msg) {
+    if (msg && msg.cmd) {
+        let handler = _cluster.get(msg.cmd);
+        if (handler) {
+            let args = msg.args || [];
+            args.push(msg.returnData);
+            let re = handler.apply(handler, args);
+            if (msg.wid) {
+                let worker = _cluster1.default.workers[msg.wid];
+                if (worker) {
+                    worker.send({
+                        "cmd": msg.cmd,
+                        "data": re,
+                        "returnData": msg.returnData
+                    });
+                }
+                worker = null;
+            }
+            args = null;
+        }
+    }
+}
+/**尝试以 cluster 模式启动服务 */ function start() {
+    var server;
+    var serverListenConf = {
+        "port": config.port
+    };
+    if (config.ip) {
+        serverListenConf.host = config.ip;
+    }
+    if (config.isMaster) {
+        if (config.workers) {
+            // 小于使用数则取一半
+            let num = CPUnum < config.workers ? Math.ceil(CPUnum / 2) : config.workers;
+            for(var i = 0; i < num; i++){
+                _cluster1.default.fork();
+            }
+            // if(!config.isProd){
+            _cluster1.default.on("listening", function(worker, address) {
+                masterLog("cluster", "info", "\tWorker ", worker.process.pid, " online, Address: ", address.address, ":", address.port);
+            });
+            _cluster1.default.on("message", masterMessageHandler);
+            // }
+            _cluster1.default.on("exit", function(worker) {
+                logger.warn("Worker " + worker.process.pid + " is dead!");
+                _cluster1.default.fork();
+            });
+        } else {
+            server = _server.default.listen(serverListenConf);
+        }
+        masterLog("cluster", "info", "[%s] online,listening on %s port %d", config.env, config.ip || "localhost", config.port);
+    } else {
+        server = _server.default.listen(serverListenConf);
+    }
+    return server;
+}
+const _default = start;