refa: move node-specific logic to cli package

Author: shigma

packages/cordis/package.json

@@ -70,6 +70,7 @@
     "@cordisjs/plugin-logger": "^1.0.1",
     "cac": "^6.7.14",
     "cosmokit": "^1.8.0",
+    "dotenv": "^16.4.7",
     "kleur": "^4.1.5",
     "schemastery": "^3.15.0"
   }

packages/cordis/src/worker/index.ts

@@ -3,6 +3,9 @@ import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
 import Logger from '@cordisjs/plugin-logger'
 import * as daemon from './daemon.ts'
+import * as dotenv from 'dotenv'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
 
 export interface Options extends Loader.Config {
   execArgv?: string[]
@@ -11,6 +14,19 @@ export interface Options extends Loader.Config {
 }
 
 export async function start(options: Options) {
+  // load .env files
+  const override = {}
+  const envFiles = ['.env', '.env.local']
+  for (const filename of envFiles) {
+    try {
+      const raw = await readFile(join(process.cwd(), filename), 'utf8')
+      Object.assign(override, dotenv.parse(raw))
+    } catch {}
+  }
+  for (const key in override) {
+    process.env[key] = override[key]
+  }
+
   const ctx = new Context()
   if (options.logger) await ctx.plugin(Logger, options.logger)
   if (options.daemon) await ctx.plugin(daemon, options.daemon)

packages/loader/package.json

@@ -48,7 +48,6 @@
   },
   "dependencies": {
     "cosmokit": "^1.8.0",
-    "dotenv": "^16.4.7",
     "js-yaml": "^4.1.0"
   }
 }

packages/loader/src/config/file.ts renamed to packages/loader/src/file.ts

@@ -2,9 +2,9 @@ import { access, constants, readFile, rename, writeFile } from 'node:fs/promises
 import { pathToFileURL } from 'node:url'
 import { remove } from 'cosmokit'
 import * as yaml from 'js-yaml'
-import { EntryOptions } from './entry.ts'
+import { EntryOptions } from './config/entry.ts'
+import { JsExpr } from './config/utils.ts'
 import { ImportTree } from './import.ts'
-import { JsExpr } from './utils.ts'
 import { dirname } from 'node:path'
 
 export const schema = yaml.JSON_SCHEMA.extend(JsExpr)

packages/loader/src/config/import.ts renamed to packages/loader/src/import.ts

@@ -2,9 +2,9 @@ import { Context, Service } from '@cordisjs/core'
 import { dirname, extname, resolve } from 'node:path'
 import { readdir, stat } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
-import { EntryTree } from './tree.ts'
+import { EntryTree } from './config/tree.ts'
 import { LoaderFile } from './file.ts'
