@midwayjs/core 3.12.2 → 3.13.0-beta.1

package/dist/baseFramework.d.ts

@@ -1,5 +1,4 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion } from './interface';
-import { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions } from './interface';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
@@ -18,7 +17,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected appLogger: ILogger;
     protected defaultContext: {};
     protected contextLoggerApplyLogger: string;
-    protected contextLoggerFormat: LoggerContextFormat;
+    protected contextLoggerFormat: any;
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected guardManager: GuardManager<CTX>;
@@ -80,7 +79,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     applyMiddleware<R, N>(lastMiddleware?: CommonMiddlewareUnion<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): any;
     getCoreLogger(): ILogger;
-    createLogger(name: string, option?: LoggerOptions): any;
+    createLogger(name: string, option?: MidwayLoggerOptions): any;
     getProjectName(): string;
     getFrameworkName(): string;
     useMiddleware(middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;

package/dist/baseFramework.js

@@ -107,7 +107,7 @@ class BaseFramework {
                 return ctxLoggerCache.get(name);
             }
             // create new context logger
-            const ctxLogger = appLogger.createContextLogger(ctx, {
+            const ctxLogger = this.loggerService.createContextLogger(ctx, appLogger, {
                 contextFormat: this.contextLoggerFormat,
             });
             ctxLoggerCache.set(name, ctxLogger);
@@ -118,7 +118,7 @@ class BaseFramework {
             if (ctx['_logger']) {
                 return ctx['_logger'];
             }
-            ctx['_logger'] = appLogger.createContextLogger(ctx, {
+            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger, {
                 contextFormat: this.contextLoggerFormat,
             });
             return ctx['_logger'];

package/dist/common/dataSourceManager.d.ts

@@ -1,9 +1,12 @@
 import { ModuleLoadType, DataSourceManagerConfigOption } from '../interface';
+import { MidwayEnvironmentService } from '../service/environmentService';
 export declare abstract class DataSourceManager<T, ConnectionOpts extends Record<string, any> = Record<string, any>> {
     protected dataSource: Map<string, T>;
     protected options: DataSourceManagerConfigOption<ConnectionOpts>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
+    appDir: string;
+    environmentService: MidwayEnvironmentService;
     protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts>, baseDirOrOptions: {
         baseDir: string;
         entitiesConfigKey?: string;

package/dist/common/dataSourceManager.js

@@ -1,4 +1,13 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globModels = exports.formatGlobString = exports.DataSourceManager = void 0;
 /**
@@ -12,6 +21,8 @@ const types_1 = require("../util/types");
 const constants_1 = require("../constants");
 const util_1 = require("util");
 const util_2 = require("../util");
+const decorator_1 = require("../decorator");
+const environmentService_1 = require("../service/environmentService");
 const debug = (0, util_1.debuglog)('midway:debug');
 class DataSourceManager {
     constructor() {
@@ -20,6 +31,7 @@ class DataSourceManager {
         this.modelMapping = new WeakMap();
     }
     async initDataSource(dataSourceConfig, baseDirOrOptions) {
+        var _a;
         this.options = dataSourceConfig;
         if (!this.options.dataSource) {
             throw new error_1.MidwayParameterError('[DataSourceManager] must set options.dataSource.');
@@ -39,7 +51,7 @@ class DataSourceManager {
                 for (const entity of userEntities) {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = await globModels(entity, baseDirOrOptions.baseDir);
+                        const models = await globModels(entity, baseDirOrOptions.baseDir, (_a = this.environmentService) === null || _a === void 0 ? void 0 : _a.getModuleLoadType());
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
@@ -141,6 +153,14 @@ class DataSourceManager {
         return this.innerDefaultDataSourceName;
     }
 }
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], DataSourceManager.prototype, "appDir", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", environmentService_1.MidwayEnvironmentService)
+], DataSourceManager.prototype, "environmentService", void 0);
 exports.DataSourceManager = DataSourceManager;
 function formatGlobString(globString) {
     let pattern;

package/dist/common/loggerFactory.d.ts

@@ -1,8 +1,32 @@
-import { ILogger } from '../interface';
+import { ILogger, MidwayAppInfo } from '../interface';
 export declare abstract class LoggerFactory<Logger extends ILogger, LoggerOptions> {
     abstract createLogger(name: string, options: LoggerOptions): Logger;
     abstract getLogger(loggerName: string): Logger;
     abstract close(loggerName?: string): any;
     abstract removeLogger(loggerName: string): any;
+    abstract getDefaultMidwayLoggerConfig(appInfo: MidwayAppInfo): {
+        midwayLogger: {
+            default?: LoggerOptions;
+            clients?: {
+                [loggerName: string]: LoggerOptions;
+            };
+        };
+    };
+    abstract createContextLogger(ctx: any, appLogger: ILogger, contextOptions?: any): ILogger;
+}
+export declare class DefaultConsoleLoggerFactory implements LoggerFactory<ILogger, any> {
+    createLogger(name: string, options: any): ILogger;
+    getLogger(loggerName: string): ILogger;
+    close(loggerName?: string): void;
+    removeLogger(loggerName: string): void;
+    getDefaultMidwayLoggerConfig(): {
+        midwayLogger: {
+            default?: any;
+            clients?: {
+                [p: string]: any;
+            };
+        };
+    };
+    createContextLogger(ctx: any, appLogger: ILogger): ILogger;
 }
 //# sourceMappingURL=loggerFactory.d.ts.map

package/dist/common/loggerFactory.js

@@ -1,7 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerFactory = void 0;
+exports.DefaultConsoleLoggerFactory = exports.LoggerFactory = void 0;
 class LoggerFactory {
 }
 exports.LoggerFactory = LoggerFactory;
+class DefaultConsoleLoggerFactory {
+    createLogger(name, options) {
+        return console;
+    }
+    getLogger(loggerName) {
+        return console;
+    }
+    close(loggerName) { }
+    removeLogger(loggerName) { }
+    getDefaultMidwayLoggerConfig() {
+        return {
+            midwayLogger: {
+                default: {},
+                clients: {
+                    coreLogger: {},
+                    appLogger: {},
+                },
+            },
+        };
+    }
+    createContextLogger(ctx, appLogger) {
+        return appLogger;
+    }
+}
+exports.DefaultConsoleLoggerFactory = DefaultConsoleLoggerFactory;
 //# sourceMappingURL=loggerFactory.js.map

package/dist/config/config.default.js

@@ -1,30 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const util_1 = require("../util/");
-const path_1 = require("path");
-const constants_1 = require("../constants");
 exports.default = (appInfo) => {
-    var _a;
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
-    const logRoot = (_a = process.env[constants_1.MIDWAY_LOGGER_WRITEABLE_DIR]) !== null && _a !== void 0 ? _a : appInfo.root;
     return {
         asyncContextManager: {
             enable: false,
         },
         midwayLogger: {
             default: {
-                dir: (0, path_1.join)(logRoot, 'logs', appInfo.name),
                 level: 'info',
-                consoleLevel: isDevelopment ? 'info' : 'warn',
-                auditFileDir: '.audit',
             },
             clients: {
-                coreLogger: {
-                    level: isDevelopment ? 'info' : 'warn',
-                    fileLogName: 'midway-core.log',
-                },
+                coreLogger: {},
                 appLogger: {
-                    fileLogName: 'midway-app.log',
                     aliasName: 'logger',
                 },
             },

package/dist/index.d.ts

@@ -45,5 +45,4 @@ export { Types } from './util/types';
 export { PathFileUtil } from './util/pathFileUtil';
 export { FileUtils } from './util/fs';
 export { FORMAT } from './util/format';
-export type { ILogger, IMidwayLogger } from '@midwayjs/logger';
 //# sourceMappingURL=index.d.ts.map

package/dist/interface.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-import type { LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import type { AsyncContextManager } from './common/asyncContextManager';
 import type { LoggerFactory } from './common/loggerFactory';
@@ -343,16 +342,53 @@ export interface ParamDecoratorOptions {
     throwError?: boolean;
     pipes?: PipeUnionTransform<any, any>[];
 }
+/**
+ * Logger Options for midway, you can merge this interface in package
+ * @example
+ * ```typescript
+ *
+ * import { IMidwayLogger } from '@midwayjs/logger';
+ *
+ * declare module '@midwayjs/core/dist/interface' {
+ *   interface ILogger extends IMidwayLogger {
+ *   }
+ * }
+ *
+ * ```
+ */
 export interface ILogger {
     info(msg: any, ...args: any[]): void;
     debug(msg: any, ...args: any[]): void;
     error(msg: any, ...args: any[]): void;
     warn(msg: any, ...args: any[]): void;
 }
+/**
+ * @deprecated
+ */
+export type IMidwayLogger = ILogger;
+/**
+ * Logger Options for midway, you can merge this interface in package
+ * @example
+ * ```typescript
+ *
+ * import { LoggerOptions } from '@midwayjs/logger';
+ *
+ * declare module '@midwayjs/core/dist/interface' {
+ *   interface MidwayLoggerOptions extends LoggerOptions {
+ *     logDir?: string;
+ *     level?: string;
+ *   }
+ * }
+ *
+ * ```
+ */
+export interface MidwayLoggerOptions {
+    lazyLoad?: boolean;
+    aliasName?: string;
+    [key: string]: any;
+}
 export interface MidwayCoreDefaultConfig {
-    midwayLogger?: ServiceFactoryConfigOption<LoggerOptions & {
-        lazyLoad?: boolean;
-    }>;
+    midwayLogger?: ServiceFactoryConfigOption<MidwayLoggerOptions>;
     debug?: {
         recordConfigMergeOrder?: boolean;
     };
@@ -762,7 +798,7 @@ export interface IMidwayBaseApplication<CTX extends IMidwayContext> {
      * @param name
      * @param options
      */
-    createLogger(name: string, options: LoggerOptions): ILogger;
+    createLogger(name: string, options: MidwayLoggerOptions): ILogger;
     /**
      * Get project name, just package.json name
      */
@@ -847,7 +883,7 @@ export interface IConfigurationOptions {
     logger?: ILogger;
     appLogger?: ILogger;
     contextLoggerApplyLogger?: string;
-    contextLoggerFormat?: LoggerContextFormat;
+    contextLoggerFormat?: any;
 }
 export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, CONFIG extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> {
     app: APP;
@@ -866,7 +902,7 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     getBaseDir(): string;
     getLogger(name?: string): ILogger;
     getCoreLogger(): ILogger;
-    createLogger(name: string, options: LoggerOptions): ILogger;
+    createLogger(name: string, options: MidwayLoggerOptions): ILogger;
     getProjectName(): string;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
     getMiddleware(): IMiddlewareManager<CTX, ResOrNext, Next>;

package/dist/service/configService.d.ts

@@ -34,6 +34,7 @@ export declare class MidwayConfigService implements IConfigService {
      */
     addFilter(filter: (config: Record<string, any>) => Record<string, any>): void;
     protected runWithFilter(config: Record<string, any>): Record<string, any>;
+    getAppInfo(): MidwayAppInfo;
 }
 export {};
 //# sourceMappingURL=configService.d.ts.map

package/dist/service/configService.js

@@ -224,6 +224,9 @@ let MidwayConfigService = class MidwayConfigService {
         }
         return config;
     }
+    getAppInfo() {
+        return this.appInfo;
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/service/loggerService.d.ts

@@ -1,6 +1,6 @@
 import { MidwayConfigService } from './configService';
 import { ServiceFactory } from '../common/serviceFactory';
-import { ILogger, IMidwayContainer } from '../interface';
+import { ILogger, IMidwayContainer, IMidwayContext, MidwayLoggerOptions } from '../interface';
 import { LoggerFactory } from '../common/loggerFactory';
 export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     readonly applicationContext: IMidwayContainer;
@@ -8,12 +8,14 @@ export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
     configService: MidwayConfigService;
     private loggerFactory;
     private lazyLoggerConfigMap;
+    private aliasLoggerMap;
     constructor(applicationContext: IMidwayContainer, globalOptions?: {});
     protected init(): void;
     protected createClient(config: any, name?: string): void;
     getName(): string;
-    createLogger(name: any, config: any): any;
+    createLogger(name: string, config: MidwayLoggerOptions): any;
     getLogger(name: string): any;
     getCurrentLoggerFactory(): LoggerFactory<any, any>;
+    createContextLogger(ctx: IMidwayContext, appLogger: ILogger, contextOptions?: any): ILogger;
 }
 //# sourceMappingURL=loggerService.d.ts.map

package/dist/service/loggerService.js

@@ -14,22 +14,41 @@ const decorator_1 = require("../decorator");
 const configService_1 = require("./configService");
 const serviceFactory_1 = require("../common/serviceFactory");
 const interface_1 = require("../interface");
-const logger_1 = require("@midwayjs/logger");
+const loggerFactory_1 = require("../common/loggerFactory");
+const error_1 = require("../error");
 let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.ServiceFactory {
     constructor(applicationContext, globalOptions = {}) {
         super();
         this.applicationContext = applicationContext;
         this.globalOptions = globalOptions;
         this.lazyLoggerConfigMap = new Map();
+        this.aliasLoggerMap = new Map();
     }
     init() {
         var _a;
-        this.loggerFactory = this.globalOptions['loggerFactory'] || logger_1.loggers;
+        const loggerFactory = this.configService.getConfiguration('loggerFactory');
+        // load logger factory from user config first
+        this.loggerFactory =
+            loggerFactory ||
+                this.globalOptions['loggerFactory'] ||
+                new loggerFactory_1.DefaultConsoleLoggerFactory();
+        // check
+        if (!this.loggerFactory.getDefaultMidwayLoggerConfig) {
+            throw new error_1.MidwayFeatureNoLongerSupportedError('please upgrade your @midwayjs/logger to latest version');
+        }
+        const defaultLoggerConfig = this.loggerFactory.getDefaultMidwayLoggerConfig(this.configService.getAppInfo());
+        // merge to user config
+        this.configService.addObject(defaultLoggerConfig, true);
+        // init logger
         this.initClients(this.configService.getConfiguration('midwayLogger'));
         // alias inject logger
         (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
     }
     createClient(config, name) {
+        if (config.aliasName) {
+            // mapping alias logger name to real logger name
+            this.aliasLoggerMap.set(config.aliasName, name);
+        }
         if (!config.lazyLoad) {
             this.loggerFactory.createLogger(name, config);
         }
@@ -42,9 +61,14 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
         return 'logger';
     }
     createLogger(name, config) {
+        delete config['aliasName'];
         return this.loggerFactory.createLogger(name, config);
     }
     getLogger(name) {
+        if (this.aliasLoggerMap.has(name)) {
+            // get real logger name
+            name = this.aliasLoggerMap.get(name);
+        }
         const logger = this.loggerFactory.getLogger(name);
         if (logger) {
             return logger;
@@ -59,6 +83,9 @@ let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.Ser
     getCurrentLoggerFactory() {
         return this.loggerFactory;
     }
+    createContextLogger(ctx, appLogger, contextOptions) {
+        return this.loggerFactory.createContextLogger(ctx, appLogger, contextOptions);
+    }
 };
 __decorate([
     (0, decorator_1.Inject)(),

package/dist/setup.js

@@ -142,6 +142,9 @@ async function prepareGlobalApplicationContextAsync(globalOptions) {
         }
     }
     printStepDebugInfo('Init MidwayConfigService, MidwayAspectService and MidwayDecoratorService');
+    // init default environment
+    const environmentService = applicationContext.get(_1.MidwayEnvironmentService);
+    environmentService.setModuleLoadType(globalOptions.moduleLoadType);
     // init default config
     const configService = applicationContext.get(_1.MidwayConfigService);
     configService.add([
@@ -196,6 +199,9 @@ function prepareGlobalApplicationContext(globalOptions) {
     applicationContext.registerObject('baseDir', baseDir);
     applicationContext.registerObject('appDir', appDir);
     printStepDebugInfo('Ready module detector');
+    if (!globalOptions.moduleLoadType) {
+        globalOptions.moduleLoadType = 'commonjs';
+    }
     if (globalOptions.moduleDetector !== false) {
         if (globalOptions.moduleDetector === undefined) {
             applicationContext.setFileDetector(new _1.CommonJSFileDetector({

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.12.2",
+  "version": "3.13.0-beta.1",
   "description": "midway core",
-  "main": "dist/index",
+  "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
@@ -25,11 +25,11 @@
     "koa": "2.14.1",
     "mm": "3.3.0",
     "raw-body": "2.5.2",
-    "sinon": "15.2.0"
+    "sinon": "15.2.0",
+    "@midwayjs/logger": "3.0.0"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
-    "@midwayjs/logger": "^2.15.0",
     "class-transformer": "0.5.1",
     "picomatch": "2.3.1",
     "reflect-metadata": "0.1.13"
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "2f385d135df1dcb65bfdfd25a0c97476773f8315"
+  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2013 - Now midwayjs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.