@cadenza.io/service 1.24.6 → 1.25.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/dist/index.d.mts +488 -84
- package/dist/index.d.ts +488 -84
- package/dist/index.js +363 -91
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +363 -91
- package/dist/index.mjs.map +1 -1
- package/package.json +1 -1
package/dist/index.d.mts
CHANGED
|
@@ -442,6 +442,7 @@ declare class CadenzaService {
|
|
|
442
442
|
nodes: {
|
|
443
443
|
id: string;
|
|
444
444
|
routineExecId: string;
|
|
445
|
+
executionTraceId: string;
|
|
445
446
|
task: Task;
|
|
446
447
|
context: _cadenza_io_core.GraphContext;
|
|
447
448
|
layer: /*elided*/ any | undefined;
|
|
@@ -582,6 +583,7 @@ declare class CadenzaService {
|
|
|
582
583
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
583
584
|
id: string;
|
|
584
585
|
routineExecId: string;
|
|
586
|
+
executionTraceId: string;
|
|
585
587
|
task: Task;
|
|
586
588
|
context: _cadenza_io_core.GraphContext;
|
|
587
589
|
layer: /*elided*/ any | undefined;
|
|
@@ -715,6 +717,7 @@ declare class CadenzaService {
|
|
|
715
717
|
getIdenticalNodes(node: {
|
|
716
718
|
id: string;
|
|
717
719
|
routineExecId: string;
|
|
720
|
+
executionTraceId: string;
|
|
718
721
|
task: Task;
|
|
719
722
|
context: _cadenza_io_core.GraphContext;
|
|
720
723
|
layer: /*elided*/ any | undefined;
|
|
@@ -847,6 +850,7 @@ declare class CadenzaService {
|
|
|
847
850
|
}): {
|
|
848
851
|
id: string;
|
|
849
852
|
routineExecId: string;
|
|
853
|
+
executionTraceId: string;
|
|
850
854
|
task: Task;
|
|
851
855
|
context: _cadenza_io_core.GraphContext;
|
|
852
856
|
layer: /*elided*/ any | undefined;
|
|
@@ -983,6 +987,7 @@ declare class CadenzaService {
|
|
|
983
987
|
add(node: {
|
|
984
988
|
id: string;
|
|
985
989
|
routineExecId: string;
|
|
990
|
+
executionTraceId: string;
|
|
986
991
|
task: Task;
|
|
987
992
|
context: _cadenza_io_core.GraphContext;
|
|
988
993
|
layer: /*elided*/ any | undefined;
|
|
@@ -1131,6 +1136,7 @@ declare class CadenzaService {
|
|
|
1131
1136
|
visitNode(node: {
|
|
1132
1137
|
id: string;
|
|
1133
1138
|
routineExecId: string;
|
|
1139
|
+
executionTraceId: string;
|
|
1134
1140
|
task: Task;
|
|
1135
1141
|
context: _cadenza_io_core.GraphContext;
|
|
1136
1142
|
layer: /*elided*/ any | undefined;
|
|
@@ -1317,6 +1323,7 @@ declare class CadenzaService {
|
|
|
1317
1323
|
nodes: {
|
|
1318
1324
|
id: string;
|
|
1319
1325
|
routineExecId: string;
|
|
1326
|
+
executionTraceId: string;
|
|
1320
1327
|
task: Task;
|
|
1321
1328
|
context: _cadenza_io_core.GraphContext;
|
|
1322
1329
|
layer: /*elided*/ any | undefined;
|
|
@@ -1457,6 +1464,7 @@ declare class CadenzaService {
|
|
|
1457
1464
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
1458
1465
|
id: string;
|
|
1459
1466
|
routineExecId: string;
|
|
1467
|
+
executionTraceId: string;
|
|
1460
1468
|
task: Task;
|
|
1461
1469
|
context: _cadenza_io_core.GraphContext;
|
|
1462
1470
|
layer: /*elided*/ any | undefined;
|
|
@@ -1590,6 +1598,7 @@ declare class CadenzaService {
|
|
|
1590
1598
|
getIdenticalNodes(node: {
|
|
1591
1599
|
id: string;
|
|
1592
1600
|
routineExecId: string;
|
|
1601
|
+
executionTraceId: string;
|
|
1593
1602
|
task: Task;
|
|
1594
1603
|
context: _cadenza_io_core.GraphContext;
|
|
1595
1604
|
layer: /*elided*/ any | undefined;
|
|
@@ -1722,6 +1731,7 @@ declare class CadenzaService {
|
|
|
1722
1731
|
}): {
|
|
1723
1732
|
id: string;
|
|
1724
1733
|
routineExecId: string;
|
|
1734
|
+
executionTraceId: string;
|
|
1725
1735
|
task: Task;
|
|
1726
1736
|
context: _cadenza_io_core.GraphContext;
|
|
1727
1737
|
layer: /*elided*/ any | undefined;
|
|
@@ -1858,6 +1868,7 @@ declare class CadenzaService {
|
|
|
1858
1868
|
add(node: {
|
|
1859
1869
|
id: string;
|
|
1860
1870
|
routineExecId: string;
|
|
1871
|
+
executionTraceId: string;
|
|
1861
1872
|
task: Task;
|
|
1862
1873
|
context: _cadenza_io_core.GraphContext;
|
|
1863
1874
|
layer: /*elided*/ any | undefined;
|
|
@@ -2006,6 +2017,7 @@ declare class CadenzaService {
|
|
|
2006
2017
|
visitNode(node: {
|
|
2007
2018
|
id: string;
|
|
2008
2019
|
routineExecId: string;
|
|
2020
|
+
executionTraceId: string;
|
|
2009
2021
|
task: Task;
|
|
2010
2022
|
context: _cadenza_io_core.GraphContext;
|
|
2011
2023
|
layer: /*elided*/ any | undefined;
|
|
@@ -2193,6 +2205,7 @@ declare class CadenzaService {
|
|
|
2193
2205
|
nodes: {
|
|
2194
2206
|
id: string;
|
|
2195
2207
|
routineExecId: string;
|
|
2208
|
+
executionTraceId: string;
|
|
2196
2209
|
task: Task;
|
|
2197
2210
|
context: _cadenza_io_core.GraphContext;
|
|
2198
2211
|
layer: /*elided*/ any | undefined;
|
|
@@ -2333,6 +2346,7 @@ declare class CadenzaService {
|
|
|
2333
2346
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
2334
2347
|
id: string;
|
|
2335
2348
|
routineExecId: string;
|
|
2349
|
+
executionTraceId: string;
|
|
2336
2350
|
task: Task;
|
|
2337
2351
|
context: _cadenza_io_core.GraphContext;
|
|
2338
2352
|
layer: /*elided*/ any | undefined;
|
|
@@ -2466,6 +2480,7 @@ declare class CadenzaService {
|
|
|
2466
2480
|
getIdenticalNodes(node: {
|
|
2467
2481
|
id: string;
|
|
2468
2482
|
routineExecId: string;
|
|
2483
|
+
executionTraceId: string;
|
|
2469
2484
|
task: Task;
|
|
2470
2485
|
context: _cadenza_io_core.GraphContext;
|
|
2471
2486
|
layer: /*elided*/ any | undefined;
|
|
@@ -2598,6 +2613,7 @@ declare class CadenzaService {
|
|
|
2598
2613
|
}): {
|
|
2599
2614
|
id: string;
|
|
2600
2615
|
routineExecId: string;
|
|
2616
|
+
executionTraceId: string;
|
|
2601
2617
|
task: Task;
|
|
2602
2618
|
context: _cadenza_io_core.GraphContext;
|
|
2603
2619
|
layer: /*elided*/ any | undefined;
|
|
@@ -2734,6 +2750,7 @@ declare class CadenzaService {
|
|
|
2734
2750
|
add(node: {
|
|
2735
2751
|
id: string;
|
|
2736
2752
|
routineExecId: string;
|
|
2753
|
+
executionTraceId: string;
|
|
2737
2754
|
task: Task;
|
|
2738
2755
|
context: _cadenza_io_core.GraphContext;
|
|
2739
2756
|
layer: /*elided*/ any | undefined;
|
|
@@ -2882,6 +2899,7 @@ declare class CadenzaService {
|
|
|
2882
2899
|
visitNode(node: {
|
|
2883
2900
|
id: string;
|
|
2884
2901
|
routineExecId: string;
|
|
2902
|
+
executionTraceId: string;
|
|
2885
2903
|
task: Task;
|
|
2886
2904
|
context: _cadenza_io_core.GraphContext;
|
|
2887
2905
|
layer: /*elided*/ any | undefined;
|
|
@@ -3066,6 +3084,7 @@ declare class CadenzaService {
|
|
|
3066
3084
|
addNode(node: {
|
|
3067
3085
|
id: string;
|
|
3068
3086
|
routineExecId: string;
|
|
3087
|
+
executionTraceId: string;
|
|
3069
3088
|
task: Task;
|
|
3070
3089
|
context: _cadenza_io_core.GraphContext;
|
|
3071
3090
|
layer: {
|
|
@@ -3450,6 +3469,7 @@ declare class CadenzaService {
|
|
|
3450
3469
|
addNodes(nodes: {
|
|
3451
3470
|
id: string;
|
|
3452
3471
|
routineExecId: string;
|
|
3472
|
+
executionTraceId: string;
|
|
3453
3473
|
task: Task;
|
|
3454
3474
|
context: _cadenza_io_core.GraphContext;
|
|
3455
3475
|
layer: {
|
|
@@ -3837,6 +3857,7 @@ declare class CadenzaService {
|
|
|
3837
3857
|
nodes: {
|
|
3838
3858
|
id: string;
|
|
3839
3859
|
routineExecId: string;
|
|
3860
|
+
executionTraceId: string;
|
|
3840
3861
|
task: Task;
|
|
3841
3862
|
context: _cadenza_io_core.GraphContext;
|
|
3842
3863
|
layer: /*elided*/ any | undefined;
|
|
@@ -3977,6 +3998,7 @@ declare class CadenzaService {
|
|
|
3977
3998
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
3978
3999
|
id: string;
|
|
3979
4000
|
routineExecId: string;
|
|
4001
|
+
executionTraceId: string;
|
|
3980
4002
|
task: Task;
|
|
3981
4003
|
context: _cadenza_io_core.GraphContext;
|
|
3982
4004
|
layer: /*elided*/ any | undefined;
|
|
@@ -4110,6 +4132,7 @@ declare class CadenzaService {
|
|
|
4110
4132
|
getIdenticalNodes(node: {
|
|
4111
4133
|
id: string;
|
|
4112
4134
|
routineExecId: string;
|
|
4135
|
+
executionTraceId: string;
|
|
4113
4136
|
task: Task;
|
|
4114
4137
|
context: _cadenza_io_core.GraphContext;
|
|
4115
4138
|
layer: /*elided*/ any | undefined;
|
|
@@ -4242,6 +4265,7 @@ declare class CadenzaService {
|
|
|
4242
4265
|
}): {
|
|
4243
4266
|
id: string;
|
|
4244
4267
|
routineExecId: string;
|
|
4268
|
+
executionTraceId: string;
|
|
4245
4269
|
task: Task;
|
|
4246
4270
|
context: _cadenza_io_core.GraphContext;
|
|
4247
4271
|
layer: /*elided*/ any | undefined;
|
|
@@ -4378,6 +4402,7 @@ declare class CadenzaService {
|
|
|
4378
4402
|
add(node: {
|
|
4379
4403
|
id: string;
|
|
4380
4404
|
routineExecId: string;
|
|
4405
|
+
executionTraceId: string;
|
|
4381
4406
|
task: Task;
|
|
4382
4407
|
context: _cadenza_io_core.GraphContext;
|
|
4383
4408
|
layer: /*elided*/ any | undefined;
|
|
@@ -4526,6 +4551,7 @@ declare class CadenzaService {
|
|
|
4526
4551
|
visitNode(node: {
|
|
4527
4552
|
id: string;
|
|
4528
4553
|
routineExecId: string;
|
|
4554
|
+
executionTraceId: string;
|
|
4529
4555
|
task: Task;
|
|
4530
4556
|
context: _cadenza_io_core.GraphContext;
|
|
4531
4557
|
layer: /*elided*/ any | undefined;
|
|
@@ -4711,6 +4737,7 @@ declare class CadenzaService {
|
|
|
4711
4737
|
nodes: {
|
|
4712
4738
|
id: string;
|
|
4713
4739
|
routineExecId: string;
|
|
4740
|
+
executionTraceId: string;
|
|
4714
4741
|
task: Task;
|
|
4715
4742
|
context: _cadenza_io_core.GraphContext;
|
|
4716
4743
|
layer: /*elided*/ any | undefined;
|
|
@@ -4851,6 +4878,7 @@ declare class CadenzaService {
|
|
|
4851
4878
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
4852
4879
|
id: string;
|
|
4853
4880
|
routineExecId: string;
|
|
4881
|
+
executionTraceId: string;
|
|
4854
4882
|
task: Task;
|
|
4855
4883
|
context: _cadenza_io_core.GraphContext;
|
|
4856
4884
|
layer: /*elided*/ any | undefined;
|
|
@@ -4984,6 +5012,7 @@ declare class CadenzaService {
|
|
|
4984
5012
|
getIdenticalNodes(node: {
|
|
4985
5013
|
id: string;
|
|
4986
5014
|
routineExecId: string;
|
|
5015
|
+
executionTraceId: string;
|
|
4987
5016
|
task: Task;
|
|
4988
5017
|
context: _cadenza_io_core.GraphContext;
|
|
4989
5018
|
layer: /*elided*/ any | undefined;
|
|
@@ -5116,6 +5145,7 @@ declare class CadenzaService {
|
|
|
5116
5145
|
}): {
|
|
5117
5146
|
id: string;
|
|
5118
5147
|
routineExecId: string;
|
|
5148
|
+
executionTraceId: string;
|
|
5119
5149
|
task: Task;
|
|
5120
5150
|
context: _cadenza_io_core.GraphContext;
|
|
5121
5151
|
layer: /*elided*/ any | undefined;
|
|
@@ -5252,6 +5282,7 @@ declare class CadenzaService {
|
|
|
5252
5282
|
add(node: {
|
|
5253
5283
|
id: string;
|
|
5254
5284
|
routineExecId: string;
|
|
5285
|
+
executionTraceId: string;
|
|
5255
5286
|
task: Task;
|
|
5256
5287
|
context: _cadenza_io_core.GraphContext;
|
|
5257
5288
|
layer: /*elided*/ any | undefined;
|
|
@@ -5400,6 +5431,7 @@ declare class CadenzaService {
|
|
|
5400
5431
|
visitNode(node: {
|
|
5401
5432
|
id: string;
|
|
5402
5433
|
routineExecId: string;
|
|
5434
|
+
executionTraceId: string;
|
|
5403
5435
|
task: Task;
|
|
5404
5436
|
context: _cadenza_io_core.GraphContext;
|
|
5405
5437
|
layer: /*elided*/ any | undefined;
|
|
@@ -5590,6 +5622,7 @@ declare class CadenzaService {
|
|
|
5590
5622
|
nodes: {
|
|
5591
5623
|
id: string;
|
|
5592
5624
|
routineExecId: string;
|
|
5625
|
+
executionTraceId: string;
|
|
5593
5626
|
task: Task;
|
|
5594
5627
|
context: _cadenza_io_core.GraphContext;
|
|
5595
5628
|
layer: /*elided*/ any | undefined;
|
|
@@ -5730,6 +5763,7 @@ declare class CadenzaService {
|
|
|
5730
5763
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
5731
5764
|
id: string;
|
|
5732
5765
|
routineExecId: string;
|
|
5766
|
+
executionTraceId: string;
|
|
5733
5767
|
task: Task;
|
|
5734
5768
|
context: _cadenza_io_core.GraphContext;
|
|
5735
5769
|
layer: /*elided*/ any | undefined;
|
|
@@ -5863,6 +5897,7 @@ declare class CadenzaService {
|
|
|
5863
5897
|
getIdenticalNodes(node: {
|
|
5864
5898
|
id: string;
|
|
5865
5899
|
routineExecId: string;
|
|
5900
|
+
executionTraceId: string;
|
|
5866
5901
|
task: Task;
|
|
5867
5902
|
context: _cadenza_io_core.GraphContext;
|
|
5868
5903
|
layer: /*elided*/ any | undefined;
|
|
@@ -5995,6 +6030,7 @@ declare class CadenzaService {
|
|
|
5995
6030
|
}): {
|
|
5996
6031
|
id: string;
|
|
5997
6032
|
routineExecId: string;
|
|
6033
|
+
executionTraceId: string;
|
|
5998
6034
|
task: Task;
|
|
5999
6035
|
context: _cadenza_io_core.GraphContext;
|
|
6000
6036
|
layer: /*elided*/ any | undefined;
|
|
@@ -6131,6 +6167,7 @@ declare class CadenzaService {
|
|
|
6131
6167
|
add(node: {
|
|
6132
6168
|
id: string;
|
|
6133
6169
|
routineExecId: string;
|
|
6170
|
+
executionTraceId: string;
|
|
6134
6171
|
task: Task;
|
|
6135
6172
|
context: _cadenza_io_core.GraphContext;
|
|
6136
6173
|
layer: /*elided*/ any | undefined;
|
|
@@ -6279,6 +6316,7 @@ declare class CadenzaService {
|
|
|
6279
6316
|
visitNode(node: {
|
|
6280
6317
|
id: string;
|
|
6281
6318
|
routineExecId: string;
|
|
6319
|
+
executionTraceId: string;
|
|
6282
6320
|
task: Task;
|
|
6283
6321
|
context: _cadenza_io_core.GraphContext;
|
|
6284
6322
|
layer: /*elided*/ any | undefined;
|
|
@@ -6465,6 +6503,7 @@ declare class CadenzaService {
|
|
|
6465
6503
|
nodes: {
|
|
6466
6504
|
id: string;
|
|
6467
6505
|
routineExecId: string;
|
|
6506
|
+
executionTraceId: string;
|
|
6468
6507
|
task: Task;
|
|
6469
6508
|
context: _cadenza_io_core.GraphContext;
|
|
6470
6509
|
layer: /*elided*/ any | undefined;
|
|
@@ -6605,6 +6644,7 @@ declare class CadenzaService {
|
|
|
6605
6644
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
6606
6645
|
id: string;
|
|
6607
6646
|
routineExecId: string;
|
|
6647
|
+
executionTraceId: string;
|
|
6608
6648
|
task: Task;
|
|
6609
6649
|
context: _cadenza_io_core.GraphContext;
|
|
6610
6650
|
layer: /*elided*/ any | undefined;
|
|
@@ -6738,6 +6778,7 @@ declare class CadenzaService {
|
|
|
6738
6778
|
getIdenticalNodes(node: {
|
|
6739
6779
|
id: string;
|
|
6740
6780
|
routineExecId: string;
|
|
6781
|
+
executionTraceId: string;
|
|
6741
6782
|
task: Task;
|
|
6742
6783
|
context: _cadenza_io_core.GraphContext;
|
|
6743
6784
|
layer: /*elided*/ any | undefined;
|
|
@@ -6870,6 +6911,7 @@ declare class CadenzaService {
|
|
|
6870
6911
|
}): {
|
|
6871
6912
|
id: string;
|
|
6872
6913
|
routineExecId: string;
|
|
6914
|
+
executionTraceId: string;
|
|
6873
6915
|
task: Task;
|
|
6874
6916
|
context: _cadenza_io_core.GraphContext;
|
|
6875
6917
|
layer: /*elided*/ any | undefined;
|
|
@@ -7006,6 +7048,7 @@ declare class CadenzaService {
|
|
|
7006
7048
|
add(node: {
|
|
7007
7049
|
id: string;
|
|
7008
7050
|
routineExecId: string;
|
|
7051
|
+
executionTraceId: string;
|
|
7009
7052
|
task: Task;
|
|
7010
7053
|
context: _cadenza_io_core.GraphContext;
|
|
7011
7054
|
layer: /*elided*/ any | undefined;
|
|
@@ -7154,6 +7197,7 @@ declare class CadenzaService {
|
|
|
7154
7197
|
visitNode(node: {
|
|
7155
7198
|
id: string;
|
|
7156
7199
|
routineExecId: string;
|
|
7200
|
+
executionTraceId: string;
|
|
7157
7201
|
task: Task;
|
|
7158
7202
|
context: _cadenza_io_core.GraphContext;
|
|
7159
7203
|
layer: /*elided*/ any | undefined;
|
|
@@ -7341,6 +7385,7 @@ declare class CadenzaService {
|
|
|
7341
7385
|
nodes: {
|
|
7342
7386
|
id: string;
|
|
7343
7387
|
routineExecId: string;
|
|
7388
|
+
executionTraceId: string;
|
|
7344
7389
|
task: Task;
|
|
7345
7390
|
context: _cadenza_io_core.GraphContext;
|
|
7346
7391
|
layer: /*elided*/ any | undefined;
|
|
@@ -7481,6 +7526,7 @@ declare class CadenzaService {
|
|
|
7481
7526
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
7482
7527
|
id: string;
|
|
7483
7528
|
routineExecId: string;
|
|
7529
|
+
executionTraceId: string;
|
|
7484
7530
|
task: Task;
|
|
7485
7531
|
context: _cadenza_io_core.GraphContext;
|
|
7486
7532
|
layer: /*elided*/ any | undefined;
|
|
@@ -7614,6 +7660,7 @@ declare class CadenzaService {
|
|
|
7614
7660
|
getIdenticalNodes(node: {
|
|
7615
7661
|
id: string;
|
|
7616
7662
|
routineExecId: string;
|
|
7663
|
+
executionTraceId: string;
|
|
7617
7664
|
task: Task;
|
|
7618
7665
|
context: _cadenza_io_core.GraphContext;
|
|
7619
7666
|
layer: /*elided*/ any | undefined;
|
|
@@ -7746,6 +7793,7 @@ declare class CadenzaService {
|
|
|
7746
7793
|
}): {
|
|
7747
7794
|
id: string;
|
|
7748
7795
|
routineExecId: string;
|
|
7796
|
+
executionTraceId: string;
|
|
7749
7797
|
task: Task;
|
|
7750
7798
|
context: _cadenza_io_core.GraphContext;
|
|
7751
7799
|
layer: /*elided*/ any | undefined;
|
|
@@ -7882,6 +7930,7 @@ declare class CadenzaService {
|
|
|
7882
7930
|
add(node: {
|
|
7883
7931
|
id: string;
|
|
7884
7932
|
routineExecId: string;
|
|
7933
|
+
executionTraceId: string;
|
|
7885
7934
|
task: Task;
|
|
7886
7935
|
context: _cadenza_io_core.GraphContext;
|
|
7887
7936
|
layer: /*elided*/ any | undefined;
|
|
@@ -8030,6 +8079,7 @@ declare class CadenzaService {
|
|
|
8030
8079
|
visitNode(node: {
|
|
8031
8080
|
id: string;
|
|
8032
8081
|
routineExecId: string;
|
|
8082
|
+
executionTraceId: string;
|
|
8033
8083
|
task: Task;
|
|
8034
8084
|
context: _cadenza_io_core.GraphContext;
|
|
8035
8085
|
layer: /*elided*/ any | undefined;
|
|
@@ -8214,6 +8264,7 @@ declare class CadenzaService {
|
|
|
8214
8264
|
addNode(node: {
|
|
8215
8265
|
id: string;
|
|
8216
8266
|
routineExecId: string;
|
|
8267
|
+
executionTraceId: string;
|
|
8217
8268
|
task: Task;
|
|
8218
8269
|
context: _cadenza_io_core.GraphContext;
|
|
8219
8270
|
layer: {
|
|
@@ -8598,6 +8649,7 @@ declare class CadenzaService {
|
|
|
8598
8649
|
addNodes(nodes: {
|
|
8599
8650
|
id: string;
|
|
8600
8651
|
routineExecId: string;
|
|
8652
|
+
executionTraceId: string;
|
|
8601
8653
|
task: Task;
|
|
8602
8654
|
context: _cadenza_io_core.GraphContext;
|
|
8603
8655
|
layer: {
|
|
@@ -8985,6 +9037,7 @@ declare class CadenzaService {
|
|
|
8985
9037
|
nodes: {
|
|
8986
9038
|
id: string;
|
|
8987
9039
|
routineExecId: string;
|
|
9040
|
+
executionTraceId: string;
|
|
8988
9041
|
task: Task;
|
|
8989
9042
|
context: _cadenza_io_core.GraphContext;
|
|
8990
9043
|
layer: /*elided*/ any | undefined;
|
|
@@ -9125,6 +9178,7 @@ declare class CadenzaService {
|
|
|
9125
9178
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
9126
9179
|
id: string;
|
|
9127
9180
|
routineExecId: string;
|
|
9181
|
+
executionTraceId: string;
|
|
9128
9182
|
task: Task;
|
|
9129
9183
|
context: _cadenza_io_core.GraphContext;
|
|
9130
9184
|
layer: /*elided*/ any | undefined;
|
|
@@ -9258,6 +9312,7 @@ declare class CadenzaService {
|
|
|
9258
9312
|
getIdenticalNodes(node: {
|
|
9259
9313
|
id: string;
|
|
9260
9314
|
routineExecId: string;
|
|
9315
|
+
executionTraceId: string;
|
|
9261
9316
|
task: Task;
|
|
9262
9317
|
context: _cadenza_io_core.GraphContext;
|
|
9263
9318
|
layer: /*elided*/ any | undefined;
|
|
@@ -9390,6 +9445,7 @@ declare class CadenzaService {
|
|
|
9390
9445
|
}): {
|
|
9391
9446
|
id: string;
|
|
9392
9447
|
routineExecId: string;
|
|
9448
|
+
executionTraceId: string;
|
|
9393
9449
|
task: Task;
|
|
9394
9450
|
context: _cadenza_io_core.GraphContext;
|
|
9395
9451
|
layer: /*elided*/ any | undefined;
|
|
@@ -9526,6 +9582,7 @@ declare class CadenzaService {
|
|
|
9526
9582
|
add(node: {
|
|
9527
9583
|
id: string;
|
|
9528
9584
|
routineExecId: string;
|
|
9585
|
+
executionTraceId: string;
|
|
9529
9586
|
task: Task;
|
|
9530
9587
|
context: _cadenza_io_core.GraphContext;
|
|
9531
9588
|
layer: /*elided*/ any | undefined;
|
|
@@ -9674,6 +9731,7 @@ declare class CadenzaService {
|
|
|
9674
9731
|
visitNode(node: {
|
|
9675
9732
|
id: string;
|
|
9676
9733
|
routineExecId: string;
|
|
9734
|
+
executionTraceId: string;
|
|
9677
9735
|
task: Task;
|
|
9678
9736
|
context: _cadenza_io_core.GraphContext;
|
|
9679
9737
|
layer: /*elided*/ any | undefined;
|
|
@@ -9859,6 +9917,7 @@ declare class CadenzaService {
|
|
|
9859
9917
|
nodes: {
|
|
9860
9918
|
id: string;
|
|
9861
9919
|
routineExecId: string;
|
|
9920
|
+
executionTraceId: string;
|
|
9862
9921
|
task: Task;
|
|
9863
9922
|
context: _cadenza_io_core.GraphContext;
|
|
9864
9923
|
layer: /*elided*/ any | undefined;
|
|
@@ -9999,6 +10058,7 @@ declare class CadenzaService {
|
|
|
9999
10058
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
10000
10059
|
id: string;
|
|
10001
10060
|
routineExecId: string;
|
|
10061
|
+
executionTraceId: string;
|
|
10002
10062
|
task: Task;
|
|
10003
10063
|
context: _cadenza_io_core.GraphContext;
|
|
10004
10064
|
layer: /*elided*/ any | undefined;
|
|
@@ -10132,6 +10192,7 @@ declare class CadenzaService {
|
|
|
10132
10192
|
getIdenticalNodes(node: {
|
|
10133
10193
|
id: string;
|
|
10134
10194
|
routineExecId: string;
|
|
10195
|
+
executionTraceId: string;
|
|
10135
10196
|
task: Task;
|
|
10136
10197
|
context: _cadenza_io_core.GraphContext;
|
|
10137
10198
|
layer: /*elided*/ any | undefined;
|
|
@@ -10264,6 +10325,7 @@ declare class CadenzaService {
|
|
|
10264
10325
|
}): {
|
|
10265
10326
|
id: string;
|
|
10266
10327
|
routineExecId: string;
|
|
10328
|
+
executionTraceId: string;
|
|
10267
10329
|
task: Task;
|
|
10268
10330
|
context: _cadenza_io_core.GraphContext;
|
|
10269
10331
|
layer: /*elided*/ any | undefined;
|
|
@@ -10400,6 +10462,7 @@ declare class CadenzaService {
|
|
|
10400
10462
|
add(node: {
|
|
10401
10463
|
id: string;
|
|
10402
10464
|
routineExecId: string;
|
|
10465
|
+
executionTraceId: string;
|
|
10403
10466
|
task: Task;
|
|
10404
10467
|
context: _cadenza_io_core.GraphContext;
|
|
10405
10468
|
layer: /*elided*/ any | undefined;
|
|
@@ -10548,6 +10611,7 @@ declare class CadenzaService {
|
|
|
10548
10611
|
visitNode(node: {
|
|
10549
10612
|
id: string;
|
|
10550
10613
|
routineExecId: string;
|
|
10614
|
+
executionTraceId: string;
|
|
10551
10615
|
task: Task;
|
|
10552
10616
|
context: _cadenza_io_core.GraphContext;
|
|
10553
10617
|
layer: /*elided*/ any | undefined;
|
|
@@ -10733,6 +10797,7 @@ declare class CadenzaService {
|
|
|
10733
10797
|
addNode(node: {
|
|
10734
10798
|
id: string;
|
|
10735
10799
|
routineExecId: string;
|
|
10800
|
+
executionTraceId: string;
|
|
10736
10801
|
task: Task;
|
|
10737
10802
|
context: _cadenza_io_core.GraphContext;
|
|
10738
10803
|
layer: {
|
|
@@ -11125,6 +11190,7 @@ declare class CadenzaService {
|
|
|
11125
11190
|
nodes: {
|
|
11126
11191
|
id: string;
|
|
11127
11192
|
routineExecId: string;
|
|
11193
|
+
executionTraceId: string;
|
|
11128
11194
|
task: Task;
|
|
11129
11195
|
context: _cadenza_io_core.GraphContext;
|
|
11130
11196
|
layer: /*elided*/ any | undefined;
|
|
@@ -11265,6 +11331,7 @@ declare class CadenzaService {
|
|
|
11265
11331
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
11266
11332
|
id: string;
|
|
11267
11333
|
routineExecId: string;
|
|
11334
|
+
executionTraceId: string;
|
|
11268
11335
|
task: Task;
|
|
11269
11336
|
context: _cadenza_io_core.GraphContext;
|
|
11270
11337
|
layer: /*elided*/ any | undefined;
|
|
@@ -11398,6 +11465,7 @@ declare class CadenzaService {
|
|
|
11398
11465
|
getIdenticalNodes(node: {
|
|
11399
11466
|
id: string;
|
|
11400
11467
|
routineExecId: string;
|
|
11468
|
+
executionTraceId: string;
|
|
11401
11469
|
task: Task;
|
|
11402
11470
|
context: _cadenza_io_core.GraphContext;
|
|
11403
11471
|
layer: /*elided*/ any | undefined;
|
|
@@ -11530,6 +11598,7 @@ declare class CadenzaService {
|
|
|
11530
11598
|
}): {
|
|
11531
11599
|
id: string;
|
|
11532
11600
|
routineExecId: string;
|
|
11601
|
+
executionTraceId: string;
|
|
11533
11602
|
task: Task;
|
|
11534
11603
|
context: _cadenza_io_core.GraphContext;
|
|
11535
11604
|
layer: /*elided*/ any | undefined;
|
|
@@ -11666,6 +11735,7 @@ declare class CadenzaService {
|
|
|
11666
11735
|
add(node: {
|
|
11667
11736
|
id: string;
|
|
11668
11737
|
routineExecId: string;
|
|
11738
|
+
executionTraceId: string;
|
|
11669
11739
|
task: Task;
|
|
11670
11740
|
context: _cadenza_io_core.GraphContext;
|
|
11671
11741
|
layer: /*elided*/ any | undefined;
|
|
@@ -11814,6 +11884,7 @@ declare class CadenzaService {
|
|
|
11814
11884
|
visitNode(node: {
|
|
11815
11885
|
id: string;
|
|
11816
11886
|
routineExecId: string;
|
|
11887
|
+
executionTraceId: string;
|
|
11817
11888
|
task: Task;
|
|
11818
11889
|
context: _cadenza_io_core.GraphContext;
|
|
11819
11890
|
layer: /*elided*/ any | undefined;
|
|
@@ -12000,6 +12071,7 @@ declare class CadenzaService {
|
|
|
12000
12071
|
nodes: {
|
|
12001
12072
|
id: string;
|
|
12002
12073
|
routineExecId: string;
|
|
12074
|
+
executionTraceId: string;
|
|
12003
12075
|
task: Task;
|
|
12004
12076
|
context: _cadenza_io_core.GraphContext;
|
|
12005
12077
|
layer: /*elided*/ any | undefined;
|
|
@@ -12140,6 +12212,7 @@ declare class CadenzaService {
|
|
|
12140
12212
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
12141
12213
|
id: string;
|
|
12142
12214
|
routineExecId: string;
|
|
12215
|
+
executionTraceId: string;
|
|
12143
12216
|
task: Task;
|
|
12144
12217
|
context: _cadenza_io_core.GraphContext;
|
|
12145
12218
|
layer: /*elided*/ any | undefined;
|
|
@@ -12273,6 +12346,7 @@ declare class CadenzaService {
|
|
|
12273
12346
|
getIdenticalNodes(node: {
|
|
12274
12347
|
id: string;
|
|
12275
12348
|
routineExecId: string;
|
|
12349
|
+
executionTraceId: string;
|
|
12276
12350
|
task: Task;
|
|
12277
12351
|
context: _cadenza_io_core.GraphContext;
|
|
12278
12352
|
layer: /*elided*/ any | undefined;
|
|
@@ -12405,6 +12479,7 @@ declare class CadenzaService {
|
|
|
12405
12479
|
}): {
|
|
12406
12480
|
id: string;
|
|
12407
12481
|
routineExecId: string;
|
|
12482
|
+
executionTraceId: string;
|
|
12408
12483
|
task: Task;
|
|
12409
12484
|
context: _cadenza_io_core.GraphContext;
|
|
12410
12485
|
layer: /*elided*/ any | undefined;
|
|
@@ -12541,6 +12616,7 @@ declare class CadenzaService {
|
|
|
12541
12616
|
add(node: {
|
|
12542
12617
|
id: string;
|
|
12543
12618
|
routineExecId: string;
|
|
12619
|
+
executionTraceId: string;
|
|
12544
12620
|
task: Task;
|
|
12545
12621
|
context: _cadenza_io_core.GraphContext;
|
|
12546
12622
|
layer: /*elided*/ any | undefined;
|
|
@@ -12689,6 +12765,7 @@ declare class CadenzaService {
|
|
|
12689
12765
|
visitNode(node: {
|
|
12690
12766
|
id: string;
|
|
12691
12767
|
routineExecId: string;
|
|
12768
|
+
executionTraceId: string;
|
|
12692
12769
|
task: Task;
|
|
12693
12770
|
context: _cadenza_io_core.GraphContext;
|
|
12694
12771
|
layer: /*elided*/ any | undefined;
|
|
@@ -12876,6 +12953,7 @@ declare class CadenzaService {
|
|
|
12876
12953
|
nodes: {
|
|
12877
12954
|
id: string;
|
|
12878
12955
|
routineExecId: string;
|
|
12956
|
+
executionTraceId: string;
|
|
12879
12957
|
task: Task;
|
|
12880
12958
|
context: _cadenza_io_core.GraphContext;
|
|
12881
12959
|
layer: /*elided*/ any | undefined;
|
|
@@ -13016,6 +13094,7 @@ declare class CadenzaService {
|
|
|
13016
13094
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
13017
13095
|
id: string;
|
|
13018
13096
|
routineExecId: string;
|
|
13097
|
+
executionTraceId: string;
|
|
13019
13098
|
task: Task;
|
|
13020
13099
|
context: _cadenza_io_core.GraphContext;
|
|
13021
13100
|
layer: /*elided*/ any | undefined;
|
|
@@ -13149,6 +13228,7 @@ declare class CadenzaService {
|
|
|
13149
13228
|
getIdenticalNodes(node: {
|
|
13150
13229
|
id: string;
|
|
13151
13230
|
routineExecId: string;
|
|
13231
|
+
executionTraceId: string;
|
|
13152
13232
|
task: Task;
|
|
13153
13233
|
context: _cadenza_io_core.GraphContext;
|
|
13154
13234
|
layer: /*elided*/ any | undefined;
|
|
@@ -13281,6 +13361,7 @@ declare class CadenzaService {
|
|
|
13281
13361
|
}): {
|
|
13282
13362
|
id: string;
|
|
13283
13363
|
routineExecId: string;
|
|
13364
|
+
executionTraceId: string;
|
|
13284
13365
|
task: Task;
|
|
13285
13366
|
context: _cadenza_io_core.GraphContext;
|
|
13286
13367
|
layer: /*elided*/ any | undefined;
|
|
@@ -13417,6 +13498,7 @@ declare class CadenzaService {
|
|
|
13417
13498
|
add(node: {
|
|
13418
13499
|
id: string;
|
|
13419
13500
|
routineExecId: string;
|
|
13501
|
+
executionTraceId: string;
|
|
13420
13502
|
task: Task;
|
|
13421
13503
|
context: _cadenza_io_core.GraphContext;
|
|
13422
13504
|
layer: /*elided*/ any | undefined;
|
|
@@ -13565,6 +13647,7 @@ declare class CadenzaService {
|
|
|
13565
13647
|
visitNode(node: {
|
|
13566
13648
|
id: string;
|
|
13567
13649
|
routineExecId: string;
|
|
13650
|
+
executionTraceId: string;
|
|
13568
13651
|
task: Task;
|
|
13569
13652
|
context: _cadenza_io_core.GraphContext;
|
|
13570
13653
|
layer: /*elided*/ any | undefined;
|
|
@@ -13749,6 +13832,7 @@ declare class CadenzaService {
|
|
|
13749
13832
|
addNode(node: {
|
|
13750
13833
|
id: string;
|
|
13751
13834
|
routineExecId: string;
|
|
13835
|
+
executionTraceId: string;
|
|
13752
13836
|
task: Task;
|
|
13753
13837
|
context: _cadenza_io_core.GraphContext;
|
|
13754
13838
|
layer: {
|
|
@@ -14133,6 +14217,7 @@ declare class CadenzaService {
|
|
|
14133
14217
|
addNodes(nodes: {
|
|
14134
14218
|
id: string;
|
|
14135
14219
|
routineExecId: string;
|
|
14220
|
+
executionTraceId: string;
|
|
14136
14221
|
task: Task;
|
|
14137
14222
|
context: _cadenza_io_core.GraphContext;
|
|
14138
14223
|
layer: {
|
|
@@ -14520,6 +14605,7 @@ declare class CadenzaService {
|
|
|
14520
14605
|
nodes: {
|
|
14521
14606
|
id: string;
|
|
14522
14607
|
routineExecId: string;
|
|
14608
|
+
executionTraceId: string;
|
|
14523
14609
|
task: Task;
|
|
14524
14610
|
context: _cadenza_io_core.GraphContext;
|
|
14525
14611
|
layer: /*elided*/ any | undefined;
|
|
@@ -14660,6 +14746,7 @@ declare class CadenzaService {
|
|
|
14660
14746
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
14661
14747
|
id: string;
|
|
14662
14748
|
routineExecId: string;
|
|
14749
|
+
executionTraceId: string;
|
|
14663
14750
|
task: Task;
|
|
14664
14751
|
context: _cadenza_io_core.GraphContext;
|
|
14665
14752
|
layer: /*elided*/ any | undefined;
|
|
@@ -14793,6 +14880,7 @@ declare class CadenzaService {
|
|
|
14793
14880
|
getIdenticalNodes(node: {
|
|
14794
14881
|
id: string;
|
|
14795
14882
|
routineExecId: string;
|
|
14883
|
+
executionTraceId: string;
|
|
14796
14884
|
task: Task;
|
|
14797
14885
|
context: _cadenza_io_core.GraphContext;
|
|
14798
14886
|
layer: /*elided*/ any | undefined;
|
|
@@ -14925,6 +15013,7 @@ declare class CadenzaService {
|
|
|
14925
15013
|
}): {
|
|
14926
15014
|
id: string;
|
|
14927
15015
|
routineExecId: string;
|
|
15016
|
+
executionTraceId: string;
|
|
14928
15017
|
task: Task;
|
|
14929
15018
|
context: _cadenza_io_core.GraphContext;
|
|
14930
15019
|
layer: /*elided*/ any | undefined;
|
|
@@ -15061,6 +15150,7 @@ declare class CadenzaService {
|
|
|
15061
15150
|
add(node: {
|
|
15062
15151
|
id: string;
|
|
15063
15152
|
routineExecId: string;
|
|
15153
|
+
executionTraceId: string;
|
|
15064
15154
|
task: Task;
|
|
15065
15155
|
context: _cadenza_io_core.GraphContext;
|
|
15066
15156
|
layer: /*elided*/ any | undefined;
|
|
@@ -15209,6 +15299,7 @@ declare class CadenzaService {
|
|
|
15209
15299
|
visitNode(node: {
|
|
15210
15300
|
id: string;
|
|
15211
15301
|
routineExecId: string;
|
|
15302
|
+
executionTraceId: string;
|
|
15212
15303
|
task: Task;
|
|
15213
15304
|
context: _cadenza_io_core.GraphContext;
|
|
15214
15305
|
layer: /*elided*/ any | undefined;
|
|
@@ -15394,6 +15485,7 @@ declare class CadenzaService {
|
|
|
15394
15485
|
nodes: {
|
|
15395
15486
|
id: string;
|
|
15396
15487
|
routineExecId: string;
|
|
15488
|
+
executionTraceId: string;
|
|
15397
15489
|
task: Task;
|
|
15398
15490
|
context: _cadenza_io_core.GraphContext;
|
|
15399
15491
|
layer: /*elided*/ any | undefined;
|
|
@@ -15534,6 +15626,7 @@ declare class CadenzaService {
|
|
|
15534
15626
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
15535
15627
|
id: string;
|
|
15536
15628
|
routineExecId: string;
|
|
15629
|
+
executionTraceId: string;
|
|
15537
15630
|
task: Task;
|
|
15538
15631
|
context: _cadenza_io_core.GraphContext;
|
|
15539
15632
|
layer: /*elided*/ any | undefined;
|
|
@@ -15667,6 +15760,7 @@ declare class CadenzaService {
|
|
|
15667
15760
|
getIdenticalNodes(node: {
|
|
15668
15761
|
id: string;
|
|
15669
15762
|
routineExecId: string;
|
|
15763
|
+
executionTraceId: string;
|
|
15670
15764
|
task: Task;
|
|
15671
15765
|
context: _cadenza_io_core.GraphContext;
|
|
15672
15766
|
layer: /*elided*/ any | undefined;
|
|
@@ -15799,6 +15893,7 @@ declare class CadenzaService {
|
|
|
15799
15893
|
}): {
|
|
15800
15894
|
id: string;
|
|
15801
15895
|
routineExecId: string;
|
|
15896
|
+
executionTraceId: string;
|
|
15802
15897
|
task: Task;
|
|
15803
15898
|
context: _cadenza_io_core.GraphContext;
|
|
15804
15899
|
layer: /*elided*/ any | undefined;
|
|
@@ -15935,6 +16030,7 @@ declare class CadenzaService {
|
|
|
15935
16030
|
add(node: {
|
|
15936
16031
|
id: string;
|
|
15937
16032
|
routineExecId: string;
|
|
16033
|
+
executionTraceId: string;
|
|
15938
16034
|
task: Task;
|
|
15939
16035
|
context: _cadenza_io_core.GraphContext;
|
|
15940
16036
|
layer: /*elided*/ any | undefined;
|
|
@@ -16083,6 +16179,7 @@ declare class CadenzaService {
|
|
|
16083
16179
|
visitNode(node: {
|
|
16084
16180
|
id: string;
|
|
16085
16181
|
routineExecId: string;
|
|
16182
|
+
executionTraceId: string;
|
|
16086
16183
|
task: Task;
|
|
16087
16184
|
context: _cadenza_io_core.GraphContext;
|
|
16088
16185
|
layer: /*elided*/ any | undefined;
|
|
@@ -16273,6 +16370,7 @@ declare class CadenzaService {
|
|
|
16273
16370
|
nodes: {
|
|
16274
16371
|
id: string;
|
|
16275
16372
|
routineExecId: string;
|
|
16373
|
+
executionTraceId: string;
|
|
16276
16374
|
task: Task;
|
|
16277
16375
|
context: _cadenza_io_core.GraphContext;
|
|
16278
16376
|
layer: /*elided*/ any | undefined;
|
|
@@ -16413,6 +16511,7 @@ declare class CadenzaService {
|
|
|
16413
16511
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
16414
16512
|
id: string;
|
|
16415
16513
|
routineExecId: string;
|
|
16514
|
+
executionTraceId: string;
|
|
16416
16515
|
task: Task;
|
|
16417
16516
|
context: _cadenza_io_core.GraphContext;
|
|
16418
16517
|
layer: /*elided*/ any | undefined;
|
|
@@ -16546,6 +16645,7 @@ declare class CadenzaService {
|
|
|
16546
16645
|
getIdenticalNodes(node: {
|
|
16547
16646
|
id: string;
|
|
16548
16647
|
routineExecId: string;
|
|
16648
|
+
executionTraceId: string;
|
|
16549
16649
|
task: Task;
|
|
16550
16650
|
context: _cadenza_io_core.GraphContext;
|
|
16551
16651
|
layer: /*elided*/ any | undefined;
|
|
@@ -16678,6 +16778,7 @@ declare class CadenzaService {
|
|
|
16678
16778
|
}): {
|
|
16679
16779
|
id: string;
|
|
16680
16780
|
routineExecId: string;
|
|
16781
|
+
executionTraceId: string;
|
|
16681
16782
|
task: Task;
|
|
16682
16783
|
context: _cadenza_io_core.GraphContext;
|
|
16683
16784
|
layer: /*elided*/ any | undefined;
|
|
@@ -16814,6 +16915,7 @@ declare class CadenzaService {
|
|
|
16814
16915
|
add(node: {
|
|
16815
16916
|
id: string;
|
|
16816
16917
|
routineExecId: string;
|
|
16918
|
+
executionTraceId: string;
|
|
16817
16919
|
task: Task;
|
|
16818
16920
|
context: _cadenza_io_core.GraphContext;
|
|
16819
16921
|
layer: /*elided*/ any | undefined;
|
|
@@ -16962,6 +17064,7 @@ declare class CadenzaService {
|
|
|
16962
17064
|
visitNode(node: {
|
|
16963
17065
|
id: string;
|
|
16964
17066
|
routineExecId: string;
|
|
17067
|
+
executionTraceId: string;
|
|
16965
17068
|
task: Task;
|
|
16966
17069
|
context: _cadenza_io_core.GraphContext;
|
|
16967
17070
|
layer: /*elided*/ any | undefined;
|
|
@@ -17148,6 +17251,7 @@ declare class CadenzaService {
|
|
|
17148
17251
|
nodes: {
|
|
17149
17252
|
id: string;
|
|
17150
17253
|
routineExecId: string;
|
|
17254
|
+
executionTraceId: string;
|
|
17151
17255
|
task: Task;
|
|
17152
17256
|
context: _cadenza_io_core.GraphContext;
|
|
17153
17257
|
layer: /*elided*/ any | undefined;
|
|
@@ -17288,6 +17392,7 @@ declare class CadenzaService {
|
|
|
17288
17392
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
17289
17393
|
id: string;
|
|
17290
17394
|
routineExecId: string;
|
|
17395
|
+
executionTraceId: string;
|
|
17291
17396
|
task: Task;
|
|
17292
17397
|
context: _cadenza_io_core.GraphContext;
|
|
17293
17398
|
layer: /*elided*/ any | undefined;
|
|
@@ -17421,6 +17526,7 @@ declare class CadenzaService {
|
|
|
17421
17526
|
getIdenticalNodes(node: {
|
|
17422
17527
|
id: string;
|
|
17423
17528
|
routineExecId: string;
|
|
17529
|
+
executionTraceId: string;
|
|
17424
17530
|
task: Task;
|
|
17425
17531
|
context: _cadenza_io_core.GraphContext;
|
|
17426
17532
|
layer: /*elided*/ any | undefined;
|
|
@@ -17553,6 +17659,7 @@ declare class CadenzaService {
|
|
|
17553
17659
|
}): {
|
|
17554
17660
|
id: string;
|
|
17555
17661
|
routineExecId: string;
|
|
17662
|
+
executionTraceId: string;
|
|
17556
17663
|
task: Task;
|
|
17557
17664
|
context: _cadenza_io_core.GraphContext;
|
|
17558
17665
|
layer: /*elided*/ any | undefined;
|
|
@@ -17689,6 +17796,7 @@ declare class CadenzaService {
|
|
|
17689
17796
|
add(node: {
|
|
17690
17797
|
id: string;
|
|
17691
17798
|
routineExecId: string;
|
|
17799
|
+
executionTraceId: string;
|
|
17692
17800
|
task: Task;
|
|
17693
17801
|
context: _cadenza_io_core.GraphContext;
|
|
17694
17802
|
layer: /*elided*/ any | undefined;
|
|
@@ -17837,6 +17945,7 @@ declare class CadenzaService {
|
|
|
17837
17945
|
visitNode(node: {
|
|
17838
17946
|
id: string;
|
|
17839
17947
|
routineExecId: string;
|
|
17948
|
+
executionTraceId: string;
|
|
17840
17949
|
task: Task;
|
|
17841
17950
|
context: _cadenza_io_core.GraphContext;
|
|
17842
17951
|
layer: /*elided*/ any | undefined;
|
|
@@ -18024,6 +18133,7 @@ declare class CadenzaService {
|
|
|
18024
18133
|
nodes: {
|
|
18025
18134
|
id: string;
|
|
18026
18135
|
routineExecId: string;
|
|
18136
|
+
executionTraceId: string;
|
|
18027
18137
|
task: Task;
|
|
18028
18138
|
context: _cadenza_io_core.GraphContext;
|
|
18029
18139
|
layer: /*elided*/ any | undefined;
|
|
@@ -18164,6 +18274,7 @@ declare class CadenzaService {
|
|
|
18164
18274
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
18165
18275
|
id: string;
|
|
18166
18276
|
routineExecId: string;
|
|
18277
|
+
executionTraceId: string;
|
|
18167
18278
|
task: Task;
|
|
18168
18279
|
context: _cadenza_io_core.GraphContext;
|
|
18169
18280
|
layer: /*elided*/ any | undefined;
|
|
@@ -18297,6 +18408,7 @@ declare class CadenzaService {
|
|
|
18297
18408
|
getIdenticalNodes(node: {
|
|
18298
18409
|
id: string;
|
|
18299
18410
|
routineExecId: string;
|
|
18411
|
+
executionTraceId: string;
|
|
18300
18412
|
task: Task;
|
|
18301
18413
|
context: _cadenza_io_core.GraphContext;
|
|
18302
18414
|
layer: /*elided*/ any | undefined;
|
|
@@ -18429,6 +18541,7 @@ declare class CadenzaService {
|
|
|
18429
18541
|
}): {
|
|
18430
18542
|
id: string;
|
|
18431
18543
|
routineExecId: string;
|
|
18544
|
+
executionTraceId: string;
|
|
18432
18545
|
task: Task;
|
|
18433
18546
|
context: _cadenza_io_core.GraphContext;
|
|
18434
18547
|
layer: /*elided*/ any | undefined;
|
|
@@ -18565,6 +18678,7 @@ declare class CadenzaService {
|
|
|
18565
18678
|
add(node: {
|
|
18566
18679
|
id: string;
|
|
18567
18680
|
routineExecId: string;
|
|
18681
|
+
executionTraceId: string;
|
|
18568
18682
|
task: Task;
|
|
18569
18683
|
context: _cadenza_io_core.GraphContext;
|
|
18570
18684
|
layer: /*elided*/ any | undefined;
|
|
@@ -18713,6 +18827,7 @@ declare class CadenzaService {
|
|
|
18713
18827
|
visitNode(node: {
|
|
18714
18828
|
id: string;
|
|
18715
18829
|
routineExecId: string;
|
|
18830
|
+
executionTraceId: string;
|
|
18716
18831
|
task: Task;
|
|
18717
18832
|
context: _cadenza_io_core.GraphContext;
|
|
18718
18833
|
layer: /*elided*/ any | undefined;
|
|
@@ -18897,6 +19012,7 @@ declare class CadenzaService {
|
|
|
18897
19012
|
addNode(node: {
|
|
18898
19013
|
id: string;
|
|
18899
19014
|
routineExecId: string;
|
|
19015
|
+
executionTraceId: string;
|
|
18900
19016
|
task: Task;
|
|
18901
19017
|
context: _cadenza_io_core.GraphContext;
|
|
18902
19018
|
layer: {
|
|
@@ -19281,6 +19397,7 @@ declare class CadenzaService {
|
|
|
19281
19397
|
addNodes(nodes: {
|
|
19282
19398
|
id: string;
|
|
19283
19399
|
routineExecId: string;
|
|
19400
|
+
executionTraceId: string;
|
|
19284
19401
|
task: Task;
|
|
19285
19402
|
context: _cadenza_io_core.GraphContext;
|
|
19286
19403
|
layer: {
|
|
@@ -19668,6 +19785,7 @@ declare class CadenzaService {
|
|
|
19668
19785
|
nodes: {
|
|
19669
19786
|
id: string;
|
|
19670
19787
|
routineExecId: string;
|
|
19788
|
+
executionTraceId: string;
|
|
19671
19789
|
task: Task;
|
|
19672
19790
|
context: _cadenza_io_core.GraphContext;
|
|
19673
19791
|
layer: /*elided*/ any | undefined;
|
|
@@ -19808,6 +19926,7 @@ declare class CadenzaService {
|
|
|
19808
19926
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
19809
19927
|
id: string;
|
|
19810
19928
|
routineExecId: string;
|
|
19929
|
+
executionTraceId: string;
|
|
19811
19930
|
task: Task;
|
|
19812
19931
|
context: _cadenza_io_core.GraphContext;
|
|
19813
19932
|
layer: /*elided*/ any | undefined;
|
|
@@ -19941,6 +20060,7 @@ declare class CadenzaService {
|
|
|
19941
20060
|
getIdenticalNodes(node: {
|
|
19942
20061
|
id: string;
|
|
19943
20062
|
routineExecId: string;
|
|
20063
|
+
executionTraceId: string;
|
|
19944
20064
|
task: Task;
|
|
19945
20065
|
context: _cadenza_io_core.GraphContext;
|
|
19946
20066
|
layer: /*elided*/ any | undefined;
|
|
@@ -20073,6 +20193,7 @@ declare class CadenzaService {
|
|
|
20073
20193
|
}): {
|
|
20074
20194
|
id: string;
|
|
20075
20195
|
routineExecId: string;
|
|
20196
|
+
executionTraceId: string;
|
|
20076
20197
|
task: Task;
|
|
20077
20198
|
context: _cadenza_io_core.GraphContext;
|
|
20078
20199
|
layer: /*elided*/ any | undefined;
|
|
@@ -20209,6 +20330,7 @@ declare class CadenzaService {
|
|
|
20209
20330
|
add(node: {
|
|
20210
20331
|
id: string;
|
|
20211
20332
|
routineExecId: string;
|
|
20333
|
+
executionTraceId: string;
|
|
20212
20334
|
task: Task;
|
|
20213
20335
|
context: _cadenza_io_core.GraphContext;
|
|
20214
20336
|
layer: /*elided*/ any | undefined;
|
|
@@ -20357,6 +20479,7 @@ declare class CadenzaService {
|
|
|
20357
20479
|
visitNode(node: {
|
|
20358
20480
|
id: string;
|
|
20359
20481
|
routineExecId: string;
|
|
20482
|
+
executionTraceId: string;
|
|
20360
20483
|
task: Task;
|
|
20361
20484
|
context: _cadenza_io_core.GraphContext;
|
|
20362
20485
|
layer: /*elided*/ any | undefined;
|
|
@@ -20542,6 +20665,7 @@ declare class CadenzaService {
|
|
|
20542
20665
|
nodes: {
|
|
20543
20666
|
id: string;
|
|
20544
20667
|
routineExecId: string;
|
|
20668
|
+
executionTraceId: string;
|
|
20545
20669
|
task: Task;
|
|
20546
20670
|
context: _cadenza_io_core.GraphContext;
|
|
20547
20671
|
layer: /*elided*/ any | undefined;
|
|
@@ -20682,6 +20806,7 @@ declare class CadenzaService {
|
|
|
20682
20806
|
getNodesByRoutineExecId(routineExecId: string): {
|
|
20683
20807
|
id: string;
|
|
20684
20808
|
routineExecId: string;
|
|
20809
|
+
executionTraceId: string;
|
|
20685
20810
|
task: Task;
|
|
20686
20811
|
context: _cadenza_io_core.GraphContext;
|
|
20687
20812
|
layer: /*elided*/ any | undefined;
|
|
@@ -20815,6 +20940,7 @@ declare class CadenzaService {
|
|
|
20815
20940
|
getIdenticalNodes(node: {
|
|
20816
20941
|
id: string;
|
|
20817
20942
|
routineExecId: string;
|
|
20943
|
+
executionTraceId: string;
|
|
20818
20944
|
task: Task;
|
|
20819
20945
|
context: _cadenza_io_core.GraphContext;
|
|
20820
20946
|
layer: /*elided*/ any | undefined;
|
|
@@ -20947,6 +21073,7 @@ declare class CadenzaService {
|
|
|
20947
21073
|
}): {
|
|
20948
21074
|
id: string;
|
|
20949
21075
|
routineExecId: string;
|
|
21076
|
+
executionTraceId: string;
|
|
20950
21077
|
task: Task;
|
|
20951
21078
|
context: _cadenza_io_core.GraphContext;
|
|
20952
21079
|
layer: /*elided*/ any | undefined;
|
|
@@ -21083,6 +21210,7 @@ declare class CadenzaService {
|
|
|
21083
21210
|
add(node: {
|
|
21084
21211
|
id: string;
|
|
21085
21212
|
routineExecId: string;
|
|
21213
|
+
executionTraceId: string;
|
|
21086
21214
|
task: Task;
|
|
21087
21215
|
context: _cadenza_io_core.GraphContext;
|
|
21088
21216
|
layer: /*elided*/ any | undefined;
|
|
@@ -21231,6 +21359,7 @@ declare class CadenzaService {
|
|
|
21231
21359
|
visitNode(node: {
|
|
21232
21360
|
id: string;
|
|
21233
21361
|
routineExecId: string;
|
|
21362
|
+
executionTraceId: string;
|
|
21234
21363
|
task: Task;
|
|
21235
21364
|
context: _cadenza_io_core.GraphContext;
|
|
21236
21365
|
layer: /*elided*/ any | undefined;
|
|
@@ -21417,6 +21546,7 @@ declare class CadenzaService {
|
|
|
21417
21546
|
addNode(node: {
|
|
21418
21547
|
id: string;
|
|
21419
21548
|
routineExecId: string;
|
|
21549
|
+
executionTraceId: string;
|
|
21420
21550
|
task: Task;
|
|
21421
21551
|
context: _cadenza_io_core.GraphContext;
|
|
21422
21552
|
layer: {
|
|
@@ -21814,6 +21944,13 @@ declare class CadenzaService {
|
|
|
21814
21944
|
* @param {string} signal - The name of the event or signal to emit.
|
|
21815
21945
|
* @param {AnyObject} [data={}] - The data to be emitted along with the signal.
|
|
21816
21946
|
* @return {void} No return value.
|
|
21947
|
+
*
|
|
21948
|
+
* @example
|
|
21949
|
+
* This is meant to be used as a global event emitter.
|
|
21950
|
+
* If you want to emit an event from within a task, you can use the `emit` method provided to the task function. See {@link TaskFunction}.
|
|
21951
|
+
* ```ts
|
|
21952
|
+
* Cadenza.emit('main.my_event', { foo: 'bar' });
|
|
21953
|
+
* ```
|
|
21817
21954
|
*/
|
|
21818
21955
|
static emit(signal: string, data?: AnyObject): void;
|
|
21819
21956
|
/**
|
|
@@ -21822,10 +21959,24 @@ declare class CadenzaService {
|
|
|
21822
21959
|
* @param {Task | GraphRoutine} task - The task or graph routine to be executed.
|
|
21823
21960
|
* @param {AnyObject} context - The context within which the task will be executed.
|
|
21824
21961
|
* @return {void}
|
|
21962
|
+
*
|
|
21963
|
+
* @example
|
|
21964
|
+
* ```ts
|
|
21965
|
+
* const task = Cadenza.createTask('My task', (ctx) => {
|
|
21966
|
+
* console.log('My task executed with context:', ctx);
|
|
21967
|
+
* });
|
|
21968
|
+
*
|
|
21969
|
+
* Cadenza.run(task, { foo: 'bar' });
|
|
21970
|
+
*
|
|
21971
|
+
* const routine = Cadenza.createRoutine('My routine', [task], 'My routine description');
|
|
21972
|
+
*
|
|
21973
|
+
* Cadenza.run(routine, { foo: 'bar' });
|
|
21974
|
+
* ```
|
|
21825
21975
|
*/
|
|
21826
21976
|
static run(task: Task | GraphRoutine, context: AnyObject): void;
|
|
21827
21977
|
/**
|
|
21828
21978
|
* Logs a message with a specified log level and additional contextual data.
|
|
21979
|
+
* Records in the CadenzaDB when available.
|
|
21829
21980
|
*
|
|
21830
21981
|
* @param {string} message - The main message to be logged.
|
|
21831
21982
|
* @param {any} [data={}] - Additional data or metadata to include with the log.
|
|
@@ -21844,11 +21995,57 @@ declare class CadenzaService {
|
|
|
21844
21995
|
* @param {string|undefined} [serviceName] - The name of the service that the routine belongs to. This is optional and defaults to undefined.
|
|
21845
21996
|
* @param {TaskOptions} [options={}] - A configuration object for the task, allowing various properties such as concurrency, timeout, and retry settings to be customized.
|
|
21846
21997
|
* @return {DeputyTask} - A new DeputyTask instance initialized with the specified parameters.
|
|
21998
|
+
*
|
|
21999
|
+
* @example
|
|
22000
|
+
* Let's say we are writing the code for a Service called "Service1".
|
|
22001
|
+
* We also have an additional service called "Service2" with a routine called "My Routine".
|
|
22002
|
+
* A flow on Service1 depends on the result of "My Routine" on Service2.
|
|
22003
|
+
* We can create a deputy task for the routine using the following code:
|
|
22004
|
+
* ```ts
|
|
22005
|
+
* Cadenza.createDeputyTask("My Routine", "Service2").then(
|
|
22006
|
+
* Cadenza.createTask("Handle result", (ctx) => {
|
|
22007
|
+
* console.log("'Handle result' executed with context:", ctx);
|
|
22008
|
+
* }),
|
|
22009
|
+
* );
|
|
22010
|
+
* ```
|
|
22011
|
+
* Internally, this will send a request to an available "Service2" instance to execute the "My Routine" routine.
|
|
22012
|
+
* The deputy task will wait for the response and then execute the next task(s) in the chain.
|
|
22013
|
+
*
|
|
22014
|
+
* You can visualize the execution of the deputy task as follows:
|
|
22015
|
+
* ```
|
|
22016
|
+
* Service1 flow = [Deputy tasks for "My Routine"] -> ["Handle result"]
|
|
22017
|
+
* || A
|
|
22018
|
+
* V ||
|
|
22019
|
+
* Service2 flow = [[My Routine]]
|
|
22020
|
+
* ```
|
|
22021
|
+
*
|
|
22022
|
+
* Deputy tasks are useful for delegating flows to other services, allowing for parallel execution and load balancing.
|
|
22023
|
+
* But it creates tight coupling between the services, which may not be desirable in some cases.
|
|
22024
|
+
* In cases where an event on one service should simply trigger a flow on another service, without the need for a result,
|
|
22025
|
+
* it is recommended to use signals instead. Like this:
|
|
22026
|
+
*
|
|
22027
|
+
* Service1
|
|
22028
|
+
* ```ts
|
|
22029
|
+
* Cadenza.createTask("Generate event", (ctx, emit) => {
|
|
22030
|
+
* // Do something
|
|
22031
|
+
* emit("some.event");
|
|
22032
|
+
* });
|
|
22033
|
+
* ```
|
|
22034
|
+
*
|
|
22035
|
+
* Service2
|
|
22036
|
+
* ```ts
|
|
22037
|
+
* Cadenza.createTask("Handle event", (ctx) => {
|
|
22038
|
+
* console.log("Handle event executed with context:", ctx);
|
|
22039
|
+
* }).doOn("Service1.some.event");
|
|
22040
|
+
* ```
|
|
22041
|
+
*
|
|
22042
|
+
* Every time the "Generate event" task is executed, it will emit a signal "Service1.some.event" to one Service2 instance and trigger the "Handle event" task.
|
|
21847
22043
|
*/
|
|
21848
22044
|
static createDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
|
|
21849
22045
|
/**
|
|
21850
22046
|
* Creates a meta deputy task by setting the `isMeta` property in the options to true,
|
|
21851
22047
|
* and delegating task creation to the `createDeputyTask` method.
|
|
22048
|
+
* See {@link createDeputyTask} and {@link createMetaTask} for more information.
|
|
21852
22049
|
*
|
|
21853
22050
|
* @param {string} routineName - The name of the routine associated with the task.
|
|
21854
22051
|
* @param {string | undefined} [serviceName] - The optional name of the service associated with the task.
|
|
@@ -21856,39 +22053,20 @@ declare class CadenzaService {
|
|
|
21856
22053
|
* @return {DeputyTask} - The created meta deputy task.
|
|
21857
22054
|
*/
|
|
21858
22055
|
static createMetaDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
|
|
21859
|
-
/**
|
|
21860
|
-
* Creates a unique deputy task with the specified routine name, service name,
|
|
21861
|
-
* and optional task options. The uniqueness is ensured by setting the
|
|
21862
|
-
* `isUnique` property in the task options.
|
|
21863
|
-
*
|
|
21864
|
-
* @param {string} routineName - The name of the routine associated with the task.
|
|
21865
|
-
* @param {string | undefined} [serviceName] - The name of the service associated with the task. If undefined, no service name is used.
|
|
21866
|
-
* @param {TaskOptions} [options={}] - Additional configuration options for the task.
|
|
21867
|
-
* @return {*} - Returns the result of creating a deputy task with the provided parameters and unique configuration.
|
|
21868
|
-
*/
|
|
21869
|
-
static createUniqueDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
|
|
21870
|
-
/**
|
|
21871
|
-
* Creates a unique meta deputy task based on the provided routine name, service name, and options.
|
|
21872
|
-
* This method sets the task as a meta task and delegates the creation to the `createUniqueDeputyTask` method.
|
|
21873
|
-
*
|
|
21874
|
-
* @param {string} routineName - The routine name to associate with the meta deputy task.
|
|
21875
|
-
* @param {string | undefined} [serviceName] - The optional service name associated with the task.
|
|
21876
|
-
* @param {TaskOptions} [options] - Additional options to configure the task. Defaults to an empty options object.
|
|
21877
|
-
* @return {*} A unique meta deputy task created based on the given parameters.
|
|
21878
|
-
*/
|
|
21879
|
-
static createUniqueMetaDeputyTask(routineName: string, serviceName?: string | undefined, options?: TaskOptions): DeputyTask;
|
|
21880
22056
|
/**
|
|
21881
22057
|
* Creates a throttled deputy task with the specified parameters.
|
|
22058
|
+
* See {@link createThrottledTask} and {@link createDeputyTask} for more information.
|
|
21882
22059
|
*
|
|
21883
22060
|
* @param {string} routineName - The name of the routine to be executed.
|
|
21884
22061
|
* @param {string | undefined} [serviceName=undefined] - The name of the service, if applicable.
|
|
21885
22062
|
* @param {ThrottleTagGetter} [throttledIdGetter=() => "default"] - A function to get the throttled tag for the task.
|
|
21886
22063
|
* @param {TaskOptions} [options={}] - The options for task configuration, including concurrency and callbacks.
|
|
21887
|
-
* @return {
|
|
22064
|
+
* @return {DeputyTask} The created throttled deputy task.
|
|
21888
22065
|
*/
|
|
21889
22066
|
static createThrottledDeputyTask(routineName: string, serviceName?: string | undefined, throttledIdGetter?: ThrottleTagGetter, options?: TaskOptions): DeputyTask;
|
|
21890
22067
|
/**
|
|
21891
22068
|
* Creates a throttled deputy task with meta-task settings enabled.
|
|
22069
|
+
* See {@link createThrottledTask},{@link createDeputyTask} and {@link createMetaTask} for more information.
|
|
21892
22070
|
*
|
|
21893
22071
|
* @param {string} routineName - The name of the routine for which the task is being created.
|
|
21894
22072
|
* @param {string|undefined} [serviceName=undefined] - The name of the service associated with the task, or undefined if not applicable.
|
|
@@ -21900,6 +22078,7 @@ declare class CadenzaService {
|
|
|
21900
22078
|
/**
|
|
21901
22079
|
* Creates and configures a signal transmission task that handles the transmission
|
|
21902
22080
|
* of a specified signal to a target service with a set of customizable options.
|
|
22081
|
+
* This is only used for internal purposes and is not exposed to the business logic layer.
|
|
21903
22082
|
*
|
|
21904
22083
|
* @param {string} signalName - The name of the signal to be transmitted.
|
|
21905
22084
|
* @param {string} serviceName - The name of the target service to transmit the signal to.
|
|
@@ -22013,114 +22192,339 @@ declare class CadenzaService {
|
|
|
22013
22192
|
* @param {string} [description] - An optional description of what the task does.
|
|
22014
22193
|
* @param {TaskOptions} [options={}] - An optional configuration object specifying additional task options.
|
|
22015
22194
|
* @return {Task} - The created task instance.
|
|
22195
|
+
*
|
|
22196
|
+
* @example
|
|
22197
|
+
* You can use arrow functions to create tasks.
|
|
22198
|
+
* ```ts
|
|
22199
|
+
* const task = Cadenza.createTask('My task', (ctx) => {
|
|
22200
|
+
* console.log('My task executed with context:', ctx);
|
|
22201
|
+
* }, 'My task description');
|
|
22202
|
+
* ```
|
|
22203
|
+
*
|
|
22204
|
+
* You can also use named functions to create tasks.
|
|
22205
|
+
* This is the preferred way to create tasks since it allows for code inspection in the CadenzaUI.
|
|
22206
|
+
* ```ts
|
|
22207
|
+
* function myTask(ctx) {
|
|
22208
|
+
* console.log('My task executed with context:', ctx);
|
|
22209
|
+
* }
|
|
22210
|
+
*
|
|
22211
|
+
* const task = Cadenza.createTask('My task', myTask);
|
|
22212
|
+
* ```
|
|
22213
|
+
*
|
|
22214
|
+
* ** Use the TaskOptions object to configure the task. **
|
|
22215
|
+
*
|
|
22216
|
+
* With concurrency limit, timeout limit and retry settings.
|
|
22217
|
+
* ```ts
|
|
22218
|
+
* Cadenza.createTask('My task', (ctx) => {
|
|
22219
|
+
* console.log('My task executed with context:', ctx);
|
|
22220
|
+
* }, 'My task description', {
|
|
22221
|
+
* concurrency: 10,
|
|
22222
|
+
* timeout: 10000,
|
|
22223
|
+
* retryCount: 3,
|
|
22224
|
+
* retryDelay: 1000,
|
|
22225
|
+
* retryDelayFactor: 1.5,
|
|
22226
|
+
* });
|
|
22227
|
+
* ```
|
|
22228
|
+
*
|
|
22229
|
+
* You can specify the input and output context schemas for the task.
|
|
22230
|
+
* ```ts
|
|
22231
|
+
* Cadenza.createTask('My task', (ctx) => {
|
|
22232
|
+
* return { bar: 'foo' + ctx.foo };
|
|
22233
|
+
* }, 'My task description', {
|
|
22234
|
+
* inputContextSchema: {
|
|
22235
|
+
* type: 'object',
|
|
22236
|
+
* properties: {
|
|
22237
|
+
* foo: {
|
|
22238
|
+
* type: 'string',
|
|
22239
|
+
* },
|
|
22240
|
+
* },
|
|
22241
|
+
* required: ['foo'],
|
|
22242
|
+
* },
|
|
22243
|
+
* validateInputContext: true, // default is false
|
|
22244
|
+
* outputContextSchema: {
|
|
22245
|
+
* type: 'object',
|
|
22246
|
+
* properties: {
|
|
22247
|
+
* bar: {
|
|
22248
|
+
* type: 'string',
|
|
22249
|
+
* },
|
|
22250
|
+
* },
|
|
22251
|
+
* required: ['bar'],
|
|
22252
|
+
* },
|
|
22253
|
+
* validateOutputContext: true, // default is false
|
|
22254
|
+
* });
|
|
22255
|
+
* ```
|
|
22016
22256
|
*/
|
|
22017
22257
|
static createTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
|
|
22018
22258
|
/**
|
|
22019
|
-
* Creates a
|
|
22259
|
+
* Creates a meta task with the specified name, functionality, description, and options.
|
|
22260
|
+
* This is used for creating tasks that lives on the meta layer.
|
|
22261
|
+
* The meta layer is a special layer that is executed separately from the business logic layer and is used for extending Cadenzas core functionality.
|
|
22262
|
+
* See {@link Task} or {@link createTask} for more information.
|
|
22020
22263
|
*
|
|
22021
22264
|
* @param {string} name - The name of the meta task.
|
|
22022
22265
|
* @param {TaskFunction} func - The function to be executed by the meta task.
|
|
22023
22266
|
* @param {string} [description] - An optional description of the meta task.
|
|
22024
|
-
* @param {TaskOptions} [options={}] - Additional
|
|
22025
|
-
* @return {Task}
|
|
22267
|
+
* @param {TaskOptions} [options={}] - Additional optional task configuration. Automatically sets `isMeta` to true.
|
|
22268
|
+
* @return {Task} A task instance configured as a meta task.
|
|
22026
22269
|
*/
|
|
22027
22270
|
static createMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
|
|
22028
22271
|
/**
|
|
22029
|
-
* Creates a
|
|
22030
|
-
*
|
|
22272
|
+
* Creates a unique task by wrapping the provided task function with a uniqueness constraint.
|
|
22273
|
+
* Unique tasks are designed to execute once per execution ID, merging parents. This is useful for
|
|
22274
|
+
* tasks that require fan-in/joins after parallel branches.
|
|
22275
|
+
* See {@link Task} for more information.
|
|
22031
22276
|
* @param {string} name Unique identifier.
|
|
22032
22277
|
* @param {TaskFunction} func Function receiving joinedContexts as a list (context.joinedContexts).
|
|
22033
22278
|
* @param {string} [description] Optional description.
|
|
22034
22279
|
* @param {TaskOptions} [options={}] Optional task options.
|
|
22035
22280
|
* @returns {Task} The created UniqueTask.
|
|
22281
|
+
*
|
|
22282
|
+
* @example
|
|
22283
|
+
* ```ts
|
|
22284
|
+
* const splitTask = Cadenza.createTask('Split foos', function* (ctx) {
|
|
22285
|
+
* for (const foo of ctx.foos) {
|
|
22286
|
+
* yield { foo };
|
|
22287
|
+
* }
|
|
22288
|
+
* }, 'Splits a list of foos into multiple sub-branches');
|
|
22289
|
+
*
|
|
22290
|
+
* const processTask = Cadenza.createTask('Process foo', (ctx) => {
|
|
22291
|
+
* return { bar: 'foo' + ctx.foo };
|
|
22292
|
+
* }, 'Process a foo');
|
|
22293
|
+
*
|
|
22294
|
+
* const uniqueTask = Cadenza.createUniqueTask('Gather processed foos', (ctx) => {
|
|
22295
|
+
* // A unique task will always be provided with a list of contexts (ctx.joinedContexts) from its predecessors.
|
|
22296
|
+
* const processedFoos = ctx.joinedContexts.map((c) => c.bar);
|
|
22297
|
+
* return { foos: processedFoos };
|
|
22298
|
+
* }, 'Gathers together the processed foos.');
|
|
22299
|
+
*
|
|
22300
|
+
* splitTask.then(
|
|
22301
|
+
* processTask.then(
|
|
22302
|
+
* uniqueTask,
|
|
22303
|
+
* ),
|
|
22304
|
+
* );
|
|
22305
|
+
*
|
|
22306
|
+
* // Give the flow a name using a routine
|
|
22307
|
+
* Cadenza.createRoutine(
|
|
22308
|
+
* 'Process foos',
|
|
22309
|
+
* [splitTask],
|
|
22310
|
+
* 'Processes a list of foos'
|
|
22311
|
+
* ).doOn('main.received_foos'); // Subscribe to a signal
|
|
22312
|
+
*
|
|
22313
|
+
* // Trigger the flow from anywhere
|
|
22314
|
+
* Cadenza.emit('main.received_foos', { foos: ['foo1', 'foo2', 'foo3'] });
|
|
22315
|
+
* ```
|
|
22036
22316
|
*/
|
|
22037
22317
|
static createUniqueTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
|
|
22038
22318
|
/**
|
|
22039
|
-
* Creates a unique meta task with the
|
|
22319
|
+
* Creates a unique meta task with the specified name, function, description, and options.
|
|
22320
|
+
* See {@link createUniqueTask} and {@link createMetaTask} for more information.
|
|
22040
22321
|
*
|
|
22041
|
-
* @param {string} name - The
|
|
22042
|
-
* @param {TaskFunction} func - The function to
|
|
22043
|
-
* @param {string} [description] - An optional description of the task
|
|
22044
|
-
* @param {TaskOptions} [options={}] -
|
|
22045
|
-
* @return {Task}
|
|
22322
|
+
* @param {string} name - The name of the task to create.
|
|
22323
|
+
* @param {TaskFunction} func - The function to execute when the task is run.
|
|
22324
|
+
* @param {string} [description] - An optional description of the task.
|
|
22325
|
+
* @param {TaskOptions} [options={}] - Optional settings for the task. Defaults to an empty object. Automatically sets `isMeta` and `isUnique` to true.
|
|
22326
|
+
* @return {Task} The created unique meta task.
|
|
22046
22327
|
*/
|
|
22047
22328
|
static createUniqueMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions): Task;
|
|
22048
22329
|
/**
|
|
22049
|
-
* Creates a
|
|
22050
|
-
*
|
|
22051
|
-
* @
|
|
22052
|
-
*
|
|
22053
|
-
* @param {string}
|
|
22054
|
-
* @param {
|
|
22055
|
-
* @
|
|
22330
|
+
* Creates a throttled task with a concurrency limit of 1, ensuring that only one instance of the task can run at a time for a specific throttle tag.
|
|
22331
|
+
* This is useful for ensuring execution order and preventing race conditions.
|
|
22332
|
+
* See {@link Task} for more information.
|
|
22333
|
+
*
|
|
22334
|
+
* @param {string} name - The name of the task.
|
|
22335
|
+
* @param {TaskFunction} func - The function to be executed when the task runs.
|
|
22336
|
+
* @param {ThrottleTagGetter} [throttledIdGetter=() => "default"] - A function that generates a throttle tag identifier to group tasks for throttling.
|
|
22337
|
+
* @param {string} [description] - An optional description of the task.
|
|
22338
|
+
* @param {TaskOptions} [options={}] - Additional options to customize the task behavior.
|
|
22339
|
+
* @return {Task} The created throttled task.
|
|
22340
|
+
*
|
|
22341
|
+
* @example
|
|
22342
|
+
* ```ts
|
|
22343
|
+
* const task = Cadenza.createThrottledTask(
|
|
22344
|
+
* 'My task',
|
|
22345
|
+
* async (ctx) => {
|
|
22346
|
+
* await new Promise((resolve) => setTimeout(resolve, 1000));
|
|
22347
|
+
* console.log('My task executed with context:', ctx);
|
|
22348
|
+
* },
|
|
22349
|
+
* // Will throttle by the value of ctx.foo to make sure tasks with the same value are executed sequentially
|
|
22350
|
+
* (ctx) => ctx.foo,
|
|
22351
|
+
* );
|
|
22352
|
+
*
|
|
22353
|
+
* Cadenza.run(task, { foo: 'bar' }); // (First execution)
|
|
22354
|
+
* Cadenza.run(task, { foo: 'bar' }); // This will be executed after the first execution is finished
|
|
22355
|
+
* Cadenza.run(task, { foo: 'baz' }); // This will be executed in parallel with the first execution
|
|
22356
|
+
* ```
|
|
22056
22357
|
*/
|
|
22057
22358
|
static createThrottledTask(name: string, func: TaskFunction, throttledIdGetter?: ThrottleTagGetter, description?: string, options?: TaskOptions): Task;
|
|
22058
22359
|
/**
|
|
22059
|
-
* Creates
|
|
22060
|
-
*
|
|
22360
|
+
* Creates a throttled meta task with the specified configuration.
|
|
22361
|
+
* See {@link createThrottledTask} and {@link createMetaTask} for more information.
|
|
22061
22362
|
*
|
|
22062
|
-
* @param {string} name - The
|
|
22063
|
-
* @param {TaskFunction} func - The function to be executed
|
|
22064
|
-
* @param {ThrottleTagGetter}
|
|
22363
|
+
* @param {string} name - The name of the throttled meta task.
|
|
22364
|
+
* @param {TaskFunction} func - The task function to be executed.
|
|
22365
|
+
* @param {ThrottleTagGetter} throttledIdGetter - A function to retrieve the throttling identifier.
|
|
22065
22366
|
* @param {string} [description] - An optional description of the task.
|
|
22066
|
-
* @param {TaskOptions} [options={}] - Additional
|
|
22367
|
+
* @param {TaskOptions} [options={}] - Additional options for configuring the task.
|
|
22067
22368
|
* @return {Task} The created throttled meta task.
|
|
22068
22369
|
*/
|
|
22069
22370
|
static createThrottledMetaTask(name: string, func: TaskFunction, throttledIdGetter?: ThrottleTagGetter, description?: string, options?: TaskOptions): Task;
|
|
22070
22371
|
/**
|
|
22071
|
-
* Creates
|
|
22072
|
-
*
|
|
22073
|
-
* @
|
|
22074
|
-
*
|
|
22075
|
-
* @param {
|
|
22076
|
-
* @param {
|
|
22077
|
-
* @
|
|
22372
|
+
* Creates and returns a new debounced task with the specified parameters.
|
|
22373
|
+
* This is useful to prevent rapid execution of tasks that may be triggered by multiple events within a certain time frame.
|
|
22374
|
+
* See {@link DebounceTask} for more information.
|
|
22375
|
+
*
|
|
22376
|
+
* @param {string} name - The unique name of the task to be created.
|
|
22377
|
+
* @param {TaskFunction} func - The function to be executed by the task.
|
|
22378
|
+
* @param {string} [description] - An optional description of the task.
|
|
22379
|
+
* @param {number} [debounceTime=1000] - The debounce time in milliseconds to delay the execution of the task.
|
|
22380
|
+
* @param {TaskOptions & DebounceOptions} [options={}] - Additional configuration options for the task, including debounce behavior and other task properties.
|
|
22381
|
+
* @return {DebounceTask} A new instance of the DebounceTask with the specified configuration.
|
|
22382
|
+
*
|
|
22383
|
+
* @example
|
|
22384
|
+
* ```ts
|
|
22385
|
+
* const task = Cadenza.createDebounceTask(
|
|
22386
|
+
* 'My debounced task',
|
|
22387
|
+
* (ctx) => {
|
|
22388
|
+
* console.log('My task executed with context:', ctx);
|
|
22389
|
+
* },
|
|
22390
|
+
* 'My debounced task description',
|
|
22391
|
+
* 100, // Debounce time in milliseconds. Default is 1000
|
|
22392
|
+
* {
|
|
22393
|
+
* leading: false, // Should the first execution of a burst be executed immediately? Default is false
|
|
22394
|
+
* trailing: true, // Should the last execution of a burst be executed? Default is true
|
|
22395
|
+
* maxWait: 1000, // Maximum time in milliseconds to wait for the next execution. Default is 0
|
|
22396
|
+
* },
|
|
22397
|
+
* );
|
|
22398
|
+
*
|
|
22399
|
+
* Cadenza.run(task, { foo: 'bar' }); // This will not be executed
|
|
22400
|
+
* Cadenza.run(task, { foo: 'bar' }); // This will not be executed
|
|
22401
|
+
* Cadenza.run(task, { foo: 'baz' }); // This execution will be delayed by 100ms
|
|
22402
|
+
* ```
|
|
22078
22403
|
*/
|
|
22079
22404
|
static createDebounceTask(name: string, func: TaskFunction, description?: string, debounceTime?: number, options?: TaskOptions & DebounceOptions): DebounceTask;
|
|
22080
22405
|
/**
|
|
22081
|
-
* Creates a
|
|
22082
|
-
* @
|
|
22083
|
-
*
|
|
22084
|
-
* @param {string}
|
|
22085
|
-
* @param {
|
|
22086
|
-
* @param {
|
|
22087
|
-
* @
|
|
22406
|
+
* Creates a debounced meta task with the specified parameters.
|
|
22407
|
+
* See {@link createDebounceTask} and {@link createMetaTask} for more information.
|
|
22408
|
+
*
|
|
22409
|
+
* @param {string} name - The name of the task.
|
|
22410
|
+
* @param {TaskFunction} func - The function to be executed by the task.
|
|
22411
|
+
* @param {string} [description] - Optional description of the task.
|
|
22412
|
+
* @param {number} [debounceTime=1000] - The debounce delay in milliseconds.
|
|
22413
|
+
* @param {TaskOptions & DebounceOptions} [options={}] - Additional configuration options for the task.
|
|
22414
|
+
* @return {DebounceTask} Returns an instance of the debounced meta task.
|
|
22088
22415
|
*/
|
|
22089
22416
|
static createDebounceMetaTask(name: string, func: TaskFunction, description?: string, debounceTime?: number, options?: TaskOptions & DebounceOptions): DebounceTask;
|
|
22090
22417
|
/**
|
|
22091
|
-
* Creates an
|
|
22092
|
-
*
|
|
22093
|
-
*
|
|
22094
|
-
*
|
|
22095
|
-
* @
|
|
22096
|
-
*
|
|
22097
|
-
* @
|
|
22418
|
+
* Creates an ephemeral task with the specified configuration.
|
|
22419
|
+
* Ephemeral tasks are designed to self-destruct after execution or a certain condition is met.
|
|
22420
|
+
* This is useful for transient tasks such as resolving promises or performing cleanup operations.
|
|
22421
|
+
* They are not registered by default.
|
|
22422
|
+
* See {@link EphemeralTask} for more information.
|
|
22423
|
+
*
|
|
22424
|
+
* @param {string} name - The name of the task to be created.
|
|
22425
|
+
* @param {TaskFunction} func - The function that defines the logic of the task.
|
|
22426
|
+
* @param {string} [description] - An optional description of the task.
|
|
22427
|
+
* @param {TaskOptions & EphemeralTaskOptions} [options={}] - The configuration options for the task, including concurrency, timeouts, and retry policies.
|
|
22428
|
+
* @return {EphemeralTask} The created ephemeral task instance.
|
|
22429
|
+
*
|
|
22430
|
+
* @example
|
|
22431
|
+
* By default, ephemeral tasks are executed once and destroyed after execution.
|
|
22432
|
+
* ```ts
|
|
22433
|
+
* const task = Cadenza.createEphemeralTask('My ephemeral task', (ctx) => {
|
|
22434
|
+
* console.log('My task executed with context:', ctx);
|
|
22435
|
+
* });
|
|
22436
|
+
*
|
|
22437
|
+
* Cadenza.run(task); // Executes the task once and destroys it after execution
|
|
22438
|
+
* Cadenza.run(task); // Does nothing, since the task is destroyed
|
|
22439
|
+
* ```
|
|
22440
|
+
*
|
|
22441
|
+
* Use destroy condition to conditionally destroy the task
|
|
22442
|
+
* ```ts
|
|
22443
|
+
* const task = Cadenza.createEphemeralTask(
|
|
22444
|
+
* 'My ephemeral task',
|
|
22445
|
+
* (ctx) => {
|
|
22446
|
+
* console.log('My task executed with context:', ctx);
|
|
22447
|
+
* },
|
|
22448
|
+
* 'My ephemeral task description',
|
|
22449
|
+
* {
|
|
22450
|
+
* once: false, // Should the task be executed only once? Default is true
|
|
22451
|
+
* destroyCondition: (ctx) => ctx.foo > 10, // Should the task be destroyed after execution? Default is undefined
|
|
22452
|
+
* },
|
|
22453
|
+
* );
|
|
22454
|
+
*
|
|
22455
|
+
* Cadenza.run(task, { foo: 5 }); // The task will not be destroyed and can still be executed
|
|
22456
|
+
* Cadenza.run(task, { foo: 10 }); // The task will not be destroyed and can still be executed
|
|
22457
|
+
* Cadenza.run(task, { foo: 20 }); // The task will be destroyed after execution and cannot be executed anymore
|
|
22458
|
+
* Cadenza.run(task, { foo: 30 }); // This will not be executed
|
|
22459
|
+
* ```
|
|
22460
|
+
*
|
|
22461
|
+
* A practical use case for ephemeral tasks is to resolve a promise upon some external event.
|
|
22462
|
+
* ```ts
|
|
22463
|
+
* const task = Cadenza.createTask('Confirm something', (ctx, emit) => {
|
|
22464
|
+
* return new Promise((resolve) => {
|
|
22465
|
+
* ctx.foo = uuid();
|
|
22466
|
+
*
|
|
22467
|
+
* Cadenza.createEphemeralTask(`Resolve promise of ${ctx.foo}`, (c) => {
|
|
22468
|
+
* console.log('My task executed with context:', ctx);
|
|
22469
|
+
* resolve(c);
|
|
22470
|
+
* }).doOn(`socket.confirmation_received:${ctx.foo}`);
|
|
22471
|
+
*
|
|
22472
|
+
* emit('this_domain.confirmation_requested', ctx);
|
|
22473
|
+
* });
|
|
22474
|
+
* });
|
|
22475
|
+
* ```
|
|
22098
22476
|
*/
|
|
22099
22477
|
static createEphemeralTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions & EphemeralTaskOptions): EphemeralTask;
|
|
22100
22478
|
/**
|
|
22101
|
-
* Creates an
|
|
22102
|
-
*
|
|
22103
|
-
*
|
|
22104
|
-
* @param {
|
|
22105
|
-
* @param {
|
|
22106
|
-
* @param {
|
|
22107
|
-
* @
|
|
22479
|
+
* Creates an ephemeral meta task with the specified name, function, description, and options.
|
|
22480
|
+
* See {@link createEphemeralTask} and {@link createMetaTask} for more details.
|
|
22481
|
+
*
|
|
22482
|
+
* @param {string} name - The name of the task to be created.
|
|
22483
|
+
* @param {TaskFunction} func - The function to be executed as part of the task.
|
|
22484
|
+
* @param {string} [description] - An optional description of the task.
|
|
22485
|
+
* @param {TaskOptions & EphemeralTaskOptions} [options={}] - Additional options for configuring the task.
|
|
22486
|
+
* @return {EphemeralTask} The created ephemeral meta task.
|
|
22108
22487
|
*/
|
|
22109
22488
|
static createEphemeralMetaTask(name: string, func: TaskFunction, description?: string, options?: TaskOptions & EphemeralTaskOptions): EphemeralTask;
|
|
22110
22489
|
/**
|
|
22111
|
-
* Creates a
|
|
22112
|
-
*
|
|
22113
|
-
*
|
|
22114
|
-
* @
|
|
22115
|
-
*
|
|
22490
|
+
* Creates a new routine with the specified name, tasks, and an optional description.
|
|
22491
|
+
* Routines are named entry points to starting tasks and are registered in the GraphRegistry.
|
|
22492
|
+
* They are used to group tasks together and provide a high-level structure for organizing and managing the execution of a set of tasks.
|
|
22493
|
+
* See {@link GraphRoutine} for more information.
|
|
22494
|
+
*
|
|
22495
|
+
* @param {string} name - The name of the routine to create.
|
|
22496
|
+
* @param {Task[]} tasks - A list of tasks to include in the routine.
|
|
22497
|
+
* @param {string} [description=""] - An optional description for the routine.
|
|
22498
|
+
* @return {GraphRoutine} A new instance of the GraphRoutine containing the specified tasks and description.
|
|
22499
|
+
*
|
|
22500
|
+
* @example
|
|
22501
|
+
* ```ts
|
|
22502
|
+
* const task1 = Cadenza.createTask("Task 1", () => {});
|
|
22503
|
+
* const task2 = Cadenza.createTask("Task 2", () => {});
|
|
22504
|
+
*
|
|
22505
|
+
* task1.then(task2);
|
|
22506
|
+
*
|
|
22507
|
+
* const routine = Cadenza.createRoutine("Some routine", [task1]);
|
|
22508
|
+
*
|
|
22509
|
+
* Cadenza.run(routine);
|
|
22510
|
+
*
|
|
22511
|
+
* // Or, routines can be triggered by signals
|
|
22512
|
+
* routine.doOn("some.signal");
|
|
22513
|
+
*
|
|
22514
|
+
* Cadenza.emit("some.signal", {});
|
|
22515
|
+
* ```
|
|
22116
22516
|
*/
|
|
22117
22517
|
static createRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
|
|
22118
22518
|
/**
|
|
22119
|
-
* Creates a
|
|
22120
|
-
*
|
|
22121
|
-
*
|
|
22122
|
-
* @
|
|
22123
|
-
*
|
|
22519
|
+
* Creates a meta routine with a given name, tasks, and optional description.
|
|
22520
|
+
* Routines are named entry points to starting tasks and are registered in the GraphRegistry.
|
|
22521
|
+
* They are used to group tasks together and provide a high-level structure for organizing and managing the execution of a set of tasks.
|
|
22522
|
+
* See {@link GraphRoutine} and {@link createRoutine} for more information.
|
|
22523
|
+
*
|
|
22524
|
+
* @param {string} name - The name of the routine to be created.
|
|
22525
|
+
* @param {Task[]} tasks - An array of tasks that the routine will consist of.
|
|
22526
|
+
* @param {string} [description=""] - An optional description for the routine.
|
|
22527
|
+
* @return {GraphRoutine} A new instance of the `GraphRoutine` representing the created routine.
|
|
22124
22528
|
*/
|
|
22125
22529
|
static createMetaRoutine(name: string, tasks: Task[], description?: string): GraphRoutine;
|
|
22126
22530
|
static reset(): void;
|