fortepiano 0.1.0

package/lib/Storage.js

@@ -0,0 +1,57 @@
+"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.log = void 0;
+const function_1 = require("fp-ts/function");
+const R = __importStar(require("fp-ts/Random"));
+const TE = __importStar(require("fp-ts/TaskEither"));
+const $L = __importStar(require("./Log"));
+const $R = __importStar(require("./Random"));
+const $Stri = __importStar(require("./string"));
+const _log = ([verb, preposition], path, { fileSystem }, log) => (ma) => $R.salt(TE.MonadIO)(R.randomInt(0, Number.MAX_SAFE_INTEGER), (salt) => {
+    const message = `[${salt}] \r${$Stri.capitalize(verb)} file "${path}"${undefined !== fileSystem
+        ? ` ${preposition} file system "${fileSystem}"`
+        : ''}`;
+    return function_1.pipe(log.start(message), TE.fromIO, TE.chain(() => ma), 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) => (storage) => ({
+    getStream: (path, options = {}) => function_1.pipe(storage.getStream(path, options), _log(['getting stream for', 'from'], path, options, {
+        start: logStart,
+        end: logEnd,
+    })),
+    getUrl: (path, options = {}) => function_1.pipe(storage.getUrl(path, options), _log(['getting URL for', 'from'], path, options, {
+        start: logStart,
+        end: logEnd,
+    })),
+    read: (path, options = {}) => function_1.pipe(storage.read(path, options), _log(['reading', 'from'], path, options, {
+        start: logStart,
+        end: logEnd,
+    })),
+    write: (path, options = {}) => function_1.flow(storage.write(path, options), _log(['writing', 'to'], path, options, {
+        start: logStart,
+        end: logEnd,
+    })),
+    delete: (path, options = {}) => function_1.pipe(storage.delete(path, options), _log(['deleting', 'from'], path, options, {
+        start: logStart,
+        end: logEnd,
+    })),
+});
+exports.log = log;

package/lib/Stream.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import * as t from 'io-ts';
+export declare const ReadableStreamC: t.Type<NodeJS.ReadableStream, NodeJS.ReadableStream, unknown>;
+export declare const WritableStreamC: t.Type<NodeJS.WritableStream, NodeJS.WritableStream, unknown>;
+export declare const ReadWriteStreamC: t.Type<NodeJS.ReadWriteStream, NodeJS.ReadWriteStream, unknown>;

package/lib/Stream.js

@@ -0,0 +1,31 @@
+"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.ReadWriteStreamC = exports.WritableStreamC = exports.ReadableStreamC = void 0;
+const function_1 = require("fp-ts/function");
+const t = __importStar(require("io-ts"));
+const stream_1 = require("stream");
+const isReadable = (u) => u instanceof stream_1.Readable;
+exports.ReadableStreamC = new t.Type('ReadableStream', isReadable, (u, c) => (isReadable(u) ? t.success(u) : t.failure(u, c)), function_1.identity);
+const isWritable = (u) => u instanceof stream_1.Writable;
+exports.WritableStreamC = new t.Type('WritableStream', isWritable, (u, c) => (isWritable(u) ? t.success(u) : t.failure(u, c)), function_1.identity);
+const isReadWrite = (u) => u instanceof stream_1.Duplex;
+exports.ReadWriteStreamC = new t.Type('ReadWriteStream', isReadWrite, (u, c) => (isReadWrite(u) ? t.success(u) : t.failure(u, c)), function_1.identity);

package/lib/TaskEither.d.ts

@@ -0,0 +1,2 @@
+import * as TE from 'fp-ts/TaskEither';
+export declare const tryCatch: typeof TE.tryCatch;

package/lib/TaskEither.js

@@ -0,0 +1,32 @@
+"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.tryCatch = void 0;
+const TE = __importStar(require("fp-ts/TaskEither"));
+const tryCatch = (f, onRejected) => TE.tryCatch(() => {
+    try {
+        return f();
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+}, onRejected);
+exports.tryCatch = tryCatch;

package/lib/Type.d.ts

@@ -0,0 +1,11 @@
+import * as t from 'io-ts';
+export declare const numeric: t.Type<number, number, unknown>;
+export declare function literal<V extends number | string>(value: V, name?: string): t.LiteralC<V>;
+export declare function literal(regExp: RegExp, name?: string): t.StringC;
+export declare const struct: t.Type<object, object, unknown>;
+export declare const nullable: <C extends t.Mixed>(codec: C, name?: string | undefined) => t.UnionC<[C, t.UndefinedC]>;
+export declare const alias: <C extends t.Mixed>(name: string, codec: C) => t.Type<t.TypeOf<C>, t.OutputOf<C>, t.InputOf<C>>;
+export declare function literalUnion<A extends number | string, B extends {
+    readonly [K in A]: null;
+}>(strings: Readonly<[A, A, ...ReadonlyArray<A>]>, name?: string): t.KeyofC<B>;
+export declare const lax: <P extends t.Props>(props: P, name?: string | undefined) => t.Type<{ [K in keyof P]?: t.TypeOf<P[K]> | undefined; }, { [K_1 in keyof P]?: t.OutputOf<P[K_1]> | undefined; }, unknown>;

package/lib/Type.js

@@ -0,0 +1,53 @@
+"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.lax = exports.literalUnion = exports.alias = exports.nullable = exports.struct = exports.literal = exports.numeric = void 0;
+const E = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const O = __importStar(require("fp-ts/Option"));
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+const RR = __importStar(require("fp-ts/ReadonlyRecord"));
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+exports.numeric = new t.Type('Numeric', t.number.is, (u, c) => function_1.pipe(t.number.validate(u, c), E.alt(() => io_ts_types_1.NumberFromString.validate(u, c))), t.number.encode);
+const isLiteral = (r) => (u) => t.string.is(u) && r.test(u);
+function literal(a, name) {
+    return a instanceof RegExp
+        ? new t.Type(name || 'Literal', isLiteral(a), (u, c) => (isLiteral(a)(u) ? t.success(u) : t.failure(u, c)), function_1.identity)
+        : t.literal(a, name);
+}
+exports.literal = literal;
+const isStruct = (u) => 'object' === typeof u && null !== u && !Array.isArray(u);
+exports.struct = new t.Type('struct', isStruct, (u, c) => (isStruct(u) ? t.success(u) : t.failure(u, c)), function_1.identity);
+const nullable = (codec, name) => t.union([codec, t.undefined], name);
+exports.nullable = nullable;
+const alias = (name, codec) => (Object.assign(Object.assign({}, codec), { name }));
+exports.alias = alias;
+const isStringArray = (as) => t.string.is(as[0]);
+function literalUnion(as, name) {
+    return isStringArray(as)
+        ? t.keyof(as.reduce((result, string) => (Object.assign(Object.assign({}, result), { [string]: null })), {}), name)
+        : t.union(as.map((number) => t.literal(number)), name);
+}
+exports.literalUnion = literalUnion;
+const lax = (props, name) => function_1.pipe(t.partial(props, name), (partial) => new t.Type(partial.name, partial.is, function_1.flow(t.UnknownRecord.validate, E.map(RR.toReadonlyArray), E.map(RA.reduce({}, (result, [key, value]) => function_1.pipe(partial.props, RR.lookup(key), O.match(() => result, // ({ ...result, [key]: value }),
+(codec) => function_1.pipe(codec.decode(value), E.match(() => result, (value) => (Object.assign(Object.assign({}, result), { [key]: value })))))))), E.chain(t.success)), partial.encode));
+exports.lax = lax;

package/lib/Validation.d.ts

@@ -0,0 +1,4 @@
+import * as E from 'fp-ts/Either';
+export declare type Validation<E, A> = E.Either<ReadonlyArray<E>, A>;
+export declare const fromEither: <E, A>(fa: E.Either<E, A>) => Validation<E, A>;
+export declare const getMonoid: <E>() => <A>(M: import("fp-ts/lib/Monoid").Monoid<A>) => import("fp-ts/lib/Monoid").Monoid<E.Either<readonly E[], A>>;

package/lib/Validation.js

@@ -0,0 +1,30 @@
+"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.getMonoid = exports.fromEither = void 0;
+const A = __importStar(require("fp-ts/Applicative"));
+const E = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+const fromEither = (fa) => function_1.pipe(fa, E.mapLeft(RA.of));
+exports.fromEither = fromEither;
+const getMonoid = () => A.getApplicativeMonoid(E.getApplicativeValidation(RA.getSemigroup()));
+exports.getMonoid = getMonoid;

package/lib/cache/Memcached.d.ts

@@ -0,0 +1,4 @@
+import { Lazy } from 'fp-ts/function';
+import Memcached from 'memcached';
+import * as $C from '../Cache';
+export declare const $memcached: (memcached: Lazy<Memcached>, ttl?: number) => $C.Cache;

package/lib/cache/Memcached.js

@@ -0,0 +1,50 @@
+"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.$memcached = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const $Er = __importStar(require("../Error"));
+const function_2 = require("../function");
+const $TE = __importStar(require("../TaskEither"));
+const $memcached = (memcached, ttl = Infinity) => {
+    const _memcached = function_2.memoize(memcached);
+    return {
+        get: (key, codec) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _memcached().get(key, (error, data) => {
+            // eslint-disable-next-line eqeqeq
+            undefined != error || undefined == data
+                ? reject(error)
+                : resolve(data);
+        })), $Er.fromUnknown(Error(`Cannot find cache item "${key}"`))), TE.chainEitherK(function_1.flow(codec.decode, Ei.mapLeft($Er.fromUnknown(Error(`Cannot decode cache item "${key}" into "${codec.name}"`)))))),
+        set: (key, codec, _ttl = ttl) => (value) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _memcached().set(key, codec.encode(value), _ttl / 1000, (error) => 
+        // eslint-disable-next-line eqeqeq
+        undefined != error ? reject(error) : resolve())), $Er.fromUnknown(Error(`Cannot write cache item "${key}"`)))),
+        delete: (key) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _memcached().del(key, (error) => {
+            // eslint-disable-next-line eqeqeq
+            undefined != error ? reject(error) : resolve();
+        })), $Er.fromUnknown(Error(`Cannot delete cache item "${key}"`)))),
+        clear: function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _memcached().flush((error) => 
+        // eslint-disable-next-line eqeqeq
+        undefined != error ? reject(error) : resolve())), $Er.fromUnknown(Error('Cannot clear cache')))),
+    };
+};
+exports.$memcached = $memcached;

