feat(loader): basic support for group.write()

Author: shigma

packages/hmr/src/index.ts

@@ -72,7 +72,7 @@ class Watcher extends Service {
   constructor(ctx: Context, public config: Watcher.Config) {
     super(ctx, 'hmr')
     this.base = resolve(ctx.baseDir, config.base || '')
-    this.initialURL = pathToFileURL(ctx.loader.file.name).href
+    this.initialURL = ctx.loader.file.url
   }
 
   relative(filename: string) {

packages/loader/src/entry.ts

@@ -1,6 +1,6 @@
 import { Context, ForkScope, Inject } from '@cordisjs/core'
 import { Dict } from 'cosmokit'
-import Loader from './shared.ts'
+import { Loader } from './shared.ts'
 import { EntryGroup } from './group.ts'
 
 export namespace Entry {
@@ -46,7 +46,7 @@ export class Entry {
   static key = Symbol('cordis.entry')
 
   public fork?: ForkScope
-  public isUpdate = false
+  public suspend = false
   public options!: Entry.Options
   public children?: EntryGroup
 
@@ -150,7 +150,7 @@ export class Entry {
     if (!this.loader.isTruthyLike(options.when) || options.disabled) {
       this.stop()
     } else if (this.fork) {
-      this.isUpdate = true
+      this.suspend = true
       for (const [key, label] of Object.entries(legacy.isolate ?? {})) {
         if (this.options.isolate?.[key] === label) continue
         const name = this.resolveRealm(label)

packages/loader/src/file.ts

@@ -1,15 +1,19 @@
 import { access, constants, readFile, writeFile } from 'node:fs/promises'
 import { pathToFileURL } from 'node:url'
 import * as yaml from 'js-yaml'
-import Loader from './shared.ts'
+import { Entry } from './entry.ts'
+import { Loader } from './shared.ts'
 
 export class FileLoader<T extends Loader = Loader> {
+  public url: string
   public suspend = false
   public mutable = false
 
   private _writeTask?: NodeJS.Timeout
 
-  constructor(public loader: T, public name: string, public type?: string) {}
+  constructor(public loader: T, public name: string, public type?: string) {
+    this.url = pathToFileURL(name).href
+  }
 
   async checkAccess() {
     if (!this.type) return
@@ -19,7 +23,7 @@ export class FileLoader<T extends Loader = Loader> {
     } catch {}
   }
 
-  async read() {
+  async read(): Promise<Entry.Options[]> {
     if (this.type === 'application/yaml') {
       return yaml.load(await readFile(this.name, 'utf8')) as any
     } else if (this.type === 'application/json') {
@@ -31,7 +35,7 @@ export class FileLoader<T extends Loader = Loader> {
     }
   }
 
-  private async _write(config: any) {
+  private async _write(config: Entry.Options[]) {
     this.suspend = true
     if (!this.mutable) {
       throw new Error(`cannot overwrite readonly config`)
@@ -43,7 +47,8 @@ export class FileLoader<T extends Loader = Loader> {
     }
   }
 
-  write(config: any) {
+  write(config: Entry.Options[]) {
+    this.loader.app.emit('config')
     clearTimeout(this._writeTask)
     this._writeTask = setTimeout(() => {
       this._writeTask = undefined
@@ -53,9 +58,13 @@ export class FileLoader<T extends Loader = Loader> {
 
   async import(name: string) {
     if (this.loader.internal) {
-      return this.loader.internal.import(name, pathToFileURL(this.name).href, {})
+      return this.loader.internal.import(name, this.url, {})
     } else {
       return import(name)
     }
   }
+
+  dispose() {
+    clearTimeout(this._writeTask)
+  }
 }

packages/loader/src/group.ts

@@ -1,11 +1,14 @@
 import { Context } from '@cordisjs/core'
 import { FileLoader } from './file.ts'
 import { Entry } from './entry.ts'
+import { fileURLToPath } from 'node:url'
 
 export class EntryGroup {
   public data: Entry.Options[] = []
 
-  constructor(public ctx: Context) {}
+  constructor(public ctx: Context) {
+    ctx.on('dispose', () => this.stop())
+  }
 
   async _create(options: Omit<Entry.Options, 'id'>) {
     const id = this.ctx.loader.ensureId(options)
@@ -47,7 +50,11 @@ export class EntryGroup {
     }
   }
 
-  dispose() {
+  write() {
+    this.ctx.loader.file.write(this.ctx.loader.root.data)
+  }
+
+  stop() {
     for (const options of this.data) {
       this._remove(options.id)
     }
@@ -72,9 +79,6 @@ export function defineGroup(config?: Entry.Options[], options: GroupOptions = {}
     constructor(public ctx: Context) {
       super(ctx)
       ctx.scope.entry!.children = this
-      ctx.on('dispose', () => {
-        this.dispose()
-      })
       ctx.accept((config: Entry.Options[]) => {
         this.update(config)
       }, { passive: true, immediate: true })
@@ -88,8 +92,8 @@ export const group = defineGroup()
 
 export namespace Import {
   export interface Config {
-    path: string
-    disabled?: boolean
+    url: string
+    // disabled?: boolean
   }
 }
 
@@ -98,5 +102,19 @@ export class Import extends EntryGroup {
 
   constructor(public ctx: Context, public config: Import.Config) {
     super(ctx)
+    ctx.on('ready', () => this.start())
+  }
+
+  async start() {
+    const { url } = this.config
+    const filename = fileURLToPath(new URL(url, this.ctx.loader.file.url))
+    this.file = new FileLoader(this.ctx.loader, filename)
+    this.update(await this.file.read())
+    await this.file.checkAccess()
+  }
+
+  stop() {
+    this.file?.dispose()
+    return super.stop()
   }
 }

packages/loader/src/index.ts

@@ -1,4 +1,4 @@
-import Loader from './shared.ts'
+import { Loader } from './shared.ts'
 import { promises as fs } from 'fs'
 import * as dotenv from 'dotenv'
 import * as path from 'path'

packages/loader/src/shared.ts

@@ -58,7 +58,7 @@ export namespace Loader {
   }
 }
 
-export abstract class Loader<T extends Loader.Options = Loader.Options> extends Service<Entry.Options[]> {
+export abstract class Loader<T extends Loader.Options = Loader.Options> extends Service<T> {
   // TODO auto inject optional when provided?
   static inject = {
     optional: ['loader'],
@@ -83,7 +83,7 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
 
   private tasks = new Set<Promise<any>>()
 
-  constructor(public app: Context, public options: T) {
+  constructor(public app: Context, public config: T) {
     super(app, 'loader', true)
     this.root = new EntryGroup(this.app)
     this.realms['#'] = app.root[Context.isolate]
@@ -99,10 +99,10 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
 
     this.app.on('internal/before-update', (fork, config) => {
       if (!fork.entry) return
-      if (fork.entry.isUpdate) return fork.entry.isUpdate = false
+      if (fork.entry.suspend) return fork.entry.suspend = false
       const { schema } = fork.runtime
       fork.entry.options.config = schema ? schema.simplify(config) : config
-      this.file.write(this.config)
+      fork.entry.parent.write()
     })
 
     this.app.on('internal/fork', (fork) => {
@@ -121,7 +121,7 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
       fork.entry.options.disabled = true
       fork.entry.fork = undefined
       fork.entry.stop()
-      this.file.write(this.config)
+      fork.entry.parent.write()
     })
   }
 
@@ -144,29 +144,30 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
     } else {
       await this.findConfig()
     }
+    this.app.on('dispose', () => this.file.dispose())
     await this.file.checkAccess()
     this.app.provide('baseDir', this.baseDir, true)
   }
 
   private async findConfig() {
+    const { name, initial } = this.config
     const dirents = await readdir(this.baseDir, { withFileTypes: true })
     for (const extension of supported) {
-      const dirent = dirents.find(dirent => dirent.name === this.options.name + extension)
+      const dirent = dirents.find(dirent => dirent.name === name + extension)
       if (!dirent) continue
       if (!dirent.isFile()) {
         throw new Error(`config file "${dirent.name}" is not a file`)
       }
       const type = writable[extension]
-      const name = path.resolve(this.baseDir, this.options.name + extension)
-      this.file = new FileLoader(this, name, type)
+      const filename = path.resolve(this.baseDir, name + extension)
+      this.file = new FileLoader(this, filename, type)
       return
     }
-    if (this.options.initial) {
-      this.config = this.options.initial as any
+    if (initial) {
       const type = writable['.yml']
-      const name = path.resolve(this.baseDir, this.options.name + '.yml')
-      this.file = new FileLoader(this, name, type)
-      return this.file.write(this.config)
+      const filename = path.resolve(this.baseDir, name + '.yml')
+      this.file = new FileLoader(this, filename, type)
+      return this.file.write(initial as any)
     }
     throw new Error('config file not found')
   }
@@ -218,7 +219,7 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
         override[key] = value
       }
     }
-    this.file.write(this.config)
+    entry.parent.write()
     return entry.update(override)
   }
 
@@ -231,15 +232,15 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
   async create(options: Omit<Entry.Options, 'id'>, parent: string | null = null, position = Infinity) {
     const group = this.resolveGroup(parent)
     group.data.splice(position, 0, options as Entry.Options)
-    this.file.write(this.config)
+    group.write()
     return group._create(options)
   }
 
   remove(id: string) {
     const entry = this.entries[id]
     if (!entry) throw new Error(`entry ${id} not found`)
     entry.parent._remove(id)
-    this.file.write(this.config)
+    entry.parent.write()
   }
 
   transfer(id: string, parent: string | null, position = Infinity) {
@@ -249,7 +250,8 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
     const target = this.resolveGroup(parent)
     source._unlink(entry.options)
     target.data.splice(position, 0, entry.options)
-    this.file.write(this.config)
+    source.write()
+    target.write()
     if (source === target) return
     entry.parent = target
     if (!entry.fork) return
@@ -275,8 +277,7 @@ export abstract class Loader<T extends Loader.Options = Loader.Options> extends
   }
 
   async start() {
-    this.config = await this.file.read()
-    this.root.update(this.config)
+    this.root.update(await this.file.read())
 
     while (this.tasks.size) {
       await Promise.all(this.tasks)