@ossiana/node-libcurl 1.0.7-alpha-2 → 1.0.8-alpha-1

package/src/libcurl.ts

@@ -1,12 +1,71 @@
 import bindings from 'bindings'
+import { httpCookiesToArray, cookieOptFilter } from './utils';
 
 const { BaoLibCurl } = bindings('bao_curl_node_addon');
 
-export enum LibCurl_HTTP_VERSION {
+export enum LibCurlHttpVersionInfo {
     http1_1,
     http2,
 }
 
+//Domain         Secure  Path    CORS    TimeStamp       Name    Value
+export type LibCurlSetCookieOption = {
+    domain?: string;
+    // secure?: boolean;
+    path?: string;
+    // cors?: boolean;
+    name: string;
+    value: string;
+}
+
+export type LibCurlCookiesInfo = string | { [key: string]: string };
+
+
+export type LibCurlGetCookiesOption = {
+    domain?: string;
+    path?: string;
+}
+
+export type LibCurlGetCookieOption = {
+    name: string;
+    domain: string;
+    path?: string;
+}
+
+export type LibCurlCookieAttrArray = [
+    domain: string, secure: boolean, path: string, cors: boolean, timestamp: number, name: string, value: string
+]
+
+export type LibCurlCookieAttrObject = {
+    domain: string, secure: boolean, path: string, cors: boolean, timestamp: number, value: string
+}
+
+export type LibCurlCookiesAttr = Map<string, LibCurlCookieAttrObject>
+
+export type LibCurlHeadersAttr = Map<string, string>
+
+export type LibCurlHeadersInfo = string | { [key: string]: [value: string] } | LibCurlHeadersAttr
+
+export type LibCurlBodyInfo = string | Uint8Array | URLSearchParams | any;
+
+export type LibCurlMethodInfo = 'GET' | 'POST' | 'HEAD' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'
+
+export type LibCurlProxyWithAccountInfo = {
+    proxy: string;
+    username: string;
+    password: string;
+};
+
+export type LibCurlProxyInfo = string | LibCurlProxyWithAccountInfo;
+
+export type LibCurlURLInfo = string | URL;
+
+export class LibCurlError extends Error {
+    constructor(e: string) {
+        super(e)
+    }
+}
+
 export class LibCurl {
     private m_libCurl_impl_: any;
     private m_isAsync_: boolean;
@@ -19,9 +78,9 @@ export class LibCurl {
             throw new Error('the last request is sending, don\'t send one more request on one instance!')
         }
     }
-    public open(method: string, url: string, async: boolean = true): void {
+    public open(method: LibCurlMethodInfo, url: LibCurlURLInfo, async: boolean = true): void {
         this.checkSending();
-        this.m_libCurl_impl_.open(method, url);
+        this.m_libCurl_impl_.open(method, url+'');
         this.m_isAsync_ = async;
     }
 
@@ -32,11 +91,25 @@ export class LibCurl {
 
     /**
      * 
-     * @param headers 多个header 以\n换行链接的文本
+     * @param headers
      */
-    public setRequestHeaders(headers: string): void {
+    public setRequestHeaders(headers: LibCurlHeadersInfo): void {
         this.checkSending();
-        this.m_libCurl_impl_.setRequestHeaders(headers);
+        if (!headers) {
+            return;
+        }
+        if (headers instanceof Map) {
+            headers.forEach((value, key) => this.m_libCurl_impl_.setRequestHeader(key, value))
+        } else if (typeof headers == 'string') {
+            this.m_libCurl_impl_.setRequestHeaders(headers);
+        } else if (typeof headers == 'object') {
+            Object.keys(headers).forEach((key) => {
+                const value = headers[key];
+                this.m_libCurl_impl_.setRequestHeader(key, value);
+            })
+        } else {
+            throw new TypeError('unkown type')
+        }
     }
 
     /**
@@ -45,12 +118,12 @@ export class LibCurl {
      * @param username 
      * @param password 
      */
-    public setProxy(proxy: string, username?: string, password?: string): void {
+    public setProxy(proxyOpt: LibCurlProxyInfo): void {
         this.checkSending();
-        if (username && password) {
-            this.m_libCurl_impl_.setProxy(proxy, username, password);
+        if (typeof proxyOpt == 'string') {
+            this.m_libCurl_impl_.setProxy(proxyOpt);
         } else {
-            this.m_libCurl_impl_.setProxy(proxy);
+            this.m_libCurl_impl_.setProxy(proxyOpt.proxy, proxyOpt.username, proxyOpt.password);
         }
     }
 
@@ -74,41 +147,60 @@ export class LibCurl {
      * @param value 
      * @param domain cookie作用域 sample: .baidu.com  baike.baidu.com
      */
-    public setCookie(key: string, value: string, domain: string): void {
+    public setCookie(cookieOpt: LibCurlSetCookieOption): void {
         this.checkSending();
-        this.m_libCurl_impl_.setCookie(key, value, domain);
+        this.m_libCurl_impl_.setCookie(cookieOpt.name, cookieOpt.value, cookieOpt.domain, cookieOpt.path);
     }
 
     /**
      * 
-     * @param key 
+     * @param cookieOpt 
      * @param domain cookie作用域 sample: .baidu.com  baike.baidu.com
      */
-    public removeCookie(key: string, domain: string): void {
+    public deleteCookie(cookieOpt: LibCurlGetCookieOption): void {
         this.checkSending();
-        this.m_libCurl_impl_.removeCookie(key, domain);
+        this.m_libCurl_impl_.deleteCookie(cookieOpt.name, cookieOpt.domain, cookieOpt.path || "/");
     }
 
     /**
-     * 
-     * @returns 返回所有Cookies 以\n连接
-     * sample: .127.0.0.1      TRUE    /       FALSE   3000000000      a       b
-     *         .127.0.0.1      TRUE    /api    FALSE   3000000000      c       d
+     * @param {LibCurlGetCookiesOption}cookieOpt
+     * @returns 返回所有Cookies sample:'a=b;c=d;'
+     */
+    public getCookies(cookieOpt?: LibCurlGetCookiesOption): string {
+        this.checkSending();
+        const cookies_ = this.m_libCurl_impl_.getCookies();
+        return httpCookiesToArray(cookies_).filter(cookieOptFilter(cookieOpt)).map(e => `${e[5]}=${encodeURIComponent(e[6])}`).join(';');
+    }
+
+    /**
+     * @param {LibCurlGetCookiesOption}cookieOpt
+     * @returns 返回所有Cookie的Map
      */
-    public getCookies(): string {
+    public getCookiesMap(cookieOpt?: LibCurlGetCookiesOption): LibCurlCookiesAttr {
         this.checkSending();
-        return this.m_libCurl_impl_.getCookies();
+        const cookies_ = this.m_libCurl_impl_.getCookies();
+        return httpCookiesToArray(cookies_).filter(cookieOptFilter(cookieOpt)).reduce((e: LibCurlCookiesAttr, t: LibCurlCookieAttrArray) => {
+            e.set(t[5], {
+                domain: t[0],
+                secure: t[1],
+                path: t[2],
+                cors: t[3],
+                timestamp: t[4],
+                value: t[6],
+            } as LibCurlCookieAttrObject)
+            return e;
+        }, new Map<string, LibCurlCookieAttrObject>());
     }
 
     /**
      * 
-     * @param key
-     * @returns 返回该key对应的cookie
+     * @param cookieOpt
+     * @returns 返回该cookieOpt对应的cookieValue
      * sample: 
      */
-    public getCookie(key: string): string {
+    public getCookie(cookieOpt: LibCurlGetCookieOption): string {
         this.checkSending();
-        return this.m_libCurl_impl_.getCookie(key);
+        return this.m_libCurl_impl_.getCookie(cookieOpt.name, cookieOpt.domain || "", cookieOpt.path || "");
     }
 
     /**
@@ -120,6 +212,24 @@ export class LibCurl {
         return this.m_libCurl_impl_.getResponseHeaders();
     }
 
+    /**
+     * @returns 返回响应头 Map
+     */
+    public getResponseHeadersMap(): LibCurlHeadersAttr {
+        this.checkSending();
+        const headers_ = this.m_libCurl_impl_.getResponseHeaders();
+        return headers_.split('\r\n')
+            .slice(1)//HTTP/1.1 200 OK
+            .reduce((e: LibCurlHeadersAttr, t: string) => {
+                if (!t) {
+                    return e;
+                }
+                const [key, value] = t.split(': ');
+                e.set(key, value);
+                return e;
+            }, new Map<string, string>());
+    }
+
     /**
      * 
      * @returns 返回状态码
@@ -160,7 +270,7 @@ export class LibCurl {
      * @param version 
      * 设置http版本号
      */
-    public setHttpVersion(version: LibCurl_HTTP_VERSION): void {
+    public setHttpVersion(version: LibCurlHttpVersionInfo): void {
         this.checkSending();
         this.m_libCurl_impl_.setHttpVersion(version);
     }
@@ -170,14 +280,18 @@ export class LibCurl {
      * @param body POST PUT PATCH时 发送的body
      * 当body不为string或uint8array时 此函数将用JSON.stringify转换对象
      */
-    public send(body?: string | Uint8Array | any): Promise<undefined> | undefined {
+    public send(body?: LibCurlBodyInfo): Promise<undefined> | undefined {
         this.checkSending();
         this.m_isSending_ = true;
         if (this.m_isAsync_) {
             return new Promise((resolve, reject) => {
-                const callback = () => {
+                const callback = (curlcode: number, curlcodeError: string) => {
                     this.m_isSending_ = false;
-                    resolve(void 0);
+                    if (curlcode != 0) {
+                        reject(new LibCurlError(curlcodeError));
+                    } else {
+                        resolve(void 0);
+                    }
                 };
                 if (body) {
                     this.m_libCurl_impl_.sendAsync(body, callback);
@@ -187,7 +301,11 @@ export class LibCurl {
             })
         }
         if (body) {
-            this.m_libCurl_impl_.send(body);
+            if (body instanceof URLSearchParams) {
+                this.m_libCurl_impl_.send(body + '');
+            } else {
+                this.m_libCurl_impl_.send(body);
+            }
         } else {
             this.m_libCurl_impl_.send();
         }
@@ -208,32 +326,5 @@ export class LibCurl {
         return JSON.parse(this.getResponseString());
     }
 
-    /**
-     * 
-     * @param callbackName 
-     * @returns JSON
-     * unsafe
-     * sample __WX__({a:1})
-     */
-    public getResponseJsonp(callbackName?: string): Object {
-        this.checkSending();
-        const str: string = this.getResponseString();
-        let jsonstr: string = str;
-        if (callbackName) {
-            [, jsonstr] = new RegExp(`\s*${callbackName}[\s\S]*(.*)[\s\S]*`, 'g').exec(str)
-        } else {
-            try {
-                eval(str)
-                throw new Error('it seem not a jsonp');
-            } catch (error) {
-                try {
-                    [, callbackName] = /(.*) is not defined/g.exec(error.message);
-                    return this.getResponseJsonp(callbackName);
-                } catch {
-                    throw new Error('it seem not a jsonp')
-                }
-            }
-        }
-        return eval(jsonstr);
-    }
+    
 }

package/src/requests.ts

@@ -0,0 +1,211 @@
+import { LibCurl, LibCurlBodyInfo, LibCurlCookiesAttr, LibCurlCookiesInfo, LibCurlHeadersAttr, LibCurlHeadersInfo, LibCurlMethodInfo, LibCurlProxyInfo, LibCurlHttpVersionInfo, LibCurlURLInfo } from "./libcurl"
+import { libcurlSetCookies } from "./utils";
+
+type requestsHttpVersionInfo = LibCurlHttpVersionInfo;
+type requestsHeadersInfo = LibCurlHeadersInfo;
+type requestsBodyInfo = LibCurlBodyInfo;
+type requestsCookiesInfo = LibCurlCookiesInfo;
+type requestsMethodInfo = LibCurlMethodInfo;
+
+type requestsProxyInfo = LibCurlProxyInfo;
+type requestsURLInfo = LibCurlURLInfo
+
+interface requestsResponseImp {
+    readonly text: string;
+    readonly json: object;
+    readonly buffer: Uint8Array;
+    readonly headers: string;
+    readonly headersMap: LibCurlHeadersAttr;
+    readonly status: number;
+}
+
+class requestsResponse implements requestsResponseImp {
+    private curl: LibCurl;
+    constructor(curl: LibCurl) {
+        this.curl = curl;
+    }
+
+    public get text(): string {
+        return this.curl.getResponseString();
+    }
+
+    public get json(): object {
+        return this.curl.getResponseJson();
+    }
+
+    public get buffer(): Uint8Array {
+        return this.curl.getResponseBody();
+    }
+
+    public get headers(): string {
+        return this.curl.getResponseHeaders();
+    }
+
+    public get headersMap(): LibCurlHeadersAttr {
+        return this.curl.getResponseHeadersMap();
+    }
+
+    public get status(): number {
+        return this.curl.getResponseStatus();
+    }
+
+
+}
+
+interface requestsInitOption {
+    redirect?: boolean;
+    cookies?: requestsCookiesInfo;
+    proxy?: requestsProxyInfo;
+    body?: requestsBodyInfo;
+    httpVersion?: requestsHttpVersionInfo;
+
+    /**
+     * 单位(秒)
+     */
+    timeout?: number;
+    /**
+     * 传入LibCurl实例可以做持久化连接
+     */
+    instance?: LibCurl;
+}
+
+type requestsParamsInfo = URLSearchParams | string | { [key: string]: string };
+
+interface requestsOption {
+    headers?: requestsHeadersInfo;
+    body?: requestsBodyInfo;
+    params?: requestsParamsInfo;
+}
+
+const assignURLSearchParam = (target: URLSearchParams, source: URLSearchParams) => {
+    source.forEach((value, key) => {
+        target.append(key, value);
+    })
+}
+
+export class requests {
+    private option: requestsInitOption;
+    constructor(option: requestsInitOption = {}) {
+        this.option = { ...option };
+        const { cookies, timeout } = option;
+        const curl = this.option.instance ||= new LibCurl();
+
+        if (cookies) {
+            libcurlSetCookies(curl, cookies, '.');
+        }
+        if (timeout) {
+            curl.setTimeout(timeout, timeout);
+        }
+    }
+
+    static session(option: requestsInitOption = {}): requests {
+        return new requests(option);
+    }
+
+
+    //暂定6种常用方法
+    static async get(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('GET', url, requestOpt);
+    }
+    static async post(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('POST', url, requestOpt);
+    }
+    static async put(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('PUT', url, requestOpt);
+    }
+    static async patch(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('PATCH', url, requestOpt);
+    }
+    static async trace(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('TRACE', url, requestOpt);
+    }
+    static async head(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return requests.session().sendRequest('HEAD', url, requestOpt);
+    }
+    async get(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('GET', url, requestOpt);
+    }
+    async post(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('POST', url, requestOpt);
+    }
+    async put(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('PUT', url, requestOpt);
+    }
+    async patch(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('PATCH', url, requestOpt);
+    }
+    async trace(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('TRACE', url, requestOpt);
+    }
+    async head(url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        return this.sendRequest('HEAD', url, requestOpt);
+    }
+
+    setCookie(key: string, value: string, domain: string = '', path: string = '') {
+        this.option.instance.setCookie({
+            name: key,
+            value,
+            domain,
+            path,
+        });
+    }
+
+    getCookie(key: string, domain?: string, path?: string): string {
+        return this.option.instance.getCookie({
+            name: key,
+            domain: domain || "",
+            path: path || "",
+        })
+    }
+
+    getCookies(domain?: string, path?: string): string {
+        if (arguments.length == 0) {
+            return this.option.instance.getCookies();
+        }
+        return this.option.instance.getCookies({
+            domain: domain || "",
+            path: path || "",
+        })
+    }
+    getCookiesMap(domain?: string, path?: string): LibCurlCookiesAttr {
+        if (arguments.length == 0) {
+            return this.option.instance.getCookiesMap();
+        }
+        return this.option.instance.getCookiesMap({
+            domain: domain || "",
+            path: path || "",
+        })
+    }
+
+    deleteCookie(key: string, domain: string, path?: string) {
+        this.option.instance.deleteCookie({
+            name: key,
+            domain: domain,
+            path: path || "/",
+        })
+    }
+
+    private async sendRequest(method: requestsMethodInfo, url: requestsURLInfo, requestOpt?: requestsOption): Promise<requestsResponse> {
+        const { instance: curl, redirect = false, proxy, httpVersion } = this.option;
+        const { headers, body, params } = requestOpt || {};
+        const url_ = new URL(url);
+        if (params) {
+            assignURLSearchParam(url_.searchParams, new URLSearchParams(params));
+        }
+        curl.open(method, url + '', true);
+        if (headers) {
+            curl.setRequestHeaders(headers);
+        }
+        if (redirect) {
+            curl.setRedirect(true);
+        }
+        if (httpVersion) {
+            curl.setHttpVersion(httpVersion);
+        }
+        if (proxy) {
+            curl.setProxy(proxy);
+        }
+        await curl.send(body);
+        return new requestsResponse(curl);
+    }
+}

package/src/utils.ts

@@ -0,0 +1,71 @@
+import { LibCurl, LibCurlCookieAttrArray, LibCurlCookiesInfo, LibCurlGetCookiesOption } from "./libcurl";
+
+export const httpCookiesToArray: (cookies: string) => LibCurlCookieAttrArray[] = (cookies) => {
+    const stringBooleanToJsBoolean = (e: string) => {
+        switch (e) {
+            case 'TRUE':
+                return true;
+            case 'FALSE':
+                return false;
+            default:
+                throw new Error(`unkonw type ${e}`)
+        }
+    }
+    /*
+     *          Domain         Secure  Path    CORS    TimeStamp       Name    Value
+     * sample: .127.0.0.1      TRUE    /       FALSE   3000000000      a       b
+     *         .127.0.0.1      TRUE    /api    FALSE   3000000000      c       d
+     */
+    const cookies_ = [];
+    for (const it of cookies.split('\n')) {
+        if (!it) {
+            continue;
+        }
+        const [domain, secure, path, cors, timestamp, name, value] = it.split('\t');
+        cookies_.push([domain, stringBooleanToJsBoolean(secure), path, stringBooleanToJsBoolean(cors), parseInt(timestamp), name, value])
+    }
+    return cookies_;
+}
+
+export const cookieOptFilter = (cookieOpt: LibCurlGetCookiesOption) => {
+    return (e: LibCurlCookieAttrArray) => {
+        if (cookieOpt) {
+            if (cookieOpt.domain) {
+                if (cookieOpt.domain != e[0])
+                    return false;
+            }
+            if (cookieOpt.path) {
+                if (cookieOpt.path != e[2])
+                    return false;
+            }
+        }
+        return true;
+    }
+}
+
+
+export const libcurlSetCookies = (curl: LibCurl, cookies: LibCurlCookiesInfo, domain: string) => {
+    if (typeof cookies == 'string') {
+        cookies.replace(/\s+/g, '')
+            .split(';')
+            .reverse()//保证顺序不颠倒
+            .map(e => e.split('=', 2))
+            .forEach(([key, value]) => {
+                curl.setCookie({
+                    name: key,
+                    value,
+                    domain,
+                    path: '/',
+                })
+            });
+    } else {
+        Object.keys(cookies).forEach(key => {
+            curl.setCookie({
+                name: key,
+                value: cookies[key],
+                domain,
+                path: '/',
+            });
+        })
+    }
+}

package/tsconfig.json

@@ -17,6 +17,7 @@
     "esModuleInterop": true
   },
   "lib": [
+    "es2019",
     "es2017",
     "es7",
     "es6",

package/dist/src/export.d.ts

@@ -1,3 +0,0 @@
-import { LibCurl } from "./libcurl";
-import { fetch } from "./fetch";
-export { LibCurl, fetch };

package/dist/src/export.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = exports.LibCurl = void 0;
-const libcurl_1 = require("./libcurl");
-Object.defineProperty(exports, "LibCurl", { enumerable: true, get: function () { return libcurl_1.LibCurl; } });
-const fetch_1 = require("./fetch");
-Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_1.fetch; } });
-//# sourceMappingURL=export.js.map

package/dist/src/export.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"export.js","sourceRoot":"","sources":["../../src/export.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AAG3B,wFAHA,iBAAO,OAGA;AAFhB,mCAA+B;AAEb,sFAFT,aAAK,OAES"}

package/dist/src/fetch.d.ts

@@ -1,32 +0,0 @@
-import { LibCurl, LibCurl_HTTP_VERSION } from "./libcurl";
-type LibCurlHeadersInfo = [string, string][] | object | string;
-type LibCurlBodyInfo = string | Uint8Array | any;
-type LibCurlCookiesInfo = string | object;
-type LibCurlHttpVersionInfo = LibCurl_HTTP_VERSION;
-type LibCurlProxyWithAccountInfo = {
-    proxy: string;
-    username: string;
-    password: string;
-};
-type LibCurlProxyInfo = string | LibCurlProxyWithAccountInfo;
-interface LibCurlRequestInfo {
-    method?: string;
-    headers?: LibCurlHeadersInfo;
-    body?: LibCurlBodyInfo;
-    redirect?: boolean;
-    cookies?: LibCurlCookiesInfo;
-    httpVersion?: LibCurlHttpVersionInfo;
-    openInnerLog?: boolean;
-    proxy?: LibCurlProxyInfo;
-    instance?: LibCurl;
-}
-interface LibCurlResponseInfo {
-    status: () => number;
-    arraybuffer: () => Promise<ArrayBuffer>;
-    text: () => Promise<string>;
-    json: () => Promise<object>;
-    jsonp: (callbackName?: string) => Promise<object>;
-    headers: () => Promise<string>;
-}
-export declare function fetch(url: string | URL, request?: LibCurlRequestInfo): Promise<LibCurlResponseInfo>;
-export {};