lowdb-node/lib/index.cjs.js

Tiny local JSON database for Node, Electron and the browser

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var fs = require('fs');
var path = require('path');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __classPrivateFieldGet$1(receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}

function __classPrivateFieldSet$1(receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}

var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Writer_instances, _Writer_filename, _Writer_tempFilename, _Writer_locked, _Writer_prev, _Writer_next, _Writer_nextPromise, _Writer_nextData, _Writer_add, _Writer_write;
// Returns a temporary file
// Example: for /some/file will return /some/.file.tmp
function getTempFilename(file) {
    return path__default["default"].join(path__default["default"].dirname(file), '.' + path__default["default"].basename(file) + '.tmp');
}
class Writer {
    constructor(filename) {
        _Writer_instances.add(this);
        _Writer_filename.set(this, void 0);
        _Writer_tempFilename.set(this, void 0);
        _Writer_locked.set(this, false);
        _Writer_prev.set(this, null);
        _Writer_next.set(this, null);
        _Writer_nextPromise.set(this, null);
        _Writer_nextData.set(this, null
        // File is locked, add data for later
        );
        __classPrivateFieldSet(this, _Writer_filename, filename, "f");
        __classPrivateFieldSet(this, _Writer_tempFilename, getTempFilename(filename), "f");
    }
    async write(data) {
        return __classPrivateFieldGet(this, _Writer_locked, "f") ? __classPrivateFieldGet(this, _Writer_instances, "m", _Writer_add).call(this, data) : __classPrivateFieldGet(this, _Writer_instances, "m", _Writer_write).call(this, data);
    }
}
_Writer_filename = new WeakMap(), _Writer_tempFilename = new WeakMap(), _Writer_locked = new WeakMap(), _Writer_prev = new WeakMap(), _Writer_next = new WeakMap(), _Writer_nextPromise = new WeakMap(), _Writer_nextData = new WeakMap(), _Writer_instances = new WeakSet(), _Writer_add = function _Writer_add(data) {
    // Only keep most recent data
    __classPrivateFieldSet(this, _Writer_nextData, data, "f");
    // Create a singleton promise to resolve all next promises once next data is written
    __classPrivateFieldSet(this, _Writer_nextPromise, __classPrivateFieldGet(this, _Writer_nextPromise, "f") || new Promise((resolve, reject) => {
        __classPrivateFieldSet(this, _Writer_next, [resolve, reject], "f");
    }), "f");
    // Return a promise that will resolve at the same time as next promise
    return new Promise((resolve, reject) => {
        var _a;
        (_a = __classPrivateFieldGet(this, _Writer_nextPromise, "f")) === null || _a === void 0 ? void 0 : _a.then(resolve).catch(reject);
    });
}, _Writer_write = 
// File isn't locked, write data
async function _Writer_write(data) {
    var _a, _b;
    // Lock file
    __classPrivateFieldSet(this, _Writer_locked, true, "f");
    try {
        // Atomic write
        await fs__default["default"].promises.writeFile(__classPrivateFieldGet(this, _Writer_tempFilename, "f"), data, 'utf-8');
        await fs__default["default"].promises.rename(__classPrivateFieldGet(this, _Writer_tempFilename, "f"), __classPrivateFieldGet(this, _Writer_filename, "f"));
        // Call resolve
        (_a = __classPrivateFieldGet(this, _Writer_prev, "f")) === null || _a === void 0 ? void 0 : _a[0]();
    }
    catch (err) {
        // Call reject
        (_b = __classPrivateFieldGet(this, _Writer_prev, "f")) === null || _b === void 0 ? void 0 : _b[1](err);
        throw err;
    }
    finally {
        // Unlock file
        __classPrivateFieldSet(this, _Writer_locked, false, "f");
        __classPrivateFieldSet(this, _Writer_prev, __classPrivateFieldGet(this, _Writer_next, "f"), "f");
        __classPrivateFieldSet(this, _Writer_next, __classPrivateFieldSet(this, _Writer_nextPromise, null, "f"), "f");
        if (__classPrivateFieldGet(this, _Writer_nextData, "f") !== null) {
            const nextData = __classPrivateFieldGet(this, _Writer_nextData, "f");
            __classPrivateFieldSet(this, _Writer_nextData, null, "f");
            await this.write(nextData);
        }
    }
};

var _TextFile_filename, _TextFile_writer;
class TextFile {
    constructor(filename) {
        _TextFile_filename.set(this, void 0);
        _TextFile_writer.set(this, void 0);
        __classPrivateFieldSet$1(this, _TextFile_filename, filename, "f");
        __classPrivateFieldSet$1(this, _TextFile_writer, new Writer(filename), "f");
    }
    async read() {
        let data;
        try {
            data = await fs__default["default"].promises.readFile(__classPrivateFieldGet$1(this, _TextFile_filename, "f"), 'utf-8');
        }
        catch (e) {
            if (e.code === 'ENOENT') {
                return null;
            }
            throw e;
        }
        return data;
    }
    write(str) {
        return __classPrivateFieldGet$1(this, _TextFile_writer, "f").write(str);
    }
}
_TextFile_filename = new WeakMap(), _TextFile_writer = new WeakMap();

