@conversationlearner/sdk/lib/FileStorage.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const path = require("path");
const fs = require("async-file");
const file = require("fs");
const filenamify = require("filenamify");
/**
 * :package: **botbuilder**
 *
 * A file based storage provider. Items will be persisted to a folder on disk.
 *
 * **Usage Example**
 *
 * ```JavaScript
 * const { FileStorage } = require('botbuilder');
 * const path = require('path');
 *
 * const storage = new FileStorage(path.join(__dirname, './state'));
 * ```
 */
class FileStorage {
    /**
     * Creates a new FileStorage instance.
     * @param path Root filesystem path for where the provider should store its items.
     */
    constructor(filePath) {
        this.path = filePath;
    }
    read(keys) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            yield this.ensureFolder();
            const data = {};
            const promises = keys.map(key => {
                const filePath = this.getFilePath(key);
                return parseFile(filePath)
                    .then((obj) => {
                    if (obj) {
                        data[key] = obj;
                    }
                });
            });
            yield Promise.all(promises);
            return data;
        });
    }
    write(changes) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            yield this.ensureFolder();
            const promises = Object.keys(changes).map(key => {
                const filePath = this.getFilePath(key);
                return fs.exists(filePath)
                    .then((exists) => {
                    const newObj = Object.assign({}, changes[key]);
                    newObj.eTag = (parseInt(newObj.eTag || '0', 10) + 1).toString();
                    return fs.writeTextFile(filePath, JSON.stringify(newObj));
                });
            });
            yield Promise.all(promises);
        });
    }
    delete(keys) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            yield this.ensureFolder();
            const promises = keys.map(key => {
                const filePath = this.getFilePath(key);
                return fs.exists(filePath)
                    .then((exists) => {
                    if (exists) {
                        file.unlinkSync(filePath);
                    }
                });
            });
            yield Promise.all(promises);
        });
    }
    ensureFolder() {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            if (this.pEnsureFolder) {
                return this.pEnsureFolder;
            }
            const exists = yield fs.exists(this.path);
            if (!exists) {
                this.pEnsureFolder = fs.mkdirp(this.path);
            }
        });
    }
    getFileName(key) {
        return filenamify(key);
    }
    getFilePath(key) {
        return path.join(this.path, this.getFileName(key));
    }
}
FileStorage.nextTag = 0;
exports.FileStorage = FileStorage;
function parseFile(filePath) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        try {
            const exists = yield fs.exists(filePath);
            const data = yield (exists
                ? fs.readTextFile(filePath)
                : Promise.resolve(undefined));
            try {
                if (data) {
                    return JSON.parse(data);
                }
            }
            catch (err) {
                console.warn(`FileStorage: error parsing "${filePath}": ${err.toString()}`);
            }
            return undefined;
        }
        catch (error) {
            // File could legitimately have been deleted
            if (error.code != "ENOENT") {
                console.warn(`FileStorage: error reading "${filePath}": ${error.toString()}`);
            }
            return undefined;
        }
    });
}
//# sourceMappingURL=FileStorage.js.map