wok-server 0.2.2 → 0.3.0

package/dist/mvc/server.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WokServer = void 0;
+const fs_1 = require("fs");
+const http_1 = require("http");
+const https_1 = require("https");
+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");
+const static_1 = require("./static");
+const validation_1 = require("../validation");
+function resolvePath(path) {
+    if ((0, path_1.isAbsolute)(path)) {
+        return path;
+    }
+    return (0, path_1.resolve)(process.cwd(), path);
+}
+/**
+ * web 服务
+ */
+class WokServer {
+    opts;
+    config;
+    server;
+    interceptors;
+    routers;
+    defaultRouter;
+    staticHandler;
+    constructor(opts) {
+        this.opts = opts;
+        this.config = (0, config_1.getConfig)();
+        // https
+        let tls;
+        if (this.config.tlsEnable) {
+            (0, validation_1.validate)(this.config, {
+                tlsCert: [(0, validation_1.notBlank)()],
+                tlsKey: [(0, validation_1.notBlank)()]
+            });
+            tls = {
+                cert: (0, fs_1.readFileSync)(resolvePath(this.config.tlsCert)),
+                key: (0, fs_1.readFileSync)(resolvePath(this.config.tlsKey))
+            };
+        }
+        // 路由
+        this.routers = opts.routers;
+        this.defaultRouter = this.routers['*'];
+        // 拦截器
+        this.interceptors = [];
+        if (this.config.accessLog) {
+            this.interceptors.push(access_log_1.accessLogInterceptor);
+        }
+        if (opts.interceptors) {
+            this.interceptors.push(...opts.interceptors);
+        }
+        // 静态处理
+        if (opts.static) {
+            this.staticHandler = new static_1.StaticHandler(opts.static);
+        }
+        // 主服务
+        if (!tls) {
+            this.server = (0, http_1.createServer)({
+                requestTimeout: this.config.timeout
+            }, (req, res) => {
+                res.setHeader('Server', 'Wok Server');
+                res.on('error', error => {
+                    // 如果响应流发生错误，只能把信息记录下来
+                    (0, log_1.getLogger)().error(`Response Error：${req.url}`, error);
+                });
+                this.handleRequest(req, res).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);
+                    }
+                });
+            });
+        }
+        else {
+            this.server = (0, https_1.createServer)({
+                requestTimeout: this.config.timeout,
+                key: tls.key,
+                cert: tls.cert
+            }, (req, res) => {
+                res.setHeader('Server', 'Wok Server');
+                res.on('error', error => {
+                    // 如果响应流发生错误，只能把信息记录下来
+                    (0, log_1.getLogger)().error(`Response Error：${req.url}`, error);
+                });
+                this.handleRequest(req, res).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);
+                    }
+                });
+            });
+        }
+        this.server.on('timeout', (socket) => {
+            socket.end('HTTP/1.1 408 Timeout\ncontent-type: application/json; charset=utf-8\n\n{"message":"Request timeout"}');
+        });
+    }
+    /**
+     * 处理请求，完成拦截器和路由的流程.
+     *
+     * @param req
+     * @param res
+     */
+    async handleRequest(req, res) {
+        req.socket.remoteAddress;
+        const { method } = req;
+        // cros 支持
+        res.setHeader('Access-Control-Allow-Origin', this.config.corsAllowOrigin);
+        res.setHeader('Access-Control-Allow-Headers', this.config.corsAllowHeaders);
+        res.setHeader('Access-Control-Allow-Methods', this.config.corsAllowMethods);
+        if (method === 'OPTIONS') {
+            res.statusCode = 200;
+            res.end();
+            return;
+        }
+        const exchange = new exchange_1.ServerExchange(req, res);
+        // 顺序执行拦截器
+        await this.handleInterceptor(0, exchange, req, res);
+    }
+    /**
+     * 处理拦截器.
+     * @param idx 当前要执行的拦截器下标
+     * @param exchange 传输对象
+     * @param req
+     * @param res
+     */
+    async handleInterceptor(idx, exchange, req, res) {
+        const interceptor = this.interceptors[idx];
+        // 到最后一个了，那么执行路由处理
+        if (!interceptor) {
+            await this.handleRouter(exchange);
+            return;
+        }
+        await interceptor(exchange, () => this.handleInterceptor(idx + 1, exchange, req, res));
+    }
+    /**
+     * 处理路由.
+     * @param exchange
+     * @param routers
+     * @param staticSettings
+     * @returns
+     */
+    async handleRouter(exchange) {
+        const url = exchange.request.url;
+        if (url === undefined) {
+            return;
+        }
+        // 判定路由
+        const idx = url.indexOf('?');
+        let path = idx === -1 ? url : url.substring(0, idx);
+        const router = this.routers[path];
+        if (!router) {
+            // 路由找不不到，尝试静态文件
+            if (this.staticHandler) {
+                const method = (exchange.request.method || '').toLowerCase();
+                if (method === 'head') {
+                    if (await this.staticHandler.handleHead(path, exchange.response)) {
+                        return;
+                    }
+                }
+                if (method === 'get') {
+                    if (await this.staticHandler.handleGet(exchange.request, exchange.response, path)) {
+                        return;
+                    }
+                }
+            }
+            this.respond404(exchange, path);
+            return;
+        }
+        // 执行路由
+        await router(exchange);
+        // 在路由顺利处理的情况下，如果 res 没有 end ，就表示响应没有完成
+        // 也就是说路由没有做响应处理，或处理没有完成就结束了，给予错误提示
+        if (!exchange.response.writableEnded) {
+            throw new Error(`RouterHandler unresponsive, url: ${url}`);
+        }
+    }
+    /**
+     * 404响应
+     *
+     * @param exchange
+     * @param path
+     */
+    async respond404(exchange, path) {
+        if (this.defaultRouter) {
+            await this.defaultRouter(exchange);
+        }
+        else {
+            exchange.respondErrMsg(`${path} not found`, 404);
+        }
+    }
+    /**
+     * 启动
+     */
+    async start() {
+        if (this.opts.preHandler) {
+            await this.opts.preHandler(this.server);
+        }
+        await new Promise((resolve, reject) => {
+            this.server.on('error', e => {
+                if (e.code === 'EADDRINUSE') {
+                    reject(`Port ${this.config.port} is already in use.`);
+                }
+                else {
+                    reject(e);
+                }
+            });
+            this.server.listen(this.config.port, resolve);
+        });
+        console.log('App running at: ');
+        let portOmitted = (this.server instanceof https_1.Server && this.config.port === 443) ||
+            (this.server instanceof http_1.Server && this.config.port === 80);
+        this.getIpv4List().forEach(ip => {
+            if (portOmitted) {
+                console.log(`http://${ip}`);
+            }
+            else {
+                console.log(`http://${ip}:${this.config.port}`);
+            }
+        });
+    }
+    /**
+     * 获取 ipv4 地址列表
+     * @returns
+     */
+    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;
+    }
+    /**
+     * 停止
+     */
+    async stop() {
+        if (!this.server.listening) {
+            return;
+        }
+        await new Promise((res, rej) => {
+            this.server.close(err => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res();
+                }
+            });
+        });
+    }
+}
+exports.WokServer = WokServer;

