wok-server 0.1.0

package/dist/mongodb/manager/tx.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoTxSession = void 0;
+const exception_1 = require("../exception");
+const base_1 = require("./base");
+/**
+ * 事务会话
+ */
+class MongoTxSession extends base_1.BaseMongoManager {
+    /**
+     * 中止标识
+     */
+    #aborted = false;
+    constructor(config, db, session) {
+        super(config, db, session);
+    }
+    timingQuery(opts) {
+        if (this.#aborted) {
+            throw new exception_1.MongoDBException('Session has been aborted!');
+        }
+        return super.timingQuery(opts);
+    }
+    /**
+     * 中止，被中止后的会话不能再进行任何操作
+     */
+    abort() {
+        this.#aborted = true;
+    }
+}
+exports.MongoTxSession = MongoTxSession;

package/dist/mongodb/migration.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const exception_1 = require("./exception");
+const log_1 = require("../log");
+/**
+ * 迁移
+ * @param db
+ * @param versionList
+ */
+async function migrate(db, versionList) {
+    let currentVersion = await getCurrentVersion(db);
+    // 逐个执行，迁移执行的逻辑是无法提供事务支持的
+    // 版本管理代码是自定义的，无法做到强制绑定 session
+    // 一旦出错，只能手动处理数据库，然后再重新执行程序，和 mysql 一样
+    for (let idx = 0; idx < versionList.length; idx++) {
+        if (idx <= currentVersion) {
+            continue;
+        }
+        const migrationVersion = versionList[idx];
+        (0, log_1.getLogger)().info(`MongoDB migrating, version: ${idx}`);
+        await migrationVersion(db);
+        await updateVersion(db, idx);
+    }
+}
+exports.migrate = migrate;
+const VERSION_COLLECTION_NAME = 'db_version';
+const VERSION_RECORD_ID = 'db_version';
+async function getCurrentVersion(db) {
+    const res = await db
+        .collection(VERSION_COLLECTION_NAME)
+        .findOne({ _id: VERSION_RECORD_ID });
+    return res ? res.version : -1;
+}
+/**
+ * 更新版本号
+ * @param db
+ * @param version
+ */
+async function updateVersion(db, version) {
+    const collection = db.collection(VERSION_COLLECTION_NAME);
+    const res = await collection.findOne({ _id: VERSION_RECORD_ID });
+    if (res) {
+        const rs = await collection.updateOne({ _id: VERSION_RECORD_ID }, { $set: { version } });
+        if (rs.modifiedCount !== 1) {
+            throw new exception_1.MongoDBException('Failed to update version.');
+        }
+    }
+    else {
+        await collection.insertOne({ _id: VERSION_RECORD_ID, version: version });
+    }
+}

package/dist/mvc/access-log.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessLogInterceptor = void 0;
+const log_1 = require("../log");
+const date_1 = require("../log/date");
+/**
+ * 访问日志拦截器，记录请求信息
+ * @param exchange
+ * @param next
+ */
+const accessLogInterceptor = async (exchange, next) => {
+    const start = new Date().getTime();
+    const userAgent = exchange.request.headers['user-agent'];
+    const ip = exchange.request.socket.remoteAddress;
+    const { url, method } = exchange.request;
+    exchange.response.once('close', () => {
+        const status = exchange.response.statusCode;
+        const rt = new Date().getTime() - start;
+        (0, log_1.getLogger)().info(`[access-log]${JSON.stringify({
+            method,
+            url,
+            ip,
+            userAgent,
+            start: (0, date_1.formatDateTime)(new Date(start)),
+            rt,
+            status
+        })}`);
+    });
+    await next();
+};
+exports.accessLogInterceptor = accessLogInterceptor;

package/dist/mvc/config.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const config_1 = require("../config");
+const validation_1 = require("../validation");
+exports.config = (0, config_1.registerConfig)({
+    port: 8080,
+    timeout: 30000,
+    accessLog: false,
+    corsAllowHeaders: '*',
+    corsAllowMethods: '*',
+    corsAllowOrigin: '*'
+}, 'SERVER', {
+    port: [(0, validation_1.notNull)(), (0, validation_1.min)(80), (0, validation_1.max)(65535)],
+    timeout: [(0, validation_1.notNull)(), (0, validation_1.min)(1000), (0, validation_1.max)(60000)],
+    accessLog: [(0, validation_1.notNull)()],
+    corsAllowOrigin: [(0, validation_1.notBlank)()],
+    corsAllowHeaders: [(0, validation_1.notBlank)()],
+    corsAllowMethods: [(0, validation_1.notBlank)()]
+});