var _JSONFile_adapter;
class JSONFile {
    constructor(filename) {
        _JSONFile_adapter.set(this, void 0);
        __classPrivateFieldSet$1(this, _JSONFile_adapter, new TextFile(filename), "f");
    }
    async read() {
        const data = await __classPrivateFieldGet$1(this, _JSONFile_adapter, "f").read();
        if (data === null) {
            return null;
        }
        else {
            return JSON.parse(data);
        }
    }
    write(obj) {
        return __classPrivateFieldGet$1(this, _JSONFile_adapter, "f").write(JSON.stringify(obj, null, 2));
    }
}
_JSONFile_adapter = new WeakMap();

var _TextFileSync_tempFilename, _TextFileSync_filename;
class TextFileSync {
    constructor(filename) {
        _TextFileSync_tempFilename.set(this, void 0);
        _TextFileSync_filename.set(this, void 0);
        __classPrivateFieldSet$1(this, _TextFileSync_filename, filename, "f");
        __classPrivateFieldSet$1(this, _TextFileSync_tempFilename, path__default["default"].join(path__default["default"].dirname(filename), `.${path__default["default"].basename(filename)}.tmp`), "f");
    }
    read() {
        let data;
        try {
            data = fs__default["default"].readFileSync(__classPrivateFieldGet$1(this, _TextFileSync_filename, "f"), 'utf-8');
        }
        catch (e) {
            if (e.code === 'ENOENT') {
                return null;
            }
            throw e;
        }
        return data;
    }
    write(str) {
        fs__default["default"].writeFileSync(__classPrivateFieldGet$1(this, _TextFileSync_tempFilename, "f"), str);
        fs__default["default"].renameSync(__classPrivateFieldGet$1(this, _TextFileSync_tempFilename, "f"), __classPrivateFieldGet$1(this, _TextFileSync_filename, "f"));
    }
}
_TextFileSync_tempFilename = new WeakMap(), _TextFileSync_filename = new WeakMap();

var _JSONFileSync_adapter;
class JSONFileSync {
    constructor(filename) {
        _JSONFileSync_adapter.set(this, void 0);
        __classPrivateFieldSet$1(this, _JSONFileSync_adapter, new TextFileSync(filename), "f");
    }
    read() {
        const data = __classPrivateFieldGet$1(this, _JSONFileSync_adapter, "f").read();
        if (data === null) {
            return null;
        }
        else {
            return JSON.parse(data);
        }
    }
    write(obj) {
        __classPrivateFieldGet$1(this, _JSONFileSync_adapter, "f").write(JSON.stringify(obj, null, 2));
    }
}
_JSONFileSync_adapter = new WeakMap();

var _LocalStorage_key;
class LocalStorage {
    constructor(key) {
        _LocalStorage_key.set(this, void 0);
        __classPrivateFieldSet$1(this, _LocalStorage_key, key, "f");
    }
    read() {
        const value = localStorage.getItem(__classPrivateFieldGet$1(this, _LocalStorage_key, "f"));
        if (value === null) {
            return null;
        }
        return JSON.parse(value);
    }
    write(obj) {
        localStorage.setItem(__classPrivateFieldGet$1(this, _LocalStorage_key, "f"), JSON.stringify(obj));
    }
}
_LocalStorage_key = new WeakMap();

var _Memory_data;
class Memory {
    constructor() {
        _Memory_data.set(this, null);
    }
    read() {
        return Promise.resolve(__classPrivateFieldGet$1(this, _Memory_data, "f"));
    }
    write(obj) {
        __classPrivateFieldSet$1(this, _Memory_data, obj, "f");
        return Promise.resolve();
    }
}
_Memory_data = new WeakMap();

var _MemorySync_data;
class MemorySync {
    constructor() {
        _MemorySync_data.set(this, null);
    }
    read() {
        return __classPrivateFieldGet$1(this, _MemorySync_data, "f") || null;
    }
    write(obj) {
        __classPrivateFieldSet$1(this, _MemorySync_data, obj, "f");
    }
}
_MemorySync_data = new WeakMap();

class MissingAdapterError extends Error {
    constructor() {
        super();
        this.message = 'Missing Adapter';
    }
}

class Low {
    constructor(adapter) {
        Object.defineProperty(this, "adapter", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: null
        });
        if (adapter) {
            this.adapter = adapter;
        }
        else {
            throw new MissingAdapterError();
        }
    }
    async read() {
        this.data = await this.adapter.read();
    }
    async write() {
        if (this.data) {
            await this.adapter.write(this.data);
        }
    }
}

class LowSync {
    constructor(adapter) {
        Object.defineProperty(this, "adapter", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        Object.defineProperty(this, "data", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: null
        });
        if (adapter) {
            this.adapter = adapter;
        }
        else {
            throw new MissingAdapterError();
        }
    }
    read() {
        this.data = this.adapter.read();
    }
    write() {
        if (this.data !== null) {
            this.adapter.write(this.data);
        }
    }
}

exports.JSONFile = JSONFile;
exports.JSONFileSync = JSONFileSync;
exports.LocalStorage = LocalStorage;
exports.Low = Low;
exports.LowSync = LowSync;
exports.Memory = Memory;
exports.MemorySync = MemorySync;
exports.TextFile = TextFile;
exports.TextFileSync = TextFileSync;