package/lib/cache/Memory.d.ts

@@ -0,0 +1,2 @@
+import * as $C from '../Cache';
+export declare const memory: (ttl?: number) => $C.Cache;

package/lib/cache/Memory.js

@@ -0,0 +1,66 @@
+"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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memory = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const memory = (ttl = Infinity) => {
+    let cache = {};
+    let timeouts = {};
+    return {
+        get: (key, codec) => () => __awaiter(void 0, void 0, void 0, function* () {
+            return function_1.pipe(key in cache
+                ? Ei.right(cache[key])
+                : Ei.left(Error(`Cannot find cache item "${key}"`)), Ei.filterOrElse(codec.is, () => Error(`Cannot decode cache item "${key}" into "${codec.name}"`)));
+        }),
+        set: (key, _, _ttl = ttl) => (value) => () => __awaiter(void 0, void 0, void 0, function* () {
+            clearTimeout(timeouts[key]);
+            cache[key] = value;
+            timeouts[key] = setTimeout(() => {
+                delete cache[key];
+                delete timeouts[key];
+            }, Math.min(Math.pow(2, 31) - 1, Math.max(0, _ttl)));
+            return Ei.of(undefined);
+        }),
+        delete: (key) => () => __awaiter(void 0, void 0, void 0, function* () {
+            clearTimeout(timeouts[key]);
+            delete cache[key];
+            delete timeouts[key];
+            return Ei.of(undefined);
+        }),
+        clear: () => __awaiter(void 0, void 0, void 0, function* () {
+            Object.values(timeouts).forEach(clearTimeout);
+            cache = {};
+            timeouts = {};
+            return Ei.of(undefined);
+        }),
+    };
+};
+exports.memory = memory;