package/dist/mvc/exchange.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerExchange = void 0;
+const query_1 = require("./query");
+const render_1 = require("./render");
+const text_1 = require("./render/text");
+/**
+ * 服务的数据交换对象.
+ */
+class ServerExchange {
+    request;
+    response;
+    #bufferPromise;
+    constructor(request, response) {
+        this.request = request;
+        this.response = response;
+    }
+    bodyBuffer() {
+        if (this.#bufferPromise) {
+            return this.#bufferPromise;
+        }
+        this.#bufferPromise = new Promise((resolve, reject) => {
+            if (this.request.readableEnded) {
+                throw new Error('Request has ended!');
+            }
+            let body = [];
+            this.request
+                .resume()
+                .on('error', reject)
+                .on('data', chunk => body.push(chunk))
+                .on('end', () => resolve(Buffer.concat(body)));
+        });
+        return this.#bufferPromise;
+    }
+    async bodyText() {
+        const buffer = await this.bodyBuffer();
+        return buffer.toString('utf-8');
+    }
+    async bodyJson() {
+        const buffer = await this.bodyBuffer();
+        const bodyText = buffer.toString('utf-8');
+        if (!bodyText || !bodyText.trim()) {
+            return {};
+        }
+        return JSON.parse(bodyText);
+    }
+    /**
+     * 响应纯文本
+     * @param text 文本内容
+     * @param status 状态码，可选，默认 200
+     */
+    respondText(text, status) {
+        (0, text_1.renderText)(this.response, text, status);
+    }
+    /**
+     * 响应 json
+     * @param json 任意可被 json 序列化的对象
+     * @param status 状态码，可选，默认 200
+     */
+    respondJson(json, status) {
+        (0, render_1.renderJson)(this.response, json, status);
+    }
+    /**
+     * 响应错误信息提示，提供一个统一的格式封装，json 格式
+     * @param message 消息
+     * @param status 状态码，默认 400 ，表示业务错误
+     * @returns
+     */
+    respondErrMsg(message, status) {
+        (0, render_1.renderError)(this.response, message, status);
+    }
+    /**
+     * 响应文件
+     * @param filePath 文件路径，绝对路径
+     * @param download 是否下载模式
+     * @returns
+     */
+    respondFile(filePath, download) {
+        return (0, render_1.renderFile)(this.request, this.response, filePath, download);
+    }
+    /**
+     * 响应 html
+     * @param html html 内容，一个特定结构的对象或者是字符串
+     * @param status 状态码，可选，默认 200
+     */
+    respondHtml(html, status) {
+        (0, render_1.renderHtml)(this.response, html, status);
+    }
+    /**
+     * 响应
+     * @param opts
+     */
+    respond(opts) {
+        this.response.statusCode = opts.statusCode;
+        if (opts.headers) {
+            for (const key in opts.headers) {
+                this.response.setHeader(key, opts.headers[key]);
+            }
+        }
+        if (opts.body) {
+            this.response.write(opts.body);
+        }
+        this.response.end();
+    }
+    /**
+     * 解析 queryString
+     * @returns
+     */
+    parseQueryString() {
+        return new query_1.QueryString(this.request.url || '');
+    }
+}
+exports.ServerExchange = ServerExchange;

package/dist/mvc/handler/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./json"), exports);
+tslib_1.__exportStar(require("./upload"), exports);
+tslib_1.__exportStar(require("./restful"), exports);

package/dist/mvc/handler/json.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonHandler = void 0;
+const i18n_1 = require("../../i18n");
+const validation_1 = require("../../validation");
+/**
+ * 创建 json 处理器..
+ * @param <REQ> 表示请求的 json 数据格式类型
+ * @param <RES> 表示响应的类型，可选，如果不需要响应 json 数据，则方法可以不返回任何值
+ * @param opts
+ * @returns
+ */
+function createJsonHandler(opts) {
+    return async function (exchange) {
+        if (!exchange.request.method || exchange.request.method.toUpperCase() !== 'POST') {
+            exchange.respondErrMsg('Method Not Allowed', 405);
+            return;
+        }
+        const body = await exchange.bodyJson();
+        if (opts.validation) {
+            // 切换语言
+            (0, i18n_1.getI18n)().switchByRequest(exchange.request.headers);
+            (0, validation_1.validate)(body, opts.validation);
+        }
+        const res = await opts.handle(body, exchange);
+        if (!res) {
+            exchange.respond({ statusCode: 200 });
+            return;
+        }
+        exchange.respondJson(res);
+    };
+}
+exports.createJsonHandler = createJsonHandler;

