@midwayjs/bootstrap 3.7.3 → 3.8.1-beta.1

package/dist/{bootstrap.d.ts → bootstrap/bootstrap.d.ts}

@@ -1,4 +1,5 @@
 import { IMidwayBootstrapOptions, IMidwayContainer } from '@midwayjs/core';
+import { IMidwayLogger } from '@midwayjs/logger';
 export declare function isTypeScriptEnvironment(): boolean;
 export declare class BootstrapStarter {
     protected appDir: string;
@@ -14,15 +15,15 @@ export declare class BootstrapStarter {
     protected getBaseDir(): string;
 }
 export declare class Bootstrap {
-    private static starter;
-    private static logger;
-    private static configured;
+    protected static starter: BootstrapStarter;
+    protected static logger: IMidwayLogger;
+    protected static configured: boolean;
     /**
      * set global configuration for midway
      * @param configuration
      */
     static configure(configuration?: IMidwayBootstrapOptions): typeof Bootstrap;
-    private static getStarter;
+    static getStarter(): BootstrapStarter;
     static run(): Promise<void>;
     static stop(): Promise<void>;
     static reset(): void;

package/dist/bootstrap/cluster.d.ts

@@ -0,0 +1,18 @@
+import { Bootstrap, BootstrapStarter } from './bootstrap';
+import { ClusterBootstrapOptions } from '../interface';
+export declare class ClusterBootstrapStarter extends BootstrapStarter {
+    protected globalOptions: ClusterBootstrapOptions;
+    private clusterManager;
+    init(): Promise<any>;
+    run(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare class ClusterBootstrap extends Bootstrap {
+    /**
+     * set global configuration for midway
+     * @param configuration
+     */
+    static configure(configuration?: ClusterBootstrapOptions): typeof Bootstrap;
+    static getStarter(): BootstrapStarter;
+}
+//# sourceMappingURL=cluster.d.ts.map

package/dist/bootstrap/cluster.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterBootstrap = exports.ClusterBootstrapStarter = void 0;
+const bootstrap_1 = require("./bootstrap");
+const cp_1 = require("../fork/cp");
+const path_1 = require("path");
+class ClusterBootstrapStarter extends bootstrap_1.BootstrapStarter {
+    constructor() {
+        super(...arguments);
+        this.globalOptions = {};
+    }
+    async init() {
+        return null;
+    }
+    async run() {
+        this.clusterManager = new cp_1.ClusterManager({
+            exec: (0, path_1.join)(__dirname, 'bootstrap'),
+            ...this.globalOptions,
+        });
+        await this.clusterManager.start();
+    }
+    async stop() {
+        await this.clusterManager.close();
+    }
+}
+exports.ClusterBootstrapStarter = ClusterBootstrapStarter;
+class ClusterBootstrap extends bootstrap_1.Bootstrap {
+    /**
+     * set global configuration for midway
+     * @param configuration
+     */
+    static configure(configuration = {}) {
+        return super.configure(configuration);
+    }
+    static getStarter() {
+        if (!this.starter) {
+            this.starter = new ClusterBootstrapStarter();
+        }
+        return this.starter;
+    }
+}
+exports.ClusterBootstrap = ClusterBootstrap;
+//# sourceMappingURL=cluster.js.map

package/dist/fork/base.d.ts

@@ -0,0 +1,42 @@
+import { ForkOptions } from '../interface';
+import type { IEventBus } from '@midwayjs/event-bus';
+export declare abstract class AbstractForkManager<T, ClusterOptions extends ForkOptions> {
+    readonly options: ClusterOptions;
+    private reforks;
+    private disconnectCount;
+    private unexpectedCount;
+    private disconnects;
+    private hub;
+    protected workers: Set<T>;
+    protected eventBus: IEventBus<T>;
+    private isClosing;
+    protected constructor(options: ClusterOptions);
+    start(): Promise<void>;
+    protected tryToRefork(oldWorker: T): void;
+    /**
+     * allow refork
+     */
+    protected allowRefork(): boolean;
+    /**
+     * uncaughtException default handler
+     */
+    protected onerror(err: any): void;
+    /**
+     * unexpectedExit default handler
+     */
+    protected onUnexpected(worker: T, code: any, signal: any): void;
+    /**
+     * reachReforkLimit default handler
+     */
+    protected onReachReforkLimit(): void;
+    protected killWorker(worker: any, timeout: any): Promise<void>;
+    close(timeout?: number): Promise<void>;
+    abstract createWorker(oldWorker?: T): T;
+    abstract bindWorkerDisconnect(listener: (worker: T) => void): void;
+    abstract bindWorkerExit(listener: (worker: T, code: any, signal: any) => void): void;
+    abstract getWorkerId(worker: T): string;
+    abstract isWorkerDead(worker: T): boolean;
+    abstract closeWorker(worker: T): any;
+    abstract createEventBus(): IEventBus<T>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/fork/base.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractForkManager = void 0;
+const os = require("os");
+const util = require("util");
+const util_1 = require("../util");
+const events_1 = require("events");
+const util_2 = require("util");
+const debug = (0, util_2.debuglog)('midway:bootstrap');
+class AbstractForkManager {
+    constructor(options) {
+        this.options = options;
+        this.reforks = [];
+        this.disconnectCount = 0;
+        this.unexpectedCount = 0;
+        this.disconnects = {};
+        this.hub = new events_1.EventEmitter();
+        this.workers = new Set();
+        this.isClosing = false;
+        options.count = options.count || os.cpus().length - 1;
+        options.refork = options.refork !== false;
+        options.limit = options.limit || 60;
+        options.duration = options.duration || 60000; // 1 min
+        options.logger = options.logger || console;
+        this.eventBus = this.createEventBus();
+    }
+    async start() {
+        this.bindWorkerDisconnect(worker => {
+            debug(' - worker(%s): trigger event = disconnect', this.getWorkerId(worker));
+            const log = this.options.logger[worker['disableRefork'] ? 'info' : 'error'];
+            this.disconnectCount++;
+            const isDead = this.isWorkerDead(worker);
+            if (isDead) {
+                debug(' - worker(%s): worker is dead', this.getWorkerId(worker));
+                // worker has terminated before disconnect
+                this.options.logger.info("[%s] [bootstrap:master:%s] don't fork, because worker:%s exit event emit before disconnect", (0, util_1.logDate)(), process.pid, this.getWorkerId(worker));
+                return;
+            }
+            if (worker['disableRefork']) {
+                debug(' - worker(%s): worker is disableRefork(maybe terminated by master)', this.getWorkerId(worker));
+                // worker has terminated by master
+                log("[%s] [bootstrap:master:%s] don't fork, because worker:%s will be kill soon", (0, util_1.logDate)(), process.pid, this.getWorkerId(worker));
+                return;
+            }
+            this.disconnects[this.getWorkerId(worker)] = (0, util_1.logDate)();
+            this.tryToRefork(worker);
+        });
+        this.bindWorkerExit((worker, code, signal) => {
+            debug(' - worker(%s): trigger event = exit', this.getWorkerId(worker));
+            // remove worker
+            // this.workers.delete(worker);
+            if (worker['disableRefork']) {
+                return;
+            }
+            const isExpected = !!this.disconnects[this.getWorkerId(worker)];
+            debug(' - worker(%s): isExpected=%s', this.getWorkerId(worker), isExpected);
+            if (isExpected) {
+                delete this.disconnects[this.getWorkerId(worker)];
+                // worker disconnect first, exit expected
+                return;
+            }
+            debug(' - worker(%s): isWorkerDead=%s', this.getWorkerId(worker), this.isWorkerDead(worker));
+            if (this.isWorkerDead(worker)) {
+                return;
+            }
+            debug(' - worker(%s): unexpectedCount will add');
+            this.unexpectedCount++;
+            this.tryToRefork(worker);
+            this.onUnexpected(worker, code, signal);
+        });
+        this.hub.on('reachReforkLimit', this.onReachReforkLimit.bind(this));
+        // defer to set the listeners
+        // so you can listen this by your own
+        setImmediate(() => {
+            if (process.listeners('uncaughtException').length === 0) {
+                process.on('uncaughtException', this.onerror.bind(this));
+            }
+        });
+        for (let i = 0; i < this.options.count; i++) {
+            const w = this.createWorker();
+            debug(' - worker(%s) created', this.getWorkerId(w));
+            this.workers.add(w);
+        }
+        await this.eventBus.start();
+    }
+    tryToRefork(oldWorker) {
+        if (this.allowRefork()) {
+            debug(' - worker(%s): allow refork and will fork new', this.getWorkerId(oldWorker));
+            const newWorker = this.createWorker(oldWorker);
+            this.workers.add(newWorker);
+            debug('----after create', newWorker.process.pid);
+            this.options.logger.info('[%s] [bootstrap:master:%s] new worker:%s fork (state: %s)', (0, util_1.logDate)(), process.pid, this.getWorkerId(newWorker), newWorker['state']);
+            this.eventBus.addWorker(newWorker);
+        }
+        else {
+            debug(' - worker(%s): forbidden refork and will stop', this.getWorkerId(oldWorker));
+            this.options.logger.info("[%s] [bootstrap:master:%s] don't fork new work (refork: %s)", (0, util_1.logDate)(), process.pid, this.options.refork);
+        }
+    }
+    /**
+     * allow refork
+     */
+    allowRefork() {
+        if (!this.options.refork || this.isClosing) {
+            return false;
+        }
+        const times = this.reforks.push(Date.now());
+        if (times > this.options.limit) {
+            this.reforks.shift();
+        }
+        const span = this.reforks[this.reforks.length - 1] - this.reforks[0];
+        const canFork = this.reforks.length < this.options.limit || span > this.options.duration;
+        if (!canFork) {
+            this.hub.emit('reachReforkLimit');
+        }
+        return canFork;
+    }
+    /**
+     * uncaughtException default handler
+     */
+    onerror(err) {
+        if (!err) {
+            return;
+        }
+        this.options.logger.error('[%s] [bootstrap:master:%s] master uncaughtException: %s', (0, util_1.logDate)(), process.pid, err.stack);
+        this.options.logger.error(err);
+        this.options.logger.error('(total %d disconnect, %d unexpected exit)', this.disconnectCount, this.unexpectedCount);
+    }
+    /**
+     * unexpectedExit default handler
+     */
+    onUnexpected(worker, code, signal) {
+        // eslint-disable-next-line no-prototype-builtins
+        const propertyName = worker.hasOwnProperty('exitedAfterDisconnect')
+            ? 'exitedAfterDisconnect'
+            : 'suicide';
+        const err = new Error(util.format('worker:%s died unexpected (code: %s, signal: %s, %s: %s, state: %s)', this.getWorkerId(worker), code, signal, propertyName, worker[propertyName], worker['state']));
+        err.name = 'WorkerDiedUnexpectedError';
+        this.options.logger.error('[%s] [bootstrap:master:%s] (total %d disconnect, %d unexpected exit) %s', (0, util_1.logDate)(), process.pid, this.disconnectCount, this.unexpectedCount, err.stack);
+    }
+    /**
+     * reachReforkLimit default handler
+     */
+    onReachReforkLimit() {
+        this.options.logger.error('[%s] [bootstrap:master:%s] worker died too fast (total %d disconnect, %d unexpected exit)', (0, util_1.logDate)(), process.pid, this.disconnectCount, this.unexpectedCount);
+    }
+    async killWorker(worker, timeout) {
+        // kill process, if SIGTERM not work, try SIGKILL
+        await this.closeWorker(worker);
+        await Promise.race([(0, events_1.once)(worker, 'exit'), (0, util_1.sleep)(timeout)]);
+        if (worker.killed)
+            return;
+        // SIGKILL: http://man7.org/linux/man-pages/man7/signal.7.html
+        // worker: https://github.com/nodejs/node/blob/master/lib/internal/cluster/worker.js#L22
+        // subProcess.kill is wrapped to subProcess.destroy, it will wait to disconnected.
+        (worker.process || worker).kill('SIGKILL');
+    }
+    async close(timeout = 2000) {
+        debug('run close');
+        this.isClosing = true;
+        await this.eventBus.stop();
+        for (const worker of this.workers) {
+            worker['disableRefork'] = true;
+            await this.killWorker(worker, timeout);
+        }
+    }
+}
+exports.AbstractForkManager = AbstractForkManager;
+//# sourceMappingURL=base.js.map

package/dist/fork/cp.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Worker } from 'cluster';
+import { ClusterOptions } from '../interface';
+import { AbstractForkManager } from './base';
+export declare class ClusterManager extends AbstractForkManager<Worker, ClusterOptions> {
+    readonly options: ClusterOptions;
+    constructor(options?: ClusterOptions);
+    createWorker(): any;
+    bindWorkerDisconnect(listener: (worker: Worker) => void): void;
+    bindWorkerExit(listener: (worker: Worker, code: any, signal: any) => void): void;
+    getWorkerId(worker: Worker): string;
+    isWorkerDead(worker: Worker): boolean;
+    closeWorker(worker: Worker): void;
+    createEventBus(): any;
+}
+//# sourceMappingURL=cp.d.ts.map

package/dist/fork/cp.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterManager = void 0;
+const cp_1 = require("@midwayjs/event-bus/dist/cp");
+const base_1 = require("./base");
+const path_1 = require("path");
+const cluster = require('cluster');
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:bootstrap');
+class ClusterManager extends base_1.AbstractForkManager {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        options.args = options.args || [];
+        options.execArgv = options.execArgv || [];
+        if ((0, path_1.extname)(this.options.exec) === '.ts') {
+            options.execArgv.push(...['--require', 'ts-node/register']);
+        }
+        debug('Init cluster manager with options: %j', options);
+    }
+    createWorker() {
+        if (cluster['setupPrimary']) {
+            cluster['setupPrimary'](this.options);
+        }
+        else if (cluster['setupMaster']) {
+            cluster['setupMaster'](this.options);
+        }
+        console.log('----cluster=', process.pid);
+        return cluster.fork();
+    }
+    bindWorkerDisconnect(listener) {
+        debug('Bind cluster.disconnect event');
+        cluster.on('disconnect', listener);
+    }
+    bindWorkerExit(listener) {
+        debug('Bind cluster.exit event');
+        cluster.on('exit', listener);
+    }
+    getWorkerId(worker) {
+        return String(worker.process.pid);
+    }
+    isWorkerDead(worker) {
+        return worker.isDead();
+    }
+    closeWorker(worker) {
+        worker.kill('SIGTERM');
+    }
+    createEventBus() {
+        return new cp_1.ChildProcessEventBus();
+    }
+}
+exports.ClusterManager = ClusterManager;
+//# sourceMappingURL=cp.js.map

package/dist/fork/thread.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { ThreadOptions } from '../interface';
+import { AbstractForkManager } from './base';
+import type { Worker as ThreadWorker } from 'worker_threads';
+export declare class ThreadManager extends AbstractForkManager<ThreadWorker, ThreadOptions> {
+    readonly options: ThreadOptions;
+    private exitListener;
+    constructor(options?: ThreadOptions);
+    createWorker(): ThreadWorker;
+    bindWorkerDisconnect(listener: (worker: ThreadWorker) => void): void;
+    bindWorkerExit(listener: (worker: ThreadWorker, code: any, signal: any) => void): void;
+    getWorkerId(worker: ThreadWorker): any;
+    isWorkerDead(worker: ThreadWorker): boolean;
+    closeWorker(worker: ThreadWorker): Promise<void>;
+    createEventBus(): any;
+}
+//# sourceMappingURL=thread.d.ts.map

package/dist/fork/thread.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadManager = void 0;
+const path_1 = require("path");
+const base_1 = require("./base");
+let threads = null;
+let shareEnv = null;
+let Worker = null;
+let ThreadEventBus = null;
+try {
+    // eslint-disable-next-line node/no-unsupported-features/node-builtins
+    threads = require('worker_threads');
+    shareEnv = threads.SHARE_ENV;
+    Worker = threads.Worker;
+    ThreadEventBus = require('@midwayjs/event-bus').ThreadEventBus;
+}
+catch (e) {
+    // ignore not support worker_threads
+}
+class ThreadManager extends base_1.AbstractForkManager {
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        options.argv = options.argv || [];
+        options.execArgv = options.execArgv || [];
+    }
+    createWorker() {
+        let w;
+        let content = `
+    require(${JSON.stringify(this.options.exec)});
+  `;
+        // 当前是 ts 环境
+        if ((0, path_1.extname)(this.options.exec) === '.ts') {
+            content = `
+    require("ts-node/register/transpile-only");
+    ${content}
+    `;
+            w = new Worker(content, { eval: true, env: shareEnv });
+            w['_originThreadId'] = String(w.threadId);
+            this.options.logger.info('new worker thread with ts-node, threadId = %s.', this.getWorkerId(w));
+        }
+        else {
+            w = new Worker(content, { eval: true, env: shareEnv });
+            this.options.logger.info('new worker thread, threadId = %s.', this.getWorkerId(w));
+        }
+        w.on('exit', code => {
+            this.exitListener(w, code);
+        });
+        return w;
+    }
+    bindWorkerDisconnect(listener) {
+        // this.disconnectListener = listener;
+    }
+    bindWorkerExit(listener) {
+        this.exitListener = listener;
+    }
+    getWorkerId(worker) {
+        return worker['_originThreadId'] || String(worker.threadId);
+    }
+    isWorkerDead(worker) {
+        return false;
+    }
+    async closeWorker(worker) {
+        await worker.terminate();
+    }
+    createEventBus() {
+        return new ThreadEventBus();
+    }
+}
+exports.ThreadManager = ThreadManager;
+//# sourceMappingURL=thread.js.map

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export { isTypeScriptEnvironment, Bootstrap, BootstrapStarter, } from './bootstrap';
+export * from './interface';
+export { isTypeScriptEnvironment, Bootstrap, BootstrapStarter, } from './bootstrap/bootstrap';
+export { ClusterBootstrap, ClusterBootstrapStarter } from './bootstrap/cluster';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,26 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BootstrapStarter = exports.Bootstrap = exports.isTypeScriptEnvironment = void 0;
-var bootstrap_1 = require("./bootstrap");
+exports.ClusterBootstrapStarter = exports.ClusterBootstrap = exports.BootstrapStarter = exports.Bootstrap = exports.isTypeScriptEnvironment = void 0;
+__exportStar(require("./interface"), exports);
+var bootstrap_1 = require("./bootstrap/bootstrap");
 Object.defineProperty(exports, "isTypeScriptEnvironment", { enumerable: true, get: function () { return bootstrap_1.isTypeScriptEnvironment; } });
 Object.defineProperty(exports, "Bootstrap", { enumerable: true, get: function () { return bootstrap_1.Bootstrap; } });
 Object.defineProperty(exports, "BootstrapStarter", { enumerable: true, get: function () { return bootstrap_1.BootstrapStarter; } });
+var cluster_1 = require("./bootstrap/cluster");
+Object.defineProperty(exports, "ClusterBootstrap", { enumerable: true, get: function () { return cluster_1.ClusterBootstrap; } });
+Object.defineProperty(exports, "ClusterBootstrapStarter", { enumerable: true, get: function () { return cluster_1.ClusterBootstrapStarter; } });
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IMidwayBootstrapOptions } from '@midwayjs/core';
+import type { IMidwayLogger } from '@midwayjs/logger';
+import { ClusterSettings } from 'cluster';
+import { WorkerOptions } from 'worker_threads';
+export interface ForkOptions {
+    exec?: string;
+    /**
+     * worker num, default is `os.cpus().length`
+     */
+    count?: number;
+    /**
+     * refork when disconect and unexpected exit, default is `true`
+     */
+    refork?: boolean;
+    /**
+     * restart limit, default is `60`
+     */
+    limit?: number;
+    duration?: number;
+    logger?: IMidwayLogger | Console;
+}
+export declare type ClusterOptions = ForkOptions & ClusterSettings;
+export declare type ThreadOptions = ForkOptions & WorkerOptions;
+export declare type ClusterBootstrapOptions = IMidwayBootstrapOptions & ClusterOptions;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/util.d.ts

@@ -0,0 +1,3 @@
+export declare function logDate(): string;
+export declare function sleep(timeout: any): Promise<unknown>;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.logDate = void 0;
+function logDate() {
+    const d = new Date();
+    let date = d.getDate();
+    if (date < 10) {
+        date = '0' + date;
+    }
+    let month = d.getMonth() + 1;
+    if (month < 10) {
+        month = '0' + month;
+    }
+    let hours = d.getHours();
+    if (hours < 10) {
+        hours = '0' + hours;
+    }
+    let mintues = d.getMinutes();
+    if (mintues < 10) {
+        mintues = '0' + mintues;
+    }
+    let seconds = d.getSeconds();
+    if (seconds < 10) {
+        seconds = '0' + seconds;
+    }
+    let milliseconds = d.getMilliseconds();
+    if (milliseconds < 10) {
+        milliseconds = '00' + milliseconds;
+    }
+    else if (milliseconds < 100) {
+        milliseconds = '0' + milliseconds;
+    }
+    return d.getFullYear() + '-' + month + '-' + date + ' ' +
+        hours + ':' + mintues + ':' + seconds + ('.') + milliseconds;
+}
+exports.logDate = logDate;
+async function sleep(timeout) {
+    return new Promise(resolve => {
+        setTimeout(resolve, timeout);
+    });
+}
+exports.sleep = sleep;
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/bootstrap",
-  "version": "3.7.3",
+  "version": "3.8.1-beta.1",
   "description": "midwayjs bootstrap",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,23 +21,24 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@midwayjs/async-hooks-context-manager": "^3.7.0"
+    "@midwayjs/async-hooks-context-manager": "^3.8.0",
+    "@midwayjs/event-bus": "0.0.1"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.7.0",
+    "@midwayjs/core": "^3.8.0",
     "@midwayjs/logger": "^2.15.0",
-    "@midwayjs/socketio": "^3.7.3",
-    "@midwayjs/web": "^3.7.3",
+    "@midwayjs/socketio": "^3.8.0",
+    "@midwayjs/web": "^3.8.0",
     "request": "2.88.2",
     "socket.io-client": "4.5.3"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
   "repository": {
     "type": "git",
-    "url": "http://github.com/midwayjs/midway.git"
+    "url": "https://github.com/midwayjs/midway.git"
   },
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "8e6c830bca52818e0086873b542423d16e609aef"
+  "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.