fix(loader): support for nested isolate realms

Author: shigma

packages/loader/src/entry.ts

@@ -83,12 +83,12 @@ export class Entry {
     }
 
     // part 2: generate service diff
-    const delimiter = Symbol('delimiter')
-    ctx[delimiter] = true
-    const diff: [string, symbol, symbol, boolean][] = []
+    const diff: [string, symbol, symbol, symbol, symbol][] = []
     const oldMap = ctx[Context.isolate]
     for (const key in { ...oldMap, ...newMap }) {
       if (newMap[key] === oldMap[key]) continue
+      const delim = this.loader.delims[key] ??= Symbol(key)
+      ctx[delim] = Symbol(`${key}#${this.options.id}`)
       for (const symbol of [oldMap[key], newMap[key]]) {
         const value = symbol && ctx[symbol]
         if (!(value instanceof Object)) continue
@@ -97,45 +97,48 @@ export class Entry {
           this.parent.emit('internal/warning', new Error(`expected service ${key} to be implemented`))
           continue
         }
-        diff.push([key, oldMap[key], newMap[key], !!source[delimiter]])
-        break
+        diff.push([key, oldMap[key], newMap[key], ctx[delim], source[delim]])
+        if (ctx[delim] !== source[delim]) break
       }
     }
 
     // part 3: emit service events
     // part 3.1: internal/before-service