package/dist/mvc/handler/restful.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restful = void 0;
+/**
+ * 构建 restful 风格路由
+ */
+function restful(opts) {
+    return async (exchange) => {
+        const method = (exchange.request.method || '').toLowerCase();
+        let handler;
+        switch (method) {
+            case 'get':
+                handler = opts.get;
+                break;
+            case 'post':
+                handler = opts.post;
+                break;
+            case 'put':
+                handler = opts.put;
+                break;
+            case 'patch':
+                handler = opts.patch;
+                break;
+            case 'delete':
+                handler = opts.delete;
+                break;
+        }
+        if (!handler) {
+            exchange.respondErrMsg(`${method} ${exchange.request.url} not found`, 404);
+            return;
+        }
+        await handler(exchange);
+    };
+}
+exports.restful = restful;

package/dist/mvc/handler/upload.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploadHandler = void 0;
+/**
+ * 创建上传处理器. 上传要求一次只能传输一个文件，并且请求正文就是文件二进制内容。
+ * 必须是 post 请求，额外的参数只能通过 queryString 或 header 来传递。
+ * 和 postman 中的 binary 模式是一致的，这样上传文件性能会好一些，但是局限性也很大。
+ *
+ * @param opts
+ * @param <RES> 响应json数据类型
+ * @returns
+ */
+function createUploadHandler(opts) {
+    return async function (exchange) {
+        if (!exchange.request.method || exchange.request.method.toUpperCase() !== 'POST') {
+            exchange.respondErrMsg('Method Not Allowed', 405);
+            return;
+        }
+        const body = await exchange.bodyBuffer();
+        const { url, headers } = exchange.request;
+        const res = await opts.handle(body, {
+            url: url || '',
+            headers,
+            query: exchange.parseQueryString()
+        });
+        if (!res) {
+            exchange.respond({ statusCode: 200 });
+            return;
+        }
+        exchange.respondJson(res);
+    };
+}
+exports.createUploadHandler = createUploadHandler;