package/dist/mvc/static/header.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHeaders = void 0;
+/**
+ * 解析 range 消息头，如果解析失败，返回 null
+ */
+function parseRange(rangeHeader) {
+    // 解析，range 示例：bytes=200-1000, 2000-6576, 19000-
+    // 多段的情况，暂时不做支持，非常麻烦，段数多还可能会有效率问题
+    // 如果不是字节范围不是以字节为单位，暂时也不做支持
+    const ranges = rangeHeader.split(',');
+    if (!ranges.length) {
+        return null;
+    }
+    let range = ranges[0].trim();
+    if (!range.startsWith('bytes=')) {
+        return null;
+    }
+    range = range.substring(6);
+    const strs = range.split('-');
+    let start = strs[0] ? parseInt(strs[0], 10) : NaN;
+    let end = strs[1] ? parseInt(strs[1], 10) : undefined;
+    return { start, end };
+}
+/**
+ * 解析消息头，返回静态文件处理需要的信息
+ * @param headers
+ */
+function parseHeaders(headers) {
+    // 是否支持 gzip
+    const acceptEncoding = headers['accept-encoding'];
+    let acceptGzip = false;
+    if (acceptEncoding) {
+        // Accept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1
+        const acceptEncodings = acceptEncoding
+            .trim()
+            .split(',')
+            .map(item => item.trim())
+            .map(item => item.split(';')[0]);
+        if (acceptEncodings.includes('gzip') || acceptEncodings.includes('*')) {
+            acceptGzip = true;
+        }
+    }
+    let res = {
+        gzip: acceptGzip
+    };
+    // 支持 If-Modified-Since
+    // 由于只是简单的文件映射，没有 etag，不能支持 If-None-Match
+    const ifModifiedSince = headers['if-modified-since'];
+    if (ifModifiedSince) {
+        const modifiedSince = new Date(ifModifiedSince);
+        if (modifiedSince instanceof Date && !isNaN(modifiedSince.getTime())) {
+            res.ifModifiedSince = modifiedSince;
+        }
+    }
+    // 支持 Range
+    // https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Range
+    const rangeHeader = headers['range'];
+    if (rangeHeader) {
+        const rangeRes = parseRange(rangeHeader);
+        if (rangeRes) {
+            res.range = rangeRes;
+        }
+    }
+    return res;
+}
+exports.parseHeaders = parseHeaders;