package/lib/cache/Redis.d.ts

@@ -0,0 +1,4 @@
+import { Lazy } from 'fp-ts/function';
+import { RedisClient } from 'redis';
+import * as $C from '../Cache';
+export declare const $redis: (redis: Lazy<RedisClient>, ttl?: number) => $C.Cache;

package/lib/cache/Redis.js

@@ -0,0 +1,58 @@
+"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.$redis = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const io_ts_types_1 = require("io-ts-types");
+const $Er = __importStar(require("../Error"));
+const function_2 = require("../function");
+const $TE = __importStar(require("../TaskEither"));
+const $redis = (redis, ttl = Infinity) => {
+    const _redis = function_2.memoize(() => new Promise((resolve, reject) => {
+        const client = redis();
+        client.on('error', reject).on('ready', () => resolve(client));
+    }));
+    return {
+        get: (key, codec) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _redis()
+            .then((client) => client.get(key, (error, result) => {
+            null !== error || null === result
+                ? reject(error)
+                : resolve(result);
+        }))
+            .catch(reject)), $Er.fromUnknown(Error(`Cannot find cache item "${key}"`))), TE.chainEitherK(function_1.flow(codec.decode, Ei.mapLeft($Er.fromUnknown(Error(`Cannot decode cache item "${key}" into "${codec.name}"`)))))),
+        set: (key, codec, _ttl = ttl) => (value) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _redis()
+            .then((client) => client.set(key, io_ts_types_1.JsonFromString.pipe(codec).encode(value), 'EX', _ttl / 1000, (error) => (null !== error ? reject(error) : resolve())))
+            .catch(reject)), $Er.fromUnknown(Error(`Cannot write cache item "${key}"`)))),
+        delete: (key) => function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _redis()
+            .then((client) => client.del(key, (error, result) => {
+            null !== error || null === result
+                ? reject(error)
+                : resolve();
+        }))
+            .catch(reject)), $Er.fromUnknown(Error(`Cannot delete cache item "${key}"`)))),
+        clear: function_1.pipe($TE.tryCatch(() => new Promise((resolve, reject) => _redis()
+            .then((client) => client.flushdb((error) => null !== error ? reject(error) : resolve()))
+            .catch(reject)), $Er.fromUnknown(Error('Cannot clear cache')))),
+    };
+};
+exports.$redis = $redis;

