keq 2.5.1 → 2.5.3

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.5.3](https://github.com/keq-request/keq/compare/v2.5.2...v2.5.3) (2024-05-23)
+
+
+### Bug Fixes
+
+* retryTimes avoids throw errors caused by NaN ([a5ece3f](https://github.com/keq-request/keq/commit/a5ece3f8afec3c58d2daa3c5e1a2f85fae044665))
+
+## [2.5.2](https://github.com/keq-request/keq/compare/v2.5.1...v2.5.2) (2024-05-22)
+
+
+### Bug Fixes
+
+* composeMiddleware should not change parameters ([131c1d4](https://github.com/keq-request/keq/commit/131c1d42227eeda2d42436c5285426bf3f787df0))
+
+
+### Performance Improvements
+
+* avoid duplication of compose middleware ([c4e5cc1](https://github.com/keq-request/keq/commit/c4e5cc161d94b2440768c778489ee5ac1bb07484))
+* warn for incorrect invoke next() ([f4b418f](https://github.com/keq-request/keq/commit/f4b418f28e3df07bad0c03e2aca811ed6254e57c)), closes [#74](https://github.com/keq-request/keq/issues/74)
+
 ## [2.5.1](https://github.com/keq-request/keq/compare/v2.5.0...v2.5.1) (2024-05-21)
 
 

package/README.md

@@ -291,11 +291,11 @@ There are multiple parsing methods for us to choose from
 
 No retry by default, invoke `.retry(retryTimes[, retryDelay[, retryOn]])` to set retry parameters
 
-| Parameter  | Description                                                                                                              |
-| :--------- | :----------------------------------------------------------------------------------------------------------------------- |
-| retryTimes | Max number of retries per call.                                                                                          |
-| retryDelay | Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor). |
-| retryOn    | Will be called after request used to control whether the next retry runs. If it return `false`, stop retrying.           |
+| Parameter | Default | Description                                                                                                              |
+| :--------- |:------- | :----------------------------------------------------------------------------------------------------------------------- |
+| retryTimes  | `0` | Max number of retries per call.                                                                                          |
+| retryDelay |`0` | Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor). |
+| retryOn    | `(attempt, error) => !!error` | Will be called after request used to control whether the next retry runs. If it return `false`, stop retrying.           |
 
 ```javascript
 import { request } from "keq";

package/dist/esm/src/constant.d.ts

@@ -1 +1,2 @@
 export declare const OUTPUT_PROPERTY: unique symbol;
+export declare const NEXT_INVOKED_PROPERTY: unique symbol;

package/dist/esm/src/constant.js

@@ -1 +1,2 @@
 export const OUTPUT_PROPERTY = Symbol('outputProperty');
+export const NEXT_INVOKED_PROPERTY = Symbol('nextInvokedProperty');

package/dist/esm/src/core.js

@@ -1,7 +1,7 @@
 import { URL } from 'whatwg-url';
 import { Exception } from "./exception/exception.js";
 import { clone } from "./util/clone.js";
-import { OUTPUT_PROPERTY } from './constant.js';
+import { NEXT_INVOKED_PROPERTY, OUTPUT_PROPERTY } from './constant.js';
 import { composeMiddleware } from './util/compose-middleware.js';
 import { shadowClone } from './util/shadow-clone.js';
 /**
@@ -59,6 +59,11 @@ export class Core {
         };
         const options = shadowClone(this.__options__);
         const ctx = {
+            [NEXT_INVOKED_PROPERTY]: {
+                finished: false,
+                entryNextTimes: 0,
+                outNextTimes: 0,
+            },
             request: requestContext,
             options,
             global: this.__global__,

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

@@ -1,9 +1,12 @@
+import { NEXT_INVOKED_PROPERTY } from "../constant.js";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export function retryMiddleware() {
     return async function retryMiddleware(ctx, next) {
-        const retryTimes = (Number(ctx.options.retryTimes) || 0) + 1;
+        const retryTimes = Number.isInteger(ctx.options.retryTimes)
+            ? ctx.options.retryTimes + 1
+            : 1;
         const retryDelay = (attempt, error, ctx) => {
             if (typeof ctx.options.retryDelay === 'function') {
                 return ctx.options.retryDelay(attempt, error, ctx);
@@ -11,9 +14,11 @@ export function retryMiddleware() {
             else if (typeof ctx.options.retryDelay === 'number') {
                 return ctx.options.retryDelay;
             }
-            return 10;
+            return 0;
         };
-        const retryOn = typeof ctx.options.retryOn === 'function' ? ctx.options.retryOn : undefined;
+        const retryOn = typeof ctx.options.retryOn === 'function'
+            ? ctx.options.retryOn
+            : (attempt, error) => !!error;
         // Avoid multiple middleware from being added repeatedly
         ctx.options = {
             ...ctx.options,
@@ -24,6 +29,8 @@ export function retryMiddleware() {
         for (let i = 0; i < retryTimes; i++) {
             let err = null;
             try {
+                ctx[NEXT_INVOKED_PROPERTY].entryNextTimes = 0;
+                ctx[NEXT_INVOKED_PROPERTY].outNextTimes = 0;
                 await next();
             }
             catch (e) {
@@ -34,14 +41,11 @@ export function retryMiddleware() {
                     throw err;
                 break;
             }
-            if (retryOn && retryOn(i, err, ctx) === false) {
+            if (retryOn(i, err, ctx) === false) {
                 if (err)
                     throw err;
                 break;
             }
-            else if (!retryOn && !err) {
-                break;
-            }
             const delay = retryDelay(i, err, ctx);
             if (delay > 0)
                 await sleep(delay);

package/dist/esm/src/router/keq-router.js

@@ -10,15 +10,15 @@ export class KeqRouter {
         this.prependMiddlewares = prependMiddlewares;
     }
     route(route, ...middlewares) {
-        const middleware = async (ctx, next) => {
-            if (route(ctx)) {
-                await composeMiddleware(middlewares)(ctx, next);
-            }
-            else {
+        if (middlewares.length === 0)
+            return this;
+        const m = middlewares.length > 1 ? composeMiddleware(middlewares) : middlewares[0];
+        this.prependMiddlewares.push(async (ctx, next) => {
+            if (route(ctx))
+                await m(ctx, next);
+            else
                 await next();
-            }
-        };
-        this.prependMiddlewares.push(middleware);
+        });
         return this;
     }
     host(host, ...middlewares) {

package/dist/esm/src/types/keq-context.d.ts

@@ -1,5 +1,5 @@
 import { URL } from 'whatwg-url';
-import { OUTPUT_PROPERTY } from "../constant";
+import { NEXT_INVOKED_PROPERTY, OUTPUT_PROPERTY } from "../constant";
 import { KeqRequestBody } from './keq-request-body';
 import { KeqRequestMethod } from './keq-request-method';
 import { KeqOptionsParameter } from './keq-options.js';
@@ -23,6 +23,17 @@ export interface KeqRequestContext {
     signal?: AbortSignal | null;
 }
 export interface KeqContext {
+    /**
+     * Middleware invoker counter
+     *
+     * to prevent someone from calling next
+     * multiple times or forgetting to write await
+     */
+    [NEXT_INVOKED_PROPERTY]: {
+        finished: boolean;
+        entryNextTimes: number;
+        outNextTimes: number;
+    };
     options: KeqContextOptions;
     /**
      * Fetch API Arguments

package/dist/esm/src/types/keq-context.js

@@ -1 +1 @@
-import { OUTPUT_PROPERTY } from "../constant";
+import { NEXT_INVOKED_PROPERTY, OUTPUT_PROPERTY } from "../constant";

package/dist/esm/src/util/compose-middleware.js

@@ -1,12 +1,51 @@
 import { Exception } from "../exception/exception.js";
+import { NEXT_INVOKED_PROPERTY } from "../constant.js";
 export function composeMiddleware(middlewares) {
     if (!middlewares.length) {
         throw new Exception('At least one middleware');
     }
-    const middleware = middlewares
+    const middleware = [...middlewares]
         .reverse()
         .reduce(function (prev, curr) {
-        return (ctx, next) => curr(ctx, () => prev(ctx, next));
+        return async (ctx, next) => {
+            const invoked = {
+                finished: false,
+                entryNextTimes: 0,
+                outNextTimes: 0,
+            };
+            const context = new Proxy(ctx, {
+                get(target, property) {
+                    if (property === NEXT_INVOKED_PROPERTY) {
+                        return invoked;
+                    }
+                    // @ts-ignore
+                    return target[property];
+                },
+            });
+            await curr(context, async () => {
+                if (invoked.finished) {
+                    throw new Exception([
+                        `next() should not invoke after ${curr.toString()} middleware finished.`,
+                    ].join(''));
+                }
+                if (invoked.entryNextTimes > 1) {
+                    console.warn(`next() had be invoke multiple times at ${curr.toString()} middleware`);
+                }
+                invoked.entryNextTimes += 1;
+                await prev(ctx, next);
+                invoked.outNextTimes += 1;
+            });
+            invoked.finished = true;
+            if (invoked.entryNextTimes === 0) {
+                console.warn(`next() is not invoked at ${curr.toString()}.`);
+            }
+            if (invoked.entryNextTimes !== invoked.outNextTimes) {
+                throw new Exception([
+                    `next() should be invoke before ${curr.toString()} middleware finish.`,
+                    'Maybe you forgot to await when calling next().',
+                ].join(''));
+            }
+        };
     });
     return middleware;
 }

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

@@ -1 +1,2 @@
 export declare const OUTPUT_PROPERTY: unique symbol;
+export declare const NEXT_INVOKED_PROPERTY: unique symbol;

package/dist/umd/src/constant.js

@@ -9,6 +9,7 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.OUTPUT_PROPERTY = void 0;
+    exports.NEXT_INVOKED_PROPERTY = exports.OUTPUT_PROPERTY = void 0;
     exports.OUTPUT_PROPERTY = Symbol('outputProperty');
+    exports.NEXT_INVOKED_PROPERTY = Symbol('nextInvokedProperty');
 });

package/dist/umd/src/core.js

@@ -71,6 +71,11 @@
             };
             const options = (0, shadow_clone_js_1.shadowClone)(this.__options__);
             const ctx = {
+                [constant_js_1.NEXT_INVOKED_PROPERTY]: {
+                    finished: false,
+                    entryNextTimes: 0,
+                    outNextTimes: 0,
+                },
                 request: requestContext,
                 options,
                 global: this.__global__,

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

@@ -4,18 +4,21 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
+        define(["require", "exports", "../constant.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.retryMiddleware = void 0;
+    const constant_js_1 = require("../constant.js");
     function sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
     function retryMiddleware() {
         return async function retryMiddleware(ctx, next) {
-            const retryTimes = (Number(ctx.options.retryTimes) || 0) + 1;
+            const retryTimes = Number.isInteger(ctx.options.retryTimes)
+                ? ctx.options.retryTimes + 1
+                : 1;
             const retryDelay = (attempt, error, ctx) => {
                 if (typeof ctx.options.retryDelay === 'function') {
                     return ctx.options.retryDelay(attempt, error, ctx);
@@ -23,9 +26,11 @@
                 else if (typeof ctx.options.retryDelay === 'number') {
                     return ctx.options.retryDelay;
                 }
-                return 10;
+                return 0;
             };
-            const retryOn = typeof ctx.options.retryOn === 'function' ? ctx.options.retryOn : undefined;
+            const retryOn = typeof ctx.options.retryOn === 'function'
+                ? ctx.options.retryOn
+                : (attempt, error) => !!error;
             // Avoid multiple middleware from being added repeatedly
             ctx.options = {
                 ...ctx.options,
@@ -36,6 +41,8 @@
             for (let i = 0; i < retryTimes; i++) {
                 let err = null;
                 try {
+                    ctx[constant_js_1.NEXT_INVOKED_PROPERTY].entryNextTimes = 0;
+                    ctx[constant_js_1.NEXT_INVOKED_PROPERTY].outNextTimes = 0;
                     await next();
                 }
                 catch (e) {
@@ -46,14 +53,11 @@
                         throw err;
                     break;
                 }
-                if (retryOn && retryOn(i, err, ctx) === false) {
+                if (retryOn(i, err, ctx) === false) {
                     if (err)
                         throw err;
                     break;
                 }
-                else if (!retryOn && !err) {
-                    break;
-                }
                 const delay = retryDelay(i, err, ctx);
                 if (delay > 0)
                     await sleep(delay);

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

@@ -22,15 +22,15 @@
             this.prependMiddlewares = prependMiddlewares;
         }
         route(route, ...middlewares) {
-            const middleware = async (ctx, next) => {
-                if (route(ctx)) {
-                    await (0, compose_middleware_js_1.composeMiddleware)(middlewares)(ctx, next);
-                }
-                else {
+            if (middlewares.length === 0)
+                return this;
+            const m = middlewares.length > 1 ? (0, compose_middleware_js_1.composeMiddleware)(middlewares) : middlewares[0];
+            this.prependMiddlewares.push(async (ctx, next) => {
+                if (route(ctx))
+                    await m(ctx, next);
+                else
                     await next();
-                }
-            };
-            this.prependMiddlewares.push(middleware);
+            });
             return this;
         }
         host(host, ...middlewares) {

package/dist/umd/src/types/keq-context.d.ts

@@ -1,5 +1,5 @@
 import { URL } from 'whatwg-url';
-import { OUTPUT_PROPERTY } from "../constant";
+import { NEXT_INVOKED_PROPERTY, OUTPUT_PROPERTY } from "../constant";
 import { KeqRequestBody } from './keq-request-body';
 import { KeqRequestMethod } from './keq-request-method';
 import { KeqOptionsParameter } from './keq-options.js';
@@ -23,6 +23,17 @@ export interface KeqRequestContext {
     signal?: AbortSignal | null;
 }
 export interface KeqContext {
+    /**
+     * Middleware invoker counter
+     *
+     * to prevent someone from calling next
+     * multiple times or forgetting to write await
+     */
+    [NEXT_INVOKED_PROPERTY]: {
+        finished: boolean;
+        entryNextTimes: number;
+        outNextTimes: number;
+    };
     options: KeqContextOptions;
     /**
      * Fetch API Arguments

package/dist/umd/src/util/compose-middleware.js

@@ -4,21 +4,60 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../exception/exception.js"], factory);
+        define(["require", "exports", "../exception/exception.js", "../constant.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.composeMiddleware = void 0;
     const exception_js_1 = require("../exception/exception.js");
+    const constant_js_1 = require("../constant.js");
     function composeMiddleware(middlewares) {
         if (!middlewares.length) {
             throw new exception_js_1.Exception('At least one middleware');
         }
-        const middleware = middlewares
+        const middleware = [...middlewares]
             .reverse()
             .reduce(function (prev, curr) {
-            return (ctx, next) => curr(ctx, () => prev(ctx, next));
+            return async (ctx, next) => {
+                const invoked = {
+                    finished: false,
+                    entryNextTimes: 0,
+                    outNextTimes: 0,
+                };
+                const context = new Proxy(ctx, {
+                    get(target, property) {
+                        if (property === constant_js_1.NEXT_INVOKED_PROPERTY) {
+                            return invoked;
+                        }
+                        // @ts-ignore
+                        return target[property];
+                    },
+                });
+                await curr(context, async () => {
+                    if (invoked.finished) {
+                        throw new exception_js_1.Exception([
+                            `next() should not invoke after ${curr.toString()} middleware finished.`,
+                        ].join(''));
+                    }
+                    if (invoked.entryNextTimes > 1) {
+                        console.warn(`next() had be invoke multiple times at ${curr.toString()} middleware`);
+                    }
+                    invoked.entryNextTimes += 1;
+                    await prev(ctx, next);
+                    invoked.outNextTimes += 1;
+                });
+                invoked.finished = true;
+                if (invoked.entryNextTimes === 0) {
+                    console.warn(`next() is not invoked at ${curr.toString()}.`);
+                }
+                if (invoked.entryNextTimes !== invoked.outNextTimes) {
+                    throw new exception_js_1.Exception([
+                        `next() should be invoke before ${curr.toString()} middleware finish.`,
+                        'Maybe you forgot to await when calling next().',
+                    ].join(''));
+                }
+            };
         });
         return middleware;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keq",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",