We don't store remote functions anymore. And rpcFilter/createRemoteFnFilter works as encoder

Josema · Josema · commit 9b4dd8bfbd29 · 2020-07-02T23:29:50.000+02:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "dop",
-    "version": "1.3.1",
+    "version": "1.4.0",
     "main": "dist/dop.js",
     "browser": "dist/dop.umd.js",
     "module": "src/",
diff --git a/src/api/createNodeFactory.js b/src/api/createNodeFactory.js
@@ -7,20 +7,16 @@ export default function createNodeFactory({ encode, decode }) {
     return function createNode({
         serialize = JSON.stringify,
         deserialize = JSON.parse,
-        createRemoteFunctionFilter = () => true,
+        rpcFilter = (props) => props.rpc,
         errorInstances = [Error],
     } = {}) {
         const requests = {}
         const local_functions_id = {}
         const local_functions = new Map()
-        const remote_functions_id = {}
-        const remote_functions = new Set()
         let local_function_index = 0
-        let remote_function_index = 0
         let request_id_index = 0
 
         const encode_params = {
-            remote_functions,
             local_functions,
             registerLocalFunctionFromEncode,
         }
@@ -38,25 +34,14 @@ export default function createNodeFactory({ encode, decode }) {
             caller,
             function_creator,
         }) {
-            if (
-                !createRemoteFunctionFilter({
-                    node: api,
-                    function_id,
-                    target,
-                    path,
-                    caller,
-                    function_creator,
-                })
-            ) {
-                return null
-            }
             const makeCall = (request_id, args) => {
                 const data = [request_id, function_id]
                 if (args.length > 0) data.push(args)
                 api.send(encode(data, encode_params))
                 return data
             }
-            const fn = (...args) => {
+
+            const rpc = (...args) => {
                 const request_id = ++request_id_index
                 const req = createRequest()
                 const { resolve, reject } = req
@@ -73,23 +58,27 @@ export default function createNodeFactory({ encode, decode }) {
                 requests[request_id] = req
                 return req
             }
-            fn.stub = (...args) => {
+
+            rpc.push = (...args) => {
                 makeCall(0, args)
             }
 
-            remote_functions.add(fn)
-            remote_functions.add(fn.stub)
-            remote_functions_id[function_id] = fn
-            return fn
+            return rpcFilter({
+                rpc,
+                node: api,
+                function_id,
+                function_creator,
+                caller,
+                path,
+            })
         }
 
         function open(send, fn) {
-            const remote_function_id = remote_function_index++
             const local_function_id = local_function_index++
             if (isFunction(fn)) registerLocalFunction(local_function_id, fn)
             api.send = (msg) => send(serialize(msg))
             return createRemoteFunction({
-                function_id: remote_function_id,
+                function_id: 0,
                 function_creator: FUNCTION_CREATOR.ENTRY,
             })
         }
@@ -106,7 +95,6 @@ export default function createNodeFactory({ encode, decode }) {
 
             msg = decode(msg, {
                 createRemoteFunction,
-                remote_functions_id,
                 caller: fn,
                 function_creator: is_request
                     ? FUNCTION_CREATOR.REQUEST
@@ -166,7 +154,6 @@ export default function createNodeFactory({ encode, decode }) {
             open,
             message,
             requests,
-            remote_functions, // Exposing this can be used to know if a function is a remote function
         }
 
         return api
diff --git a/src/types/Function.js b/src/types/Function.js
@@ -7,12 +7,10 @@ export default function Function() {}
 
 Function.encode = function ({
     value,
-    remote_functions,
     local_functions,
     registerLocalFunctionFromEncode,
 }) {
     if (isFunction(value)) {
-        if (remote_functions.has(value)) return null
         const function_id = local_functions.has(value)
             ? local_functions.get(value)
             : registerLocalFunctionFromEncode(value)
@@ -25,7 +23,6 @@ Function.encode = function ({
 
 Function.decode = function ({
     value,
-    remote_functions_id,
     createRemoteFunction,
     path,
     caller,
@@ -35,16 +32,12 @@ Function.decode = function ({
         getUniqueKey(value) === FUNCTION_KEY &&
         isInteger(value[FUNCTION_KEY])
     ) {
-        const function_id = value[FUNCTION_KEY]
-        const fn = remote_functions_id[function_id]
-        return isFunction(fn)
-            ? fn
-            : createRemoteFunction({
-                  function_id,
-                  function_creator,
-                  caller,
-                  path: path.slice(2),
-              })
+        return createRemoteFunction({
+            function_id: value[FUNCTION_KEY],
+            function_creator,
+            caller,
+            path: path.slice(2),
+        })
     } else if (
         isValidToEscape({ value }) &&
         isValidToDecode({ value: value[ESCAPE_KEY], key: FUNCTION_KEY })
diff --git a/test/api.js b/test/api.js
@@ -12,31 +12,21 @@ const exported = [
     'createNode',
     'createStore',
     'addType',
-    'TYPE'
+    'TYPE',
 ]
 
-test('Checking exported params', function(t) {
+test('Checking exported params', function (t) {
     t.deepEqual(Object.keys(dop), exported)
 })
 
-test('Checking factory', function(t) {
+test('Checking factory', function (t) {
     const dopcopy = dop.factory()
     t.deepEqual(Object.keys(dop), Object.keys(dopcopy))
     t.is(dop.factory, dopcopy.factory)
     t.not(dop.createNode, dopcopy.createNode)
 })
 
-test('isRemoteFunction', async t => {
-    const node = createNode()
-    const { remote_functions } = node
-    const isRemoteFunction = f => remote_functions.has(f)
-    const callClient = node.open()
-    t.true(isRemoteFunction(callClient))
-    t.false(isRemoteFunction(() => {}))
-    t.false(isRemoteFunction('other'))
-})
-
-test('Types must be same instance when creating new dop', function(t) {
+test('Types must be same instance when creating new dop', function (t) {
     const dopcopy = dop.factory()
     t.is(dop.TYPE.Inner, dopcopy.TYPE.Inner)
     t.is(dop.TYPE.Replace, dopcopy.TYPE.Replace)
diff --git a/test/createNode.js b/test/createNode.js
@@ -18,7 +18,7 @@ test('Api', async (t) => {
     const callClient = server.open(client.message)
     const promise = callClient(2, 5)
 
-    t.deepEqual(Object.keys(server).length, 5)
+    t.deepEqual(Object.keys(server).length, 4)
 
     t.deepEqual(Object.keys(promise).length, 5)
     t.true(promise instanceof Promise)
@@ -89,8 +89,20 @@ test('Response (reject or resolve must delete request)', async (t) => {
 })
 
 test('Passing same functions should not create a new one', async (t) => {
+    function rpcFilter() {
+        const rpcs = {}
+        return ({ rpc, function_id }) => {
+            if (rpcs.hasOwnProperty(function_id)) {
+                return rpcs[function_id]
+            } else {
+                rpcs[function_id] = rpc
+                return rpc
+            }
+        }
+    }
+
     const server = createNode()
-    const client = createNode()
+    const client = createNode({ rpcFilter: rpcFilter() })
 
     // Client side
     const callServer = client.open(
@@ -108,25 +120,6 @@ test('Passing same functions should not create a new one', async (t) => {
     callClient(repeated, repeated, receiveFromClient)
 })
 
-test('Sending remote functions that is from the same node must be replaced as null', async (t) => {
-    const server = createNode()
-    const client = createNode()
-
-    // server side
-    server.open(client.message, (...args) => {
-        t.is(args.length, 3)
-        t.is(args[0], null)
-        t.is(typeof args[1], 'function')
-        t.is(typeof args[2], 'object')
-        return args[1]
-    })
-
-    // client side
-    const callServer = client.open(server.message)
-    const resu = await callServer(callServer, () => {})
-    t.is(resu, null)
-})
-
 test('Testing messages', async (t) => {
     const serdes = { serialize: (m) => m, deserialize: (m) => m }
     const server = createNode(serdes)
@@ -203,7 +196,7 @@ test('Using reject', async (t) => {
     t.is(Object.keys(client.requests).length, 0)
 })
 
-test('Using stub', async (t) => {
+test('Using push', async (t) => {
     const server = createNode()
     const client = createNode()
     server.open(client.message, (...args) => {
@@ -212,29 +205,10 @@ test('Using stub', async (t) => {
     })
     const callServer = client.open(server.message)
     t.is(Object.keys(client.requests).length, 0)
-    t.is(callServer.stub(), undefined)
+    t.is(callServer.push(), undefined)
     t.is(Object.keys(client.requests).length, 0)
 })
 
-test('Sending remote stub functions that is from the same node must be replaced as null', async (t) => {
-    const server = createNode()
-    const client = createNode()
-
-    // server side
-    server.open(client.message, (...args) => {
-        t.is(args.length, 3)
-        t.is(args[0], null)
-        t.is(typeof args[1], 'function')
-        t.is(typeof args[2], 'object')
-        return args[1]
-    })
-
-    // client side
-    const callServer = client.open(server.message)
-    const resu = await callServer(callServer.stub, () => {})
-    t.is(resu, null)
-})
-
 test('Calling functions from client to server with another node in the middle', async (t) => {
     // connection 1
     const server = createNode()
@@ -267,45 +241,19 @@ test('Calling functions from client to server with another node in the middle',
     t.is(result, 10)
 })
 
-test('Limiting remote functions', async (t) => {
-    const server = createNode({
-        createRemoteFunctionFilter: () => server.remote_functions.size < 6,
-    })
-    t.is(server.remote_functions.size, 0)
+test('rpc is created if rpcFilter returns the rpc itself', async (t) => {
+    const n = Math.random()
+    const server = createNode({ rpcFilter: () => n })
     const client = createNode()
-    server.open(client.message, (fn, isLast) => {
-        if (isLast) t.is(fn, null)
-        else t.is(typeof fn, 'function')
+    const callClient = server.open(client.message, (fn) => {
+        t.is(fn, n)
     })
+    t.is(callClient, n)
     const callServer = client.open(server.message)
-    t.is(server.remote_functions.size, 2)
-    await callServer(() => {}, false)
-    t.is(server.remote_functions.size, 4)
-    await callServer(() => {}, false)
-    t.is(server.remote_functions.size, 6)
-    await callServer(() => {}, true)
-    t.is(server.remote_functions.size, 6)
-})
-
-test('Limiting remote functions to 0', async (t) => {
-    const server = createNode({ createRemoteFunctionFilter: () => false })
-    const client = createNode()
-    const callClient = server.open(client.message, (fn) => fn)
-    t.is(callClient, null)
-    const callServer = client.open(server.message)
-    await callServer(() => {})
-    t.is(server.remote_functions.size, 0)
-    t.is(client.remote_functions.size, 2)
-    await callServer(() => {})
-    t.is(client.remote_functions.size, 2)
-
-    // faking calls
-    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)
+    callServer(() => {})
 })
 
-test('createRemoteFunctionFilter API', async (t) => {
+test('rpcFilter API', async (t) => {
     function login({ value, fn }) {
         t.is(typeof fn, 'function')
     }
@@ -317,7 +265,8 @@ test('createRemoteFunctionFilter API', async (t) => {
         }
     }
 
-    const createRemoteFunctionFilter = ({
+    const rpcFilter = ({
+        rpc,
         node,
         function_id,
         function_creator,
@@ -346,9 +295,9 @@ test('createRemoteFunctionFilter API', async (t) => {
             t.is(caller, login)
             t.deepEqual(path, [0, 'fn'])
         }
-        return true
+        return rpc
     }
-    const server = createNode({ createRemoteFunctionFilter })
+    const server = createNode({ rpcFilter })
     const client = createNode()
     server.ENV = 'SERVER'
     client.ENV = 'CLIENT'

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "dop",`
`3`		`- "version": "1.3.1",`
	`3`	`+ "version": "1.4.0",`
`4`	`4`	`"main": "dist/dop.js",`
`5`	`5`	`"browser": "dist/dop.umd.js",`
`6`	`6`	`"module": "src/",`