bellboy 8.4.0 → 8.5.1

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/lib/job.js CHANGED
@@ -1,450 +1,195 @@
1
1
  "use strict";
2
- var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
3
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
4
- return new (P || (P = Promise))(function (resolve, reject) {
5
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
6
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
7
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
8
- step((generator = generator.apply(thisArg, _arguments || [])).next());
9
- });
10
- };
11
- var __generator = (this && this.__generator) || function (thisArg, body) {
12
- var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
13
- return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
14
- function verb(n) { return function (v) { return step([n, v]); }; }
15
- function step(op) {
16
- if (f) throw new TypeError("Generator is already executing.");
17
- while (_) try {
18
- if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
19
- if (y = 0, t) op = [op[0] & 2, t.value];
20
- switch (op[0]) {
21
- case 0: case 1: t = op; break;
22
- case 4: _.label++; return { value: op[1], done: false };
23
- case 5: _.label++; y = op[1]; op = [0]; continue;
24
- case 7: op = _.ops.pop(); _.trys.pop(); continue;
25
- default:
26
- if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
27
- if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
28
- if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
29
- if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
30
- if (t[2]) _.ops.pop();
31
- _.trys.pop(); continue;
32
- }
33
- op = body.call(thisArg, _);
34
- } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
35
- if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
36
- }
37
- };
38
- var __asyncValues = (this && this.__asyncValues) || function (o) {
39
- if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
40
- var m = o[Symbol.asyncIterator], i;
41
- return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
42
- function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
43
- function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
44
- };
45
- var __spreadArrays = (this && this.__spreadArrays) || function () {
46
- for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
47
- for (var r = Array(s), k = 0, i = 0; i < il; i++)
48
- for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
49
- r[k] = a[j];
50
- return r;
51
- };
52
2
  Object.defineProperty(exports, "__esModule", { value: true });
53
3
  exports.Job = void 0;
