- Added types for fail and ok

- Added throwFail

package.json

@@ -2,7 +2,7 @@
   "name": "lambda-res",
   "description": "Type-safe error handling without exception",
   "keywords": ["aws", "serverless", "lambda", "error", "error-handling"],
-  "version": "1.0.18",
+  "version": "1.0.19",
   "author": "Alex Shelkovskiy <alexshelkov@gmail.com>",
   "repository": "https://github.com/alexshelkov/result",
   "license": "MIT",

src/__tests__/cast.ts

@@ -5,19 +5,19 @@ describe('to result', () => {
     expect.assertions(2);
 
     expect(() => {
-      return toResult(null);
+      toResult(null);
     }).toThrow('Unexpected input');
 
     expect(() => {
-      return toResult('123');
+      toResult('123');
     }).toThrow('Unexpected input');
   });
 
   it('no status will throws an error', () => {
     expect.assertions(1);
 
     expect(() => {
-      return toResult({ data: 1 });
+      toResult({ data: 1 });
     }).toThrow('Unexpected input');
   });
 

src/__tests__/util.ts

@@ -1,4 +1,4 @@
-import { Err, Result, ok, fail, err, compare, nope } from '../index';
+import { Err, Result, ok, fail, throwFail, err, compare, nope } from '../index';
 
 describe('util', () => {
   it('works with skip option', () => {
@@ -66,11 +66,33 @@ describe('util', () => {
     }).toThrow('Unknown status');
   });
 
+  it('throw fail', () => {
+    expect.assertions(2);
+
+    expect(() => {
+      throwFail<Err>('Thrown');
+    }).toThrow('Thrown');
+
+    expect(() => {
+      const a: string | undefined = Math.random() === -1 ? 'never' : undefined;
+
+      if (!a) {
+        throwFail<Err>('Thrown');
+      }
+
+      // undefined is removed because
+      // throwFail returns never
+      const b: string = a;
+
+      expect(b).toStrictEqual('never');
+    }).toThrow('Thrown');
+  });
+
   it('never will throw exception if called', () => {
     expect.assertions(1);
 
     expect(() => {
-      return nope(undefined as never);
+      nope(undefined as never);
     }).toThrow('Unreachable');
   });
 });

src/index.ts

@@ -2,19 +2,18 @@ export { ErrUtil as Err, Err as ErrInfo, ErrLevel, Errs } from './err';
 
 export { Success, Failure, Result, Response } from './result';
 
-export {
-  isErr,
-  isErrType,
-  isSuccessLike,
-  isFailureLike
-} from './checks'
+export { isErr, isErrType, isSuccessLike, isFailureLike } from './checks';
 
 export {
   ok,
   fail,
+  throwFail,
   err,
   compare,
   nope,
   toResult,
   FailureException,
+  OkFn,
+  FailFn,
+  ThrowFailFn,
 } from './utils';

src/result.ts

@@ -77,14 +77,6 @@ export interface Failure<Fail> extends PartialFailure<Fail> {
 
   onOk(): never;
 
-  // onFail<Res1 extends Result<never, Fail2>, Res2 extends Response<never, Fail2>, Res extends Res1  | Res2, Data = never, Fail2 = never>(
-  //   this: Result<Data, Fail>,
-  //   cb: (
-  //     err: Fail,
-  //     result: Result<never, Fail>
-  //   ) => Res
-  // ): Res extends Response<never, Fail2> ? Transform<Data, Fail2> : Result<Data, Fail2>;
-
   onFail<Data = never, Fail2 = never>(
     this: Result<Data, Fail>,
     cb: (err: Fail, result: Result<never, Fail>) => Result<never, Fail2>
@@ -95,17 +87,6 @@ export interface Failure<Fail> extends PartialFailure<Fail> {
     cb: (err: Fail, result: Result<never, Fail>) => Response<never, Fail2>
   ): Transform<Data, Fail2>;
 
-  // onErr<
-  //   Type extends string,
-  //   Res extends ({ type: Type } | Type) | Promise<{ type: Type } | Type>,
-  //   Data = never
-  //   >(
-  //   this: Result<Data, Fail>,
-  //   cb: (err: Fail, result: Result<never, Fail>) => Res
-  // ): Res extends Promise<infer WholeRes>
-  //   ? Transform<Data, ErrUtil<WholeRes>>
-  //   : Result<Data, ErrUtil<Res>>;
-
   onErr<Type extends string, Res extends { type: Type } | Type, Data = never>(
     this: Result<Data, Fail>,
     cb: (err: Fail, result: Result<never, Fail>) => Res

src/utils.ts

@@ -316,7 +316,9 @@ type OkMessage = {
   skip?: boolean;
 };
 
-export const ok = <Data = never>(
+export type OkFn = <Data = never>(data: Data, params?: OkMessage) => Success<Data>;
+
+export const ok: OkFn = <Data = never>(
   data: Data,
   { code, order, skip }: OkMessage = {}
 ): Success<Data> => {
@@ -372,7 +374,12 @@ export const err = <Fail = never>(
 
 type ErrorMessage<Error> = FailMessage & Omit<Error, 'type' | 'message'>;
 
-export const fail = <Fail extends Err | undefined = never>(
+export type FailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params?: ErrorMessage<Fail>
+) => Failure<Fail>;
+
+export const fail: FailFn = <Fail extends Err | undefined = never>(
   type: Fail extends Err ? Fail['type'] : undefined,
   { message, code, order, skip, ...error }: ErrorMessage<Fail> = {} as ErrorMessage<Fail>
 ): Failure<Fail> => {
@@ -385,6 +392,18 @@ export const fail = <Fail extends Err | undefined = never>(
   return err(failure, { message, code, order, skip });
 };
 
+export type ThrowFailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params?: ErrorMessage<Fail>
+) => never;
+
+export const throwFail: ThrowFailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params: ErrorMessage<Fail> = {} as ErrorMessage<Fail>
+): never => {
+  throw fail(type, params);
+};
+
 export const compare = <Data1, Error1, Data2, Error2>(
   r1: Result<Data1, Error1>,
   r2: Result<Data2, Error2>