@midwayjs/core 3.12.0-beta.2 → 3.12.1

package/LICENSE

@@ -0,0 +1,21 @@
+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.

package/dist/baseFramework.js

@@ -197,6 +197,9 @@ class BaseFramework {
                 ctx.getAttr = (key) => {
                     return ctx.requestContext.getAttr(key);
                 };
+                ctx.getApp = () => {
+                    return this.getApplication();
+                };
                 return ctx;
             },
             addConfigObject: (obj) => {

package/dist/common/dataSourceManager.d.ts

@@ -1,34 +1,12 @@
-import { ModuleLoadType } from '../interface';
-export interface CreateDataSourceInstanceOptions {
-    /**
-     * @default false
-     */
-    validateConnection?: boolean;
-    /**
-     * @default true
-     */
-    cacheInstance?: boolean | undefined;
-}
-interface DataSourceConfig extends CreateDataSourceInstanceOptions {
-    dataSource: {
-        entities?: Array<string | unknown>;
-        [key: string]: unknown;
-    };
-}
-export declare abstract class DataSourceManager<T> {
+import { ModuleLoadType, DataSourceManagerConfigOption } from '../interface';
+export declare abstract class DataSourceManager<T, ConnectionOpts extends Record<string, any> = Record<string, any>> {
     protected dataSource: Map<string, T>;
-    protected options: Partial<DataSourceConfig>;
+    protected options: DataSourceManagerConfigOption<ConnectionOpts>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
-    protected initDataSource(dataSourceConfig: {
-        dataSource: {
-            entities?: Array<string | unknown>;
-            [key: string]: unknown;
-        };
-        cacheInstance?: boolean;
-        validateConnection?: boolean;
-    }, appDirOrOptions: {
-        appDir: string;
+    protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts>, baseDirOrOptions: {
+        baseDir: string;
+        entitiesConfigKey?: string;
     } | string): Promise<void>;
     /**
      * get a data source instance
@@ -46,7 +24,10 @@ export declare abstract class DataSourceManager<T> {
      * @param dataSourceName
      */
     isConnected(dataSourceName: string): Promise<boolean>;
-    createInstance(config: any, clientName: any, options?: CreateDataSourceInstanceOptions): Promise<T | void>;
+    createInstance(config: any, clientName: any, options?: {
+        validateConnection?: boolean;
+        cacheInstance?: boolean | undefined;
+    }): Promise<T | void>;
     /**
      * get data source name by model or repository
      * @param modelOrRepository
@@ -61,5 +42,4 @@ export declare abstract class DataSourceManager<T> {
 }
 export declare function formatGlobString(globString: string): string[];
 export declare function globModels(globString: string, appDir: string, loadMode?: ModuleLoadType): Promise<any[]>;
-export {};
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -19,25 +19,27 @@ class DataSourceManager {
         this.options = {};
         this.modelMapping = new WeakMap();
     }
-    async initDataSource(dataSourceConfig, appDirOrOptions) {
+    async initDataSource(dataSourceConfig, baseDirOrOptions) {
         this.options = dataSourceConfig;
         if (!this.options.dataSource) {
             throw new error_1.MidwayParameterError('[DataSourceManager] must set options.dataSource.');
         }
-        if (typeof appDirOrOptions === 'string') {
-            appDirOrOptions = {
-                appDir: appDirOrOptions,
+        if (typeof baseDirOrOptions === 'string') {
+            baseDirOrOptions = {
+                baseDir: baseDirOrOptions,
+                entitiesConfigKey: 'entities',
             };
         }
         for (const dataSourceName in dataSourceConfig.dataSource) {
             const dataSourceOptions = dataSourceConfig.dataSource[dataSourceName];
-            if (dataSourceOptions['entities']) {
+            const userEntities = dataSourceOptions[baseDirOrOptions.entitiesConfigKey];
+            if (userEntities) {
                 const entities = new Set();
                 // loop entities and glob files to model
-                for (const entity of dataSourceOptions['entities']) {
+                for (const entity of userEntities) {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = await globModels(entity, appDirOrOptions.appDir);
+                        const models = await globModels(entity, baseDirOrOptions.baseDir);
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
@@ -49,8 +51,9 @@ class DataSourceManager {
                         this.modelMapping.set(entity, dataSourceName);
                     }
                 }
-                dataSourceOptions['entities'] = Array.from(entities);
-                debug(`[core]: DataManager load ${dataSourceOptions['entities'].length} models from ${dataSourceName}.`);
+                dataSourceOptions[baseDirOrOptions.entitiesConfigKey] =
+                    Array.from(entities);
+                debug(`[core]: DataManager load ${dataSourceOptions[baseDirOrOptions.entitiesConfigKey].length} models from ${dataSourceName}.`);
             }
             // create data source
             const opts = {

package/dist/constants.d.ts

@@ -41,10 +41,14 @@ export declare const FUNCTION_INJECT_KEY = "midway:function_inject_key";
 export declare const MIDWAY_LOGGER_WRITEABLE_DIR = "MIDWAY_LOGGER_WRITEABLE_DIR";
 export declare const REQUEST_CTX_KEY = "ctx";
 export declare const REQUEST_OBJ_CTX_KEY = "_req_ctx";
+export declare const CONTAINER_OBJ_SCOPE = "_obj_scope";
 export declare const HTTP_SERVER_KEY = "_midway_http_server";
 export declare const REQUEST_CTX_LOGGER_CACHE_KEY = "_midway_ctx_logger_cache";
 export declare const ASYNC_CONTEXT_KEY: unique symbol;
 export declare const ASYNC_CONTEXT_MANAGER_KEY = "MIDWAY_ASYNC_CONTEXT_MANAGER_KEY";
 export declare const DEFAULT_PATTERN: string[];
 export declare const IGNORE_PATTERN: string[];
+export declare const SINGLETON_CONTAINER_CTX: {
+    _MAIN_CTX_: boolean;
+};
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IGNORE_PATTERN = exports.DEFAULT_PATTERN = exports.ASYNC_CONTEXT_MANAGER_KEY = exports.ASYNC_CONTEXT_KEY = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.FUNCTION_INJECT_KEY = exports.KEYS = void 0;
+exports.SINGLETON_CONTAINER_CTX = exports.IGNORE_PATTERN = exports.DEFAULT_PATTERN = exports.ASYNC_CONTEXT_MANAGER_KEY = exports.ASYNC_CONTEXT_KEY = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.CONTAINER_OBJ_SCOPE = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.FUNCTION_INJECT_KEY = exports.KEYS = void 0;
 /**
  * 静态参数
  *
@@ -44,6 +44,7 @@ exports.FUNCTION_INJECT_KEY = 'midway:function_inject_key';
 exports.MIDWAY_LOGGER_WRITEABLE_DIR = 'MIDWAY_LOGGER_WRITEABLE_DIR';
 exports.REQUEST_CTX_KEY = 'ctx';
 exports.REQUEST_OBJ_CTX_KEY = '_req_ctx';
+exports.CONTAINER_OBJ_SCOPE = '_obj_scope';
 exports.HTTP_SERVER_KEY = '_midway_http_server';
 exports.REQUEST_CTX_LOGGER_CACHE_KEY = '_midway_ctx_logger_cache';
 exports.ASYNC_CONTEXT_KEY = Symbol('ASYNC_CONTEXT_KEY');
@@ -57,4 +58,5 @@ exports.DEFAULT_PATTERN = [
     '**/**.cjs',
 ];
 exports.IGNORE_PATTERN = ['**/**.d.ts', '**/**.d.mts', '**/**.d.cts'];
+exports.SINGLETON_CONTAINER_CTX = { _MAIN_CTX_: true };
 //# sourceMappingURL=constants.js.map

package/dist/context/container.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { IFileDetector, IIdentifierRelationShip, IMidwayContainer, IModuleStore, IObjectDefinition, IObjectDefinitionRegistry, ObjectContext, ObjectIdentifier } from '../interface';
+import { IFileDetector, IIdentifierRelationShip, IMidwayContainer, IModuleStore, IObjectDefinition, IObjectDefinitionRegistry, ObjectContext, ObjectIdentifier, ScopeEnum } from '../interface';
 import { ManagedResolverFactory } from './managedResolverFactory';
 import * as EventEmitter from 'events';
 export declare class MidwayContainer implements IMidwayContainer, IModuleStore {
@@ -9,7 +9,9 @@ export declare class MidwayContainer implements IMidwayContainer, IModuleStore {
     private moduleMap;
     private _objectCreateEventTarget;
     parent: IMidwayContainer;
-    protected ctx: {};
+    protected ctx: {
+        _MAIN_CTX_: boolean;
+    };
     private fileDetector;
     private attrMap;
     private _namespaceSet;
@@ -79,5 +81,6 @@ export declare class MidwayContainer implements IMidwayContainer, IModuleStore {
     getNamespaceList(): string[];
     hasDefinition(identifier: ObjectIdentifier): boolean;
     hasObject(identifier: ObjectIdentifier): boolean;
+    getInstanceScope(instance: any): ScopeEnum | undefined;
 }
 //# sourceMappingURL=container.d.ts.map

package/dist/context/container.js

@@ -186,8 +186,8 @@ class MidwayContainer {
         this._identifierMapping = null;
         this.moduleMap = null;
         this.parent = null;
-        // 仅仅用于兼容requestContainer的ctx
-        this.ctx = {};
+        // 仅仅用于兼容 requestContainer 的 ctx
+        this.ctx = constants_1.SINGLETON_CONTAINER_CTX;
         this.attrMap = new Map();
         this._namespaceSet = null;
         this.parent = parent;
@@ -502,6 +502,12 @@ class MidwayContainer {
     hasObject(identifier) {
         return this.registry.hasObject(identifier);
     }
+    getInstanceScope(instance) {
+        if (instance[constants_1.CONTAINER_OBJ_SCOPE]) {
+            return instance[constants_1.CONTAINER_OBJ_SCOPE];
+        }
+        return undefined;
+    }
 }
 exports.MidwayContainer = MidwayContainer;
 //# sourceMappingURL=container.js.map

package/dist/context/managedResolverFactory.d.ts

@@ -1,4 +1,4 @@
-import { IManagedResolver, IObjectDefinition, IManagedResolverFactoryCreateOptions, IMidwayContainer, IManagedInstance, InjectModeEnum, ObjectIdentifier } from '../interface';
+import { IManagedInstance, IManagedResolver, IManagedResolverFactoryCreateOptions, IMidwayContainer, InjectModeEnum, IObjectDefinition, ObjectIdentifier } from '../interface';
 export declare class ManagedReference implements IManagedInstance {
     type: string;
     name: string;
@@ -50,5 +50,6 @@ export declare class ManagedResolverFactory {
     depthFirstSearch(identifier: string, definition: IObjectDefinition, depth?: string[]): boolean;
     private getObjectEventTarget;
     private checkSingletonInvokeRequest;
+    private setInstanceScope;
 }
 //# sourceMappingURL=managedResolverFactory.d.ts.map

package/dist/context/managedResolverFactory.js

@@ -163,12 +163,18 @@ class ManagedResolverFactory {
             context: this.context,
             definition,
         });
-        if (definition.isSingletonScope() && definition.id) {
-            this.singletonCache.set(definition.id, inst);
-        }
-        // for request scope
-        if (definition.isRequestScope() && definition.id) {
-            this.context.registerObject(definition.id, inst);
+        if (definition.id) {
+            if (definition.isSingletonScope()) {
+                this.singletonCache.set(definition.id, inst);
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Singleton);
+            }
+            else if (definition.isRequestScope()) {
+                this.context.registerObject(definition.id, inst);
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Request);
+            }
+            else {
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Prototype);
+            }
         }
         this.removeCreateStatus(definition, true);
         return inst;
@@ -217,6 +223,7 @@ class ManagedResolverFactory {
         if (definition.isRequestScope() &&
             definition.constructor.name === 'ObjectDefinition') {
             debug('id = %s inject ctx', definition.id);
+            // set related ctx
             Object.defineProperty(inst, constants_1.REQUEST_OBJ_CTX_KEY, {
                 value: this.context.get(constants_1.REQUEST_CTX_KEY),
                 writable: false,
@@ -253,14 +260,20 @@ class ManagedResolverFactory {
             context: this.context,
             definition,
         });
-        if (definition.isSingletonScope() && definition.id) {
-            debug(`id = ${definition.id}(${definition.name}) set to singleton cache`);
-            this.singletonCache.set(definition.id, inst);
-        }
-        // for request scope
-        if (definition.isRequestScope() && definition.id) {
-            debug(`id = ${definition.id}(${definition.name}) set to register object`);
-            this.context.registerObject(definition.id, inst);
+        if (definition.id) {
+            if (definition.isSingletonScope()) {
+                debug(`id = ${definition.id}(${definition.name}) set to singleton cache`);
+                this.singletonCache.set(definition.id, inst);
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Singleton);
+            }
+            else if (definition.isRequestScope()) {
+                debug(`id = ${definition.id}(${definition.name}) set to register object`);
+                this.context.registerObject(definition.id, inst);
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Request);
+            }
+            else {
+                this.setInstanceScope(inst, interface_1.ScopeEnum.Prototype);
+            }
         }
         this.removeCreateStatus(definition, true);
         return inst;
@@ -409,6 +422,20 @@ class ManagedResolverFactory {
         }
         return true;
     }
+    setInstanceScope(inst, scope) {
+        if (typeof inst === 'object') {
+            if (scope === interface_1.ScopeEnum.Request &&
+                inst[constants_1.REQUEST_OBJ_CTX_KEY] === constants_1.SINGLETON_CONTAINER_CTX) {
+                scope = interface_1.ScopeEnum.Singleton;
+            }
+            Object.defineProperty(inst, constants_1.CONTAINER_OBJ_SCOPE, {
+                value: scope,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        }
+    }
 }
 exports.ManagedResolverFactory = ManagedResolverFactory;
 //# sourceMappingURL=managedResolverFactory.js.map

package/dist/context/requestContainer.d.ts

@@ -7,6 +7,8 @@ export declare class MidwayRequestContainer extends MidwayContainer {
     get<T = any>(identifier: any, args?: any): T;
     getAsync<T = any>(identifier: any, args?: any): Promise<T>;
     ready(): Promise<void>;
-    getContext(): {};
+    getContext(): {
+        _MAIN_CTX_: boolean;
+    };
 }
 //# sourceMappingURL=requestContainer.d.ts.map

package/dist/decorator/faas/serverlessTrigger.js

@@ -23,7 +23,7 @@ function ServerlessTrigger(type, metadata = {}) {
             type,
             methodName: functionName,
             metadata,
-        }, target.constructor);
+        }, target);
     };
 }
 exports.ServerlessTrigger = ServerlessTrigger;

package/dist/index.d.ts

@@ -17,7 +17,7 @@ export { MidwayDecoratorService } from './service/decoratorService';
 export { MidwayMockService } from './service/mockService';
 export { RouterInfo, DynamicRouterInfo, RouterPriority, RouterCollectorOptions, MidwayWebRouterService, } from './service/webRouterService';
 export { MidwayServerlessFunctionService, WebRouterCollector, } from './service/slsFunctionService';
-export { CreateDataSourceInstanceOptions, DataSourceManager, } from './common/dataSourceManager';
+export { DataSourceManager } from './common/dataSourceManager';
 export * from './service/pipelineService';
 export * from './common/loggerFactory';
 export * from './common/serviceFactory';

package/dist/interface.d.ts

@@ -368,15 +368,25 @@ export type ServiceFactoryConfigOption<OPTIONS> = {
     };
     defaultClientName?: string;
 };