-    for (const [key, symbol1, symbol2, flag] of diff) {
+    for (const [key, symbol1, symbol2, flag1, flag2] of diff) {
       const self = Object.create(null)
       self[Context.filter] = (target: Context) => {
-        if (!target[delimiter] !== flag) return false
-        if (symbol1 === target[Context.isolate][key]) return true
-        return flag && symbol2 === target[Context.isolate][key]
+        if (![symbol1, symbol2].includes(target[Context.isolate][key])) return false
+        return (flag1 === target[this.loader.delims[key]]) !== (flag1 === flag2)
       }
       ctx.emit(self, 'internal/before-service', key)
     }
 
     // part 3.2: update service impl, prevent double update
     this.fork?.update(this.options.config)
     swap(ctx[Context.isolate], newMap)
-    for (const [, symbol1, symbol2, flag] of diff) {
-      if (flag && ctx[symbol1] && !ctx[symbol2]) {
+    for (const [, symbol1, symbol2, flag1, flag2] of diff) {
+      if (flag1 === flag2 && ctx[symbol1] && !ctx[symbol2]) {
         ctx.root[symbol2] = ctx.root[symbol1]
         delete ctx.root[symbol1]
       }
     }
 
     // part 3.3: internal/service
-    for (const [key, symbol1, symbol2, flag] of diff) {
+    for (const [key, symbol1, symbol2, flag1, flag2] of diff) {
       const self = Object.create(null)
       self[Context.filter] = (target: Context) => {
-        if (!target[delimiter] !== flag) return false
-        if (symbol2 === target[Context.isolate][key]) return true
-        return flag && symbol1 === target[Context.isolate][key]
+        if (![symbol1, symbol2].includes(target[Context.isolate][key])) return false
+        return (flag1 === target[this.loader.delims[key]]) !== (flag1 === flag2)
       }
       ctx.emit(self, 'internal/service', key)
     }
 
-    delete ctx[delimiter]
+    // part 4: clean up delimiter
+    for (const key in this.loader.delims) {
+      if (!Reflect.ownKeys(newMap).includes(key)) {
+        delete ctx[this.loader.delims[key]]
+      }
+    }
     return ctx
   }
 

packages/loader/src/shared.ts

@@ -70,6 +70,7 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
   public filename!: string
   public entries: Dict<Entry> = Object.create(null)
   public realms: Dict<Dict<symbol>> = Object.create(null)
+  public delims: Dict<symbol> = Object.create(null)
 
   private tasks = new Set<Promise<any>>()
   private _writeTask?: Promise<void>

packages/loader/tests/isolate.spec.ts

@@ -189,9 +189,7 @@ describe('service isolation: realm', async () => {
   root.plugin(MockLoader)
   const loader = root.loader
 
-  const dispose = mock.fn(() => {
-    console.log(new Error())
-  })
+  const dispose = mock.fn()
 
   const foo = Object.assign(loader.mock('foo', (ctx: Context) => {
     ctx.on('dispose', dispose)
@@ -288,14 +286,239 @@ describe('service isolation: realm', async () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(foo.mock.calls).to.have.length(2)
     expect(dispose.mock.calls).to.have.length(0)
-    expect(loader.entries[nested1]!.fork).to.be.ok
-    expect(loader.entries[nested1]!.fork!.ctx.get('bar')!.value).to.equal('alpha')
-    expect(loader.entries[nested1]!.fork!.status).to.equal(ScopeStatus.ACTIVE)
-    expect(loader.entries[nested2]!.fork).to.be.ok
-    expect(loader.entries[nested2]!.fork!.ctx.get('bar')!.value).to.equal('beta')
-    expect(loader.entries[nested2]!.fork!.status).to.equal(ScopeStatus.ACTIVE)
-    expect(loader.entries[nested3]!.fork).to.be.ok
-    expect(loader.entries[nested3]!.fork!.ctx.get('bar')).to.be.undefined
-    expect(loader.entries[nested3]!.fork!.status).to.equal(ScopeStatus.PENDING)
+    const fork1 = loader.expectFork(nested1)
+    expect(fork1.ctx.get('bar')!.value).to.equal('alpha')
+    expect(fork1.status).to.equal(ScopeStatus.ACTIVE)
+    const fork2 = loader.expectFork(nested2)
+    expect(fork2.ctx.get('bar')!.value).to.equal('beta')
+    expect(fork2.status).to.equal(ScopeStatus.ACTIVE)
+    const fork3 = loader.expectFork(nested3)
+    expect(fork3.ctx.get('bar')).to.be.undefined
+    expect(fork3.status).to.equal(ScopeStatus.PENDING)
+  })
+
+  it('special case: nested realms', async () => {
+    const root = new Context()
+    root.plugin(MockLoader)
+    const loader = root.loader
+  
+    const dispose = mock.fn()
+  
+    const foo = Object.assign(loader.mock('foo', (ctx: Context) => {
+      ctx.on('dispose', dispose)
+    }), {
+      inject: ['bar'],
+      reusable: true,
+    })
+  
+    Object.assign(loader.mock('bar', (ctx: Context, config: {}) => {
+      ctx.set('bar', config)
+    }), {
+      reusable: true,
+    })
+
+    await loader.start()
+
+    const outer = await loader.create({
+      name: 'cordis/group',
+      config: [],
+    })
+
+    const inner = await loader.create({
+      name: 'cordis/group',
+      isolate: {
+        bar: 'custom',
+      },
+      config: [],
+    }, outer)
+
+    await loader.create({
+      name: 'bar',
+      config: { value: 'custom' },
+    }, inner)
+
+    const  alpha = await loader.create({
+      name: 'foo',
+      isolate: {
+        bar: 'custom',
+      },
+    })
+
+    const beta = await loader.create({
+      name: 'foo',
+    }, inner)
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    const fork1 = loader.expectFork(alpha)
+    const fork2 = loader.expectFork(beta)
+    expect(fork1.ctx.get('bar')!.value).to.equal('custom')
+    expect(fork2.ctx.get('bar')!.value).to.equal('custom')
+
+    foo.mock.resetCalls()
+    dispose.mock.resetCalls()
+
+    await loader.update(outer, {
+      isolate: {
+        bar: 'custom',
+      },
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(0)
+    expect(dispose.mock.calls).to.have.length(0)
+
+    foo.mock.resetCalls()
+    dispose.mock.resetCalls()
+
+    await loader.update(outer, {
+      isolate: {},
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(0)
+    expect(dispose.mock.calls).to.have.length(0)
+  })
+
+  it('special case: change provider', async () => {
+    const root = new Context()
+    root.plugin(MockLoader)
+    const loader = root.loader
+  
+    const dispose = mock.fn()
+  
+    const foo = Object.assign(loader.mock('foo', (ctx: Context) => {
+      ctx.on('dispose', dispose)
+    }), {
+      inject: ['bar'],
+      reusable: true,
+    })
+  
+    Object.assign(loader.mock('bar', (ctx: Context, config: {}) => {
+      ctx.set('bar', config)
+    }), {
+      reusable: true,
+    })
+
+    await loader.start()
+
+    await loader.create({
+      name: 'bar',
+      isolate: {
+        bar: 'alpha',
+      },
+      config: { value: 'alpha' },
+    })
+
+    await loader.create({
+      name: 'bar',
+      isolate: {
+        bar: 'beta',
+      },
+      config: { value: 'beta' },
+    })
+
+    const group = await loader.create({
+      name: 'cordis/group',
+      isolate: {
+        bar: 'alpha',
+      },
+      config: [],
+    })
+
+    const id = await loader.create({
+      name: 'foo',
+    }, group)
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(0)
+    const fork = loader.expectFork(id)
+    expect(fork.ctx.get('bar')!.value).to.equal('alpha')
+
+    foo.mock.resetCalls()
+    dispose.mock.resetCalls()
+
+    await loader.update(group, {
+      isolate: {
+        bar: 'beta',
+      },
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(1)
+    expect(fork.ctx.get('bar')!.value).to.equal('beta')
+  })
+
+  it('special case: change injector', async () => {
+    const root = new Context()
+    root.plugin(MockLoader)
+    const loader = root.loader
+  
+    const dispose = mock.fn()
+  
+    const foo = Object.assign(loader.mock('foo', (ctx: Context) => {
+      ctx.on('dispose', dispose)
+    }), {
+      inject: ['bar'],
+      reusable: true,
+    })
+  
+    Object.assign(loader.mock('bar', (ctx: Context, config: {}) => {
+      ctx.set('bar', config)
+    }), {
+      reusable: true,
+    })
+
+    await loader.start()
+
+    const alpha = await loader.create({
+      name: 'foo',
+      isolate: {
+        bar: 'alpha',
+      },
+    })
+
+    const beta = await loader.create({
+      name: 'foo',
+      isolate: {
+        bar: 'beta',
+      },
+    })
+
+    const group = await loader.create({
+      name: 'cordis/group',
+      isolate: {
+        bar: 'alpha',
+      },
+      config: [],
+    })
+
+    await loader.create({
+      name: 'bar',
+    }, group)
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(0)
+    const fork1 = loader.expectFork(alpha)
+    expect(fork1.ctx.get('bar')).to.be.ok
+    const fork2 = loader.expectFork(beta)
+    expect(fork2.ctx.get('bar')).to.be.undefined
+
+    foo.mock.resetCalls()
+    dispose.mock.resetCalls()
+
+    await loader.update(group, {
+      isolate: {
+        bar: 'beta',
+      },
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(foo.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(1)
+    expect(fork1.ctx.get('bar')).to.be.undefined
+    expect(fork2.ctx.get('bar')).to.be.ok
   })
 })

packages/loader/tests/utils.ts

@@ -1,5 +1,5 @@
 import { Dict } from 'cosmokit'
-import { Context, Plugin } from '@cordisjs/core'
+import { Context, ForkScope, Plugin } from '@cordisjs/core'
 import { Entry, group, Loader } from '../src'
 import { Mock, mock } from 'node:test'
 import { expect } from 'chai'
@@ -9,6 +9,7 @@ declare module '../src/shared' {
     mock<F extends Function>(name: string, plugin: F): Mock<F>
     expectEnable(plugin: any, config?: any): void
     expectDisable(plugin: any): void
+    expectFork(id: string): ForkScope
   }
 }
 
@@ -44,4 +45,9 @@ export default class MockLoader extends Loader {
     const runtime = this.ctx.registry.get(plugin)
     expect(runtime).to.be.not.ok
   }
+
+  expectFork(id: string) {
+    expect(this.entries[id]?.fork).to.be.ok
+    return this.entries[id]!.fork!
+  }
 }