@maiyunnet/kebab 2.0.0

package/lib/net.js

@@ -0,0 +1,462 @@
+"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.getCa = getCa;
+exports.open = open;
+exports.get = get;
+exports.post = post;
+exports.postJson = postJson;
+exports.request = request;
+exports.setCookie = setCookie;
+exports.buildCookieQuery = buildCookieQuery;
+exports.resetCookieSession = resetCookieSession;
+exports.getFormData = getFormData;
+exports.filterProxyHeaders = filterProxyHeaders;
+exports.mproxy = mproxy;
+exports.mproxyData = mproxyData;
+exports.rproxy = rproxy;
+const stream = __importStar(require("stream"));
+const hc = __importStar(require("@litert/http-client"));
+const fs = __importStar(require("~/lib/fs"));
+const text = __importStar(require("~/lib/text"));
+const time = __importStar(require("~/lib/time"));
+const kebab = __importStar(require("~/index"));
+const fd = __importStar(require("./net/formdata"));
+const lRequest = __importStar(require("./net/request"));
+const response = __importStar(require("./net/response"));
+let ca = '';
+async function getCa() {
+    if (ca) {
+        return ca;
+    }
+    ca = (await fs.getContent(kebab.LIB_PATH + 'net/cacert.pem', 'utf8')) ?? '';
+    return ca;
+}
+const reuses = {
+    'default': hc.createHttpClient()
+};
+function open(u) {
+    return new lRequest.Request(u);
+}
+async function get(u, opt = {}) {
+    return request(u, undefined, opt);
+}
+async function post(u, data, opt = {}) {
+    opt.method = 'POST';
+    return request(u, data, opt);
+}
+async function postJson(u, data, opt = {}) {
+    opt.method = 'POST';
+    opt.type = 'json';
+    return request(u, data, opt);
+}
+async function request(u, data, opt = {}) {
+    const uri = text.parseUrl(u);
+    const puri = opt.mproxy ? text.parseUrl(opt.mproxy.url) : null;
+    const method = opt.method ?? 'GET';
+    const type = opt.type ?? 'form';
+    const timeout = opt.timeout ?? 10;
+    const follow = opt.follow ?? 0;
+    const hosts = opt.hosts ?? {};
+    const save = opt.save;
+    const local = opt.local;
+    const reuse = opt.reuse ?? 'default';
+    const headers = {};
+    if (opt.headers) {
+        for (const key in opt.headers) {
+            headers[key.toLowerCase()] = opt.headers[key];
+        }
+    }
+    headers['user-agent'] ??= 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36';
+    if (method === 'GET') {
+        if (data && !(data instanceof stream.Readable) && !Buffer.isBuffer(data)) {
+            u += (u.includes('?') ? '&' : '?') +
+                (typeof data === 'string' ? data : text.queryStringify(data));
+            data = undefined;
+        }
+    }
+    else {
+        if (data && !(data instanceof stream.Readable) && !Buffer.isBuffer(data) && typeof data !== 'string') {
+            if (type === 'form') {
+                data = text.queryStringify(data);
+                headers['content-type'] = 'application/x-www-form-urlencoded';
+            }
+            else {
+                data = text.stringifyJson(data);
+                headers['content-type'] = 'application/json; charset=utf-8';
+            }
+        }
+        else if (data instanceof fd.FormData) {
+            headers['content-type'] = 'multipart/form-data; boundary=' + data.getBoundary();
+            headers['content-length'] = data.getLength();
+        }
+    }
+    headers['accept-encoding'] = 'gzip, deflate';
+    if (uri.protocol === 'https:') {
+        await getCa();
+    }
+    if (opt.cookie) {
+        headers['cookie'] = buildCookieQuery(opt.cookie, uri);
+    }
+    let req;
+    try {
+        const host = (puri ? puri.hostname : uri.hostname) ?? '';
+        if (!host) {
+            const res = new response.Response(null);
+            res.error = {
+                'name': 'Possible mProxy error',
+                'message': 'host not found'
+            };
+            return res;
+        }
+        if (hosts[host] !== undefined && !hosts[host]) {
+            const res = new response.Response(null);
+            res.error = {
+                'name': 'hosts error',
+                'message': 'hosts param error'
+            };
+            return res;
+        }
+        if (!reuses[reuse]) {
+            reuses[reuse] = hc.createHttpClient();
+        }
+        req = await reuses[reuse].request({
+            'url': opt.mproxy ? opt.mproxy.url + (opt.mproxy.url.includes('?') ? '&' : '?') + text.queryStringify({
+                'url': u,
+                'auth': opt.mproxy.auth,
+                'data': opt.mproxy.data ? text.stringifyJson(opt.mproxy.data) : '{}'
+            }) : u,
+            'method': method,
+            'data': data,
+            'headers': headers,
+            'timeout': timeout * 1000,
+            'localAddress': local,
+            'ca': ca,
+            'connectionOptions': {
+                'remoteHost': hosts[host]
+            },
+        });
+    }
+    catch (err) {
+        const res = new response.Response(null);
+        res.error = err;
+        return res;
+    }
+    if (opt.cookie) {
+        await buildCookieObject(opt.cookie, (req.headers['set-cookie'] ?? []), uri);
+    }
+    let total = 0;
+    if (save && (!req.headers['location'] || follow === 0)) {
+        await new Promise(function (resolve) {
+            req.getStream().on('end', () => {
+                fs.stats(save).then((stat) => {
+                    total = stat?.size ?? 0;
+                    resolve();
+                }).catch(() => {
+                    resolve();
+                });
+            }).on('error', function () {
+                resolve();
+            }).pipe(fs.createWriteStream(save));
+        });
+    }
+    const res = new response.Response(req);
+    if (total) {
+        res.setContent(total.toString());
+    }
+    res.headers = req.headers;
+    switch (req.protocol) {
+        case hc.EProtocol.HTTPS_2:
+        case hc.EProtocol.HTTP_2: {
+            req.headers['http-version'] = '2.0';
+            break;
+        }
+        default: {
+            res.headers['http-version'] = '1.1';
+        }
+    }
+    res.headers['http-code'] = req.statusCode;
+    res.headers['http-url'] = u;
+    if (follow === 0) {
+        return res;
+    }
+    if (!res.headers['location']) {
+        return res;
+    }
+    headers['referer'] = u;
+    return request(text.urlResolve(u, req.headers['location']), data, {
+        'method': method,
+        'type': type,
+        'timeout': timeout,
+        'follow': follow - 1,
+        'hosts': hosts,
+        'save': save,
+        'local': local,
+        'headers': headers,
+        'mproxy': opt.mproxy,
+        'reuse': reuse
+    });
+}
+function setCookie(cookie, name, value, domain, opt = {}) {
+    const tim = time.stamp();
+    const ttl = opt.ttl ?? 0;
+    domain = domain.split(':')[0];
+    const domainN = domain.startsWith('.') ? domain.slice(1) : domain;
+    let exp = -1992199400;
+    if (ttl) {
+        exp = tim + ttl;
+    }
+    cookie[name + '-' + domainN] = {
+        'name': name,
+        'value': value,
+        'exp': exp,
+        'path': opt['path'] ?? '/',
+        'domain': domainN,
+        'secure': opt['ssl'] ? true : false,
+        'httponly': opt['httponly'] ? true : false
+    };
+}
+async function buildCookieObject(cookie, setCookies, uri) {
+    const tim = time.stamp();
+    uri.path ??= '/';
+    for (const setCookie of setCookies) {
+        const cookieTmp = {};
+        const list = setCookie.split(';');
+        for (let index = 0; index < list.length; ++index) {
+            const item = list[index];
+            const arr = item.split('=');
+            const key = arr[0].trim();
+            const val = arr[1] ?? '';
+            if (index === 0) {
+                cookieTmp['name'] = key;
+                cookieTmp['value'] = decodeURIComponent(val);
+            }
+            else {
+                cookieTmp[key.toLowerCase()] = val;
+            }
+        }
+        let domain = '', domainN = '';
+        if (cookieTmp['domain']) {
+            cookieTmp['domain'] = cookieTmp['domain'].split(':')[0];
+            if (!(cookieTmp['domain'].startsWith('.'))) {
+                domain = '.' + cookieTmp['domain'];
+                domainN = cookieTmp['domain'];
+            }
+            else {
+                domain = cookieTmp['domain'];
+                domainN = cookieTmp['domain'].slice(1);
+            }
+        }
+        else {
+            domain = '.' + (uri.hostname ?? '');
+            domainN = uri.hostname ?? '';
+        }
+        if (uri.hostname !== domainN) {
+            if (!text.isDomain(uri.hostname ?? '')) {
+                continue;
+            }
+            const parseDomain = await text.parseDomain(domainN);
+            if (parseDomain.tld === domainN.toLowerCase()) {
+                continue;
+            }
+            if (!((uri.hostname ?? '').endsWith(domain))) {
+                continue;
+            }
+        }
+        const cookieKey = cookieTmp['name'] + '-' + domainN;
+        if (cookieTmp['max-age'] && (Number(cookieTmp['max-age']) <= 0)) {
+            if (cookie[cookieKey]) {
+                delete cookie[cookieKey];
+                continue;
+            }
+        }
+        let exp = -1992199400;
+        if (cookieTmp['max-age']) {
+            exp = tim + Number(cookieTmp['max-age']);
+        }
+        let path = cookieTmp['path'] ?? '';
+        if (path === '') {
+            const srp = (uri.pathname ?? '').lastIndexOf('/');
+            path = (uri.pathname ?? '').slice(0, srp + 1);
+        }
+        else if (!path.startsWith('/')) {
+            path = '/' + path;
+        }
+        cookie[cookieKey] = {
+            'name': cookieTmp['name'],
+            'value': cookieTmp['value'],
+            'exp': exp,
+            'path': path,
+            'domain': domainN,
+            'secure': cookieTmp['secure'] !== undefined ? true : false,
+            'httponly': cookieTmp['httponly'] !== undefined ? true : false
+        };
+    }
+}
+function buildCookieQuery(cookie, uri) {
+    const tim = time.stamp();
+    let cookieStr = '';
+    for (const key in cookie) {
+        const item = cookie[key];
+        if ((item.exp < tim) && (item.exp !== -1992199400)) {
+            delete cookie[key];
+            continue;
+        }
+        uri.path ??= '/';
+        if (item.secure && (uri.protocol === 'https')) {
+            continue;
+        }
+        if (!uri.path.startsWith(item.path)) {
+            continue;
+        }
+        const domain = '.' + item.domain;
+        if ('.' + (uri.hostname ?? '') !== domain) {
+            if (!(uri.hostname.endsWith(domain))) {
+                continue;
+            }
+        }
+        cookieStr += item.name + '=' + encodeURIComponent(item.value) + '; ';
+    }
+    if (cookieStr !== '') {
+        return cookieStr.slice(0, -2);
+    }
+    else {
+        return '';
+    }
+}
+function resetCookieSession(cookie) {
+    for (const key in cookie) {
+        const item = cookie[key];
+        if (item.exp === -1992199400000) {
+            delete cookie[key];
+        }
+    }
+}
+function getFormData() {
+    return new fd.FormData();
+}
+const proxyContinueHeaders = ['host', 'connection', 'http-version', 'http-code', 'http-url'];
+function filterProxyHeaders(headers, res) {
+    const heads = {};
+    for (const h in headers) {
+        if (proxyContinueHeaders.includes(h)) {
+            continue;
+        }
+        if (h.includes(':') || h.includes('(')) {
+            continue;
+        }
+        const v = headers[h];
+        if (v === undefined) {
+            continue;
+        }
+        if (res) {
+            res.setHeader(h, v);
+            continue;
+        }
+        heads[h] = v;
+    }
+    return heads;
+}
+async function mproxy(ctr, auth, opt = {}) {
+    const req = ctr.getPrototype('_req');
+    const res = ctr.getPrototype('_res');
+    const input = ctr.getPrototype('_input');
+    const get = ctr.getPrototype('_get');
+    if (get['auth'] !== auth) {
+        return 0;
+    }
+    if (!get['url']) {
+        return -1;
+    }
+    opt.method = req.method ?? 'GET';
+    opt.headers ??= {};
+    Object.assign(opt.headers, filterProxyHeaders(req.headers));
+    const rres = await request(get['url'], req.headers['content-type']?.includes('form-data') ? req : input, opt);
+    if (rres.error) {
+        return -2;
+    }
+    if (rres.headers) {
+        filterProxyHeaders(rres.headers, res);
+    }
+    res.writeHead(rres.headers?.['http-code'] ?? 200);
+    await new Promise((resolve) => {
+        rres.getRawStream().pipe(res).on('finish', () => {
+            resolve();
+        });
+    });
+    return 1;
+}
+function mproxyData(ctr) {
+    const get = ctr.getPrototype('_get');
+    if (!get['data']) {
+        return {};
+    }
+    const data = text.parseJson(get['data']);
+    if (!data) {
+        return {};
+    }
+    return data;
+}
+async function rproxy(ctr, route, opt = {}) {
+    const req = ctr.getPrototype('_req');
+    const res = ctr.getPrototype('_res');
+    const config = ctr.getPrototype('_config');
+    const input = ctr.getPrototype('_input');
+    const path = config.const.path + (config.const.qs ? '?' + config.const.qs : '');
+    for (const key in route) {
+        if (!path.startsWith(key)) {
+            continue;
+        }
+        const lpath = path.slice(key.length);
+        opt.method = req.method ?? 'GET';
+        opt.headers ??= {};
+        Object.assign(opt.headers, filterProxyHeaders(req.headers));
+        const rres = await request(route[key] + lpath, req.headers['content-type']?.includes('form-data') ? req : input, opt);
+        if (rres.error) {
+            return false;
+        }
+        if (rres.headers) {
+            filterProxyHeaders(rres.headers, res);
+        }
+        res.writeHead(rres.headers?.['http-code'] ?? 200);
+        await new Promise((resolve) => {
+            rres.getRawStream().pipe(res).on('finish', () => {
+                resolve();
+            });
+        });
+        return true;
+    }
+    return false;
+}