package/dist/mvc/index.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopWebServer = exports.startWebServer = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const http_1 = require("http");
+const os_1 = require("os");
+const path_1 = require("path");
+const log_1 = require("../log");
+const access_log_1 = require("./access-log");
+const config_1 = require("./config");
+const exchange_1 = require("./exchange");
+const render_1 = require("./render");
+/**
+ * 处理请求，完成拦截器和路由的流程.
+ *
+ * @param interceptors 拦截器
+ * @param routers 路由
+ * @param req
+ * @param res
+ * @param staticSettings
+ */
+async function handleRequest(interceptors, routers, req, res, staticSettings) {
+    req.socket.remoteAddress;
+    const { method } = req;
+    // cros 支持
+    res.setHeader('Access-Control-Allow-Origin', config_1.config.corsAllowOrigin);
+    res.setHeader('Access-Control-Allow-Headers', config_1.config.corsAllowHeaders);
+    res.setHeader('Access-Control-Allow-Methods', config_1.config.corsAllowMethods);
+    if (method === 'OPTIONS') {
+        res.statusCode = 200;
+        res.end();
+        return;
+    }
+    const exchange = new exchange_1.ServerExchange(req, res);
+    // 顺序执行拦截器
+    await handleInterceptor(interceptors, 0, exchange, req, res, routers, staticSettings);
+}
+/**
+ * 处理拦截器.
+ * @param interceptors 拦截器
+ * @param idx 当前要执行的拦截器下标
+ * @param exchange 传输对象
+ * @param req
+ * @param res
+ * @param routers 路由
+ * @param staticSettings
+ */
+async function handleInterceptor(interceptors, idx, exchange, req, res, routers, staticSettings) {
+    const interceptor = interceptors[idx];
+    // 到最后一个了，那么执行路由处理
+    if (!interceptor) {
+        await handleRouter(exchange, routers, staticSettings);
+        return;
+    }
+    await interceptor(exchange, () => handleInterceptor(interceptors, idx + 1, exchange, req, res, routers, staticSettings));
+}
+/**
+ * 处理路由.
+ * @param exchange
+ * @param routers
+ * @param staticSettings
+ * @returns
+ */
+async function handleRouter(exchange, routers, staticSettings) {
+    const url = exchange.request.url;
+    if (url === undefined) {
+        return;
+    }
+    // 判定路由
+    const idx = url.indexOf('?');
+    let path = idx === -1 ? url : url.substring(0, idx);
+    const router = routers[path];
+    if (!router) {
+        // 路由找不不到，尝试静态文件
+        if (staticSettings.length) {
+            await handleStatic(exchange, routers, path, staticSettings);
+        }
+        else {
+            respond404(exchange, routers, path);
+        }
+        return;
+    }
+    // 执行路由
+    await router(exchange);
+    // 在路由顺利处理的情况下，如果 res 没有 end ，就表示响应没有完成
+    // 也就是说路由没有做响应处理，或处理没有完成就结束了，给予错误提示
+    if (!exchange.response.writableEnded) {
+        throw new Error(`RouterHandler unresponsive, url: ${url}`);
+    }
+}
+/**
+ * 处理静态文件
+ * @param exchange
+ * @param routers
+ * @param path
+ * @param staticDir
+ * @returns
+ */
+async function handleStatic(exchange, routers, path, staticSettings) {
+    // 匹配
+    let matchedSetting;
+    for (const setting of staticSettings) {
+        if (setting.path === '/') {
+            matchedSetting = setting;
+            break;
+        }
+        if (path.startsWith(setting.path)) {
+            matchedSetting = setting;
+            break;
+        }
+    }
+    if (!matchedSetting) {
+        respond404(exchange, routers, path);
+        return;
+    }
+    let finalPath = matchedSetting.path === '/' ? path : path.substring(matchedSetting.path.length);
+    if (finalPath.startsWith('/')) {
+        finalPath = finalPath.substring(1);
+    }
+    const fullPath = (0, path_1.resolve)(matchedSetting.dir, finalPath);
+    if (!(0, fs_1.existsSync)(fullPath)) {
+        respond404(exchange, routers, path);
+        return;
+    }
+    const stat = (0, fs_1.statSync)(fullPath);
+    // 目录，寻找 index.html
+    if (stat.isDirectory()) {
+        const indexPath = (0, path_1.resolve)(fullPath, 'index.html');
+        if (!(0, fs_1.existsSync)(indexPath)) {
+            respond404(exchange, routers, path);
+            return;
+        }
+        const indexStat = (0, fs_1.statSync)(indexPath);
+        if (!indexStat.isFile()) {
+            respond404(exchange, routers, path);
+            return;
+        }
+        // Cache-Control
+        if (matchedSetting.cacheAge >= 0) {
+            exchange.response.setHeader('Cache-Control', matchedSetting.cacheAge === 0 ? 'no-store' : `max-age=${matchedSetting.cacheAge}`);
+        }
+        await exchange.respondFile(indexPath, false);
+        return;
+    }
+    // 文件直接渲染
+    if (stat.isFile()) {
+        // Cache-Control
+        if (matchedSetting.cacheAge >= 0) {
+            exchange.response.setHeader('Cache-Control', matchedSetting.cacheAge === 0 ? 'no-store' : `max-age=${matchedSetting.cacheAge}`);
+        }
+        await exchange.respondFile(fullPath, false);
+        return;
+    }
+    // 其它类型，404
+    respond404(exchange, routers, path);
+}
+/**
+ * 404响应
+ *
+ * @param exchange
+ * @param routers
+ * @param path
+ */
+async function respond404(exchange, routers, path) {
+    const handler = routers['*'];
+    if (handler) {
+        await handler(exchange);
+    }
+    else {
+        exchange.respondErrMsg(`${path} not found`, 404);
+    }
+}
+/**
+ * 获取 ipv4 地址列表
+ * @returns
+ */
+function getIpv4List() {
+    const ifs = (0, os_1.networkInterfaces)();
+    const res = [];
+    for (const name in ifs) {
+        const list = ifs[name];
+        if (!list) {
+            continue;
+        }
+        res.push(...list.filter(info => info.family === 'IPv4').map(info => info.address));
+    }
+    return res;
+}
+/**
+ * 服务实例.
+ */
+let SERVER;
+/**
+ * 启动 web服务
+ * @param opts
+ */
+async function startWebServer(opts) {
+    if (SERVER) {
+        throw new Error('The server has already been started!');
+    }
+    // 检查静态文件配置，做一些预处理的操作，在处理静态资源的请求时不必再做这些处理
+    const staticSettings = [];
+    if (opts.static) {
+        // 重复记录表 ，作用是为了路径去重判定，可以提示哪些路径是重复的
+        const duplicateMap = new Map();
+        for (const entry of Object.entries(opts.static)) {
+            const [path, setting] = entry;
+            const dir = (0, path_1.isAbsolute)(setting.dir) ? setting.dir : (0, path_1.resolve)(process.cwd(), setting.dir);
+            if (!(0, fs_1.existsSync)(dir)) {
+                throw new Error(`Static file configuration error，path ${dir} does not exist，config dir：${setting.dir}`);
+            }
+            const stat = (0, fs_1.statSync)(dir);
+            if (!stat.isDirectory()) {
+                throw new Error(`Static file configuration error，path ${dir} is not a directory，config dir：${setting.dir}`);
+            }
+            let finalPath = path.startsWith('/') ? path : '/' + path;
+            // 保持以 / 结尾，为了匹配方便
+            if (!finalPath.endsWith('/')) {
+                finalPath += '/';
+            }
+            if (duplicateMap.has(finalPath)) {
+                throw new Error(`Static path duplicated: ${duplicateMap.get(finalPath)} and ${path}`);
+            }
+            duplicateMap.set(finalPath, path);
+            staticSettings.push({ path: finalPath, dir, cacheAge: setting.cacheAge || 0 });
+        }
+        // 优先级排序
+        staticSettings.sort((o1, o2) => {
+            let priority1 = o1.path === '/' ? -1 : o1.path.split('/').length;
+            let priority2 = o2.path === '/' ? -1 : o2.path.split('/').length;
+            // 如果 o1 优先级高，就应该排前面，返回小于0的值，反之亦然\
+            // 前面的优先级值是值越大优先级越高，反过来减
+            return priority2 - priority1;
+        });
+    }
+    // 如果启用请求日志，增加拦截器
+    let interceptors = [];
+    if (config_1.config.accessLog) {
+        interceptors.push(access_log_1.accessLogInterceptor);
+    }
+    if (opts.interceptors) {
+        interceptors.push(...opts.interceptors);
+    }
+    SERVER = (0, http_1.createServer)((req, res) => {
+        res.on('error', error => {
+            // 如果响应流发生错误，只能把信息记录下来
+            (0, log_1.getLogger)().error(`Response Error：${req.url}`, error);
+        });
+        handleRequest(interceptors, opts.routers, req, res, staticSettings).catch(error => {
+            (0, log_1.getLogger)().error(`Handle request failed：${req.url}`, error);
+            if (!res.writableEnded) {
+                // 响应 500
+                (0, render_1.renderError)(res, error.message ? error.message : 'Internal Server Error', 500);
+            }
+        });
+    });
+    SERVER.setTimeout(config_1.config.timeout);
+    SERVER.on('timeout', (socket) => {
+        socket.end('HTTP/1.1 408 Timeout\ncontent-type: application/json; charset=utf-8\n\n{"message":"Request timeout"}');
+    });
+    if (opts.preHandler) {
+        await opts.preHandler(SERVER);
+    }
+    const server = SERVER;
+    await new Promise((resolve, reject) => {
+        server.on('error', e => {
+            if (e.code === 'EADDRINUSE') {
+                reject(`端口号 ${config_1.config.port} 已经被占用`);
+            }
+            else {
+                reject(e);
+            }
+        });
+        server.listen(config_1.config.port, resolve);
+    });
+    console.log('App running at: ');
+    getIpv4List().forEach(ip => {
+        console.log(`http://${ip}:${config_1.config.port}`);
+    });
+    process.on('beforeExit', () => {
+        if (server.listening) {
+            server.close();
+        }
+    });
+}
+exports.startWebServer = startWebServer;
+/**
+ * 停止 web 服务
+ * @returns
+ */
+async function stopWebServer() {
+    if (!SERVER) {
+        return;
+    }
+    if (SERVER.listening) {
+        const server = SERVER;
+        await new Promise((res, rej) => {
+            server.close(err => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res();
+                }
+            });
+        });
+    }
+    SERVER = undefined;
+}
+exports.stopWebServer = stopWebServer;
+tslib_1.__exportStar(require("./exchange"), exports);
+tslib_1.__exportStar(require("./handler"), exports);
+tslib_1.__exportStar(require("./render"), exports);
+tslib_1.__exportStar(require("./router"), exports);
+tslib_1.__exportStar(require("./interceptor"), exports);

package/dist/mvc/interceptor.js

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