fortepiano 0.1.0

package/lib/Http.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mock = exports.log = exports.pool = exports.cache = exports.buffer = exports.json = exports.HttpErrorC = exports.HttpResponseC = exports.HttpMethodC = exports.HttpError = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const J = __importStar(require("fp-ts/Json"));
+const O = __importStar(require("fp-ts/Option"));
+const R = __importStar(require("fp-ts/Random"));
+const TE = __importStar(require("fp-ts/TaskEither"));
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const $T = __importStar(require("./Type"));
+const $Er = __importStar(require("./Error"));
+const Mock_1 = require("./http/Mock");
+Object.defineProperty(exports, "mock", { enumerable: true, get: function () { return Mock_1.mock; } });
+const $L = __importStar(require("./Log"));
+const $R = __importStar(require("./Random"));
+const $Stri = __importStar(require("./string"));
+const ERRORS = {
+    BadRequest: 400,
+    Unauthorized: 401,
+    Forbidden: 403,
+    NotFound: 404,
+    UnprocessableEntity: 422,
+};
+class HttpError extends Error {
+    constructor(response, message) {
+        super(message);
+        this.response = response;
+    }
+}
+exports.HttpError = HttpError;
+const HttpMethods = [
+    'delete',
+    'get',
+    'head',
+    'options',
+    'patch',
+    'post',
+    'put',
+];
+exports.HttpMethodC = $T.literalUnion(HttpMethods, 'HttpMethod');
+const HttpResponseC = (codec) => t.type({
+    url: t.string,
+    status: t.number,
+    headers: t.readonly(t.record(t.string, t.union([t.string, t.readonlyArray(t.string)]))),
+    body: codec,
+}, `HttpResponse(${codec.name})`);
+exports.HttpResponseC = HttpResponseC;
+const is = (type) => (u) => $Er.ErrorC.is(u) &&
+    t
+        .type({
+        response: t.intersection([
+            exports.HttpResponseC(t.unknown),
+            t.type({ status: type ? t.literal(ERRORS[type]) : t.number }),
+        ]),
+    })
+        .is(Object.assign({}, u));
+const HttpErrorC = (type) => new t.Type(`Http${type || ''}Error`, is(type), (u, c) => (is(type)(u) ? t.success(u) : t.failure(u, c)), function_1.identity);
+exports.HttpErrorC = HttpErrorC;
+const _json = (request) => (url, options) => request(url, Object.assign(Object.assign({}, options), { json: true, buffer: false }));
+const json = (http) => ({
+    delete: _json(http.delete),
+    get: _json(http.get),
+    patch: _json(http.patch),
+    post: _json(http.post),
+    put: _json(http.put),
+    head: _json(http.head),
+    options: _json(http.options),
+});
+exports.json = json;
+const _buffer = (request) => (url, options) => request(url, Object.assign(Object.assign({}, options), { buffer: true, json: false }));
+const buffer = (http) => ({
+    delete: _buffer(http.delete),
+    get: _buffer(http.get),
+    patch: _buffer(http.patch),
+    post: _buffer(http.post),
+    put: _buffer(http.put),
+    head: _buffer(http.head),
+    options: _buffer(http.options),
+});
+exports.buffer = buffer;
+const cache = (cache) => (http) => (Object.assign(Object.assign({}, http), { get: (url, options) => function_1.pipe([url, options], J.stringify, Ei.match(() => http.get(url, options), (key) => function_1.pipe(cache.get(key, exports.HttpResponseC(t.unknown)), TE.alt(() => function_1.pipe(http.get(url, options), TE.chainFirst((response) => function_1.pipe(response, cache.set(key, exports.HttpResponseC(io_ts_types_1.Json)), TE.altW(() => TE.of(undefined))))))))) }));
+exports.cache = cache;
+const pool = (http) => {
+    const pool = new Map();
+    return Object.assign(Object.assign({}, http), { get: (url, options) => {
+            const key = [url, options];
+            return function_1.pipe(pool.get(key), O.fromNullable, O.match(() => () => {
+                const promise = http
+                    .get(url, options)()
+                    .finally(() => pool.delete(key));
+                pool.set(key, promise);
+                return promise;
+            }, function_1.constant));
+        } });
+};
+exports.pool = pool;
+const _log = (method, request, log) => (url, options) => $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => {
+    const message = `[${salt}] \r${$Stri.uppercase(method)} ${url}`;
+    return function_1.pipe(log.start(message), TE.fromIO, TE.chain(() => request(url, options)), TE.chainFirstIOK(() => log.end(message)), TE.orElseW((error) => function_1.pipe(log.end(message), TE.fromIO, TE.chain(() => TE.left(error)))));
+});
+const log = (logStart, logEnd = $L.void) => (http) => ({
+    delete: _log('delete', http.delete, { start: logStart, end: logEnd }),
+    get: _log('get', http.get, { start: logStart, end: logEnd }),
+    patch: _log('patch', http.patch, { start: logStart, end: logEnd }),
+    post: _log('post', http.post, { start: logStart, end: logEnd }),
+    put: _log('put', http.put, { start: logStart, end: logEnd }),
+    head: _log('head', http.head, { start: logStart, end: logEnd }),
+    options: _log('options', http.options, { start: logStart, end: logEnd }),
+});
+exports.log = log;

