@vtex/api 1.9.3 → 1.9.4

package/lib/Metadata.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IODataSource_1 = require("./IODataSource");
+const appId = process.env.VTEX_APP_ID;
+const [runningAppName] = appId ? appId.split('@') : [''];
+const routes = {
+    Bucket: (bucket) => `/buckets/${runningAppName}/${bucket}`,
+    Metadata: (bucket) => `${routes.Bucket(bucket)}/metadata`,
+    MetadataKey: (bucket, key) => `${routes.Metadata(bucket)}/${key}`,
+};
+class Metadata extends IODataSource_1.IODataSource {
+    constructor(context, options = {}) {
+        super(context, options);
+        this.service = 'router';
+        this.httpClientFactory = IODataSource_1.forWorkspace;
+        this.getBuckets = (bucket) => {
+            return this.http.get(routes.Bucket(bucket));
+        };
+        this.list = (bucket, includeValue, limit, nextMarker) => {
+            const query = { value: includeValue, _limit: 10 };
+            if (limit && limit > 0) {
+                query._limit = limit;
+            }
+            if (nextMarker) {
+                query._marker = nextMarker;
+            }
+            return this.http.get(routes.Metadata(bucket), { params: query });
+        };
+        this.listAll = (bucket, includeValue) => {
+            const query = { value: includeValue, _limit: 1000 };
+            return this.http.get(routes.Metadata(bucket), { params: query });
+        };
+        this.get = (bucket, key) => {
+            return this.http.get(routes.MetadataKey(bucket, key));
+        };
+        this.save = (bucket, key, data) => {
+            return this.http.put(routes.MetadataKey(bucket, key), data);
+        };
+        this.saveAll = (bucket, data) => {
+            return this.http.put(routes.Metadata(bucket), data);
+        };
+        this.delete = (bucket, key) => {
+            return this.http.delete(routes.MetadataKey(bucket, key));
+        };
+        this.deleteAll = (bucket) => {
+            return this.http.delete(routes.Metadata(bucket));
+        };
+        if (runningAppName === '') {
+            throw new Error(`Invalid path to access Metadata. Variable VTEX_APP_ID is not available.`);
+        }
+    }
+}
+exports.Metadata = Metadata;

package/lib/Registry.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { HttpClientFactory, IODataSource } from './IODataSource';
+import { AppBundlePublished, AppFilesList, AppManifest } from './responses';
+export declare class Registry extends IODataSource {
+    protected httpClientFactory: HttpClientFactory;
+    protected service: string;
+    publishApp: (files: File[], tag?: string | undefined, { zlib }?: ZipOptions) => Promise<AppBundlePublished>;
+    listApps: () => Promise<RegistryAppsList>;
+    listVersionsByApp: (app: string) => Promise<RegistryAppVersionsList>;
+    deprecateApp: (app: string, version: string) => Promise<void>;
+    getAppManifest: (app: string, version: string, opts?: AppsManifestOptions | undefined) => Promise<AppManifest>;
+    listAppFiles: (app: string, version: string, opts?: ListAppFilesOptions | undefined) => Promise<AppFilesList>;
+    getAppFile: (app: string, version: string, path: string) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppFileStream: (app: string, version: string, path: string) => Promise<IncomingMessage>;
+    getAppBundle: (app: string, version: string, bundlePath: string, generatePackageJson: boolean) => Promise<Readable>;
+    unpackAppBundle: (app: string, version: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean) => Promise<Writable>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string) => Promise<Record<string, string[]>>;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+export interface AppsManifestOptions {
+    resolveDeps: boolean;
+}
+export interface ListAppFilesOptions {
+    prefix: string;
+}
+export interface RegistryAppsListItem {
+    partialIdentifier: string;
+    location: string;
+}
+export interface RegistryAppsList {
+    data: RegistryAppsListItem[];
+}
+export interface RegistryAppVersionsListItem {
+    versionIdentifier: string;
+    location: string;
+}
+export interface RegistryAppVersionsList {
+    data: RegistryAppVersionsListItem[];
+}
+export interface File {
+    path: string;
+    content: any;
+}
+export {};

