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

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.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) {
@@ -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,5 +1,5 @@
-import { IMidwayApplication, IMidwayBootstrapOptions } from '@midwayjs/core';
-export interface MockBootstrapOptions extends IMidwayBootstrapOptions {
+import { ILifeCycle, IMidwayApplication, IMidwayBootstrapOptions } from '@midwayjs/core';
+export interface MockBootstrapOptions extends IMidwayBootstrapOptions, ILifeCycle {
     cleanLogsDir?: boolean;
     cleanTempDir?: boolean;
     ssl?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/mock",
-  "version": "4.0.0-beta.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-beta.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": "832961ec3aff123c033197d8c00cb2bc9bad7ff8"
+  "gitHead": "53bfef4c5279da5f09025e4610bdbf64f94f60bd"
 }