@maiyunnet/kebab 2.0.0

package/sys/ctr.js

@@ -0,0 +1,608 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ctr = void 0;
+exports.clearLocaleData = clearLocaleData;
+const ejs = __importStar(require("ejs"));
+const lCore = __importStar(require("../lib/core"));
+const fs = __importStar(require("../lib/fs"));
+const crypto = __importStar(require("../lib/crypto"));
+const session = __importStar(require("../lib/session"));
+const text = __importStar(require("../lib/text"));
+const sRoute = __importStar(require("../sys/route"));
+let loadedData = {};
+let localeFiles = [];
+let localeData = {};
+function clearLocaleData() {
+    loadedData = {};
+    localeFiles = [];
+    localeData = {};
+}
+class Ctr {
+    constructor(config, req, res) {
+        this._param = [];
+        this._action = '';
+        this._headers = {};
+        this._rawPost = {};
+        this._post = {};
+        this._input = '';
+        this._files = {};
+        this._cookie = {};
+        this._jwt = {};
+        this._session = {};
+        this._sess = null;
+        this._xsrf = '';
+        this._httpCode = 0;
+        this._locale = 'en';
+        this._localeFiles = [];
+        this._localeData = {};
+        this._waitInfo = {
+            'asyncTask': {
+                'count': 0,
+                'resolve': () => {
+                },
+                'callback': function () {
+                    return new Promise((resolve) => {
+                        this.resolve = resolve;
+                    });
+                }
+            },
+            'transaction': 0
+        };
+        this._authorization = null;
+        this._config = config;
+        this._req = req;
+        if (res) {
+            this._res = res;
+        }
+        this._cacheTTL = config.set.cacheTtl;
+    }
+    get isAvail() {
+        return this._req.socket.writable;
+    }
+    get timeout() {
+        return this._timer?.timeout ?? 30_000;
+    }
+    set timeout(num) {
+        if (!this._timer) {
+            return;
+        }
+        this._timer.timeout = num;
+        clearTimeout(this._timer.timer);
+        this._timer.timer = setTimeout(this._timer.callback, num);
+    }
+    _asyncTask(func) {
+        ++this._waitInfo.asyncTask.count;
+        setTimeout(() => {
+            (async () => {
+                await func();
+                --this._waitInfo.asyncTask.count;
+                if (!this._waitInfo.asyncTask.count) {
+                    this._waitInfo.asyncTask.resolve();
+                }
+            })().catch(async (e) => {
+                lCore.display('[ERROR][CTR][ASYNCTASK]', e);
+                await lCore.log(this, '(ctr.asyncTask)' + text.stringifyJson(e.stack).slice(1, -1), '-error');
+                --this._waitInfo.asyncTask.count;
+                if (!this._waitInfo.asyncTask.count) {
+                    this._waitInfo.asyncTask.resolve();
+                }
+            });
+        }, 0);
+    }
+    getPrototype(name) {
+        return this[name];
+    }
+    setPrototype(name, val) {
+        this[name] = val;
+    }
+    onLoad() {
+        return true;
+    }
+    onUnload(rtn) {
+        return rtn;
+    }
+    onUpgrade() {
+        return {};
+    }
+    onData() {
+        return '';
+    }
+    onMessage() {
+        return;
+    }
+    onDrain() {
+        return;
+    }
+    onClose() {
+        return;
+    }
+    _getRunTime(ms = false) {
+        const t = process.hrtime.bigint() - this._config.const.startTime;
+        return ms ? Number(t) / 1000000 : Number(t) / 1000000000;
+    }
+    _getMemoryUsage() {
+        return process.memoryUsage().rss - this._config.const.startMemory;
+    }
+    async _loadView(path, data = {}) {
+        const content = await fs.getContent(this._config.const.viewPath + path + '.ejs', 'utf8');
+        if (!content) {
+            return '';
+        }
+        data._urlBase = this._config.const.urlBase;
+        data._urlFull = this._config.const.urlFull;
+        data._urlStcFill = this._config.const.urlStcFull;
+        data._staticVer = this._config.set.staticVer;
+        data._staticPath = this._config.set.staticPath;
+        data._staticPathFull = this._config.set.staticPathFull;
+        data.l = (key, data) => {
+            return this._l(key, data);
+        };
+        return lCore.purify(ejs.render(content, data));
+    }
+    _checkInput(input, rule, rtn) {
+        for (const key in rule) {
+            const val = rule[key];
+            if (input[key] === undefined) {
+                input[key] = null;
+            }
+            const c = val.length;
+            if (c === 0) {
+                continue;
+            }
+            const lastK = c - 1;
+            if ((val[lastK][0] === undefined) || (val[lastK][1] === undefined) || !Number.isInteger(val[lastK][0]) || (typeof val[lastK][1] !== 'string')) {
+                rtn[0] = 0;
+                rtn[1] = 'Param error(' + key + ')';
+                return false;
+            }
+            for (let k = 0; k < lastK; ++k) {
+                const v = val[k] ?? '';
+                if (Array.isArray(v)) {
+                    if (v.length === 0) {
+                        rtn[0] = val[lastK][0];
+                        rtn[1] = val[lastK][1];
+                        if (val[lastK][2]) {
+                            rtn[2] = val[lastK][2];
+                        }
+                        return false;
+                    }
+                    if (input[key] === null) {
+                        input[key] = v[0];
+                    }
+                    else if (!v.includes(input[key])) {
+                        rtn[0] = val[lastK][0];
+                        rtn[1] = val[lastK][1];
+                        if (val[lastK][2]) {
+                            rtn[2] = val[lastK][2];
+                        }
+                        return false;
+                    }
+                }
+                else if (v instanceof RegExp) {
+                    if (input[key] !== null && !v.test(input[key])) {
+                        rtn[0] = val[lastK][0];
+                        rtn[1] = val[lastK][1];
+                        if (val[lastK][2]) {
+                            rtn[2] = val[lastK][2];
+                        }
+                        return false;
+                    }
+                }
+                else if (typeof v === 'object' && v.type !== undefined) {
+                    if (input[key] !== null) {
+                        const r = lCore.checkType(input[key], v.type);
+                        if (r) {
+                            rtn[0] = val[lastK][0];
+                            rtn[1] = typeof val[lastK][1] === 'string' ? val[lastK][1] + '(' + r + ')' : val[lastK][1];
+                            if (val[lastK][2]) {
+                                rtn[2] = val[lastK][2];
+                            }
+                            return false;
+                        }
+                    }
+                }
+                else {
+                    switch (v) {
+                        case 'require': {
+                            if ((input[key] === null) || (input[key] === '')) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'int':
+                        case 'integer': {
+                            if (input[key] && (typeof input[key] !== 'number') && !Number.isSafeInteger(input[key])) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'float':
+                        case 'double': {
+                            if (input[key] && (typeof input[key] !== 'number')) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'num':
+                        case 'number': {
+                            if (input[key] && (typeof input[key] !== 'number') && !/^[0-9]+\.?[0-9]*$/.test(input[key])) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'array': {
+                            if (input[key] !== null && !Array.isArray(input[key])) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'bool':
+                        case 'boolean': {
+                            if (input[key] !== null && (typeof input[key] !== 'boolean')) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        case 'string': {
+                            if (input[key] !== null && (typeof input[key] !== 'string')) {
+                                rtn[0] = val[lastK][0];
+                                rtn[1] = val[lastK][1];
+                                if (val[lastK][2]) {
+                                    rtn[2] = val[lastK][2];
+                                }
+                                return false;
+                            }
+                            break;
+                        }
+                        default: {
+                            let match;
+                            if (input[key] !== null) {
+                                if (v[0] === '/') {
+                                    if (!(new RegExp(v.slice(1, -1))).test(input[key])) {
+                                        rtn[0] = val[lastK][0];
+                                        rtn[1] = val[lastK][1];
+                                        if (val[lastK][2]) {
+                                            rtn[2] = val[lastK][2];
+                                        }
+                                        return false;
+                                    }
+                                }
+                                else if ((match = /^([><=]+) *([0-9]+)$/.exec(v))) {
+                                    let needReturn = false;
+                                    const inputNum = Number(input[key]);
+                                    const num = Number(match[2]);
+                                    switch (match[1]) {
+                                        case '>': {
+                                            if (inputNum <= num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                        case '<': {
+                                            if (inputNum >= num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                        case '>=': {
+                                            if (inputNum < num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                        case '<=': {
+                                            if (inputNum > num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                        case '=':
+                                        case '==':
+                                        case '===': {
+                                            if (inputNum !== num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                        case '!=':
+                                        case '<>': {
+                                            if (inputNum === num) {
+                                                needReturn = true;
+                                            }
+                                            break;
+                                        }
+                                    }
+                                    if (needReturn) {
+                                        rtn[0] = val[lastK][0];
+                                        rtn[1] = val[lastK][1];
+                                        if (val[lastK][2]) {
+                                            rtn[2] = val[lastK][2];
+                                        }
+                                        return false;
+                                    }
+                                }
+                                else {
+                                    if (input[key] !== v) {
+                                        rtn[0] = val[lastK][0];
+                                        rtn[1] = val[lastK][1];
+                                        if (val[lastK][2]) {
+                                            rtn[2] = val[lastK][2];
+                                        }
+                                        return false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    _checkXInput(input, rule, rtn) {
+        rule['_xsrf'] ??= ['require', this._cookie['XSRF-TOKEN'], [0, 'Bad request, no permission.']];
+        return this._checkInput(input, rule, rtn);
+    }
+    _enabledXsrf() {
+        if (this._cookie['XSRF-TOKEN'] === undefined) {
+            const xsrf = lCore.random(16, lCore.RANDOM_LUN);
+            this._xsrf = xsrf;
+            lCore.setCookie(this, 'XSRF-TOKEN', xsrf, {
+                'path': '/',
+                'httponly': true
+            });
+            this._cookie['XSRF-TOKEN'] = xsrf;
+        }
+        else {
+            this._xsrf = this._cookie['XSRF-TOKEN'];
+        }
+    }
+    _getBasicAuth(user, pwd) {
+        return 'Basic ' + crypto.base64Encode(user + ':' + pwd);
+    }
+    _device() {
+        const ua = this._req.headers['user-agent']?.toLowerCase();
+        if (!ua) {
+            return 'unknown';
+        }
+        const list = ['android', 'windows', 'linux', 'macintosh', 'ipad', 'unknown'];
+        for (const item of list) {
+            if (!ua.includes(item)) {
+                continue;
+            }
+            return item;
+        }
+        return 'unknown';
+    }
+    getAuthorization() {
+        if (this._authorization !== null) {
+            return this._authorization;
+        }
+        let auth = '';
+        if (this._headers['authorization']) {
+            auth = this._headers['authorization'];
+        }
+        else if (this._get['_auth']) {
+            auth = this._get['_auth'];
+        }
+        else if (this._post['_auth']) {
+            auth = this._post['_auth'];
+        }
+        if (typeof auth !== 'string') {
+            return false;
+        }
+        let authArr = auth.split(' ');
+        if (authArr[1] === undefined) {
+            return false;
+        }
+        if (authArr[1].includes('.')) {
+            return authArr[1];
+        }
+        if (!(auth = crypto.base64Decode(authArr[1]))) {
+            return false;
+        }
+        authArr = auth.split(':');
+        this._authorization = { 'user': authArr[0], 'pwd': authArr[1] ?? '' };
+        return this._authorization;
+    }
+    async _loadData(path) {
+        const realPath = this._config.const.dataPath + path + '.json';
+        if (loadedData[realPath]) {
+            return loadedData[realPath];
+        }
+        const content = await fs.getContent(realPath, 'utf8');
+        if (!content) {
+            return null;
+        }
+        const json = text.parseJson(content);
+        loadedData[realPath] = json;
+        return json;
+    }
+    _location(location) {
+        if (this._res) {
+            this._res.setHeader('location', text.urlResolve(this._config.const.urlBase, location));
+        }
+        return false;
+    }
+    async _startSession(link, auth = false, opt = {}) {
+        this._sess = new session.Session();
+        await this._sess.init(this, link, auth, opt);
+    }
+    async _loadLocale(loc, pkg = 'default') {
+        const lName = loc + '.' + pkg;
+        this._locale = loc;
+        if (!this._localeFiles.includes(lName)) {
+            const lPath = this._config.const.dataPath + 'locale/' + lName;
+            if (!localeFiles.includes(lPath)) {
+                const locData = await this._loadData('locale/' + lName);
+                if (locData === null) {
+                    return false;
+                }
+                this._locale = loc;
+                localeData[lPath] ??= {};
+                this._loadLocaleDeep(lPath, locData);
+                localeFiles.push(lPath);
+            }
+            else {
+                this._locale = loc;
+            }
+            this._localeData[loc] ??= {};
+            for (const key in localeData[lPath]) {
+                this._localeData[loc][key] = localeData[lPath][key];
+            }
+            this._localeFiles.push(lName);
+        }
+        else {
+            this._locale = loc;
+        }
+        return true;
+    }
+    _loadLocaleDeep(lPath, locData, pre = '') {
+        for (const k in locData) {
+            const v = locData[k];
+            if (typeof v === 'object') {
+                this._loadLocaleDeep(lPath, v, pre + k + '.');
+            }
+            else {
+                localeData[lPath][pre + k] = v;
+            }
+        }
+    }
+    _getLocaleJsonString() {
+        if (this._localeData[this._locale] !== undefined) {
+            return text.stringifyJson(this._localeData[this._locale]);
+        }
+        else {
+            return '{}';
+        }
+    }
+    _getLocale() {
+        return this._locale;
+    }
+    _cross() {
+        this._res.setHeader('access-control-allow-origin', '*');
+        this._res.setHeader('access-control-allow-headers', '*');
+        this._res.setHeader('access-control-allow-methods', '*');
+        if (this._req.method === 'OPTIONS') {
+            this._res.setHeader('access-control-max-age', '600');
+            return false;
+        }
+        return true;
+    }
+    _l(key, data) {
+        if (!this._localeData[this._locale]) {
+            return '[LocaleError]' + key;
+        }
+        if (!this._localeData[this._locale][key]) {
+            return '[LocaleError]' + key;
+        }
+        if (data) {
+            let i = -1;
+            return this._localeData[this._locale][key].replace(/\?/g, function () {
+                ++i;
+                if (!data[i]) {
+                    return '';
+                }
+                return data[i];
+            });
+        }
+        else {
+            return this._localeData[this._locale][key];
+        }
+    }
+    _writeText(data) {
+        return this._socket.writeText(data);
+    }
+    _writeResult(data) {
+        return this._socket.writeResult(data);
+    }
+    _writeBinary(data) {
+        return this._socket.writeBinary(data);
+    }
+    _ping() {
+        return this._socket.ping();
+    }
+    _pong() {
+        return this._socket.pong();
+    }
+    _end() {
+        this._socket.end();
+    }
+    async _handleFormData(events = {}) {
+        const rtn = await sRoute.getFormData(this._req, events);
+        if (!rtn) {
+            return false;
+        }
+        for (const key in rtn.post) {
+            this._post[key] = rtn.post[key];
+        }
+        for (const key in rtn.files) {
+            this._files[key] = rtn.files[key];
+        }
+        return true;
+    }
+}
+exports.Ctr = Ctr;