@eggjs/core 6.4.0 → 6.5.0

package/src/loader/file_loader.ts

@@ -2,10 +2,17 @@ import assert from 'node:assert';
 import fs from 'node:fs';
 import { debuglog } from 'node:util';
 import path from 'node:path';
+
 import globby from 'globby';
-import { isClass, isGeneratorFunction, isAsyncFunction, isPrimitive } from 'is-type-of';
+import {
+  isClass,
+  isGeneratorFunction,
+  isAsyncFunction,
+  isPrimitive,
+} from 'is-type-of';
 import { isSupportTypeScript } from '@eggjs/utils';
-import utils, { Fun } from '../utils/index.js';
+
+import utils, { type Fun } from '../utils/index.js';
 
 const debug = debuglog('@eggjs/core/file_loader');
 
@@ -19,13 +26,17 @@ export enum CaseStyle {
 }
 
 export type CaseStyleFunction = (filepath: string) => string[];
-export type FileLoaderInitializer = (exports: unknown, options: { path: string; pathName: string }) => unknown;
+export type FileLoaderInitializer = (
+  exports: unknown,
+  options: { path: string; pathName: string }
+) => unknown;
 export type FileLoaderFilter = (exports: unknown) => boolean;
 
 export interface FileLoaderOptions {
   /** directories to be loaded */
   directory: string | string[];
   /** attach the target object from loaded files */
+
   target: Record<string, any>;
   /** match the files when load, support glob, default to all js files */
   match?: string | string[];
@@ -38,6 +49,7 @@ export interface FileLoaderOptions {
   /** determine whether override the property when get the same name */
   override?: boolean;
   /** an object that be the argument when invoke the function */
+
   inject?: Record<string, any>;
   /** a function that filter the exports which can be loaded */
   filter?: FileLoaderFilter;
@@ -65,7 +77,8 @@ export class FileLoader {
     return EXPORTS;
   }
 
-  readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, 'caseStyle'>>;
+  readonly options: FileLoaderOptions &
+    Required<Pick<FileLoaderOptions, 'caseStyle'>>;
 
   /**
    * @class
@@ -101,7 +114,7 @@ export class FileLoader {
   /**
    * attach items to target object. Mapping the directory to properties.
    * `app/controller/group/repository.js` => `target.group.repository`
-   * @return {Object} target
+   * @returns {Object} target
    * @since 1.0.0
    */
   async load(): Promise<object> {
@@ -111,12 +124,15 @@ export class FileLoader {
       debug('loading item: %o', item);
       // item { properties: [ 'a', 'b', 'c'], exports }
       // => target.a.b.c = exports
+      // oxlint-disable-next-line unicorn/no-array-reduce
       item.properties.reduce((target, property, index) => {
         let obj;
         const properties = item.properties.slice(0, index + 1).join('.');
         if (index === item.properties.length - 1) {
-          if (property in target) {
-            if (!this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target[property][FULLPATH]} by ${item.fullpath}`);
+          if (property in target && !this.options.override) {
+            throw new Error(
+              `can't overwrite property '${properties}' from ${target[property][FULLPATH]} by ${item.fullpath}`
+            );
           }
           obj = item.exports;
           if (obj && !isPrimitive(obj)) {
@@ -157,37 +173,43 @@ export class FileLoader {
    * `Properties` is an array that contains the directory of a filepath.
    *
    * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
-   * @return {Array} items
+   * @returns {Array} items
    * @since 1.0.0
    */
   protected async parse(): Promise<FileLoaderParseItem[]> {
     let files = this.options.match;
-    if (!files) {
-      files = isSupportTypeScript()
-        ? [ '**/*.(js|ts)', '!**/*.d.ts' ]
-        : [ '**/*.js' ];
+    if (files) {
+      files = Array.isArray(files) ? files : [files];
     } else {
-      files = Array.isArray(files) ? files : [ files ];
+      files = isSupportTypeScript()
+        ? ['**/*.(js|ts)', '!**/*.d.ts']
+        : ['**/*.js'];
     }
 
     let ignore = this.options.ignore;
     if (ignore) {
-      ignore = Array.isArray(ignore) ? ignore : [ ignore ];
+      ignore = Array.isArray(ignore) ? ignore : [ignore];
       ignore = ignore.filter(f => !!f).map(f => '!' + f);
       files = files.concat(ignore);
     }
 
     let directories = this.options.directory;
     if (!Array.isArray(directories)) {
-      directories = [ directories ];
+      directories = [directories];
     }
 
-    const filter = typeof this.options.filter === 'function' ? this.options.filter : null;
+    const filter =
+      typeof this.options.filter === 'function' ? this.options.filter : null;
     const items: FileLoaderParseItem[] = [];
     debug('[parse] parsing directories: %j', directories);
     for (const directory of directories) {
       const filepaths = globby.sync(files, { cwd: directory });
-      debug('[parse] globby files: %o, cwd: %o => %o', files, directory, filepaths);
+      debug(
+        '[parse] globby files: %o, cwd: %o => %o',
+        files,
+        directory,
+        filepaths
+      );
       for (const filepath of filepaths) {
         const fullpath = path.join(directory, filepath);
         if (!fs.statSync(fullpath).isFile()) continue;
@@ -202,12 +224,17 @@ export class FileLoader {
         // app/service/foo/bar.js => [ 'foo', 'bar' ]
         const properties = getProperties(filepath, this.options.caseStyle);
         // app/service/foo/bar.js => service.foo.bar
-        const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
+        const pathName =
+          directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
         // get exports from the file
         const exports = await getExports(fullpath, this.options, pathName);
 
         // ignore exports when it's null or false returned by filter function
-        if (exports == null || (filter && filter(exports) === false)) {
+        if (
+          exports === null ||
+          exports === undefined ||
+          (filter && filter(exports) === false)
+        ) {
           continue;
         }
 
@@ -218,7 +245,12 @@ export class FileLoader {
         }
 
         items.push({ fullpath, properties, exports });
-        debug('[parse] parse %s, properties %j, exports %o', fullpath, properties, exports);
+        debug(
+          '[parse] parse %s, properties %j, exports %o',
+          fullpath,
+          properties,
+          exports
+        );
       }
     }
 
@@ -228,11 +260,17 @@ export class FileLoader {
 
 // convert file path to an array of properties
 // a/b/c.js => ['a', 'b', 'c']
-function getProperties(filepath: string, caseStyle: CaseStyle | CaseStyleFunction) {
+function getProperties(
+  filepath: string,
+  caseStyle: CaseStyle | CaseStyleFunction
+) {
   // if caseStyle is function, return the result of function
   if (typeof caseStyle === 'function') {
     const result = caseStyle(filepath);
-    assert(Array.isArray(result), `caseStyle expect an array, but got ${JSON.stringify(result)}`);
+    assert(
+      Array.isArray(result),
+      `caseStyle expect an array, but got ${JSON.stringify(result)}`
+    );
     return result;
   }
   // use default camelize
@@ -241,7 +279,11 @@ function getProperties(filepath: string, caseStyle: CaseStyle | CaseStyleFunctio
 
 // Get exports from filepath
 // If exports is null/undefined, it will be ignored
-async function getExports(fullpath: string, options: FileLoaderOptions, pathName: string) {
+async function getExports(
+  fullpath: string,
+  options: FileLoaderOptions,
+  pathName: string
+) {
   let exports = await utils.loadFile(fullpath);
   // process exports as you like
   if (options.initializer) {
@@ -250,7 +292,9 @@ async function getExports(fullpath: string, options: FileLoaderOptions, pathName
   }
 
   if (isGeneratorFunction(exports)) {
-    throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
+    throw new TypeError(
+      `Support for generators was removed, fullpath: ${fullpath}`
+    );
   }
 
   // return exports when it's a class or async function
@@ -269,7 +313,7 @@ async function getExports(fullpath: string, options: FileLoaderOptions, pathName
   // }
   if (options.call && typeof exports === 'function') {
     exports = exports(options.inject);
-    if (exports != null) {
+    if (exports !== null && exports !== undefined) {
       return exports;
     }
   }
@@ -279,7 +323,7 @@ async function getExports(fullpath: string, options: FileLoaderOptions, pathName
 }
 
 function defaultCamelize(filepath: string, caseStyle: CaseStyle) {
-  const properties = filepath.substring(0, filepath.lastIndexOf('.')).split('/');
+  const properties = filepath.slice(0, filepath.lastIndexOf('.')).split('/');
   return properties.map(property => {
     if (!/^[a-z][a-z0-9_-]*$/i.test(property)) {
       throw new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`);
@@ -291,18 +335,15 @@ function defaultCamelize(filepath: string, caseStyle: CaseStyle) {
     // FooBar.js  > FooBar
     // FooBar.js  > FooBar
     // FooBar.js  > fooBar (if lowercaseFirst is true)
-    property = property.replace(/[_-][a-z]/ig, s => s.substring(1).toUpperCase());
+    property = property.replaceAll(/[_-][a-z]/gi, s =>
+      s.slice(1).toUpperCase()
+    );
     let first = property[0];
-    switch (caseStyle) {
-      case 'lower':
-        first = first.toLowerCase();
-        break;
-      case 'upper':
-        first = first.toUpperCase();
-        break;
-      case 'camel':
-      default:
+    if (caseStyle === CaseStyle.lower) {
+      first = first.toLowerCase();
+    } else if (caseStyle === CaseStyle.upper) {
+      first = first.toUpperCase();
     }
-    return first + property.substring(1);
+    return first + property.slice(1);
   });
 }

package/src/singleton.ts

@@ -2,8 +2,11 @@ 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 type SingletonCreateMethod = (
+  config: Record<string, any>,
+  app: EggCore,
+  clientName: string
+) => unknown | Promise<unknown>;
 
 export interface SingletonOptions {
   name: string;
@@ -19,10 +22,22 @@ export class Singleton<T = any> {
   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`);
+    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;
@@ -35,8 +50,10 @@ export class Singleton<T = any> {
 
   initSync() {
     const options = this.options;
-    assert(!(options.client && options.clients),
-      `[@eggjs/core/singleton] ${this.name} can not set options.client and options.clients both`);
+    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) {
@@ -48,10 +65,10 @@ export class Singleton<T = any> {
 
     // multi client, use app[name].getSingletonInstance(id)
     if (options.clients) {
-      Object.keys(options.clients).forEach(id => {
+      for (const id of Object.keys(options.clients)) {
         const client = this.createInstance(options.clients[id], id);
         this.clients.set(id, client);
-      });
+      }
       this.#setClientToApp(this);
       return;
     }
@@ -62,12 +79,17 @@ export class Singleton<T = any> {
 
   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`);
+    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);
+      const client = await this.createInstanceAsync(
+        options.client,
+        options.name
+      );
       this.#setClientToApp(client);
       this.#extendDynamicMethods(client);
       return;
@@ -75,10 +97,13 @@ export class Singleton<T = any> {
 
     // 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));
-      }));
+      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;
     }
@@ -95,26 +120,32 @@ export class Singleton<T = any> {
    * @deprecated please use `getSingletonInstance(id)` instead
    */
   get(id: string) {
-    return this.clients.get(id)!;
+    return this.clients.get(id) as T;
   }
 
   /**
    * Get singleton instance by id
    */
   getSingletonInstance(id: string) {
-    return this.clients.get(id)!;
+    return this.clients.get(id) as T;
   }
 
   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`);
+    assert(
+      !isAsyncFunction(this.create),
+      `[@eggjs/core/singleton] ${this.name} only support asynchronous 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;
+    return (this.create as SingletonCreateMethod)(
+      config,
+      this.app,
+      clientName
+    ) as T;
   }
 
   async createInstanceAsync(config: Record<string, any>, clientName: string) {
@@ -123,12 +154,18 @@ export class Singleton<T = any> {
       ...this.options.default,
       ...config,
     };
-    return await this.create(config, this.app, clientName) as T;
+    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');
+    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;
@@ -142,7 +179,8 @@ export class Singleton<T = any> {
     } catch (err) {
       this.app.coreLogger.warn(
         '[@eggjs/core/singleton] %s dynamic create is disabled because of client is un-extendable',
-        this.name);
+        this.name
+      );
       this.app.coreLogger.warn(err);
     }
   }

package/src/utils/index.ts

@@ -3,20 +3,22 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { stat } from 'node:fs/promises';
 import BuiltinModule from 'node:module';
+
 import { importResolve, importModule } from '@eggjs/utils';
 
 const debug = debuglog('@eggjs/core/utils');
 
-export type Fun = (...args: any[]) => any;
+export type Fun = (...args: unknown[]) => unknown;
 
 // Guard against poorly mocked module constructors.
-const Module = typeof module !== 'undefined' && module.constructor.length > 1
-  ? module.constructor
-  /* istanbul ignore next */
-  : BuiltinModule;
+const Module =
+  typeof module !== 'undefined' && module.constructor.length > 1
+    ? module.constructor
+    : /* istanbul ignore next */
+      BuiltinModule;
 
 const extensions = (Module as any)._extensions;
-const extensionNames = Object.keys(extensions).concat([ '.cjs', '.mjs' ]);
+const extensionNames = Object.keys(extensions).concat(['.cjs', '.mjs']);
 debug('Module extensions: %j', extensionNames);
 
 function getCalleeFromStack(withLine?: boolean, stackIndex?: number) {
@@ -28,6 +30,7 @@ function getCalleeFromStack(withLine?: boolean, stackIndex?: number) {
   Error.stackTraceLimit = 5;
 
   // capture the stack
+
   const obj: any = {};
   Error.captureStackTrace(obj);
   let callSite = obj.stack[stackIndex];
@@ -58,7 +61,9 @@ export default {
       console.trace('[@eggjs/core/deprecated] %s', message);
     } else {
       console.log('[@eggjs/core/deprecated] %s', message);
-      console.log('[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack');
+      console.log(
+        '[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack'
+      );
     }
   },
 
@@ -83,13 +88,15 @@ export default {
       }
       const obj = await importModule(filepath, { importDefaultOnly: true });
       return obj;
-    } catch (e: any) {
-      if (!e.message && typeof e !== 'string') {
+    } catch (e) {
+      if (!(e instanceof Error)) {
         // 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}`);
+      const err = new Error(
+        `[@eggjs/core] load file: ${filepath}, error: ${e.message}`
+      );
       err.cause = e;
       debug('[loadFile] handle %s error: %s', filepath, e);
       throw err;
@@ -100,9 +107,9 @@ export default {
     return importResolve(filepath, options);
   },
 
-  methods: [ 'head', 'options', 'get', 'put', 'patch', 'post', 'delete' ],
+  methods: ['head', 'options', 'get', 'put', 'patch', 'post', 'delete'],
 
-  async callFn(fn: Fun, args?: any[], ctx?: any) {
+  async callFn(fn: Fun, args?: unknown[], ctx?: unknown) {
     args = args || [];
     if (typeof fn !== 'function') return;
     return ctx ? fn.call(ctx, ...args) : fn(...args);
@@ -120,6 +127,6 @@ export default {
  * Capture call site stack from v8.
  * https://github.com/v8/v8/wiki/Stack-Trace-API
  */
-function prepareObjectStackTrace(_obj: any, stack: any) {
+function prepareObjectStackTrace(_obj: unknown, stack: unknown) {
   return stack;
 }

package/src/utils/sequencify.ts

@@ -12,27 +12,59 @@ export interface SequencifyTask {
   optionalDependencies: string[];
 }
 
-function sequence(tasks: Record<string, SequencifyTask>, names: string[], result: SequencifyResult,
-  missing: string[], recursive: string[],
-  nest: string[], optional: boolean, parent: string) {
-  names.forEach(function(name) {
-    if (result.requires[name]) return;
-
+function sequence(
+  // oxlint-disable-next-line max-params
+  tasks: Record<string, SequencifyTask>,
+  names: string[],
+  result: SequencifyResult,
+  missing: string[],
+  recursive: string[],
+  nest: string[],
+  optional: boolean,
+  parent: string
+) {
+  for (const name of names) {
+    if (result.requires[name]) {
+      continue;
+    }
     const node = tasks[name];
     if (!node) {
-      if (optional === true) return;
+      if (optional === true) {
+        continue;
+      }
       missing.push(name);
     } else if (nest.includes(name)) {
       nest.push(name);
       recursive.push(...nest.slice(0));
       nest.pop();
-    } else if (node.dependencies.length || node.optionalDependencies.length) {
+    } else if (
+      node.dependencies.length > 0 ||
+      node.optionalDependencies.length > 0
+    ) {
       nest.push(name);
-      if (node.dependencies.length) {
-        sequence(tasks, node.dependencies, result, missing, recursive, nest, optional, name);
+      if (node.dependencies.length > 0) {
+        sequence(
+          tasks,
+          node.dependencies,
+          result,
+          missing,
+          recursive,
+          nest,
+          optional,
+          name
+        );
       }
-      if (node.optionalDependencies.length) {
-        sequence(tasks, node.optionalDependencies, result, missing, recursive, nest, true, name);
+      if (node.optionalDependencies.length > 0) {
+        sequence(
+          tasks,
+          node.optionalDependencies,
+          result,
+          missing,
+          recursive,
+          nest,
+          true,
+          name
+        );
       }
       nest.pop();
     }
@@ -43,12 +75,15 @@ function sequence(tasks: Record<string, SequencifyTask>, names: string[], result
     if (!result.sequence.includes(name)) {
       result.sequence.push(name);
     }
-  });
+  }
 }
 
 // tasks: object with keys as task names
 // names: array of task names
-export default function sequencify(tasks: Record<string, SequencifyTask>, names: string[]) {
+export function sequencify(
+  tasks: Record<string, SequencifyTask>,
+  names: string[]
+) {
   const result: SequencifyResult = {
     sequence: [],
     requires: {},
@@ -58,7 +93,7 @@ export default function sequencify(tasks: Record<string, SequencifyTask>, names:
 
   sequence(tasks, names, result, missing, recursive, [], false, 'app');
 
-  if (missing.length || recursive.length) {
+  if (missing.length > 0 || recursive.length > 0) {
     result.sequence = []; // results are incomplete at best, completely wrong at worst, remove them to avoid confusion
   }