keq 2.5.0 → 2.5.2

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.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)
+
+
+### Bug Fixes
+
+* throw error when retryOn is not set ([cbf4594](https://github.com/keq-request/keq/commit/cbf45942e113a4f57c4351abd03a82cbab5a0a6a))
+
 ## [2.5.0](https://github.com/keq-request/keq/compare/v2.4.1...v2.5.0) (2024-05-21)
 
 

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/keq.js

@@ -171,7 +171,9 @@ export class Keq extends Core {
     retry(retryTimes, retryDelay, retryOn) {
         this.option('retryTimes', retryTimes);
         this.option('retryDelay', retryDelay);
-        this.option('retryOn', retryOn);
+        if (retryOn !== undefined) {
+            this.option('retryOn', retryOn);
+        }
         return this;
     }
     redirect(mod) {

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

@@ -1,11 +1,20 @@
+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 retryDelay = ctx.options.retryDelay || 10;
-        const retryOn = ctx.options.retryOn;
+        const retryDelay = (attempt, error, ctx) => {
+            if (typeof ctx.options.retryDelay === 'function') {
+                return ctx.options.retryDelay(attempt, error, ctx);
+            }
+            else if (typeof ctx.options.retryDelay === 'number') {
+                return ctx.options.retryDelay;
+            }
+            return 10;
+        };
+        const retryOn = typeof ctx.options.retryOn === 'function' ? ctx.options.retryOn : undefined;
         // Avoid multiple middleware from being added repeatedly
         ctx.options = {
             ...ctx.options,
@@ -16,6 +25,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,7 +45,7 @@ export function retryMiddleware() {
             else if (!retryOn && !err) {
                 break;
             }
-            const delay = typeof retryDelay === 'function' ? retryDelay(i, err, ctx) : retryDelay;
+            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/keq.js

@@ -183,7 +183,9 @@
         retry(retryTimes, retryDelay, retryOn) {
             this.option('retryTimes', retryTimes);
             this.option('retryDelay', retryDelay);
-            this.option('retryOn', retryOn);
+            if (retryOn !== undefined) {
+                this.option('retryOn', retryOn);
+            }
             return this;
         }
         redirect(mod) {

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

@@ -4,20 +4,29 @@
         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 retryDelay = ctx.options.retryDelay || 10;
-            const retryOn = ctx.options.retryOn;
+            const retryDelay = (attempt, error, ctx) => {
+                if (typeof ctx.options.retryDelay === 'function') {
+                    return ctx.options.retryDelay(attempt, error, ctx);
+                }
+                else if (typeof ctx.options.retryDelay === 'number') {
+                    return ctx.options.retryDelay;
+                }
+                return 10;
+            };
+            const retryOn = typeof ctx.options.retryOn === 'function' ? ctx.options.retryOn : undefined;
             // Avoid multiple middleware from being added repeatedly
             ctx.options = {
                 ...ctx.options,
@@ -28,6 +37,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,7 +57,7 @@
                 else if (!retryOn && !err) {
                     break;
                 }
-                const delay = typeof retryDelay === 'function' ? retryDelay(i, err, ctx) : retryDelay;
+                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.0",
+  "version": "2.5.2",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",
@@ -71,7 +71,7 @@
     "typescript": "^5.4.5",
     "typescript-transform-paths": "^3.4.7"
   },
-  "packageManager": "pnpm@8.6.4",
+  "packageManager": "pnpm@9.1.2",
   "engines": {
     "node": ">=18.0.0"
   }