Removed node.close and added serialize and deserialize

Author: Josema

README.md

@@ -14,44 +14,11 @@
 
 </div>
 
-Distributed Object Protocol is a thin layer on top of your data network that helps you communicate server and clients (nodes) using [RPCs](https://en.wikipedia.org/wiki/Remote_procedure_call). It is also a pattern that makes easy update, mutate or even sync the state of your App using [Patches](https://github.com/DistributedObjectProtocol/protocol#Patches).
-
-## Quick example using RPCs with WebSockets
-
-```js
-// Server (node.js)
-const { createNode } = require('dop')
-const WebSocket = require('ws')
-const wss = new WebSocket.Server({ port: 8080 })
-
-const sum = (a, b) => a + b
-const multiply = (a, b) => a * b
-const getCalculator = () => ({ sum, multiply })
-
-wss.on('connection', ws => {
-    const client = createNode()
-    client.open(msg => ws.send(JSON.stringify(msg)), getCalculator)
-    ws.on('message', msg => client.message(JSON.parse(msg)))
-    ws.on('close', client.close)
-})
-```
-
-```js
-// Client (Browser)
-import { createNode } from 'dop'
-const ws = new WebSocket('ws://localhost:8080')
-const server = createNode()
-
-ws.onopen = async () => {
-    const getCalculator = server.open(msg => ws.send(JSON.stringify(msg)))
-    const { sum, multiply } = await getCalculator()
-    const result1 = await sum(5, 5)
-    const result2 = await multiply(5, 5)
-    console.log(result1, result2) // 10, 25
-}
-ws.onmessage = msg => server.message(JSON.parse(msg.data))
-ws.onclose = server.close
-```
+**Distributed Object Protocol** is a thin layer on top of your data network that helps you communicate server and clients (nodes) using [RPCs](https://en.wikipedia.org/wiki/Remote_procedure_call). It is also a pattern that makes easy update, mutate or even sync the state of your App using [Patches](https://github.com/DistributedObjectProtocol/protocol#Patches).
+
+## RPCs with WebSockets
+
+image
 
 Check the website for more info [https://distributedobjectprotocol.org/](https://distributedobjectprotocol.org/guide/javascript)
 

package.json

@@ -1,6 +1,6 @@
 {
     "name": "dop",
-    "version": "1.0.0-beta.5",
+    "version": "1.0.0-beta.6",
     "main": "dist/dop.js",
     "browser": "dist/dop.umd.js",
     "license": "MIT",

src/api/createNodeFactory.js

@@ -5,7 +5,11 @@ import converter from '../util/converter'
 import Func from '../types/Function'
 
 export default function createNodeFactory({ encoders, decoders }) {
-    return function createNode({ max_remote_functions = Infinity } = {}) {
+    return function createNode({
+        serialize = JSON.stringify,
+        deserialize = JSON.parse,
+        max_remote_functions = Infinity
+    } = {}) {
         const requests = {}
         const local_functions_id = {}
         const local_functions = new Map()
@@ -61,74 +65,68 @@ export default function createNodeFactory({ encoders, decoders }) {
         function open(send, fn) {
             const remote_function_id = remote_function_index++
             const local_function_id = local_function_index++
-            api.send = send
-            api.opened = true
+            api.send = msg => send(serialize(msg))
             if (isFunction(fn)) registerLocalFunction(fn, local_function_id)
             return createRemoteFunction(remote_function_id)
         }
 
         function message(msg) {
-            if (api.opened) {
-                try {
-                    msg = decode(msg)
-                } catch (e) {
-                    // Invalid array to decode
-                    return false
-                }
+            msg = deserialize(msg)
+            try {
+                msg = decode(msg)
+            } catch (e) {
+                // Invalid array to decode
+                return false
+            }
+
+            let [id, function_id, args] = msg
+            const response_id = -id
+
+            if (isInteger(id)) {
+                const fn = local_functions_id[function_id]
+
+                if (id > -1 && isFunction(fn)) {
+                    args = isArray(msg[2]) ? msg[2] : []
 
-                let [id, function_id, args] = msg
-                const response_id = -id
-
-                if (isInteger(id)) {
-                    const fn = local_functions_id[function_id]
-
-                    if (id > -1 && isFunction(fn)) {
-                        args = isArray(msg[2]) ? msg[2] : []
-
-                        // Request without response
-                        if (id === 0) {
-                            const req = { node: api }
-                            args.push(req)
-                            fn.apply(req, args)
-                        }
-
-                        // Request
-                        else {
-                            const req = createRequest()
-                            const response = [response_id]
-                            req.node = api
-                            req.then(value => {
-                                response.push(0) // no errors
-                                if (value !== undefined) response.push(value)
-                                api.send(encode(response))
-                            }).catch(error => {
-                                response.push(error) // error
-                                api.send(encode(response))
-                            })
-                            args.push(req)
-                            localProcedureCall(fn, req, args)
-                        }
-                        return true
+                    // Request without response
+                    if (id === 0) {
+                        const req = { node: api }
+                        args.push(req)
+                        fn.apply(req, args)
                     }
 
-                    // Response
-                    else if (id < 0 && requests.hasOwnProperty(response_id)) {
-                        const response_status = function_id
-                        const req = requests[response_id]
-                        response_status === 0
-                            ? req.resolve(args)
-                            : req.reject(response_status)
-                        return true
+                    // Request
+                    else {
+                        const req = createRequest()
+                        const response = [response_id]
+                        req.node = api
+                        req.then(value => {
+                            response.push(0) // no errors
+                            if (value !== undefined) response.push(value)
+                            api.send(encode(response))
+                        }).catch(error => {
+                            response.push(error) // error
+                            api.send(encode(response))
+                        })
+                        args.push(req)
+                        localProcedureCall(fn, req, args)
                     }
+                    return true
+                }
+
+                // Response
+                else if (id < 0 && requests.hasOwnProperty(response_id)) {
+                    const response_status = function_id
+                    const req = requests[response_id]
+                    response_status === 0
+                        ? req.resolve(args)
+                        : req.reject(response_status)
+                    return true
                 }
             }
             return false
         }
 
-        function close() {
-            api.opened = false
-        }
-
         function registerLocalFunctionFromEncode(fn) {
             return registerLocalFunction(fn, local_function_index++)
         }
@@ -163,8 +161,6 @@ export default function createNodeFactory({ encoders, decoders }) {
         const api = {
             open,
             message,
-            close,
-            opened: false,
             requests,
             remote_functions // Exposing this can be used to know if a function is a remote function
         }

src/util/forEachObject.js

@@ -11,9 +11,8 @@ function forEachObjectLoop(origin, destiny, mutator, path) {
     forEach(origin, (value_origin, prop) => {
         path.push(prop)
         const shallWeGoDown = mutator({ origin, destiny, prop, path })
-        if (shallWeGoDown !== false && isObject(value_origin)) {
+        if (shallWeGoDown !== false && isObject(value_origin))
             forEachObjectLoop(value_origin, destiny[prop], mutator, path)
-        }
         path.pop()
     })
 }

test/createNode.js

@@ -17,12 +17,12 @@ test('Api', async t => {
     const callClient = server.open(client.message)
     const promise = callClient(2, 5)
 
-    t.deepEqual(Object.keys(server).length, 7)
+    t.deepEqual(Object.keys(server).length, 5)
 
     t.deepEqual(Object.keys(promise).length, 5)
     t.true(promise instanceof Promise)
-    t.is(server.send, client.message)
     t.is(promise.node, server)
+    t.is(typeof server.send, 'function')
     t.is(typeof promise.resolve, 'function')
     t.is(typeof promise.reject, 'function')
     t.is(typeof promise.createdAt, 'number')
@@ -127,8 +127,9 @@ test('Sending remote functions that is from the same node must be replaced as nu
 })
 
 test('Testing messages', async t => {
-    const server = createNode()
-    const client = createNode()
+    const serdes = { serialize: m => m, deserialize: m => m }
+    const server = createNode(serdes)
+    const client = createNode(serdes)
 
     client.open(
         msg => {
@@ -146,8 +147,9 @@ test('Testing messages', async t => {
 })
 
 test('Escaping $f', async t => {
-    const server = createNode()
-    const client = createNode()
+    const serdes = { serialize: m => m, deserialize: m => m }
+    const server = createNode(serdes)
+    const client = createNode(serdes)
 
     // server side
     server.open(
@@ -294,7 +296,7 @@ test('Limiting remote functions to 0', async t => {
     t.is(client.remote_functions.size, 2)
 
     // faking calls
-    t.is(server.message([111, 0]), true)
-    t.is(server.message([222, 1]), false)
-    t.is(client.message([222, 0]), false)
+    t.is(server.message(JSON.stringify([111, 0])), true)
+    t.is(server.message(JSON.stringify([222, 1])), false)
+    t.is(client.message(JSON.stringify([222, 0])), false)
 })