feat(falcor): add idempotent book operations

closes #9

Author: itsjgf

package.json

@@ -33,7 +33,6 @@
   },
   "homepage": "https://github.com/StoryShop/api#readme",
   "dependencies": {
-    "@reactivex/rxjs": "^5.0.0-beta.12",
     "aws-sdk": "^2.2.41",
     "babel-preset-es2015": "^6.5.0",
     "babel-preset-stage-0": "^6.5.0",
@@ -52,7 +51,9 @@
     "multiparty": "^4.1.2",
     "neo4j-driver": "^1.0.4",
     "opml-generator": "^1.1.1",
+    "rx": "^4.1.0",
     "shortid": "^2.2.4",
+    "slug": "^0.9.1",
     "uservoice-sso": "^0.1.0"
   },
   "devDependencies": {

src/db.js

@@ -19,13 +19,7 @@ export default ({ mongodb, neo4j }) => {
         }
 
         // convert the neo4j run function's Result into an Observable.
-        return new Observable( sub => {
-          this.session.run( ...args ).subscribe({
-            onNext: ( ...args ) => sub.next( ...args ),
-            onError: ( ...args ) => sub.error( ...args ),
-            onCompleted: ( ...args ) => sub.completed( ...args ),
-          });
-        });
+        return Observable.create( sub => this.session.run( ...args ).subscribe( sub ) );
       },
 
       close ( ...args ) {

src/falcor/books/index.js

@@ -0,0 +1,70 @@
+import { Observable } from 'rx';
+import { keys, $ref } from '../../utils';
+import {
+  getBooks,
+  setBookProps,
+  getWorldByBook
+} from '../transforms/books'
+import slug from 'slug'
+
+
+export default ( db, req, res ) => {
+  const {user} = req;
+  return [
+    {
+      route: 'booksById[{keys:ids}]["_id", "title", "slug"]',
+      get: ({ids})=> {
+        return db
+          ::getBooks(ids,user._id)
+          .flatMap(book =>
+            [
+              {path: ["booksById", book._id, "_id"], value: book._id},
+              {path: ["booksById", book._id, "title"], value: book.title},
+              {path: ["booksById", book._id, "slug"], value: slug(book.title,{lower: true})},
+            ]
+          )
+      }
+    },
+    {
+      route: 'booksById[{keys:ids}]["title"]',
+      set: pathSet => {
+        return db
+          ::setBookProps( pathSet.booksById, user )
+          .flatMap(book => {
+            return [
+              {path: ["booksById", book._id, "title"], value: book.title},
+              {path: ["booksById", book._id, "slug"], value: slug(book.title,{lower: true})},
+            ]
+          })
+      }
+    },
+    {
+      route: 'booksById[{keys:ids}].world',
+      get: pathSet => {
+        const {ids} = pathSet;
+        return db
+          ::getBooks(ids,user._id)
+          .flatMap(book =>
+            db::getWorldByBook(book._id)
+              .map((worldId) =>
+                [
+                  {path: ["booksById", book._id, "world",], value: $ref(['worldsById', worldId])},
+                ]
+              )
+          )
+      }
+    },
+    {
+      route: 'booksById[{keys:ids}].status',
+      get: pathSet => {
+        const {ids} = pathSet;
+        ids.map(id => {
+          return [
+            {path: ["booksById", id, "status"], value: 0},
+          ]
+        })
+      }
+    },
+
+  ]
+}

src/falcor/index.js

@@ -5,6 +5,7 @@ import users from './users';
 import characters from './characters';
 import outlines from './outlines';
 import elements from './elements';
+import books from './books'
 
 export default db => falcorExpress.dataSourceRoute( ( req, res ) => new Router(
   []
@@ -13,5 +14,6 @@ export default db => falcorExpress.dataSourceRoute( ( req, res ) => new Router(
     .concat( characters( db, req, res ) )
     .concat( outlines( db, req, res ) )
     .concat( elements( db, req, res ) )
+    .concat( books( db, req, res ) )
 ));
 

src/falcor/transforms/books.js

@@ -0,0 +1,83 @@
+import {Observable} from 'rx';
+import {
+  keysO,
+} from '../../utils';
+
+import {accessControl} from './index'
+
+
+export function getBooks(ids, userId, secure) {
+  return this.flatMap(db =>
+    Observable.from(ids)
+      .flatMap(id =>
+        this::permissionBook(id, userId, secure)
+          .map(permission => {
+            if (permission === false)
+              throw new Error("Not authorized");
+            return id;
+          })
+      )
+      .toArray()
+      .flatMap(ids => {
+          return db.mongo.collection('books').find({_id: {$in: ids}}).toArray()
+        }
+      )
+      .flatMap(normalize => normalize)
+  )
+}
+
+export function setBookProps(propsById) {
+  return this.flatMap(db => {
+    return keysO(propsById)
+      .flatMap(_id => {
+        return db.mongo.collection('books').findOneAndUpdate({_id}, {$set: propsById[_id]}, {
+          returnOriginal: false,
+        });
+      })
+      .map(book => book.value)
+      ;
+  });
+}
+
+
+export function getBooksLength(worldID) {
+  const query = `
+    match (b:Book)-[rel:IN]->(w:World)
+    WHERE rel.archived = false and w._id = {worldID}
+    return count(b) as count
+  `;
+  return this.flatMap(db =>db.neo.run(query, {worldID}))
+    .map(record =>
+      record.get('count').toNumber()
+    )
+}
+
+export function getWorldByBook(bookId) {
+  const query = `
+    match (b:Book)-[rel:IN]->(w:World)
+    WHERE rel.archived = false and b._id = "${bookId}"
+    return w._id as id
+  `;
+  return this.flatMap(db => db.neo.run(query))
+    .map(record =>
+      record.get('id')
+    )
+}
+
+
+export function permissionBook(bookId, userId, write) {
+
+  const permissions = accessControl(write);
+
+  const query = `
+    MATCH (b:Book)-[r:IN]->(w:World)<-[rel]-(u:User)
+    WHERE b._id = {bookId} AND u._id ={userId} 
+    AND (${permissions})
+    return count(rel) > 0 as permission
+  `;
+
+  return this.flatMap(db => db.neo.run(query, {bookId, userId}))
+    .map(record =>
+      record.get('permission')
+    )
+}

src/falcor/transforms/books.spec.js

@@ -0,0 +1,181 @@
+import test from 'tape';
+import {Observable} from 'rx';
+import database from '../../db';
+import {
+  getBooks,
+  getBooksLength,
+  permissionBook
+} from './books'
+
+const dbconf = {
+  mongodb: {
+    uri: process.env.MONGO_URI || 'mongodb://localhost:27017/dev',
+  },
+
+  neo4j: {
+    uri: process.env.NEO_URI || 'bolt://localhost',
+  },
+};
+
+const populate = `
+  CREATE (reader:User {  _id:"testUser1" }) 
+  CREATE (user:User {  _id:"testUser" }) 
+  CREATE (world:World {_id: "testWorld"})<-[:OWNER {archived: false}]-(user) 
+  CREATE (world)<-[:READER {archived: false}]-(reader) 
+  CREATE (:Book {_id : "testBook"})-[:IN {archived: false}]->(world) 
+  CREATE (:Book {_id: "testBook1" })-[:IN {archived: false}]->(world)
+  CREATE (:Book {_id: "testBookAlone"})
+  return user
+  `;
+const remove = `
+    MATCH (n)
+    OPTIONAL MATCH (n)-[r]-()
+    WITH n,r LIMIT 50000
+    WHERE n._id =~ ".*test.*"
+    DELETE n,r
+    RETURN count(n) as deletedNodesCount
+  `;
+
+const books = [
+  {_id: 'testBook', title: 'Book for test'},
+  {_id: 'testBook1', title: 'Book for test2'},
+];
+
+const bookIds = books.map(book => book._id);
+
+test('permissionBook', t => {
+  const db = database(dbconf);
+  let neo, mongo, actual, expected;
+  let book = 'testBook';
+  let owner = 'testUser';
+  let reader = 'testUser1'
+
+  db
+    .map(db => {
+      neo = db.neo;
+      mongo = db.mongo;
+      return neo;
+    })
+    .flatMap(neo =>
+      neo.run(populate)
+    )
+    .flatMap(neo =>
+      db::permissionBook(book, owner)
+    )
+    .flatMap(permission => {
+
+      actual = permission;
+      expected = true;
+      t.equals(actual, expected, "should have permission to read the book");
+
+
+      return db::permissionBook(book, owner, true)
+    })
+    .flatMap(permission => {
+
+      actual = permission;
+      expected = true;
+      t.equals(actual, expected, "should have permission to modify the book");
+
+      return db::permissionBook(book, reader, true)
+    })
+    .flatMap(permission => {
+
+      actual = permission;
+      expected = false;
+      t.equals(actual, expected, "should not have permission to modify the book");
+
+      return neo.run(remove);
+    })
+    .subscribe(() => {
+      mongo.close().then(() => neo.close(() => neo.disconnect()));
+      t.end();
+    })
+});
+
+test('getBooks', t => {
+  const db = database(dbconf);
+  let neo, mongo, actual, expected;
+  let booksToFind = ["testBook", "testBook1"];
+  let userId = 'testUser';
+  db
+    .map(db => {
+      neo = db.neo;
+      mongo = db.mongo;
+      return neo;
+    })
+    .flatMap(neo =>
+      neo.run(populate)
+    )
+    .flatMap(() =>
+      mongo.collection('books').insertMany(books)
+    )
+    .flatMap(neo =>
+      db::getBooks(booksToFind, userId)
+    )
+    .flatMap((book) => {
+
+      actual = bookIds.find(id => book._id) != null;
+      expected = true;
+      t.equals(actual, expected, 'should match one of the ids that has been passed to getBooks');
+
+      return neo.run(remove)
+    })
+
+    .flatMap(() => {
+      //t.throws(() => db::getBooks(['invalidID'], userId), 'should throw an exception');
+      return mongo.collection('books').removeMany({_id: {$in: bookIds}})
+    })
+    .subscribe(
+      () => {
+        mongo.close().then(() => neo.close(() => neo.disconnect()));
+        t.end();
+      },
+      error => {
+        mongo.close().then(() => neo.close(() => neo.disconnect()));
+      }
+    )
+});
+
+
+test('getBooksLength', t => {
+  const db = database(dbconf);
+  let neo, mongo, actual, expected;
+
+  db
+    .map(db => {
+      neo = db.neo;
+      mongo = db.mongo;
+      return neo;
+    })
+    .flatMap(neo =>
+      neo.run(populate)
+    )
+    .flatMap(() =>
+      db::getBooksLength('testWorld')
+    )
+    .flatMap(length => {
+
+      actual = length;
+      expected = 2;
+      t.equals(actual, expected, "should match the number of books the world has");
+
+      return neo.run(remove);
+    })
+    .flatMap(() =>
+      db::getBooksLength('invalidWorld')
+    )
+    .flatMap(length => {
+
+      actual = length;
+      expected = 0;
+      t.equals(actual, expected, "should not have any book when the world is not valid");
+
+      return neo.run(remove);
+    })
+    .subscribe(() => {
+      mongo.close().then(() => neo.close(() => neo.disconnect()));
+      t.end();
+    })
+});
+