package/dist/mvc/static/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./mime-type"), exports);
+tslib_1.__exportStar(require("./header"), exports);
+tslib_1.__exportStar(require("./static-handler"), exports);

package/dist/mvc/static/mime-type.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideContentType = exports.MIME_TYPES = void 0;
+exports.MIME_TYPES = {
+    aac: 'audio/aac',
+    abw: 'application/x-abiword',
+    arc: 'application/x-freearc',
+    avi: 'video/x-msvideo',
+    azw: 'application/vnd.amazon.ebook',
+    bin: 'application/octet-stream',
+    bmp: 'image/bmp',
+    bz: 'application/x-bzip',
+    bz2: 'application/x-bzip2',
+    csh: 'application/x-csh',
+    css: 'text/css',
+    csv: 'text/csv',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    eot: 'application/vnd.ms-fontobject',
+    epub: 'application/epub+zip',
+    gif: 'image/gif',
+    htm: 'text/html',
+    html: 'text/html',
+    ico: 'image/vnd.microsoft.icon',
+    ics: 'text/calendar',
+    jar: 'application/java-archive',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    js: 'text/javascript',
+    json: 'application/json',
+    jsonld: 'application/ld+json',
+    mid: 'audio/midi',
+    midi: 'audio/midi',
+    mjs: 'text/javascript',
+    mp3: 'audio/mpeg',
+    mpeg: 'video/mpeg',
+    mpkg: 'application/vnd.apple.installer+xml',
+    odp: 'application/vnd.oasis.opendocument.presentation',
+    ods: 'application/vnd.oasis.opendocument.spreadsheet',
+    odt: 'application/vnd.oasis.opendocument.text',
+    oga: 'audio/ogg',
+    ogv: 'video/ogg',
+    ogx: 'application/ogg',
+    otf: 'font/otf',
+    png: 'image/png',
+    pdf: 'application/pdf',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    rar: 'application/x-rar-compressed',
+    rtf: 'application/rtf',
+    sh: 'application/x-sh',
+    svg: 'image/svg+xml',
+    swf: 'application/x-shockwave-flash',
+    tar: 'application/x-tar',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    ttf: 'font/ttf',
+    txt: 'text/plain',
+    vsd: 'application/vnd.visio',
+    wav: 'audio/wav',
+    weba: 'audio/webm',
+    webm: 'video/webm',
+    webp: 'image/webp',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    xhtml: 'application/xhtml+xml',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    xml: 'application/xml',
+    xul: 'application/vnd.mozilla.xul+xml',
+    zip: 'application/zip',
+    '3gp': 'video/3gpp',
+    '3g2': 'video/3gpp2',
+    '7z': 'application/x-7z-compressed'
+};
+function decideContentType(fileName) {
+    const idx = fileName.lastIndexOf('.');
+    if (idx === -1) {
+        return undefined;
+    }
+    const suffix = fileName.substring(idx + 1);
+    return exports.MIME_TYPES[suffix];
+}
+exports.decideContentType = decideContentType;

package/dist/mvc/static/server-cache-config.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = exports.parseSize = void 0;
+const config_1 = require("../../config");
+const validation_1 = require("../../validation");
+function parseSize(size) {
+    if (typeof size === 'number') {
+        return size;
+    }
+    const match = size.match(/^(\d+)([kmg]?)$/i);
+    if (!match) {
+        throw new Error(`Invalid size: ${size}`);
+    }
+    const [, num, unit] = match;
+    let sizeNum = parseInt(num, 10);
+    switch (unit.toLowerCase()) {
+        case 'k':
+            sizeNum *= 1024;
+            break;
+        case 'm':
+            sizeNum *= 1024 * 1024;
+            break;
+        case 'g':
+            sizeNum *= 1024 * 1024 * 1024;
+            break;
+        default:
+            break;
+    }
+    return sizeNum;
+}
+exports.parseSize = parseSize;
+function validateSize(max) {
+    const maxNum = parseSize(max);
+    const validator = 'size';
+    return val => {
+        if (val === null || val === undefined) {
+            return { ok: true };
+        }
+        const sizeNum = typeof val === 'number' ? val : parseSize(val);
+        if (sizeNum < 1) {
+            return { ok: false, validator, message: `size must greater than 1` };
+        }
+        if (sizeNum > maxNum) {
+            return { ok: false, validator, message: `size must less than ${max}` };
+        }
+        return { ok: true };
+    };
+}
+/**
+ * 获取缓存的配置信息
+ * @returns
+ */
+function getConfig() {
+    return (0, config_1.generateConfig)({
+        enable: false,
+        maxAge: 600,
+        maxSize: '100m',
+        maxFileSize: '10m'
+    }, 'SERVER_STATIC_CACHE', {
+        enable: [(0, validation_1.notNull)()],
+        maxAge: [(0, validation_1.notNull)(), (0, validation_1.min)(1), (0, validation_1.max)(31536000)],
+        maxSize: [(0, validation_1.notNull)(), validateSize('1024g')],
+        maxFileSize: [(0, validation_1.notNull)(), validateSize('1g')]
+    });
+}
+exports.getConfig = getConfig;

