@varasto/fs-storage/dist/storage.js

Varasto storage implementation that stores data to hard disk

"use strict";
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
    var g = generator.apply(thisArg, _arguments || []), i, q = [];
    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
    function fulfill(value) { resume("next", value); }
    function reject(value) { resume("throw", value); }
    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createFileSystemStorage = void 0;
const storage_1 = require("@varasto/storage");
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const utils_1 = require("./utils");
/**
 * Creates new file system storage with given options.
 */
const createFileSystemStorage = (options = {}) => {
    var _a, _b, _c, _d;
    const dir = (_a = options.dir) !== null && _a !== void 0 ? _a : './data';
    const encoding = (_b = options.encoding) !== null && _b !== void 0 ? _b : 'utf-8';
    const serialize = (_c = options.serialize) !== null && _c !== void 0 ? _c : JSON.stringify;
    const deserialize = (_d = options.deserialize) !== null && _d !== void 0 ? _d : JSON.parse;
    return new (class extends storage_1.Storage {
        has(namespace, key) {
            let filename;
            try {
                filename = (0, utils_1.buildFilename)(dir, namespace, key);
            }
            catch (_a) {
                return Promise.resolve(false);
            }
            return Promise.resolve(fs_1.default.existsSync(filename));
        }
        keys(namespace) {
            return __asyncGenerator(this, arguments, function* keys_1() {
                const matches = yield __await((0, utils_1.globNamespace)(dir, namespace));
                for (const match of matches) {
                    yield yield __await(path_1.default.basename(match, '.json'));
                }
            });
        }
        values(namespace) {
            return __asyncGenerator(this, arguments, function* values_1() {
                const filenames = yield __await((0, utils_1.globNamespace)(dir, namespace));
                for (const filename of filenames) {
                    const value = yield __await((0, utils_1.readItem)(filename, encoding, deserialize));
                    if (value !== undefined) {
                        yield yield __await(value);
                    }
                }
            });
        }
        entries(namespace) {
            return __asyncGenerator(this, arguments, function* entries_1() {
                const filenames = yield __await((0, utils_1.globNamespace)(dir, namespace));
                for (const filename of filenames) {
                    const value = yield __await((0, utils_1.readItem)(filename, encoding, deserialize));
                    if (value !== undefined) {
                        yield yield __await([path_1.default.basename(filename, '.json'), value]);
                    }
                }
            });
        }
        get(namespace, key) {
            let filename;
            try {
                filename = (0, utils_1.buildFilename)(dir, namespace, key);
            }
            catch (err) {
                return Promise.reject(err);
            }
            return (0, utils_1.readItem)(filename, encoding, deserialize);
        }
        set(namespace, key, value) {
            return (0, utils_1.createNamespace)(dir, namespace).then(() => new Promise((resolve, reject) => {
                let filename;
                try {
                    filename = (0, utils_1.buildFilename)(dir, namespace, key);
                }
                catch (err) {
                    reject(err);
                    return;
                }
                fs_1.default.writeFile(filename, serialize(value), encoding, (err) => {
                    if (err) {
                        reject(err);
                    }
                    else {
                        resolve();
                    }
                });
            }));
        }
        update(namespace, key, value) {
            let filename;
            try {
                filename = (0, utils_1.buildFilename)(dir, namespace, key);
            }
            catch (err) {
                return Promise.reject(err);
            }
            return (0, utils_1.readItem)(filename, encoding, deserialize).then((oldValue) => {
                if (oldValue !== undefined) {
                    const newValue = Object.assign(Object.assign({}, oldValue), value);
                    return new Promise((resolve, reject) => {
                        fs_1.default.writeFile(filename, serialize(newValue), encoding, (err) => {
                            if (err) {
                                reject(err);
                            }
                            else {
                                resolve(newValue);
                            }
                        });
                    });
                }
                return Promise.reject(new storage_1.ItemDoesNotExistError('Item does not exist'));
            });
        }
        delete(namespace, key) {
            return new Promise((resolve, reject) => {
                let filename;
                try {
                    filename = (0, utils_1.buildFilename)(dir, namespace, key);
                }
                catch (err) {
                    reject(err);
                    return;
                }
                fs_1.default.unlink(filename, (err) => {
                    if (err) {
                        if (err.code === 'ENOENT') {
                            resolve(false);
                        }
                        else {
                            reject(err);
                        }
                    }
                    else {
                        resolve(true);
                    }
                });
            });
        }
    })();
};
exports.createFileSystemStorage = createFileSystemStorage;