package/lib/cache/Storage.d.ts

@@ -0,0 +1,4 @@
+import { Lazy } from 'fp-ts/function';
+import * as $C from '../Cache';
+declare const _storage: (storage: Lazy<Storage>, name?: string | undefined, ttl?: number) => $C.Cache;
+export { _storage as storage };

package/lib/cache/Storage.js

@@ -0,0 +1,62 @@
+"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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const J = __importStar(require("fp-ts/Json"));
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const $Er = __importStar(require("../Error"));
+const function_2 = require("../function");
+const $S = __importStar(require("../struct"));
+const CacheItemC = t.type({
+    exp: t.number,
+    value: io_ts_types_1.Json,
+});
+const _storage = (storage, name, ttl = Infinity) => {
+    const _storage = function_2.memoize(storage);
+    return {
+        get: (key, codec) => () => __awaiter(void 0, void 0, void 0, function* () {
+            return function_1.pipe(_storage().getItem(`${undefined !== name ? `${name}_` : ''}${key}`), Ei.fromNullable(Error(`Cannot find cache item "${key}"`)), Ei.chain(function_1.flow(J.parse, Ei.chainW(CacheItemC.decode), Ei.mapLeft($Er.fromUnknown(Error(`Cannot decode cache item "${key}"`))))), Ei.filterOrElse(({ exp }) => Date.now() < exp, () => Error(`Cache item "${key}" is expired`)), Ei.map($S.lookup('value')), Ei.chain(function_1.flow(codec.decode, Ei.mapLeft($Er.fromUnknown(Error(`Cannot decode cache item "${key}" into "${codec.name}"`))))));
+        }),
+        set: (key, codec, _ttl = ttl) => (value) => () => __awaiter(void 0, void 0, void 0, function* () {
+            return function_1.pipe({
+                exp: Math.min(Number.MAX_SAFE_INTEGER, Date.now() + Math.max(0, _ttl) + 1),
+                value: codec.encode(value),
+            }, J.stringify, Ei.bimap($Er.fromUnknown(Error(`Cannot encode cache item "${key}"`)), (item) => _storage().setItem(`${undefined !== name ? `${name}_` : ''}${key}`, item)));
+        }),
+        delete: (key) => () => __awaiter(void 0, void 0, void 0, function* () {
+            return function_1.pipe(_storage().removeItem(`${undefined !== name ? `${name}_` : ''}${key}`), Ei.of);
+        }),
+        clear: () => __awaiter(void 0, void 0, void 0, function* () { return function_1.pipe(_storage().clear(), Ei.of); }),
+    };
+};
+exports.storage = _storage;

package/lib/function.d.ts

