add support for class de-/serialistion + tests #1

Author: drinking-code

README.md

@@ -45,6 +45,61 @@ See [`example/main-process.js`](https://github.com/drinking-code/inter-process-o
 and [`example/sub-process.js`](https://github.com/drinking-code/inter-process-object-sharing/blob/main/example/sub-process.js)
 .
 
+## A note on class instances
+
+To synchronise class instances, you first have to register the class with ipos _on each process_ (on which the class
+instance does not yet exist) before the synchronisation happens. That means if you want to connect two IPOS instances,
+and the instance on the main process has a class instance somewhere inside a field, this class type must be registered
+on the subprocess, before calling `IPOS.new()`. For IPOS to be able to transmit the class instance it has to have
+methods to serialise (turn the class instance into either a string, a number, an object, an array, a map, or a set) and
+deserialize (turn the serialised value back into a class instance). IPOS will look for `.serialize()`, or `.stringify()`
+for serialisation and `.from()` for de-serialisation, but you can specify custom methods / functions. Here is an
+example:
+
+```javascript
+// example-class.js
+
+export class Example {
+    data;
+
+    constructor(data) {
+        this.data = data
+    }
+
+    serialize() {
+        return this.data
+    }
+
+    static from(data) {
+        return new Example(data)
+    }
+}
+```
+
+```javascript
+// main-process.js
+
+import IPOS from 'ipos'
+
+const exampleInstance = new Example('myValue')
+const ipos = IPOS.new()
+ipos.create('myClassInstance', exampleInstance)
+const subProcess = child_process.spawn('node', ['sub-process.js'], {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+})
+await sharedObject.addProcess(subProcess)
+```
+
+```javascript
+// sub-process.js
+
+import IPOS from 'ipos'
+import {Example} from './example-class.js'
+
+const ipos = IPOS.registerClass(Example)
+const ipos = await IPOS.new()
+```
+
 ## `IPOS()`
 
 The main class. Don't use the `new` keyword (when creating an instance in a subprocess). Instead, use the

src/__test__/synchronize.test.ts

@@ -17,7 +17,7 @@ describe('Synchronising fields', () =>
             await Promise.all([
                 // @ts-ignore Argument of type 'subProcessIPCLoopback' is not assignable to parameter of type 'ChildProcess'
                 main_ipos.addProcess(sub_process),
-                (async () => sub_ipos = await IPOS.new())()
+                expect((async () => sub_ipos = await IPOS.new())()).resolves.not.toThrow()
             ])
 
             // @ts-ignore Variable 'sub_ipos' is used before being assigned.

src/__test__/testData.ts

@@ -1,3 +1,23 @@
+import IPOS from '../main'
+
+class TestClass {
+    data: any
+
+    constructor(data: any) {
+        this.data = data
+    }
+
+    stringify() {
+        return this.data
+    }
+
+    static from(data: any) {
+        return new TestClass(data)
+    }
+}
+
+IPOS.registerClass(TestClass)
+
 export const examples = {
     'string': 'myString',
     'number': 42,
@@ -12,6 +32,7 @@ export const examples = {
     })),
     'set': new Set(['myItem', 42]),
     'function': (a: number, b: number) => a + b,
+    'class': new TestClass('myClass')
 }
 
 // exemplary; don't iterate every possible method, just do one direct value assignment and one method

src/main.ts

@@ -2,6 +2,7 @@ import {ChildProcess} from 'child_process'
 import initChild from './init-child.js'
 import IPOSMessaging, {iposMessagingMessage, iposMessagingType} from './messaging.js'
 import intercept from './intercept.js'
+import {classes, deSerialize, SerializableType, SerializedType} from "./serialize";
 
 export default class IPOS {
     private readonly fields: Map<string, any>
@@ -58,6 +59,15 @@ export default class IPOS {
         return this.proxy
     }
 
+    static registerClass(
+        constructor: Function,
+        serialize?: (value?: object) => SerializableType,
+        deserialize?: (value: SerializedType) => object
+    ) {
+        classes.set(constructor.name, constructor)
+        deSerialize.set(constructor, {serialize, deserialize})
+    }
+
     /****************** MESSAGING *******************/
     protected mountListeners(messaging: IPOSMessaging) {
         messaging.listenForType('update', (message) => this.performUpdate(message))

src/serialize.ts

@@ -1,19 +1,47 @@
+function isNativeObject(value: object) {
+    return /^\[object .+?Constructor]$/.test(Object.prototype.toString.call(value))
+}
+
+export const classes: Map<string, Function> = new Map()
+export const deSerialize: Map<Function, { serialize?: (value?: object) => SerializableType, deserialize?: (value: SerializedType) => object }> = new Map()
+
+export type SerializedType =
+    string
+    | number
+    | boolean
+    | null
+    | undefined
+    | Array<SerializedType>
+    | { [k: string]: SerializedType }
+
+export type SerializableType =
+    string
+    | number
+    | boolean
+    | null
+    | undefined
+    | Function
+    | Array<SerializableType>
+    | { [k: string]: SerializableType }
+    | Set<SerializableType>
+    | Map<SerializableType, SerializableType>
+
 export function serialize(value: any): any | void {
     // todo: handle other builtins
     if (['string', 'number', 'boolean'].includes(typeof value) || !value) {
         return value
-    } else if (typeof value === 'function') {
-        return {
-            $$iposType: 'Function',
-            data: value.toString()
-        }
     } else if (Array.isArray(value)) {
         return value.map(v => serialize(v))
     } else if (value.constructor === {}.constructor || value.valueOf().constructor === {}.constructor) {
         return Object.fromEntries(
             Array.from(Object.entries(value))
                 .map(([key, value]) => [key, serialize(value)])
         )
+    } else if (typeof value === 'function') {
+        return {
+            $$iposType: 'Function',
+            data: value.toString()
+        }
     } else if (value instanceof Set) {
         return {
             $$iposType: 'Set',
@@ -28,12 +56,21 @@ export function serialize(value: any): any | void {
                     .map(([key, value]) => [key, serialize(value)])
             )
         }
+    } else if (isNativeObject(value)) {
+        throw new Error(`Could not serialise: \`${value.constructor.name}\`.`)
     } else {
-        if (!value.stringify && !value.serialize)
+        const serializeMethod = deSerialize.get(value.constructor)?.serialize ?? value.stringify ?? value.serialize
+        if (!serializeMethod)
             throw new Error(
                 `Class: \`${value.constructor.name}\` must have methods to serialize and deserialize objects. (\`.stringify()\`, \`.serialize()\`)`
             )
-        // return value.toString()
+
+        return {
+            $$iposType: value.constructor.name,
+            data: serialize(
+                serializeMethod.call(value, value)
+            )
+        }
     }
 }
 
@@ -64,6 +101,17 @@ export function deserialize(value: string | number | Array<any> | { $$iposType?:
                 Array.from(Object.entries(value.data))
                     .map(deserialize)
             )
+        } else if (classes.has(value.$$iposType)) {
+            const constructor = classes.get(value.$$iposType) as Function
+            const deserializeMethod = deSerialize.get(constructor)?.deserialize ??
+                (constructor as unknown as { from: Function })?.from
+
+            if (!deserializeMethod)
+                throw new Error(`Did not recognize type \`${value.$$iposType}\`. Did you register it in the child process?`)
+
+            return deserializeMethod(deserialize(value.data))
+        } else {
+            throw new Error(`Did not recognize type \`${value.$$iposType}\`. Did you register it in the child process?`)
         }
     } else
         console.warn('I don\'t know', value)