add basic structure and logic

Author: drinking-code

.gitignore

@@ -0,0 +1 @@
+lib

example/main-process.js

@@ -0,0 +1,16 @@
+import child_process from 'child_process'
+import IPOS from '../lib/main.js'
+
+const sharedObject = IPOS.new()
+sharedObject.create('exampleArray', [])
+sharedObject.exampleArray.push('hello')
+
+const subProcess = child_process.spawn('node', ['sub-process.js'], {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+})
+
+sharedObject.addProcess(subProcess)
+sharedObject.create('exampleObject', {})
+sharedObject.exampleObject.from = 'the other side'
+
+console.log(sharedObject.exampleArray, sharedObject.exampleObject)

example/sub-process.js

@@ -0,0 +1,4 @@
+import IPOS from '../lib/main.js'
+
+const sharedObject = IPOS.new()
+console.log(sharedObject.exampleArray)

package-lock.json

@@ -0,0 +1,18 @@
+{
+  "name": "inter-process-object-sharing",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "build" : "tsc",
+    "watch" : "tsc --watch"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^18.7.18",
+    "typescript": "^4.8.3"
+  }
+}

package.json

@@ -0,0 +1,54 @@
+export default class InterceptedArray<T> extends Array {
+    private callback
+
+    // intercepts only methods that change the object
+    constructor(callback: (object: object, method: string, ...args: any) => void) {
+        super();
+        this.callback = callback
+    }
+
+    copyWithin(target: number, start: number, end?: number): this {
+        this.callback(this, 'copyWithin', target, start, end)
+        return super.copyWithin(target, start, end)
+    }
+
+    fill(value: T, start?: number, end?: number): this {
+        this.callback(this, 'fill', value, start, end)
+        return super.fill(value, start, end)
+    }
+
+    pop(): T | undefined {
+        this.callback(this, 'pop')
+        return super.pop()
+    }
+
+    push(...items: T[]): number {
+        this.callback(this, 'push', ...items)
+        return super.push(...items)
+    }
+
+    reverse(): T[] {
+        this.callback(this, 'reverse')
+        return super.reverse()
+    }
+
+    shift(): T | undefined {
+        this.callback(this, 'shift')
+        return super.shift()
+    }
+
+    sort(compareFn?: (a: T, b: T) => number): this {
+        this.callback(this, 'sort', compareFn)
+        return super.sort(compareFn)
+    }
+
+    splice(start: number, deleteCount?: number): T[] {
+        this.callback(this, 'splice', start, deleteCount)
+        return super.splice(start, deleteCount)
+    }
+
+    unshift(...items: T[]): number {
+        this.callback(this, 'unshift', ...items)
+        return super.unshift(...items)
+    }
+}

src/array.ts

@@ -0,0 +1,136 @@
+import {deserialize, serialize} from 'v8'
+import {ChildProcess} from 'child_process'
+import InterceptedArray from './array.js'
+import IPOSMessaging from './messaging.js'
+
+export default class IPOS {
+    private fields: Map<string, object>
+    private fieldsReverseMap: Map<object, string>
+    private processes: Set<ChildProcess>
+    private processMessagingMap: Map<ChildProcess, IPOSMessaging>
+    private readonly proxy
+    private messaging?: IPOSMessaging;
+
+    static new(): IPOS {
+        return new 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
+        this.proxy = new Proxy(this, {
+            get(target, name: string) {
+                if (Reflect.has(target, name)) {
+                    return Reflect.get(target, name)
+                } else if (target.fields.has(name)) {
+                    return target.fields.get(name)
+                }
+            }
+        })
+        // 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 create(key: string, value: object): void {
+        if (Array.isArray(value)) {
+            value = new InterceptedArray((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
+    }
+
+    public delete(key: string): boolean {
+        return this.fields.delete(key)
+        // todo: send update message
+    }
+
+    public addProcess(process: ChildProcess) {
+        if (!process.send)
+            throw new Error(`Process must have an ipc channel. Activate by passing "stdio: [<stdin>, <stdout>, <stderr>, 'ipc']" as an option.`)
+        const messaging = new IPOSMessaging(process)
+
+        let registered = false
+        messaging.listenForType('register', () => {
+            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)
+        })
+    }
+
+    private sendMethodCall(object: object, method: string, ...args: any) {
+        this.processMessagingMap.forEach(processMessaging => {
+            processMessaging.send('update', {
+                do: method,
+                on: this.fieldsReverseMap.get(object),
+                with: serialize(args)
+            })
+        })
+    }
+
+    // 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()
+        }
+    }*/
+}

src/main.ts

@@ -0,0 +1,69 @@
+import {ChildProcess} from 'child_process'
+
+type iposMessagingType = 'ready' | 'register' | 'update' | 'sync'
+type iposMessagingCallback = (message: iposMessagingMessage) => (any | void)
+type iposMessagingMessage = {
+    protocol: 'ipos',
+    type: iposMessagingType,
+    fields?: Buffer
+}
+
+const mustHaveSendError = new Error(`Process must have a \`.send()\` method.`)
+
+export default class IPOSMessaging {
+    private listeners: Map<iposMessagingType | 'any', Array<iposMessagingCallback>>
+    private process: ChildProcess | NodeJS.Process
+
+    constructor(process: ChildProcess | NodeJS.Process) {
+        this.listeners = new Map()
+        if (!process.send) throw mustHaveSendError
+        this.process = process
+        this.process.on('message', (message: iposMessagingMessage) => {
+            try {
+                if (message.protocol !== 'ipos')
+                    return
+
+                if (message.type === 'ready') {
+                    this.send('register')
+                    return
+                }
+
+                if (this.listeners.has('any')) {
+                    this.listeners.get('any')
+                        ?.forEach(callback => callback(message))
+                }
+                if (this.listeners.has(message.type)) {
+                    this.listeners.get(message.type)
+                        ?.forEach(callback => callback(message))
+                }
+            } catch (e) {
+                // not a message from ipos
+            }
+        })
+
+        // if the current process is a parent process
+        if (process instanceof ChildProcess) {
+            // send a "ready" message to receive another "register" (if an instance is initiated)
+            this.send('ready')
+        }
+    }
+
+    send(type: iposMessagingType, data?: {}) {
+        if (!this.process.send) throw mustHaveSendError
+        this.process.send({
+            protocol: 'ipos',
+            type,
+            ...data
+        })
+    }
+
+    listenForType(type: iposMessagingType | 'any', callback: iposMessagingCallback) {
+        let callbacks: Array<iposMessagingCallback> = this.listeners.get(type) ?? []
+        callbacks.push(callback)
+        this.listeners.set(type, callbacks)
+    }
+
+    listenForAll(callback: iposMessagingCallback) {
+        this.listenForType('any', callback)
+    }
+}

src/messaging.ts

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+
+    "declaration": true,
+
+    "outDir": "./lib",
+    "strict": true,
+
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}