Add fromReaderEither and fromReaderTaskEither

src/modules/__tests__/reader-either.ts

@@ -0,0 +1,27 @@
+import { Either } from 'fp-ts/lib/Either';
+import * as Either_ from 'fp-ts/lib/Either';
+
+import { crashObject } from '../../helpers/crash';
+import * as ruins from '../reader-either';
+
+const exampleModel = { foo: 'model' };
+
+type ExampleLeft = { error: number };
+const exampleLeft: ExampleLeft = { error: 404 };
+
+type ExampleRight = { result: number };
+const exampleRight: ExampleRight = { result: 42 };
+
+type ExampleEither = Either<ExampleLeft, ExampleRight>;
+const exampleEitherL: ExampleEither = Either_.left(exampleLeft);
+const exampleEitherR: ExampleEither = Either_.right(exampleRight);
+
+describe('ruinReaderEither', () => {
+  it('should return right', () => {
+    const result: ExampleRight = ruins.fromReaderEither(exampleModel, (_) => exampleEitherR);
+    expect(result).toEqual(exampleRight);
+  });
+  it('should throw left', () => {
+    expect(() => ruins.fromReaderEither(exampleModel, (_) => exampleEitherL)).toThrowError(crashObject(exampleLeft));
+  });
+});

src/modules/__tests__/reader-task-either.ts

@@ -0,0 +1,29 @@
+import { TaskEither } from 'fp-ts/lib/TaskEither';
+import * as TaskEither_ from 'fp-ts/lib/TaskEither';
+
+import { crashObject } from '../../helpers/crash';
+import * as ruins from '../reader-task-either';
+
+const exampleModel = { foo: 'model' };
+
+type ExampleLeft = { error: number };
+const exampleLeft: ExampleLeft = { error: 404 };
+
+type ExampleRight = { result: number };
+const exampleRight: ExampleRight = { result: 42 };
+
+type ExampleTaskEither = TaskEither<ExampleLeft, ExampleRight>;
+const exampleTaskEitherL: ExampleTaskEither = TaskEither_.left(exampleLeft);
+const exampleTaskEitherR: ExampleTaskEither = TaskEither_.right(exampleRight);
+
+describe('ruinReaderTaskEither', () => {
+  it('should return right', async () => {
+    await expect(ruins.fromReaderTaskEither(exampleModel, (_) => exampleTaskEitherR)).resolves.toEqual(exampleRight);
+  });
+
+  it('should throw left', async () => {
+    await expect(ruins.fromReaderTaskEither(exampleModel, (_) => (exampleTaskEitherL))).rejects.toEqual(
+      crashObject(exampleLeft),
+    );
+  });
+});

src/modules/reader-either.ts

@@ -0,0 +1,11 @@
+import {pipe} from 'fp-ts/lib/function';
+import {ReaderEither} from "fp-ts/ReaderEither";
+
+import { fromEither } from "./either";
+
+export const fromReaderEither = <M, R>(model: M, aReaderEither: ReaderEither<M, unknown, R>): R =>
+  pipe(
+    model,
+    aReaderEither,
+    fromEither
+  );

src/modules/reader-task-either.ts

@@ -0,0 +1,7 @@
+import {pipe} from 'fp-ts/lib/function';
+import {ReaderTaskEither} from "fp-ts/ReaderTaskEither";
+
+import {fromTaskEither} from "./task-either";
+
+export const fromReaderTaskEither = <M, E, R>(model: M, aReaderTaskEither: ReaderTaskEither<M, E, R>): Promise<R> =>
+  pipe(model, aReaderTaskEither, fromTaskEither);