inngest 1.8.4 → 1.9.0
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/CHANGELOG.md +12 -0
- package/components/Inngest.d.ts +2 -1
- package/components/Inngest.d.ts.map +1 -1
- package/components/Inngest.js +3 -1
- package/components/Inngest.js.map +1 -1
- package/components/InngestFunction.d.ts.map +1 -1
- package/components/InngestFunction.js +230 -209
- package/components/InngestFunction.js.map +1 -1
- package/components/InngestStepTools.d.ts +5 -0
- package/components/InngestStepTools.d.ts.map +1 -1
- package/components/InngestStepTools.js +12 -0
- package/components/InngestStepTools.js.map +1 -1
- package/helpers/errors.d.ts +2 -1
- package/helpers/errors.d.ts.map +1 -1
- package/helpers/errors.js +1 -0
- package/helpers/errors.js.map +1 -1
- package/landing.d.ts +1 -1
- package/landing.d.ts.map +1 -1
- package/landing.js +1 -1
- package/landing.js.map +1 -1
- package/middleware/logger.d.ts +48 -0
- package/middleware/logger.d.ts.map +1 -0
- package/middleware/logger.js +90 -0
- package/middleware/logger.js.map +1 -0
- package/package.json +1 -1
- package/types.d.ts +21 -0
- package/types.d.ts.map +1 -1
- package/types.js.map +1 -1
- package/version.d.ts +1 -1
- package/version.js +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,17 @@
|
|
|
1
1
|
# inngest
|
|
2
2
|
|
|
3
|
+
## 1.9.0
|
|
4
|
+
|
|
5
|
+
### Minor Changes
|
|
6
|
+
|
|
7
|
+
- 48d94a2: Allow user provided logger to be used within functions (experimental)
|
|
8
|
+
|
|
9
|
+
## 1.8.5
|
|
10
|
+
|
|
11
|
+
### Patch Changes
|
|
12
|
+
|
|
13
|
+
- 34f9ee8: INN-1253 Show actionable error when steps are nested
|
|
14
|
+
|
|
3
15
|
## 1.8.4
|
|
4
16
|
|
|
5
17
|
### Patch Changes
|
package/components/Inngest.d.ts
CHANGED
|
@@ -47,6 +47,7 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
|
|
|
47
47
|
private inngestApiUrl;
|
|
48
48
|
private readonly headers;
|
|
49
49
|
private readonly fetch;
|
|
50
|
+
private readonly logger;
|
|
50
51
|
/**
|
|
51
52
|
* A client used to interact with the Inngest API by sending or reacting to
|
|
52
53
|
* events.
|
|
@@ -70,7 +71,7 @@ export declare class Inngest<Events extends Record<string, EventPayload> = Recor
|
|
|
70
71
|
* >({ name: "My App" });
|
|
71
72
|
* ```
|
|
72
73
|
*/
|
|
73
|
-
constructor({ name, eventKey, inngestBaseUrl, fetch, env, }: ClientOptions);
|
|
74
|
+
constructor({ name, eventKey, inngestBaseUrl, fetch, env, logger, }: ClientOptions);
|
|
74
75
|
/**
|
|
75
76
|
* Set the event key for this instance of Inngest. This is useful if for some
|
|
76
77
|
* reason the key is not available at time of instantiation or present in the
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Inngest.d.ts","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;
|
|
1
|
+
{"version":3,"file":"Inngest.d.ts","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAQpD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,OAAO,CAClB,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;;IAE1E;;;OAGG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAM;IAEtB;;OAEG;IACH,SAAgB,cAAc,EAAE,GAAG,CAAC;IAEpC;;OAEG;IACH,OAAO,CAAC,aAAa,CAAyD;IAE9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IAEjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;gBACS,EACV,IAAI,EACJ,QAAQ,EACR,cAAkC,EAClC,KAAK,EACL,GAAG,EACH,MAA4B,GAC7B,EAAE,aAAa;IAoEhB;;;;OAIG;IACI,WAAW;IAChB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,GACf,IAAI;IAKP;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,IAAI,CAAC,KAAK,SAAS,MAAM,MAAM,EAC1C,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,GACxE,OAAO,CAAC,IAAI,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,IAAI,CAAC,OAAO,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACxD,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC;IA+FT,cAAc,CACnB,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,QAAQ,SAAS,cAAc,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,EACtD,WAAW,SAAS,MAAM,CACxB,MAAM,EAEN,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CACxB,GAAG,UAAU,CAAC,IAAI,CAAC,EACpB,YAAY,SAAS,MAAM,MAAM,GAAG,MAAM,GAAG,oBAAoB,CAC/D,MAAM,EACN,QAAQ,CACT,EAED,UAAU,EACN,MAAM,GACN,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC,GAAG;QAClE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+BG;QACH,GAAG,CAAC,EAAE,IAAI,CAAC;QAEX;;;;;;;WAOG;QACH,SAAS,CAAC,EAAE,OAAO,CACjB,MAAM,EACN,YAAY,EACZ,WAAW,EACX,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CACvC,CAAC;KACH,CAAC,EACN,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,CAAC,GAClD,eAAe;CAYnB"}
|
package/components/Inngest.js
CHANGED
|
@@ -12,6 +12,7 @@ const devserver_1 = require("../helpers/devserver");
|
|
|
12
12
|
const env_1 = require("../helpers/env");
|
|
13
13
|
const errors_1 = require("../helpers/errors");
|
|
14
14
|
const InngestFunction_1 = require("./InngestFunction");
|
|
15
|
+
const logger_1 = require("../middleware/logger");
|
|
15
16
|
/**
|
|
16
17
|
* A client used to interact with the Inngest API by sending or reacting to
|
|
17
18
|
* events.
|
|
@@ -61,7 +62,7 @@ class Inngest {
|
|
|
61
62
|
* >({ name: "My App" });
|
|
62
63
|
* ```
|
|
63
64
|
*/
|
|
64
|
-
constructor({ name, eventKey, inngestBaseUrl = "https://inn.gs/", fetch, env, }) {
|
|
65
|
+
constructor({ name, eventKey, inngestBaseUrl = "https://inn.gs/", fetch, env, logger = new logger_1.DefaultLogger(), }) {
|
|
65
66
|
_Inngest_instances.add(this);
|
|
66
67
|
/**
|
|
67
68
|
* Inngest event key, used to send events to Inngest Cloud.
|
|
@@ -92,6 +93,7 @@ class Inngest {
|
|
|
92
93
|
inngestEnv: env,
|
|
93
94
|
});
|
|
94
95
|
this.fetch = (0, env_1.getFetch)(fetch);
|
|
96
|
+
this.logger = logger;
|
|
95
97
|
}
|
|
96
98
|
/**
|
|
97
99
|
* Set the event key for this instance of Inngest. This is useful if for some
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Inngest.js","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":";;;;;;;;;AAAA,8CAA4C;AAC5C,oDAAwE;AACxE,wCAMwB;AACxB,8CAAyE;AAiBzE,uDAAoD;
|
|
1
|
+
{"version":3,"file":"Inngest.js","sourceRoot":"","sources":["../../src/components/Inngest.ts"],"names":[],"mappings":"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"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"InngestFunction.d.ts","sourceRoot":"","sources":["../../src/components/InngestFunction.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"InngestFunction.d.ts","sourceRoot":"","sources":["../../src/components/InngestFunction.ts"],"names":[],"mappings":"AAWA,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,YAAY,EAIjB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,OAAO,EAIb,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC;;;;;;;;GAQG;AACH,qBAAa,eAAe,CAC1B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC1E,OAAO,SAAS,eAAe,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,eAAe,CACtE,MAAM,MAAM,GAAG,MAAM,CACtB,EACD,IAAI,SAAS,eAAe,CAC1B,MAAM,EACN,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CACtC,GAAG,eAAe,CAAC,MAAM,EAAE,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;IAElE,MAAM,CAAC,MAAM,SAAU;IACvB,MAAM,CAAC,aAAa,SAAc;IAQlC;;;;;;OAMG;gBAED,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC;IAEvB;;OAEG;IACH,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,EAAE,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,MAAM,GAAG,MAAM,CAAC;IAS5C;;OAEG;IACI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM;IAIzB;;OAEG;IACH,IAAW,IAAI,WAEd;IAED;;OAEG;IACH,OAAO,CAAC,SAAS;IAiGjB;;;;;;;;;;;;;;;OAeG;YACW,KAAK;CAkWpB"}
|
|
@@ -28,6 +28,7 @@ const consts_1 = require("../helpers/consts");
|
|
|
28
28
|
const errors_1 = require("../helpers/errors");
|
|
29
29
|
const promises_1 = require("../helpers/promises");
|
|
30
30
|
const strings_1 = require("../helpers/strings");
|
|
31
|
+
const logger_1 = require("../middleware/logger");
|
|
31
32
|
const types_1 = require("../types");
|
|
32
33
|
const InngestStepTools_1 = require("./InngestStepTools");
|
|
33
34
|
const NonRetriableError_1 = require("./NonRetriableError");
|
|
@@ -199,231 +200,251 @@ class InngestFunction {
|
|
|
199
200
|
* if an op has been submitted or not.
|
|
200
201
|
*/
|
|
201
202
|
const [tools, state] = (0, InngestStepTools_1.createStepTools)(__classPrivateFieldGet(this, _InngestFunction_client, "f"));
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
const fnArg = Object.assign(Object.assign({}, data), { tools, step: tools });
|
|
207
|
-
let userFnToRun = __classPrivateFieldGet(this, _InngestFunction_fn, "f");
|
|
208
|
-
/**
|
|
209
|
-
* If the incoming event is an Inngest function failure event, we also want
|
|
210
|
-
* to pass some extra data to the function to act as shortcuts to the event
|
|
211
|
-
* payload.
|
|
212
|
-
*/
|
|
213
|
-
if (isFailureHandler) {
|
|
203
|
+
// create new proxy logger so it doesn't share the buffer with other
|
|
204
|
+
// function runs
|
|
205
|
+
const logger = new logger_1.ProxyLogger(__classPrivateFieldGet(this, _InngestFunction_client, "f")["logger"]);
|
|
206
|
+
try {
|
|
214
207
|
/**
|
|
215
|
-
*
|
|
216
|
-
*
|
|
217
|
-
*
|
|
218
|
-
* We only use the onFailure handler if
|
|
208
|
+
* Create args to pass in to our function. We blindly pass in the data and
|
|
209
|
+
* add tools.
|
|
219
210
|
*/
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
return acc;
|
|
211
|
+
const fnArg = Object.assign(Object.assign({}, data), { tools, step: tools, logger: logger });
|
|
212
|
+
let userFnToRun = __classPrivateFieldGet(this, _InngestFunction_fn, "f");
|
|
213
|
+
/**
|
|
214
|
+
* If the incoming event is an Inngest function failure event, we also want
|
|
215
|
+
* to pass some extra data to the function to act as shortcuts to the event
|
|
216
|
+
* payload.
|
|
217
|
+
*/
|
|
218
|
+
if (isFailureHandler) {
|
|
219
|
+
/**
|
|
220
|
+
* The user could have created a function that intentionally listens for
|
|
221
|
+
* these events. In this case, we may want to use the original handler.
|
|
222
|
+
*
|
|
223
|
+
* We only use the onFailure handler if
|
|
224
|
+
*/
|
|
225
|
+
if (!__classPrivateFieldGet(this, _InngestFunction_onFailureFn, "f")) {
|
|
226
|
+
// TODO PrettyError
|
|
227
|
+
throw new Error(`Function "${this.name}" received a failure event to handle, but no failure handler was defined.`);
|
|
238
228
|
}
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
[key]: (...args) => tools.run(key, () => fn(...args)) });
|
|
242
|
-
}, {});
|
|
243
|
-
}
|
|
244
|
-
// eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor
|
|
245
|
-
const userFnPromise = new Promise(async (resolve, reject) => {
|
|
246
|
-
try {
|
|
247
|
-
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
248
|
-
resolve(await userFnToRun(fnArg));
|
|
229
|
+
userFnToRun = __classPrivateFieldGet(this, _InngestFunction_onFailureFn, "f");
|
|
230
|
+
fnArg.error = (0, errors_1.deserializeError)(fnArg.event.data.error);
|
|
249
231
|
}
|
|
250
|
-
|
|
251
|
-
|
|
232
|
+
/**
|
|
233
|
+
* If the user has passed functions they wish to use in their step, add them
|
|
234
|
+
* here.
|
|
235
|
+
*
|
|
236
|
+
* We simply place a thin `tools.run()` wrapper around the function and
|
|
237
|
+
* nothing else.
|
|
238
|
+
*/
|
|
239
|
+
if (__classPrivateFieldGet(this, _InngestFunction_opts, "f").fns) {
|
|
240
|
+
fnArg.fns = Object.entries(__classPrivateFieldGet(this, _InngestFunction_opts, "f").fns).reduce((acc, [key, fn]) => {
|
|
241
|
+
if (typeof fn !== "function") {
|
|
242
|
+
return acc;
|
|
243
|
+
}
|
|
244
|
+
return Object.assign(Object.assign({}, acc), {
|
|
245
|
+
// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
|
|
246
|
+
[key]: (...args) => tools.run(key, () => fn(...args)) });
|
|
247
|
+
}, {});
|
|
252
248
|
}
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
state.tickOps = {};
|
|
258
|
-
const incomingOp = opStack[pos];
|
|
259
|
-
state.currentOp = state.allFoundOps[incomingOp.id];
|
|
260
|
-
if (!state.currentOp) {
|
|
261
|
-
/**
|
|
262
|
-
* We're trying to resume the function, but we can't find where to go.
|
|
263
|
-
*
|
|
264
|
-
* This means that either the function has changed or there are async
|
|
265
|
-
* actions in-between steps that we haven't noticed in previous
|
|
266
|
-
* executions.
|
|
267
|
-
*
|
|
268
|
-
* Whichever the case, this is bad and we can't continue in this
|
|
269
|
-
* undefined state.
|
|
270
|
-
*/
|
|
271
|
-
throw new NonRetriableError_1.NonRetriableError((0, errors_1.functionStoppedRunningErr)(errors_1.ErrCode.ASYNC_DETECTED_DURING_MEMOIZATION));
|
|
249
|
+
// eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor
|
|
250
|
+
const userFnPromise = new Promise(async (resolve, reject) => {
|
|
251
|
+
if (opStack.length == 0 && !requestedRunStep) {
|
|
252
|
+
logger.enable();
|
|
272
253
|
}
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
254
|
+
try {
|
|
255
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
256
|
+
resolve(await userFnToRun(fnArg));
|
|
276
257
|
}
|
|
277
|
-
|
|
278
|
-
|
|
258
|
+
catch (err) {
|
|
259
|
+
logger.error(err);
|
|
260
|
+
reject(err);
|
|
279
261
|
}
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
262
|
+
logger.disable();
|
|
263
|
+
});
|
|
264
|
+
let pos = -1;
|
|
265
|
+
do {
|
|
266
|
+
if (pos >= 0) {
|
|
267
|
+
if (!requestedRunStep && pos == opStack.length - 1) {
|
|
268
|
+
logger.enable();
|
|
269
|
+
}
|
|
270
|
+
state.tickOps = {};
|
|
271
|
+
const incomingOp = opStack[pos];
|
|
272
|
+
state.currentOp = state.allFoundOps[incomingOp.id];
|
|
273
|
+
if (!state.currentOp) {
|
|
274
|
+
/**
|
|
275
|
+
* We're trying to resume the function, but we can't find where to go.
|
|
276
|
+
*
|
|
277
|
+
* This means that either the function has changed or there are async
|
|
278
|
+
* actions in-between steps that we haven't noticed in previous
|
|
279
|
+
* executions.
|
|
280
|
+
*
|
|
281
|
+
* Whichever the case, this is bad and we can't continue in this
|
|
282
|
+
* undefined state.
|
|
283
|
+
*/
|
|
284
|
+
throw new NonRetriableError_1.NonRetriableError((0, errors_1.functionStoppedRunningErr)(errors_1.ErrCode.ASYNC_DETECTED_DURING_MEMOIZATION));
|
|
285
|
+
}
|
|
286
|
+
state.currentOp.fulfilled = true;
|
|
287
|
+
if (typeof incomingOp.data !== "undefined") {
|
|
288
|
+
state.currentOp.resolve(incomingOp.data);
|
|
289
|
+
}
|
|
290
|
+
else {
|
|
291
|
+
state.currentOp.reject(incomingOp.error);
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
await timer.wrap("memoizing-ticks", promises_1.resolveAfterPending);
|
|
295
|
+
logger.disable();
|
|
296
|
+
state.reset();
|
|
297
|
+
pos++;
|
|
298
|
+
} while (pos < opStack.length);
|
|
299
|
+
memoizingStop();
|
|
300
|
+
const discoveredOps = Object.values(state.tickOps).map(tickOpToOutgoing);
|
|
301
|
+
/**
|
|
302
|
+
* We make an optimization here by immediately invoking an op if it's the
|
|
303
|
+
* only one we've discovered. The alternative is to plan the step and then
|
|
304
|
+
* complete it, so we skip at least one entire execution with this.
|
|
305
|
+
*/
|
|
306
|
+
const runStep = requestedRunStep || getEarlyExecRunStep(discoveredOps);
|
|
307
|
+
if (runStep) {
|
|
308
|
+
const userFnOp = state.allFoundOps[runStep];
|
|
309
|
+
const userFnToRun = userFnOp === null || userFnOp === void 0 ? void 0 : userFnOp.fn;
|
|
310
|
+
if (!userFnToRun) {
|
|
311
|
+
// TODO PrettyError
|
|
312
|
+
throw new Error(`Bad stack; executor requesting to run unknown step "${runStep}"`);
|
|
323
313
|
}
|
|
324
|
-
|
|
325
|
-
|
|
314
|
+
const runningStepStop = timer.start("running-step");
|
|
315
|
+
state.executingStep = true;
|
|
316
|
+
logger.enable();
|
|
317
|
+
const result = await new Promise((resolve) => {
|
|
318
|
+
return resolve(userFnToRun());
|
|
319
|
+
})
|
|
320
|
+
.finally(() => {
|
|
321
|
+
state.executingStep = false;
|
|
322
|
+
runningStepStop();
|
|
323
|
+
})
|
|
324
|
+
.then((data) => {
|
|
326
325
|
return {
|
|
327
|
-
|
|
326
|
+
data: typeof data === "undefined" ? null : data,
|
|
328
327
|
};
|
|
329
|
-
}
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
*
|
|
351
|
-
* An empty list while also using step tooling is a valid state when the end
|
|
352
|
-
* of a chain of promises is reached, so we MUST also check if step tooling
|
|
353
|
-
* has previously been used.
|
|
354
|
-
*/
|
|
355
|
-
if (!discoveredOps.length) {
|
|
356
|
-
const fnRet = await Promise.race([
|
|
357
|
-
userFnPromise.then((data) => ({ type: "complete", data })),
|
|
358
|
-
(0, promises_1.resolveNextTick)().then(() => ({ type: "incomplete" })),
|
|
359
|
-
]);
|
|
360
|
-
if (fnRet.type === "complete") {
|
|
361
|
-
/**
|
|
362
|
-
* The function has returned a value, so we should return this to
|
|
363
|
-
* Inngest. Doing this will cause the function to be marked as
|
|
364
|
-
* complete, so we should only do this if we're sure that all
|
|
365
|
-
* registered ops have been resolved.
|
|
366
|
-
*/
|
|
367
|
-
const allOpsFulfilled = Object.values(state.allFoundOps).every((op) => {
|
|
368
|
-
return op.fulfilled;
|
|
328
|
+
})
|
|
329
|
+
.catch((err) => {
|
|
330
|
+
/**
|
|
331
|
+
* If the user-defined code throws an error, we should return this
|
|
332
|
+
* to Inngest as the response for this step. The function didn't
|
|
333
|
+
* fail, only this step, so Inngest can decide what we do next.
|
|
334
|
+
*
|
|
335
|
+
* Make sure to log this so the user sees what has happened.
|
|
336
|
+
*/
|
|
337
|
+
logger.error(err);
|
|
338
|
+
try {
|
|
339
|
+
return {
|
|
340
|
+
error: (0, errors_1.serializeError)(err),
|
|
341
|
+
};
|
|
342
|
+
}
|
|
343
|
+
catch (serializationErr) {
|
|
344
|
+
logger.warn("Could not serialize error to return to Inngest; stringifying instead", serializationErr);
|
|
345
|
+
return {
|
|
346
|
+
error: err,
|
|
347
|
+
};
|
|
348
|
+
}
|
|
369
349
|
});
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
* If we're here, it means that the user's function has returned a
|
|
375
|
-
* value but not all ops have been resolved. This might be intentional
|
|
376
|
-
* if they are purposefully pushing work to the background, but also
|
|
377
|
-
* might be unintentional and a bug in the user's code where they
|
|
378
|
-
* expected an order to be maintained.
|
|
379
|
-
*
|
|
380
|
-
* To be safe, we'll show a warning here to tell users that this might
|
|
381
|
-
* be unintentional, but otherwise carry on as normal.
|
|
382
|
-
*/
|
|
383
|
-
// TODO PrettyError
|
|
384
|
-
console.warn(`Warning: Your "${this.name}" function has returned a value, but not all ops have been resolved, i.e. you have used step tooling without \`await\`. This may be intentional, but if you expect your ops to be resolved in order, you should \`await\` them. If you are knowingly leaving ops unresolved using \`.catch()\` or \`void\`, you can ignore this warning.`);
|
|
385
|
-
}
|
|
386
|
-
else if (!state.hasUsedTools) {
|
|
387
|
-
/**
|
|
388
|
-
* If we're here, it means that the user's function has not returned
|
|
389
|
-
* a value, but also has not used step tooling. This is a valid
|
|
390
|
-
* state, indicating that the function is a single-action async
|
|
391
|
-
* function.
|
|
392
|
-
*
|
|
393
|
-
* We should wait for the result and return it.
|
|
394
|
-
*
|
|
395
|
-
* A caveat here is that the user could use step tooling later on,
|
|
396
|
-
* resulting in a mix of step and non-step logic. This is not something
|
|
397
|
-
* we want to support without an opt-in from the user, so we should
|
|
398
|
-
* throw if this is the case.
|
|
399
|
-
*/
|
|
400
|
-
state.nonStepFnDetected = true;
|
|
401
|
-
return ["complete", await userFnPromise];
|
|
350
|
+
return [
|
|
351
|
+
"run",
|
|
352
|
+
Object.assign(Object.assign(Object.assign({}, tickOpToOutgoing(userFnOp)), result), { op: types_1.StepOpCode.RunStep }),
|
|
353
|
+
];
|
|
402
354
|
}
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
355
|
+
/**
|
|
356
|
+
* Now we're here, we've memoised any function state and we know that this
|
|
357
|
+
* request was a discovery call to find out next steps.
|
|
358
|
+
*
|
|
359
|
+
* We've already given the user's function a lot of chance to register any
|
|
360
|
+
* more ops, so we can assume that this list of discovered ops is final.
|
|
361
|
+
*
|
|
362
|
+
* With that in mind, if this list is empty AND we haven't previously used
|
|
363
|
+
* any step tools, we can assume that the user's function is not one that'll
|
|
364
|
+
* be using step tooling, so we'll just wait for it to complete and return
|
|
365
|
+
* the result.
|
|
366
|
+
*
|
|
367
|
+
* An empty list while also using step tooling is a valid state when the end
|
|
368
|
+
* of a chain of promises is reached, so we MUST also check if step tooling
|
|
369
|
+
* has previously been used.
|
|
370
|
+
*/
|
|
371
|
+
if (!discoveredOps.length) {
|
|
372
|
+
const fnRet = await Promise.race([
|
|
373
|
+
userFnPromise.then((data) => ({ type: "complete", data })),
|
|
374
|
+
(0, promises_1.resolveNextTick)().then(() => ({ type: "incomplete" })),
|
|
375
|
+
]);
|
|
376
|
+
if (fnRet.type === "complete") {
|
|
377
|
+
/**
|
|
378
|
+
* The function has returned a value, so we should return this to
|
|
379
|
+
* Inngest. Doing this will cause the function to be marked as
|
|
380
|
+
* complete, so we should only do this if we're sure that all
|
|
381
|
+
* registered ops have been resolved.
|
|
382
|
+
*/
|
|
383
|
+
const allOpsFulfilled = Object.values(state.allFoundOps).every((op) => {
|
|
384
|
+
return op.fulfilled;
|
|
385
|
+
});
|
|
386
|
+
if (allOpsFulfilled) {
|
|
387
|
+
return ["complete", fnRet.data];
|
|
388
|
+
}
|
|
389
|
+
/**
|
|
390
|
+
* If we're here, it means that the user's function has returned a
|
|
391
|
+
* value but not all ops have been resolved. This might be intentional
|
|
392
|
+
* if they are purposefully pushing work to the background, but also
|
|
393
|
+
* might be unintentional and a bug in the user's code where they
|
|
394
|
+
* expected an order to be maintained.
|
|
395
|
+
*
|
|
396
|
+
* To be safe, we'll show a warning here to tell users that this might
|
|
397
|
+
* be unintentional, but otherwise carry on as normal.
|
|
398
|
+
*/
|
|
399
|
+
// TODO PrettyError
|
|
400
|
+
logger.warn(`Warning: Your "${this.name}" function has returned a value, but not all ops have been resolved, i.e. you have used step tooling without \`await\`. This may be intentional, but if you expect your ops to be resolved in order, you should \`await\` them. If you are knowingly leaving ops unresolved using \`.catch()\` or \`void\`, you can ignore this warning.`);
|
|
401
|
+
}
|
|
402
|
+
else if (!state.hasUsedTools) {
|
|
403
|
+
/**
|
|
404
|
+
* If we're here, it means that the user's function has not returned
|
|
405
|
+
* a value, but also has not used step tooling. This is a valid
|
|
406
|
+
* state, indicating that the function is a single-action async
|
|
407
|
+
* function.
|
|
408
|
+
*
|
|
409
|
+
* We should wait for the result and return it.
|
|
410
|
+
*
|
|
411
|
+
* A caveat here is that the user could use step tooling later on,
|
|
412
|
+
* resulting in a mix of step and non-step logic. This is not something
|
|
413
|
+
* we want to support without an opt-in from the user, so we should
|
|
414
|
+
* throw if this is the case.
|
|
415
|
+
*/
|
|
416
|
+
state.nonStepFnDetected = true;
|
|
417
|
+
const result = await userFnPromise;
|
|
418
|
+
return ["complete", result];
|
|
419
|
+
}
|
|
420
|
+
else {
|
|
421
|
+
/**
|
|
422
|
+
* If we're here, the user's function has not returned a value, has not
|
|
423
|
+
* reported any new, ops, but has also previously used step tools and
|
|
424
|
+
* successfully memoized state.
|
|
425
|
+
*
|
|
426
|
+
* This indicates that the user has mixed step and non-step logic, which
|
|
427
|
+
* is not something we want to support without an opt-in from the user.
|
|
428
|
+
*
|
|
429
|
+
* We should throw here to let the user know that this is not supported.
|
|
430
|
+
*
|
|
431
|
+
* We need to be careful, though; it's a valid state for a chain of
|
|
432
|
+
* promises to return no further actions, so we should only throw if
|
|
433
|
+
* this state is reached and there are no other pending steps.
|
|
434
|
+
*/
|
|
435
|
+
const hasOpsPending = Object.values(state.allFoundOps).some((op) => {
|
|
436
|
+
return op.fulfilled === false;
|
|
437
|
+
});
|
|
438
|
+
if (!hasOpsPending) {
|
|
439
|
+
throw new NonRetriableError_1.NonRetriableError((0, errors_1.functionStoppedRunningErr)(errors_1.ErrCode.ASYNC_DETECTED_AFTER_MEMOIZATION));
|
|
440
|
+
}
|
|
423
441
|
}
|
|
424
442
|
}
|
|
443
|
+
return ["discovery", discoveredOps];
|
|
444
|
+
}
|
|
445
|
+
finally {
|
|
446
|
+
await logger.flush();
|
|
425
447
|
}
|
|
426
|
-
return ["discovery", discoveredOps];
|
|
427
448
|
}
|
|
428
449
|
}
|
|
429
450
|
_InngestFunction_opts = new WeakMap(), _InngestFunction_trigger = new WeakMap(), _InngestFunction_fn = new WeakMap(), _InngestFunction_onFailureFn = new WeakMap(), _InngestFunction_client = new WeakMap(), _InngestFunction_instances = new WeakSet(), _InngestFunction_generateId = function _InngestFunction_generateId(prefix) {
|