@jnode/db 1.0.0

package/src/index.js

@@ -0,0 +1,14 @@
+/*
+@jnode/db
+
+Simple database package for Node.js.
+
+by JustApple
+*/
+
+// export
+module.exports = {
+    jdb: require('./jdb.js'),
+    dble: require('./dble.js'),
+    ljson: require('./ljson.js')
+}

package/src/jdb.js

@@ -0,0 +1,81 @@
+/*
+@jnode/db/jdb.js
+
+Simple database package for Node.js.
+
+JDB (.jdb) is the format of all the database files.
+
+by JustApple
+*/
+
+// dependencies
+const fs = require('fs/promises');
+
+// base jdb file manager
+class JDBFile {
+    constructor(handle) {
+        this.handle = handle;
+    }
+
+    static async load(path) {
+        const jdb = new JDBFile(await fs.open(path, 'r+'));
+        await jdb._loadHead();
+
+        return jdb;
+    }
+
+    static async create(path, options = {}) {
+        const jdb = new JDBFile(await fs.open(path, 'wx+'));
+        await jdb._init(options);
+
+        return jdb;
+    }
+
+    static async forceCreate(path, options = {}) {
+        const jdb = new JDBFile(await fs.open(path, 'w+'));
+        await jdb._init(options);
+
+        return jdb;
+    }
+
+    // init the file
+    async _init(options = {}) {
+        const headBuf = Buffer.alloc(16);
+        headBuf.writeUInt32BE(0x4A444244, 0); // magic string
+        headBuf[4] = 1; // jdb file version
+        headBuf.writeUInt32BE(this.dbType = (options.dbType || 0), 8); // db type
+        headBuf[12] = this.dbVersion = (options.dbVersion || 0); // db version
+        await this.handle.write(headBuf, 0, 16, 0);
+    }
+
+    // load and verify the file head
+    async _loadHead() {
+        const headBuf = Buffer.allocUnsafe(16);
+        const { bytesRead } = await this.handle.read(headBuf, 0, 16, 0);
+
+        if (bytesRead !== 16) throw new Error('JDB: File length not enough to be a JDB file.'); // basic length check
+        if (headBuf.readUInt32BE(0) !== 0x4A444244) throw new Error('JDB: Magic string doesn\'t match "JDBD".'); // magic string
+        if (headBuf[4] !== 1) throw new Error('JDB: Unsupported JDB file version.'); // file version
+
+        // load db type and version
+        this.dbType = headBuf.readUInt32BE(8);
+        this.dbVersion = headBuf[12];
+    }
+
+    close() {
+        return this.handle.close();
+    }
+
+    sync() {
+        return this.handle.sync();
+    }
+
+    datasync() {
+        return this.handle.datasync();
+    }
+}
+
+// export
+module.exports = {
+    JDBFile
+};

package/src/ljson.js

@@ -0,0 +1,165 @@
+/*
+@jnode/db/ljson.js
+
+Simple database package for Node.js.
+
+LineJSON (LJSON) is a simple new line-splitted JSON array database format with some special features.
+Some place also called this JSONL or NDJSON.
+This format is best for small, append-only data.
+This format follows text-based JLD (JustLineData) format instead of binary-based JDB format.
+
+by JustApple
+*/
+
+// dependencies
+const fs = require('fs/promises');
+
+class LJSONFile {
+    constructor(path, data, options = {}) {
+        this.path = path;
+        this.options = options;
+
+        this._loadData(data);
+    }
+
+    static async forceCreate(file, options) {
+        const data = '@ JLD 01 LJSO 01\n';
+        await fs.writeFile(file, data);
+        return new LJSONFile(file, data, options);
+    }
+
+    static async load(file, options = {}) {
+        let data;
+        try {
+            data = (await fs.readFile(file)).toString('utf8');
+        } catch {
+            data = '@ JLD 01 LJSO 01\n';
+            await fs.writeFile(file, data);
+        }
+
+        // check header
+        if (!data.startsWith('@ JLD 01 LJSO 01\n')) {
+            throw new Error('JDB (LJSON): File header incorrect.')
+        }
+
+        const ljson = new LJSONFile(file, data, options);
+
+        if (!options.disableCleanupOnStart) {
+            await ljson.cleanUp();
+        }
+
+        return ljson;
+    }
+
+    _loadData(data) {
+        const lines = data.split('\n');
+        this.lines = [];
+        this._requireCleanup = false;
+
+        for (let i of lines) {
+            if (i.startsWith('@')) continue; // header line
+            else if (i.startsWith('//')) this._requireCleanup = true; // comment line
+            else if (i === '') this._requireCleanup = true; // empty line
+            else if (i.startsWith('+ ')) { // update line
+                this._requireCleanup = true;
+                const split = i.indexOf(' ', 2);
+                const index = i.substring(2, split);
+                const json = JSON.parse(i.substring(split));
+
+                // check type
+                const lineType = _typeof(this.lines[index]);
+                if (lineType === _typeof(json)) {
+                    switch (lineType) {
+                        case 'number':
+                        case 'string':
+                            this.lines[index] += json;
+                            break;
+                        case 'boolean':
+                            this.lines[index] = json !== this.lines[index];
+                            break;
+                        case 'array':
+                            this.lines[index].push(...json);
+                            break;
+                        case 'object':
+                            Object.assign(this.lines[index], json);
+                            break;
+                    }
+                }
+            } else if (i.startsWith('= ')) { // overwrite line
+                this._requireCleanup = true;
+                const split = i.indexOf(' ', 2);
+                const index = i.substring(2, split);
+                const json = JSON.parse(i.substring(split));
+
+                this.lines[index] = json;
+            } else if (i.startsWith('- ')) { // delete line
+                this._requireCleanup = true;
+                const index = i.substring(2);
+
+                this.lines.splice(index, 1);
+            } else { // data
+                this.lines.push(JSON.parse(i));
+            }
+        }
+    }
+
+    // clean up the file
+    async cleanUp(force) {
+        if (this._requireCleanup || force) {
+            await fs.writeFile(this.path + '.tmp', '@ JLD 01 LJSO 01\n' + this.lines.map(JSON.stringify).join('\n') + '\n');
+            await fs.rename(this.path + '.tmp', this.path);
+        }
+    }
+
+    update(index, json) {
+        // check type
+        const lineType = _typeof(this.lines[index]);
+        if (lineType === _typeof(json)) {
+            this._requireCleanup = true;
+
+            switch (lineType) {
+                case 'number':
+                case 'string':
+                    this.lines[index] += json;
+                    break;
+                case 'boolean':
+                    this.lines[index] = json !== this.lines[index];
+                    break;
+                case 'array':
+                    this.lines[index].push(...json);
+                    break;
+                case 'object':
+                    Object.assign(this.lines[index], json);
+                    break;
+            }
+
+            return fs.appendFile(this.path, `+ ${index} ${JSON.stringify(json)}\n`);
+        }
+    }
+
+    overwrite(index, json) {
+        this._requireCleanup = true;
+        this.lines[index] = json;
+        return fs.appendFile(this.path, `= ${index} ${JSON.stringify(json)}\n`);
+    }
+
+    delete(index) {
+        this._requireCleanup = true;
+        this.lines.splice(index, 1);
+        return fs.appendFile(this.path, `- ${index}\n`);
+    }
+
+    push(json) {
+        this.lines.push(json);
+        return fs.appendFile(this.path, `${JSON.stringify(json)}\n`);
+    }
+}
+
+// get type with array support
+function _typeof(value) {
+    return Array.isArray(value) ? 'array' : typeof value;
+}
+
+module.exports = {
+    LJSONFile
+};