feat(fs-storage): add fs storage as separate package (#19)

Author: Viatorus

CONTRIBUTING.md

@@ -138,6 +138,7 @@ The following is the list of supported scopes:
 * **loki**: The LokiJS database.
 * **partitioning-adapter**: The partitioning adapter.
 * **local-storage**: The local storage adapter.
+* **fs-storage**: The file system storage adapter.
 * **fts**: A full text search for the database.
 
 There are currently a few exceptions to the "use package name" rule:

config/build.js

@@ -10,7 +10,8 @@ const conventionalChangelog = require("conventional-changelog");
 const PACKAGES = [
   "loki",
   "partitioning-adapter",
-  "local-storage"
+  "local-storage",
+  "fs-storage"
 ];
 
 const ROOT_DIR = process.cwd();

packages/fs-storage/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@lokijs/fs-storage",
+  "description": "A persistence adapter which persists to node fs module storage.",
+  "author": "Various authors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LokiJS-Forge/LokiJS2.git"
+  },
+  "main": "lokijs.fs-storage.js",
+  "dependencies": {
+    "@lokijs/loki": "0"
+  }
+}

packages/fs-storage/spec/node/fs-adapter.spec.js

@@ -0,0 +1,51 @@
+/* global describe, it, expect */
+import {Loki} from "../../../loki/src/loki";
+import {LokiFSStorage} from "../../src/fs_storage";
+
+describe("testing persistence adapter", function () {
+  it("LokiFSStorage", function (done) {
+    const db = new Loki("myTestApp");
+
+    const adapter = {adapter: new LokiFSStorage()};
+    db.initializePersistence(adapter)
+      .then(() => {
+        db.addCollection("myColl").insert({name: "Hello World"});
+        return db.saveDatabase().then(() => {
+          const db2 = new Loki("myTestApp");
+          return db2.initializePersistence(adapter)
+            .then(() => {
+              return db2.loadDatabase()
+                .then(() => {
+                  expect(db2.getCollection("myColl").find()[0].name).toEqual("Hello World");
+                });
+            });
+        });
+      })
+      .then(() => {
+        const db3 = new Loki("other");
+        return db3.initializePersistence(adapter)
+          .then(() => {
+            return db3.loadDatabase()
+              .then(() => {
+                expect(false).toEqual(true);
+              }, () => {
+                expect(true).toEqual(true);
+              });
+          });
+      })
+      .then(() => {
+        return db.deleteDatabase();
+      })
+      .then(() => {
+        return db.loadDatabase()
+          .then(() => {
+            expect(db.getCollection("myColl").find()[0].name).toEqual("Hello World");
+            expect(false).toEqual(true);
+            done();
+          }, () => {
+            expect(true).toEqual(true);
+            done();
+          });
+      });
+  });
+});

packages/fs-storage/src/fs_storage.js

@@ -0,0 +1,83 @@
+import {Loki} from "../../loki/src/loki";
+import fs from "fs";
+
+/**
+ * A loki persistence adapter which persists using node fs module.
+ */
+export class LokiFSStorage {
+  /**
+   * loadDatabase() - Load data from file, will throw an error if the file does not exist
+   * @param {string} dbname - the filename of the database to load
+   * @returns {Promise} a Promise that resolves after the database was loaded
+   * @memberof LokiFsAdapter
+   */
+  loadDatabase(dbname) {
+    return new Promise((resolve, reject) => {
+      fs.stat(dbname, (err, stats) => {
+        if (!err && stats.isFile()) {
+          fs.readFile(dbname, {
+            encoding: "utf8"
+          }, function readFileCallback(err, data) {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(data);
+            }
+          });
+        } else {
+          reject();
+        }
+      });
+    });
+  }
+
+  /**
+   * saveDatabase() - save data to file, will throw an error if the file can't be saved
+   * might want to expand this to avoid dataloss on partial save
+   * @param {string} dbname - the filename of the database to load
+   * @returns {Promise} a Promise that resolves after the database was persisted
+   * @memberof LokiFsAdapter
+   */
+  saveDatabase(dbname, dbstring) {
+    const tmpdbname = dbname + "~";
+
+    return new Promise((resolve, reject) => {
+      fs.writeFile(tmpdbname, dbstring, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          fs.rename(tmpdbname, dbname, (err) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve();
+            }
+          });
+        }
+      });
+    });
+  }
+
+  /**
+   * deleteDatabase() - delete the database file, will throw an error if the
+   * file can't be deleted
+   * @param {string} dbname - the filename of the database to delete
+   * @returns {Promise} a Promise that resolves after the database was deleted
+   * @memberof LokiFsAdapter
+   */
+  deleteDatabase(dbname) {
+    return new Promise((resolve, reject) => {
+      fs.unlink(dbname, function deleteDatabaseCallback(err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+Loki.LokiFSStorage = LokiFSStorage;
+
+export default LokiFSStorage;

packages/fs-storage/webpack.config.js

@@ -0,0 +1,29 @@
+/* global __dirname, module, require */
+const path = require("path");
+
+module.exports = {
+  devtool: "source-map",
+  entry: path.join(__dirname, "src", "fs_storage.js"),
+  output: {
+    filename: "lokijs.fs-storage.js",
+    library: "@lokijs/fs-storage",
+    libraryTarget: "umd2",
+    umdNamedDefine: false
+  },
+  externals: {
+    "../../loki/src/loki": "@lokijs/loki",
+    "fs": "fs"
+  },
+  module: {
+    loaders: [
+      {
+        test: /(\.js)$/,
+        loader: "eslint-loader",
+        exclude: /(node_modules|bower_components)/,
+        options: {
+          configFile: path.join("config", "eslintrc.js")
+        }
+      }
+    ]
+  }
+};