54
- var perf_hooks_1 = require("perf_hooks");
55
- var shortid_1 = require("shortid");
56
- var stream_1 = require("stream");
57
- var Job = /** @class */ (function () {
58
- function Job(processor, destinations, config) {
59
- if (config === void 0) { config = {}; }
4
+ const node_perf_hooks_1 = require("node:perf_hooks");
5
+ const shortid_1 = require("shortid");
6
+ const stream_1 = require("stream");
7
+ class Job {
8
+ processor;
9
+ destinations;
10
+ events = {};
11
+ reporters;
12
+ anyEvent = [];
13
+ stopped = false;
14
+ jobId = (0, shortid_1.generate)();
15
+ jobName;
16
+ settingReporterEvents = false;
17
+ constructor(processor, destinations, config = {}) {
60
18
  this.processor = processor;
61
19
  this.destinations = destinations;
62
- this.events = {};
63
- this.anyEvent = [];
64
- this.stopped = false;
65
- this.jobId = shortid_1.generate();
66
- this.settingReporterEvents = false;
67
- this.jobName = config === null || config === void 0 ? void 0 : config.jobName;
20
+ this.jobName = config?.jobName;
68
21
  this.reporters = config.reporters || [];
69
22
  }
70
- Job.prototype.stop = function (message) { };
71
- Job.prototype.run = function () {
72
- return __awaiter(this, void 0, void 0, function () {
73
- var i, readStream, errorMessage, e_1, err_1;
74
- var _this = this;
75
- return __generator(this, function (_a) {
76
- switch (_a.label) {
77
- case 0:
78
- this.settingReporterEvents = true;
79
- i = 0;
80
- _a.label = 1;
81
- case 1:
82
- if (!(i < this.reporters.length)) return [3 /*break*/, 4];
83
- return [4 /*yield*/, this.reporters[i].report(this)];
84
- case 2:
85
- _a.sent();
86
- _a.label = 3;
87
- case 3:
88
- i++;
89
- return [3 /*break*/, 1];
90
- case 4:
91
- this.settingReporterEvents = false;
92
- this.stop = function (message) {
93
- if (!_this.stopped) {
94
- _this.stopped = true;
95
- if (readStream && (readStream instanceof stream_1.Readable)) {
96
- readStream.emit('end');
97
- readStream.destroy();
98
- }
99
- errorMessage = message;
23
+ stop(message) { }
24
+ async run() {
25
+ this.settingReporterEvents = true;
26
+ for (let i = 0; i < this.reporters.length; i++) {
27
+ await this.reporters[i].report(this);
28
+ }
29
+ this.settingReporterEvents = false;
30
+ let readStream;
31
+ let errorMessage;
32
+ this.stop = (message) => {
33
+ if (!this.stopped) {
34
+ this.stopped = true;
35
+ if (readStream && (readStream instanceof stream_1.Readable)) {
36
+ readStream.emit('end');
37
+ readStream.destroy();
38
+ }
39
+ errorMessage = message;
40
+ }
41
+ };
42
+ await this.emit('startProcessing', this.processor, this.destinations);
43
+ if (!this.stopped) {
44
+ try {
45
+ let e;
46
+ await this.processor.process(async (_readStream, ...args) => {
47
+ readStream = _readStream;
48
+ await this.emit('startProcessingStream', ...args);
49
+ try {
50
+ if (!this.stopped) {
51
+ const results = [];
52
+ for (let j = 0; j < this.destinations.length; j++) {
53
+ results[j] = [];
100
54
  }
101
- };
102
- return [4 /*yield*/, this.emit('startProcessing', this.processor, this.destinations)];
103
- case 5:
104
- _a.sent();
105
- if (!!this.stopped) return [3 /*break*/, 10];
106
- _a.label = 6;
107
- case 6:
108
- _a.trys.push([6, 8, , 10]);
109
- return [4 /*yield*/, this.processor.process(function (_readStream) {
110
- var args = [];
111
- for (var _i = 1; _i < arguments.length; _i++) {
112
- args[_i - 1] = arguments[_i];
113
- }
114
- return __awaiter(_this, void 0, void 0, function () {
115
- var results, j, processedRowCount, readStream_1, readStream_1_1, row, i, recordGeneratorFn, _a, _b, record, e_2_1, err_2, i, destination, toSend, e_3_1, err_3;
116
- var e_3, _c, e_2, _d;
117
- return __generator(this, function (_e) {
118
- switch (_e.label) {
119
- case 0:
120
- readStream = _readStream;
121
- return [4 /*yield*/, this.emit.apply(this, __spreadArrays(['startProcessingStream'], args))];
122
- case 1:
123
- _e.sent();
124
- _e.label = 2;
125
- case 2:
126
- _e.trys.push([2, 44, , 45]);
127
- if (!!this.stopped) return [3 /*break*/, 43];
128
- results = [];
129
- for (j = 0; j < this.destinations.length; j++) {
130
- results[j] = [];
55
+ let processedRowCount = 0;
56
+ for await (const row of readStream) {
57
+ await this.emit('startProcessingRow', row);
58
+ if (!this.stopped) {
59
+ for (let i = 0; i < this.destinations.length; i++) {
60
+ const recordGeneratorFn = this.destinations[i].recordGenerator;
61
+ if (!recordGeneratorFn) {
62
+ results[i].push(row);
63
+ }
64
+ else {
65
+ try {
66
+ for await (const record of recordGeneratorFn(row)) {
67
+ results[i].push(record);
68
+ await this.emit('rowGenerated', i, record);
131
69
  }
132
- processedRowCount = 0;
133
- _e.label = 3;
134
- case 3:
135
- _e.trys.push([3, 35, 36, 41]);
136
- readStream_1 = __asyncValues(readStream);
137
- _e.label = 4;
138
- case 4: return [4 /*yield*/, readStream_1.next()];
139
- case 5:
140
- if (!(readStream_1_1 = _e.sent(), !readStream_1_1.done)) return [3 /*break*/, 34];
141
- row = readStream_1_1.value;
142
- return [4 /*yield*/, this.emit('startProcessingRow', row)];
143
- case 6:
144
- _e.sent();
145
- if (!!this.stopped) return [3 /*break*/, 25];
146
- i = 0;
147
- _e.label = 7;
148
- case 7:
149
- if (!(i < this.destinations.length)) return [3 /*break*/, 25];
150
- recordGeneratorFn = this.destinations[i].recordGenerator;
151
- if (!!recordGeneratorFn) return [3 /*break*/, 8];
152
- results[i].push(row);
153
- return [3 /*break*/, 24];
154
- case 8:
155
- _e.trys.push([8, 22, , 24]);
156
- _e.label = 9;
157
- case 9:
158
- _e.trys.push([9, 15, 16, 21]);
159
- _a = (e_2 = void 0, __asyncValues(recordGeneratorFn(row)));
160
- _e.label = 10;
161
- case 10: return [4 /*yield*/, _a.next()];
162
- case 11:
163
- if (!(_b = _e.sent(), !_b.done)) return [3 /*break*/, 14];
164
- record = _b.value;
165
- results[i].push(record);
166
- return [4 /*yield*/, this.emit('rowGenerated', i, record)];
167
- case 12:
168
- _e.sent();
169
- _e.label = 13;
170
- case 13: return [3 /*break*/, 10];
171
- case 14: return [3 /*break*/, 21];
172
- case 15:
173
- e_2_1 = _e.sent();
174
- e_2 = { error: e_2_1 };
175
- return [3 /*break*/, 21];
176
- case 16:
177
- _e.trys.push([16, , 19, 20]);
178
- if (!(_b && !_b.done && (_d = _a.return))) return [3 /*break*/, 18];
179
- return [4 /*yield*/, _d.call(_a)];
180
- case 17:
181
- _e.sent();
182
- _e.label = 18;
183
- case 18: return [3 /*break*/, 20];
184
- case 19:
185
- if (e_2) throw e_2.error;
186
- return [7 /*endfinally*/];
187
- case 20: return [7 /*endfinally*/];
188
- case 21: return [3 /*break*/, 24];
189
- case 22:
190
- err_2 = _e.sent();
191
- return [4 /*yield*/, this.emit('rowGenerationError', i, row, err_2)];
192
- case 23:
193
- _e.sent();
194
- return [3 /*break*/, 24];
195
- case 24:
196
- i++;
197
- return [3 /*break*/, 7];
198
- case 25: return [4 /*yield*/, this.emit('endProcessingRow')];
199
- case 26:
200
- _e.sent();
201
- i = 0;
202
- _e.label = 27;
203
- case 27:
204
- if (!(i < this.destinations.length)) return [3 /*break*/, 31];
205
- _e.label = 28;
206
- case 28:
207
- if (!(this.destinations[i].batchSize && results[i].length >= this.destinations[i].batchSize)) return [3 /*break*/, 30];
208
- destination = this.destinations[i];
209
- toSend = results[i].splice(0, destination.batchSize);
210
- return [4 /*yield*/, this.loadBatch(i, destination, toSend)];
211
- case 29:
212
- _e.sent();
213
- return [3 /*break*/, 28];
214
- case 30:
215
- i++;
216
- return [3 /*break*/, 27];
217
- case 31:
218
- processedRowCount++;
219
- if (!(this.processor.rowLimit === processedRowCount)) return [3 /*break*/, 33];
220
- return [4 /*yield*/, this.flushRows(results)];
221
- case 32:
222
- _e.sent();
223
- this.stop();
224
- return [3 /*break*/, 34];
225
- case 33: return [3 /*break*/, 4];
226
- case 34: return [3 /*break*/, 41];
227
- case 35:
228
- e_3_1 = _e.sent();
229
- e_3 = { error: e_3_1 };
230
- return [3 /*break*/, 41];
231
- case 36:
232
- _e.trys.push([36, , 39, 40]);
233
- if (!(readStream_1_1 && !readStream_1_1.done && (_c = readStream_1.return))) return [3 /*break*/, 38];
234
- return [4 /*yield*/, _c.call(readStream_1)];
235
- case 37:
236
- _e.sent();
237
- _e.label = 38;
238
- case 38: return [3 /*break*/, 40];
239
- case 39:
240
- if (e_3) throw e_3.error;
241
- return [7 /*endfinally*/];
242
- case 40: return [7 /*endfinally*/];
243
- case 41:
244
- if (!!this.stopped) return [3 /*break*/, 43];
245
- return [4 /*yield*/, this.flushRows(results)];
246
- case 42:
247
- _e.sent();
248
- _e.label = 43;
249
- case 43: return [3 /*break*/, 45];
250
- case 44:
251
- err_3 = _e.sent();
252
- e_1 = err_3;
253
- return [3 /*break*/, 45];
254
- case 45: return [4 /*yield*/, this.emit.apply(this, __spreadArrays(['endProcessingStream'], args))];
255
- case 46:
256
- _e.sent();
257
- return [2 /*return*/];
70
+ }
71
+ catch (err) {
72
+ await this.emit('rowGenerationError', i, row, err);
73
+ }
258
74
  }
259
- });
260
- });
261
- })];
262
- case 7:
263
- _a.sent();
264
- if (e_1) {
265
- throw e_1;
266
- }
267
- return [3 /*break*/, 10];
268
- case 8:
269
- err_1 = _a.sent();
270
- return [4 /*yield*/, this.emit('processingError', err_1)];
271
- case 9:
272
- _a.sent();
273
- return [3 /*break*/, 10];
274
- case 10: return [4 /*yield*/, this.emit('endProcessing')];
275
- case 11:
276
- _a.sent();
277
- if (errorMessage) {
278
- throw new Error(errorMessage);
75
+ }
76
+ }
77
+ await this.emit('endProcessingRow');
78
+ for (let i = 0; i < this.destinations.length; i++) {
79
+ while (this.destinations[i].batchSize && results[i].length >= this.destinations[i].batchSize) {
80
+ const destination = this.destinations[i];
81
+ const toSend = results[i].splice(0, destination.batchSize);
82
+ await this.loadBatch(i, destination, toSend);
83
+ }
84
+ }
85
+ processedRowCount++;
86
+ if (this.processor.rowLimit === processedRowCount) {
87
+ await this.flushRows(results);
88
+ this.stop();
89
+ break;
90
+ }
91
+ }
92
+ if (!this.stopped) {
93
+ await this.flushRows(results);
94
+ }
279
95
  }
280
- return [2 /*return*/];
96
+ }
97
+ catch (err) {
98
+ e = err;
99
+ }
100
+ await this.emit('endProcessingStream', ...args);
101
+ });
102
+ if (e) {
103
+ throw e;
281
104
  }
282
- });
283
- });
284
- };
285
- Job.prototype.on = function (eventName, event, extendedEvent) {
286
- var eventEntry = { event: event, extendedEvent: extendedEvent };
105
+ }
106
+ catch (err) {
107
+ await this.emit('processingError', err);
108
+ }
109
+ }
110
+ await this.emit('endProcessing');
111
+ if (errorMessage) {
112
+ throw new Error(errorMessage);
113
+ }
114
+ }
115
+ on(eventName, event, extendedEvent) {
116
+ const eventEntry = { event, extendedEvent };
287
117
  if (!this.events[eventName]) {
288
118
  this.events[eventName] = [];
289
119
  }
290
120
  this.settingReporterEvents
291
121
  ? this.events[eventName].unshift(eventEntry)
292
122
  : this.events[eventName].push(eventEntry);
293
- };
294
- Job.prototype.onAny = function (event, extendedEvent) {
295
- var eventEntry = { event: event, extendedEvent: extendedEvent };
123
+ }
124
+ onAny(event, extendedEvent) {
125
+ const eventEntry = { event, extendedEvent };
296
126
  this.settingReporterEvents
297
127
  ? this.anyEvent.unshift(eventEntry)
298
128
  : this.anyEvent.push(eventEntry);
299
- };
300
- Job.prototype.flushRows = function (rows) {
301
- return __awaiter(this, void 0, void 0, function () {
302
- var i;
303
- return __generator(this, function (_a) {
304
- switch (_a.label) {
305
- case 0:
306
- i = 0;
307
- _a.label = 1;
308
- case 1:
309
- if (!(i < this.destinations.length)) return [3 /*break*/, 4];
310
- if (!rows[i].length) return [3 /*break*/, 3];
311
- return [4 /*yield*/, this.loadBatch(i, this.destinations[i], rows[i])];
312
- case 2:
313
- _a.sent();
314
- _a.label = 3;
315
- case 3:
316
- i++;
317
- return [3 /*break*/, 1];
318
- case 4: return [2 /*return*/];
129
+ }
130
+ async flushRows(rows) {
131
+ for (let i = 0; i < this.destinations.length; i++) {
132
+ if (rows[i].length) {
133
+ await this.loadBatch(i, this.destinations[i], rows[i]);
134
+ }
135
+ }
136
+ }
137
+ async loadBatch(destinationIndex, destination, data) {
138
+ if (data.length) {
139
+ if (destination.batchTransformer) {
140
+ await this.emit('transformingBatch', destinationIndex, data);
141
+ if (!this.stopped) {
142
+ try {
143
+ data = await destination.batchTransformer(data);
144
+ await this.emit('transformedBatch', destinationIndex, data);
145
+ }
146
+ catch (err) {
147
+ await this.emit('transformingBatchError', destinationIndex, data, err);
148
+ }
319
149
  }
320
- });
321
- });
322
- };
323
- Job.prototype.loadBatch = function (destinationIndex, destination, data) {
324
- return __awaiter(this, void 0, void 0, function () {
325
- var err_4, err_5;
326
- return __generator(this, function (_a) {
327
- switch (_a.label) {
328
- case 0:
329
- if (!data.length) return [3 /*break*/, 18];
330
- if (!destination.batchTransformer) return [3 /*break*/, 9];
331
- return [4 /*yield*/, this.emit('transformingBatch', destinationIndex, data)];
332
- case 1:
333
- _a.sent();
334
- if (!!this.stopped) return [3 /*break*/, 7];
335
- _a.label = 2;
336
- case 2:
337
- _a.trys.push([2, 5, , 7]);
338
- return [4 /*yield*/, destination.batchTransformer(data)];
339
- case 3:
340
- data = _a.sent();
341
- return [4 /*yield*/, this.emit('transformedBatch', destinationIndex, data)];
342
- case 4:
343
- _a.sent();
344
- return [3 /*break*/, 7];
345
- case 5:
346
- err_4 = _a.sent();
347
- return [4 /*yield*/, this.emit('transformingBatchError', destinationIndex, data, err_4)];
348
- case 6:
349
- _a.sent();
350
- return [3 /*break*/, 7];
351
- case 7: return [4 /*yield*/, this.emit('endTransformingBatch', destinationIndex)];
352
- case 8:
353
- _a.sent();
354
- _a.label = 9;
355
- case 9:
356
- if (!(!destination.disableLoad && !this.stopped)) return [3 /*break*/, 18];
357
- return [4 /*yield*/, this.emit('loadingBatch', destinationIndex, data)];
358
- case 10:
359
- _a.sent();
360
- if (!!this.stopped) return [3 /*break*/, 16];
361
- _a.label = 11;
362
- case 11:
363
- _a.trys.push([11, 14, , 16]);
364
- return [4 /*yield*/, destination.loadBatch(data)];
365
- case 12:
366
- _a.sent();
367
- return [4 /*yield*/, this.emit('loadedBatch', destinationIndex, data)];
368
- case 13:
369
- _a.sent();
370
- return [3 /*break*/, 16];
371
- case 14:
372
- err_5 = _a.sent();
373
- return [4 /*yield*/, this.emit('loadingBatchError', destinationIndex, data, err_5)];
374
- case 15:
375
- _a.sent();
376
- return [3 /*break*/, 16];
377
- case 16: return [4 /*yield*/, this.emit('endLoadingBatch', destinationIndex)];
378
- case 17:
379
- _a.sent();
380
- _a.label = 18;
381
- case 18: return [2 /*return*/];
150
+ await this.emit('endTransformingBatch', destinationIndex);
151
+ }
152
+ if (!destination.disableLoad && !this.stopped) {
153
+ await this.emit('loadingBatch', destinationIndex, data);
154
+ if (!this.stopped) {
155
+ try {
156
+ await destination.loadBatch(data);
157
+ await this.emit('loadedBatch', destinationIndex, data);
158
+ }
159
+ catch (err) {
160
+ await this.emit('loadingBatchError', destinationIndex, data, err);
161
+ }
382
162
  }
383
- });
384
- });
385
- };
386
- Job.prototype.emit = function (eventName) {
387
- var _a, _b, _c, _d;
388
- var args = [];
389
- for (var _i = 1; _i < arguments.length; _i++) {
390
- args[_i - 1] = arguments[_i];
163
+ await this.emit('endLoadingBatch', destinationIndex);
164
+ }
391
165
  }
392
- return __awaiter(this, void 0, void 0, function () {
393
- var fn, bellboyEvent, i, i, err_6;
394
- return __generator(this, function (_e) {
395
- switch (_e.label) {
396
- case 0:
397
- _e.trys.push([0, 11, , 12]);
398
- fn = this.events[eventName];
399
- bellboyEvent = {
400
- eventName: eventName,
401
- eventArguments: args,
402
- timestamp: perf_hooks_1.performance.now() + perf_hooks_1.performance.timeOrigin,
403
- jobStopped: this.stopped,
404
- eventId: shortid_1.generate(),
405
- jobId: this.jobId,
406
- jobName: this.jobName,
407
- };
408
- if (!fn) return [3 /*break*/, 5];
409
- i = 0;
410
- _e.label = 1;
411
- case 1:
412
- if (!(i < fn.length)) return [3 /*break*/, 5];
413
- return [4 /*yield*/, ((_a = fn[i].event) === null || _a === void 0 ? void 0 : _a.apply(this, args))];
414
- case 2:
415
- _e.sent();
416
- return [4 /*yield*/, ((_b = fn[i].extendedEvent) === null || _b === void 0 ? void 0 : _b.apply(this, [bellboyEvent]))];
417
- case 3:
418
- _e.sent();
419
- _e.label = 4;
420
- case 4:
421
- i++;
422
- return [3 /*break*/, 1];
423
- case 5:
424
- i = 0;
425
- _e.label = 6;
426
- case 6:
427
- if (!(i < this.anyEvent.length)) return [3 /*break*/, 10];
428
- return [4 /*yield*/, ((_c = this.anyEvent[i].event) === null || _c === void 0 ? void 0 : _c.apply(this, __spreadArrays([eventName], args)))];
429
- case 7:
430
- _e.sent();
431
- return [4 /*yield*/, ((_d = this.anyEvent[i].extendedEvent) === null || _d === void 0 ? void 0 : _d.apply(this, [bellboyEvent]))];
432
- case 8:
433
- _e.sent();
434
- _e.label = 9;
435
- case 9:
436
- i++;
437
- return [3 /*break*/, 6];
438
- case 10: return [3 /*break*/, 12];
439
- case 11:
440
- err_6 = _e.sent();
441
- console.error("Warning. Exception was thrown inside " + eventName + " event.", err_6);
442
- return [3 /*break*/, 12];
443
- case 12: return [2 /*return*/];
166
+ }
167
+ async emit(eventName, ...args) {
168
+ try {
169
+ const fn = this.events[eventName];
170
+ const bellboyEvent = {
171
+ eventName,
172
+ eventArguments: args,
173
+ timestamp: node_perf_hooks_1.performance.now() + node_perf_hooks_1.performance.timeOrigin,
174
+ jobStopped: this.stopped,
175
+ eventId: (0, shortid_1.generate)(),
176
+ jobId: this.jobId,
177
+ jobName: this.jobName,
178
+ };
179
+ if (fn) {
180
+ for (let i = 0; i < fn.length; i++) {
181
+ await fn[i].event?.apply(this, args);
182
+ await fn[i].extendedEvent?.apply(this, [bellboyEvent]);
444
183
  }
445
- });
446
- });
447
- };
448
- return Job;
449
- }());
184
+ }
185
+ for (let i = 0; i < this.anyEvent.length; i++) {
186
+ await this.anyEvent[i].event?.apply(this, [eventName, ...args]);
187
+ await this.anyEvent[i].extendedEvent?.apply(this, [bellboyEvent]);
188
+ }
189
+ }
190
+ catch (err) {
191
+ console.error(`Warning. Exception was thrown inside ${eventName} event.`, err);
192
+ }
193
+ }
194
+ }
450
195
  exports.Job = Job;