@midwayjs/core 3.11.1 → 3.11.6

package/dist/common/dataSourceManager.d.ts

@@ -1,9 +1,34 @@
+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> {
     protected dataSource: Map<string, T>;
-    protected options: {};
+    protected options: Partial<DataSourceConfig>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
-    protected initDataSource(options: any, appDir: string): Promise<void>;
+    protected initDataSource(dataSourceConfig: {
+        dataSource: {
+            entities?: Array<string | unknown>;
+            [key: string]: unknown;
+        };
+        cacheInstance?: boolean;
+        validateConnection?: boolean;
+    }, appDirOrOptions: {
+        appDir: string;
+    } | string): Promise<void>;
     /**
      * get a data source instance
      * @param dataSourceName
@@ -35,14 +60,5 @@ export declare abstract class DataSourceManager<T> {
 }
 export declare function formatGlobString(globString: string): string[];
 export declare function globModels(globString: string, appDir: string): any[];
-export interface CreateDataSourceInstanceOptions {
-    /**
-     * @default false
-     */
-    validateConnection?: boolean;
-    /**
-     * @default true
-     */
-    cacheInstance?: boolean | undefined;
-}
+export {};
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -10,43 +10,51 @@ const glob_1 = require("@midwayjs/glob");
 const path_1 = require("path");
 const types_1 = require("../util/types");
 const constants_1 = require("../constants");
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:debug');
 class DataSourceManager {
     constructor() {
         this.dataSource = new Map();
         this.options = {};
         this.modelMapping = new WeakMap();
     }
-    async initDataSource(options, appDir) {
-        this.options = options;
-        if (!options.dataSource) {
+    async initDataSource(dataSourceConfig, appDirOrOptions) {
+        this.options = dataSourceConfig;
+        if (!this.options.dataSource) {
             throw new error_1.MidwayParameterError('[DataSourceManager] must set options.dataSource.');
         }
-        for (const dataSourceName in options.dataSource) {
-            const dataSourceOptions = options.dataSource[dataSourceName];
+        if (typeof appDirOrOptions === 'string') {
+            appDirOrOptions = {
+                appDir: appDirOrOptions,
+            };
+        }
+        for (const dataSourceName in dataSourceConfig.dataSource) {
+            const dataSourceOptions = dataSourceConfig.dataSource[dataSourceName];
             if (dataSourceOptions['entities']) {
                 const entities = new Set();
                 // loop entities and glob files to model
                 for (const entity of dataSourceOptions['entities']) {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = globModels(entity, appDir);
+                        const models = globModels(entity, appDirOrOptions.appDir);
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
                         }
                     }
                     else {
-                        // model will be add to array
+                        // model will be added to array
                         entities.add(entity);
                         this.modelMapping.set(entity, dataSourceName);
                     }
                 }
                 dataSourceOptions['entities'] = Array.from(entities);
+                debug(`[core]: DataManager load ${dataSourceOptions['entities'].length} models from ${dataSourceName}.`);
             }
             // create data source
             const opts = {
-                cacheInstance: options.cacheInstance,
-                validateConnection: options.validateConnection,
+                cacheInstance: dataSourceConfig.cacheInstance,
+                validateConnection: dataSourceConfig.validateConnection,
             };
             await this.createInstance(dataSourceOptions, dataSourceName, opts);
         }

package/dist/decorator/faas/serverlessTrigger.d.ts

@@ -1,5 +1,5 @@
 import { FaaSMetadata, ServerlessTriggerType } from '../../interface';
-export declare function ServerlessFunction(options: FaaSMetadata.ServerlessFunctionOptions): MethodDecorator;
+export declare function ServerlessFunction(options: FaaSMetadata.ServerlessFunctionOptions & Record<string, any>): MethodDecorator;
 export declare function ServerlessTrigger(type: ServerlessTriggerType.HTTP, metadata: FaaSMetadata.HTTPTriggerOptions): MethodDecorator;
 export declare function ServerlessTrigger(type: ServerlessTriggerType.OS, metadata: FaaSMetadata.OSTriggerOptions): MethodDecorator;
 export declare function ServerlessTrigger(type: ServerlessTriggerType.LOG, metadata: FaaSMetadata.LogTriggerOptions): MethodDecorator;

package/dist/decorator/web/paramMapping.d.ts

@@ -1,4 +1,4 @@
-import { IMidwayContext, PipeUnionTransform } from '../../interface';
+import { IMidwayContext, ParamDecoratorOptions, PipeUnionTransform } from '../../interface';
 export declare enum RouteParamTypes {
     QUERY = "query",
     BODY = "body",
@@ -22,7 +22,7 @@ export interface RouterParamValue {
 export declare type KoaLikeCustomParamDecorator<T = unknown> = (ctx: IMidwayContext) => T | Promise<T>;
 export declare type ExpressLikeCustomParamDecorator<T = unknown> = (req: any, res: any) => T | Promise<T>;
 export declare type CustomParamDecorator<T = unknown> = KoaLikeCustomParamDecorator<T> | ExpressLikeCustomParamDecorator<T>;
-export declare const createRequestParamDecorator: (transform: CustomParamDecorator, pipes?: Array<PipeUnionTransform>) => ParameterDecorator;
+export declare const createRequestParamDecorator: (transform: CustomParamDecorator, pipesOrOptions?: ParamDecoratorOptions | Array<PipeUnionTransform>) => ParameterDecorator;
 export declare const Session: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;
 export declare const Body: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;
 export declare const Query: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;

package/dist/decorator/web/paramMapping.js

@@ -33,8 +33,14 @@ const createParamMapping = function (type) {
         });
     };
 };
-const createRequestParamDecorator = function (transform, pipes) {
-    return createParamMapping(RouteParamTypes.CUSTOM)(transform, pipes);
+const createRequestParamDecorator = function (transform, pipesOrOptions) {
+    pipesOrOptions = pipesOrOptions || {};
+    if (Array.isArray(pipesOrOptions)) {
+        pipesOrOptions = {
+            pipes: pipesOrOptions,
+        };
+    }
+    return createParamMapping(RouteParamTypes.CUSTOM)(transform, pipesOrOptions.pipes);
 };
 exports.createRequestParamDecorator = createRequestParamDecorator;
 const Session = (propertyOrPipes, pipes) => createParamMapping(RouteParamTypes.SESSION)(propertyOrPipes, pipes);

package/dist/interface.d.ts

@@ -3,6 +3,43 @@ import type { LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import type { AsyncContextManager } from './common/asyncContextManager';
 import type { LoggerFactory } from './common/loggerFactory';
+export type PowerPartial<T> = {
+    [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
+};
+/**
+ * Make object property writeable
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Utility type that adds a `fn` parameter to each method in the input type `T`,
+ * transforming the original method's parameter types and return type into a function type.
+ *
+ * @example
+ * // Input:
+ * interface MyInterface {
+ *   method1(a: string, b: number): boolean;
+ *   method2(x: Foo, y: Bar): void;
+ * }
+ *
+ * // Output:
+ * interface MyInterfaceWithFn {
+ *   method1(fn: (a: string, b: number) => boolean): void;
+ *   method2(fn: (x: Foo, y: Bar) => void): void;
+ * }
+ */
+export type WithFn<T> = {
+    [K in keyof T]: T[K] extends (...args: infer P) => infer R ? (fn: (...args: P) => R) => void : T[K];
+};
+/**
+ * Transform an object type `T` with methods that have function-type parameters
+ * to a new object type with the same methods, but with the parameters
+ * extracted as separate properties.
+ */
+export type WithoutFn<T> = {
+    [K in keyof T]: T[K] extends (arg: any, ...args: any[]) => any ? (...args: Parameters<T[K]>) => ReturnType<T[K]> : T[K];
+};
 export type MiddlewareParamArray = Array<string | any>;
 export type ObjectIdentifier = string | Symbol;
 export type GroupModeType = 'one' | 'multi';
@@ -323,9 +360,6 @@ export interface MidwayCoreDefaultConfig {
         enable: boolean;
     };
 }
-export type PowerPartial<T> = {
-    [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
-};
 export type ServiceFactoryConfigOption<OPTIONS> = {
     default?: PowerPartial<OPTIONS>;
     client?: PowerPartial<OPTIONS>;
@@ -348,12 +382,6 @@ type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<R
  * Get definition from config
  */
 export type FileConfigOption<T, K = unknown> = K extends keyof ConfigType<T> ? Pick<ConfigType<T>, K> : ConfigType<T>;
-/**
- * Make object property writeable
- */
-export type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
 /**
  * Lifecycle Definition
  * 生命周期定义
@@ -407,11 +435,11 @@ export interface ObjectBeforeDestroyOptions extends ObjectLifeCycleOptions {
  * 对象生命周期
  */
 export interface IObjectLifeCycle {
-    onBeforeBind(fn: (Clzz: any, options: ObjectBeforeBindOptions) => void): any;
-    onBeforeObjectCreated(fn: (Clzz: any, options: ObjectBeforeCreatedOptions) => void): any;
-    onObjectCreated<T>(fn: (ins: T, options: ObjectCreatedOptions<T>) => void): any;
-    onObjectInit<T>(fn: (ins: T, options: ObjectInitOptions) => void): any;
-    onBeforeObjectDestroy<T>(fn: (ins: T, options: ObjectBeforeDestroyOptions) => void): any;
+    onBeforeBind(Clzz: any, options: ObjectBeforeBindOptions): void;
+    onBeforeObjectCreated(Clzz: any, options: ObjectBeforeCreatedOptions): void;
+    onObjectCreated<T>(ins: T, options: ObjectCreatedOptions<T>): void;
+    onObjectInit<T>(ins: T, options: ObjectInitOptions): void;
+    onBeforeObjectDestroy<T>(ins: T, options: ObjectBeforeDestroyOptions): void;
 }
 /**
  * Object Definition
@@ -537,7 +565,7 @@ export interface IIdentifierRelationShip {
     hasRelation(id: ObjectIdentifier): boolean;
     getRelation(id: ObjectIdentifier): string;
 }
-export interface IMidwayContainer extends IObjectFactory, IObjectLifeCycle {
+export interface IMidwayContainer extends IObjectFactory, WithFn<IObjectLifeCycle> {
     parent: IMidwayContainer;
     identifierMapping: IIdentifierRelationShip;
     objectCreateEventTarget: EventEmitter;

package/dist/util/httpclient.d.ts

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

package/dist/util/httpclient.js

@@ -22,10 +22,8 @@ async function makeHttpRequest(url, options = {}) {
     debug(`request '${url}'`);
     const whatwgUrl = new URL(url);
     const client = whatwgUrl.protocol === 'https:' ? https : http;
-    const contentType = options.contentType;
-    const dataType = options.dataType;
-    const method = (options.method || 'GET').toUpperCase();
-    const timeout = options.timeout || 5000;
+    options.method = (options.method || 'GET').toUpperCase();
+    const { contentType, dataType, method, timeout = 5000, ...otherOptions } = options;
     const headers = {
         Accept: mimeMap[dataType] || mimeMap.octet,
         ...options.headers,
@@ -50,6 +48,7 @@ async function makeHttpRequest(url, options = {}) {
         const req = client.request(whatwgUrl.toString(), {
             method,
             headers,
+            ...otherOptions,
         }, res => {
             res.setTimeout(timeout, () => {
                 res.destroy(new Error('Response Timeout'));

package/dist/util/index.d.ts

@@ -18,6 +18,7 @@ export declare const getCurrentEnvironment: () => string;
  */
 export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
 /**
+ *  @example
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
  *  safelyGet(['a','b'],{c: {b: 2}})  // => undefined
  *  safelyGet(['a','1'],{a: {"1": 2}})  // => 2

package/dist/util/index.js

@@ -55,6 +55,7 @@ const safeRequire = (p, enabledCache = true) => {
 };
 exports.safeRequire = safeRequire;
 /**
+ *  @example
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
  *  safelyGet(['a','b'],{c: {b: 2}})  // => undefined
  *  safelyGet(['a','1'],{a: {"1": 2}})  // => 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.11.1",
+  "version": "3.11.6",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -23,9 +23,9 @@
   "license": "MIT",
   "devDependencies": {
     "koa": "2.14.1",
-    "mm": "3.2.1",
+    "mm": "3.2.2",
     "raw-body": "2.5.2",
-    "sinon": "15.0.3"
+    "sinon": "15.0.4"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "bd9375874eb8cfaa49fbcfaa0497021cea06a394"
+  "gitHead": "d1ca8ca3ee5223c1c034ad3c97d335348931404b"
 }