klubok 0.3.3 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 type KeyedFunction<K extends string, F extends Function> = F & {
+    exitable: boolean;
     key: K;
     mutable: boolean;
     onError: boolean;
@@ -6,6 +7,7 @@ type KeyedFunction<K extends string, F extends Function> = F & {
 export declare const pure: <K extends string, C, R>(key: K, fn: (ctx: C) => R) => KeyedFunction<K, (ctx: C) => R>;
 export declare const eff: <K extends string, C, R>(key: K, fn: (ctx: C) => Promise<R>) => KeyedFunction<K, (ctx: C) => Promise<R>>;
 export declare const mut: <K extends string, C, R>(fn: KeyedFunction<K, (ctx: C) => R>) => KeyedFunction<K, (ctx: C) => R>;
+export declare const exitIf: <K extends string, C, R>(fn: KeyedFunction<K, (ctx: C) => R>) => KeyedFunction<K, (ctx: C) => R>;
 export declare const onError: <K extends string, C, R>(key: K, fn: (ctx: C) => R) => KeyedFunction<K, (ctx: C) => R>;
 export declare function klubok<K1 extends string, C extends object, R1>(fn1: KeyedFunction<K1, (ctx: C) => Promise<R1> | R1>): (ctx: C, mock?: {
     [k in K1]?: R1 | ((ctx: C) => R1 | Promise<R1>);

package/dist/index.js

@@ -1,44 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onError = exports.mut = exports.eff = exports.pure = void 0;
+exports.onError = exports.exitIf = exports.mut = exports.eff = exports.pure = void 0;
 exports.klubok = klubok;
 const node_util_1 = require("node:util");
-const pure = (key, fn) => Object.assign(fn, { key, mutable: false, onError: false });
+const pure = (key, fn) => Object.assign(fn, { exitable: false, key, mutable: false, onError: false });
 exports.pure = pure;
-const eff = (key, fn) => Object.assign(fn, { key, mutable: false, onError: false });
+const eff = (key, fn) => Object.assign(fn, { exitable: false, key, mutable: false, onError: false });
 exports.eff = eff;
 const mut = (fn) => Object.assign(fn, { mutable: true });
 exports.mut = mut;
-const onError = (key, fn) => Object.assign(fn, { key, mutable: false, onError: true });
+const exitIf = (fn) => Object.assign(fn, { exitable: true });
+exports.exitIf = exitIf;
+const onError = (key, fn) => Object.assign(fn, { exitable: false, key, mutable: false, onError: true });
 exports.onError = onError;
 function klubok(...fns) {
     const funcs = fns.filter(f => !f.onError);
     const onError = fns.find(f => f.onError);
-    return (rootCtx = {}, mock, only) => funcs.reduce(mock == null && only == null
-        ? (acc, fn) => acc.then(ctx => !fn.mutable && Reflect.has(ctx, fn.key)
-            ? Promise.reject(new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`))
-            : (async () => {
-                try {
-                    return await Promise.resolve(fn(ctx)).then(resp => ({ ...ctx, [fn.key]: resp }));
-                }
-                catch (error) {
-                    await onError?.({ ...ctx, $error: error });
-                    if (error instanceof Error) {
-                        error.stack += '\ncontext: ' + (0, node_util_1.inspect)(ctx);
-                    }
-                    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
+    return (rootCtx = {}, mock, only) => {
+        let isExit = false;
+        return funcs.reduce(mock == null && only == null
+            ? (acc, fn) => acc.then(ctx => !fn.mutable && Reflect.has(ctx, fn.key)
+                ? Promise.reject(new Error(`Try to override existing alias "${fn.key}". Let's rename alias or use "mut" wrapper`))
                 : (async () => {
                     try {
-                        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 => ({ ...ctx, [fn.key]: resp }));
+                        if (isExit) {
+                            return ctx;
+                        }
+                        return await Promise.resolve(fn(ctx)).then(resp => (fn.exitable && resp && (isExit = true), { ...ctx, [fn.key]: resp }));
                     }
                     catch (error) {
                         await onError?.({ ...ctx, $error: error });
@@ -47,5 +35,28 @@ function klubok(...fns) {
                         }
                         throw error;
                     }
-                })()), Promise.resolve({ ...rootCtx, ...mock }));
+                })())
+            : (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 }));
+                        }
+                        catch (error) {
+                            await onError?.({ ...ctx, $error: error });
+                            if (error instanceof Error) {
+                                error.stack += '\ncontext: ' + (0, node_util_1.inspect)(ctx);
+                            }
+                            throw error;
+                        }
+                    })()), Promise.resolve({ ...rootCtx, ...mock }));
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klubok",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Do notation pipes for Promise-based or pure functions which easy to mock",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",