@eggjs/core 6.4.1 → 6.6.0-beta.2

package/src/loader/file_loader.ts

@@ -1,308 +0,0 @@
-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 { isSupportTypeScript } from '@eggjs/utils';
-import utils, { Fun } from '../utils/index.js';
-
-const debug = debuglog('@eggjs/core/file_loader');
-
-export const FULLPATH = Symbol('EGG_LOADER_ITEM_FULLPATH');
-export const EXPORTS = Symbol('EGG_LOADER_ITEM_EXPORTS');
-
-export enum CaseStyle {
-  camel = 'camel',
-  lower = 'lower',
-  upper = 'upper',
-}
-
-export type CaseStyleFunction = (filepath: string) => string[];
-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[];
-  /** ignore the files when load, support glob */
-  ignore?: string | string[];
-  /** custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path` */
-  initializer?: FileLoaderInitializer;
-  /** determine whether invoke when exports is function */
-  call?: boolean;
-  /** 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;
-  /** set property's case when converting a filepath to property list. */
-  caseStyle?: CaseStyle | CaseStyleFunction;
-  lowercaseFirst?: boolean;
-}
-
-export interface FileLoaderParseItem {
-  fullpath: string;
-  properties: string[];
-  exports: object | Fun;
-}
-
-/**
- * Load files from directory to target object.
- * @since 1.0.0
- */
-export class FileLoader {
-  static get FULLPATH() {
-    return FULLPATH;
-  }
-
-  static get EXPORTS() {
-    return EXPORTS;
-  }
-
-  readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, 'caseStyle'>>;
-
-  /**
-   * @class
-   * @param {Object} options - options
-   * @param {String|Array} options.directory - directories to be loaded
-   * @param {Object} options.target - attach the target object from loaded files
-   * @param {String} options.match - match the files when load, support glob, default to all js files
-   * @param {String} options.ignore - ignore the files when load, support glob
-   * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
-   * @param {Boolean} options.call - determine whether invoke when exports is function
-   * @param {Boolean} options.override - determine whether override the property when get the same name
-   * @param {Object} options.inject - an object that be the argument when invoke the function
-   * @param {Function} options.filter - a function that filter the exports which can be loaded
-   * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
-   */
-  constructor(options: FileLoaderOptions) {
-    assert(options.directory, 'options.directory is required');
-    assert(options.target, 'options.target is required');
-    this.options = {
-      caseStyle: CaseStyle.camel,
-      call: true,
-      override: false,
-      ...options,
-    };
-
-    // compatible old options _lowercaseFirst_
-    if (this.options.lowercaseFirst === true) {
-      utils.deprecated('lowercaseFirst is deprecated, use caseStyle instead');
-      this.options.caseStyle = CaseStyle.lower;
-    }
-  }
-
-  /**
-   * attach items to target object. Mapping the directory to properties.
-   * `app/controller/group/repository.js` => `target.group.repository`
-   * @return {Object} target
-   * @since 1.0.0
-   */
-  async load(): Promise<object> {
-    const items = await this.parse();
-    const target = this.options.target;
-    for (const item of items) {
-      debug('loading item: %o', item);
-      // item { properties: [ 'a', 'b', 'c'], exports }
-      // => target.a.b.c = exports
-      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}`);
-          }
-          obj = item.exports;
-          if (obj && !isPrimitive(obj)) {
-            Reflect.set(obj, FULLPATH, item.fullpath);
-            Reflect.set(obj, EXPORTS, true);
-          }
-        } else {
-          obj = target[property] || {};
-        }
-        target[property] = obj;
-        debug('loaded item properties: %o => %o', properties, obj);
-        return obj;
-      }, target);
-    }
-    return target;
-  }
-
-  /**
-   * Parse files from given directories, then return an items list, each item contains properties and exports.
-   *
-   * For example, parse `app/controller/group/repository.js`
-   *
-   * ```
-   * module.exports = app => {
-   *   return class RepositoryController extends app.Controller {};
-   * }
-   * ```
-   *
-   * It returns a item
-   *
-   * ```
-   * {
-   *   properties: [ 'group', 'repository' ],
-   *   exports: app => { ... },
-   * }
-   * ```
-   *
-   * `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
-   * @since 1.0.0
-   */
-  protected async parse(): Promise<FileLoaderParseItem[]> {
-    let files = this.options.match;
-    if (!files) {
-      files = isSupportTypeScript()
-        ? [ '**/*.(js|ts)', '!**/*.d.ts' ]
-        : [ '**/*.js' ];
-    } else {
-      files = Array.isArray(files) ? files : [ files ];
-    }
-
-    let ignore = this.options.ignore;
-    if (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 ];
-    }
-
-    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);
-      for (const filepath of filepaths) {
-        const fullpath = path.join(directory, filepath);
-        if (!fs.statSync(fullpath).isFile()) continue;
-        if (filepath.endsWith('.js')) {
-          const filepathTs = filepath.replace(/\.js$/, '.ts');
-          if (filepaths.includes(filepathTs)) {
-            debug('[parse] ignore %s, because %s exists', fullpath, filepathTs);
-            continue;
-          }
-        }
-        // get properties
-        // 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('.');
-        // 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)) {
-          continue;
-        }
-
-        // set properties of class
-        if (isClass(exports)) {
-          exports.prototype.pathName = pathName;
-          exports.prototype.fullPath = fullpath;
-        }
-
-        items.push({ fullpath, properties, exports });
-        debug('[parse] parse %s, properties %j, exports %o', fullpath, properties, exports);
-      }
-    }
-
-    return items;
-  }
-}
-
-// convert file path to an array of properties
-// a/b/c.js => ['a', 'b', 'c']
-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)}`);
-    return result;
-  }
-  // use default camelize
-  return defaultCamelize(filepath, caseStyle);
-}
-
-// Get exports from filepath
-// If exports is null/undefined, it will be ignored
-async function getExports(fullpath: string, options: FileLoaderOptions, pathName: string) {
-  let exports = await utils.loadFile(fullpath);
-  // process exports as you like
-  if (options.initializer) {
-    exports = options.initializer(exports, { path: fullpath, pathName });
-    debug('[getExports] after initializer => %o', exports);
-  }
-
-  if (isGeneratorFunction(exports)) {
-    throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
-  }
-
-  // return exports when it's a class or async function
-  //
-  // module.exports = class Service {};
-  // or
-  // module.exports = async function() {}
-  if (isClass(exports) || isAsyncFunction(exports)) {
-    return exports;
-  }
-
-  // return exports after call when it's a function
-  //
-  // module.exports = function(app) {
-  //   return {};
-  // }
-  if (options.call && typeof exports === 'function') {
-    exports = exports(options.inject);
-    if (exports != null) {
-      return exports;
-    }
-  }
-
-  // return exports what is
-  return exports;
-}
-
-function defaultCamelize(filepath: string, caseStyle: CaseStyle) {
-  const properties = filepath.substring(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}`);
-    }
-
-    // use default camelize, will capitalize the first letter
-    // foo_bar.js > FooBar
-    // fooBar.js  > FooBar
-    // FooBar.js  > FooBar
-    // FooBar.js  > FooBar
-    // FooBar.js  > fooBar (if lowercaseFirst is true)
-    property = property.replace(/[_-][a-z]/ig, s => s.substring(1).toUpperCase());
-    let first = property[0];
-    switch (caseStyle) {
-      case 'lower':
-        first = first.toLowerCase();
-        break;
-      case 'upper':
-        first = first.toUpperCase();
-        break;
-      case 'camel':
-      default:
-    }
-    return first + property.substring(1);
-  });
-}

