diff --git a/packages/bootstrap/src/bootstrap.ts b/packages/bootstrap/src/bootstrap.ts
index a48d7bdfdac0..44a7595a6ba7 100644
--- a/packages/bootstrap/src/bootstrap.ts
+++ b/packages/bootstrap/src/bootstrap.ts
@@ -4,11 +4,12 @@ import {
   MidwayApplicationManager,
   initializeGlobalApplicationContext,
   destroyGlobalApplicationContext,
+  loadModule,
+  isTypeScriptEnvironment,
 } from '@midwayjs/core';
 import { join } from 'path';
 import { IMidwayLogger, MidwayBaseLogger } from '@midwayjs/logger';
 import { createContextManager } from '@midwayjs/async-hooks-context-manager';
-import { isTypeScriptEnvironment } from './util';
 import {
   ChildProcessEventBus,
   ThreadEventBus,
@@ -46,6 +47,16 @@ export class BootstrapStarter {
       }
     }
 
+    if (!this.globalOptions.fileLoadMode) {
+      const pkgJSON = await loadModule(join(this.appDir, 'package.json'), {
+        safeLoad: true,
+        enableCache: false,
+      });
+
+      this.globalOptions.fileLoadMode =
+        pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
+    }
+
     this.applicationContext = await initializeGlobalApplicationContext({
       asyncContextManager: createContextManager(),
       ...this.globalOptions,
diff --git a/packages/bootstrap/src/index.ts b/packages/bootstrap/src/index.ts
index eb7bd5a665a4..03f1eba69686 100644
--- a/packages/bootstrap/src/index.ts
+++ b/packages/bootstrap/src/index.ts
@@ -1,5 +1,4 @@
 export * from './interface';
-export { isTypeScriptEnvironment } from './util';
 export { Bootstrap, BootstrapStarter } from './bootstrap';
 export { ClusterManager } from './manager/cp';
 export { AbstractForkManager } from './manager/base';
diff --git a/packages/bootstrap/src/manager/cp.ts b/packages/bootstrap/src/manager/cp.ts
index 865746376338..bb937900b70f 100644
--- a/packages/bootstrap/src/manager/cp.ts
+++ b/packages/bootstrap/src/manager/cp.ts
@@ -4,7 +4,7 @@ import { ClusterOptions } from '../interface';
 import { AbstractForkManager } from './base';
 const cluster = require('cluster');
 import { debuglog } from 'util';
-import { isTypeScriptEnvironment } from '../util';
+import { isTypeScriptEnvironment } from '@midwayjs/core';
 
 const debug = debuglog('midway:bootstrap');
 
diff --git a/packages/bootstrap/src/manager/thread.ts b/packages/bootstrap/src/manager/thread.ts
index 4ab4f84dd890..2eb4fa602e55 100644
--- a/packages/bootstrap/src/manager/thread.ts
+++ b/packages/bootstrap/src/manager/thread.ts
@@ -2,7 +2,7 @@ import { ThreadOptions } from '../interface';
 import { AbstractForkManager } from './base';
 import { Worker, isMainThread, SHARE_ENV } from 'worker_threads';
 import { ThreadEventBus } from '@midwayjs/event-bus';
-import { isTypeScriptEnvironment } from '../util';
+import { isTypeScriptEnvironment } from '@midwayjs/core';
 
 export class ThreadManager extends AbstractForkManager<Worker, ThreadOptions> {
   private workerExitListener;
diff --git a/packages/bootstrap/src/util.ts b/packages/bootstrap/src/util.ts
index abaccecd9c06..2fb2f5be9958 100644
--- a/packages/bootstrap/src/util.ts
+++ b/packages/bootstrap/src/util.ts
@@ -48,12 +48,3 @@ export async function sleep(timeout) {
     setTimeout(resolve, timeout);
   });
 }
-
-export function isTypeScriptEnvironment() {
-  const TS_MODE_PROCESS_FLAG: string = process.env.MIDWAY_TS_MODE;
-  if ('false' === TS_MODE_PROCESS_FLAG) {
-    return false;
-  }
-  // eslint-disable-next-line node/no-deprecated-api
-  return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
-}
diff --git a/packages/core/package.json b/packages/core/package.json
index 12228fd76e5f..21dda110ae38 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.11.12",
+  "version": "3.12.0-beta.1",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
diff --git a/packages/core/src/common/fileDetector.ts b/packages/core/src/common/fileDetector.ts
index e38a39b765b1..5af50addbfd6 100644
--- a/packages/core/src/common/fileDetector.ts
+++ b/packages/core/src/common/fileDetector.ts
@@ -8,6 +8,7 @@ import { run } from '@midwayjs/glob';
 import { MidwayDuplicateClassNameError } from '../error';
 import { DEFAULT_PATTERN, IGNORE_PATTERN } from '../constants';
 import { getProviderName } from '../decorator';
+import { loadModule } from '../util';
 
 export abstract class AbstractFileDetector<T> implements IFileDetector {
   options: T;
@@ -157,7 +158,9 @@ export class CommonJSFileDetector extends AbstractFileDetector<{
       };
 
       for (const file of fileResults) {
-        const exports = await import(file);
+        const exports = await loadModule(file, {
+          loadMode: 'esm',
+        });
         // add module to set
         container.bindClass(exports, {
           namespace: this.options.namespace,
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index e5fb4352c571..fe97389a65f1 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -70,6 +70,7 @@ export {
   pathMatching,
   wrapMiddleware,
   wrapAsync,
+  isTypeScriptEnvironment,
 } from './util/';
 export { extend } from './util/extend';
 export * from './util/webRouterParam';
diff --git a/packages/core/src/interface.ts b/packages/core/src/interface.ts
index e62d8e0f944f..4a08289cd566 100644
--- a/packages/core/src/interface.ts
+++ b/packages/core/src/interface.ts
@@ -1020,6 +1020,7 @@ export interface IMidwayBootstrapOptions {
    */
   configurationModule?: any | any[];
   imports?: any | any[];
+  fileLoadType?: 'esm' | 'commonjs';
   moduleDetector?: IFileDetector | false;
   logger?: boolean | ILogger;
   /**
diff --git a/packages/core/src/service/informationService.ts b/packages/core/src/service/informationService.ts
index 7904569b3ac2..2fab4a027b0c 100644
--- a/packages/core/src/service/informationService.ts
+++ b/packages/core/src/service/informationService.ts
@@ -3,7 +3,7 @@ import {
   getCurrentEnvironment,
   getUserHome,
   isDevelopmentEnvironment,
-  safeRequire,
+  loadModule,
 } from '../util';
 import { dirname, join } from 'path';
 import { Provide, Inject, Init, Scope } from '../decorator';
@@ -20,12 +20,15 @@ export class MidwayInformationService implements IInformationService {
   protected baseDir: string;
 
   @Init()
-  protected init() {
+  protected async init() {
     if (this.baseDir) {
       if (!this.appDir) {
         this.appDir = dirname(this.baseDir);
       }
-      this.pkg = safeRequire(join(this.appDir, 'package.json')) || {};
+      this.pkg =
+        (await loadModule(join(this.appDir, 'package.json'), {
+          safeLoad: true,
+        })) || {};
     } else {
       this.pkg = {};
     }
diff --git a/packages/core/src/setup.ts b/packages/core/src/setup.ts
index 4aa826459a7d..d617210617c3 100644
--- a/packages/core/src/setup.ts
+++ b/packages/core/src/setup.ts
@@ -14,10 +14,11 @@ import {
   MidwayApplicationManager,
   MidwayMockService,
   MidwayWebRouterService,
-  loadModule,
   ESModuleFileDetector,
   CommonJSFileDetector,
+  loadModule,
   safeRequire,
+  isTypeScriptEnvironment,
 } from './';
 import defaultConfig from './config/config.default';
 import {
@@ -144,33 +145,38 @@ export async function prepareGlobalApplicationContext(
 
   debug('[core]: set default file detector');
 
+  if (!globalOptions.fileLoadType) {
+    globalOptions.fileLoadType = 'commonjs';
+  }
+
   // set module detector
   if (globalOptions.moduleDetector !== false) {
-    const pkgJSON = await loadModule(join(appDir, 'package.json'), {
-      safeLoad: true,
-      enableCache: false,
-    });
-
-    const loadMode = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
-    debug('[core]: module load mode = %s', loadMode);
+    debug('[core]: set file load mode = %s', globalOptions.fileLoadType);
 
     // set default entry file
     if (!globalOptions.imports) {
       globalOptions.imports = [
-        await loadModule(join(baseDir, 'configuration'), {
-          loadMode,
-          safeLoad: true,
-        }),
+        await loadModule(
+          join(
+            baseDir,
+            `configuration${isTypeScriptEnvironment() ? '.ts' : '.js'}`
+          ),
+          {
+            loadMode: globalOptions.fileLoadType,
+            safeLoad: true,
+          }
+        ),
       ];
     }
     if (globalOptions.moduleDetector === undefined) {
-      if (loadMode === 'esm') {
+      if (globalOptions.fileLoadType === 'esm') {
         applicationContext.setFileDetector(
           new ESModuleFileDetector({
             loadDir: baseDir,
             ignore: globalOptions.ignore ?? [],
           })
         );
+        globalOptions.fileLoadType = 'esm';
       } else {
         applicationContext.setFileDetector(
           new CommonJSFileDetector({
diff --git a/packages/core/src/util/index.ts b/packages/core/src/util/index.ts
index 93b0ae95a4a4..861f0fbe4183 100644
--- a/packages/core/src/util/index.ts
+++ b/packages/core/src/util/index.ts
@@ -79,7 +79,14 @@ export const loadModule = async (
       if (options.loadMode === 'commonjs') {
         return require(p);
       } else {
-        return await import(p);
+        // if json file, import need add options
+        if (p.endsWith('.json')) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          return (await import(p, { assert: { type: 'json' } })).default;
+        } else {
+          return await import(p);
+        }
       }
     } else {
       const content = readFileSync(p, {
@@ -504,6 +511,15 @@ export function toAsyncFunction<T extends (...args) => any>(
   }
 }
 
+export function isTypeScriptEnvironment() {
+  const TS_MODE_PROCESS_FLAG: string = process.env.MIDWAY_TS_MODE;
+  if ('false' === TS_MODE_PROCESS_FLAG) {
+    return false;
+  }
+  // eslint-disable-next-line node/no-deprecated-api
+  return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
+}
+
 export const Utils = {
   sleep,
   getParamNames,
@@ -514,4 +530,5 @@ export const Utils = {
   toAsyncFunction,
   safeStringify,
   safeParse,
+  isTypeScriptEnvironment,
 };
diff --git a/packages/core/test/util/esm-fixtures/clz-default.mts b/packages/core/test/util/esm-fixtures/clz-default.mts
new file mode 100644
index 000000000000..1769efa1c4e3
--- /dev/null
+++ b/packages/core/test/util/esm-fixtures/clz-default.mts
@@ -0,0 +1,8 @@
+class User {}
+
+class UserService {}
+
+export default {
+  User,
+  UserService,
+}
diff --git a/packages/core/test/util/esm-fixtures/clz.mts b/packages/core/test/util/esm-fixtures/clz.mts
new file mode 100644
index 000000000000..edc03417ac98
--- /dev/null
+++ b/packages/core/test/util/esm-fixtures/clz.mts
@@ -0,0 +1,3 @@
+export class User {}
+
+export class UserService {}
diff --git a/packages/core/test/util/esm-fixtures/data.json b/packages/core/test/util/esm-fixtures/data.json
new file mode 100644
index 000000000000..2046e1cf7797
--- /dev/null
+++ b/packages/core/test/util/esm-fixtures/data.json
@@ -0,0 +1,3 @@
+{
+  "test": 1
+}
diff --git a/packages/core/test/util/esm-fixtures/esm.mjs b/packages/core/test/util/esm-fixtures/esm.mjs
new file mode 100644
index 000000000000..8c917f2cd892
--- /dev/null
+++ b/packages/core/test/util/esm-fixtures/esm.mjs
@@ -0,0 +1,21 @@
+import { createRequire } from 'module';
+import assert from 'assert';
+
+// console.log(import.meta.url);
+const require = createRequire(import.meta.url);
+// 这里要用 dist，因为 esm 会找最近的 pkg，而 src 目录最近的 pkg 是 commonjs，会报错
+const { loadModule } = require('../../../dist/');
+
+// console.log(url);
+const clzDefault = await loadModule(new URL('./clz-default.mts', import.meta.url).pathname, { loadMode: 'esm' });
+assert(clzDefault.default.User.name === 'User');
+
+const clz = await loadModule(new URL('./clz.mts', import.meta.url).pathname, { loadMode: 'esm' });
+assert(clz.User.name === 'User');
+
+const data = await loadModule(new URL('./data.json', import.meta.url).pathname, { loadMode: 'esm'});
+assert(data.test === 1);
+
+const dataNoCache = await loadModule(new URL('./data.json', import.meta.url).pathname, { loadMode: 'esm', enableCache: false});
+assert(dataNoCache.test === 1);
+process.send('ready');
diff --git a/packages/core/test/util/esm-fixtures/tsconfig.json b/packages/core/test/util/esm-fixtures/tsconfig.json
new file mode 100644
index 000000000000..fc669d820659
--- /dev/null
+++ b/packages/core/test/util/esm-fixtures/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "NodeNext",
+    "baseUrl": "./",
+    "esModuleInterop": true
+  },
+  "include": [
+    "*.mts",
+  ],
+  "ts-node": {
+    "esm": true,
+  }
+}
diff --git a/packages/core/test/util/util.test.ts b/packages/core/test/util/util.test.ts
index bbe890817ddf..e40b2c5b14ee 100644
--- a/packages/core/test/util/util.test.ts
+++ b/packages/core/test/util/util.test.ts
@@ -9,10 +9,12 @@ import {
   delegateTargetProperties,
   transformRequestObjectByType,
   isIncludeProperty,
-  delegateTargetAllPrototypeMethod
+  delegateTargetAllPrototypeMethod,
+  loadModule, sleep
 } from '../../src/util';
 import { PathFileUtil } from '../../src';
 import * as EventEmitter from 'events';
+import { fork } from 'child_process';
 
 describe('/test/util/util.test.ts', () => {
 
@@ -26,6 +28,37 @@ describe('/test/util/util.test.ts', () => {
     assert.strictEqual(safeRequire('../fixtures/dir/bbb/nok.js'), undefined);
   });
 
+  it('should test loadModule', async () => {
+    expect(await loadModule(join(__dirname, '../fixtures/dir/nok.js'), {safeLoad: true})).toBeUndefined();
+    expect(await loadModule('../fixtures/dir/bbb/nok.js', {safeLoad: true})).toBeUndefined();
+  });
+
+  it('should test load modle with esm', async () => {
+    let child = fork('esm.mjs', [], {
+      cwd: join(__dirname, './esm-fixtures'),
+      execArgv: [
+        '--loader',
+        'ts-node/esm',
+      ]
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        console.log(`process exited with code ${code}`);
+      }
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      child.on('message', (ready) => {
+        if (ready === 'ready') {
+          resolve();
+        }
+      });
+    });
+
+    await sleep(1000);
+  });
+
   it('should safeGet be ok', () => {
     const fn = safelyGet(['a', 'b']);
     assert.deepEqual(2, fn({a: {b: 2}}), 'safelyGet one argument not ok');
diff --git a/packages/faas/src/starter.ts b/packages/faas/src/starter.ts
index c60e9f3b49a9..c922c141e8b7 100644
--- a/packages/faas/src/starter.ts
+++ b/packages/faas/src/starter.ts
@@ -6,15 +6,7 @@ import {
 } from '@midwayjs/core';
 import { MidwayFaaSFramework } from './framework';
 import { join } from 'path';
-
-function isTypeScriptEnvironment() {
-  const TS_MODE_PROCESS_FLAG: string = process.env.MIDWAY_TS_MODE;
-  if ('false' === TS_MODE_PROCESS_FLAG) {
-    return false;
-  }
-  // eslint-disable-next-line node/no-deprecated-api
-  return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
-}
+import { isTypeScriptEnvironment } from '@midwayjs/core';
 
 export abstract class AbstractBootstrapStarter {
   protected applicationContext;
diff --git a/packages/mock/src/creator.ts b/packages/mock/src/creator.ts
index dc8cdc27653b..41e9a5b67b0a 100644
--- a/packages/mock/src/creator.ts
+++ b/packages/mock/src/creator.ts
@@ -7,7 +7,7 @@ import {
   IMidwayFramework,
   MidwayFrameworkService,
   MidwayFrameworkType,
-  safeRequire,
+  loadModule,
   MidwayContainer,
   MidwayCommonError,
   MidwayApplicationManager,
@@ -55,6 +55,16 @@ function formatPath(baseDir, p) {
   }
 }
 
+function getCurrentFileDir(loadMode: 'commonjs' | 'esm') {
+  if (loadMode === 'commonjs') {
+    return __dirname;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return new URL(import.meta.url).pathname;
+  }
+}
+
 export async function create<
   T extends IMidwayFramework<any, any, any, any, any>
 >(
@@ -89,12 +99,6 @@ export async function create<
     clearAllLoggers();
 
     options = options || ({} as any);
-    if (options.baseDir) {
-      safeRequire(join(`${options.baseDir}`, 'interface'));
-    } else if (appDir) {
-      options.baseDir = `${appDir}/src`;
-      safeRequire(join(`${options.baseDir}`, 'interface'));
-    }
 
     if (options.entryFile) {
       // start from entry file, like bootstrap.js
@@ -121,8 +125,33 @@ export async function create<
       return;
     }
 
+    if (!options.fileLoadType) {
+      const pkgJSON = await loadModule(join(appDir, 'package.json'), {
+        safeLoad: true,
+        enableCache: false,
+      });
+
+      options.fileLoadMode = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
+    }
+
+    if (options.baseDir) {
+      await loadModule(join(`${options.baseDir}`, 'interface.ts'), {
+        safeLoad: true,
+        loadMode: options.fileLoadMode,
+      });
+    } else if (appDir) {
+      options.baseDir = `${appDir}/src`;
+      await loadModule(join(`${options.baseDir}`, 'interface.ts'), {
+        safeLoad: true,
+        loadMode: options.fileLoadMode,
+      });
+    }
+
     if (!options.imports && customFramework) {
-      options.imports = transformFrameworkToConfiguration(customFramework);
+      options.imports = await transformFrameworkToConfiguration(
+        customFramework,
+        options.fileLoadType
+      );
     }
 
     if (customFramework?.['Configuration']) {
@@ -131,18 +160,19 @@ export async function create<
     }
 
     if (options.ssl) {
+      const currentFileDir = getCurrentFileDir(options.fileLoadMode);
       const sslConfig = {
         koa: {
-          key: join(__dirname, '../ssl/ssl.key'),
-          cert: join(__dirname, '../ssl/ssl.pem'),
+          key: join(currentFileDir, '../ssl/ssl.key'),
+          cert: join(currentFileDir, '../ssl/ssl.pem'),
         },
         egg: {
-          key: join(__dirname, '../ssl/ssl.key'),
-          cert: join(__dirname, '../ssl/ssl.pem'),
+          key: join(currentFileDir, '../ssl/ssl.key'),
+          cert: join(currentFileDir, '../ssl/ssl.pem'),
         },
         express: {
-          key: join(__dirname, '../ssl/ssl.key'),
-          cert: join(__dirname, '../ssl/ssl.pem'),
+          key: join(currentFileDir, '../ssl/ssl.key'),
+          cert: join(currentFileDir, '../ssl/ssl.pem'),
         },
       };
       options.globalConfig = mergeGlobalConfig(options.globalConfig, sslConfig);
@@ -183,13 +213,14 @@ export async function create<
       ...options,
       appDir,
       asyncContextManager: createContextManager(),
-      imports: []
-        .concat(options.imports)
-        .concat(
-          options.baseDir
-            ? safeRequire(join(options.baseDir, 'configuration'))
-            : []
-        ),
+      imports: [].concat(options.imports).concat(
+        options.baseDir
+          ? await loadModule(join(options.baseDir, 'configuration.ts'), {
+              safeLoad: true,
+              loadMode: options.fileLoadMode,
+            })
+          : []
+      ),
     });
 
     if (customFramework) {
@@ -296,7 +327,7 @@ export async function createFunctionApp<
       const doc = yaml.load(readFileSync(join(baseDir, 'f.yml'), 'utf8'));
       starterName = doc?.['provider']?.['starter'];
       if (starterName) {
-        const m = safeRequire(starterName);
+        const m = await loadModule(starterName);
         if (m && m['BootstrapStarter']) {
           options.starter = new m['BootstrapStarter']();
         }
@@ -332,12 +363,25 @@ export async function createFunctionApp<
 
     clearAllLoggers();
 
+    const pkgJSON = await loadModule(join(options.appDir, 'package.json'), {
+      safeLoad: true,
+      enableCache: false,
+    });
+
+    options.fileLoadMode = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
+
     options = options || ({} as any);
     if (options.baseDir) {
-      safeRequire(join(`${options.baseDir}`, 'interface'));
+      await loadModule(join(`${options.baseDir}`, 'interface.ts'), {
+        safeLoad: true,
+        loadMode: options.fileLoadMode,
+      });
     } else if (options.appDir) {
       options.baseDir = `${options.appDir}/src`;
-      safeRequire(join(`${options.baseDir}`, 'interface'));
+      await loadModule(join(`${options.baseDir}`, 'interface.ts'), {
+        safeLoad: true,
+        loadMode: options.fileLoadMode,
+      });
     }
 
     // new mode
@@ -475,10 +519,14 @@ export async function createFunctionApp<
       await new Promise<void>(resolve => {
         let server: http.Server | https.Server;
         if (options.ssl) {
+          const currentFileDir = getCurrentFileDir(options.fileLoadMode);
           server = require('https').createServer(
             {
-              key: readFileSync(join(__dirname, '../ssl/ssl.key'), 'utf8'),
-              cert: readFileSync(join(__dirname, '../ssl/ssl.pem'), 'utf8'),
+              key: readFileSync(join(currentFileDir, '../ssl/ssl.key'), 'utf8'),
+              cert: readFileSync(
+                join(currentFileDir, '../ssl/ssl.pem'),
+                'utf8'
+              ),
             },
             app.callback2()
           );
@@ -500,7 +548,10 @@ export async function createFunctionApp<
         '@ali/serverless-app',
         '@midwayjs/serverless-app',
       ]);
-    const serverlessModule = transformFrameworkToConfiguration(customFramework);
+    const serverlessModule = await transformFrameworkToConfiguration(
+      customFramework,
+      options.fileLoadType
+    );
     if (serverlessModule) {
       if (options && options.imports) {
         options.imports.unshift(serverlessModule);
@@ -541,6 +592,7 @@ class LightFramework extends BaseFramework<any, any, any, any, any> {
 }
 
 class BootstrapAppStarter implements IBootstrapAppStarter {
+  constructor(protected options: MockBootstrapOptions) {}
   getApp(type: MidwayFrameworkType | string): IMidwayApplication<any> {
     const applicationContext = getCurrentApplicationContext();
     const applicationManager = applicationContext.get(MidwayApplicationManager);
@@ -553,7 +605,10 @@ class BootstrapAppStarter implements IBootstrapAppStarter {
     } = {}
   ) {
     // eslint-disable-next-line node/no-extraneous-require
-    const BootstrapModule = safeRequire('@midwayjs/bootstrap');
+    const BootstrapModule = await loadModule('@midwayjs/bootstrap', {
+      loadMode: this.options.fileLoadMode,
+      safeLoad: true,
+    });
     if (BootstrapModule?.Bootstrap) {
       await BootstrapModule.Bootstrap.stop();
     }
@@ -586,11 +641,25 @@ export async function createLightApp(
     },
     options.globalConfig ?? {}
   );
+
+  if (!options.fileLoadType) {
+    const cwd = process.cwd();
+    const pkgJSON = await loadModule(join(cwd, 'package.json'), {
+      safeLoad: true,
+      enableCache: false,
+    });
+
+    options.fileLoadMode = pkgJSON?.type === 'module' ? 'esm' : 'commonjs';
+  }
+
   return createApp(baseDir, {
     ...options,
-    imports: [transformFrameworkToConfiguration(LightFramework)].concat(
-      options?.imports
-    ),
+    imports: [
+      await transformFrameworkToConfiguration(
+        LightFramework,
+        options.fileLoadType
+      ),
+    ].concat(options?.imports),
   });
 }
 
@@ -598,13 +667,16 @@ export async function createBootstrap(
   entryFile: string,
   options: MockBootstrapOptions = {}
 ): Promise<IBootstrapAppStarter> {
+  const cwd = process.cwd();
   if (!options.bootstrapMode) {
-    options.bootstrapMode = safeRequire('@midwayjs/faas') ? 'faas' : 'app';
+    options.bootstrapMode = existsSync(join(cwd, 'node_modules/@midwayjs/faas'))
+      ? 'faas'
+      : 'app';
   }
 
   if (options.bootstrapMode === 'faas') {
     options.entryFile = entryFile;
-    const app = await createFunctionApp(process.cwd(), options);
+    const app = await createFunctionApp(cwd, options);
     return {
       close: async () => {
         return close(app);
@@ -614,6 +686,6 @@ export async function createBootstrap(
     await create(undefined, {
       entryFile,
     });
-    return new BootstrapAppStarter();
+    return new BootstrapAppStarter(options);
   }
 }
diff --git a/packages/mock/src/utils.ts b/packages/mock/src/utils.ts
index ae6d9596e9ad..031ff14ca3e3 100644
--- a/packages/mock/src/utils.ts
+++ b/packages/mock/src/utils.ts
@@ -1,8 +1,8 @@
 import {
   IMidwayContainer,
   IMidwayFramework,
-  safeRequire,
   Configuration,
+  loadModule,
 } from '@midwayjs/core';
 import { ComponentModule } from './interface';
 import * as os from 'os';
@@ -37,18 +37,22 @@ export function findFirstExistModule(moduleList): ComponentModule {
  * transform a framework component or framework module to configuration class
  * @param Framework
  */
-export function transformFrameworkToConfiguration<
+export async function transformFrameworkToConfiguration<
   T extends IMidwayFramework<any, any, any>
 >(
-  Framework: any
-): {
+  Framework: any,
+  loadMode: 'commonjs' | 'esm'
+): Promise<{
   [key: string]: any;
   Configuration: any;
-} {
+}> {
   if (!Framework) return null;
   let CustomFramework = Framework;
   if (typeof Framework === 'string') {
-    Framework = safeRequire(Framework);
+    Framework = await loadModule(Framework, {
+      loadMode,
+      safeLoad: true,
+    });
   }
 
   if (Framework.Configuration) {
diff --git a/packages/swagger/src/swaggerMiddleware.ts b/packages/swagger/src/swaggerMiddleware.ts
index cb51e336f47f..b7a0b10fc576 100644
--- a/packages/swagger/src/swaggerMiddleware.ts
+++ b/packages/swagger/src/swaggerMiddleware.ts
@@ -3,7 +3,7 @@ import {
   IMidwayApplication,
   IMidwayContext,
   NextFunction,
-  safeRequire,
+  loadModule,
   Config,
   Init,
   Inject,
@@ -32,7 +32,9 @@ export class SwaggerMiddleware
 
   @Init()
   async init() {
-    const { getAbsoluteFSPath } = safeRequire('swagger-ui-dist');
+    const { getAbsoluteFSPath } = await loadModule('swagger-ui-dist', {
+      safeLoad: true,
+    });
     if (getAbsoluteFSPath) {
       this.swaggerUiAssetPath = getAbsoluteFSPath();
     }
diff --git a/packages/web/src/cluster.ts b/packages/web/src/cluster.ts
index 12e5ce25159d..59c290669005 100644
--- a/packages/web/src/cluster.ts
+++ b/packages/web/src/cluster.ts
@@ -1,6 +1,8 @@
-import { prepareGlobalApplicationContextSync } from '@midwayjs/core';
+import {
+  prepareGlobalApplicationContextSync,
+  isTypeScriptEnvironment,
+} from '@midwayjs/core';
 import { join } from 'path';
-import { isTypeScriptEnvironment } from './utils';
 import { debuglog } from 'util';
 const debug = debuglog('midway:debug');
 
diff --git a/packages/web/src/utils.ts b/packages/web/src/utils.ts
index 04bc26bd7bbe..ecdea4fec581 100644
--- a/packages/web/src/utils.ts
+++ b/packages/web/src/utils.ts
@@ -11,6 +11,7 @@ import {
   REQUEST_OBJ_CTX_KEY,
   MidwayEnvironmentService,
   MidwayInformationService,
+  isTypeScriptEnvironment,
 } from '@midwayjs/core';
 import {
   ALL,
@@ -26,15 +27,6 @@ import { EGG_AGENT_APP_KEY } from './interface';
 
 const debug = debuglog('midway:debug');
 
-export function isTypeScriptEnvironment() {
-  const TS_MODE_PROCESS_FLAG: string = process.env.MIDWAY_TS_MODE;
-  if ('false' === TS_MODE_PROCESS_FLAG) {
-    return false;
-  }
-  // eslint-disable-next-line node/no-deprecated-api
-  return TS_MODE_PROCESS_FLAG === 'true' || !!require.extensions['.ts'];
-}
-
 export const parseNormalDir = (baseDir: string, isTypescript = true) => {
   if (isTypescript) {
     // 这里要么就是 src 目录，要么就已经是根目录
diff --git a/tsconfig.json b/tsconfig.json
index 47098a233f83..b8ec67c043aa 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,7 +2,6 @@
   "extends": "./node_modules/mwts/tsconfig-midway.json",
   "compileOnSave": true,
   "compilerOptions": {
-    "moduleResolution": "node",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "noImplicitThis": false,