add synchronisation of object stores

Author: drinking-code

example/sub-process.js

@@ -1,4 +1,5 @@
 import IPOS from '../lib/main.js'
 
-const sharedObject = IPOS.new()
-console.log(sharedObject.exampleArray)
+const sharedObject = await IPOS.new()
+console.log('sharedObject.exampleArray', sharedObject.exampleArray)
+// console.log(sharedObject.exampleArray[0], /*...sharedObject.exampleObject.entries()*/)

src/init-child.ts

@@ -0,0 +1,26 @@
+import IPOSMessaging from './messaging.js'
+import IPOS from './main.js'
+
+export default function initChild(this: IPOS) {
+    let resolve: Function
+    const promise = new Promise(res => resolve = res)
+
+    this.messaging = new IPOSMessaging(process)
+    this.messaging?.listenForType('sync', message => {
+        if (!message.fields) return
+        Object.entries(
+            IPOS.deserialize(JSON.parse(message.fields))
+        )
+            .map(([key, value]: [string, any]) => {
+                this.create(key, value.constructor())
+                if (Array.isArray(value)) {
+                    this.get(key)?.push(...value)
+                }
+            })
+        resolve()
+    })
+    // register with parent process
+    this.messaging.send('register')
+
+    return promise
+}

src/intercept.ts

@@ -0,0 +1,20 @@
+import InterceptedArray from './intercept/array.js'
+
+export default function intercept(value: object, interceptCallback: (object: object, method: string, ...args: any) => void): object {
+    if (Array.isArray(value)) {
+        value = new InterceptedArray(interceptCallback)
+    }
+    /*Object.getOwnPropertyNames(Object.getPrototypeOf(value))
+        .filter(methodName => !(methodName.startsWith('__') && methodName.endsWith('__')))
+        .forEach(methodName => {
+            if (!value[methodName]) return
+            const method = value[methodName]
+            value[methodName] = function (...args: any) {
+                // interception
+                console.log(methodName)
+                method.call(value, ...args)
+            }
+        })
+    */
+    return value
+}

src/array.ts src/intercept/array.tssrc/array.ts renamed to src/intercept/array.ts

@@ -1,9 +1,9 @@
 export default class InterceptedArray<T> extends Array {
-    private callback
+    private readonly callback
 
     // intercepts only methods that change the object
     constructor(callback: (object: object, method: string, ...args: any) => void) {
-        super();
+        super()
         this.callback = callback
     }
 

src/main.ts

@@ -1,24 +1,31 @@
-import {deserialize, serialize} from 'v8'
 import {ChildProcess} from 'child_process'
-import InterceptedArray from './array.js'
+import initChild from './init-child.js'
 import IPOSMessaging from './messaging.js'
+import {deserialize, serialize} from './serialize.js'
+import intercept from './intercept.js'
 
 export default class IPOS {
-    private fields: Map<string, object>
+    private readonly fields: Map<string, object>
     private fieldsReverseMap: Map<object, string>
-    private processes: Set<ChildProcess>
     private processMessagingMap: Map<ChildProcess, IPOSMessaging>
     private readonly proxy
-    private messaging?: IPOSMessaging;
+    protected messaging?: IPOSMessaging
 
-    static new(): IPOS {
-        return new IPOS()
+    static new(): IPOS | Promise<IPOS> {
+        const ipos = new IPOS()
+        // was called on child process
+        if (process.send) {
+            return new Promise(async resolve => {
+                await initChild.call(ipos)
+                resolve(ipos)
+            })
+        }
+        return ipos
     }
 
     constructor() {
         this.fields = new Map()
         this.fieldsReverseMap = new Map()
-        this.processes = new Set()
         this.processMessagingMap = new Map()
 
         // proxy makes all "target.fields" available as "actual" fields
@@ -31,39 +38,21 @@ export default class IPOS {
                 }
             }
         })
-        // was called on child process
-        if (process.send) {
-            this.messaging?.listenForType('sync', message => {
-                console.log(message)
-                if (message.fields)
-                    this.fields = deserialize(message.fields)
-            })
-
-            // register with parent process
-            this.messaging = new IPOSMessaging(process)
-            this.messaging.send('register')
-        }
         return this.proxy
     }
 