-import Loader from '../loader.ts'
+import Loader from './loader.ts'
 
 export class ImportTree<C extends Context = Context> extends EntryTree<C> {
   public file!: LoaderFile

packages/loader/src/index.ts

@@ -1,70 +0,0 @@
-import { Module } from 'node:module'
-import { pathToFileURL } from 'node:url'
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { Service } from '@cordisjs/core'
-import { Loader } from './loader.ts'
-import * as dotenv from 'dotenv'
-import { ModuleLoader } from './internal.ts'
-
-export * from './internal.ts'
-export * from './loader.ts'
-
-type ModuleLoad = (request: string, parent: Module, isMain: boolean) => any
-
-namespace NodeLoader {
-  export interface Config extends Loader.Config {}
-}
-
-class NodeLoader extends Loader {
-  static readonly exitCode = 51
-
-  public internal = ModuleLoader.fromInternal()
-
-  async* [Service.init]() {
-    const originalLoad: ModuleLoad = Module['_load']
-    Module['_load'] = ((request, parent, isMain) => {
-      try {
-        return originalLoad(request, parent, isMain)
-      } catch (e: any) {
-        if (e.code !== 'ERR_REQUIRE_ESM' || !this.internal) throw e
-        try {
-          // TODO support hmr for cjs-esm interop
-          const result = this.internal.resolveSync(request, pathToFileURL(parent.filename).href, {})
-          const job = result?.format === 'module'
-            ? this.internal.loadCache.get(result.url)
-            : undefined
-          if (job) return job?.module?.getNamespace()
-        } catch {
-          throw e
-        }
-      }
-    }) as ModuleLoad
-
-    // load .env files
-    const override = {}
-    const envFiles = ['.env', '.env.local']
-    for (const filename of envFiles) {
-      try {
-        const raw = await readFile(join(process.cwd(), filename), 'utf8')
-        Object.assign(override, dotenv.parse(raw))
-      } catch {}
-    }
-    for (const key in override) {
-      process.env[key] = override[key]
-    }
-
-    yield* super[Service.init]()
-  }
-
-  exit(code = NodeLoader.exitCode) {
-    const body = JSON.stringify(this.envData)
-    process.send?.({ type: 'shared', body }, (err: any) => {
-      if (err) this.ctx.emit(this.ctx, 'internal/error', 'failed to send shared data')
-      this.ctx.root.logger?.('loader').info('trigger full reload')
-      process.exit(code)
-    })
-  }
-}
-
-export default NodeLoader

packages/loader/src/internal.ts

@@ -57,12 +57,15 @@ export namespace ModuleLoader {
     (require) => require('internal/process/esm_loader').esmLoader,
   ]
 
+  let _cachedLoader: ModuleLoader | undefined
+
   export function fromInternal() {
     if (!process.execArgv.includes('--expose-internals')) return
+    if (_cachedLoader) return _cachedLoader
     const require = createRequire(import.meta.url)
     for (const loader of internalLoaders) {
       try {
-        return loader(require)
+        return _cachedLoader = loader(require)
       } catch {}
     }
   }

packages/loader/src/loader.ts

@@ -3,16 +3,16 @@ import type {} from '@cordisjs/plugin-logger'
 import { defineProperty, Dict, isNullable } from 'cosmokit'
 import { ModuleLoader } from './internal.ts'
 import { Entry, EntryOptions } from './config/entry.ts'
-import { LoaderFile } from './config/file.ts'
-import { ImportTree } from './config/import.ts'
+import { EntryTree } from './config/tree.ts'
 import isolate from './config/isolate.ts'
+import { LoaderFile } from './loader.ts'
 
 export * from './config/entry.ts'
-export * from './config/file.ts'
 export * from './config/group.ts'
-export * from './config/import.ts'
 export * from './config/isolate.ts'
 export * from './config/tree.ts'
+export * from './file.ts'
+export * from './import.ts'
 
 declare module '@cordisjs/core' {
   interface Events {
@@ -49,7 +49,7 @@ export namespace Loader {
   }
 }
 
-export abstract class Loader<C extends Context = Context> extends ImportTree<C> {
+export abstract class Loader<C extends Context = Context> extends EntryTree<C> {
   declare [Service.config]: Loader.Intercept
 
   public envData = process.env.CORDIS_SHARED
@@ -126,10 +126,10 @@ export abstract class Loader<C extends Context = Context> extends ImportTree<C>
     ctx.plugin(isolate)
   }
 
-  async* [Service.init]() {
-    await this.init(process.cwd(), this.config)
-    yield* super[Service.init]()
-  }
+  // async* [Service.init]() {
+  //   await this.init(process.cwd(), this.config)
+  //   yield* super[Service.init]()
+  // }
 
   [Service.check]() {
     const config: Loader.Intercept = Service.prototype[Service.resolveConfig].call(this)
@@ -151,7 +151,14 @@ export abstract class Loader<C extends Context = Context> extends ImportTree<C>
     }
   }
 
-  exit() {}
+  exit() {
+    // const body = JSON.stringify(this.envData)
+    // process.send?.({ type: 'shared', body }, (err: any) => {
+    //   if (err) this.ctx.emit(this.ctx, 'internal/error', 'failed to send shared data')
+    //   this.ctx.root.logger?.('loader').info('trigger full reload')
+    //   process.exit(code)
+    // })
+  }
 
   unwrapExports(exports: any) {
     if (isNullable(exports)) return exports