keq 2.0.0 → 2.0.2

package/dist/umd/src/keq.js

@@ -0,0 +1,193 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./core", "./exception/exception", "./exception/invalid-arguments.exception", "./is/is-blob", "./is/is-file", "./is/is-form-data", "./is/is-headers", "./is/is-url-search-params", "./util/assign-keq-request-body", "./util/base64", "./util/fix-content-type"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Keq = void 0;
+    const core_1 = require("./core");
+    const exception_1 = require("./exception/exception");
+    const invalid_arguments_exception_1 = require("./exception/invalid-arguments.exception");
+    const is_blob_1 = require("./is/is-blob");
+    const is_file_1 = require("./is/is-file");
+    const is_form_data_1 = require("./is/is-form-data");
+    const is_headers_1 = require("./is/is-headers");
+    const is_url_search_params_1 = require("./is/is-url-search-params");
+    const assign_keq_request_body_1 = require("./util/assign-keq-request-body");
+    const base64_1 = require("./util/base64");
+    const fix_content_type_1 = require("./util/fix-content-type");
+    /**
+     * @description Keq 扩展 API，人性化的常用的API
+     */
+    class Keq extends core_1.Core {
+        use(...middlewares) {
+            return this.prependMiddlewares(...middlewares);
+        }
+        option(key, value = true) {
+            this.__options__[key] = value;
+            return this;
+        }
+        options(opts) {
+            for (const [key, value] of Object.entries(opts)) {
+                this.__options__[key] = value;
+            }
+            return this;
+        }
+        set(headersOrName, value) {
+            if ((0, is_headers_1.isHeaders)(headersOrName)) {
+                headersOrName.forEach((value, key) => {
+                    this.requestContext.headers.set(key, value);
+                });
+            }
+            else if (typeof headersOrName === 'string' && value) {
+                this.requestContext.headers.set(headersOrName, value);
+            }
+            else if (typeof headersOrName === 'object') {
+                for (const [key, value] of Object.entries(headersOrName)) {
+                    this.requestContext.headers.set(key, value);
+                }
+            }
+            return this;
+        }
+        query(key, value) {
+            if (typeof key === 'string' && Array.isArray(value)) {
+                for (const item of value) {
+                    this.requestContext.url.searchParams.append(key, String(item));
+                }
+            }
+            else if (typeof key === 'string' && typeof value === 'string') {
+                this.requestContext.url.searchParams.append(key, value);
+            }
+            else if (typeof key === 'object') {
+                for (const [k, v] of Object.entries(key)) {
+                    if (v === undefined)
+                        continue;
+                    this.query(k, v);
+                }
+            }
+            else {
+                throw new exception_1.Exception('please set query value');
+            }
+            return this;
+        }
+        params(key, value) {
+            if (typeof key === 'string') {
+                this.requestContext.routeParams[key] = String(value);
+            }
+            else if (typeof key === 'object') {
+                for (const [k, v] of Object.entries(key)) {
+                    this.requestContext.routeParams[k] = String(v);
+                }
+            }
+            else {
+                throw new exception_1.Exception('please set params value');
+            }
+            return this;
+        }
+        /**
+         * Set request body
+         */
+        body(value) {
+            this.requestContext.body = value;
+            return this;
+        }
+        /**
+         * Setting the Content-Type
+         */
+        type(contentType) {
+            const type = (0, fix_content_type_1.fixContentType)(contentType);
+            this.set('Content-Type', type);
+            return this;
+        }
+        /**
+         * Http Basic Authentication
+         */
+        auth(username, password) {
+            this.set('Authorization', `Basic ${(0, base64_1.base64Encode)(`${username}:${password}`)}`);
+            return this;
+        }
+        setTypeIfEmpty(contentType) {
+            if (!this.requestContext.headers.has('Content-Type'))
+                void this.type(contentType);
+        }
+        /**
+         * set request body
+         */
+        send(value) {
+            this.requestContext.body = (0, assign_keq_request_body_1.assignKeqRequestBody)(this.requestContext.body, value);
+            if ((0, is_url_search_params_1.isUrlSearchParams)(value)) {
+                this.setTypeIfEmpty('form');
+            }
+            else if ((0, is_form_data_1.isFormData)(value)) {
+                this.setTypeIfEmpty('form-data');
+            }
+            else if (typeof value === 'object') {
+                this.setTypeIfEmpty('json');
+            }
+            return this;
+        }
+        field(arg1, arg2) {
+            if (typeof arg1 === 'object') {
+                this.requestContext.body = (0, assign_keq_request_body_1.assignKeqRequestBody)(this.requestContext.body, arg1);
+            }
+            else if (arg2) {
+                this.requestContext.body = (0, assign_keq_request_body_1.assignKeqRequestBody)(this.requestContext.body, { [arg1]: arg2 });
+            }
+            else {
+                throw new invalid_arguments_exception_1.InvalidArgumentsExceptions();
+            }
+            this.setTypeIfEmpty('form-data');
+            return this;
+        }
+        attach(key, value, arg3 = 'file') {
+            let file;
+            if ((0, is_blob_1.isBlob)(value)) {
+                const formData = new FormData();
+                formData.set(key, value, arg3);
+                file = formData.get(key);
+            }
+            else if ((0, is_file_1.isFile)(value)) {
+                file = value;
+            }
+            else if (value instanceof Buffer) {
+                file = new File([value], arg3);
+            }
+            else {
+                throw new invalid_arguments_exception_1.InvalidArgumentsExceptions();
+            }
+            this.requestContext.body = (0, assign_keq_request_body_1.assignKeqRequestBody)(this.requestContext.body, { [key]: file });
+            this.setTypeIfEmpty('form-dat');
+            return this;
+        }
+        /**
+         *
+         * @param retryTimes Max number of retries per call
+         * @param retryDelay Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor)
+         * @param retryCallback Will be called after request failed
+         */
+        retry(retryTimes, retryDelay, retryOn) {
+            this.option('retryTimes', retryTimes);
+            this.option('retryDelay', retryDelay);
+            this.option('retryOn', retryOn);
+            return this;
+        }
+        redirect(mod) {
+            this.requestContext.redirect = mod;
+            return this;
+        }
+        credentials(mod) {
+            this.requestContext.credentials = mod;
+            return this;
+        }
+        mode(mod) {
+            this.requestContext.mode = mod;
+            return this;
+        }
+    }
+    exports.Keq = Keq;
+});