-export type DataSourceManagerConfigOption<OPTIONS> = {
+export type CreateDataSourceInstanceOptions = {
+    /**
+     * @default false
+     */
+    validateConnection?: boolean;
+    /**
+     * @default true
+     */
+    cacheInstance?: boolean | undefined;
+};
+export type DataSourceManagerConfigOption<OPTIONS, ENTITY_CONFIG_KEY extends string = 'entities'> = {
     default?: PowerPartial<OPTIONS>;
     defaultDataSourceName?: string;
     dataSource?: {
         [key: string]: PowerPartial<{
-            entities: any[];
+            [keyName in ENTITY_CONFIG_KEY]: any[];
         } & OPTIONS>;
     };
-};
+} & CreateDataSourceInstanceOptions;
 type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<ReturnType<T>>> : Writable<PowerPartial<T>>;
 /**
  * Get definition from config
@@ -593,6 +603,11 @@ export interface IMidwayContainer extends IObjectFactory, WithFn<IObjectLifeCycl
      * @param key
      */
     getAttr<T>(key: string): T;
+    /**
+     * Get instance IoC container scope
+     * @param instance
+     */
+    getInstanceScope(instance: any): ScopeEnum | undefined;
 }
 /**
  * @deprecated
@@ -645,6 +660,10 @@ export interface Context {
      * @param key
      */
     getAttr<T>(key: string): T;
