@eggjs/core 6.3.0-beta.0 → 6.3.0

package/src/singleton.ts

@@ -0,0 +1,149 @@
+import assert from 'node:assert';
+import { isAsyncFunction } from 'is-type-of';
+import type { EggCore } from './egg.js';
+
+export type SingletonCreateMethod =
+  (config: Record<string, any>, app: EggCore, clientName: string) => unknown | Promise<unknown>;
+
+export interface SingletonOptions {
+  name: string;
+  app: EggCore;
+  create: SingletonCreateMethod;
+}
+
+export class Singleton<T = any> {
+  readonly clients = new Map<string, T>();
+  readonly app: EggCore;
+  readonly create: SingletonCreateMethod;
+  readonly name: string;
+  readonly options: Record<string, any>;
+
+  constructor(options: SingletonOptions) {
+    assert(options.name, '[@eggjs/core/singleton] Singleton#constructor options.name is required');
+    assert(options.app, '[@eggjs/core/singleton] Singleton#constructor options.app is required');
+    assert(options.create, '[@eggjs/core/singleton] Singleton#constructor options.create is required');
+    assert(!(options.name in options.app), `[@eggjs/core/singleton] ${options.name} is already exists in app`);
+    this.app = options.app;
+    this.name = options.name;
+    this.create = options.create;
+    this.options = options.app.config[this.name] ?? {};
+  }
+
+  init() {
+    return isAsyncFunction(this.create) ? this.initAsync() : this.initSync();
+  }
+
+  initSync() {
+    const options = this.options;
+    assert(!(options.client && options.clients),
+      `[@eggjs/core/singleton] ${this.name} can not set options.client and options.clients both`);
+
+    // alias app[name] as client, but still support createInstance method
+    if (options.client) {
+      const client = this.createInstance(options.client, options.name);
+      this.#setClientToApp(client);
+      this.#extendDynamicMethods(client);
+      return;
+    }
+
+    // multi client, use app[name].getSingletonInstance(id)
+    if (options.clients) {
+      Object.keys(options.clients).forEach(id => {
+        const client = this.createInstance(options.clients[id], id);
+        this.clients.set(id, client);
+      });
+      this.#setClientToApp(this);
+      return;
+    }
+
+    // no config.clients and config.client
+    this.#setClientToApp(this);
+  }
+
+  async initAsync() {
+    const options = this.options;
+    assert(!(options.client && options.clients),
+      `[@eggjs/core/singleton] ${this.name} can not set options.client and options.clients both`);
+
+    // alias app[name] as client, but still support createInstance method
+    if (options.client) {
+      const client = await this.createInstanceAsync(options.client, options.name);
+      this.#setClientToApp(client);
+      this.#extendDynamicMethods(client);
+      return;
+    }
+
+    // multi client, use app[name].getInstance(id)
+    if (options.clients) {
+      await Promise.all(Object.keys(options.clients).map((id: string) => {
+        return this.createInstanceAsync(options.clients[id], id)
+          .then(client => this.clients.set(id, client));
+      }));
+      this.#setClientToApp(this);
+      return;
+    }
+
+    // no config.clients and config.client
+    this.#setClientToApp(this);
+  }
+
+  #setClientToApp(client: unknown) {
+    Reflect.set(this.app, this.name, client);
+  }
+
+  /**
+   * @deprecated please use `getSingletonInstance(id)` instead
+   */
+  get(id: string) {
+    return this.clients.get(id)!;
+  }
+
+  /**
+   * Get singleton instance by id
+   */
+  getSingletonInstance(id: string) {
+    return this.clients.get(id)!;
+  }
+
+  createInstance(config: Record<string, any>, clientName: string) {
+    // async creator only support createInstanceAsync
+    assert(!isAsyncFunction(this.create),
+      `[@eggjs/core/singleton] ${this.name} only support synchronous creation, please use createInstanceAsync`);
+    // options.default will be merge in to options.clients[id]
+    config = {
+      ...this.options.default,
+      ...config,
+    };
+    return (this.create as SingletonCreateMethod)(config, this.app, clientName) as T;
+  }
+
+  async createInstanceAsync(config: Record<string, any>, clientName: string) {
+    // options.default will be merge in to options.clients[id]
+    config = {
+      ...this.options.default,
+      ...config,
+    };
+    return await this.create(config, this.app, clientName) as T;
+  }
+
+  #extendDynamicMethods(client: any) {
+    assert(!client.createInstance, '[@eggjs/core/singleton] singleton instance should not have createInstance method');
+    assert(!client.createInstanceAsync, '[@eggjs/core/singleton] singleton instance should not have createInstanceAsync method');
+
+    try {
+      let extendable = client;
+      // Object.preventExtensions() or Object.freeze()
+      if (!Object.isExtensible(client) || Object.isFrozen(client)) {
+        // eslint-disable-next-line no-proto
+        extendable = client.__proto__ || client;
+      }
+      extendable.createInstance = this.createInstance.bind(this);
+      extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
+    } catch (err) {
+      this.app.coreLogger.warn(
+        '[@eggjs/core/singleton] %s dynamic create is disabled because of client is un-extendable',
+        this.name);
+      this.app.coreLogger.warn(err);
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,56 @@
+export interface EggAppInfo {
+  /** package.json */
+  pkg: Record<string, any>;
+  /** the application name from package.json */
+  name: string;
+  /** current directory of application */
+  baseDir: string;
+  /** equals to serverEnv */
+  env: string;
+  /** equals to serverScope */
+  scope: string;
+  /** home directory of the OS */
+  HOME: string;
+  /** baseDir when local and unittest, HOME when other environment */
+  root: string;
+}
+
+export interface EggPluginInfo {
+  /** the plugin name, it can be used in `dep` */
+  name: string;
+  /** the package name of plugin */
+  package?: string;
+  version?: string;
+  /** whether enabled */
+  enable: boolean;
+  implicitEnable?: boolean;
+  /** the directory of the plugin package */
+  path?: string;
+  /** the dependent plugins, you can use the plugin name */
+  dependencies: string[];
+  /** the optional dependent plugins. */
+  optionalDependencies: string[];
+  dependents?: string[];
+  /** specify the serverEnv that only enable the plugin in it */
+  env: string[];
+  /** the file plugin config in. */
+  from: string;
+}
+
+export interface CustomLoaderConfigItem {
+  /** the directory of the custom loader */
+  directory: string;
+  /** the inject object, it can be app or ctx */
+  inject: string;
+  /** whether load unit files */
+  loadunit?: boolean;
+}
+
+export interface EggAppConfig extends Record<string, any> {
+  coreMiddleware: string[];
+  middleware: string[];
+  customLoader?: Record<string, CustomLoaderConfigItem>;
+  controller?: {
+    supportParams?: boolean;
+  };
+}

package/src/utils/index.ts

@@ -5,7 +5,7 @@ import { stat } from 'node:fs/promises';
 import BuiltinModule from 'node:module';
 import { importResolve, importModule } from '@eggjs/utils';
 
-const debug = debuglog('@eggjs/core:utils');
+const debug = debuglog('@eggjs/core/utils');
 
 export type Fun = (...args: any[]) => any;
 
@@ -55,10 +55,10 @@ function getCalleeFromStack(withLine?: boolean, stackIndex?: number) {
 export default {
   deprecated(message: string) {
     if (debug.enabled) {
-      console.trace('[@eggjs/core:deprecated] %s', message);
+      console.trace('[@eggjs/core/deprecated] %s', message);
     } else {
-      console.warn('[@eggjs/core:deprecated] %s', message);
-      console.warn('[@eggjs/core:deprecated] set NODE_DEBUG=@eggjs/core:utils can show call stack');
+      console.log('[@eggjs/core/deprecated] %s', message);
+      console.log('[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack');
     }
   },
 
@@ -84,6 +84,11 @@ export default {
       const obj = await importModule(filepath, { importDefaultOnly: true });
       return obj;
     } catch (e: any) {
+      if (!e.message && typeof e !== 'string') {
+        // ts error: test/fixtures/apps/app-ts/app/extend/context.ts(5,17): error TS2339: Property 'url' does not exist on type 'Context'
+        console.trace(e);
+        throw e;
+      }
       const err = new Error(`[@eggjs/core] load file: ${filepath}, error: ${e.message}`);
       err.cause = e;
       debug('[loadFile] handle %s error: %s', filepath, e);

package/src/utils/sequencify.ts

@@ -1,6 +1,6 @@
 import { debuglog } from 'node:util';
 
-const debug = debuglog('@eggjs/core:utils:sequencify');
+const debug = debuglog('@eggjs/core/utils/sequencify');
 
 export interface SequencifyResult {
   sequence: string[];

package/src/utils/timing.ts

@@ -2,7 +2,7 @@ import { EOL } from 'node:os';
 import { debuglog } from 'node:util';
 import assert from 'node:assert';
 
-const debug = debuglog('@eggjs/core:utils:timing');
+const debug = debuglog('@eggjs/core/utils/timing');
 
 export interface TimingItem {
   name: string;