package/dist/umd/src/middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from './types/keq-middleware';
+export declare function composeMiddleware(middlewares: KeqMiddleware[]): KeqMiddleware;

package/dist/umd/src/middleware.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception/exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.composeMiddleware = void 0;
+    /* eslint-disable @typescript-eslint/no-empty-function */
+    const exception_1 = require("./exception/exception");
+    function composeMiddleware(middlewares) {
+        if (!middlewares.length) {
+            throw new exception_1.Exception('At least one middleware');
+        }
+        const middleware = middlewares
+            .reverse()
+            .reduce(function (prev, curr) {
+            return (ctx, next) => curr(ctx, () => prev(ctx, next));
+        });
+        return middleware;
+    }
+    exports.composeMiddleware = composeMiddleware;
+});

package/dist/umd/src/middlewares/fetch-arguments-middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from '../types/keq-middleware';
+export declare function fetchArgumentsMiddleware(): KeqMiddleware;

package/dist/umd/src/middlewares/fetch-arguments-middleware.js

@@ -0,0 +1,96 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "path-to-regexp", "whatwg-url", "../exception/exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fetchArgumentsMiddleware = void 0;
+    const path_to_regexp_1 = require("path-to-regexp");
+    const whatwg_url_1 = require("whatwg-url");
+    const exception_1 = require("../exception/exception");
+    function compileUrl(obj, routeParams) {
+        const url = new whatwg_url_1.URL(typeof obj === 'string' ? obj : obj.href);
+        try {
+            const toPath = (0, path_to_regexp_1.compile)(url.pathname, { encode: encodeURIComponent });
+            url.pathname = toPath(routeParams);
+        }
+        catch (e) {
+            throw new exception_1.Exception(`Cannot compile the params in ${url.pathname}, Because ${e?.message}.`);
+        }
+        return url.href;
+    }
+    function inferContentTypeByBody(body) {
+        if (!body)
+            return 'text/plain';
+        if (typeof body === 'object')
+            return 'application/json';
+        return 'application/x-www-form-urlencoded';
+    }
+    function compileBody(ctx) {
+        const request = ctx.request;
+        const body = request.body;
+        const contentType = request.headers.get('Content-Type');
+        if (contentType === 'application/json' && body) {
+            return typeof body === 'object' ? JSON.stringify(body) : body;
+        }
+        else if (contentType === 'application/x-www-form-urlencoded' && body) {
+            if (Array.isArray(body))
+                return;
+            const params = new URLSearchParams();
+            Object.entries(body).map(([key, value]) => {
+                if (Array.isArray(value)) {
+                    for (const v of value) {
+                        params.append(key, v);
+                    }
+                }
+                else {
+                    params.append(key, value);
+                }
+            });
+            return params;
+        }
+        else if (contentType === 'multipart/form-data') {
+            if (Array.isArray(ctx.request.body)) {
+                throw new exception_1.Exception('FormData cannot send array');
+            }
+            if (!ctx.request.body)
+                return;
+            const body = ctx.request.body;
+            const form = new FormData();
+            for (const [key, value] of Object.entries(body)) {
+                if (Array.isArray(value)) {
+                    for (const v of value) {
+                        form.append(key, v);
+                    }
+                }
+                else {
+                    form.append(key, value);
+                }
+            }
+            request.headers.delete('content-type');
+            return form;
+        }
+    }
+    function fetchArgumentsMiddleware() {
+        return async (ctx, next) => {
+            const request = ctx.request;
+            const url = compileUrl(request.url, request.routeParams);
+            if (!request.headers.has('Content-Type') && request.body) {
+                request.headers.set('Content-Type', inferContentTypeByBody(ctx.request.body));
+            }
+            const requestInit = {
+                method: request.method.toUpperCase(),
+                headers: request.headers,
+                body: compileBody(ctx),
+            };
+            ctx.fetchArguments = [url, requestInit];
+            await next();
+        };
+    }
+    exports.fetchArgumentsMiddleware = fetchArgumentsMiddleware;
+});

