@midwayjs/mock 4.0.0-alpha.1 → 4.0.0-beta.2

package/README.md

@@ -9,4 +9,4 @@ Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 
-[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))
+[MIT]((https://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/client/index.d.ts

@@ -3,4 +3,5 @@ export * from './rabbitMQ';
 export * from './socketio';
 export * from './ws.client';
 export * from './kafka';
+export * from './sse';
 //# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./rabbitMQ"), exports);
 __exportStar(require("./socketio"), exports);
 __exportStar(require("./ws.client"), exports);
 __exportStar(require("./kafka"), exports);
+__exportStar(require("./sse"), exports);
 //# sourceMappingURL=index.js.map

package/dist/client/sse.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export interface SSEClientOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+}
+export declare class SSEClient extends EventEmitter {
+    private url;
+    private options;
+    private request?;
+    private reconnectAttempts;
+    private shouldReconnect;
+    private reconnectTimer?;
+    constructor(url: string, options?: SSEClientOptions);
+    connect(): Promise<void>;
+    private processLine;
+    private scheduleReconnect;
+    close(): void;
+}
+export declare function createSSEClient(url: string, options?: SSEClientOptions): SSEClient;
+//# sourceMappingURL=sse.d.ts.map

package/dist/client/sse.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSEClient = exports.SSEClient = void 0;
+const http = require("http");
+const https = require("https");
+const events_1 = require("events");
+class SSEClient extends events_1.EventEmitter {
+    constructor(url, options = {}) {
+        super();
+        this.url = url;
+        this.options = options;
+        this.reconnectAttempts = 0;
+        this.shouldReconnect = true;
+        this.options = {
+            timeout: 30000,
+            reconnectInterval: 3000,
+            maxReconnectAttempts: 5,
+            ...options,
+        };
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new URL(this.url);
+            const isSecure = parsedUrl.protocol === 'https:';
+            const httpModule = isSecure ? https : http;
+            const requestOptions = {
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: 'GET',
+                headers: {
+                    Accept: 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    ...this.options.headers,
+                },
+            };
+            this.request = httpModule.request(requestOptions, response => {
+                if (response.statusCode !== 200) {
+                    reject(new Error(`SSE connection failed with status: ${response.statusCode}`));
+                    return;
+                }
+                this.reconnectAttempts = 0;
+                this.emit('connected');
+                resolve();
+                response.setEncoding('utf8');
+                let buffer = '';
+                response.on('data', (chunk) => {
+                    buffer += chunk;
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        this.processLine(line);
+                    }
+                });
+                response.on('end', () => {
+                    this.emit('disconnected');
+                    if (this.shouldReconnect &&
+                        this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) {
+                        this.scheduleReconnect();
+                    }
+                });
+                response.on('error', error => {
+                    this.emit('error', error);
+                });
+            });
+            this.request.on('error', error => {
+                reject(error);
+                if (this.shouldReconnect &&
+                    this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) {
+                    this.scheduleReconnect();
+                }
+            });
+            this.request.on('timeout', () => {
+                this.request?.destroy();
+                reject(new Error('SSE connection timeout'));
+            });
+            if (this.options.timeout) {
+                this.request.setTimeout(this.options.timeout);
+            }
+            this.request.end();
+        });
+    }
+    processLine(line) {
+        if (line.trim() === '') {
+            return;
+        }
+        if (line.startsWith('data: ')) {
+            const data = line.substring(6);
+            try {
+                const parsed = JSON.parse(data);
+                this.emit('message', parsed);
+            }
+            catch {
+                this.emit('message', data);
+            }
+        }
+        else if (line.startsWith('event: ')) {
+            const eventType = line.substring(7);
+            this.emit('event', eventType);
+        }
+        else if (line.startsWith('id: ')) {
+            const id = line.substring(4);
+            this.emit('id', id);
+        }
+        else if (line.startsWith('retry: ')) {
+            const retry = parseInt(line.substring(7), 10);
+            if (!isNaN(retry)) {
+                this.options.reconnectInterval = retry;
+            }
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch(error => {
+                this.emit('error', error);
+            });
+        }, this.options.reconnectInterval);
+    }
+    close() {
+        this.shouldReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        if (this.request) {
+            this.request.destroy();
+        }
+        this.emit('closed');
+    }
+}
+exports.SSEClient = SSEClient;
+function createSSEClient(url, options) {
+    return new SSEClient(url, options);
+}
+exports.createSSEClient = createSSEClient;
+//# sourceMappingURL=sse.js.map

package/dist/creator.d.ts

@@ -1,7 +1,7 @@
 import { IMidwayApplication, IMidwayFramework } from '@midwayjs/core';