@@ -0,0 +1,52 @@
+import { Lazy } from 'fp-ts/function';
+export declare const run: <A>(f: Lazy<A>) => A;
+export declare function curry<A, B, C>(f: (a: A, b: B) => C): (a: A) => (b: B) => C;
+export declare function curry<A, B, C, D>(f: (a: A, b: B, c: C) => D): (a: A) => (b: B) => (c: C) => D;
+export declare function uncurry<A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D): D extends (...args: any) => any ? never : (a: A, b: B, c: C) => D;
+export declare function uncurry<A, B, C>(f: (a: A) => (b: B) => C): C extends (...args: any) => any ? never : (a: A, b: B) => C;
+export declare const memoize: <A extends (...args: any) => any>(f: A) => A;
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+export declare const recurse: <A extends (...args: any) => any>(f: (self: A, depth: number) => A, cache?: boolean) => A;
+/**
+ * @example
+ * type _Op<A> = { _tag: A; x: number; y: number }
+ * type Add = _Op<'Add'>
+ * type Mul = _Op<'Mul'>
+ * type Sub = _Op<'Sub'>
+ * type Div = _Op<'Div'>
+ * type Op = Add | Mul | Sub | Div
+ *
+ * const calc = match<Op>()({
+ *   Add: ({ x, y }) => option.some(x + y),
+ *   Mul: ({ x, y }) => option.some(x * y),
+ *   Sub: ({ x, y }) => option.some(x - y),
+ *   Div: ({ x, y }) => (0 === y ? option.none : option.some(x / y)),
+ * })
+ * const op = (_tag: Op['_tag']) => (y: number) => (x: number) => calc({ _tag, x, y })
+ * const add = op('Add')
+ * const mul = op('Mul')
+ * const sub = op('Sub')
+ * const div = op('Div')
+ *
+ * expect(
+ *   pipe(
+ *     option.of(42),
+ *     option.chain(add(1138)),
+ *     option.chain(mul(0.1)),
+ *     option.chain(sub(1337)),
+ *     option.chain(div(0.1)),
+ *     option.getOrElse(() => NaN)
+ *   )
+ * ).toBeCloseTo(-12190)
+ */
+export declare const match: <A extends { readonly [k in K]: string; }, K extends string = "_tag">() => <T extends A[K], B>(onCases: { readonly [t in T]: (a: Extract<A, { readonly [k_1 in K]: t; }>) => B; }, k?: K) => (a: A) => B;

package/lib/function.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.match = exports.recurse = exports.memoize = exports.uncurry = exports.curry = exports.run = void 0;
+const run = (f) => f();
+exports.run = run;
+function curry(f) {
+    return function curried(...head) {
+        return head.length >= f.length
+            ? f(...head)
+            : (...rest) => curried(...head.concat(rest));
+    };
+}
+exports.curry = curry;
+function uncurry(f) {
+    return (...args) => args.reduce((_f, arg) => _f(arg), f);
+}
+exports.uncurry = uncurry;
+const memoize = (f) => {
+    const cache = {};
+    return ((...args) => {
+        let key = '';
+        try {
+            key = JSON.stringify(args);
+        }
+        catch (error) {
+            return f(...args);
+        }
+        if (!(key in cache)) {
+            const result = f(...args);
+            cache[key] =
+                result instanceof Promise
+                    ? result.catch((error) => {
+                        delete cache[key];
+                        throw error;
+                    })
+                    : result;
+        }
+        return cache[key];
+    });
+};
+exports.memoize = memoize;
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+const recurse = (f, cache = false) => {
+    let depth = 0;
+    let _cache = null;
+    const run = !cache
+        ? f
+        : (_self, _depth) => {
+            if (!_cache) {
+                _cache = f(_self, _depth);
+            }
+            return _cache;
+        };
+    const self = ((...args) => run(self, depth++)(...args));
+    return self;
+};
+exports.recurse = recurse;
+/**
+ * @example
+ * type _Op<A> = { _tag: A; x: number; y: number }
+ * type Add = _Op<'Add'>
+ * type Mul = _Op<'Mul'>
+ * type Sub = _Op<'Sub'>
+ * type Div = _Op<'Div'>
+ * type Op = Add | Mul | Sub | Div
+ *
+ * const calc = match<Op>()({
+ *   Add: ({ x, y }) => option.some(x + y),
+ *   Mul: ({ x, y }) => option.some(x * y),
+ *   Sub: ({ x, y }) => option.some(x - y),
+ *   Div: ({ x, y }) => (0 === y ? option.none : option.some(x / y)),
+ * })
+ * const op = (_tag: Op['_tag']) => (y: number) => (x: number) => calc({ _tag, x, y })
+ * const add = op('Add')
+ * const mul = op('Mul')
+ * const sub = op('Sub')
+ * const div = op('Div')
+ *
+ * expect(
+ *   pipe(
+ *     option.of(42),
+ *     option.chain(add(1138)),
+ *     option.chain(mul(0.1)),
+ *     option.chain(sub(1337)),
+ *     option.chain(div(0.1)),
+ *     option.getOrElse(() => NaN)
+ *   )
+ * ).toBeCloseTo(-12190)
+ */
+const match = () => (onCases, k = '_tag') => (a) => onCases[a[k]](a);
+exports.match = match;