package/lib/Registry.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const archiver = require("archiver");
+const qs_1 = require("qs");
+const tar_fs_1 = require("tar-fs");
+const zlib_1 = require("zlib");
+const constants_1 = require("./constants");
+const HttpClient_1 = require("./HttpClient");
+const IODataSource_1 = require("./IODataSource");
+const EMPTY_OBJECT = {};
+const routes = {
+    App: (app) => `${routes.Registry}/${app}`,
+    AppBundle: (app, version, path) => `${routes.AppVersion(app, version)}/bundle/${path}`,
+    AppFile: (app, version, path) => `${routes.AppFiles(app, version)}/${path}`,
+    AppFiles: (app, version) => `${routes.AppVersion(app, version)}/files`,
+    AppVersion: (app, version) => `${routes.App(app)}/${version}`,
+    Publish: '/v2/registry',
+    Registry: '/registry',
+    ResolveDependenciesWithManifest: '/v2/registry/_resolve',
+};
+const forWorkspaceMaster = ({ service, context, options }) => (service && context)
+    ? HttpClient_1.HttpClient.forWorkspace(service, Object.assign({}, context, { workspace: constants_1.DEFAULT_WORKSPACE }), options || {})
+    : undefined;
+const paramsSerializer = (params) => {
+    return qs_1.stringify(params, { arrayFormat: 'repeat' });
+};
+class Registry extends IODataSource_1.IODataSource {
+    constructor() {
+        super(...arguments);
+        this.httpClientFactory = forWorkspaceMaster;
+        this.service = 'apps';
+        this.publishApp = (files, tag, { zlib } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (!(files[0] && files[0].path && files[0].content)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = archiver('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const request = this.http.post(routes.Publish, zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                params: tag ? { tag } : EMPTY_OBJECT,
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            try {
+                const [response] = yield Promise.all([request, finalize]);
+                response.bundleSize = zip.pointer();
+                return response;
+            }
+            catch (e) {
+                e.bundleSize = zip.pointer();
+                throw e;
+            }
+        });
+        this.listApps = () => {
+            return this.http.get(routes.Registry);
+        };
+        this.listVersionsByApp = (app) => {
+            return this.http.get(routes.App(app));
+        };
+        this.deprecateApp = (app, version) => {
+            return this.http.patch(routes.AppVersion(app, version), { deprecated: true });
+        };
+        this.getAppManifest = (app, version, opts) => {
+            return this.http.get(routes.AppVersion(app, version), { params: opts });
+        };
+        this.listAppFiles = (app, version, opts) => {
+            return this.http.get(routes.AppFiles(app, version), { params: opts });
+        };
+        this.getAppFile = (app, version, path) => {
+            return this.http.getBuffer(routes.AppFile(app, version, path));
+        };
+        this.getAppFileStream = (app, version, path) => {
+            return this.http.getStream(routes.AppFile(app, version, path));
+        };
+        this.getAppBundle = (app, version, bundlePath, generatePackageJson) => {
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            return this.http.getStream(routes.AppBundle(app, version, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                params,
+            });
+        };
+        this.unpackAppBundle = (app, version, bundlePath, unpackPath, generatePackageJson) => {
+            return this.getAppBundle(app, version, bundlePath, generatePackageJson)
+                .then(stream => stream
+                .pipe(zlib_1.createGunzip())
+                .pipe(tar_fs_1.extract(unpackPath)));
+        };
+        this.resolveDependenciesWithManifest = (manifest, filter = '') => {
+            const params = { filter };
+            return this.http.post(routes.ResolveDependenciesWithManifest, manifest, { params, paramsSerializer });
+        };
+    }
+}
+exports.Registry = Registry;

package/lib/Router.d.ts

@@ -0,0 +1,35 @@
+import { InstanceOptions, IOContext } from './HttpClient';
+export declare class Router {
+    private http;
+    private account;
+    private workspace;
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    listAvailableIoVersions: () => Promise<AvaiableIO[]>;
+    getInstalledIoVersion: () => Promise<AvaiableIO>;
+    installIo: (version: string) => Promise<void>;
+    listAvailableServices: () => Promise<AvailableServices>;
+    getAvailableVersions: (name: string) => Promise<AvailableServiceVersions>;
+    listInstalledServices: () => Promise<InstalledService[]>;
+    installService: (name: string, version: string) => Promise<void>;
+}
+export interface AvaiableIO {
+    version: string;
+    tested: boolean;
+    services: {
+        [service: string]: string;
+    };
+}
+export declare type InstalledIO = AvaiableIO;
+export interface AvailableServiceVersions {
+    versions: {
+        [region: string]: string[];
+    };
+}
+export interface AvailableServices {
+    [service: string]: AvailableServiceVersions;
+}
+export interface InstalledService {
+    name: string;
+    version: string;
+    serviceIsolation: number;
+}

package/lib/Router.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("./HttpClient");
+const routes = {
+    AvailableIoVersions: '/_io',
+    AvailableServiceVersions: (service) => `${routes.AvailableServices}/${service}`,
+    AvailableServices: '/_services',
+    InstalledIoVersion: (account, workspace) => `/${account}/${workspace}/io`,
+    InstalledService: (account, workspace, name) => `/${routes.InstalledServices(account, workspace)}/services/${name}`,
+    InstalledServices: (account, workspace) => `/${account}/${workspace}/services`,
+};
+class Router {
+    constructor(ioContext, opts = {}) {
+        this.listAvailableIoVersions = () => {
+            return this.http.get(routes.AvailableIoVersions);
+        };
+        this.getInstalledIoVersion = () => {
+            if (!this.account || !this.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.get(routes.InstalledIoVersion(this.account, this.workspace));
+        };
+        this.installIo = (version) => {
+            if (!this.account || !this.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.put(routes.InstalledIoVersion(this.account, this.workspace), { version });
+        };
+        this.listAvailableServices = () => {
+            return this.http.get(routes.AvailableServices);
+        };
+        this.getAvailableVersions = (name) => {
+            return this.http.get(routes.AvailableServiceVersions(name));
+        };
+        this.listInstalledServices = () => {
+            if (!this.account || !this.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.get(routes.InstalledServices(this.account, this.workspace));
+        };
+        this.installService = (name, version) => {
+            if (!this.account || !this.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.post(routes.InstalledServices(this.account, this.workspace), { name, version });
+        };
+        this.account = ioContext.account;
+        this.workspace = ioContext.workspace;
+        this.http = HttpClient_1.HttpClient.forRoot('router', ioContext, opts);
+    }
+}
+exports.Router = Router;

package/lib/VBase.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable } from 'stream';
+import { InstanceOptions, IOContext } from './HttpClient';
+import { IODataSource } from './IODataSource';
+import { BucketMetadata, FileListItem } from './responses';
+export declare class VBase extends IODataSource {
+    protected httpClientFactory: import("./IODataSource").HttpClientFactory;
+    protected service: string;
+    constructor(context?: IOContext, options?: InstanceOptions);
+    getBucket: (bucket: string) => Promise<BucketMetadata>;
+    resetBucket: (bucket: string) => Promise<import("./HttpClient").IOResponse<void>>;
+    listFiles: (bucket: string, opts?: string | VBaseOptions | undefined) => Promise<BucketFileList>;
+    getFile: (bucket: string, path: string) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getJSON: <T>(bucket: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+    getFileStream: (bucket: string, path: string) => Promise<IncomingMessage>;
+    saveFile: (bucket: string, path: string, stream: Readable, gzip?: boolean, ttl?: number | undefined) => Promise<void>;
+    saveJSON: <T>(bucket: string, path: string, data: T) => Promise<void>;
+    saveZippedContent: (bucket: string, path: string, stream: Readable) => Promise<void>;
+    deleteFile: (bucket: string, path: string) => Promise<import("./HttpClient").IOResponse<void>>;
+    private saveContent;
+}
+export interface BucketFileList {
+    data: FileListItem[];
+    next: string;
+    smartCacheHeaders: any;
+}
+export interface VBaseOptions {
+    prefix?: string;
+    _next?: string;
+    _limit?: number;
+}
+export interface VBaseSaveOptions {
+    gzip?: boolean;
+    unzip?: boolean;
+    ttl?: number;
+}

package/lib/VBase.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mime = require("mime-types");
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const IODataSource_1 = require("./IODataSource");
+const appId = process.env.VTEX_APP_ID;
+const [runningAppName] = appId ? appId.split('@') : [''];
+const routes = {
+    Bucket: (bucket) => `/buckets/${runningAppName}/${bucket}`,
+    File: (bucket, path) => `${routes.Bucket(bucket)}/files/${path}`,
+    Files: (bucket) => `${routes.Bucket(bucket)}/files`,
+};
+const isVBaseOptions = (opts) => {
+    return typeof opts !== 'string' && !(opts instanceof String);
+};
+class VBase extends IODataSource_1.IODataSource {
+    constructor(context, options = {}) {
+        super(context, options);
+        this.httpClientFactory = IODataSource_1.forWorkspace;
+        this.service = 'vbase';
+        this.getBucket = (bucket) => {
+            return this.http.get(routes.Bucket(bucket));
+        };
+        this.resetBucket = (bucket) => {
+            return this.http.delete(routes.Files(bucket));
+        };
+        this.listFiles = (bucket, opts) => {
+            let params = {};
+            if (isVBaseOptions(opts)) {
+                params = opts;
+            }
+            else if (opts) {
+                params = { prefix: opts };
+            }
+            return this.http.get(routes.Files(bucket), { params });
+        };
+        this.getFile = (bucket, path) => {
+            return this.http.getBuffer(routes.File(bucket, path));
+        };
+        this.getJSON = (bucket, path, nullIfNotFound) => {
+            return this.http.get(routes.File(bucket, path), { nullIfNotFound });
+        };
+        this.getFileStream = (bucket, path) => {
+            return this.http.getStream(routes.File(bucket, path));
+        };
+        this.saveFile = (bucket, path, stream, gzip = true, ttl) => {
+            return this.saveContent(bucket, path, stream, { gzip, ttl });
+        };
+        this.saveJSON = (bucket, path, data) => {
+            const headers = { 'Content-Type': 'application/json' };
+            return this.http.put(routes.File(bucket, path), data, { headers });
+        };
+        this.saveZippedContent = (bucket, path, stream) => {
+            return this.saveContent(bucket, path, stream, { unzip: true });
+        };
+        this.deleteFile = (bucket, path) => {
+            return this.http.delete(routes.File(bucket, path));
+        };
+        this.saveContent = (bucket, path, stream, opts = {}) => {
+            if (!stream.pipe || !stream.on) {
+                throw new Error(`Argument stream must be a readable stream`);
+            }
+            const params = opts.unzip ? { unzip: opts.unzip } : {};
+            const headers = {};
+            let finalStream = stream;
+            headers['Content-Type'] = mime.contentType(path_1.basename(path)) || 'application/octet-stream';
+            if (opts.gzip) {
+                headers['Content-Encoding'] = 'gzip';
+                finalStream = stream.pipe(zlib_1.createGzip());
+            }
+            if (opts.ttl && Number.isInteger(opts.ttl)) {
+                headers['X-VTEX-TTL'] = opts.ttl;
+            }
+            return this.http.put(routes.File(bucket, path), finalStream, { headers, params });
+        };
+        if (runningAppName === '') {
+            throw new Error(`Invalid path to access Vbase. Variable VTEX_APP_ID is not available.`);
+        }
+    }
+}
+exports.VBase = VBase;

package/lib/Workspaces.d.ts

@@ -0,0 +1,17 @@
+import { IODataSource } from './IODataSource';
+export declare class Workspaces extends IODataSource {
+    protected service: string;
+    protected httpClientFactory: import("./IODataSource").HttpClientFactory;
+    list: (account: string) => Promise<WorkspaceMetadata[]>;
+    get: (account: string, workspace: string) => Promise<WorkspaceMetadata>;
+    set: (account: string, workspace: string, metadata: Partial<WorkspaceMetadata>) => Promise<void>;
+    create: (account: string, workspace: string) => Promise<void>;
+    delete: (account: string, workspace: string) => Promise<import("./HttpClient").IOResponse<void>>;
+    reset: (account: string, workspace: string, metadata?: Partial<WorkspaceMetadata>) => Promise<void>;
+    promote: (account: string, workspace: string) => Promise<void>;
+}
+export interface WorkspaceMetadata {
+    name: string;
+    weight: number;
+    production: boolean;
+}

package/lib/Workspaces.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const IODataSource_1 = require("./IODataSource");
+const routes = {
+    Account: (account) => `/${account}`,
+    Promote: (account) => `${routes.Workspace(account, constants_1.DEFAULT_WORKSPACE)}/_promote`,
+    Workspace: (account, workspace) => `${routes.Account(account)}/${workspace}`,
+};
+class Workspaces extends IODataSource_1.IODataSource {
+    constructor() {
+        super(...arguments);
+        this.service = 'router';
+        this.httpClientFactory = IODataSource_1.forRoot;
+        this.list = (account) => {
+            return this.http.get(routes.Account(account));
+        };
+        this.get = (account, workspace) => {
+            return this.http.get(routes.Workspace(account, workspace));
+        };
+        this.set = (account, workspace, metadata) => {
+            return this.http.put(routes.Workspace(account, workspace), metadata);
+        };
+        this.create = (account, workspace) => {
+            return this.http.post(routes.Account(account), { name: workspace });
+        };
+        this.delete = (account, workspace) => {
+            return this.http.delete(routes.Workspace(account, workspace));
+        };
+        this.reset = (account, workspace, metadata = {}) => {
+            const params = { reset: true };
+            return this.http.put(routes.Workspace(account, workspace), metadata, { params });
+        };
+        this.promote = (account, workspace) => {
+            return this.http.put(routes.Promote(account), { workspace });
+        };
+    }
+}
+exports.Workspaces = Workspaces;

package/lib/caches/CacheLayer.d.ts

@@ -0,0 +1,7 @@
+import { FetchResult } from './typings';
+export interface CacheLayer<K, V> {
+    get(key: K, fetcher?: () => Promise<FetchResult<V>>): Promise<V | void> | V | void;
+    has(key: K): Promise<boolean> | boolean;
+    set(key: K, value: V, maxAge?: number | void): Promise<boolean> | boolean;
+    getStats?(name?: string): any;
+}

package/lib/caches/CacheLayer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/caches/DiskCache.d.ts

@@ -0,0 +1,17 @@
+import { CacheLayer } from './CacheLayer';
+import { DiskStats } from './typings';
+import { outputJSON, readJSON } from 'fs-extra';
+export declare class DiskCache<V> implements CacheLayer<string, V> {
+    private cachePath;
+    private readFile;
+    private writeFile;
+    private hits;
+    private total;
+    private lock;
+    constructor(cachePath: string, readFile?: typeof readJSON, writeFile?: typeof outputJSON);
+    has: (key: string) => boolean;
+    getStats: (name?: string) => DiskStats;
+    get: (key: string) => Promise<void | V>;
+    set: (key: string, value: V) => Promise<boolean>;
+    private getPathKey;
+}

package/lib/caches/DiskCache.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const ReadWriteLock = require("rwlock");
+class DiskCache {
+    constructor(cachePath, readFile = fs_extra_1.readJSON, writeFile = fs_extra_1.outputJSON) {
+        this.cachePath = cachePath;
+        this.readFile = readFile;
+        this.writeFile = writeFile;
+        this.hits = 0;
+        this.total = 0;
+        this.has = (key) => {
+            const pathKey = this.getPathKey(key);
+            return fs_extra_1.pathExistsSync(pathKey);
+        };
+        this.getStats = (name = 'disk-cache') => {
+            const stats = {
+                hits: this.hits,
+                name,
+                total: this.total,
+            };
+            this.hits = 0;
+            this.total = 0;
+            return stats;
+        };
+        this.get = (key) => __awaiter(this, void 0, void 0, function* () {
+            const pathKey = this.getPathKey(key);
+            this.total += 1;
+            const data = yield new Promise(resolve => {
+                this.lock.readLock(key, (release) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const fileData = yield this.readFile(pathKey);
+                        release();
+                        this.hits += 1;
+                        resolve(fileData);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(undefined);
+                    }
+                }));
+            });
+            return data;
+        });
+        this.set = (key, value) => __awaiter(this, void 0, void 0, function* () {
+            const pathKey = this.getPathKey(key);
+            const failure = yield new Promise(resolve => {
+                this.lock.writeLock(key, (release) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const writePromise = yield this.writeFile(pathKey, value);
+                        release();
+                        resolve(writePromise);
+                    }
+                    catch (e) {
+                        release();
+                        resolve(true);
+                    }
+                }));
+            });
+            return !failure;
+        });
+        this.getPathKey = (key) => path_1.join(this.cachePath, key);
+        this.lock = new ReadWriteLock();
+    }
+}
+exports.DiskCache = DiskCache;