package/dist/umd/src/middlewares/fetch-middleware.d.ts

@@ -0,0 +1,5 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+/**
+ * Send Request
+ */
+export declare function fetchMiddleware(): KeqMiddleware;

package/dist/umd/src/middlewares/fetch-middleware.js

@@ -0,0 +1,29 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../exception/exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fetchMiddleware = void 0;
+    const exception_1 = require("../exception/exception");
+    /**
+     * Send Request
+     */
+    function fetchMiddleware() {
+        return async (ctx) => {
+            const fetchArguments = ctx.fetchArguments;
+            if (!fetchArguments) {
+                throw new exception_1.Exception('fetchArguments is required');
+            }
+            const fetch = ctx.options.fetchAPI || globalThis.fetch;
+            const response = await fetch(...fetchArguments);
+            ctx.res = response;
+        };
+    }
+    exports.fetchMiddleware = fetchMiddleware;
+});

package/dist/umd/src/middlewares/proxy-response-middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from '../types/keq-middleware';
+export declare function proxyResponseMiddleware(): KeqMiddleware;

package/dist/umd/src/middlewares/proxy-response-middleware.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.proxyResponseMiddleware = void 0;
+    function proxyResponseMiddleware() {
+        return async (ctx, next) => {
+            await next();
+            const res = ctx.res;
+            if (res) {
+                Object.defineProperty(ctx, 'response', {
+                    get() {
+                        return res.clone();
+                    },
+                });
+            }
+        };
+    }
+    exports.proxyResponseMiddleware = proxyResponseMiddleware;
+});