-import { ComponentModule, MockAppConfigurationOptions, IBootstrapAppStarter, MockBootstrapOptions } from './interface';
-export declare function create<T extends IMidwayFramework<any, any, any, any, any>>(appDir: string | MockAppConfigurationOptions, options?: MockAppConfigurationOptions): Promise<T>;
-export declare function createApp<T extends IMidwayFramework<any, any, any, any, any>>(baseDir: string | MockAppConfigurationOptions, options?: MockAppConfigurationOptions): Promise<ReturnType<T['getApplication']>>;
+import { ComponentModule, IBootstrapAppStarter, MockBootstrapOptions } from './interface';
+export declare function create<T extends IMidwayFramework<any, any, any, any, any>>(appDir: string | MockBootstrapOptions, options?: MockBootstrapOptions): Promise<T>;
+export declare function createApp<T extends IMidwayFramework<any, any, any, any, any>>(baseDir: string | MockBootstrapOptions, options?: MockBootstrapOptions): Promise<ReturnType<T['getApplication']>>;
 export declare function close(app: IMidwayApplication<any> | {
     close: (...args: any[]) => void;
 }, options?: {
@@ -9,7 +9,7 @@ export declare function close(app: IMidwayApplication<any> | {
     cleanTempDir?: boolean;
     sleep?: number;
 }): Promise<void>;
-export declare function createFunctionApp<T extends IMidwayFramework<any, any, any, any, any>, Y = ReturnType<T['getApplication']>>(baseDir?: string | MockAppConfigurationOptions, options?: MockAppConfigurationOptions, customFrameworkModule?: {
+export declare function createFunctionApp<T extends IMidwayFramework<any, any, any, any, any>, Y = ReturnType<T['getApplication']>>(baseDir?: string | MockBootstrapOptions, options?: MockBootstrapOptions, customFrameworkModule?: {
     new (...args: any[]): T;
 } | ComponentModule): Promise<Y>;
 /**
@@ -17,6 +17,6 @@ export declare function createFunctionApp<T extends IMidwayFramework<any, any, a
  * @param baseDirOrOptions
  * @param options
  */
-export declare function createLightApp(baseDirOrOptions: string | MockAppConfigurationOptions, options?: MockAppConfigurationOptions): Promise<IMidwayApplication>;
+export declare function createLightApp(baseDirOrOptions: string | MockBootstrapOptions, options?: MockBootstrapOptions): Promise<IMidwayApplication>;
 export declare function createBootstrap(entryFile: string, options?: MockBootstrapOptions): Promise<IBootstrapAppStarter>;
 //# sourceMappingURL=creator.d.ts.map

package/dist/creator.js

@@ -9,6 +9,7 @@ const util_1 = require("util");
 const fs_1 = require("fs");
 const yaml = require("js-yaml");
 const getRawBody = require("raw-body");
+const functional_1 = require("@midwayjs/core/functional");
 const debug = (0, util_1.debuglog)('midway:debug');
 process.setMaxListeners(0);
 function formatPath(baseDir, p) {
@@ -23,7 +24,7 @@ function getFileNameWithSuffix(fileName) {
     return (0, core_1.isTypeScriptEnvironment)() ? `${fileName}.ts` : `${fileName}.js`;
 }
 function createMockWrapApplicationContext() {
-    const container = new core_1.MidwayContainer();
+    const container = new core_1.DynamicMidwayContainer();
     debug(`[mock]: Create mock MidwayContainer, id=${container.id}.`);
     const bindModuleMap = new WeakMap();
     container.onBeforeBind(target => {
@@ -155,12 +156,32 @@ async function create(appDir, options = {}) {
             };
             options.globalConfig = (0, utils_1.mergeGlobalConfig)(options.globalConfig, sslConfig);
         }
+        const anonymousConfiguration = (0, functional_1.defineConfiguration)({
+            namespace: 'anonymous',
+            async onReady(...args) {
+                return options.onReady?.(...args);
+            },
+            async onStop(...args) {
+                return options.onStop?.(...args);
+            },
+            async onConfigLoad(...args) {
+                return options.onConfigLoad?.(...args);
+            },
+            async onServerReady(...args) {
+                return options.onServerReady?.(...args);
+            },
+            async onHealthCheck(...args) {
+                return options.onHealthCheck?.(...args);
+            },
+        });
         const container = createMockWrapApplicationContext();
         options.applicationContext = container;
+        options.imports = options.imports || [];
+        options.imports.push(anonymousConfiguration);
         await (0, core_1.initializeGlobalApplicationContext)({
+            loggerFactory: logger_1.loggers,
             ...options,
             appDir,
-            loggerFactory: logger_1.loggers,
         });
         const frameworkService = await container.getAsync(core_1.MidwayFrameworkService);
         const mainFramework = frameworkService.getMainFramework();

package/dist/interface.d.ts

@@ -1,12 +1,13 @@
-import { IMidwayApplication, IMidwayBootstrapOptions } from '@midwayjs/core';
-export interface MockAppConfigurationOptions extends IMidwayBootstrapOptions {
+import { ILifeCycle, IMidwayApplication, IMidwayBootstrapOptions } from '@midwayjs/core';
+export interface MockBootstrapOptions extends IMidwayBootstrapOptions, ILifeCycle {
     cleanLogsDir?: boolean;
     cleanTempDir?: boolean;
     ssl?: boolean;
-}
-export interface MockBootstrapOptions extends MockAppConfigurationOptions {
+    bootstrapTimeout?: number;
+    starter?: any;
     entryFile?: string;
     bootstrapMode?: 'faas' | 'app';
+    initializeMethodName?: string;
 }
 export type ComponentModule = {
     Configuration: new () => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/mock",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-beta.2",
   "description": "create your test app from midway framework",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -25,11 +25,11 @@
     "function.js"
   ],
   "engines": {
-    "node": ">=12"
+    "node": ">=20"
   },
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/core": "^4.0.0-alpha.1",
+    "@midwayjs/core": "^4.0.0-beta.2",
     "@midwayjs/logger": "^3.0.0",
     "@types/amqplib": "0.10.6",
     "amqplib": "0.10.5",
@@ -50,5 +50,5 @@
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "14bb4da91805a1cf52f190c0d37a74b395dd6372"
+  "gitHead": "53bfef4c5279da5f09025e4610bdbf64f94f60bd"
 }