package/src/singleton.ts

@@ -1,149 +0,0 @@
-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 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;
-  }
-
-  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/utils/index.ts

@@ -1,125 +0,0 @@
-import { debuglog } from 'node:util';
-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;
-
-// Guard against poorly mocked module constructors.
-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' ]);
-debug('Module extensions: %j', extensionNames);
-
-function getCalleeFromStack(withLine?: boolean, stackIndex?: number) {
-  stackIndex = stackIndex === undefined ? 2 : stackIndex;
-  const limit = Error.stackTraceLimit;
-  const prep = Error.prepareStackTrace;
-
-  Error.prepareStackTrace = prepareObjectStackTrace;
-  Error.stackTraceLimit = 5;
-
-  // capture the stack
-  const obj: any = {};
-  Error.captureStackTrace(obj);
-  let callSite = obj.stack[stackIndex];
-  let fileName = '';
-  if (callSite) {
-    // egg-mock will create a proxy
-    // https://github.com/eggjs/egg-mock/blob/master/lib/app.js#L174
-    fileName = callSite.getFileName();
-    /* istanbul ignore if */
-    if (fileName && fileName.endsWith('egg-mock/lib/app.js')) {
-      // TODO: add test
-      callSite = obj.stack[stackIndex + 1];
-      fileName = callSite.getFileName();
-    }
-  }
-
-  Error.prepareStackTrace = prep;
-  Error.stackTraceLimit = limit;
-
-  if (!callSite || !fileName) return '<anonymous>';
-  if (!withLine) return fileName;
-  return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
-}
-
-export default {
-  deprecated(message: string) {
-    if (debug.enabled) {
-      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');
-    }
-  },
-
-  extensions,
-  extensionNames,
-
-  async existsPath(filepath: string) {
-    try {
-      await stat(filepath);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-
-  async loadFile(filepath: string) {
-    try {
-      // if not js module, just return content buffer
-      const extname = path.extname(filepath);
-      if (extname && !extensionNames.includes(extname) && extname !== '.ts') {
-        return fs.readFileSync(filepath);
-      }
-      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);
-      throw err;
-    }
-  },
-
-  resolvePath(filepath: string, options?: { paths?: string[] }) {
-    return importResolve(filepath, options);
-  },
-
-  methods: [ 'head', 'options', 'get', 'put', 'patch', 'post', 'delete' ],
-
-  async callFn(fn: Fun, args?: any[], ctx?: any) {
-    args = args || [];
-    if (typeof fn !== 'function') return;
-    return ctx ? fn.call(ctx, ...args) : fn(...args);
-  },
-
-  getCalleeFromStack,
-
-  getResolvedFilename(filepath: string, baseDir: string) {
-    const reg = /[/\\]/g;
-    return filepath.replace(baseDir + path.sep, '').replace(reg, '/');
-  },
-};
-
-/**
- * Capture call site stack from v8.
- * https://github.com/v8/v8/wiki/Stack-Trace-API
- */
-function prepareObjectStackTrace(_obj: any, stack: any) {
-  return stack;
-}

package/src/utils/sequencify.ts

@@ -1,70 +0,0 @@
-import { debuglog } from 'node:util';
-
-const debug = debuglog('@eggjs/core/utils/sequencify');
-
-export interface SequencifyResult {
-  sequence: string[];
-  requires: Record<string, true>;
-}
-
-export interface SequencifyTask {
-  dependencies: string[];
-  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;
-
-    const node = tasks[name];
-    if (!node) {
-      if (optional === true) return;
-      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) {
-      nest.push(name);
-      if (node.dependencies.length) {
-        sequence(tasks, node.dependencies, result, missing, recursive, nest, optional, name);
-      }
-      if (node.optionalDependencies.length) {
-        sequence(tasks, node.optionalDependencies, result, missing, recursive, nest, true, name);
-      }
-      nest.pop();
-    }
-    if (!optional) {
-      result.requires[name] = true;
-      debug('task: %s is enabled by %s', name, parent);
-    }
-    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[]) {
-  const result: SequencifyResult = {
-    sequence: [],
-    requires: {},
-  }; // the final sequence
-  const missing: string[] = []; // missing tasks
-  const recursive: string[] = []; // recursive task dependencies
-
-  sequence(tasks, names, result, missing, recursive, [], false, 'app');
-
-  if (missing.length || recursive.length) {
-    result.sequence = []; // results are incomplete at best, completely wrong at worst, remove them to avoid confusion
-  }
-
-  return {
-    sequence: result.sequence.filter(item => result.requires[item]),
-    missingTasks: missing,
-    recursiveDependencies: recursive,
-  };
-}