package/lib/IOAsyncGenerator.d.ts

@@ -0,0 +1,102 @@
+import * as Appli from 'fp-ts/Applicative';
+import * as _Apply from 'fp-ts/Apply';
+import * as Ch from 'fp-ts/Chain';
+import * as Co from 'fp-ts/Compactable';
+import * as Ei from 'fp-ts/Either';
+import * as Eq from 'fp-ts/Eq';
+import * as Fi from 'fp-ts/Filterable';
+import * as FiWI from 'fp-ts/FilterableWithIndex';
+import * as FIO from 'fp-ts/FromIO';
+import { Lazy, Predicate, Refinement } from 'fp-ts/function';
+import * as Fu from 'fp-ts/Functor';
+import * as FuWI from 'fp-ts/FunctorWithIndex';
+import * as IO from 'fp-ts/IO';
+import * as Mona from 'fp-ts/Monad';
+import * as MIO from 'fp-ts/MonadIO';
+import * as Mono from 'fp-ts/Monoid';
+import * as O from 'fp-ts/Option';
+import * as P from 'fp-ts/Pointed';
+import * as S from 'fp-ts/Separated';
+import * as T from 'fp-ts/Task';
+import * as $IOG from './GeneratorL';
+export declare const URI = "IOAsyncGenerator";
+export declare type URI = typeof URI;
+declare module 'fp-ts/HKT' {
+    interface URItoKind<A> {
+        [URI]: IOAsyncGenerator<A>;
+    }
+}
+export declare type IOAsyncGenerator<A> = IO.IO<AsyncGenerator<A>>;
+export declare const getMonoid: <A>() => Mono.Monoid<IOAsyncGenerator<A>>;
+export declare const fromIOGenerator: <A>(as: $IOG.GeneratorL<A>) => IOAsyncGenerator<A>;
+export declare const Functor: Fu.Functor1<URI>;
+export declare const map: <A, B>(a: (a: A) => B) => (b: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare const flap: <A>(a: A) => <B>(fab: IOAsyncGenerator<(a: A) => B>) => IOAsyncGenerator<B>;
+export declare const bindTo: <N extends string>(name: N) => <A>(fa: IOAsyncGenerator<A>) => IOAsyncGenerator<{ readonly [K in N]: A; }>;
+export declare const FunctorWithIndex: FuWI.FunctorWithIndex1<URI, number>;
+export declare const Pointed: P.Pointed1<URI>;
+export declare const of: <A>(a: A) => IOAsyncGenerator<A>;
+export declare const Do: IOAsyncGenerator<{}>;
+export declare const ApplyPar: _Apply.Apply1<URI>;
+/**
+ *
+ */
+export declare const ApplySeq: _Apply.Apply1<URI>;
+export declare const ap: <A, B>(a: IOAsyncGenerator<A>) => (b: IOAsyncGenerator<(a: A) => B>) => IOAsyncGenerator<B>;
+export declare const apFirst: <B>(second: IOAsyncGenerator<B>) => <A>(first: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const apSecond: <B>(second: IOAsyncGenerator<B>) => <A>(first: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: IOAsyncGenerator<B>) => (fa: IOAsyncGenerator<A>) => IOAsyncGenerator<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const ApplicativePar: Appli.Applicative1<URI>;
+export declare const ApplicativeSeq: Appli.Applicative1<URI>;
+export declare const Chain: Ch.Chain1<URI>;
+export declare const chain: <A, B>(a: (a: A) => IOAsyncGenerator<B>) => (b: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare const chainFirst: <A, B>(f: (a: A) => IOAsyncGenerator<B>) => (first: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => IOAsyncGenerator<B>) => (ma: IOAsyncGenerator<A>) => IOAsyncGenerator<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Monad: Mona.Monad1<URI>;
+export declare const FromIO: FIO.FromIO1<URI>;
+export declare const fromIO: import("fp-ts/lib/NaturalTransformation").NaturalTransformation11<"IO", "IOAsyncGenerator">;
+export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => (...a: A) => IOAsyncGenerator<B>;
+export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const fromIOReadonlyArray: <A>(fa: IO.IO<readonly A[]>) => IOAsyncGenerator<A>;
+export declare const fromIOReadonlyArrayK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<readonly B[]>) => (...a: A) => IOAsyncGenerator<B>;
+export declare const chainIOReadonlyArrayK: <A, B>(f: (a: A) => IO.IO<readonly B[]>) => (b: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare const MonadIO: MIO.MonadIO1<URI>;
+export declare const Compactable: Co.Compactable1<URI>;
+export declare const compact: <A>(fa: IOAsyncGenerator<O.Option<A>>) => IOAsyncGenerator<A>;
+export declare const separate: <A, B>(fa: IOAsyncGenerator<Ei.Either<A, B>>) => S.Separated<IOAsyncGenerator<A>, IOAsyncGenerator<B>>;
+export declare const Filterable: Fi.Filterable1<URI>;
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (fa: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare function filter<A>(predicate: Predicate<A>): (fa: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const filterMap: <A, B>(a: (a: A) => O.Option<B>) => (b: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare function partition<A, B extends A>(refinement: Refinement<A, B>): (fa: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<A>, IOAsyncGenerator<B>>;
+export declare function partition<A>(predicate: Predicate<A>): (fa: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<A>, IOAsyncGenerator<A>>;
+export declare const partitionMap: <A, B, C>(a: (a: A) => Ei.Either<B, C>) => (b: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<B>, IOAsyncGenerator<C>>;
+export declare const FilterableWithIndex: FiWI.FilterableWithIndex1<URI, number>;
+export declare function filterWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare function filterWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const filterMapWithIndex: <A, B>(a: (i: number, a: A) => O.Option<B>) => (b: IOAsyncGenerator<A>) => IOAsyncGenerator<B>;
+export declare function partitionWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<A>, IOAsyncGenerator<B>>;
+export declare function partitionWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<A>, IOAsyncGenerator<A>>;
+export declare const partitionMapWithIndex: <A, B, C>(a: (i: number, a: A) => Ei.Either<B, C>) => (b: IOAsyncGenerator<A>) => S.Separated<IOAsyncGenerator<B>, IOAsyncGenerator<C>>;
+export declare const range: (start: number, end?: number | undefined) => IOAsyncGenerator<number>;
+export declare const replicate: <A>(a: A) => IOAsyncGenerator<A>;
+export declare const fromReadonlyArray: <A>(x: readonly A[]) => IOAsyncGenerator<A>;
+export declare const sieve: <A>(f: (init: readonly A[], a: A) => boolean) => (as: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const prime: IOAsyncGenerator<number>;
+export declare const exp: IOAsyncGenerator<number>;
+export declare const fibonacci: IOAsyncGenerator<number>;
+export declare const flatten: <A>(as: IOAsyncGenerator<IOAsyncGenerator<A>>) => IOAsyncGenerator<A>;
+export declare const take: <A>(n: number) => (as: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const drop: <A>(n: number) => (as: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const zip: <A, B>(bs: IOAsyncGenerator<B>) => (as: IOAsyncGenerator<A>) => IOAsyncGenerator<readonly [A, B]>;
+export declare const uniq: <A>(E: Eq.Eq<A>) => (as: IOAsyncGenerator<A>) => IOAsyncGenerator<A>;
+export declare const match: <A, B>(onEmpty: Lazy<B>, onNonEmpty: (head: A, tail: IOAsyncGenerator<A>) => B) => (as: IOAsyncGenerator<A>) => T.Task<B>;
+export declare const toTask: <A>(as: IOAsyncGenerator<A>) => T.Task<readonly A[]>;
+export declare const isEmpty: (as: IOAsyncGenerator<unknown>) => T.Task<boolean>;
+export declare const isNonEmpty: (as: IOAsyncGenerator<unknown>) => T.Task<boolean>;
+export declare const lookup: <A>(i: number) => (as: IOAsyncGenerator<A>) => T.Task<O.Option<A>>;
+export declare const head: <A>(as: IOAsyncGenerator<A>) => T.Task<O.Option<A>>;
+export declare function find<A, B extends A>(refinement: Refinement<A, B>): (as: IOAsyncGenerator<A>) => T.Task<O.Option<B>>;
+export declare function find<A>(predicate: Predicate<A>): (as: IOAsyncGenerator<A>) => T.Task<O.Option<A>>;
+export declare const elem: <A>(Eq: Eq.Eq<A>) => (a: A) => (as: IOAsyncGenerator<A>) => T.Task<O.Option<A>>;