Abstract from Observable in APIClient

[raveclassic]

• research possibility of abstracting Observable out to some generic Monad
• take a look at final tagless

[raveclassic]

An abstract APIClient may be a function request which returns some Functor (and is therefore parametrised by an instance of that Functor). This allows controllers to map over the inner value abstracting from the type of container which may be rxjs Observable, most Stream or native Promise/Task.

[raveclassic]

client.ts

import { HKT, Kind, Kind2, URIS, URIS2 } from 'fp-ts/lib/HKT';
import { MonadThrow, MonadThrow1, MonadThrow2 } from 'fp-ts/lib/MonadThrow';

export interface Request {
	readonly method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
	readonly url: string;
	readonly query?: object;
	readonly body?: unknown;
}

export interface HTTPClient<F> extends MonadThrow<F> {
	readonly request: (request: Request) => HKT<F, unknown>;
}
export interface HTTPClient1<F extends URIS> extends MonadThrow1<F> {
	readonly request: (request: Request) => Kind<F, unknown>;
}
export interface HTTPClient2<F extends URIS2> extends MonadThrow2<F> {
	readonly request: (request: Request) => Kind2<F, unknown, unknown>;
}

controller.ts

import { HKT, Kind, Kind2, URIS, URIS2 } from 'fp-ts/lib/HKT';
import { HTTPClient, HTTPClient1, HTTPClient2 } from './client';
import { pipe } from 'fp-ts/lib/pipeable';
import { number } from 'io-ts';
import { either } from 'fp-ts';
import { task } from 'fp-ts/lib/Task';
import { Observable, of } from 'rxjs';
import { failure, pending, RemoteData, success } from '@devexperts/remote-data-ts';
import { catchError, map, startWith } from 'rxjs/operators';
import { mapRD } from '@devexperts/rx-utils/dist/rd/operators/mapRD';
import { switchMapRD } from '@devexperts/rx-utils/dist/rd/operators/switchMapRD';
import { combineLatestRD } from '@devexperts/rx-utils/dist/rd/operators/combineLatestRD';
import { ajax } from 'rxjs/ajax';

interface Controller<F> {
	readonly getTime: () => HKT<F, number>;
}
interface Controller1<F extends URIS> {
	readonly getTime: () => Kind<F, number>;
}
interface Controller2<F extends URIS2> {
	readonly getTime: () => Kind2<F, Error, number>;
}

interface Context<F> {
	readonly httpClient: HTTPClient<F>;
}
interface Context1<F extends URIS> {
	readonly httpClient: HTTPClient1<F>;
}
interface Context2<F extends URIS2> {
	readonly httpClient: HTTPClient2<F>;
}

export function controller<F extends URIS2>(e: Context2<F>): Controller2<F>;
export function controller<F extends URIS>(e: Context1<F>): Controller1<F>;
export function controller<F>(e: Context<F>): Controller<F> {
	return {
		getTime: () =>
			pipe(
				e.httpClient.request({
					url: '/time',
					method: 'GET',
				}),
				r =>
					e.httpClient.chain(r, a =>
						pipe(
							number.decode(a),
							either.fold(err => e.httpClient.throwError(err), a => e.httpClient.of(a)),
						),
					),
			),
	};
}

const taskClient: HTTPClient1<'Task'> = {
	...task,
	request: request => () => fetch(request.url, { method: request.method }),
	throwError: e => () => Promise.reject(e),
};

declare module 'fp-ts/lib/HKT' {
	interface URItoKind2<E, A> {
		LiveData: Observable<RemoteData<E, A>>;
	}
}
const liveDataClient: HTTPClient2<'LiveData'> = {
	URI: 'LiveData',
	map: (fa, f) =>
		pipe(
			fa,
			mapRD(f),
		),
	of: a => of(success(a)),
	chain: (fa, f) =>
		pipe(
			fa,
			switchMapRD(f),
		),
	ap: (fab, fa) =>
		pipe(
			combineLatestRD(fab, fa),
			mapRD(([ab, a]) => ab(a)),
		),
	request: request =>
		pipe(
			ajax(request),
			map(r => success(r.response)),
			catchError(liveDataClient.throwError),
			startWith(pending),
		),
	throwError: e => of(failure(e)),
};

//
const r1 = controller({ httpClient: taskClient }).getTime(); // Task<number>
r1()
	.then()
	.catch(); // all Promise methods available

const r2 = controller({ httpClient: liveDataClient }).getTime(); // LiveData<Error, number>
r2.pipe().subscribe(); //all LiveData methods available

[raveclassic]

This is working solution (hooray) however this will break a lot.
Also in addition to separate controllers we could generate a single controllers.ts file containing all available controllers already parametrised with a single HTTPClient instance.

[sutarmin]

Wow, that's beautiful. I'm for it :) basically, this will break only the layer that is autogenerated right know, right?

[raveclassic]

Currently an idiomatic way to work with generated controller is to add it to combineReader directly. This is going to break because it won't play well with generic HTTPClient.
One possible solution is to create a separate module for API in each project where such controllers.ts would be parametrised with HTTPClient instance.