+    /**
+     * Get current related application instance.
+     */
+    getApp(): IMidwayApplication;
 }
 export type IMidwayContext<FrameworkContext = unknown> = Context & FrameworkContext;
 export type NextFunction = () => Promise<any>;

package/dist/util/httpclient.d.ts

@@ -3,10 +3,8 @@
 /// <reference types="node" />
 import http = require('http');
 import https = require('https');
-type MethodType = 'GET' | 'POST';
 type MimeType = 'text' | 'json' | undefined;
 interface IOptions extends https.RequestOptions {
-    method?: MethodType;
     headers?: any;
     contentType?: MimeType;
     dataType?: MimeType;

package/dist/util/index.js

@@ -54,6 +54,7 @@ const safeRequire = (p, enabledCache = true) => {
     }
 };
 exports.safeRequire = safeRequire;
+const innerLoadModuleCache = {};
 /**
  * load module, and it can be chosen commonjs or esm mode
  * @param p
@@ -76,9 +77,18 @@ const loadModule = async (p, options = {}) => {
             else {
                 // 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;
+                    /**
+                     * attention: import json not support under nodejs 16
+                     * use readFileSync instead
+                     */
+                    if (!innerLoadModuleCache[p]) {
+                        // return (await import(p, { assert: { type: 'json' } })).default;
+                        const content = (0, fs_1.readFileSync)(p, {
+                            encoding: 'utf-8',
+                        });
+                        innerLoadModuleCache[p] = JSON.parse(content);
+                    }
+                    return innerLoadModuleCache[p];
                 }
                 else {
                     return await import(p);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.12.0-beta.2",
+  "version": "3.12.1",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+  "gitHead": "48413b87b12354cb8207de6aa58e0a4ca22ea000"
 }