@j2blasco/ts-result 0.0.9 → 0.1.1

package/dist/cjs/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./result"), exports);
 __exportStar(require("./result-functions"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,qDAAmC"}

package/dist/cjs/result-functions.js

@@ -8,3 +8,4 @@ function andThen(callback) {
 function andThenAsync(callback) {
     return (result) => result.andThenAsync(callback);
 }
+//# sourceMappingURL=result-functions.js.map

package/dist/cjs/result-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-functions.js","sourceRoot":"","sources":["../../src/result-functions.ts"],"names":[],"mappings":";;AAEA,0BAMC;AAED,oCAUC;AAlBD,SAAgB,OAAO,CACrB,QAAsC;IAItC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,SAAgB,YAAY,CAK1B,QAA+C;IAI/C,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;AACnD,CAAC"}

package/dist/cjs/result.js

@@ -93,3 +93,4 @@ function makeSafePromise(promise) {
         .then((value) => resultSuccess(value))
         .catch((error) => resultError.unknown(error.message));
 }
+//# sourceMappingURL=result.js.map

package/dist/cjs/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/result.ts"],"names":[],"mappings":"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"}

package/dist/cjs/utils/test/assert-type.js

@@ -6,3 +6,4 @@ function assertType(_value) { }
 function expectToCompile() {
     expect(true).toBe(true);
 }
+//# sourceMappingURL=assert-type.js.map

package/dist/cjs/utils/test/assert-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-type.js","sourceRoot":"","sources":["../../../../src/utils/test/assert-type.ts"],"names":[],"mappings":";;AAAA,gCAEU;AAEV,0CAEC;AAND,SAAgB,UAAU,CACxB,MAAgD,IACzC,CAAC;AAEV,SAAgB,eAAe;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/esm/index.js

@@ -1,2 +1,3 @@
 export * from './result';
 export * from './result-functions';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC"}

package/dist/esm/result-functions.js

@@ -4,3 +4,4 @@ export function andThen(callback) {
 export function andThenAsync(callback) {
     return (result) => result.andThenAsync(callback);
 }
+//# sourceMappingURL=result-functions.js.map

package/dist/esm/result-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-functions.js","sourceRoot":"","sources":["../../src/result-functions.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,OAAO,CACrB,QAAsC;IAItC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,YAAY,CAK1B,QAA+C;IAI/C,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;AACnD,CAAC"}

package/dist/esm/result.js

@@ -83,3 +83,4 @@ export function makeSafePromise(promise) {
         .then((value) => resultSuccess(value))
         .catch((error) => resultError.unknown(error.message));
 }
+//# sourceMappingURL=result.js.map

package/dist/esm/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/result.ts"],"names":[],"mappings":"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"}

package/dist/esm/utils/test/assert-type.js

@@ -2,3 +2,4 @@ export function assertType(_value) { }
 export function expectToCompile() {
     expect(true).toBe(true);
 }
+//# sourceMappingURL=assert-type.js.map

package/dist/esm/utils/test/assert-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-type.js","sourceRoot":"","sources":["../../../../src/utils/test/assert-type.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CACxB,MAAgD,IACzC,CAAC;AAEV,MAAM,UAAU,eAAe;IAC7B,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j2blasco/ts-result",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "description": "Result Monad for TypeScript",  "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "repository": {
@@ -18,6 +18,7 @@
     "dist/cjs",
     "dist/esm", 
     "types",
+    "src",
     "README.md",
     "LICENSE"
   ],  "scripts": {

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './result-functions';

package/src/result-functions.test.ts

@@ -0,0 +1,34 @@
+import { asyncPipe, pipe } from "@j2blasco/ts-pipe";
+import { andThen, andThenAsync } from "./result-functions";
+import { resultSuccess } from "./result";
+import { assertType } from "./utils/test/assert-type";
+
+function doSomething() {
+  return resultSuccess("5");
+}
+
+describe("Result integration with ts-pipe", () => {
+  test("asyncPipe", async () => {
+    var result = await asyncPipe(
+      doSomething(),
+      andThenAsync(async (_e) => resultSuccess(new Date())),
+      andThen((r) => {
+        assertType<typeof r, Date>(true);
+        return resultSuccess("test");
+      })
+    );
+    expect(result.unwrapOrThrow()).toBe("test");
+  });
+
+  test("pipe", async () => {
+    var result = pipe(
+      doSomething(),
+      andThen((_e) => resultSuccess(new Date())),
+      andThen((r) => {
+        assertType<typeof r, Date>(true);
+        return resultSuccess("test");
+      })
+    );
+    expect(result.unwrapOrThrow()).toBe("test");
+  });
+});

package/src/result-functions.ts

@@ -0,0 +1,21 @@
+import { ErrorType, Result, SuccessType } from "./result";
+
+export function andThen<TSuccess, TError, TResult extends Result<any, any>>(
+  callback: (value: TSuccess) => TResult
+): (
+  result: Result<TSuccess, TError>
+) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {
+  return (result) => result.andThen(callback);
+}
+
+export function andThenAsync<
+  TSuccess,
+  TError,
+  TResult extends Result<any, any>
+>(
+  callback: (value: TSuccess) => Promise<TResult>
+): (
+  result: Result<TSuccess, TError>
+) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>> {
+  return (result) => result.andThenAsync(callback);
+}

package/src/result.test.ts

@@ -0,0 +1,79 @@
+import {
+  resultSuccess,
+  resultError,
+  unwrapSuccessResult,
+  Result,
+  ErrorWithCode,
+  resultSuccessVoid,
+} from "./result";
+import { assertType, expectToCompile } from "./utils/test/assert-type";
+
+function createResult<TSuccess, TError>(): Result<TSuccess, TError> {
+  return resultSuccessVoid() as object as Result<TSuccess, TError>;
+}
+
+describe("Result Monad", () => {
+  test("resultSuccess should create a success result", () => {
+    const success = resultSuccess("test");
+    expect(unwrapSuccessResult(success)).toBe("test");
+  });
+
+  test("resultError.unknown should create an unknown error result", () => {
+    const error = resultError.unknown("An error occurred");
+    try {
+      error.unwrapOrThrow();
+    } catch (e) {
+      expect(e).toMatchObject({
+        code: "unknown",
+        data: { message: "An error occurred" },
+      });
+    }
+  });
+
+  test("resultError.withCode should create a coded error result", () => {
+    const error = resultError.withCode("test-code" as const, {
+      detail: "Some details",
+    });
+    try {
+      error.unwrapOrThrow();
+    } catch (e) {
+      expect(e).toMatchObject({
+        code: "test-code" as const,
+        data: { detail: "Some details" },
+      });
+    }
+  });
+
+  test("Result Monad success should be chainable with inferred types - string -> int", () => {
+    const resultString = createResult<string, ErrorWithCode<"test">>();
+
+    const resultInt = resultString.andThen((value) => {
+      type Expected = string;
+      assertType<typeof value, Expected>(true);
+      return resultSuccess(42);
+    });
+
+    type Expected = Result<number, ErrorWithCode<"test">>;
+    assertType<typeof resultInt, Expected>(true);
+
+    expectToCompile();
+  });
+
+  test("Result Monad success should be chainable with inferred types - obj -> obj", () => {
+    const resultString = createResult<
+      { test: string },
+      ErrorWithCode<"test">
+    >();
+
+    const resultInt = resultString.andThen((value) => {
+      type Expected = { test: string };
+      assertType<typeof value, Expected>(true);
+      return resultSuccess({ test2: "test" });
+    });
+
+    type Expected = Result<{ test2: string }, ErrorWithCode<"test">>;
+    assertType<typeof resultInt, Expected>(true);
+
+    expectToCompile();
+  });
+});

package/src/result.ts

@@ -0,0 +1,159 @@
+export interface Result<TSuccess1, TError1> {
+  andThen<TResult extends Result<any, any>>(
+    f: (value: TSuccess1) => TResult,
+  ): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;
+  andThenAsync<TResult extends Result<any, any>>(
+    f: (value: TSuccess1) => Promise<TResult>,
+  ): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;
+  catchError<TResult extends Result<any, any>>(
+    f: (error: TError1) => TResult,
+  ): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;
+  catchErrorAsync<TResult extends Result<any, any>>(
+    f: (error: TError1) => Promise<TResult>,
+  ): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;
+  unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;
+}
+
+export function unwrapSuccessResult<T>(result: Result<T, never>): T {
+  if (result instanceof ResultSuccessImp) {
+    return result['value'];
+  }
+  throw new Error('Unreachable code. Result is an error');
+}
+
+export type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };
+export function errorWithCode<TCode, TData>(
+  code: TCode,
+  data: TData,
+): ErrorWithCode<TCode, TData> {
+  return {
+    code,
+    data,
+  };
+}
+
+export type ErrorUnknown = {
+  code: 'unknown';
+  data: { message: string };
+};
+export function errorUnkown(message: string): ErrorUnknown {
+  return {
+    code: 'unknown',
+    data: { message },
+  };
+}
+
+export type SuccessType<T> = T extends Result<infer S, any> ? S : never;
+export type ErrorType<T> = T extends Result<any, infer E> ? E : never;
+
+export type SuccessVoid = never;
+
+export function resultSuccessVoid(): Result<SuccessVoid, never> {
+  return new ResultSuccessImp<SuccessVoid>(undefined as never);
+}
+
+export function resultSuccess<TSuccess1>(
+  value: TSuccess1,
+): Result<TSuccess1, never> {
+  return new ResultSuccessImp<TSuccess1>(value);
+}
+
+type EnforceLiteral<T> = string extends T ? never : T;
+
+export class resultError {
+  public static unknown(message: string): Result<never, ErrorUnknown> {
+    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));
+  }
+  public static withCode<TCode, TData = object>(
+    code: EnforceLiteral<TCode>,
+    data: TData = {} as TData,
+  ): Result<never, ErrorWithCode<TCode, TData>> {
+    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(
+      errorWithCode(code, data),
+    );
+  }
+  public static fromError<
+    TSuccess1,
+    TError1 extends ErrorWithCode<any, object>,
+  >(error: TError1): Result<TSuccess1, TError1> {
+    return new ResultErrorImp<TError1>(error);
+  }
+}
+
+class ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {
+  constructor(private value: TSuccess1) {}
+
+  public andThen<TSuccess2, TError2>(
+    f: (value: TSuccess1) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError2> {
+    return f(this.value);
+  }
+
+  public async andThenAsync<TSuccess2, TError2>(
+    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError2>> {
+    return await f(this.value);
+  }
+
+  public catchError<TSuccess2, TError2>(
+    _f: (error: never) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess1 | TSuccess2, TError2> {
+    return this;
+  }
+
+  public async catchErrorAsync<TSuccess2, TError2>(
+    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {
+    return this;
+  }
+
+  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {
+    return this.value;
+  }
+}
+
+class ResultErrorImp<TError1> implements Result<never, TError1> {
+  constructor(private error: TError1) {}
+
+  public andThen<TSuccess2, TError2>(
+    _f: (value: never) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError1 | TError2> {
+    return this;
+  }
+
+  public async andThenAsync<TSuccess2, TError2>(
+    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError1 | TError2>> {
+    return this;
+  }
+
+  public catchError<TSuccess2, TError2>(
+    f: (error: TError1) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError2> {
+    return f(this.error);
+  }
+
+  public async catchErrorAsync<TSuccess2, TError2>(
+    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError2>> {
+    return await f(this.error);
+  }
+
+  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {
+    if (errorCallback !== undefined) {
+      errorCallback(this.error);
+    }
+    throw this.error;
+  }
+}
+
+export type UnwrapErrorFromResult<T> =
+  T extends Result<any, infer U> ? U : never;
+
+export function makeSafePromise<T>(
+  promise: Promise<T>,
+): Promise<Result<T, ErrorUnknown>> {
+  return promise
+    .then((value) => resultSuccess(value))
+    .catch((error) => resultError.unknown(error.message));
+}

package/src/utils/test/assert-type.ts

@@ -0,0 +1,7 @@
+export function assertType<TActual, TExpected>(
+  _value: TActual extends TExpected ? true : false
+): void {}
+
+export function expectToCompile() {
+  expect(true).toBe(true);
+}