+    public get(key: string): any {
+        return this.fields.get(key)
+    }
+
+    // todo: also accept and update non object values
     public create(key: string, value: object): void {
-        if (Array.isArray(value)) {
-            value = new InterceptedArray((object, method, ...args) =>
+        // console.log('create', key)
+        if (typeof value === 'object')
+            value = intercept(value, (object, method, ...args) =>
                 this.sendMethodCall(object, method, ...args)
             )
-        }
-        /*Object.getOwnPropertyNames(Object.getPrototypeOf(value))
-            .filter(methodName => !(methodName.startsWith('__') && methodName.endsWith('__')))
-            .forEach(methodName => {
-                if (!value[methodName]) return
-                const method = value[methodName]
-                value[methodName] = function (...args: any) {
-                    // interception
-                    console.log(methodName)
-                    method.call(value, ...args)
-                }
-            })
-        */
+
         this.fields.set(key, value)
         this.fieldsReverseMap.set(value, key)
         // todo: send update message
@@ -84,16 +73,14 @@ export default class IPOS {
             if (registered) return
             registered = true
 
-            this.processes.add(process)
             this.processMessagingMap.set(process, messaging)
             this.syncProcess(process)
         })
     }
 
     private syncProcess(process: ChildProcess) {
-        console.log('sending sync')
         this.processMessagingMap.get(process)?.send('sync', {
-            field: serialize(this.fields)
+            fields: JSON.stringify(IPOS.serialize(this.fields))
         })
     }
 
@@ -107,30 +94,14 @@ export default class IPOS {
         })
     }
 
-    // serializes types, that "JSON.stringify()" doesn't properly handle
-    /*private static serialize(value: any): any | void {
-        // todo: handle other builtins
-        if (['string', 'number'].includes(typeof value)) {
-            return value
-        } else if (typeof value === 'function') {
-            return value.toString()
-        } else if (Array.isArray(value)) {
-            return value.map(serialize)
-        } else if (value.constructor === {}.constructor) {
-            return Object.fromEntries(
-                Array.from(
-                    Object.entries(value)
-                        .map(([key, value]) =>
-                            [key, this.serialize(value)]
-                        )
-                )
-            )
-        } else {
-            if (!value.stringify && !value.serialize)
-                throw new Error(
-                    `Class: \`${value.constructor.name}\` must have methods to serialize and deserialize objects. (\`.stringify()\`, \`.serialize()\`)`
-                )
-            // return value.toString()
-        }
-    }*/
+    /**
+     * Serializes types that "JSON.stringify()" doesn't properly handle
+     */
+    public static serialize(value: any): any | void {
+        return serialize(value)
+    }
+
+    public static deserialize(value: string | number | Array<any> | { $$iposType?: string, data: any }): any | void {
+        return deserialize(value)
+    }
 }

src/messaging.ts

@@ -5,7 +5,7 @@ type iposMessagingCallback = (message: iposMessagingMessage) => (any | void)
 type iposMessagingMessage = {
     protocol: 'ipos',
     type: iposMessagingType,
-    fields?: Buffer
+    fields?: string
 }
 
 const mustHaveSendError = new Error(`Process must have a \`.send()\` method.`)

src/serialize.ts

@@ -0,0 +1,58 @@
+export function serialize(value: any): any | void {
+    // todo: handle other builtins
+    if (['string', 'number'].includes(typeof value)) {
+        return value
+    } else if (typeof value === 'function') {
+        return {
+            $$iposType: 'Function',
+            data: value.toString()
+        }
+    } else if (Array.isArray(value)) {
+        return value.map(serialize)
+    } else if (value.constructor === {}.constructor) {
+        return Object.fromEntries(
+            Array.from(
+                Object.entries(value)
+                    .map(([key, value]) =>
+                        [key, serialize(value)]
+                    )
+            )
+        )
+    } else if (value.constructor === Map) {
+        return {
+            $$iposType: 'Map',
+            data: Array.from(value.entries()).map(serialize)
+        }
+    } else {
+        if (!value.stringify && !value.serialize)
+            throw new Error(
+                `Class: \`${value.constructor.name}\` must have methods to serialize and deserialize objects. (\`.stringify()\`, \`.serialize()\`)`
+            )
+        // return value.toString()
+    }
+}
+
+export function deserialize(value: string | number | Array<any> | { $$iposType?: string, data: any }): any | void {
+    if (['string', 'number'].includes(typeof value)) {
+        return value
+    } else if (Array.isArray(value)) {
+        return value.map(deserialize)
+    } else if (typeof value === 'object') {
+        if (!value.$$iposType) {
+            return Object.fromEntries(
+                Array.from(
+                    Object.entries(value)
+                        .map(([key, value]) =>
+                            [key, deserialize(value)]
+                        )
+                )
+            )
+        } else if (value.$$iposType === 'Function') {
+            // todo: is this acceptable?
+            return eval(`(${value.data})`)
+        } else if (value.$$iposType === 'Map') {
+            return Object.fromEntries(value.data.map(deserialize))
+        }
+    } else
+        console.warn('I don\'t know', value)
+}