package/dist/umd/src/middlewares/retry-middleware.d.ts

@@ -0,0 +1,2 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+export declare function retryMiddleware(): KeqMiddleware;

package/dist/umd/src/middlewares/retry-middleware.js

@@ -0,0 +1,51 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.retryMiddleware = void 0;
+    function sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    function retryMiddleware() {
+        return async (ctx, next) => {
+            const retryTimes = (Number(ctx.options.retryTimes) || 0) + 1;
+            const retryDelay = ctx.options.retryDelay || 10;
+            const retryOn = ctx.options.retryOn;
+            // Avoid multiple middleware from being added repeatedly
+            ctx.options = {
+                ...ctx.options,
+                retryTimes: undefined,
+                retryDelay: undefined,
+                retryOn: undefined,
+            };
+            for (let i = 0; i < retryTimes; i++) {
+                let err = null;
+                try {
+                    await next();
+                }
+                catch (e) {
+                    err = e;
+                }
+                if (i === retryTimes - 1)
+                    break;
+                if (retryOn && retryOn(i, err, ctx) === false) {
+                    break;
+                }
+                else if (!retryOn && !err) {
+                    break;
+                }
+                const delay = typeof retryDelay === 'function' ? retryDelay(i, err, ctx) : retryDelay;
+                if (delay > 0)
+                    await sleep(delay);
+            }
+        };
+    }
+    exports.retryMiddleware = retryMiddleware;
+});

package/dist/umd/src/router/keq-host-router.d.ts

@@ -0,0 +1,7 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+import { KeqRouter } from './keq-router';
+export declare class KeqHostRouter extends KeqRouter {
+    host: string;
+    constructor(host: string, middlewares: KeqMiddleware[]);
+    routes(): KeqMiddleware;
+}

package/dist/umd/src/router/keq-host-router.js

@@ -0,0 +1,33 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../middleware", "./keq-router"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KeqHostRouter = void 0;
+    const middleware_1 = require("../middleware");
+    const keq_router_1 = require("./keq-router");
+    class KeqHostRouter extends keq_router_1.KeqRouter {
+        host;
+        constructor(host, middlewares) {
+            super(middlewares);
+            this.host = host;
+        }
+        routes() {
+            return async (ctx, next) => {
+                if (ctx.request.url.host === this.host) {
+                    await (0, middleware_1.composeMiddleware)(this.middlewares)(ctx, next);
+                }
+                else {
+                    await next();
+                }
+            };
+        }
+    }
+    exports.KeqHostRouter = KeqHostRouter;
+});

package/dist/umd/src/router/keq-location-router.d.ts

@@ -0,0 +1,6 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+import { KeqRouter } from './keq-router';
+export declare class KeqLocationRouter extends KeqRouter {
+    constructor(middlewares: KeqMiddleware[]);
+    routes(): KeqMiddleware;
+}

package/dist/umd/src/router/keq-location-router.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../is/is-browser", "../middleware", "./keq-router"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KeqLocationRouter = void 0;
+    const is_browser_1 = require("../is/is-browser");
+    const middleware_1 = require("../middleware");
+    const keq_router_1 = require("./keq-router");
+    class KeqLocationRouter extends keq_router_1.KeqRouter {
+        constructor(middlewares) {
+            super(middlewares);
+        }
+        routes() {
+            return async (ctx, next) => {
+                if ((0, is_browser_1.isBrowser)() && ctx.request.url.host === window.location.host) {
+                    await (0, middleware_1.composeMiddleware)(this.middlewares)(ctx, next);
+                }
+                else {
+                    await next();
+                }
+            };
+        }
+    }
+    exports.KeqLocationRouter = KeqLocationRouter;
+});

