klubok 0.4.3 → 0.4.5

package/dist/index.js

@@ -16,22 +16,25 @@ exports.onError = onError;
 function klubok(...fns) {
     const funcs = fns.filter(f => !f.onError);
     const onError = fns.find(f => f.onError);
-    return (rootCtx = {}, mock, only) => {
+    const funcsLength = funcs.length;
+    return async (rootCtx = {}, mock, only) => {
         let isExit = false;
-        return funcs.reduce(mock == null && only == null
-            ? (acc, fn) => acc.then(async (ctx) => {
+        if (mock == null && only == null) {
+            let ctx = rootCtx;
+            for (let i = 0; i < funcsLength; i++) {
+                const fn = funcs[i];
                 if (!fn.mutable && ctx[fn.key]) {
-                    return Promise.reject(new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`));
+                    throw new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`);
                 }
                 if (isExit) {
-                    return ctx;
+                    break;
                 }
                 try {
                     const resp = await fn(ctx);
                     if (fn.exitable && resp) {
                         isExit = true;
                     }
-                    return { ...ctx, [fn.key]: resp };
+                    ctx[fn.key] = resp;
                 }
                 catch (error) {
                     await onError?.({ ...ctx, $error: error });
@@ -40,28 +43,30 @@ function klubok(...fns) {
                     }
                     throw error;
                 }
-            })
-            : (acc, fn) => acc.then(ctx => !fn.mutable && Reflect.has(ctx, fn.key) && !Reflect.has(mock ?? {}, fn.key)
-                ? Promise.reject(new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`))
-                : (mock && Reflect.has(mock, fn.key) && typeof Reflect.get(mock, fn.key) !== 'function') ||
-                    (only && only.length && !only.includes(fn.key))
-                    ? ctx
-                    : (async () => {
-                        try {
-                            if (isExit) {
-                                return ctx;
-                            }
-                            return await Promise.resolve(mock && Reflect.has(mock, fn.key) && typeof Reflect.get(mock, fn.key) === 'function'
-                                ? Reflect.get(mock, fn.key)(ctx)
-                                : fn(ctx)).then(resp => (fn.exitable && resp && (isExit = true), { ...ctx, [fn.key]: resp }));
+            }
+            return ctx;
+        }
+        return funcs.reduce((acc, fn) => acc.then(ctx => !fn.mutable && Reflect.has(ctx, fn.key) && !Reflect.has(mock ?? {}, fn.key)
+            ? Promise.reject(new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`))
+            : (mock && Reflect.has(mock, fn.key) && typeof Reflect.get(mock, fn.key) !== 'function') ||
+                (only && only.length && !only.includes(fn.key))
+                ? ctx
+                : (async () => {
+                    try {
+                        if (isExit) {
+                            return ctx;
                         }
-                        catch (error) {
-                            await onError?.({ ...ctx, $error: error });
-                            if (error instanceof Error) {
-                                error.stack += '\ncontext: ' + (0, node_util_1.inspect)(ctx);
-                            }
-                            throw error;
+                        return await Promise.resolve(mock && Reflect.has(mock, fn.key) && typeof Reflect.get(mock, fn.key) === 'function'
+                            ? Reflect.get(mock, fn.key)(ctx)
+                            : fn(ctx)).then(resp => (fn.exitable && resp && (isExit = true), { ...ctx, [fn.key]: resp }));
+                    }
+                    catch (error) {
+                        await onError?.({ ...ctx, $error: error });
+                        if (error instanceof Error) {
+                            error.stack += '\ncontext: ' + (0, node_util_1.inspect)(ctx);
                         }
-                    })()), Promise.resolve({ ...rootCtx, ...mock }));
+                        throw error;
+                    }
+                })()), Promise.resolve({ ...rootCtx, ...mock }));
     };
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "klubok",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Do notation pipes for Promise-based or pure functions which easy to mock",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git@github.com:darky/klubok.git"
+    "url": "git+ssh://git@github.com/darky/klubok.git"
   },
   "files": [
     "dist/index.js",
@@ -35,7 +35,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22.15.3",
-    "klubok": "0.4.2",
+    "klubok": "0.4.4",
     "tinybench": "^4.0.1",
     "tsd": "^0.32.0",
     "typescript": "^5.8.3"