package/dist/mvc/static/server-cache.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerCache = void 0;
+/**
+ * 文件的服务器缓存
+ */
+class ServerCache {
+    opts;
+    /**
+     * 当前的缓存内容大小，单位字节
+     */
+    size = 0;
+    /**
+     * 缓存内容
+     */
+    cacheMap = new Map();
+    /**
+     * promise 表，作用是处理异步并发问题，如果有相同的 key 同时请求，保证异步的 provider 只执行一次
+     */
+    promiseMap = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /**
+     * 获取缓存
+     */
+    get(key) {
+        const data = this.cacheMap.get(key);
+        if (data) {
+            if (data.expireAt < Date.now()) {
+                this.cacheMap.delete(key);
+                return null;
+            }
+            return data;
+        }
+        return null;
+    }
+    /**
+     * 设置缓存内容，如果缓存内容超过最大缓存大小，则触发清除缓存操作
+     * @param key
+     * @param value
+     * @returns
+     */
+    set(key, value) {
+        const expireAt = Date.now() + this.opts.maxAge * 1000;
+        const content = value;
+        content.expireAt = expireAt;
+        this.cacheMap.set(key, content);
+        this.size += content.buffer.length;
+        if (this.size > this.opts.maxSize) {
+            setTimeout(() => this.clean(), 0);
+        }
+    }
+    /**
+     * 删除缓存
+     */
+    remove(key) {
+        const data = this.cacheMap.get(key);
+        if (data) {
+            this.cacheMap.delete(key);
+            this.size -= data.buffer.length;
+        }
+    }
+    /**
+     * 如果缓存不存在，则计算缓存内容并放入缓存
+     * @param key
+     * @param provider 计算函数，返回值将放入缓存，如果返回 null 则表示未能计算出缓存内容，不进行缓存
+     */
+    async computeIfAbsent(key, provider) {
+        const data = this.get(key);
+        if (data) {
+            return data;
+        }
+        // 如果已经在处理中，则直接返回 promise
+        const ep = this.promiseMap.get(key);
+        if (ep) {
+            return ep;
+        }
+        const promise = Promise.resolve().then(async () => {
+            try {
+                const res = await provider();
+                if (res) {
+                    this.set(key, res);
+                }
+                return res;
+            }
+            finally {
+                this.promiseMap.delete(key);
+            }
+        });
+        this.promiseMap.set(key, promise);
+        return promise;
+    }
+    /**
+     * 清理无用的缓存内容
+     */
+    clean() {
+        // 先清理掉过期的
+        const keys = Array.from(this.cacheMap.keys());
+        for (const key of keys) {
+            const data = this.cacheMap.get(key);
+            if (data) {
+                if (data.expireAt < Date.now()) {
+                    this.cacheMap.delete(key);
+                    this.size -= data.buffer.length;
+                }
+            }
+        }
+        if (this.size < this.opts.maxSize) {
+            return;
+        }
+        const keys2 = Array.from(this.cacheMap.keys());
+        // 再逐个清理，直到空间不会超出最大缓存大小
+        for (const key of keys2) {
+            if (this.size < this.opts.maxSize * 0.8) {
+                break;
+            }
+            const data = this.cacheMap.get(key);
+            if (data) {
+                this.cacheMap.delete(key);
+                this.size -= data.buffer.length;
+            }
+        }
+    }
+    /**
+     * 清除缓存内容
+     */
+    clear() {
+        this.cacheMap.clear();
+        this.size = 0;
+    }
+}
+exports.ServerCache = ServerCache;