@eggjs/tegg-eventbus-runtime 4.0.0-beta.6 → 4.0.0-beta.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +59 -3
- package/dist/index.js +186 -3
- package/package.json +8 -8
- package/dist/EventContextFactory.d.ts +0 -11
- package/dist/EventContextFactory.js +0 -18
- package/dist/EventHandlerFactory.d.ts +0 -15
- package/dist/EventHandlerFactory.js +0 -40
- package/dist/SingletonEventBus.d.ts +0 -41
- package/dist/SingletonEventBus.js +0 -131
- package/dist/_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js +0 -10
- package/dist/_virtual/_@oxc-project_runtime@0.93.0/helpers/decorateMetadata.js +0 -7
package/dist/index.d.ts
CHANGED
|
@@ -1,4 +1,60 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
|
|
1
|
+
import { Arguments, EventBus, EventHandler, EventName, EventWaiter, Events } from "@eggjs/eventbus-decorator";
|
|
2
|
+
import { EggPrototype, EggRuntimeContext } from "@eggjs/tegg-types";
|
|
3
|
+
|
|
4
|
+
//#region src/SingletonEventBus.d.ts
|
|
5
|
+
interface Event {
|
|
6
|
+
name: EventName;
|
|
7
|
+
args: Array<any>;
|
|
8
|
+
context?: EggRuntimeContext;
|
|
9
|
+
}
|
|
10
|
+
interface CorkEvents {
|
|
11
|
+
times: number;
|
|
12
|
+
events: Array<Event>;
|
|
13
|
+
}
|
|
14
|
+
declare class SingletonEventBus implements EventBus, EventWaiter {
|
|
15
|
+
private readonly emitter;
|
|
16
|
+
private readonly eventContextFactory;
|
|
17
|
+
private readonly eventHandlerFactory;
|
|
18
|
+
private readonly logger;
|
|
19
|
+
private corkIdSequence;
|
|
20
|
+
private readonly corkedEvents;
|
|
21
|
+
/**
|
|
22
|
+
* only use for ensure event will happen
|
|
23
|
+
*/
|
|
24
|
+
once<E extends keyof Events>(event: E, listener: Events[E]): this;
|
|
25
|
+
await<E extends keyof Events>(event: E): Promise<Arguments<Events[E]>>;
|
|
26
|
+
awaitFirst<E extends keyof Events>(...e: Array<E>): Promise<{
|
|
27
|
+
event: EventName;
|
|
28
|
+
args: Arguments<Events[E]>;
|
|
29
|
+
}>;
|
|
30
|
+
emit<E extends keyof Events>(event: E, ...args: Arguments<Events[E]>): boolean;
|
|
31
|
+
generateCorkId(): string;
|
|
32
|
+
cork(corkId: string): void;
|
|
33
|
+
uncork(corkId: string): boolean;
|
|
34
|
+
queueEvent(corkId: string, event: Event): void;
|
|
35
|
+
emitWithContext<E extends keyof Events>(parentContext: EggRuntimeContext, event: E, args: Arguments<Events[E]>): boolean;
|
|
36
|
+
private doEmitWithContext;
|
|
37
|
+
private doOnceEmit;
|
|
38
|
+
private doEmit;
|
|
39
|
+
}
|
|
40
|
+
//#endregion
|
|
41
|
+
//#region src/EventHandlerFactory.d.ts
|
|
42
|
+
declare class EventHandlerFactory {
|
|
43
|
+
private handlerProtoMap;
|
|
44
|
+
registerHandler(event: EventName, proto: EggPrototype): void;
|
|
45
|
+
hasListeners(event: EventName): boolean;
|
|
46
|
+
getHandlerProtos(event: EventName): Array<EggPrototype>;
|
|
47
|
+
getHandler(proto: EggPrototype): Promise<EventHandler<keyof Events>>;
|
|
48
|
+
getHandlers(event: EventName): Promise<Array<EventHandler<keyof Events>>>;
|
|
49
|
+
handle(eventName: EventName, proto: EggPrototype, args: Arguments<any>): Promise<void>;
|
|
50
|
+
}
|
|
51
|
+
//#endregion
|
|
52
|
+
//#region src/EventContextFactory.d.ts
|
|
53
|
+
type ContextCreator = (parentContext?: EggRuntimeContext) => EggRuntimeContext;
|
|
54
|
+
declare class EventContextFactory {
|
|
55
|
+
private creator;
|
|
56
|
+
createContext(parentContext?: EggRuntimeContext): EggRuntimeContext;
|
|
57
|
+
registerContextCreator(creator: ContextCreator): void;
|
|
58
|
+
}
|
|
59
|
+
//#endregion
|
|
4
60
|
export { ContextCreator, CorkEvents, Event, EventContextFactory, EventHandlerFactory, SingletonEventBus };
|
package/dist/index.js
CHANGED
|
@@ -1,5 +1,188 @@
|
|
|
1
|
-
import
|
|
2
|
-
import {
|
|
3
|
-
import {
|
|
1
|
+
import EventEmitter from "node:events";
|
|
2
|
+
import { Inject, SingletonProto } from "@eggjs/core-decorator";
|
|
3
|
+
import { CORK_ID, EVENT_CONTEXT_INJECT } from "@eggjs/eventbus-decorator";
|
|
4
|
+
import { ContextHandler, EggContainerFactory } from "@eggjs/tegg-runtime";
|
|
5
|
+
import { AccessLevel } from "@eggjs/tegg-types";
|
|
6
|
+
import awaitEvent from "await-event";
|
|
7
|
+
import awaitFirst from "await-first";
|
|
8
|
+
import { MapUtil } from "@eggjs/tegg-common-util";
|
|
4
9
|
|
|
10
|
+
//#region \0@oxc-project+runtime@0.93.0/helpers/decorate.js
|
|
11
|
+
function __decorate(decorators, target, key, desc) {
|
|
12
|
+
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
13
|
+
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
14
|
+
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
15
|
+
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
//#endregion
|
|
19
|
+
//#region src/EventContextFactory.ts
|
|
20
|
+
let EventContextFactory = class EventContextFactory$1 {
|
|
21
|
+
creator;
|
|
22
|
+
createContext(parentContext) {
|
|
23
|
+
return this.creator(parentContext);
|
|
24
|
+
}
|
|
25
|
+
registerContextCreator(creator) {
|
|
26
|
+
this.creator = creator;
|
|
27
|
+
}
|
|
28
|
+
};
|
|
29
|
+
EventContextFactory = __decorate([SingletonProto({ accessLevel: AccessLevel.PUBLIC })], EventContextFactory);
|
|
30
|
+
|
|
31
|
+
//#endregion
|
|
32
|
+
//#region src/EventHandlerFactory.ts
|
|
33
|
+
let EventHandlerFactory = class EventHandlerFactory$1 {
|
|
34
|
+
handlerProtoMap = /* @__PURE__ */ new Map();
|
|
35
|
+
registerHandler(event, proto) {
|
|
36
|
+
MapUtil.getOrStore(this.handlerProtoMap, event, []).push(proto);
|
|
37
|
+
}
|
|
38
|
+
hasListeners(event) {
|
|
39
|
+
return this.handlerProtoMap.has(event);
|
|
40
|
+
}
|
|
41
|
+
getHandlerProtos(event) {
|
|
42
|
+
return this.handlerProtoMap.get(event) || [];
|
|
43
|
+
}
|
|
44
|
+
async getHandler(proto) {
|
|
45
|
+
return (await EggContainerFactory.getOrCreateEggObject(proto, proto.name)).obj;
|
|
46
|
+
}
|
|
47
|
+
async getHandlers(event) {
|
|
48
|
+
const handlerProtos = this.getHandlerProtos(event);
|
|
49
|
+
return await Promise.all(handlerProtos.map((proto) => {
|
|
50
|
+
return this.getHandler(proto);
|
|
51
|
+
}));
|
|
52
|
+
}
|
|
53
|
+
async handle(eventName, proto, args) {
|
|
54
|
+
const handler = await this.getHandler(proto);
|
|
55
|
+
if (proto.getMetaData(EVENT_CONTEXT_INJECT) ?? false) {
|
|
56
|
+
const ctx = { eventName };
|
|
57
|
+
await Reflect.apply(handler.handle, handler, [ctx, ...args]);
|
|
58
|
+
} else await Reflect.apply(handler.handle, handler, args);
|
|
59
|
+
}
|
|
60
|
+
};
|
|
61
|
+
EventHandlerFactory = __decorate([SingletonProto({ accessLevel: AccessLevel.PUBLIC })], EventHandlerFactory);
|
|
62
|
+
|
|
63
|
+
//#endregion
|
|
64
|
+
//#region \0@oxc-project+runtime@0.93.0/helpers/decorateMetadata.js
|
|
65
|
+
function __decorateMetadata(k, v) {
|
|
66
|
+
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
//#endregion
|
|
70
|
+
//#region src/SingletonEventBus.ts
|
|
71
|
+
var _ref, _ref2;
|
|
72
|
+
let SingletonEventBus = class SingletonEventBus$1 {
|
|
73
|
+
emitter = new EventEmitter();
|
|
74
|
+
eventContextFactory;
|
|
75
|
+
eventHandlerFactory;
|
|
76
|
+
logger;
|
|
77
|
+
corkIdSequence = 0;
|
|
78
|
+
corkedEvents = /* @__PURE__ */ new Map();
|
|
79
|
+
/**
|
|
80
|
+
* only use for ensure event will happen
|
|
81
|
+
*/
|
|
82
|
+
once(event, listener) {
|
|
83
|
+
this.emitter.once(event, listener);
|
|
84
|
+
return this;
|
|
85
|
+
}
|
|
86
|
+
async await(event) {
|
|
87
|
+
return awaitEvent(this.emitter, event);
|
|
88
|
+
}
|
|
89
|
+
awaitFirst(...e) {
|
|
90
|
+
return awaitFirst(this.emitter, e);
|
|
91
|
+
}
|
|
92
|
+
emit(event, ...args) {
|
|
93
|
+
const ctx = this.eventContextFactory.createContext();
|
|
94
|
+
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
95
|
+
this.doEmit(ctx, event, args);
|
|
96
|
+
return hasListener;
|
|
97
|
+
}
|
|
98
|
+
generateCorkId() {
|
|
99
|
+
return String(++this.corkIdSequence);
|
|
100
|
+
}
|
|
101
|
+
cork(corkId) {
|
|
102
|
+
let corkEvents = this.corkedEvents.get(corkId);
|
|
103
|
+
if (!corkEvents) {
|
|
104
|
+
corkEvents = {
|
|
105
|
+
times: 0,
|
|
106
|
+
events: []
|
|
107
|
+
};
|
|
108
|
+
this.corkedEvents.set(corkId, corkEvents);
|
|
109
|
+
}
|
|
110
|
+
corkEvents.times++;
|
|
111
|
+
}
|
|
112
|
+
uncork(corkId) {
|
|
113
|
+
const corkEvents = this.corkedEvents.get(corkId);
|
|
114
|
+
if (!corkEvents) throw new Error(`eventbus corkId ${corkId} not found`);
|
|
115
|
+
if (--corkEvents.times !== 0) return false;
|
|
116
|
+
this.corkedEvents.delete(corkId);
|
|
117
|
+
for (const event of corkEvents.events) if (event.context) this.doEmitWithContext(event.context, event.name, event.args);
|
|
118
|
+
return true;
|
|
119
|
+
}
|
|
120
|
+
queueEvent(corkId, event) {
|
|
121
|
+
const corkedEvents = this.corkedEvents.get(corkId);
|
|
122
|
+
if (!corkedEvents) throw new Error(`eventbus corkId ${corkId} not found`);
|
|
123
|
+
corkedEvents.events.push(event);
|
|
124
|
+
}
|
|
125
|
+
emitWithContext(parentContext, event, args) {
|
|
126
|
+
const corkId = parentContext.get(CORK_ID);
|
|
127
|
+
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
128
|
+
if (corkId) {
|
|
129
|
+
this.queueEvent(corkId, {
|
|
130
|
+
name: event,
|
|
131
|
+
args,
|
|
132
|
+
context: parentContext
|
|
133
|
+
});
|
|
134
|
+
return hasListener;
|
|
135
|
+
}
|
|
136
|
+
return this.doEmitWithContext(parentContext, event, args);
|
|
137
|
+
}
|
|
138
|
+
doEmitWithContext(parentContext, event, args) {
|
|
139
|
+
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
140
|
+
const ctx = this.eventContextFactory.createContext(parentContext);
|
|
141
|
+
this.doEmit(ctx, event, args);
|
|
142
|
+
return hasListener;
|
|
143
|
+
}
|
|
144
|
+
doOnceEmit(event, args) {
|
|
145
|
+
try {
|
|
146
|
+
this.emitter.emit(event, ...args);
|
|
147
|
+
} catch (e) {
|
|
148
|
+
e.message = `[EventBus] process once event ${String(event)} failed: ${e.message}`;
|
|
149
|
+
this.logger.error(e);
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
async doEmit(ctx, event, args) {
|
|
153
|
+
await ContextHandler.run(ctx, async () => {
|
|
154
|
+
const lifecycle = {};
|
|
155
|
+
if (ctx.init) await ctx.init(lifecycle);
|
|
156
|
+
try {
|
|
157
|
+
const handlerProtos = this.eventHandlerFactory.getHandlerProtos(event);
|
|
158
|
+
await Promise.all(handlerProtos.map(async (proto) => {
|
|
159
|
+
try {
|
|
160
|
+
await this.eventHandlerFactory.handle(event, proto, args);
|
|
161
|
+
} catch (e) {
|
|
162
|
+
e.message = `[EventBus] process event ${String(event)} for handler ${String(proto.name)} failed: ${e.message}`;
|
|
163
|
+
this.logger.error(e);
|
|
164
|
+
}
|
|
165
|
+
}));
|
|
166
|
+
} catch (e) {
|
|
167
|
+
e.message = `[EventBus] process event ${String(event)} failed: ${e.message}`;
|
|
168
|
+
this.logger.error(e);
|
|
169
|
+
} finally {
|
|
170
|
+
if (ctx.destroy) ctx.destroy(lifecycle).catch((e) => {
|
|
171
|
+
e.message = "[tegg/SingletonEventBus] destroy tegg ctx failed:" + e.message;
|
|
172
|
+
this.logger.error(e);
|
|
173
|
+
});
|
|
174
|
+
}
|
|
175
|
+
this.doOnceEmit(event, args);
|
|
176
|
+
});
|
|
177
|
+
}
|
|
178
|
+
};
|
|
179
|
+
__decorate([Inject(), __decorateMetadata("design:type", typeof (_ref = typeof EventContextFactory !== "undefined" && EventContextFactory) === "function" ? _ref : Object)], SingletonEventBus.prototype, "eventContextFactory", void 0);
|
|
180
|
+
__decorate([Inject(), __decorateMetadata("design:type", typeof (_ref2 = typeof EventHandlerFactory !== "undefined" && EventHandlerFactory) === "function" ? _ref2 : Object)], SingletonEventBus.prototype, "eventHandlerFactory", void 0);
|
|
181
|
+
__decorate([Inject({ name: "logger" }), __decorateMetadata("design:type", Object)], SingletonEventBus.prototype, "logger", void 0);
|
|
182
|
+
SingletonEventBus = __decorate([SingletonProto({
|
|
183
|
+
name: "eventBus",
|
|
184
|
+
accessLevel: AccessLevel.PUBLIC
|
|
185
|
+
})], SingletonEventBus);
|
|
186
|
+
|
|
187
|
+
//#endregion
|
|
5
188
|
export { EventContextFactory, EventHandlerFactory, SingletonEventBus };
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@eggjs/tegg-eventbus-runtime",
|
|
3
|
-
"version": "4.0.0-beta.
|
|
3
|
+
"version": "4.0.0-beta.8",
|
|
4
4
|
"description": "tegg eventbus runtime",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"egg",
|
|
@@ -34,11 +34,11 @@
|
|
|
34
34
|
"dependencies": {
|
|
35
35
|
"await-event": "^2.1.0",
|
|
36
36
|
"await-first": "^1.0.0",
|
|
37
|
-
"@eggjs/
|
|
38
|
-
"@eggjs/
|
|
39
|
-
"@eggjs/
|
|
40
|
-
"@eggjs/tegg-runtime": "4.0.0-beta.
|
|
41
|
-
"@eggjs/tegg-types": "4.0.0-beta.
|
|
37
|
+
"@eggjs/core-decorator": "4.0.0-beta.8",
|
|
38
|
+
"@eggjs/tegg-common-util": "4.0.0-beta.8",
|
|
39
|
+
"@eggjs/eventbus-decorator": "4.0.0-beta.8",
|
|
40
|
+
"@eggjs/tegg-runtime": "4.0.0-beta.8",
|
|
41
|
+
"@eggjs/tegg-types": "4.0.0-beta.8"
|
|
42
42
|
},
|
|
43
43
|
"engines": {
|
|
44
44
|
"node": ">=22.18.0"
|
|
@@ -51,8 +51,8 @@
|
|
|
51
51
|
"tsdown": "^0.15.6",
|
|
52
52
|
"unplugin-unused": "^0.5.3",
|
|
53
53
|
"@eggjs/module-test-util": "4.0.0-beta.4",
|
|
54
|
-
"@eggjs/tegg-
|
|
55
|
-
"@eggjs/tegg-
|
|
54
|
+
"@eggjs/tegg-metadata": "4.0.0-beta.8",
|
|
55
|
+
"@eggjs/tegg-loader": "4.0.0-beta.8"
|
|
56
56
|
},
|
|
57
57
|
"publishConfig": {
|
|
58
58
|
"access": "public"
|
|
@@ -1,11 +0,0 @@
|
|
|
1
|
-
import { EggRuntimeContext } from "@eggjs/tegg-types";
|
|
2
|
-
|
|
3
|
-
//#region src/EventContextFactory.d.ts
|
|
4
|
-
type ContextCreator = (parentContext?: EggRuntimeContext) => EggRuntimeContext;
|
|
5
|
-
declare class EventContextFactory {
|
|
6
|
-
private creator;
|
|
7
|
-
createContext(parentContext?: EggRuntimeContext): EggRuntimeContext;
|
|
8
|
-
registerContextCreator(creator: ContextCreator): void;
|
|
9
|
-
}
|
|
10
|
-
//#endregion
|
|
11
|
-
export { ContextCreator, EventContextFactory };
|
|
@@ -1,18 +0,0 @@
|
|
|
1
|
-
import { __decorate } from "./_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js";
|
|
2
|
-
import { SingletonProto } from "@eggjs/core-decorator";
|
|
3
|
-
import { AccessLevel } from "@eggjs/tegg-types";
|
|
4
|
-
|
|
5
|
-
//#region src/EventContextFactory.ts
|
|
6
|
-
let EventContextFactory = class EventContextFactory$1 {
|
|
7
|
-
creator;
|
|
8
|
-
createContext(parentContext) {
|
|
9
|
-
return this.creator(parentContext);
|
|
10
|
-
}
|
|
11
|
-
registerContextCreator(creator) {
|
|
12
|
-
this.creator = creator;
|
|
13
|
-
}
|
|
14
|
-
};
|
|
15
|
-
EventContextFactory = __decorate([SingletonProto({ accessLevel: AccessLevel.PUBLIC })], EventContextFactory);
|
|
16
|
-
|
|
17
|
-
//#endregion
|
|
18
|
-
export { EventContextFactory };
|
|
@@ -1,15 +0,0 @@
|
|
|
1
|
-
import { Arguments, EventHandler, EventName, Events } from "@eggjs/eventbus-decorator";
|
|
2
|
-
import { EggPrototype } from "@eggjs/tegg-types";
|
|
3
|
-
|
|
4
|
-
//#region src/EventHandlerFactory.d.ts
|
|
5
|
-
declare class EventHandlerFactory {
|
|
6
|
-
private handlerProtoMap;
|
|
7
|
-
registerHandler(event: EventName, proto: EggPrototype): void;
|
|
8
|
-
hasListeners(event: EventName): boolean;
|
|
9
|
-
getHandlerProtos(event: EventName): Array<EggPrototype>;
|
|
10
|
-
getHandler(proto: EggPrototype): Promise<EventHandler<keyof Events>>;
|
|
11
|
-
getHandlers(event: EventName): Promise<Array<EventHandler<keyof Events>>>;
|
|
12
|
-
handle(eventName: EventName, proto: EggPrototype, args: Arguments<any>): Promise<void>;
|
|
13
|
-
}
|
|
14
|
-
//#endregion
|
|
15
|
-
export { EventHandlerFactory };
|
|
@@ -1,40 +0,0 @@
|
|
|
1
|
-
import { __decorate } from "./_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js";
|
|
2
|
-
import { SingletonProto } from "@eggjs/core-decorator";
|
|
3
|
-
import { EVENT_CONTEXT_INJECT } from "@eggjs/eventbus-decorator";
|
|
4
|
-
import { EggContainerFactory } from "@eggjs/tegg-runtime";
|
|
5
|
-
import { AccessLevel } from "@eggjs/tegg-types";
|
|
6
|
-
import { MapUtil } from "@eggjs/tegg-common-util";
|
|
7
|
-
|
|
8
|
-
//#region src/EventHandlerFactory.ts
|
|
9
|
-
let EventHandlerFactory = class EventHandlerFactory$1 {
|
|
10
|
-
handlerProtoMap = /* @__PURE__ */ new Map();
|
|
11
|
-
registerHandler(event, proto) {
|
|
12
|
-
MapUtil.getOrStore(this.handlerProtoMap, event, []).push(proto);
|
|
13
|
-
}
|
|
14
|
-
hasListeners(event) {
|
|
15
|
-
return this.handlerProtoMap.has(event);
|
|
16
|
-
}
|
|
17
|
-
getHandlerProtos(event) {
|
|
18
|
-
return this.handlerProtoMap.get(event) || [];
|
|
19
|
-
}
|
|
20
|
-
async getHandler(proto) {
|
|
21
|
-
return (await EggContainerFactory.getOrCreateEggObject(proto, proto.name)).obj;
|
|
22
|
-
}
|
|
23
|
-
async getHandlers(event) {
|
|
24
|
-
const handlerProtos = this.getHandlerProtos(event);
|
|
25
|
-
return await Promise.all(handlerProtos.map((proto) => {
|
|
26
|
-
return this.getHandler(proto);
|
|
27
|
-
}));
|
|
28
|
-
}
|
|
29
|
-
async handle(eventName, proto, args) {
|
|
30
|
-
const handler = await this.getHandler(proto);
|
|
31
|
-
if (proto.getMetaData(EVENT_CONTEXT_INJECT) ?? false) {
|
|
32
|
-
const ctx = { eventName };
|
|
33
|
-
await Reflect.apply(handler.handle, handler, [ctx, ...args]);
|
|
34
|
-
} else await Reflect.apply(handler.handle, handler, args);
|
|
35
|
-
}
|
|
36
|
-
};
|
|
37
|
-
EventHandlerFactory = __decorate([SingletonProto({ accessLevel: AccessLevel.PUBLIC })], EventHandlerFactory);
|
|
38
|
-
|
|
39
|
-
//#endregion
|
|
40
|
-
export { EventHandlerFactory };
|
|
@@ -1,41 +0,0 @@
|
|
|
1
|
-
import { Arguments, EventBus, EventName, EventWaiter, Events } from "@eggjs/eventbus-decorator";
|
|
2
|
-
import { EggRuntimeContext } from "@eggjs/tegg-types";
|
|
3
|
-
|
|
4
|
-
//#region src/SingletonEventBus.d.ts
|
|
5
|
-
interface Event {
|
|
6
|
-
name: EventName;
|
|
7
|
-
args: Array<any>;
|
|
8
|
-
context?: EggRuntimeContext;
|
|
9
|
-
}
|
|
10
|
-
interface CorkEvents {
|
|
11
|
-
times: number;
|
|
12
|
-
events: Array<Event>;
|
|
13
|
-
}
|
|
14
|
-
declare class SingletonEventBus implements EventBus, EventWaiter {
|
|
15
|
-
private readonly emitter;
|
|
16
|
-
private readonly eventContextFactory;
|
|
17
|
-
private readonly eventHandlerFactory;
|
|
18
|
-
private readonly logger;
|
|
19
|
-
private corkIdSequence;
|
|
20
|
-
private readonly corkedEvents;
|
|
21
|
-
/**
|
|
22
|
-
* only use for ensure event will happen
|
|
23
|
-
*/
|
|
24
|
-
once<E extends keyof Events>(event: E, listener: Events[E]): this;
|
|
25
|
-
await<E extends keyof Events>(event: E): Promise<Arguments<Events[E]>>;
|
|
26
|
-
awaitFirst<E extends keyof Events>(...e: Array<E>): Promise<{
|
|
27
|
-
event: EventName;
|
|
28
|
-
args: Arguments<Events[E]>;
|
|
29
|
-
}>;
|
|
30
|
-
emit<E extends keyof Events>(event: E, ...args: Arguments<Events[E]>): boolean;
|
|
31
|
-
generateCorkId(): string;
|
|
32
|
-
cork(corkId: string): void;
|
|
33
|
-
uncork(corkId: string): boolean;
|
|
34
|
-
queueEvent(corkId: string, event: Event): void;
|
|
35
|
-
emitWithContext<E extends keyof Events>(parentContext: EggRuntimeContext, event: E, args: Arguments<Events[E]>): boolean;
|
|
36
|
-
private doEmitWithContext;
|
|
37
|
-
private doOnceEmit;
|
|
38
|
-
private doEmit;
|
|
39
|
-
}
|
|
40
|
-
//#endregion
|
|
41
|
-
export { CorkEvents, Event, SingletonEventBus };
|
|
@@ -1,131 +0,0 @@
|
|
|
1
|
-
import { __decorate } from "./_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js";
|
|
2
|
-
import { EventContextFactory } from "./EventContextFactory.js";
|
|
3
|
-
import { EventHandlerFactory } from "./EventHandlerFactory.js";
|
|
4
|
-
import { __decorateMetadata } from "./_virtual/_@oxc-project_runtime@0.93.0/helpers/decorateMetadata.js";
|
|
5
|
-
import EventEmitter from "node:events";
|
|
6
|
-
import { Inject, SingletonProto } from "@eggjs/core-decorator";
|
|
7
|
-
import { CORK_ID } from "@eggjs/eventbus-decorator";
|
|
8
|
-
import { ContextHandler } from "@eggjs/tegg-runtime";
|
|
9
|
-
import { AccessLevel } from "@eggjs/tegg-types";
|
|
10
|
-
import awaitEvent from "await-event";
|
|
11
|
-
import awaitFirst from "await-first";
|
|
12
|
-
|
|
13
|
-
//#region src/SingletonEventBus.ts
|
|
14
|
-
var _ref, _ref2;
|
|
15
|
-
let SingletonEventBus = class SingletonEventBus$1 {
|
|
16
|
-
emitter = new EventEmitter();
|
|
17
|
-
eventContextFactory;
|
|
18
|
-
eventHandlerFactory;
|
|
19
|
-
logger;
|
|
20
|
-
corkIdSequence = 0;
|
|
21
|
-
corkedEvents = /* @__PURE__ */ new Map();
|
|
22
|
-
/**
|
|
23
|
-
* only use for ensure event will happen
|
|
24
|
-
*/
|
|
25
|
-
once(event, listener) {
|
|
26
|
-
this.emitter.once(event, listener);
|
|
27
|
-
return this;
|
|
28
|
-
}
|
|
29
|
-
async await(event) {
|
|
30
|
-
return awaitEvent(this.emitter, event);
|
|
31
|
-
}
|
|
32
|
-
awaitFirst(...e) {
|
|
33
|
-
return awaitFirst(this.emitter, e);
|
|
34
|
-
}
|
|
35
|
-
emit(event, ...args) {
|
|
36
|
-
const ctx = this.eventContextFactory.createContext();
|
|
37
|
-
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
38
|
-
this.doEmit(ctx, event, args);
|
|
39
|
-
return hasListener;
|
|
40
|
-
}
|
|
41
|
-
generateCorkId() {
|
|
42
|
-
return String(++this.corkIdSequence);
|
|
43
|
-
}
|
|
44
|
-
cork(corkId) {
|
|
45
|
-
let corkEvents = this.corkedEvents.get(corkId);
|
|
46
|
-
if (!corkEvents) {
|
|
47
|
-
corkEvents = {
|
|
48
|
-
times: 0,
|
|
49
|
-
events: []
|
|
50
|
-
};
|
|
51
|
-
this.corkedEvents.set(corkId, corkEvents);
|
|
52
|
-
}
|
|
53
|
-
corkEvents.times++;
|
|
54
|
-
}
|
|
55
|
-
uncork(corkId) {
|
|
56
|
-
const corkEvents = this.corkedEvents.get(corkId);
|
|
57
|
-
if (!corkEvents) throw new Error(`eventbus corkId ${corkId} not found`);
|
|
58
|
-
if (--corkEvents.times !== 0) return false;
|
|
59
|
-
this.corkedEvents.delete(corkId);
|
|
60
|
-
for (const event of corkEvents.events) if (event.context) this.doEmitWithContext(event.context, event.name, event.args);
|
|
61
|
-
return true;
|
|
62
|
-
}
|
|
63
|
-
queueEvent(corkId, event) {
|
|
64
|
-
const corkedEvents = this.corkedEvents.get(corkId);
|
|
65
|
-
if (!corkedEvents) throw new Error(`eventbus corkId ${corkId} not found`);
|
|
66
|
-
corkedEvents.events.push(event);
|
|
67
|
-
}
|
|
68
|
-
emitWithContext(parentContext, event, args) {
|
|
69
|
-
const corkId = parentContext.get(CORK_ID);
|
|
70
|
-
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
71
|
-
if (corkId) {
|
|
72
|
-
this.queueEvent(corkId, {
|
|
73
|
-
name: event,
|
|
74
|
-
args,
|
|
75
|
-
context: parentContext
|
|
76
|
-
});
|
|
77
|
-
return hasListener;
|
|
78
|
-
}
|
|
79
|
-
return this.doEmitWithContext(parentContext, event, args);
|
|
80
|
-
}
|
|
81
|
-
doEmitWithContext(parentContext, event, args) {
|
|
82
|
-
const hasListener = this.eventHandlerFactory.hasListeners(event);
|
|
83
|
-
const ctx = this.eventContextFactory.createContext(parentContext);
|
|
84
|
-
this.doEmit(ctx, event, args);
|
|
85
|
-
return hasListener;
|
|
86
|
-
}
|
|
87
|
-
doOnceEmit(event, args) {
|
|
88
|
-
try {
|
|
89
|
-
this.emitter.emit(event, ...args);
|
|
90
|
-
} catch (e) {
|
|
91
|
-
e.message = `[EventBus] process once event ${String(event)} failed: ${e.message}`;
|
|
92
|
-
this.logger.error(e);
|
|
93
|
-
}
|
|
94
|
-
}
|
|
95
|
-
async doEmit(ctx, event, args) {
|
|
96
|
-
await ContextHandler.run(ctx, async () => {
|
|
97
|
-
const lifecycle = {};
|
|
98
|
-
if (ctx.init) await ctx.init(lifecycle);
|
|
99
|
-
try {
|
|
100
|
-
const handlerProtos = this.eventHandlerFactory.getHandlerProtos(event);
|
|
101
|
-
await Promise.all(handlerProtos.map(async (proto) => {
|
|
102
|
-
try {
|
|
103
|
-
await this.eventHandlerFactory.handle(event, proto, args);
|
|
104
|
-
} catch (e) {
|
|
105
|
-
e.message = `[EventBus] process event ${String(event)} for handler ${String(proto.name)} failed: ${e.message}`;
|
|
106
|
-
this.logger.error(e);
|
|
107
|
-
}
|
|
108
|
-
}));
|
|
109
|
-
} catch (e) {
|
|
110
|
-
e.message = `[EventBus] process event ${String(event)} failed: ${e.message}`;
|
|
111
|
-
this.logger.error(e);
|
|
112
|
-
} finally {
|
|
113
|
-
if (ctx.destroy) ctx.destroy(lifecycle).catch((e) => {
|
|
114
|
-
e.message = "[tegg/SingletonEventBus] destroy tegg ctx failed:" + e.message;
|
|
115
|
-
this.logger.error(e);
|
|
116
|
-
});
|
|
117
|
-
}
|
|
118
|
-
this.doOnceEmit(event, args);
|
|
119
|
-
});
|
|
120
|
-
}
|
|
121
|
-
};
|
|
122
|
-
__decorate([Inject(), __decorateMetadata("design:type", typeof (_ref = typeof EventContextFactory !== "undefined" && EventContextFactory) === "function" ? _ref : Object)], SingletonEventBus.prototype, "eventContextFactory", void 0);
|
|
123
|
-
__decorate([Inject(), __decorateMetadata("design:type", typeof (_ref2 = typeof EventHandlerFactory !== "undefined" && EventHandlerFactory) === "function" ? _ref2 : Object)], SingletonEventBus.prototype, "eventHandlerFactory", void 0);
|
|
124
|
-
__decorate([Inject({ name: "logger" }), __decorateMetadata("design:type", Object)], SingletonEventBus.prototype, "logger", void 0);
|
|
125
|
-
SingletonEventBus = __decorate([SingletonProto({
|
|
126
|
-
name: "eventBus",
|
|
127
|
-
accessLevel: AccessLevel.PUBLIC
|
|
128
|
-
})], SingletonEventBus);
|
|
129
|
-
|
|
130
|
-
//#endregion
|
|
131
|
-
export { SingletonEventBus };
|
|
@@ -1,10 +0,0 @@
|
|
|
1
|
-
//#region \0@oxc-project+runtime@0.93.0/helpers/decorate.js
|
|
2
|
-
function __decorate(decorators, target, key, desc) {
|
|
3
|
-
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
4
|
-
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
5
|
-
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
6
|
-
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
7
|
-
}
|
|
8
|
-
|
|
9
|
-
//#endregion
|
|
10
|
-
export { __decorate };
|