package/dist/umd/src/router/keq-method-router.d.ts

@@ -0,0 +1,8 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+import { KeqRequestMethod } from "../types/keq-request-method";
+import { KeqRouter } from './keq-router';
+export declare class KeqMethodRouter extends KeqRouter {
+    method: string;
+    constructor(method: KeqRequestMethod, middlewares: KeqMiddleware[]);
+    routes(): KeqMiddleware;
+}

package/dist/umd/src/router/keq-method-router.js

@@ -0,0 +1,33 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../middleware", "./keq-router"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KeqMethodRouter = void 0;
+    const middleware_1 = require("../middleware");
+    const keq_router_1 = require("./keq-router");
+    class KeqMethodRouter extends keq_router_1.KeqRouter {
+        method;
+        constructor(method, middlewares) {
+            super(middlewares);
+            this.method = method;
+        }
+        routes() {
+            return async (ctx, next) => {
+                if (ctx.request.method.toLowerCase() === this.method) {
+                    await (0, middleware_1.composeMiddleware)(this.middlewares)(ctx, next);
+                }
+                else {
+                    await next();
+                }
+            };
+        }
+    }
+    exports.KeqMethodRouter = KeqMethodRouter;
+});

package/dist/umd/src/router/keq-module-router.d.ts

@@ -0,0 +1,7 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+import { KeqRouter } from './keq-router';
+export declare class KeqModuleRouter extends KeqRouter {
+    moduleName: string;
+    constructor(moduleName: string, middlewares: KeqMiddleware[]);
+    routes(): KeqMiddleware;
+}

package/dist/umd/src/router/keq-module-router.js

@@ -0,0 +1,37 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../exception/exception", "../middleware", "./keq-router"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KeqModuleRouter = void 0;
+    const exception_1 = require("../exception/exception");
+    const middleware_1 = require("../middleware");
+    const keq_router_1 = require("./keq-router");
+    class KeqModuleRouter extends keq_router_1.KeqRouter {
+        moduleName;
+        constructor(moduleName, middlewares) {
+            if (moduleName === '') {
+                throw new exception_1.Exception('Module name should not be empty');
+            }
+            super(middlewares);
+            this.moduleName = moduleName;
+        }
+        routes() {
+            return async (ctx, next) => {
+                if (ctx.options.module?.name === this.moduleName) {
+                    await (0, middleware_1.composeMiddleware)(this.middlewares)(ctx, next);
+                }
+                else {
+                    await next();
+                }
+            };
+        }
+    }
+    exports.KeqModuleRouter = KeqModuleRouter;
+});

package/dist/umd/src/router/keq-pathname-router.d.ts

@@ -0,0 +1,7 @@
+import { KeqMiddleware } from "../types/keq-middleware";
+import { KeqRouter } from './keq-router';
+export declare class KeqPathnameRouter extends KeqRouter {
+    pathname: string;
+    constructor(pathname: string, middlewares: KeqMiddleware[]);
+    routes(): KeqMiddleware;
+}

package/dist/umd/src/router/keq-pathname-router.js

@@ -0,0 +1,34 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "minimatch", "../middleware", "./keq-router"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.KeqPathnameRouter = void 0;
+    const minimatch_1 = require("minimatch");
+    const middleware_1 = require("../middleware");
+    const keq_router_1 = require("./keq-router");
+    class KeqPathnameRouter extends keq_router_1.KeqRouter {
+        pathname;
+        constructor(pathname, middlewares) {
+            super(middlewares);
+            this.pathname = pathname;
+        }
+        routes() {
+            return async (ctx, next) => {
+                if ((0, minimatch_1.minimatch)(ctx.request.url.pathname, this.pathname)) {
+                    await (0, middleware_1.composeMiddleware)(this.middlewares)(ctx, next);
+                }
+                else {
+                    await next();
+                }
+            };
+        }
+    }
+    exports.KeqPathnameRouter = KeqPathnameRouter;
+});