@eggjs/core 6.3.0-beta.0 → 6.3.0

package/src/lifecycle.ts

@@ -62,13 +62,15 @@ export interface LifecycleOptions {
   logger: EggConsoleLogger;
 }
 
+export type FunWithFullPath = Fun & { fullPath?: string };
+
 export class Lifecycle extends EventEmitter {
   #init: boolean;
   #readyObject: ReadyObject;
   #bootHooks: (BootImplClass | ILifecycleBoot)[];
   #boots: ILifecycleBoot[];
   #isClosed: boolean;
-  #closeFunctionSet: Set<Fun>;
+  #closeFunctionSet: Set<FunWithFullPath>;
   loadReady: Ready;
   bootReady: Ready;
   options: LifecycleOptions;
@@ -96,10 +98,10 @@ export class Lifecycle extends EventEmitter {
     this.#initReady();
     this
       .on('ready_stat', data => {
-        this.logger.info('[egg:core:ready_stat] end ready task %s, remain %j', data.id, data.remain);
+        this.logger.info('[@eggjs/core/lifecycle:ready_stat] end ready task %s, remain %j', data.id, data.remain);
       })
       .on('ready_timeout', id => {
-        this.logger.warn('[egg:core:ready_timeout] %s seconds later %s was still unable to finish.', this.readyTimeout / 1000, id);
+        this.logger.warn('[@eggjs/core/lifecycle:ready_timeout] %s seconds later %s was still unable to finish.', this.readyTimeout / 1000, id);
       });
 
     this.ready(err => {
@@ -149,11 +151,12 @@ export class Lifecycle extends EventEmitter {
     this.#bootHooks.push(bootHootOrBootClass);
   }
 
-  addFunctionAsBootHook<T = EggCore>(hook: (app: T) => void) {
+  addFunctionAsBootHook<T = EggCore>(hook: (app: T) => void, fullPath?: string) {
     assert(this.#init === false, 'do not add hook when lifecycle has been initialized');
     // app.js is exported as a function
     // call this function in configDidLoad
-    this.#bootHooks.push(class Boot implements ILifecycleBoot {
+    class Boot implements ILifecycleBoot {
+      static fullPath?: string;
       app: T;
       constructor(app: T) {
         this.app = app;
@@ -161,25 +164,34 @@ export class Lifecycle extends EventEmitter {
       configDidLoad() {
         hook(this.app);
       }
-    });
+    }
+    Boot.fullPath = fullPath;
+    this.#bootHooks.push(Boot);
   }
 
   /**
    * init boots and trigger config did config
    */
   init() {
+    debug('%s init lifecycle', this.app.type);
     assert(this.#init === false, 'lifecycle have been init');
     this.#init = true;
     this.#boots = this.#bootHooks.map(BootHootOrBootClass => {
+      let instance = BootHootOrBootClass as ILifecycleBoot;
       if (isClass(BootHootOrBootClass)) {
-        return new BootHootOrBootClass(this.app);
+        instance = new BootHootOrBootClass(this.app);
+        if (!instance.fullPath && 'fullPath' in BootHootOrBootClass) {
+          instance.fullPath = BootHootOrBootClass.fullPath as string;
+        }
       }
-      return BootHootOrBootClass;
+      debug('[init] add boot instance: %o', instance.fullPath);
+      return instance;
     });
   }
 
   registerBeforeStart(scope: Fun, name: string) {
-    debug('add registerBeforeStart, name: %o', name);
+    debug('%s add registerBeforeStart, name: %o',
+      this.options.app.type, name);
     this.#registerReadyCallback({
       scope,
       ready: this.loadReady,
@@ -188,17 +200,24 @@ export class Lifecycle extends EventEmitter {
     });
   }
 
-  registerBeforeClose(fn: Fun) {
+  registerBeforeClose(fn: FunWithFullPath, fullPath?: string) {
     assert(typeof fn === 'function', 'argument should be function');
     assert(this.#isClosed === false, 'app has been closed');
+    if (fullPath) {
+      fn.fullPath = fullPath;
+    }
     this.#closeFunctionSet.add(fn);
+    debug('%s register beforeClose at %o, count: %d',
+      this.app.type, fullPath, this.#closeFunctionSet.size);
   }
 
   async close() {
     // close in reverse order: first created, last closed
     const closeFns = Array.from(this.#closeFunctionSet);
-    debug('close %d beforeClose functions', closeFns.length);
+    debug('%s start trigger %d beforeClose functions',
+      this.app.type, closeFns.length);
     for (const fn of closeFns.reverse()) {
+      debug('%s trigger beforeClose at %o', this.app.type, fn.fullPath);
       await utils.callFn(fn);
       this.#closeFunctionSet.delete(fn);
     }
@@ -207,13 +226,14 @@ export class Lifecycle extends EventEmitter {
     this.removeAllListeners();
     this.app.removeAllListeners();
     this.#isClosed = true;
-    debug('%s closed', this.options.app.type);
+    debug('%s closed', this.app.type);
   }
 
   triggerConfigWillLoad() {
     debug('trigger configWillLoad start');
     for (const boot of this.#boots) {
       if (typeof boot.configWillLoad === 'function') {
+        debug('trigger configWillLoad at %o', boot.fullPath);
         boot.configWillLoad();
       }
     }
@@ -225,12 +245,13 @@ export class Lifecycle extends EventEmitter {
     debug('trigger configDidLoad start');
     for (const boot of this.#boots) {
       if (typeof boot.configDidLoad === 'function') {
+        debug('trigger configDidLoad at %o', boot.fullPath);
         boot.configDidLoad();
       }
       // function boot hook register after configDidLoad trigger
       if (typeof boot.beforeClose === 'function') {
         const beforeClose = boot.beforeClose.bind(boot);
-        this.registerBeforeClose(beforeClose);
+        this.registerBeforeClose(beforeClose, boot.fullPath);
       }
     }
     debug('trigger configDidLoad end');
@@ -276,10 +297,12 @@ export class Lifecycle extends EventEmitter {
     return (async () => {
       for (const boot of this.#boots) {
         if (typeof boot.didReady === 'function') {
+          debug('trigger didReady at %o', boot.fullPath);
           try {
             await boot.didReady(err);
-          } catch (e) {
-            this.emit('error', e);
+          } catch (err) {
+            debug('trigger didReady error at %o, error: %s', boot.fullPath, err);
+            this.emit('error', err);
           }
         }
       }
@@ -294,9 +317,11 @@ export class Lifecycle extends EventEmitter {
         if (typeof boot.serverDidReady !== 'function') {
           continue;
         }
+        debug('trigger serverDidReady at %o', boot.fullPath);
         try {
           await boot.serverDidReady();
         } catch (err) {
+          debug('trigger serverDidReady error at %o, error: %s', boot.fullPath, err);
           this.emit('error', err);
         }
       }

package/src/loader/context_loader.ts

@@ -1,18 +1,18 @@
 import assert from 'node:assert';
 import { isClass, isPrimitive } from 'is-type-of';
 import { FileLoader, EXPORTS, type FileLoaderOptions } from './file_loader.js';
-import type { ContextDelegation } from '../egg.js';
+import type { Context } from '../egg.js';
 
 const CLASS_LOADER = Symbol('classLoader');
 
 export interface ClassLoaderOptions {
-  ctx: ContextDelegation;
+  ctx: Context;
   properties: any;
 }
 
 export class ClassLoader {
   readonly _cache = new Map();
-  _ctx: ContextDelegation;
+  _ctx: Context;
 
   constructor(options: ClassLoaderOptions) {
     assert(options.ctx, 'options.ctx is required');
@@ -98,7 +98,7 @@ export class ContextLoader extends FileLoader {
   }
 }
 
-function getInstance(values: any, ctx: ContextDelegation) {
+function getInstance(values: any, ctx: Context) {
   // it's a directory when it has no exports
   // then use ClassLoader
   const Class = values[EXPORTS] ? values : null;

package/src/loader/egg_loader.ts

@@ -5,66 +5,35 @@ import { debuglog, inspect } from 'node:util';
 import { homedir } from 'node-homedir';
 import { isAsyncFunction, isClass, isGeneratorFunction, isObject, isPromise } from 'is-type-of';
 import type { Logger } from 'egg-logger';
-import { getParamNames, readJSONSync, readJSON } from 'utility';
+import {
+  getParamNames, readJSONSync, readJSON, exists,
+} from 'utility';
 import { extend } from 'extend2';
-import { Request, Response, Context, Application } from '@eggjs/koa';
+import { Request, Response, Application, Context as KoaContext } from '@eggjs/koa';
+import { register as tsconfigPathsRegister } from 'tsconfig-paths';
+import { isESM, isSupportTypeScript } from '@eggjs/utils';
 import { pathMatching, type PathMatchingOptions } from 'egg-path-matching';
 import { now, diff } from 'performance-ms';
-import { FULLPATH, FileLoader, FileLoaderOptions } from './file_loader.js';
+import { CaseStyle, FULLPATH, FileLoader, FileLoaderOptions } from './file_loader.js';
 import { ContextLoader, ContextLoaderOptions } from './context_loader.js';
 import utils, { Fun } from '../utils/index.js';
 import sequencify from '../utils/sequencify.js';
 import { Timing } from '../utils/timing.js';
-import type { ContextDelegation, EggCore, MiddlewareFunc } from '../egg.js';
-import { BaseContextClass } from '../base_context_class.js';
+import type {
+  Context, EggCore, MiddlewareFunc,
+} from '../egg.js';
+import type { BaseContextClass } from '../base_context_class.js';
+import type { EggAppConfig, EggAppInfo, EggPluginInfo } from '../types.js';
 
 const debug = debuglog('@eggjs/core/loader/egg_loader');
 
 const originalPrototypes: Record<string, any> = {
   request: Request.prototype,
   response: Response.prototype,
-  context: Context.prototype,
+  context: KoaContext.prototype,
   application: Application.prototype,
 };
 
-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 EggLoaderOptions {
   /** server env */
@@ -100,7 +69,6 @@ export class EggLoader {
   readonly appInfo: EggAppInfo;
   dirs?: EggDirInfo[];
 
-
   /**
    * @class
    * @param {Object} options - options
@@ -130,12 +98,11 @@ export class EggLoader {
     if (process.env.EGG_TYPESCRIPT === 'true' || (this.pkg.egg && this.pkg.egg.typescript)) {
       // skip require tsconfig-paths if tsconfig.json not exists
       const tsConfigFile = path.join(this.options.baseDir, 'tsconfig.json');
-      // FIXME: support esm
-      if (fs.existsSync(tsConfigFile) && typeof require === 'function') {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        require('tsconfig-paths').register({ cwd: this.options.baseDir });
+      if (fs.existsSync(tsConfigFile)) {
+        tsconfigPathsRegister({ cwd: this.options.baseDir } as any);
       } else {
-        this.logger.info('[@eggjs/core:egg_loader] skip register "tsconfig-paths" because tsconfig.json not exists at %s',
+        this.logger.info(
+          '[@eggjs/core/egg_loader] skip register "tsconfig-paths" because tsconfig.json not exists at %s',
           tsConfigFile);
       }
     }
@@ -634,19 +601,19 @@ export class EggLoader {
         plugin.version = pkg.version;
       }
       // support commonjs and esm dist files
-      plugin.path = this.#formatPluginPathFromPackageJSON(plugin.path!, pkg);
+      plugin.path = await this.#formatPluginPathFromPackageJSON(plugin.path!, pkg);
     }
 
     const logger = this.options.logger;
     if (!config) {
-      logger.warn(`[@eggjs/core:egg_loader] pkg.eggPlugin is missing in ${pluginPackage}`);
+      logger.warn(`[@eggjs/core/egg_loader] pkg.eggPlugin is missing in ${pluginPackage}`);
       return;
     }
 
     if (config.name && config.strict !== false && config.name !== plugin.name) {
       // pluginName is configured in config/plugin.js
       // pluginConfigName is pkg.eggPlugin.name
-      logger.warn(`[@eggjs/core:egg_loader] pluginName(${plugin.name}) is different from pluginConfigName(${config.name})`);
+      logger.warn(`[@eggjs/core/egg_loader] pluginName(${plugin.name}) is different from pluginConfigName(${config.name})`);
     }
 
     // dep compatible
@@ -781,33 +748,43 @@ export class EggLoader {
       const pluginPkgFile = utils.resolvePath(`${name}/package.json`, { paths: [ ...this.lookupDirs ] });
       return path.dirname(pluginPkgFile);
     } catch (err) {
-      debug('[resolvePluginPath] error: %o', err);
+      debug('[resolvePluginPath] error: %o, plugin info: %o', err, plugin);
       throw new Error(`Can not find plugin ${name} in "${[ ...this.lookupDirs ].join(', ')}"`, {
         cause: err,
       });
     }
   }
 
-  #formatPluginPathFromPackageJSON(pluginPath: string, pluginPkg: {
+  async #formatPluginPathFromPackageJSON(pluginPath: string, pluginPkg: {
     eggPlugin?: {
       exports?: {
         import?: string;
         require?: string;
+        typescript?: string;
       };
     };
-  }) {
-    if (pluginPkg.eggPlugin?.exports) {
-      if (typeof require === 'function') {
-        if (pluginPkg.eggPlugin.exports.require) {
-          pluginPath = path.join(pluginPath, pluginPkg.eggPlugin.exports.require);
+  }): Promise<string> {
+    let realPluginPath = pluginPath;
+    const exports = pluginPkg.eggPlugin?.exports;
+    if (exports) {
+      if (isESM) {
+        if (exports.import) {
+          realPluginPath = path.join(pluginPath, exports.import);
         }
       } else {
-        if (pluginPkg.eggPlugin.exports.import) {
-          pluginPath = path.join(pluginPath, pluginPkg.eggPlugin.exports.import);
+        if (exports.require) {
+          realPluginPath = path.join(pluginPath, exports.require);
+        }
+      }
+      if (exports.typescript && isSupportTypeScript()) {
+        if (!(await exists(realPluginPath))) {
+          // if require/import path not exists, use typescript path for development stage
+          realPluginPath = path.join(pluginPath, exports.typescript);
+          debug('[formatPluginPathFromPackageJSON] use typescript path %o', realPluginPath);
         }
       }
     }
-    return pluginPath;
+    return realPluginPath;
   }
 
   #extendPlugins(targets: Record<string, EggPluginInfo>, plugins: Record<string, EggPluginInfo>) {
@@ -843,7 +820,7 @@ export class EggLoader {
 
   /** start Config loader */
   configMeta: Record<string, any>;
-  config: Record<string, any>;
+  config: EggAppConfig;
 
   /**
    * Load config/config.js
@@ -857,7 +834,10 @@ export class EggLoader {
     this.timing.start('Load Config');
     this.configMeta = {};
 
-    const target: Record<string, any> = {};
+    const target: EggAppConfig = {
+      middleware: [],
+      coreMiddleware: [],
+    };
 
     // Load Application config first
     const appConfig = await this.#preloadAppConfig();
@@ -1166,8 +1146,10 @@ export class EggLoader {
   async #loadBootHook(fileName: string) {
     this.timing.start(`Load ${fileName}.js`);
     for (const unit of this.getLoadUnits()) {
-      const bootFilePath = this.resolveModule(path.join(unit.path, fileName));
+      const bootFile = path.join(unit.path, fileName);
+      const bootFilePath = this.resolveModule(bootFile);
       if (!bootFilePath) {
+        // debug('[loadBootHook] %o not found', bootFile);
         continue;
       }
       const bootHook = await this.requireFile(bootFilePath);
@@ -1175,12 +1157,14 @@ export class EggLoader {
         bootHook.prototype.fullPath = bootFilePath;
         // if is boot class, add to lifecycle
         this.lifecycle.addBootHook(bootHook);
+        debug('[loadBootHook] add BootHookClass from %o', bootFilePath);
       } else if (typeof bootHook === 'function') {
         // if is boot function, wrap to class
         // for compatibility
-        this.lifecycle.addFunctionAsBootHook(bootHook);
+        this.lifecycle.addFunctionAsBootHook(bootHook, bootFilePath);
+        debug('[loadBootHook] add bootHookFunction from %o', bootFilePath);
       } else {
-        this.options.logger.warn('[@eggjs/core:egg_loader] %s must exports a boot class', bootFilePath);
+        this.options.logger.warn('[@eggjs/core/egg_loader] %s must exports a boot class', bootFilePath);
       }
     }
     // init boots
@@ -1202,7 +1186,7 @@ export class EggLoader {
     const servicePaths = this.getLoadUnits().map(unit => path.join(unit.path, 'app/service'));
     options = {
       call: true,
-      caseStyle: 'lower',
+      caseStyle: CaseStyle.lower,
       fieldClass: 'serviceClasses',
       directory: servicePaths,
       ...options,
@@ -1242,7 +1226,7 @@ export class EggLoader {
     opt = {
       call: false,
       override: true,
-      caseStyle: 'lower',
+      caseStyle: CaseStyle.lower,
       directory: middlewarePaths,
       ...opt,
     };
@@ -1291,13 +1275,13 @@ export class EggLoader {
         }
         app.use(mw);
         debug('[loadMiddleware] Use middleware: %s with options: %j', name, options);
-        this.options.logger.info('[@eggjs/core:egg_loader] Use middleware: %s', name);
+        this.options.logger.info('[@eggjs/core/egg_loader] Use middleware: %s', name);
       } else {
-        this.options.logger.info('[@eggjs/core:egg_loader] Disable middleware: %s', name);
+        this.options.logger.info('[@eggjs/core/egg_loader] Disable middleware: %s', name);
       }
     }
 
-    this.options.logger.info('[@eggjs/core:egg_loader] Loaded middleware from %j', middlewarePaths);
+    this.options.logger.info('[@eggjs/core/egg_loader] Loaded middleware from %j', middlewarePaths);
     this.timing.end('Load Middleware');
 
     // add router middleware, make sure router is the last middleware
@@ -1317,7 +1301,7 @@ export class EggLoader {
     this.timing.start('Load Controller');
     const controllerBase = path.join(this.options.baseDir, 'app/controller');
     opt = {
-      caseStyle: 'lower',
+      caseStyle: CaseStyle.lower,
       directory: controllerBase,
       initializer: (obj, opt) => {
         // return class if it exports a function
@@ -1355,7 +1339,7 @@ export class EggLoader {
     };
     await this.loadToApp(controllerBase, 'controller', opt as FileLoaderOptions);
     debug('[loadController] app.controller => %o', this.app.controller);
-    this.options.logger.info('[@eggjs/core:egg_loader] Controller loaded: %s', controllerBase);
+    this.options.logger.info('[@eggjs/core/egg_loader] Controller loaded: %s', controllerBase);
     this.timing.end('Load Controller');
   }
   /** end Controller loader */
@@ -1397,7 +1381,7 @@ export class EggLoader {
         case 'ctx': {
           assert(!(property in this.app.context), `customLoader should not override ctx.${property}`);
           const options = {
-            caseStyle: 'lower',
+            caseStyle: CaseStyle.lower,
             fieldClass: `${property}Classes`,
             ...loaderConfig,
             directory,
@@ -1408,7 +1392,7 @@ export class EggLoader {
         case 'app': {
           assert(!(property in this.app), `customLoader should not override app.${property}`);
           const options = {
-            caseStyle: 'lower',
+            caseStyle: CaseStyle.lower,
             initializer: (Clazz: unknown) => {
               return isClass(Clazz) ? new Clazz(this.app) : Clazz;
             },
@@ -1527,10 +1511,11 @@ export class EggLoader {
    * @param {Object} options - see {@link FileLoader}
    * @since 1.0.0
    */
-  async loadToApp(directory: string | string[], property: string | symbol, options?: FileLoaderOptions) {
+  async loadToApp(directory: string | string[], property: string | symbol,
+    options?: Omit<FileLoaderOptions, 'inject' | 'target'>) {
     const target = {};
     Reflect.set(this.app, property, target);
-    options = {
+    const loadOptions: FileLoaderOptions = {
       ...options,
       directory: options?.directory ?? directory,
       target,
@@ -1539,7 +1524,7 @@ export class EggLoader {
 
     const timingKey = `Load "${String(property)}" to Application`;
     this.timing.start(timingKey);
-    await new FileLoader(options).load();
+    await new FileLoader(loadOptions).load();
     this.timing.end(timingKey);
   }
 
@@ -1550,8 +1535,9 @@ export class EggLoader {
    * @param {Object} options - see {@link ContextLoader}
    * @since 1.0.0
    */
-  async loadToContext(directory: string | string[], property: string | symbol, options?: ContextLoaderOptions) {
-    options = {
+  async loadToContext(directory: string | string[], property: string | symbol,
+    options?: Omit<ContextLoaderOptions, 'inject' | 'property'>) {
+    const loadOptions: ContextLoaderOptions = {
       ...options,
       directory: options?.directory || directory,
       property,
@@ -1560,7 +1546,7 @@ export class EggLoader {
 
     const timingKey = `Load "${String(property)}" to Context`;
     this.timing.start(timingKey);
-    await new ContextLoader(options).load();
+    await new ContextLoader(loadOptions).load();
     this.timing.end(timingKey);
   }
 
@@ -1595,13 +1581,13 @@ export class EggLoader {
     let fullPath;
     try {
       fullPath = utils.resolvePath(filepath);
-    } catch (e) {
-      return undefined;
-    }
-
-    if (process.env.EGG_TYPESCRIPT !== 'true' && fullPath.endsWith('.ts')) {
+    } catch (err: any) {
+      // debug('[resolveModule] Module %o resolve error: %s', filepath, err.stack);
       return undefined;
     }
+    // if (process.env.EGG_TYPESCRIPT !== 'true' && fullPath.endsWith('.ts')) {
+    //   return undefined;
+    // }
     return fullPath;
   }
 }
@@ -1687,7 +1673,7 @@ function wrapControllerClass(Controller: typeof BaseContextClass, fullPath: stri
 }
 
 function controllerMethodToMiddleware(Controller: typeof BaseContextClass, key: string) {
-  return function classControllerMiddleware(this: ContextDelegation, ...args: any[]) {
+  return function classControllerMiddleware(this: Context, ...args: any[]) {
     const controller: any = new Controller(this);
     if (!this.app.config.controller?.supportParams) {
       args = [ this ];
@@ -1723,7 +1709,7 @@ function wrapObject(obj: Record<string, any>, fullPath: string, prefix?: string)
 }
 
 function objectFunctionToMiddleware(func: Fun) {
-  async function objectControllerMiddleware(this: ContextDelegation, ...args: any[]) {
+  async function objectControllerMiddleware(this: Context, ...args: any[]) {
     if (!this.app.config.controller?.supportParams) {
       args = [ this ];
     }

package/src/loader/file_loader.ts

@@ -6,12 +6,17 @@ import globby from 'globby';
 import { isClass, isGeneratorFunction, isAsyncFunction, isPrimitive } from 'is-type-of';
 import utils, { Fun } from '../utils/index.js';
 
-const debug = debuglog('@eggjs/core:file_loader');
+const debug = debuglog('@eggjs/core/file_loader');
 
 export const FULLPATH = Symbol('EGG_LOADER_ITEM_FULLPATH');
 export const EXPORTS = Symbol('EGG_LOADER_ITEM_EXPORTS');
 
-export type CaseStyle = 'camel' | 'lower' | 'upper';
+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;
@@ -79,7 +84,7 @@ export class FileLoader {
     assert(options.directory, 'options.directory is required');
     assert(options.target, 'options.target is required');
     this.options = {
-      caseStyle: 'camel',
+      caseStyle: CaseStyle.camel,
       call: true,
       override: false,
       ...options,
@@ -88,7 +93,7 @@ export class FileLoader {
     // compatible old options _lowercaseFirst_
     if (this.options.lowercaseFirst === true) {
       utils.deprecated('lowercaseFirst is deprecated, use caseStyle instead');
-      this.options.caseStyle = 'lower';
+      this.options.caseStyle = CaseStyle.lower;
     }
   }
 
@@ -185,6 +190,13 @@ export class FileLoader {
       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);