package/lib/caches/LRUCache.d.ts

@@ -0,0 +1,16 @@
+import * as LRU from 'lru-cache';
+import { CacheLayer } from './CacheLayer';
+import { FetchResult, LRUStats } from './typings';
+export declare class LRUCache<K, V> implements CacheLayer<K, V> {
+    private multilayer;
+    private storage;
+    private hits;
+    private total;
+    private disposed;
+    constructor(options: LRU.Options);
+    get: (key: K) => void | V;
+    getOrSet: (key: K, fetcher?: (() => Promise<FetchResult<V>>) | undefined) => Promise<void | V>;
+    set: (key: K, value: V, maxAge?: number | undefined) => boolean;
+    has: (key: K) => boolean;
+    getStats: (name?: string) => LRUStats;
+}

package/lib/caches/LRUCache.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LRU = require("lru-cache");
+const MultilayeredCache_1 = require("./MultilayeredCache");
+class LRUCache {
+    constructor(options) {
+        this.get = (key) => {
+            const value = this.storage.get(key);
+            if (this.storage.has(key)) {
+                this.hits += 1;
+            }
+            this.total += 1;
+            return value;
+        };
+        this.getOrSet = (key, fetcher) => __awaiter(this, void 0, void 0, function* () { return this.multilayer.get(key, fetcher); });
+        this.set = (key, value, maxAge) => this.storage.set(key, value, maxAge);
+        this.has = (key) => this.storage.has(key);
+        this.getStats = (name = 'lru-cache') => {
+            const stats = {
+                disposedItems: this.disposed,
+                hitRate: this.total > 0 ? this.hits / this.total : undefined,
+                hits: this.hits,
+                itemCount: this.storage.itemCount,
+                length: this.storage.length,
+                max: this.storage.max,
+                name,
+                total: this.total,
+            };
+            this.hits = 0;
+            this.total = 0;
+            this.disposed = 0;
+            return stats;
+        };
+        this.hits = 0;
+        this.total = 0;
+        this.disposed = 0;
+        this.storage = new LRU(Object.assign({}, options, { dispose: () => this.disposed += 1 }));
+        this.multilayer = new MultilayeredCache_1.MultilayeredCache([this]);
+    }
+}
+exports.LRUCache = LRUCache;