@opencrvs/toolkit 2.1.0-rc.e773220 → 2.1.0-rc.eb366a1
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/application-config/index.js +210 -187
- package/dist/commons/api/router.d.ts +613 -20
- package/dist/commons/conditionals/conditionals.d.ts +6 -6
- package/dist/commons/conditionals/validate.d.ts +2 -1
- package/dist/commons/events/ActionConfig.d.ts +54 -0
- package/dist/commons/events/ActionDocument.d.ts +45 -7
- package/dist/commons/events/ActionInput.d.ts +26 -0
- package/dist/commons/events/ActionStatus.d.ts +14 -0
- package/dist/commons/events/ActionType.d.ts +6 -1
- package/dist/commons/events/AdvancedSearchConfig.d.ts +12 -0
- package/dist/commons/events/AuditLog.d.ts +2 -0
- package/dist/commons/events/CountryConfigQueryInput.d.ts +18 -0
- package/dist/commons/events/Draft.d.ts +2 -0
- package/dist/commons/events/EventDocument.d.ts +22 -0
- package/dist/commons/events/EventIndex.d.ts +5 -24
- package/dist/commons/events/EventMetadata.d.ts +2 -1
- package/dist/commons/events/FieldConfig.d.ts +10 -0
- package/dist/commons/events/Flag.d.ts +48 -0
- package/dist/commons/events/WorkqueueColumnConfig.d.ts +4 -4
- package/dist/commons/events/WorkqueueConfig.d.ts +25 -7
- package/dist/commons/events/scopes.d.ts +1 -0
- package/dist/commons/events/test.utils.d.ts +9 -1
- package/dist/commons/events/utils.d.ts +23 -1
- package/dist/conditionals/index.js +305 -55
- package/dist/events/index.js +3261 -3141
- package/dist/notification/index.js +1481 -882
- package/dist/scopes/index.d.ts +257 -1
- package/dist/scopes/index.js +306 -55
- package/opencrvs-toolkit-2.1.0-rc.eb366a1.tgz +0 -0
- package/package.json +1 -1
- package/opencrvs-toolkit-2.1.0-rc.e773220.tgz +0 -0
|
@@ -47,14 +47,14 @@ function joinUrl(base, path) {
|
|
|
47
47
|
}
|
|
48
48
|
|
|
49
49
|
// ../commons/src/events/AuditLog.ts
|
|
50
|
-
var
|
|
50
|
+
var z8 = __toESM(require("zod/v4"));
|
|
51
51
|
|
|
52
52
|
// ../commons/src/authentication.ts
|
|
53
53
|
var import_jwt_decode = __toESM(require("jwt-decode"));
|
|
54
|
-
var
|
|
54
|
+
var z7 = __toESM(require("zod/v4"));
|
|
55
55
|
|
|
56
56
|
// ../commons/src/scopes.ts
|
|
57
|
-
var
|
|
57
|
+
var z6 = __toESM(require("zod/v4"));
|
|
58
58
|
var qs = __toESM(require("qs"));
|
|
59
59
|
|
|
60
60
|
// ../commons/src/uuid.ts
|
|
@@ -65,12 +65,264 @@ function getUUID() {
|
|
|
65
65
|
return (0, import_uuid.v4)();
|
|
66
66
|
}
|
|
67
67
|
|
|
68
|
+
// ../commons/src/events/ActionType.ts
|
|
69
|
+
var z2 = __toESM(require("zod/v4"));
|
|
70
|
+
var ActionType = {
|
|
71
|
+
// Pre-declaration actions
|
|
72
|
+
DELETE: "DELETE",
|
|
73
|
+
CREATE: "CREATE",
|
|
74
|
+
NOTIFY: "NOTIFY",
|
|
75
|
+
// Declaration actions
|
|
76
|
+
DECLARE: "DECLARE",
|
|
77
|
+
REGISTER: "REGISTER",
|
|
78
|
+
EDIT: "EDIT",
|
|
79
|
+
// Declaration system actions. Non-configurable.
|
|
80
|
+
DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
|
|
81
|
+
REJECT: "REJECT",
|
|
82
|
+
// REJECT_DECLARATION
|
|
83
|
+
MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
|
|
84
|
+
MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
|
|
85
|
+
ARCHIVE: "ARCHIVE",
|
|
86
|
+
UNARCHIVE: "UNARCHIVE",
|
|
87
|
+
// Record actions
|
|
88
|
+
PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
|
|
89
|
+
REQUEST_CORRECTION: "REQUEST_CORRECTION",
|
|
90
|
+
REJECT_CORRECTION: "REJECT_CORRECTION",
|
|
91
|
+
APPROVE_CORRECTION: "APPROVE_CORRECTION",
|
|
92
|
+
// General actions
|
|
93
|
+
READ: "READ",
|
|
94
|
+
ASSIGN: "ASSIGN",
|
|
95
|
+
UNASSIGN: "UNASSIGN",
|
|
96
|
+
// Custom action
|
|
97
|
+
CUSTOM: "CUSTOM"
|
|
98
|
+
};
|
|
99
|
+
var ConfirmableActions = [
|
|
100
|
+
ActionType.NOTIFY,
|
|
101
|
+
ActionType.DECLARE,
|
|
102
|
+
ActionType.EDIT,
|
|
103
|
+
ActionType.REGISTER,
|
|
104
|
+
ActionType.REJECT,
|
|
105
|
+
ActionType.ARCHIVE,
|
|
106
|
+
ActionType.UNARCHIVE,
|
|
107
|
+
ActionType.PRINT_CERTIFICATE,
|
|
108
|
+
ActionType.REQUEST_CORRECTION,
|
|
109
|
+
ActionType.APPROVE_CORRECTION,
|
|
110
|
+
ActionType.REJECT_CORRECTION,
|
|
111
|
+
ActionType.CUSTOM
|
|
112
|
+
];
|
|
113
|
+
var ActionTypes = z2.enum([
|
|
114
|
+
"DELETE",
|
|
115
|
+
"CREATE",
|
|
116
|
+
"NOTIFY",
|
|
117
|
+
"DECLARE",
|
|
118
|
+
"EDIT",
|
|
119
|
+
"REGISTER",
|
|
120
|
+
"DUPLICATE_DETECTED",
|
|
121
|
+
"REJECT",
|
|
122
|
+
"MARK_AS_DUPLICATE",
|
|
123
|
+
"MARK_AS_NOT_DUPLICATE",
|
|
124
|
+
"ARCHIVE",
|
|
125
|
+
"UNARCHIVE",
|
|
126
|
+
"PRINT_CERTIFICATE",
|
|
127
|
+
"REQUEST_CORRECTION",
|
|
128
|
+
"REJECT_CORRECTION",
|
|
129
|
+
"APPROVE_CORRECTION",
|
|
130
|
+
"READ",
|
|
131
|
+
"ASSIGN",
|
|
132
|
+
"UNASSIGN",
|
|
133
|
+
"CUSTOM"
|
|
134
|
+
]);
|
|
135
|
+
var ClientSpecificAction = {
|
|
136
|
+
REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
|
|
137
|
+
};
|
|
138
|
+
var declarationActionValues = [
|
|
139
|
+
ActionTypes.enum.DECLARE,
|
|
140
|
+
ActionTypes.enum.EDIT,
|
|
141
|
+
ActionTypes.enum.REGISTER,
|
|
142
|
+
ActionTypes.enum.NOTIFY,
|
|
143
|
+
ActionTypes.enum.DUPLICATE_DETECTED
|
|
144
|
+
];
|
|
145
|
+
var DeclarationActions = ActionTypes.extract(declarationActionValues);
|
|
146
|
+
var declarationUpdateActionValues = [
|
|
147
|
+
...declarationActionValues,
|
|
148
|
+
ActionTypes.enum.REQUEST_CORRECTION
|
|
149
|
+
];
|
|
150
|
+
var DeclarationUpdateActions = ActionTypes.extract(
|
|
151
|
+
declarationUpdateActionValues
|
|
152
|
+
);
|
|
153
|
+
var annotationActions = ActionTypes.exclude(declarationActionValues);
|
|
154
|
+
var writeActions = ActionTypes.exclude([
|
|
155
|
+
ActionType.CREATE,
|
|
156
|
+
ActionType.READ,
|
|
157
|
+
ActionType.ASSIGN,
|
|
158
|
+
ActionType.UNASSIGN
|
|
159
|
+
]);
|
|
160
|
+
var WorkqueueActionType = ActionTypes.extract([
|
|
161
|
+
ActionType.READ,
|
|
162
|
+
ActionType.DELETE,
|
|
163
|
+
ActionType.DECLARE,
|
|
164
|
+
ActionType.REGISTER,
|
|
165
|
+
ActionType.EDIT,
|
|
166
|
+
ActionType.REJECT,
|
|
167
|
+
ActionType.MARK_AS_DUPLICATE,
|
|
168
|
+
ActionType.ARCHIVE,
|
|
169
|
+
ActionType.UNARCHIVE,
|
|
170
|
+
ActionType.PRINT_CERTIFICATE,
|
|
171
|
+
ActionType.REQUEST_CORRECTION
|
|
172
|
+
]);
|
|
173
|
+
var META_ACTIONS = [
|
|
174
|
+
ActionType.ASSIGN,
|
|
175
|
+
ActionType.UNASSIGN,
|
|
176
|
+
ActionType.READ
|
|
177
|
+
];
|
|
178
|
+
function isMetaAction(actionType) {
|
|
179
|
+
return META_ACTIONS.includes(actionType);
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
// ../commons/src/events/ActionStatus.ts
|
|
183
|
+
var ActionStatus = {
|
|
184
|
+
Requested: "Requested",
|
|
185
|
+
Accepted: "Accepted",
|
|
186
|
+
Rejected: "Rejected"
|
|
187
|
+
};
|
|
188
|
+
|
|
189
|
+
// ../commons/src/events/Flag.ts
|
|
190
|
+
var z5 = __toESM(require("zod/v4"));
|
|
191
|
+
|
|
192
|
+
// ../commons/src/events/TranslationConfig.ts
|
|
193
|
+
var z3 = __toESM(require("zod/v4"));
|
|
194
|
+
var TranslationConfig = z3.object({
|
|
195
|
+
id: z3.string().describe(
|
|
196
|
+
"The identifier of the translation referred in translation CSV files"
|
|
197
|
+
),
|
|
198
|
+
defaultMessage: z3.string().describe("Default translation message"),
|
|
199
|
+
description: z3.string().describe(
|
|
200
|
+
"Describe the translation for a translator to be able to identify it."
|
|
201
|
+
)
|
|
202
|
+
}).meta({
|
|
203
|
+
description: "Translation configuration",
|
|
204
|
+
id: "TranslationConfig"
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
// ../commons/src/events/Conditional.ts
|
|
208
|
+
var z4 = __toESM(require("zod/v4"));
|
|
209
|
+
var Conditional = z4.any().describe("JSONSchema").meta({
|
|
210
|
+
description: "JSON schema conditional configuration",
|
|
211
|
+
id: "Conditional"
|
|
212
|
+
});
|
|
213
|
+
var ConditionalType = {
|
|
214
|
+
SHOW: "SHOW",
|
|
215
|
+
ENABLE: "ENABLE",
|
|
216
|
+
DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
|
|
217
|
+
};
|
|
218
|
+
var ShowConditional = z4.object({
|
|
219
|
+
type: z4.literal(ConditionalType.SHOW),
|
|
220
|
+
conditional: Conditional
|
|
221
|
+
}).describe(
|
|
222
|
+
"If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
|
|
223
|
+
);
|
|
224
|
+
var EnableConditional = z4.object({
|
|
225
|
+
type: z4.literal(ConditionalType.ENABLE),
|
|
226
|
+
conditional: Conditional
|
|
227
|
+
}).describe(
|
|
228
|
+
"If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
|
|
229
|
+
);
|
|
230
|
+
var ActionConditional = z4.discriminatedUnion("type", [
|
|
231
|
+
// Action can be shown / hidden
|
|
232
|
+
ShowConditional,
|
|
233
|
+
// Action can be shown to the user in the list but as disabled
|
|
234
|
+
EnableConditional
|
|
235
|
+
]).meta({
|
|
236
|
+
id: "ActionConditional",
|
|
237
|
+
description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
|
|
238
|
+
});
|
|
239
|
+
var DisplayOnReviewConditional = z4.object({
|
|
240
|
+
type: z4.literal(ConditionalType.DISPLAY_ON_REVIEW),
|
|
241
|
+
conditional: Conditional
|
|
242
|
+
}).describe(
|
|
243
|
+
"If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
|
|
244
|
+
);
|
|
245
|
+
var FieldConditional = z4.discriminatedUnion("type", [
|
|
246
|
+
// Field input can be shown / hidden
|
|
247
|
+
ShowConditional,
|
|
248
|
+
// Field input can be shown to the user but as disabled
|
|
249
|
+
EnableConditional,
|
|
250
|
+
// Field output can be shown / hidden on the review page
|
|
251
|
+
DisplayOnReviewConditional
|
|
252
|
+
]).meta({
|
|
253
|
+
id: "FieldConditional",
|
|
254
|
+
description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
// ../commons/src/events/Flag.ts
|
|
258
|
+
var InherentFlags = {
|
|
259
|
+
INCOMPLETE: "incomplete",
|
|
260
|
+
REJECTED: "rejected",
|
|
261
|
+
CORRECTION_REQUESTED: "correction-requested",
|
|
262
|
+
POTENTIAL_DUPLICATE: "potential-duplicate",
|
|
263
|
+
/**
|
|
264
|
+
* This flag is set by the Edit-action and removed after the declaration or registration.
|
|
265
|
+
* A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
|
|
266
|
+
*
|
|
267
|
+
* We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
|
|
268
|
+
*/
|
|
269
|
+
EDIT_IN_PROGRESS: "edit-in-progress",
|
|
270
|
+
SEALED: "sealed"
|
|
271
|
+
};
|
|
272
|
+
var actionFlagPattern;
|
|
273
|
+
function getActionFlagPattern() {
|
|
274
|
+
actionFlagPattern ??= new RegExp(
|
|
275
|
+
`^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
|
|
276
|
+
ActionStatus
|
|
277
|
+
).join("|").toLowerCase()})$`
|
|
278
|
+
);
|
|
279
|
+
return actionFlagPattern;
|
|
280
|
+
}
|
|
281
|
+
var ActionFlag = z5.string().refine((value) => getActionFlagPattern().test(value), {
|
|
282
|
+
message: "Flag must be in the format ActionType:ActionStatus (lowerCase)"
|
|
283
|
+
});
|
|
284
|
+
var CustomFlag = z5.string().refine((val) => !Object.values(InherentFlags).includes(val), {
|
|
285
|
+
message: `Custom flag cannot be one of the inherent flags: ${Object.values(
|
|
286
|
+
InherentFlags
|
|
287
|
+
).join(", ")}`
|
|
288
|
+
}).refine((val) => !ActionFlag.safeParse(val).success, {
|
|
289
|
+
message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
|
|
290
|
+
}).describe("Custom flag identifier defined by the country config.");
|
|
291
|
+
var Flag = ActionFlag.or(z5.enum(InherentFlags)).or(CustomFlag);
|
|
292
|
+
var ContainsFlags = z5.object({
|
|
293
|
+
anyOf: z5.array(Flag).optional(),
|
|
294
|
+
noneOf: z5.array(Flag).optional(),
|
|
295
|
+
allOf: z5.array(Flag).optional()
|
|
296
|
+
}).meta({
|
|
297
|
+
id: "ContainsFlags"
|
|
298
|
+
});
|
|
299
|
+
var FlagConfig = z5.object({
|
|
300
|
+
id: CustomFlag,
|
|
301
|
+
requiresAction: z5.boolean().describe(
|
|
302
|
+
"Indicates if this flag expects an action to be performed to be cleared."
|
|
303
|
+
),
|
|
304
|
+
label: TranslationConfig.describe("Human readable label of the flag.")
|
|
305
|
+
}).meta({
|
|
306
|
+
id: "FlagConfig",
|
|
307
|
+
description: "Configuration for a custom flag that can be added to or removed from records by event actions."
|
|
308
|
+
});
|
|
309
|
+
var ActionFlagConfig = z5.object({
|
|
310
|
+
id: Flag,
|
|
311
|
+
operation: z5.enum(["add", "remove"]).describe("Operation to perform on the flag."),
|
|
312
|
+
conditional: Conditional.optional().describe(
|
|
313
|
+
"When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
|
|
314
|
+
)
|
|
315
|
+
}).meta({
|
|
316
|
+
id: "ActionFlagConfig",
|
|
317
|
+
description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
|
|
318
|
+
});
|
|
319
|
+
|
|
68
320
|
// ../commons/src/scopes.ts
|
|
69
|
-
var JurisdictionFilter =
|
|
321
|
+
var JurisdictionFilter = z6.enum(["administrativeArea", "location", "all"]).describe(
|
|
70
322
|
"Filters based on user jurisdiction relative to their office location in hierarchy."
|
|
71
323
|
);
|
|
72
|
-
var UserFilter =
|
|
73
|
-
var RecordScopeTypeV2 =
|
|
324
|
+
var UserFilter = z6.enum(["user"]).describe("Filters based on the user. Limits to self.");
|
|
325
|
+
var RecordScopeTypeV2 = z6.enum([
|
|
74
326
|
"record.search",
|
|
75
327
|
"record.create",
|
|
76
328
|
"record.read",
|
|
@@ -79,6 +331,7 @@ var RecordScopeTypeV2 = z2.enum([
|
|
|
79
331
|
"record.edit",
|
|
80
332
|
"record.reject",
|
|
81
333
|
"record.archive",
|
|
334
|
+
"record.unarchive",
|
|
82
335
|
"record.review-duplicates",
|
|
83
336
|
"record.register",
|
|
84
337
|
"record.print-certified-copies",
|
|
@@ -87,7 +340,7 @@ var RecordScopeTypeV2 = z2.enum([
|
|
|
87
340
|
"record.unassign-others",
|
|
88
341
|
"record.custom-action"
|
|
89
342
|
]);
|
|
90
|
-
var PlainScopeType =
|
|
343
|
+
var PlainScopeType = z6.enum([
|
|
91
344
|
// Misc. system scopes
|
|
92
345
|
"bypassratelimit",
|
|
93
346
|
"record.reindex",
|
|
@@ -106,15 +359,15 @@ var PlainScopeType = z2.enum([
|
|
|
106
359
|
"record.confirm-registration",
|
|
107
360
|
"record.reject-registration"
|
|
108
361
|
]);
|
|
109
|
-
var scopeByEvent =
|
|
362
|
+
var scopeByEvent = z6.preprocess(
|
|
110
363
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
111
|
-
|
|
364
|
+
z6.array(z6.string()).optional()
|
|
112
365
|
).describe("Event type, e.g. birth, death");
|
|
113
|
-
var userRole =
|
|
366
|
+
var userRole = z6.preprocess(
|
|
114
367
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
115
|
-
|
|
368
|
+
z6.array(z6.string()).optional()
|
|
116
369
|
).describe("User role, e.g. admin, field agent");
|
|
117
|
-
var scopeOptionsPlaceEvent =
|
|
370
|
+
var scopeOptionsPlaceEvent = z6.object({
|
|
118
371
|
event: scopeByEvent,
|
|
119
372
|
placeOfEvent: JurisdictionFilter.optional()
|
|
120
373
|
}).describe("Options applicable to all record scopes.");
|
|
@@ -126,36 +379,37 @@ var scopeOptionsDeclaredOrNotified = scopeOptionsPlaceEvent.extend({
|
|
|
126
379
|
}).describe("Options applicable to actions that may take place after DECLARE");
|
|
127
380
|
var AllRecordScopeOptions = scopeOptionsDeclaredOrNotified.extend({
|
|
128
381
|
registeredIn: JurisdictionFilter.optional(),
|
|
129
|
-
registeredBy: UserFilter.optional()
|
|
382
|
+
registeredBy: UserFilter.optional(),
|
|
383
|
+
flags: ContainsFlags.optional()
|
|
130
384
|
}).describe(
|
|
131
385
|
"Options applicable to actions that may take place after REGISTER, with full filtering capabilities."
|
|
132
386
|
);
|
|
133
387
|
var CustomActionScopeOptions = AllRecordScopeOptions.extend({
|
|
134
|
-
customActionTypes:
|
|
388
|
+
customActionTypes: z6.preprocess(
|
|
135
389
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
136
|
-
|
|
390
|
+
z6.array(z6.string()).optional()
|
|
137
391
|
).describe("Allowed custom action types")
|
|
138
392
|
});
|
|
139
|
-
var AccessLevelOptions =
|
|
393
|
+
var AccessLevelOptions = z6.object({
|
|
140
394
|
accessLevel: JurisdictionFilter.optional()
|
|
141
395
|
});
|
|
142
396
|
var AllUserScopeOptions = AccessLevelOptions.extend({
|
|
143
397
|
role: userRole.optional()
|
|
144
398
|
});
|
|
145
|
-
var WorkqueueOrDashboardOptions =
|
|
146
|
-
ids:
|
|
399
|
+
var WorkqueueOrDashboardOptions = z6.object({
|
|
400
|
+
ids: z6.preprocess(
|
|
147
401
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
148
|
-
|
|
402
|
+
z6.array(z6.string())
|
|
149
403
|
).describe("Must contain a list of workqueue or dashboard ids.")
|
|
150
404
|
});
|
|
151
|
-
var AllScopeOptions =
|
|
405
|
+
var AllScopeOptions = z6.object({
|
|
152
406
|
...AllRecordScopeOptions.shape,
|
|
153
407
|
...AccessLevelOptions.shape,
|
|
154
408
|
...AllUserScopeOptions.shape,
|
|
155
409
|
...WorkqueueOrDashboardOptions.shape
|
|
156
410
|
});
|
|
157
411
|
var ScopeOptionKey = AllScopeOptions.keyof();
|
|
158
|
-
var ResolvedScopeOptionsPlaceEvent =
|
|
412
|
+
var ResolvedScopeOptionsPlaceEvent = z6.object({
|
|
159
413
|
event: scopeByEvent,
|
|
160
414
|
placeOfEvent: UUID.nullish()
|
|
161
415
|
}).describe(
|
|
@@ -163,15 +417,16 @@ var ResolvedScopeOptionsPlaceEvent = z2.object({
|
|
|
163
417
|
);
|
|
164
418
|
var ResolvedScopeOptionsDeclared = ResolvedScopeOptionsPlaceEvent.extend({
|
|
165
419
|
notifiedIn: UUID.nullish(),
|
|
166
|
-
notifiedBy:
|
|
420
|
+
notifiedBy: z6.string().optional(),
|
|
167
421
|
declaredIn: UUID.nullish(),
|
|
168
|
-
declaredBy:
|
|
422
|
+
declaredBy: z6.string().optional()
|
|
169
423
|
}).describe(
|
|
170
424
|
"Resolved options applicable to actions that may take place after DECLARE, with location ID and user ID instead of filters."
|
|
171
425
|
);
|
|
172
426
|
var ResolvedScopeOptionsFull = ResolvedScopeOptionsDeclared.extend({
|
|
173
427
|
registeredIn: UUID.nullish(),
|
|
174
|
-
registeredBy:
|
|
428
|
+
registeredBy: z6.string().optional(),
|
|
429
|
+
flags: ContainsFlags.optional()
|
|
175
430
|
}).describe(
|
|
176
431
|
"Resolved options applicable to actions that may take place after REGISTER, with full filtering capabilities and location/user IDs instead of filters."
|
|
177
432
|
);
|
|
@@ -184,6 +439,7 @@ var ScopesWithDeclaredOptions = RecordScopeTypeV2.extract([
|
|
|
184
439
|
"record.edit",
|
|
185
440
|
"record.reject",
|
|
186
441
|
"record.archive",
|
|
442
|
+
"record.unarchive",
|
|
187
443
|
"record.review-duplicates",
|
|
188
444
|
"record.register"
|
|
189
445
|
]);
|
|
@@ -195,38 +451,38 @@ var ScopesWithFullOptions = RecordScopeTypeV2.extract([
|
|
|
195
451
|
"record.unassign-others"
|
|
196
452
|
]);
|
|
197
453
|
var ScopeOptionsPrintCertifiedCopies = AllRecordScopeOptions.extend({
|
|
198
|
-
templates:
|
|
454
|
+
templates: z6.preprocess(
|
|
199
455
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
200
|
-
|
|
456
|
+
z6.array(z6.string()).optional()
|
|
201
457
|
).describe(
|
|
202
458
|
"Template IDs for certified copies. Controls which certificate templates are returned to the client via the config service. Certificate printing is a client-side operation \u2014 this option is not validated when the printCertificate action is submitted."
|
|
203
459
|
)
|
|
204
460
|
});
|
|
205
|
-
var RecordScopeV2 =
|
|
206
|
-
|
|
461
|
+
var RecordScopeV2 = z6.discriminatedUnion("type", [
|
|
462
|
+
z6.object({
|
|
207
463
|
type: ScopesWithPlaceEventOptions,
|
|
208
464
|
options: scopeOptionsPlaceEvent.optional()
|
|
209
465
|
}),
|
|
210
|
-
|
|
466
|
+
z6.object({
|
|
211
467
|
type: ScopesWithDeclaredOptions,
|
|
212
468
|
options: scopeOptionsDeclaredOrNotified.optional()
|
|
213
469
|
}),
|
|
214
|
-
|
|
470
|
+
z6.object({
|
|
215
471
|
type: ScopesWithFullOptions,
|
|
216
472
|
options: AllRecordScopeOptions.optional()
|
|
217
473
|
}),
|
|
218
|
-
|
|
219
|
-
type:
|
|
474
|
+
z6.object({
|
|
475
|
+
type: z6.literal("record.custom-action"),
|
|
220
476
|
options: CustomActionScopeOptions.optional()
|
|
221
477
|
}),
|
|
222
|
-
|
|
223
|
-
type:
|
|
478
|
+
z6.object({
|
|
479
|
+
type: z6.literal("record.print-certified-copies"),
|
|
224
480
|
options: ScopeOptionsPrintCertifiedCopies.optional()
|
|
225
481
|
})
|
|
226
482
|
]).describe(
|
|
227
483
|
"Scopes used to check user's permission to perform actions on a record."
|
|
228
484
|
);
|
|
229
|
-
var SystemScopeType =
|
|
485
|
+
var SystemScopeType = z6.enum([
|
|
230
486
|
"organisation.read-locations",
|
|
231
487
|
"user.read",
|
|
232
488
|
"user.create",
|
|
@@ -240,61 +496,61 @@ var UserScopeType = SystemScopeType.extract([
|
|
|
240
496
|
"user.search"
|
|
241
497
|
]);
|
|
242
498
|
var ScopesWithRoleOption = UserScopeType.extract(["user.edit", "user.create"]);
|
|
243
|
-
var UserScopeV2 =
|
|
244
|
-
|
|
499
|
+
var UserScopeV2 = z6.discriminatedUnion("type", [
|
|
500
|
+
z6.object({
|
|
245
501
|
type: ScopesWithRoleOption,
|
|
246
502
|
options: AllUserScopeOptions.optional()
|
|
247
503
|
}),
|
|
248
|
-
|
|
504
|
+
z6.object({
|
|
249
505
|
type: UserScopeType.extract(["user.read", "user.search"]),
|
|
250
506
|
options: AccessLevelOptions.optional()
|
|
251
507
|
})
|
|
252
508
|
]);
|
|
253
|
-
var ResolvedRecordScopeV2 =
|
|
254
|
-
|
|
509
|
+
var ResolvedRecordScopeV2 = z6.discriminatedUnion("type", [
|
|
510
|
+
z6.object({
|
|
255
511
|
type: ScopesWithPlaceEventOptions,
|
|
256
512
|
options: ResolvedScopeOptionsPlaceEvent.optional()
|
|
257
513
|
}),
|
|
258
|
-
|
|
514
|
+
z6.object({
|
|
259
515
|
type: ScopesWithDeclaredOptions,
|
|
260
516
|
options: ResolvedScopeOptionsDeclared.optional()
|
|
261
517
|
}),
|
|
262
|
-
|
|
518
|
+
z6.object({
|
|
263
519
|
type: ScopesWithFullOptions,
|
|
264
520
|
options: ResolvedScopeOptionsFull.optional()
|
|
265
521
|
}),
|
|
266
|
-
|
|
267
|
-
type:
|
|
522
|
+
z6.object({
|
|
523
|
+
type: z6.literal("record.print-certified-copies"),
|
|
268
524
|
options: ResolvedScopeOptionsFull.extend({
|
|
269
|
-
templates:
|
|
525
|
+
templates: z6.array(z6.string()).optional()
|
|
270
526
|
}).optional()
|
|
271
527
|
})
|
|
272
528
|
]).describe("Resolved scope with location/user IDs instead of filters.");
|
|
273
|
-
var Scope =
|
|
274
|
-
|
|
529
|
+
var Scope = z6.discriminatedUnion("type", [
|
|
530
|
+
z6.object({ type: PlainScopeType }),
|
|
275
531
|
...RecordScopeV2.options,
|
|
276
532
|
...UserScopeV2.options,
|
|
277
|
-
|
|
278
|
-
type:
|
|
533
|
+
z6.object({
|
|
534
|
+
type: z6.literal("organisation.read-locations"),
|
|
279
535
|
options: AccessLevelOptions.optional()
|
|
280
536
|
}),
|
|
281
|
-
|
|
282
|
-
type:
|
|
537
|
+
z6.object({
|
|
538
|
+
type: z6.literal("workqueue"),
|
|
283
539
|
options: WorkqueueOrDashboardOptions
|
|
284
540
|
}),
|
|
285
|
-
|
|
286
|
-
type:
|
|
541
|
+
z6.object({
|
|
542
|
+
type: z6.literal("dashboard.view"),
|
|
287
543
|
options: WorkqueueOrDashboardOptions
|
|
288
544
|
})
|
|
289
545
|
]);
|
|
290
|
-
var ScopeType =
|
|
546
|
+
var ScopeType = z6.enum([
|
|
291
547
|
...SystemScopeType.options,
|
|
292
548
|
...RecordScopeTypeV2.options,
|
|
293
549
|
...PlainScopeType.options,
|
|
294
550
|
"workqueue",
|
|
295
551
|
"dashboard.view"
|
|
296
552
|
]);
|
|
297
|
-
var EncodedScope =
|
|
553
|
+
var EncodedScope = z6.string().brand("EncodedScope");
|
|
298
554
|
var DEFAULT_SCOPE_OPTIONS = {
|
|
299
555
|
placeOfEvent: JurisdictionFilter.enum.all,
|
|
300
556
|
accessLevel: JurisdictionFilter.enum.all,
|
|
@@ -304,158 +560,51 @@ var DEFAULT_SCOPE_OPTIONS = {
|
|
|
304
560
|
};
|
|
305
561
|
|
|
306
562
|
// ../commons/src/authentication.ts
|
|
307
|
-
var TokenUserType =
|
|
308
|
-
var TokenWithBearer =
|
|
309
|
-
|
|
310
|
-
// ../commons/src/events/ActionType.ts
|
|
311
|
-
var z4 = __toESM(require("zod/v4"));
|
|
312
|
-
var ActionType = {
|
|
313
|
-
// Pre-declaration actions
|
|
314
|
-
DELETE: "DELETE",
|
|
315
|
-
CREATE: "CREATE",
|
|
316
|
-
NOTIFY: "NOTIFY",
|
|
317
|
-
// Declaration actions
|
|
318
|
-
DECLARE: "DECLARE",
|
|
319
|
-
REGISTER: "REGISTER",
|
|
320
|
-
EDIT: "EDIT",
|
|
321
|
-
// Declaration system actions. Non-configurable.
|
|
322
|
-
DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
|
|
323
|
-
REJECT: "REJECT",
|
|
324
|
-
// REJECT_DECLARATION
|
|
325
|
-
MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
|
|
326
|
-
MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
|
|
327
|
-
ARCHIVE: "ARCHIVE",
|
|
328
|
-
// Record actions
|
|
329
|
-
PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
|
|
330
|
-
REQUEST_CORRECTION: "REQUEST_CORRECTION",
|
|
331
|
-
REJECT_CORRECTION: "REJECT_CORRECTION",
|
|
332
|
-
APPROVE_CORRECTION: "APPROVE_CORRECTION",
|
|
333
|
-
// General actions
|
|
334
|
-
READ: "READ",
|
|
335
|
-
ASSIGN: "ASSIGN",
|
|
336
|
-
UNASSIGN: "UNASSIGN",
|
|
337
|
-
// Custom action
|
|
338
|
-
CUSTOM: "CUSTOM"
|
|
339
|
-
};
|
|
340
|
-
var ConfirmableActions = [
|
|
341
|
-
ActionType.NOTIFY,
|
|
342
|
-
ActionType.DECLARE,
|
|
343
|
-
ActionType.EDIT,
|
|
344
|
-
ActionType.REGISTER,
|
|
345
|
-
ActionType.REJECT,
|
|
346
|
-
ActionType.ARCHIVE,
|
|
347
|
-
ActionType.PRINT_CERTIFICATE,
|
|
348
|
-
ActionType.REQUEST_CORRECTION,
|
|
349
|
-
ActionType.APPROVE_CORRECTION,
|
|
350
|
-
ActionType.REJECT_CORRECTION,
|
|
351
|
-
ActionType.CUSTOM
|
|
352
|
-
];
|
|
353
|
-
var ActionTypes = z4.enum([
|
|
354
|
-
"DELETE",
|
|
355
|
-
"CREATE",
|
|
356
|
-
"NOTIFY",
|
|
357
|
-
"DECLARE",
|
|
358
|
-
"EDIT",
|
|
359
|
-
"REGISTER",
|
|
360
|
-
"DUPLICATE_DETECTED",
|
|
361
|
-
"REJECT",
|
|
362
|
-
"MARK_AS_DUPLICATE",
|
|
363
|
-
"MARK_AS_NOT_DUPLICATE",
|
|
364
|
-
"ARCHIVE",
|
|
365
|
-
"PRINT_CERTIFICATE",
|
|
366
|
-
"REQUEST_CORRECTION",
|
|
367
|
-
"REJECT_CORRECTION",
|
|
368
|
-
"APPROVE_CORRECTION",
|
|
369
|
-
"READ",
|
|
370
|
-
"ASSIGN",
|
|
371
|
-
"UNASSIGN",
|
|
372
|
-
"CUSTOM"
|
|
373
|
-
]);
|
|
374
|
-
var ClientSpecificAction = {
|
|
375
|
-
REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
|
|
376
|
-
};
|
|
377
|
-
var declarationActionValues = [
|
|
378
|
-
ActionTypes.enum.DECLARE,
|
|
379
|
-
ActionTypes.enum.EDIT,
|
|
380
|
-
ActionTypes.enum.REGISTER,
|
|
381
|
-
ActionTypes.enum.NOTIFY,
|
|
382
|
-
ActionTypes.enum.DUPLICATE_DETECTED
|
|
383
|
-
];
|
|
384
|
-
var DeclarationActions = ActionTypes.extract(declarationActionValues);
|
|
385
|
-
var declarationUpdateActionValues = [
|
|
386
|
-
...declarationActionValues,
|
|
387
|
-
ActionTypes.enum.REQUEST_CORRECTION
|
|
388
|
-
];
|
|
389
|
-
var DeclarationUpdateActions = ActionTypes.extract(
|
|
390
|
-
declarationUpdateActionValues
|
|
391
|
-
);
|
|
392
|
-
var annotationActions = ActionTypes.exclude(declarationActionValues);
|
|
393
|
-
var writeActions = ActionTypes.exclude([
|
|
394
|
-
ActionType.CREATE,
|
|
395
|
-
ActionType.READ,
|
|
396
|
-
ActionType.ASSIGN,
|
|
397
|
-
ActionType.UNASSIGN
|
|
398
|
-
]);
|
|
399
|
-
var WorkqueueActionType = ActionTypes.extract([
|
|
400
|
-
ActionType.READ,
|
|
401
|
-
ActionType.DELETE,
|
|
402
|
-
ActionType.DECLARE,
|
|
403
|
-
ActionType.REGISTER,
|
|
404
|
-
ActionType.EDIT,
|
|
405
|
-
ActionType.REJECT,
|
|
406
|
-
ActionType.MARK_AS_DUPLICATE,
|
|
407
|
-
ActionType.ARCHIVE,
|
|
408
|
-
ActionType.PRINT_CERTIFICATE,
|
|
409
|
-
ActionType.REQUEST_CORRECTION
|
|
410
|
-
]);
|
|
411
|
-
var META_ACTIONS = [
|
|
412
|
-
ActionType.ASSIGN,
|
|
413
|
-
ActionType.UNASSIGN,
|
|
414
|
-
ActionType.READ
|
|
415
|
-
];
|
|
563
|
+
var TokenUserType = z7.enum(["user", "system"]);
|
|
564
|
+
var TokenWithBearer = z7.string().regex(/^Bearer\s/);
|
|
416
565
|
|
|
417
566
|
// ../commons/src/events/AuditLog.ts
|
|
418
|
-
var AuditLogEntryBase =
|
|
419
|
-
id:
|
|
420
|
-
clientId:
|
|
567
|
+
var AuditLogEntryBase = z8.object({
|
|
568
|
+
id: z8.string(),
|
|
569
|
+
clientId: z8.string(),
|
|
421
570
|
clientType: TokenUserType,
|
|
422
|
-
createdAt:
|
|
571
|
+
createdAt: z8.string()
|
|
423
572
|
});
|
|
424
573
|
var EventCreateEntrySchema = AuditLogEntryBase.extend({
|
|
425
|
-
operation:
|
|
426
|
-
requestData:
|
|
427
|
-
transactionId:
|
|
428
|
-
type:
|
|
429
|
-
createdAtLocation:
|
|
574
|
+
operation: z8.literal("event.create"),
|
|
575
|
+
requestData: z8.object({
|
|
576
|
+
transactionId: z8.string(),
|
|
577
|
+
type: z8.string(),
|
|
578
|
+
createdAtLocation: z8.string().nullable()
|
|
430
579
|
}),
|
|
431
|
-
responseSummary:
|
|
432
|
-
eventId:
|
|
433
|
-
trackingId:
|
|
580
|
+
responseSummary: z8.object({
|
|
581
|
+
eventId: z8.string(),
|
|
582
|
+
trackingId: z8.string()
|
|
434
583
|
})
|
|
435
584
|
});
|
|
436
585
|
var EventGetEntrySchema = AuditLogEntryBase.extend({
|
|
437
|
-
operation:
|
|
438
|
-
requestData:
|
|
439
|
-
responseSummary:
|
|
440
|
-
eventType:
|
|
441
|
-
trackingId:
|
|
586
|
+
operation: z8.literal("event.get"),
|
|
587
|
+
requestData: z8.object({ eventId: z8.string() }),
|
|
588
|
+
responseSummary: z8.object({
|
|
589
|
+
eventType: z8.string(),
|
|
590
|
+
trackingId: z8.string()
|
|
442
591
|
})
|
|
443
592
|
});
|
|
444
593
|
var EventSearchEntrySchema = AuditLogEntryBase.extend({
|
|
445
|
-
operation:
|
|
446
|
-
clientType:
|
|
447
|
-
requestData:
|
|
448
|
-
query:
|
|
449
|
-
limit:
|
|
450
|
-
offset:
|
|
594
|
+
operation: z8.literal("event.search"),
|
|
595
|
+
clientType: z8.literal("system"),
|
|
596
|
+
requestData: z8.object({
|
|
597
|
+
query: z8.record(z8.string(), z8.unknown()).nullable(),
|
|
598
|
+
limit: z8.number().nullable(),
|
|
599
|
+
offset: z8.number().nullable()
|
|
451
600
|
}),
|
|
452
|
-
responseSummary:
|
|
453
|
-
total:
|
|
454
|
-
eventIds:
|
|
601
|
+
responseSummary: z8.object({
|
|
602
|
+
total: z8.number(),
|
|
603
|
+
eventIds: z8.array(z8.string())
|
|
455
604
|
})
|
|
456
605
|
});
|
|
457
606
|
var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
458
|
-
operation:
|
|
607
|
+
operation: z8.enum([
|
|
459
608
|
"event.actions.notify.request",
|
|
460
609
|
"event.actions.declare.request",
|
|
461
610
|
"event.actions.register.request",
|
|
@@ -466,6 +615,7 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
|
466
615
|
"event.actions.unassign.request",
|
|
467
616
|
"event.actions.read.request",
|
|
468
617
|
"event.actions.archive.request",
|
|
618
|
+
"event.actions.unarchive.request",
|
|
469
619
|
"event.actions.reinstate.request",
|
|
470
620
|
"event.actions.print_certificate.request",
|
|
471
621
|
"event.actions.correction.request.request",
|
|
@@ -474,83 +624,83 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
|
474
624
|
"event.actions.mark_as_duplicate.request",
|
|
475
625
|
"event.actions.mark_as_not_duplicate.request"
|
|
476
626
|
]),
|
|
477
|
-
requestData:
|
|
478
|
-
eventId:
|
|
479
|
-
actionType:
|
|
480
|
-
eventType:
|
|
481
|
-
trackingId:
|
|
482
|
-
transactionId:
|
|
627
|
+
requestData: z8.object({
|
|
628
|
+
eventId: z8.string(),
|
|
629
|
+
actionType: z8.string(),
|
|
630
|
+
eventType: z8.string(),
|
|
631
|
+
trackingId: z8.string(),
|
|
632
|
+
transactionId: z8.string()
|
|
483
633
|
})
|
|
484
634
|
});
|
|
485
635
|
var EventCustomActionEntrySchema = AuditLogEntryBase.extend({
|
|
486
|
-
operation:
|
|
487
|
-
requestData:
|
|
488
|
-
eventId:
|
|
489
|
-
actionType:
|
|
490
|
-
customAction:
|
|
491
|
-
eventType:
|
|
492
|
-
trackingId:
|
|
493
|
-
transactionId:
|
|
636
|
+
operation: z8.literal("event.actions.custom.request"),
|
|
637
|
+
requestData: z8.object({
|
|
638
|
+
eventId: z8.string(),
|
|
639
|
+
actionType: z8.literal(ActionType.CUSTOM),
|
|
640
|
+
customAction: z8.string(),
|
|
641
|
+
eventType: z8.string(),
|
|
642
|
+
trackingId: z8.string(),
|
|
643
|
+
transactionId: z8.string()
|
|
494
644
|
})
|
|
495
645
|
});
|
|
496
646
|
var IntegrationCreateEntrySchema = AuditLogEntryBase.extend({
|
|
497
|
-
operation:
|
|
498
|
-
requestData:
|
|
499
|
-
responseSummary:
|
|
647
|
+
operation: z8.literal("integrations.create"),
|
|
648
|
+
requestData: z8.object({ name: z8.string(), scopes: z8.array(z8.string()) }),
|
|
649
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
500
650
|
});
|
|
501
651
|
var IntegrationRefreshTokenEntrySchema = AuditLogEntryBase.extend({
|
|
502
|
-
operation:
|
|
503
|
-
requestData:
|
|
504
|
-
responseSummary:
|
|
652
|
+
operation: z8.literal("integrations.refreshToken"),
|
|
653
|
+
requestData: z8.object({ clientId: z8.string() }),
|
|
654
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
505
655
|
});
|
|
506
656
|
var IntegrationDeactivateEntrySchema = AuditLogEntryBase.extend({
|
|
507
|
-
operation:
|
|
508
|
-
requestData:
|
|
509
|
-
responseSummary:
|
|
657
|
+
operation: z8.literal("integrations.deactivate"),
|
|
658
|
+
requestData: z8.object({ id: z8.string() }),
|
|
659
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
510
660
|
});
|
|
511
661
|
var IntegrationActivateEntrySchema = AuditLogEntryBase.extend({
|
|
512
|
-
operation:
|
|
513
|
-
requestData:
|
|
514
|
-
responseSummary:
|
|
662
|
+
operation: z8.literal("integrations.activate"),
|
|
663
|
+
requestData: z8.object({ id: z8.string() }),
|
|
664
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
515
665
|
});
|
|
516
666
|
var IntegrationDeleteEntrySchema = AuditLogEntryBase.extend({
|
|
517
|
-
operation:
|
|
518
|
-
requestData:
|
|
519
|
-
responseSummary:
|
|
667
|
+
operation: z8.literal("integrations.delete"),
|
|
668
|
+
requestData: z8.object({ id: z8.string() }),
|
|
669
|
+
responseSummary: z8.object({ id: z8.string(), name: z8.string() })
|
|
520
670
|
});
|
|
521
671
|
var IntegrationRefreshSecretEntrySchema = AuditLogEntryBase.extend({
|
|
522
|
-
operation:
|
|
523
|
-
requestData:
|
|
524
|
-
responseSummary:
|
|
672
|
+
operation: z8.literal("integrations.refreshSecret"),
|
|
673
|
+
requestData: z8.object({ id: z8.string() }),
|
|
674
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
525
675
|
});
|
|
526
676
|
var AttachmentUploadEntrySchema = AuditLogEntryBase.extend({
|
|
527
|
-
operation:
|
|
528
|
-
requestData:
|
|
529
|
-
transactionId:
|
|
530
|
-
path:
|
|
677
|
+
operation: z8.literal("attachments.upload"),
|
|
678
|
+
requestData: z8.object({
|
|
679
|
+
transactionId: z8.string(),
|
|
680
|
+
path: z8.string().nullable()
|
|
531
681
|
}),
|
|
532
|
-
responseSummary:
|
|
682
|
+
responseSummary: z8.object({ fileUrl: z8.string() })
|
|
533
683
|
});
|
|
534
|
-
var subjectOnly =
|
|
535
|
-
var subjectWithReason =
|
|
536
|
-
subjectId:
|
|
537
|
-
reason:
|
|
538
|
-
comment:
|
|
684
|
+
var subjectOnly = z8.object({ subjectId: z8.string() });
|
|
685
|
+
var subjectWithReason = z8.object({
|
|
686
|
+
subjectId: z8.string(),
|
|
687
|
+
reason: z8.string(),
|
|
688
|
+
comment: z8.string().optional()
|
|
539
689
|
});
|
|
540
690
|
var UserCreateEntrySchema = AuditLogEntryBase.extend({
|
|
541
|
-
operation:
|
|
542
|
-
requestData:
|
|
543
|
-
subjectId:
|
|
544
|
-
role:
|
|
545
|
-
primaryOfficeId:
|
|
691
|
+
operation: z8.literal("user.create_user"),
|
|
692
|
+
requestData: z8.object({
|
|
693
|
+
subjectId: z8.string(),
|
|
694
|
+
role: z8.string(),
|
|
695
|
+
primaryOfficeId: z8.string()
|
|
546
696
|
})
|
|
547
697
|
});
|
|
548
698
|
var UserReasonEntrySchema = AuditLogEntryBase.extend({
|
|
549
|
-
operation:
|
|
699
|
+
operation: z8.enum(["user.deactivate", "user.reactivate"]),
|
|
550
700
|
requestData: subjectWithReason
|
|
551
701
|
});
|
|
552
702
|
var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
553
|
-
operation:
|
|
703
|
+
operation: z8.enum([
|
|
554
704
|
"user.edit_user",
|
|
555
705
|
"user.logged_in",
|
|
556
706
|
"user.logged_out",
|
|
@@ -564,14 +714,14 @@ var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
|
564
714
|
requestData: subjectOnly
|
|
565
715
|
});
|
|
566
716
|
var UserEmailChangedEntrySchema = AuditLogEntryBase.extend({
|
|
567
|
-
operation:
|
|
717
|
+
operation: z8.literal("user.email_address_changed"),
|
|
568
718
|
requestData: subjectOnly,
|
|
569
|
-
responseSummary:
|
|
719
|
+
responseSummary: z8.object({ email: z8.string() })
|
|
570
720
|
});
|
|
571
721
|
var UserPhoneChangedEntrySchema = AuditLogEntryBase.extend({
|
|
572
|
-
operation:
|
|
722
|
+
operation: z8.literal("user.phone_number_changed"),
|
|
573
723
|
requestData: subjectOnly,
|
|
574
|
-
responseSummary:
|
|
724
|
+
responseSummary: z8.object({ phoneNumber: z8.string() })
|
|
575
725
|
});
|
|
576
726
|
var userBaseOmit = {
|
|
577
727
|
id: true,
|
|
@@ -579,14 +729,14 @@ var userBaseOmit = {
|
|
|
579
729
|
clientType: true,
|
|
580
730
|
createdAt: true
|
|
581
731
|
};
|
|
582
|
-
var UserAuditRecordInput =
|
|
732
|
+
var UserAuditRecordInput = z8.discriminatedUnion("operation", [
|
|
583
733
|
UserCreateEntrySchema.omit(userBaseOmit),
|
|
584
734
|
UserReasonEntrySchema.omit(userBaseOmit),
|
|
585
735
|
UserSubjectOnlyEntrySchema.omit(userBaseOmit),
|
|
586
736
|
UserEmailChangedEntrySchema.omit(userBaseOmit),
|
|
587
737
|
UserPhoneChangedEntrySchema.omit(userBaseOmit)
|
|
588
738
|
]);
|
|
589
|
-
var AuditLogEntrySchema =
|
|
739
|
+
var AuditLogEntrySchema = z8.discriminatedUnion("operation", [
|
|
590
740
|
EventCreateEntrySchema,
|
|
591
741
|
EventGetEntrySchema,
|
|
592
742
|
EventSearchEntrySchema,
|
|
@@ -613,76 +763,11 @@ var CHILD_ONBOARDING_EVENT = "child-onboarding";
|
|
|
613
763
|
// ../commons/src/events/ActionConfig.ts
|
|
614
764
|
var z24 = __toESM(require("zod/v4"));
|
|
615
765
|
|
|
616
|
-
// ../commons/src/events/TranslationConfig.ts
|
|
617
|
-
var z6 = __toESM(require("zod/v4"));
|
|
618
|
-
var TranslationConfig = z6.object({
|
|
619
|
-
id: z6.string().describe(
|
|
620
|
-
"The identifier of the translation referred in translation CSV files"
|
|
621
|
-
),
|
|
622
|
-
defaultMessage: z6.string().describe("Default translation message"),
|
|
623
|
-
description: z6.string().describe(
|
|
624
|
-
"Describe the translation for a translator to be able to identify it."
|
|
625
|
-
)
|
|
626
|
-
}).meta({
|
|
627
|
-
description: "Translation configuration",
|
|
628
|
-
id: "TranslationConfig"
|
|
629
|
-
});
|
|
630
|
-
|
|
631
766
|
// ../commons/src/events/FieldConfig.ts
|
|
632
767
|
var import_v43 = __toESM(require("zod/v4"));
|
|
633
768
|
|
|
634
|
-
// ../commons/src/events/Conditional.ts
|
|
635
|
-
var z7 = __toESM(require("zod/v4"));
|
|
636
|
-
var Conditional = z7.any().describe("JSONSchema").meta({
|
|
637
|
-
description: "JSON schema conditional configuration",
|
|
638
|
-
id: "Conditional"
|
|
639
|
-
});
|
|
640
|
-
var ConditionalType = {
|
|
641
|
-
SHOW: "SHOW",
|
|
642
|
-
ENABLE: "ENABLE",
|
|
643
|
-
DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
|
|
644
|
-
};
|
|
645
|
-
var ShowConditional = z7.object({
|
|
646
|
-
type: z7.literal(ConditionalType.SHOW),
|
|
647
|
-
conditional: Conditional
|
|
648
|
-
}).describe(
|
|
649
|
-
"If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
|
|
650
|
-
);
|
|
651
|
-
var EnableConditional = z7.object({
|
|
652
|
-
type: z7.literal(ConditionalType.ENABLE),
|
|
653
|
-
conditional: Conditional
|
|
654
|
-
}).describe(
|
|
655
|
-
"If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
|
|
656
|
-
);
|
|
657
|
-
var ActionConditional = z7.discriminatedUnion("type", [
|
|
658
|
-
// Action can be shown / hidden
|
|
659
|
-
ShowConditional,
|
|
660
|
-
// Action can be shown to the user in the list but as disabled
|
|
661
|
-
EnableConditional
|
|
662
|
-
]).meta({
|
|
663
|
-
id: "ActionConditional",
|
|
664
|
-
description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
|
|
665
|
-
});
|
|
666
|
-
var DisplayOnReviewConditional = z7.object({
|
|
667
|
-
type: z7.literal(ConditionalType.DISPLAY_ON_REVIEW),
|
|
668
|
-
conditional: Conditional
|
|
669
|
-
}).describe(
|
|
670
|
-
"If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
|
|
671
|
-
);
|
|
672
|
-
var FieldConditional = z7.discriminatedUnion("type", [
|
|
673
|
-
// Field input can be shown / hidden
|
|
674
|
-
ShowConditional,
|
|
675
|
-
// Field input can be shown to the user but as disabled
|
|
676
|
-
EnableConditional,
|
|
677
|
-
// Field output can be shown / hidden on the review page
|
|
678
|
-
DisplayOnReviewConditional
|
|
679
|
-
]).meta({
|
|
680
|
-
id: "FieldConditional",
|
|
681
|
-
description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
|
|
682
|
-
});
|
|
683
|
-
|
|
684
769
|
// ../commons/src/events/FieldType.ts
|
|
685
|
-
var
|
|
770
|
+
var z9 = __toESM(require("zod/v4"));
|
|
686
771
|
var FieldType = {
|
|
687
772
|
NAME: "NAME",
|
|
688
773
|
PHONE: "PHONE",
|
|
@@ -746,7 +831,7 @@ var FieldType = {
|
|
|
746
831
|
*/
|
|
747
832
|
_EXPERIMENTAL_CUSTOM: "CUSTOM"
|
|
748
833
|
};
|
|
749
|
-
var FileFieldType =
|
|
834
|
+
var FileFieldType = z9.enum([
|
|
750
835
|
FieldType.FILE,
|
|
751
836
|
FieldType.FILE_WITH_OPTIONS,
|
|
752
837
|
FieldType.SIGNATURE
|
|
@@ -782,160 +867,164 @@ var HiddenFieldTypes = [
|
|
|
782
867
|
];
|
|
783
868
|
|
|
784
869
|
// ../commons/src/events/FieldValue.ts
|
|
785
|
-
var
|
|
870
|
+
var z13 = __toESM(require("zod/v4"));
|
|
786
871
|
|
|
787
872
|
// ../commons/src/documents.ts
|
|
788
|
-
var
|
|
789
|
-
var FullDocumentUrl =
|
|
873
|
+
var z10 = __toESM(require("zod/v4"));
|
|
874
|
+
var FullDocumentUrl = z10.string().brand("FullDocumentUrl").describe(
|
|
790
875
|
"A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio.opencrvs.com/bucket-name/document-id.jpg"
|
|
791
876
|
);
|
|
792
|
-
var FullDocumentPath =
|
|
877
|
+
var FullDocumentPath = z10.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
|
|
793
878
|
"A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
|
|
794
879
|
);
|
|
795
|
-
var DocumentPath =
|
|
880
|
+
var DocumentPath = z10.string().brand("DocumentPath").describe(
|
|
796
881
|
"A relative path within the S3 bucket, never starting with /. e.g. document-id.jpg or directory/document-id.jpg. The document service constructs the full /bucket/path internally."
|
|
797
882
|
);
|
|
798
883
|
|
|
799
884
|
// ../commons/src/events/CompositeFieldValue.ts
|
|
800
|
-
var
|
|
885
|
+
var z11 = __toESM(require("zod/v4"));
|
|
801
886
|
var AddressType = {
|
|
802
887
|
DOMESTIC: "DOMESTIC",
|
|
803
888
|
INTERNATIONAL: "INTERNATIONAL"
|
|
804
889
|
};
|
|
805
|
-
var FileFieldValue =
|
|
890
|
+
var FileFieldValue = z11.object({
|
|
806
891
|
path: DocumentPath,
|
|
807
|
-
originalFilename:
|
|
808
|
-
type:
|
|
809
|
-
});
|
|
810
|
-
var NameFieldValue =
|
|
811
|
-
firstname:
|
|
812
|
-
surname:
|
|
813
|
-
middlename:
|
|
814
|
-
});
|
|
815
|
-
var NameFieldUpdateValue =
|
|
816
|
-
firstname:
|
|
817
|
-
surname:
|
|
818
|
-
middlename:
|
|
819
|
-
}).or(
|
|
820
|
-
var StreetLevelDetailsValue =
|
|
821
|
-
var StreetLevelDetailsUpdateValue =
|
|
822
|
-
var BaseAddressFieldValue =
|
|
823
|
-
country:
|
|
892
|
+
originalFilename: z11.string(),
|
|
893
|
+
type: z11.string()
|
|
894
|
+
});
|
|
895
|
+
var NameFieldValue = z11.object({
|
|
896
|
+
firstname: z11.string(),
|
|
897
|
+
surname: z11.string(),
|
|
898
|
+
middlename: z11.string().optional()
|
|
899
|
+
});
|
|
900
|
+
var NameFieldUpdateValue = z11.object({
|
|
901
|
+
firstname: z11.string().nullish(),
|
|
902
|
+
surname: z11.string().nullish(),
|
|
903
|
+
middlename: z11.string().nullish()
|
|
904
|
+
}).or(z11.null()).or(z11.undefined());
|
|
905
|
+
var StreetLevelDetailsValue = z11.record(z11.string(), z11.string()).optional();
|
|
906
|
+
var StreetLevelDetailsUpdateValue = z11.record(z11.string(), z11.string().nullable()).nullish();
|
|
907
|
+
var BaseAddressFieldValue = z11.object({
|
|
908
|
+
country: z11.string(),
|
|
824
909
|
streetLevelDetails: StreetLevelDetailsValue
|
|
825
910
|
});
|
|
826
|
-
var BaseAddressFieldUpdateValue =
|
|
827
|
-
country:
|
|
911
|
+
var BaseAddressFieldUpdateValue = z11.object({
|
|
912
|
+
country: z11.string().nullish(),
|
|
828
913
|
streetLevelDetails: StreetLevelDetailsUpdateValue
|
|
829
914
|
});
|
|
830
915
|
var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
|
|
831
|
-
addressType:
|
|
832
|
-
administrativeArea:
|
|
916
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
917
|
+
administrativeArea: z11.string().uuid()
|
|
833
918
|
});
|
|
834
919
|
var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
|
|
835
|
-
addressType:
|
|
920
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
836
921
|
});
|
|
837
|
-
var AddressFieldValue =
|
|
922
|
+
var AddressFieldValue = z11.discriminatedUnion("addressType", [
|
|
838
923
|
DomesticAddressFieldValue,
|
|
839
924
|
InternationalAddressFieldValue
|
|
840
925
|
]);
|
|
841
926
|
var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
|
|
842
|
-
addressType:
|
|
843
|
-
administrativeArea:
|
|
927
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
928
|
+
administrativeArea: z11.string().uuid().nullish()
|
|
844
929
|
/* Leaf level admin structure */
|
|
845
930
|
});
|
|
846
931
|
var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
|
|
847
932
|
{
|
|
848
|
-
addressType:
|
|
933
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
849
934
|
}
|
|
850
935
|
);
|
|
851
|
-
var AddressFieldUpdateValue =
|
|
936
|
+
var AddressFieldUpdateValue = z11.discriminatedUnion("addressType", [
|
|
852
937
|
DomesticAddressUpdateFieldValue,
|
|
853
938
|
InternationalAddressUpdateFieldValue
|
|
854
939
|
]).nullish();
|
|
855
|
-
var FileFieldValueWithOption =
|
|
940
|
+
var FileFieldValueWithOption = z11.object({
|
|
856
941
|
path: DocumentPath,
|
|
857
|
-
originalFilename:
|
|
858
|
-
type:
|
|
859
|
-
option:
|
|
860
|
-
});
|
|
861
|
-
var FileFieldWithOptionValue =
|
|
862
|
-
var HttpFieldValue =
|
|
863
|
-
loading:
|
|
864
|
-
error:
|
|
865
|
-
data:
|
|
866
|
-
});
|
|
867
|
-
var HttpFieldUpdateValue =
|
|
868
|
-
loading:
|
|
869
|
-
error:
|
|
870
|
-
data:
|
|
871
|
-
}).or(
|
|
872
|
-
var QueryParamReaderFieldValue =
|
|
873
|
-
data:
|
|
874
|
-
updatedAt:
|
|
942
|
+
originalFilename: z11.string(),
|
|
943
|
+
type: z11.string(),
|
|
944
|
+
option: z11.string()
|
|
945
|
+
});
|
|
946
|
+
var FileFieldWithOptionValue = z11.array(FileFieldValueWithOption);
|
|
947
|
+
var HttpFieldValue = z11.object({
|
|
948
|
+
loading: z11.boolean(),
|
|
949
|
+
error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
|
|
950
|
+
data: z11.any()
|
|
951
|
+
});
|
|
952
|
+
var HttpFieldUpdateValue = z11.object({
|
|
953
|
+
loading: z11.boolean().nullish(),
|
|
954
|
+
error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
|
|
955
|
+
data: z11.any().nullish()
|
|
956
|
+
}).or(z11.null()).or(z11.undefined());
|
|
957
|
+
var QueryParamReaderFieldValue = z11.object({
|
|
958
|
+
data: z11.record(z11.string(), z11.string()),
|
|
959
|
+
updatedAt: z11.iso.datetime()
|
|
875
960
|
}).nullish();
|
|
876
|
-
var QueryParamReaderFieldUpdateValue =
|
|
877
|
-
data:
|
|
961
|
+
var QueryParamReaderFieldUpdateValue = z11.object({
|
|
962
|
+
data: z11.record(z11.string(), z11.string())
|
|
878
963
|
});
|
|
879
|
-
var ReadDataValue =
|
|
880
|
-
data:
|
|
964
|
+
var ReadDataValue = z11.object({
|
|
965
|
+
data: z11.any()
|
|
881
966
|
});
|
|
882
967
|
var QrReaderFieldValue = ReadDataValue;
|
|
883
968
|
var IdReaderFieldValue = ReadDataValue;
|
|
884
|
-
var NumberWithUnitFieldValue =
|
|
885
|
-
numericValue:
|
|
886
|
-
unit:
|
|
969
|
+
var NumberWithUnitFieldValue = z11.object({
|
|
970
|
+
numericValue: z11.number(),
|
|
971
|
+
unit: z11.string()
|
|
887
972
|
});
|
|
888
|
-
var NumberWithUnitFieldUpdateValue =
|
|
889
|
-
numericValue:
|
|
890
|
-
unit:
|
|
973
|
+
var NumberWithUnitFieldUpdateValue = z11.object({
|
|
974
|
+
numericValue: z11.number().optional(),
|
|
975
|
+
unit: z11.string().optional()
|
|
891
976
|
});
|
|
892
|
-
var CustomFieldValue =
|
|
977
|
+
var CustomFieldValue = z11.unknown().brand("CustomFieldValue");
|
|
893
978
|
|
|
894
979
|
// ../commons/src/events/PlainDate.ts
|
|
895
980
|
var import_zod = require("zod");
|
|
896
981
|
var PlainDate = import_zod.z.string().date().brand("PlainDate").describe("Date in the format YYYY-MM-DD");
|
|
982
|
+
function plainDateToLocalDate(date) {
|
|
983
|
+
const [year, month, day] = date.split("-").map(Number);
|
|
984
|
+
return new Date(year, month - 1, day);
|
|
985
|
+
}
|
|
897
986
|
|
|
898
987
|
// ../commons/src/events/FieldValue.ts
|
|
899
|
-
var TextValue =
|
|
900
|
-
var HiddenFieldValue =
|
|
901
|
-
var NonEmptyTextValue =
|
|
902
|
-
var DateValue =
|
|
903
|
-
var AgeValue =
|
|
904
|
-
age:
|
|
905
|
-
asOfDateRef:
|
|
988
|
+
var TextValue = z13.string();
|
|
989
|
+
var HiddenFieldValue = z13.string();
|
|
990
|
+
var NonEmptyTextValue = z13.string().trim().min(1);
|
|
991
|
+
var DateValue = z13.iso.date().describe("Date in the format YYYY-MM-DD");
|
|
992
|
+
var AgeValue = z13.object({
|
|
993
|
+
age: z13.number(),
|
|
994
|
+
asOfDateRef: z13.string()
|
|
906
995
|
});
|
|
907
996
|
var AgeUpdateValue = AgeValue.optional().nullable();
|
|
908
|
-
var AutocompleteValue =
|
|
909
|
-
label:
|
|
910
|
-
value:
|
|
997
|
+
var AutocompleteValue = z13.object({
|
|
998
|
+
label: z13.string(),
|
|
999
|
+
value: z13.string()
|
|
911
1000
|
});
|
|
912
1001
|
var AutocompleteUpdateValue = AutocompleteValue.optional().nullable();
|
|
913
|
-
var TimeValue =
|
|
914
|
-
var DatetimeValue =
|
|
915
|
-
var SelectDateRangeValue =
|
|
1002
|
+
var TimeValue = z13.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
|
|
1003
|
+
var DatetimeValue = z13.iso.datetime();
|
|
1004
|
+
var SelectDateRangeValue = z13.enum([
|
|
916
1005
|
"last7Days",
|
|
917
1006
|
"last30Days",
|
|
918
1007
|
"last90Days",
|
|
919
1008
|
"last365Days"
|
|
920
1009
|
]);
|
|
921
|
-
var DateRangeFieldValue =
|
|
1010
|
+
var DateRangeFieldValue = z13.object({
|
|
922
1011
|
start: PlainDate,
|
|
923
1012
|
end: PlainDate
|
|
924
1013
|
}).or(PlainDate).describe(
|
|
925
1014
|
"Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
|
|
926
1015
|
);
|
|
927
|
-
var EmailValue =
|
|
928
|
-
var CheckboxFieldValue =
|
|
929
|
-
var NumberFieldValue =
|
|
1016
|
+
var EmailValue = z13.email();
|
|
1017
|
+
var CheckboxFieldValue = z13.boolean();
|
|
1018
|
+
var NumberFieldValue = z13.number();
|
|
930
1019
|
var SignatureFieldValue = FileFieldValue;
|
|
931
|
-
var ButtonFieldValue =
|
|
932
|
-
var VerificationStatusValue =
|
|
1020
|
+
var ButtonFieldValue = z13.number();
|
|
1021
|
+
var VerificationStatusValue = z13.enum([
|
|
933
1022
|
"verified",
|
|
934
1023
|
"authenticated",
|
|
935
1024
|
"failed",
|
|
936
1025
|
"pending"
|
|
937
1026
|
]);
|
|
938
|
-
var LeafFieldValues =
|
|
1027
|
+
var LeafFieldValues = z13.union([
|
|
939
1028
|
AddressFieldValue,
|
|
940
1029
|
TextValue,
|
|
941
1030
|
PlainDate,
|
|
@@ -961,11 +1050,11 @@ var LeafFieldValues = z12.union([
|
|
|
961
1050
|
AutocompleteValue,
|
|
962
1051
|
AutocompleteUpdateValue
|
|
963
1052
|
]);
|
|
964
|
-
var FieldGroupValue =
|
|
965
|
-
var DataFieldValue =
|
|
966
|
-
data:
|
|
1053
|
+
var FieldGroupValue = z13.record(z13.string(), LeafFieldValues);
|
|
1054
|
+
var DataFieldValue = z13.object({
|
|
1055
|
+
data: z13.record(z13.string(), LeafFieldValues)
|
|
967
1056
|
}).nullish();
|
|
968
|
-
var FieldValue =
|
|
1057
|
+
var FieldValue = z13.union([
|
|
969
1058
|
LeafFieldValues,
|
|
970
1059
|
DataFieldValue,
|
|
971
1060
|
FieldGroupValue
|
|
@@ -999,7 +1088,7 @@ function safeUnion(schemas) {
|
|
|
999
1088
|
const sortedSchemas = [...schemas].sort(
|
|
1000
1089
|
(a, b) => schemaPriority(a) - schemaPriority(b)
|
|
1001
1090
|
);
|
|
1002
|
-
return
|
|
1091
|
+
return z13.any().superRefine((val, ctx) => {
|
|
1003
1092
|
for (const schema of sortedSchemas) {
|
|
1004
1093
|
if (schema.safeParse(val).success) {
|
|
1005
1094
|
return;
|
|
@@ -1038,9 +1127,9 @@ var FieldUpdateValue = safeUnion([
|
|
|
1038
1127
|
]);
|
|
1039
1128
|
|
|
1040
1129
|
// ../commons/src/events/serializers/user/serializer.ts
|
|
1041
|
-
var
|
|
1042
|
-
var SerializedUserField =
|
|
1043
|
-
$userField:
|
|
1130
|
+
var z14 = __toESM(require("zod/v4"));
|
|
1131
|
+
var SerializedUserField = z14.object({
|
|
1132
|
+
$userField: z14.enum([
|
|
1044
1133
|
"id",
|
|
1045
1134
|
"name",
|
|
1046
1135
|
"role",
|
|
@@ -1054,7 +1143,7 @@ var SerializedUserField = z13.object({
|
|
|
1054
1143
|
"primaryOfficeId",
|
|
1055
1144
|
"administrativeAreaId"
|
|
1056
1145
|
]),
|
|
1057
|
-
$location:
|
|
1146
|
+
$location: z14.string().optional()
|
|
1058
1147
|
});
|
|
1059
1148
|
function userSerializer(userField) {
|
|
1060
1149
|
return {
|
|
@@ -1080,27 +1169,22 @@ var import_v4 = require("zod/v4");
|
|
|
1080
1169
|
var z16 = __toESM(require("zod/v4"));
|
|
1081
1170
|
|
|
1082
1171
|
// ../commons/src/events/ActionDocument.ts
|
|
1083
|
-
var
|
|
1084
|
-
var ActionUpdate =
|
|
1172
|
+
var z15 = __toESM(require("zod/v4"));
|
|
1173
|
+
var ActionUpdate = z15.record(z15.string(), FieldUpdateValue).describe(
|
|
1085
1174
|
"Record of field-level changes made by an action. Supports partial updates and nullable values."
|
|
1086
1175
|
);
|
|
1087
|
-
var EventState =
|
|
1176
|
+
var EventState = z15.record(z15.string(), FieldValue).describe(
|
|
1088
1177
|
"Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
|
|
1089
1178
|
);
|
|
1090
|
-
var
|
|
1091
|
-
Requested: "Requested",
|
|
1092
|
-
Accepted: "Accepted",
|
|
1093
|
-
Rejected: "Rejected"
|
|
1094
|
-
};
|
|
1095
|
-
var ActionBase = z14.object({
|
|
1179
|
+
var ActionBase = z15.object({
|
|
1096
1180
|
id: UUID.describe("Unique identifier of the action."),
|
|
1097
|
-
transactionId:
|
|
1181
|
+
transactionId: z15.string().describe("Unique identifier of the transaction."),
|
|
1098
1182
|
createdByUserType: TokenUserType.describe(
|
|
1099
1183
|
"Indicates whether the action was created by a human-user or by a system-user."
|
|
1100
1184
|
),
|
|
1101
|
-
createdAt:
|
|
1102
|
-
createdBy:
|
|
1103
|
-
createdByRole:
|
|
1185
|
+
createdAt: z15.string().datetime().describe("Timestamp indicating when the action was created."),
|
|
1186
|
+
createdBy: z15.string().describe("Identifier of the user who created the action."),
|
|
1187
|
+
createdByRole: z15.string().optional().describe("Role of the user who created the action."),
|
|
1104
1188
|
createdBySignature: DocumentPath.nullish().describe(
|
|
1105
1189
|
"Reference to the signature of the user who created the action."
|
|
1106
1190
|
),
|
|
@@ -1112,7 +1196,7 @@ var ActionBase = z14.object({
|
|
|
1112
1196
|
"Declaration data defined by the ActionConfig. Supports partial updates."
|
|
1113
1197
|
),
|
|
1114
1198
|
annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
|
|
1115
|
-
status:
|
|
1199
|
+
status: z15.enum([
|
|
1116
1200
|
ActionStatus.Requested,
|
|
1117
1201
|
ActionStatus.Accepted,
|
|
1118
1202
|
ActionStatus.Rejected
|
|
@@ -1124,216 +1208,170 @@ var ActionBase = z14.object({
|
|
|
1124
1208
|
)
|
|
1125
1209
|
});
|
|
1126
1210
|
var AssignedAction = ActionBase.extend(
|
|
1127
|
-
|
|
1128
|
-
type:
|
|
1129
|
-
assignedTo:
|
|
1211
|
+
z15.object({
|
|
1212
|
+
type: z15.literal(ActionType.ASSIGN),
|
|
1213
|
+
assignedTo: z15.string().describe("Identifier of the user to whom the action is assigned.")
|
|
1130
1214
|
// TODO move into 'content' property
|
|
1131
1215
|
}).shape
|
|
1132
1216
|
);
|
|
1133
1217
|
var UnassignedAction = ActionBase.extend(
|
|
1134
|
-
|
|
1135
|
-
type:
|
|
1218
|
+
z15.object({
|
|
1219
|
+
type: z15.literal(ActionType.UNASSIGN)
|
|
1136
1220
|
}).shape
|
|
1137
1221
|
);
|
|
1138
1222
|
var RegisterAction = ActionBase.extend(
|
|
1139
|
-
|
|
1140
|
-
type:
|
|
1141
|
-
registrationNumber:
|
|
1223
|
+
z15.object({
|
|
1224
|
+
type: z15.literal(ActionType.REGISTER),
|
|
1225
|
+
registrationNumber: z15.string().optional().describe(
|
|
1142
1226
|
"Registration number of the event. Always present for accepted registrations."
|
|
1143
1227
|
)
|
|
1144
1228
|
// TODO move into 'content' property
|
|
1145
1229
|
}).shape
|
|
1146
1230
|
);
|
|
1147
1231
|
var DeclareAction = ActionBase.extend(
|
|
1148
|
-
|
|
1149
|
-
type:
|
|
1232
|
+
z15.object({
|
|
1233
|
+
type: z15.literal(ActionType.DECLARE)
|
|
1150
1234
|
}).shape
|
|
1151
1235
|
);
|
|
1152
|
-
var ReasonContent =
|
|
1153
|
-
reason:
|
|
1236
|
+
var ReasonContent = z15.object({
|
|
1237
|
+
reason: z15.string().min(1, { error: "Message cannot be empty" }).describe(
|
|
1154
1238
|
"Message describing the reason for rejecting or archiving the event."
|
|
1155
1239
|
)
|
|
1156
1240
|
});
|
|
1157
1241
|
var RejectAction = ActionBase.extend(
|
|
1158
|
-
|
|
1159
|
-
type:
|
|
1242
|
+
z15.object({
|
|
1243
|
+
type: z15.literal(ActionType.REJECT),
|
|
1160
1244
|
content: ReasonContent
|
|
1161
1245
|
}).shape
|
|
1162
1246
|
);
|
|
1163
|
-
var PotentialDuplicate =
|
|
1247
|
+
var PotentialDuplicate = z15.object({
|
|
1164
1248
|
id: UUID,
|
|
1165
|
-
trackingId:
|
|
1249
|
+
trackingId: z15.string()
|
|
1166
1250
|
});
|
|
1167
1251
|
var DuplicateDetectedAction = ActionBase.extend(
|
|
1168
|
-
|
|
1169
|
-
type:
|
|
1170
|
-
content:
|
|
1171
|
-
duplicates:
|
|
1252
|
+
z15.object({
|
|
1253
|
+
type: z15.literal(ActionType.DUPLICATE_DETECTED),
|
|
1254
|
+
content: z15.object({
|
|
1255
|
+
duplicates: z15.array(PotentialDuplicate)
|
|
1172
1256
|
})
|
|
1173
1257
|
}).shape
|
|
1174
1258
|
);
|
|
1175
1259
|
var MarkNotDuplicateAction = ActionBase.extend(
|
|
1176
|
-
|
|
1177
|
-
type:
|
|
1260
|
+
z15.object({
|
|
1261
|
+
type: z15.literal(ActionType.MARK_AS_NOT_DUPLICATE)
|
|
1178
1262
|
}).shape
|
|
1179
1263
|
);
|
|
1180
1264
|
var MarkAsDuplicateAction = ActionBase.extend(
|
|
1181
|
-
|
|
1182
|
-
type:
|
|
1183
|
-
content:
|
|
1265
|
+
z15.object({
|
|
1266
|
+
type: z15.literal(ActionType.MARK_AS_DUPLICATE),
|
|
1267
|
+
content: z15.object({
|
|
1184
1268
|
duplicateOf: UUID
|
|
1185
1269
|
}).optional()
|
|
1186
1270
|
}).shape
|
|
1187
1271
|
);
|
|
1188
1272
|
var ArchiveAction = ActionBase.extend(
|
|
1189
|
-
|
|
1190
|
-
type:
|
|
1273
|
+
z15.object({
|
|
1274
|
+
type: z15.literal(ActionType.ARCHIVE),
|
|
1191
1275
|
content: ReasonContent
|
|
1192
1276
|
}).shape
|
|
1193
1277
|
);
|
|
1278
|
+
var UnarchiveAction = ActionBase.extend(
|
|
1279
|
+
z15.object({
|
|
1280
|
+
type: z15.literal(ActionType.UNARCHIVE)
|
|
1281
|
+
}).shape
|
|
1282
|
+
);
|
|
1194
1283
|
var CreatedAction = ActionBase.extend(
|
|
1195
|
-
|
|
1196
|
-
type:
|
|
1284
|
+
z15.object({
|
|
1285
|
+
type: z15.literal(ActionType.CREATE)
|
|
1197
1286
|
}).shape
|
|
1198
1287
|
);
|
|
1199
1288
|
var NotifiedAction = ActionBase.extend(
|
|
1200
|
-
|
|
1201
|
-
type:
|
|
1289
|
+
z15.object({
|
|
1290
|
+
type: z15.literal(ActionType.NOTIFY)
|
|
1202
1291
|
}).shape
|
|
1203
1292
|
);
|
|
1204
1293
|
var EditAction = ActionBase.extend(
|
|
1205
|
-
|
|
1206
|
-
type:
|
|
1207
|
-
content:
|
|
1208
|
-
comment:
|
|
1294
|
+
z15.object({
|
|
1295
|
+
type: z15.literal(ActionType.EDIT),
|
|
1296
|
+
content: z15.object({
|
|
1297
|
+
comment: z15.string().describe("Comment for the edit action.").optional()
|
|
1209
1298
|
})
|
|
1210
1299
|
}).shape
|
|
1211
1300
|
);
|
|
1212
|
-
var PrintContent =
|
|
1213
|
-
templateId:
|
|
1301
|
+
var PrintContent = z15.object({
|
|
1302
|
+
templateId: z15.string().optional()
|
|
1214
1303
|
});
|
|
1215
1304
|
var PrintCertificateAction = ActionBase.extend(
|
|
1216
|
-
|
|
1217
|
-
type:
|
|
1305
|
+
z15.object({
|
|
1306
|
+
type: z15.literal(ActionType.PRINT_CERTIFICATE),
|
|
1218
1307
|
content: PrintContent.optional().nullable()
|
|
1219
1308
|
}).shape
|
|
1220
1309
|
);
|
|
1221
1310
|
var RequestedCorrectionAction = ActionBase.extend(
|
|
1222
|
-
|
|
1223
|
-
type:
|
|
1311
|
+
z15.object({
|
|
1312
|
+
type: z15.literal(ActionType.REQUEST_CORRECTION)
|
|
1224
1313
|
}).shape
|
|
1225
1314
|
);
|
|
1226
1315
|
var ApprovedCorrectionAction = ActionBase.extend(
|
|
1227
|
-
|
|
1228
|
-
type:
|
|
1229
|
-
requestId:
|
|
1316
|
+
z15.object({
|
|
1317
|
+
type: z15.literal(ActionType.APPROVE_CORRECTION),
|
|
1318
|
+
requestId: z15.string(),
|
|
1230
1319
|
// TODO move into 'content' property
|
|
1231
|
-
content:
|
|
1320
|
+
content: z15.object({ immediateCorrection: z15.boolean().optional() }).optional()
|
|
1232
1321
|
}).shape
|
|
1233
1322
|
);
|
|
1234
1323
|
var RejectedCorrectionAction = ActionBase.extend(
|
|
1235
|
-
|
|
1236
|
-
type:
|
|
1237
|
-
requestId:
|
|
1324
|
+
z15.object({
|
|
1325
|
+
type: z15.literal(ActionType.REJECT_CORRECTION),
|
|
1326
|
+
requestId: z15.string(),
|
|
1238
1327
|
// TODO move into 'content' property
|
|
1239
1328
|
content: ReasonContent
|
|
1240
1329
|
}).shape
|
|
1241
1330
|
);
|
|
1242
1331
|
var ReadAction = ActionBase.extend(
|
|
1243
|
-
|
|
1244
|
-
type:
|
|
1332
|
+
z15.object({
|
|
1333
|
+
type: z15.literal(ActionType.READ)
|
|
1245
1334
|
}).shape
|
|
1246
1335
|
);
|
|
1247
1336
|
var CustomAction = ActionBase.merge(
|
|
1248
|
-
|
|
1249
|
-
type:
|
|
1250
|
-
customActionType:
|
|
1337
|
+
z15.object({
|
|
1338
|
+
type: z15.literal(ActionType.CUSTOM),
|
|
1339
|
+
customActionType: z15.string()
|
|
1251
1340
|
})
|
|
1252
1341
|
);
|
|
1253
|
-
var ActionDocument =
|
|
1342
|
+
var ActionDocument = z15.discriminatedUnion("type", [
|
|
1254
1343
|
CreatedAction.meta({ id: "CreatedAction" }),
|
|
1255
1344
|
RejectAction.meta({ id: "RejectAction" }),
|
|
1256
1345
|
DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
|
|
1257
1346
|
MarkNotDuplicateAction.meta({ id: "MarkNotDuplicateAction" }),
|
|
1258
1347
|
MarkAsDuplicateAction.meta({ id: "MarkAsDuplicateAction" }),
|
|
1259
1348
|
ArchiveAction.meta({ id: "ArchiveAction" }),
|
|
1349
|
+
UnarchiveAction.meta({ id: "UnarchiveAction" }),
|
|
1260
1350
|
NotifiedAction.meta({ id: "NotifiedAction" }),
|
|
1261
|
-
RegisterAction.meta({ id: "RegisterAction" }),
|
|
1262
|
-
DeclareAction.meta({ id: "DeclareAction" }),
|
|
1263
|
-
AssignedAction.meta({ id: "AssignedAction" }),
|
|
1264
|
-
RequestedCorrectionAction.meta({ id: "RequestedCorrectionAction" }),
|
|
1265
|
-
ApprovedCorrectionAction.meta({ id: "ApprovedCorrectionAction" }),
|
|
1266
|
-
RejectedCorrectionAction.meta({ id: "RejectedCorrectionAction" }),
|
|
1267
|
-
UnassignedAction.meta({ id: "UnassignedAction" }),
|
|
1268
|
-
PrintCertificateAction.meta({ id: "PrintCertificateAction" }),
|
|
1269
|
-
ReadAction.meta({ id: "ReadAction" }),
|
|
1270
|
-
EditAction.meta({ id: "EditAction" }),
|
|
1271
|
-
CustomAction.meta({ id: "CustomAction" })
|
|
1272
|
-
]).meta({
|
|
1273
|
-
id: "ActionDocument"
|
|
1274
|
-
});
|
|
1275
|
-
var AsyncRejectActionDocument = ActionBase.omit({
|
|
1276
|
-
declaration: true,
|
|
1277
|
-
annotation: true
|
|
1278
|
-
}).extend(
|
|
1279
|
-
z14.object({
|
|
1280
|
-
type: z14.enum(ConfirmableActions),
|
|
1281
|
-
status: z14.literal(ActionStatus.Rejected)
|
|
1282
|
-
}).shape
|
|
1283
|
-
);
|
|
1284
|
-
var Action = z14.union([ActionDocument, AsyncRejectActionDocument]);
|
|
1285
|
-
|
|
1286
|
-
// ../commons/src/events/Flag.ts
|
|
1287
|
-
var z15 = __toESM(require("zod/v4"));
|
|
1288
|
-
var InherentFlags = {
|
|
1289
|
-
INCOMPLETE: "incomplete",
|
|
1290
|
-
REJECTED: "rejected",
|
|
1291
|
-
CORRECTION_REQUESTED: "correction-requested",
|
|
1292
|
-
POTENTIAL_DUPLICATE: "potential-duplicate",
|
|
1293
|
-
/**
|
|
1294
|
-
* This flag is set by the Edit-action and removed after the declaration or registration.
|
|
1295
|
-
* A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
|
|
1296
|
-
*
|
|
1297
|
-
* We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
|
|
1298
|
-
*/
|
|
1299
|
-
EDIT_IN_PROGRESS: "edit-in-progress"
|
|
1300
|
-
};
|
|
1301
|
-
var ActionFlag = z15.string().regex(
|
|
1302
|
-
new RegExp(
|
|
1303
|
-
`^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
|
|
1304
|
-
ActionStatus
|
|
1305
|
-
).join("|").toLowerCase()})$`
|
|
1306
|
-
),
|
|
1307
|
-
"Flag must be in the format ActionType:ActionStatus (lowerCase)"
|
|
1308
|
-
);
|
|
1309
|
-
var CustomFlag = z15.string().refine((val) => !Object.values(InherentFlags).includes(val), {
|
|
1310
|
-
message: `Custom flag cannot be one of the inherent flags: ${Object.values(
|
|
1311
|
-
InherentFlags
|
|
1312
|
-
).join(", ")}`
|
|
1313
|
-
}).refine((val) => !ActionFlag.safeParse(val).success, {
|
|
1314
|
-
message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
|
|
1315
|
-
}).describe("Custom flag identifier defined by the country config.");
|
|
1316
|
-
var Flag = ActionFlag.or(z15.enum(InherentFlags)).or(CustomFlag);
|
|
1317
|
-
var FlagConfig = z15.object({
|
|
1318
|
-
id: CustomFlag,
|
|
1319
|
-
requiresAction: z15.boolean().describe(
|
|
1320
|
-
"Indicates if this flag expects an action to be performed to be cleared."
|
|
1321
|
-
),
|
|
1322
|
-
label: TranslationConfig.describe("Human readable label of the flag.")
|
|
1323
|
-
}).meta({
|
|
1324
|
-
id: "FlagConfig",
|
|
1325
|
-
description: "Configuration for a custom flag that can be added to or removed from records by event actions."
|
|
1326
|
-
});
|
|
1327
|
-
var ActionFlagConfig = z15.object({
|
|
1328
|
-
id: Flag,
|
|
1329
|
-
operation: z15.enum(["add", "remove"]).describe("Operation to perform on the flag."),
|
|
1330
|
-
conditional: Conditional.optional().describe(
|
|
1331
|
-
"When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
|
|
1332
|
-
)
|
|
1333
|
-
}).meta({
|
|
1334
|
-
id: "ActionFlagConfig",
|
|
1335
|
-
description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
|
|
1351
|
+
RegisterAction.meta({ id: "RegisterAction" }),
|
|
1352
|
+
DeclareAction.meta({ id: "DeclareAction" }),
|
|
1353
|
+
AssignedAction.meta({ id: "AssignedAction" }),
|
|
1354
|
+
RequestedCorrectionAction.meta({ id: "RequestedCorrectionAction" }),
|
|
1355
|
+
ApprovedCorrectionAction.meta({ id: "ApprovedCorrectionAction" }),
|
|
1356
|
+
RejectedCorrectionAction.meta({ id: "RejectedCorrectionAction" }),
|
|
1357
|
+
UnassignedAction.meta({ id: "UnassignedAction" }),
|
|
1358
|
+
PrintCertificateAction.meta({ id: "PrintCertificateAction" }),
|
|
1359
|
+
ReadAction.meta({ id: "ReadAction" }),
|
|
1360
|
+
EditAction.meta({ id: "EditAction" }),
|
|
1361
|
+
CustomAction.meta({ id: "CustomAction" })
|
|
1362
|
+
]).meta({
|
|
1363
|
+
id: "ActionDocument"
|
|
1336
1364
|
});
|
|
1365
|
+
var AsyncRejectActionDocument = ActionBase.omit({
|
|
1366
|
+
declaration: true,
|
|
1367
|
+
annotation: true
|
|
1368
|
+
}).extend(
|
|
1369
|
+
z15.object({
|
|
1370
|
+
type: z15.enum(ConfirmableActions),
|
|
1371
|
+
status: z15.literal(ActionStatus.Rejected)
|
|
1372
|
+
}).shape
|
|
1373
|
+
);
|
|
1374
|
+
var Action = z15.union([ActionDocument, AsyncRejectActionDocument]);
|
|
1337
1375
|
|
|
1338
1376
|
// ../commons/src/events/EventMetadata.ts
|
|
1339
1377
|
var EventStatus = z16.enum([
|
|
@@ -1491,13 +1529,6 @@ var Range = import_v4.z.object({
|
|
|
1491
1529
|
}).meta({
|
|
1492
1530
|
id: "Range"
|
|
1493
1531
|
});
|
|
1494
|
-
var ContainsFlags = import_v4.z.object({
|
|
1495
|
-
anyOf: import_v4.z.array(Flag).optional(),
|
|
1496
|
-
noneOf: import_v4.z.array(Flag).optional(),
|
|
1497
|
-
allOf: import_v4.z.array(Flag).optional()
|
|
1498
|
-
}).meta({
|
|
1499
|
-
id: "ContainsFlags"
|
|
1500
|
-
});
|
|
1501
1532
|
var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
|
|
1502
1533
|
id: "Within"
|
|
1503
1534
|
});
|
|
@@ -2681,6 +2712,9 @@ var ActionConfigBase = z24.object({
|
|
|
2681
2712
|
var DeclarationActionBase = ActionConfigBase.extend({
|
|
2682
2713
|
deduplication: DeduplicationConfig.optional()
|
|
2683
2714
|
});
|
|
2715
|
+
var actionConfirmationForm = z24.array(FieldConfig).optional().describe(
|
|
2716
|
+
"Fields rendered on the action confirmation dialog. Submitted values are stored in the action annotation and shown in the audit history."
|
|
2717
|
+
);
|
|
2684
2718
|
var ReadActionConfig = ActionConfigBase.extend(
|
|
2685
2719
|
z24.object({
|
|
2686
2720
|
type: z24.literal(ActionType.READ),
|
|
@@ -2692,7 +2726,8 @@ var ReadActionConfig = ActionConfigBase.extend(
|
|
|
2692
2726
|
);
|
|
2693
2727
|
var NotifyConfig = ActionConfigBase.extend(
|
|
2694
2728
|
z24.object({
|
|
2695
|
-
type: z24.literal(ActionType.NOTIFY)
|
|
2729
|
+
type: z24.literal(ActionType.NOTIFY),
|
|
2730
|
+
form: actionConfirmationForm
|
|
2696
2731
|
}).shape
|
|
2697
2732
|
);
|
|
2698
2733
|
var DuplicateDetectedConfig = ActionConfigBase.extend(
|
|
@@ -2747,6 +2782,7 @@ var DeclareConfig = DeclarationActionBase.extend(
|
|
|
2747
2782
|
review: DeclarationReviewConfig.describe(
|
|
2748
2783
|
"Configuration of the review page fields."
|
|
2749
2784
|
),
|
|
2785
|
+
form: actionConfirmationForm,
|
|
2750
2786
|
dialogCopy: z24.object({
|
|
2751
2787
|
notify: TranslationConfig.describe(
|
|
2752
2788
|
"Confirmation text for the notify action"
|
|
@@ -2762,7 +2798,13 @@ var DeclareConfig = DeclarationActionBase.extend(
|
|
|
2762
2798
|
);
|
|
2763
2799
|
var ArchiveConfig = ActionConfigBase.extend(
|
|
2764
2800
|
z24.object({
|
|
2765
|
-
type: z24.literal(ActionType.ARCHIVE)
|
|
2801
|
+
type: z24.literal(ActionType.ARCHIVE),
|
|
2802
|
+
form: actionConfirmationForm
|
|
2803
|
+
}).shape
|
|
2804
|
+
);
|
|
2805
|
+
var UnarchiveConfig = ActionConfigBase.extend(
|
|
2806
|
+
z24.object({
|
|
2807
|
+
type: z24.literal(ActionType.UNARCHIVE)
|
|
2766
2808
|
}).shape
|
|
2767
2809
|
);
|
|
2768
2810
|
var EditActionConfig = ActionConfigBase.extend(
|
|
@@ -2783,12 +2825,14 @@ var EditActionConfig = ActionConfigBase.extend(
|
|
|
2783
2825
|
);
|
|
2784
2826
|
var RejectConfig = ActionConfigBase.extend(
|
|
2785
2827
|
z24.object({
|
|
2786
|
-
type: z24.literal(ActionType.REJECT)
|
|
2828
|
+
type: z24.literal(ActionType.REJECT),
|
|
2829
|
+
form: actionConfirmationForm
|
|
2787
2830
|
}).shape
|
|
2788
2831
|
);
|
|
2789
2832
|
var RegisterConfig = DeclarationActionBase.extend(
|
|
2790
2833
|
z24.object({
|
|
2791
|
-
type: z24.literal(ActionType.REGISTER)
|
|
2834
|
+
type: z24.literal(ActionType.REGISTER),
|
|
2835
|
+
form: actionConfirmationForm
|
|
2792
2836
|
}).shape
|
|
2793
2837
|
);
|
|
2794
2838
|
var PrintCertificateActionConfig = ActionConfigBase.extend(
|
|
@@ -2899,6 +2943,10 @@ var ActionConfig = z24.discriminatedUnion("type", [
|
|
|
2899
2943
|
id: "ArchiveActionConfig",
|
|
2900
2944
|
description: "Configuration for archiving a record."
|
|
2901
2945
|
}),
|
|
2946
|
+
UnarchiveConfig.meta({
|
|
2947
|
+
id: "UnarchiveActionConfig",
|
|
2948
|
+
description: "Configuration for unarchiving a record."
|
|
2949
|
+
}),
|
|
2902
2950
|
CustomActionConfig.meta({
|
|
2903
2951
|
id: "CustomActionConfig",
|
|
2904
2952
|
description: "Configuration for a country-defined custom action. An event may include any number of these."
|
|
@@ -3114,13 +3162,13 @@ var AdvancedSearchConfig = z28.object({
|
|
|
3114
3162
|
});
|
|
3115
3163
|
|
|
3116
3164
|
// ../commons/src/events/utils.ts
|
|
3117
|
-
var
|
|
3165
|
+
var import_lodash4 = require("lodash");
|
|
3118
3166
|
|
|
3119
3167
|
// ../commons/src/conditionals/validate.ts
|
|
3120
3168
|
var import__ = __toESM(require("ajv/dist/2019"));
|
|
3121
3169
|
var import_ajv_formats = __toESM(require("ajv-formats"));
|
|
3122
|
-
var
|
|
3123
|
-
var
|
|
3170
|
+
var z32 = __toESM(require("zod/v4"));
|
|
3171
|
+
var import_date_fns2 = require("date-fns");
|
|
3124
3172
|
|
|
3125
3173
|
// ../commons/src/events/FieldTypeMapping.ts
|
|
3126
3174
|
var z30 = __toESM(require("zod/v4"));
|
|
@@ -3128,204 +3176,300 @@ var z30 = __toESM(require("zod/v4"));
|
|
|
3128
3176
|
// ../commons/src/events/DynamicFieldValue.ts
|
|
3129
3177
|
var z29 = __toESM(require("zod/v4"));
|
|
3130
3178
|
|
|
3131
|
-
// ../commons/src/
|
|
3132
|
-
var
|
|
3133
|
-
|
|
3134
|
-
|
|
3135
|
-
|
|
3136
|
-
|
|
3137
|
-
|
|
3138
|
-
|
|
3139
|
-
|
|
3140
|
-
|
|
3179
|
+
// ../commons/src/events/state/index.ts
|
|
3180
|
+
var import_lodash3 = require("lodash");
|
|
3181
|
+
|
|
3182
|
+
// ../commons/src/utils.ts
|
|
3183
|
+
var z31 = __toESM(require("zod/v4"));
|
|
3184
|
+
var _ = __toESM(require("lodash"));
|
|
3185
|
+
function getOrThrow(x, message) {
|
|
3186
|
+
if (x === void 0 || x === null) {
|
|
3187
|
+
throw new Error(message);
|
|
3188
|
+
}
|
|
3189
|
+
return x;
|
|
3190
|
+
}
|
|
3191
|
+
function joinValues(values, separator = " ") {
|
|
3192
|
+
return values.filter((value) => !!value).join(separator).trim();
|
|
3193
|
+
}
|
|
3194
|
+
var FullNameV1 = z31.array(
|
|
3195
|
+
z31.object({
|
|
3196
|
+
use: z31.string(),
|
|
3197
|
+
family: z31.string(),
|
|
3198
|
+
given: z31.array(z31.string())
|
|
3141
3199
|
})
|
|
3142
|
-
|
|
3143
|
-
function
|
|
3144
|
-
|
|
3145
|
-
|
|
3146
|
-
const referencePath = pathParts.slice(1);
|
|
3147
|
-
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
3148
|
-
const traversedParts = instanceParts.slice(0, -levels);
|
|
3149
|
-
let current = rootData;
|
|
3150
|
-
for (const part of traversedParts) {
|
|
3151
|
-
if (current === null || current === void 0) {
|
|
3152
|
-
return void 0;
|
|
3153
|
-
}
|
|
3154
|
-
current = current[part];
|
|
3200
|
+
);
|
|
3201
|
+
function omitKeyDeep(obj, keyToRemove) {
|
|
3202
|
+
if (Array.isArray(obj)) {
|
|
3203
|
+
return obj.map((item) => omitKeyDeep(item, keyToRemove));
|
|
3155
3204
|
}
|
|
3156
|
-
|
|
3157
|
-
|
|
3158
|
-
|
|
3205
|
+
if (obj === null || typeof obj !== "object") {
|
|
3206
|
+
return obj;
|
|
3207
|
+
}
|
|
3208
|
+
const newObj = {};
|
|
3209
|
+
for (const key of Object.keys(obj)) {
|
|
3210
|
+
if (key !== keyToRemove) {
|
|
3211
|
+
newObj[key] = omitKeyDeep(obj[key], keyToRemove);
|
|
3159
3212
|
}
|
|
3160
|
-
current = current[part];
|
|
3161
3213
|
}
|
|
3162
|
-
return
|
|
3214
|
+
return newObj;
|
|
3163
3215
|
}
|
|
3164
|
-
|
|
3165
|
-
|
|
3216
|
+
|
|
3217
|
+
// ../commons/src/events/state/utils.ts
|
|
3218
|
+
var import_lodash = require("lodash");
|
|
3219
|
+
function getActionRequests(actionType, actions) {
|
|
3220
|
+
const filtered = actions.filter((action) => action.type === actionType).reverse();
|
|
3221
|
+
const accept = filtered.find(
|
|
3222
|
+
(action) => action.status === ActionStatus.Accepted
|
|
3223
|
+
);
|
|
3224
|
+
const request = filtered.find(
|
|
3225
|
+
(action) => action.status === ActionStatus.Requested
|
|
3226
|
+
);
|
|
3227
|
+
const reject = filtered.find(
|
|
3228
|
+
(action) => action.status === ActionStatus.Rejected
|
|
3229
|
+
);
|
|
3230
|
+
return {
|
|
3231
|
+
reject,
|
|
3232
|
+
accept,
|
|
3233
|
+
request
|
|
3234
|
+
};
|
|
3166
3235
|
}
|
|
3167
|
-
|
|
3168
|
-
|
|
3169
|
-
|
|
3170
|
-
|
|
3171
|
-
|
|
3172
|
-
|
|
3236
|
+
function getDeclarationActionCreationMetadata(actionType, actions) {
|
|
3237
|
+
const { accept: acceptAction, request: requestAction } = getActionRequests(
|
|
3238
|
+
actionType,
|
|
3239
|
+
actions
|
|
3240
|
+
);
|
|
3241
|
+
if (!acceptAction) {
|
|
3242
|
+
return null;
|
|
3173
3243
|
}
|
|
3174
|
-
|
|
3175
|
-
}
|
|
3176
|
-
(0, import_ajv_formats.default)(ajv);
|
|
3177
|
-
function buildClientFunctionContext(input) {
|
|
3244
|
+
const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
|
|
3178
3245
|
return {
|
|
3179
|
-
|
|
3180
|
-
|
|
3181
|
-
|
|
3182
|
-
|
|
3183
|
-
|
|
3184
|
-
|
|
3185
|
-
|
|
3186
|
-
|
|
3187
|
-
$window: input.systemVariables?.$window,
|
|
3188
|
-
locations: input.locations,
|
|
3189
|
-
adminLevelIds: input.adminLevelIds
|
|
3246
|
+
// When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
|
|
3247
|
+
createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
|
|
3248
|
+
createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
|
|
3249
|
+
createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
|
|
3250
|
+
createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
|
|
3251
|
+
acceptedAt: acceptAction.createdAt,
|
|
3252
|
+
createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
|
|
3253
|
+
registrationNumber
|
|
3190
3254
|
};
|
|
3191
3255
|
}
|
|
3192
|
-
|
|
3193
|
-
|
|
3256
|
+
var updateActions = ActionTypes.extract([
|
|
3257
|
+
ActionType.CREATE,
|
|
3258
|
+
ActionType.NOTIFY,
|
|
3259
|
+
ActionType.EDIT,
|
|
3260
|
+
ActionType.DECLARE,
|
|
3261
|
+
ActionType.REGISTER,
|
|
3262
|
+
ActionType.REJECT,
|
|
3263
|
+
ActionType.ARCHIVE,
|
|
3264
|
+
ActionType.UNARCHIVE,
|
|
3265
|
+
ActionType.PRINT_CERTIFICATE,
|
|
3266
|
+
ActionType.REQUEST_CORRECTION,
|
|
3267
|
+
ActionType.APPROVE_CORRECTION,
|
|
3268
|
+
ActionType.REJECT_CORRECTION,
|
|
3269
|
+
ActionType.CUSTOM
|
|
3270
|
+
]);
|
|
3271
|
+
function getActionUpdateMetadata(actions) {
|
|
3272
|
+
const createAction = getOrThrow(
|
|
3273
|
+
actions.find((action) => action.type === ActionType.CREATE),
|
|
3274
|
+
`Event has no ${ActionType.CREATE} action`
|
|
3275
|
+
);
|
|
3276
|
+
const metadataFields = [
|
|
3277
|
+
"createdAt",
|
|
3278
|
+
"createdBy",
|
|
3279
|
+
"createdByUserType",
|
|
3280
|
+
"createdAtLocation",
|
|
3281
|
+
"createdByRole"
|
|
3282
|
+
];
|
|
3283
|
+
return actions.filter(({ type }) => updateActions.safeParse(type).success).reduce(
|
|
3284
|
+
(_2, action) => {
|
|
3285
|
+
if (action.originalActionId) {
|
|
3286
|
+
const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
|
|
3287
|
+
return (0, import_lodash.pick)(originalAction, metadataFields);
|
|
3288
|
+
}
|
|
3289
|
+
return (0, import_lodash.pick)(action, metadataFields);
|
|
3290
|
+
},
|
|
3291
|
+
(0, import_lodash.pick)(createAction, metadataFields)
|
|
3292
|
+
);
|
|
3194
3293
|
}
|
|
3195
|
-
|
|
3196
|
-
|
|
3197
|
-
|
|
3198
|
-
|
|
3199
|
-
|
|
3200
|
-
|
|
3201
|
-
|
|
3202
|
-
|
|
3203
|
-
|
|
3204
|
-
|
|
3205
|
-
|
|
3206
|
-
|
|
3207
|
-
|
|
3208
|
-
|
|
3209
|
-
|
|
3210
|
-
|
|
3211
|
-
|
|
3212
|
-
|
|
3213
|
-
|
|
3214
|
-
|
|
3215
|
-
|
|
3216
|
-
|
|
3217
|
-
|
|
3218
|
-
|
|
3219
|
-
|
|
3220
|
-
|
|
3221
|
-
|
|
3222
|
-
|
|
3223
|
-
|
|
3224
|
-
|
|
3225
|
-
|
|
3226
|
-
|
|
3294
|
+
function getLegalStatuses(actions) {
|
|
3295
|
+
return {
|
|
3296
|
+
[EventStatus.enum.NOTIFIED]: getDeclarationActionCreationMetadata(
|
|
3297
|
+
ActionType.NOTIFY,
|
|
3298
|
+
actions
|
|
3299
|
+
),
|
|
3300
|
+
[EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
|
|
3301
|
+
ActionType.DECLARE,
|
|
3302
|
+
actions
|
|
3303
|
+
),
|
|
3304
|
+
[EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
|
|
3305
|
+
ActionType.REGISTER,
|
|
3306
|
+
actions
|
|
3307
|
+
)
|
|
3308
|
+
};
|
|
3309
|
+
}
|
|
3310
|
+
|
|
3311
|
+
// ../commons/src/events/state/flags.ts
|
|
3312
|
+
var import_lodash2 = require("lodash");
|
|
3313
|
+
var import_date_fns = require("date-fns");
|
|
3314
|
+
function isFlagConditionMet(conditional, form, action) {
|
|
3315
|
+
const now2 = (0, import_date_fns.isValid)((0, import_date_fns.parseISO)(action.createdAt)) ? (0, import_date_fns.formatISO)((0, import_date_fns.parseISO)(action.createdAt), { representation: "date" }) : (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
3316
|
+
return validate(conditional, {
|
|
3317
|
+
$form: form,
|
|
3318
|
+
$now: now2,
|
|
3319
|
+
$online: true,
|
|
3320
|
+
$user: {
|
|
3321
|
+
sub: "",
|
|
3322
|
+
exp: "",
|
|
3323
|
+
role: action.createdByRole,
|
|
3324
|
+
algorithm: "",
|
|
3325
|
+
scope: [],
|
|
3326
|
+
userType: action.createdByUserType
|
|
3227
3327
|
}
|
|
3228
|
-
|
|
3229
|
-
|
|
3230
|
-
|
|
3231
|
-
|
|
3232
|
-
|
|
3233
|
-
keyword: "isLeafLevelLocation",
|
|
3234
|
-
type: "string",
|
|
3235
|
-
schemaType: "boolean",
|
|
3236
|
-
$data: true,
|
|
3237
|
-
errors: true,
|
|
3238
|
-
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
3239
|
-
validate(_schema, data, _2, dataContext) {
|
|
3240
|
-
const locationIdInput = data;
|
|
3241
|
-
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
3242
|
-
return locations.some((location) => location.id === locationIdInput);
|
|
3243
|
-
}
|
|
3244
|
-
});
|
|
3245
|
-
ajv.addKeyword({
|
|
3246
|
-
keyword: "customClientValidator",
|
|
3247
|
-
schemaType: "object",
|
|
3248
|
-
errors: true,
|
|
3249
|
-
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
3250
|
-
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
3251
|
-
// so the cast holds.
|
|
3252
|
-
validate(schema, data, _2, dataContext) {
|
|
3253
|
-
return Boolean(
|
|
3254
|
-
runClientFunction(
|
|
3255
|
-
schema.code,
|
|
3256
|
-
data,
|
|
3257
|
-
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
3258
|
-
)
|
|
3259
|
-
);
|
|
3328
|
+
});
|
|
3329
|
+
}
|
|
3330
|
+
function actionConfigRemovesFlag(action, flagId, actionsUpToAndIncluding, event2, eventConfiguration) {
|
|
3331
|
+
if (!isActionConfigType(action.type)) {
|
|
3332
|
+
return false;
|
|
3260
3333
|
}
|
|
3261
|
-
|
|
3262
|
-
|
|
3263
|
-
|
|
3264
|
-
|
|
3334
|
+
const actionConfig = getActionConfig({
|
|
3335
|
+
eventConfiguration,
|
|
3336
|
+
actionType: action.type,
|
|
3337
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3338
|
+
});
|
|
3339
|
+
const removeOperations = (actionConfig?.flags ?? []).filter(
|
|
3340
|
+
({ id, operation }) => id === flagId && operation === "remove"
|
|
3341
|
+
);
|
|
3342
|
+
if (removeOperations.length === 0) {
|
|
3343
|
+
return false;
|
|
3265
3344
|
}
|
|
3266
|
-
|
|
3345
|
+
const eventUpToThisAction = { ...event2, actions: actionsUpToAndIncluding };
|
|
3346
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3347
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3348
|
+
const form = { ...declaration, ...annotation };
|
|
3349
|
+
return removeOperations.some(
|
|
3350
|
+
({ conditional }) => conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3351
|
+
);
|
|
3267
3352
|
}
|
|
3268
|
-
|
|
3269
|
-
|
|
3270
|
-
|
|
3271
|
-
|
|
3272
|
-
|
|
3273
|
-
|
|
3274
|
-
|
|
3275
|
-
|
|
3276
|
-
|
|
3277
|
-
|
|
3278
|
-
|
|
3279
|
-
|
|
3280
|
-
|
|
3281
|
-
|
|
3282
|
-
}
|
|
3283
|
-
|
|
3284
|
-
|
|
3353
|
+
var INHERENT_FLAG_RULES = [
|
|
3354
|
+
{
|
|
3355
|
+
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
3356
|
+
setOn: [ActionType.REQUEST_CORRECTION],
|
|
3357
|
+
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
3358
|
+
},
|
|
3359
|
+
{
|
|
3360
|
+
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
3361
|
+
// other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
|
|
3362
|
+
// are deliberately excluded so the flag freezes across an archive/unarchive
|
|
3363
|
+
// round trip and comes back exactly as it was.
|
|
3364
|
+
flag: InherentFlags.INCOMPLETE,
|
|
3365
|
+
setOn: [ActionType.NOTIFY],
|
|
3366
|
+
resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
|
|
3367
|
+
},
|
|
3368
|
+
{
|
|
3369
|
+
flag: InherentFlags.REJECTED,
|
|
3370
|
+
setOn: [ActionType.REJECT],
|
|
3371
|
+
resetOn: [
|
|
3372
|
+
ActionType.NOTIFY,
|
|
3373
|
+
ActionType.DECLARE,
|
|
3374
|
+
ActionType.EDIT,
|
|
3375
|
+
ActionType.REGISTER
|
|
3376
|
+
]
|
|
3377
|
+
},
|
|
3378
|
+
{
|
|
3379
|
+
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
3380
|
+
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
3381
|
+
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
3382
|
+
},
|
|
3383
|
+
{
|
|
3384
|
+
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
3385
|
+
setOn: [ActionType.EDIT],
|
|
3386
|
+
resetOnAnyOtherAction: true
|
|
3285
3387
|
}
|
|
3286
|
-
|
|
3287
|
-
|
|
3288
|
-
|
|
3289
|
-
|
|
3388
|
+
];
|
|
3389
|
+
function resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration) {
|
|
3390
|
+
return acceptedActions.reduce((present, action, idx) => {
|
|
3391
|
+
if (rule.setOn.includes(action.type)) {
|
|
3392
|
+
return true;
|
|
3290
3393
|
}
|
|
3291
|
-
|
|
3292
|
-
|
|
3394
|
+
if (rule.resetOnAnyOtherAction || (rule.resetOn ?? []).includes(action.type)) {
|
|
3395
|
+
return false;
|
|
3396
|
+
}
|
|
3397
|
+
if (actionConfigRemovesFlag(
|
|
3398
|
+
action,
|
|
3399
|
+
rule.flag,
|
|
3400
|
+
acceptedActions.slice(0, idx + 1),
|
|
3401
|
+
event2,
|
|
3402
|
+
eventConfiguration
|
|
3403
|
+
)) {
|
|
3404
|
+
return false;
|
|
3405
|
+
}
|
|
3406
|
+
return present;
|
|
3407
|
+
}, false);
|
|
3293
3408
|
}
|
|
3294
|
-
|
|
3295
|
-
|
|
3296
|
-
|
|
3297
|
-
|
|
3298
|
-
|
|
3409
|
+
function resolveEventCustomFlags(event2, eventConfiguration) {
|
|
3410
|
+
const actions = getAcceptedActions(event2).filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3411
|
+
return actions.reduce((acc, action, idx) => {
|
|
3412
|
+
let actionConfig;
|
|
3413
|
+
if (isActionConfigType(action.type)) {
|
|
3414
|
+
actionConfig = getActionConfig({
|
|
3415
|
+
eventConfiguration,
|
|
3416
|
+
actionType: action.type,
|
|
3417
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3418
|
+
});
|
|
3419
|
+
}
|
|
3420
|
+
if (!actionConfig) {
|
|
3421
|
+
return acc;
|
|
3422
|
+
}
|
|
3423
|
+
const eventUpToThisAction = {
|
|
3424
|
+
...event2,
|
|
3425
|
+
actions: actions.slice(0, idx + 1)
|
|
3426
|
+
};
|
|
3427
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3428
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3429
|
+
const form = { ...declaration, ...annotation };
|
|
3430
|
+
const flagsWithMetConditions = (actionConfig.flags ?? []).filter(
|
|
3431
|
+
({ conditional }) => (
|
|
3432
|
+
// If conditional is not provided, the flag is resolved
|
|
3433
|
+
conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3434
|
+
)
|
|
3435
|
+
);
|
|
3436
|
+
const addedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "add").map(({ id }) => id);
|
|
3437
|
+
const removedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "remove").map(({ id }) => id);
|
|
3438
|
+
const flags = [...acc, ...addedFlags].filter(
|
|
3439
|
+
(flagId) => !removedFlags.includes(flagId)
|
|
3440
|
+
);
|
|
3441
|
+
return (0, import_lodash2.uniq)(flags);
|
|
3442
|
+
}, []);
|
|
3299
3443
|
}
|
|
3300
|
-
|
|
3301
|
-
|
|
3302
|
-
|
|
3303
|
-
|
|
3304
|
-
|
|
3305
|
-
|
|
3306
|
-
|
|
3307
|
-
|
|
3308
|
-
|
|
3309
|
-
|
|
3310
|
-
|
|
3311
|
-
|
|
3312
|
-
|
|
3313
|
-
|
|
3314
|
-
|
|
3315
|
-
|
|
3316
|
-
|
|
3444
|
+
function getActionStatusFlags(sortedActions) {
|
|
3445
|
+
const actionStatus = sortedActions.reduce(
|
|
3446
|
+
(actionStatuses, { type, status }) => ({
|
|
3447
|
+
...actionStatuses,
|
|
3448
|
+
[type]: status
|
|
3449
|
+
}),
|
|
3450
|
+
{}
|
|
3451
|
+
);
|
|
3452
|
+
return Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
|
|
3453
|
+
const flag = joinValues([type, status], ":").toLowerCase();
|
|
3454
|
+
return flag;
|
|
3455
|
+
});
|
|
3456
|
+
}
|
|
3457
|
+
function getInherentFlags(sortedActions, event2, eventConfiguration) {
|
|
3458
|
+
const acceptedActions = sortedActions.filter(
|
|
3459
|
+
({ status }) => status === ActionStatus.Accepted
|
|
3460
|
+
);
|
|
3461
|
+
return INHERENT_FLAG_RULES.filter(
|
|
3462
|
+
(rule) => resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration)
|
|
3463
|
+
).map(({ flag }) => flag);
|
|
3464
|
+
}
|
|
3465
|
+
function getEventFlags(event2, config) {
|
|
3466
|
+
const sortedActions = event2.actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3467
|
+
return [
|
|
3468
|
+
...getActionStatusFlags(sortedActions),
|
|
3469
|
+
...getInherentFlags(sortedActions, event2, config),
|
|
3470
|
+
...resolveEventCustomFlags(event2, config)
|
|
3471
|
+
];
|
|
3317
3472
|
}
|
|
3318
|
-
var findAllFields = (config) => {
|
|
3319
|
-
return (0, import_lodash.flattenDeep)([
|
|
3320
|
-
...getDeclarationFields(config),
|
|
3321
|
-
...getAllAnnotationFields(config)
|
|
3322
|
-
]);
|
|
3323
|
-
};
|
|
3324
|
-
var EXCLUDED_ACTIONS = [
|
|
3325
|
-
ActionType.REQUEST_CORRECTION,
|
|
3326
|
-
ActionType.PRINT_CERTIFICATE,
|
|
3327
|
-
ActionType.REJECT_CORRECTION
|
|
3328
|
-
];
|
|
3329
3473
|
|
|
3330
3474
|
// ../commons/src/conditionals/conditionals.ts
|
|
3331
3475
|
var objectHash = __toESM(require("object-hash"));
|
|
@@ -3854,84 +3998,590 @@ function createFieldConditionals(fieldId) {
|
|
|
3854
3998
|
},
|
|
3855
3999
|
this.$$subfield
|
|
3856
4000
|
)
|
|
3857
|
-
},
|
|
3858
|
-
required: [fieldId]
|
|
3859
|
-
});
|
|
3860
|
-
},
|
|
3861
|
-
getId: () => ({ fieldId }),
|
|
3862
|
-
/**
|
|
3863
|
-
* @deprecated
|
|
3864
|
-
* use field(fieldId).get(nestedProperty) instead
|
|
3865
|
-
* with 'and' combinator e.g.
|
|
3866
|
-
* and(
|
|
3867
|
-
* field('child.name').get('firstname').isEqualTo('John'),
|
|
3868
|
-
* field('child.name').get('surname').isEqualTo('Doe')
|
|
3869
|
-
* )
|
|
3870
|
-
*/
|
|
3871
|
-
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
3872
|
-
object: (options) => defineFormConditional({
|
|
3873
|
-
type: "object",
|
|
3874
|
-
properties: {
|
|
3875
|
-
[fieldId]: {
|
|
3876
|
-
type: "object",
|
|
3877
|
-
properties: Object.fromEntries(
|
|
3878
|
-
Object.entries(options).map(([key, value]) => {
|
|
3879
|
-
return [key, value.properties.$form.properties[key]];
|
|
3880
|
-
})
|
|
3881
|
-
),
|
|
3882
|
-
required: Object.keys(options)
|
|
4001
|
+
},
|
|
4002
|
+
required: [fieldId]
|
|
4003
|
+
});
|
|
4004
|
+
},
|
|
4005
|
+
getId: () => ({ fieldId }),
|
|
4006
|
+
/**
|
|
4007
|
+
* @deprecated
|
|
4008
|
+
* use field(fieldId).get(nestedProperty) instead
|
|
4009
|
+
* with 'and' combinator e.g.
|
|
4010
|
+
* and(
|
|
4011
|
+
* field('child.name').get('firstname').isEqualTo('John'),
|
|
4012
|
+
* field('child.name').get('surname').isEqualTo('Doe')
|
|
4013
|
+
* )
|
|
4014
|
+
*/
|
|
4015
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
4016
|
+
object: (options) => defineFormConditional({
|
|
4017
|
+
type: "object",
|
|
4018
|
+
properties: {
|
|
4019
|
+
[fieldId]: {
|
|
4020
|
+
type: "object",
|
|
4021
|
+
properties: Object.fromEntries(
|
|
4022
|
+
Object.entries(options).map(([key, value]) => {
|
|
4023
|
+
return [key, value.properties.$form.properties[key]];
|
|
4024
|
+
})
|
|
4025
|
+
),
|
|
4026
|
+
required: Object.keys(options)
|
|
4027
|
+
}
|
|
4028
|
+
},
|
|
4029
|
+
required: [fieldId]
|
|
4030
|
+
}),
|
|
4031
|
+
/**
|
|
4032
|
+
* Custom client-side validator. The provided function is serialised and executed
|
|
4033
|
+
* just-in-time on the client only. External references (e.g. lodash) are not
|
|
4034
|
+
* available inside the function body — all logic must be self-contained.
|
|
4035
|
+
*
|
|
4036
|
+
* @example
|
|
4037
|
+
* field('nid').customClientValidator((value) => {
|
|
4038
|
+
* // LUHN check — all logic must be inline
|
|
4039
|
+
* const digits = String(value).split('').map(Number)
|
|
4040
|
+
* // ...
|
|
4041
|
+
* return isValid
|
|
4042
|
+
* })
|
|
4043
|
+
*/
|
|
4044
|
+
customClientValidator(validationFn) {
|
|
4045
|
+
const code = validationFn.toString();
|
|
4046
|
+
return defineFormConditional({
|
|
4047
|
+
type: "object",
|
|
4048
|
+
properties: wrapToPath(
|
|
4049
|
+
{ [fieldId]: { customClientValidator: { code } } },
|
|
4050
|
+
this.$$subfield
|
|
4051
|
+
),
|
|
4052
|
+
required: [fieldId]
|
|
4053
|
+
});
|
|
4054
|
+
},
|
|
4055
|
+
/**
|
|
4056
|
+
* Custom client-side evaluation. Returns a {@link FieldReference} descriptor
|
|
4057
|
+
* that can be used as the `value` property or a DATA component entry.
|
|
4058
|
+
* The function receives the referenced field's value as the first argument and
|
|
4059
|
+
* the full form context as the second; its return value replaces the field reference.
|
|
4060
|
+
* The function is serialised and executed just-in-time on the client only.
|
|
4061
|
+
* External references (e.g. lodash) are not available inside the function body.
|
|
4062
|
+
*
|
|
4063
|
+
* For computing a default value without referencing a specific field, use
|
|
4064
|
+
* `evaluate(fn)` in the `defaultValue` property instead.
|
|
4065
|
+
*
|
|
4066
|
+
* @example
|
|
4067
|
+
* field('a').customClientEvaluation((aValue, ctx) =>
|
|
4068
|
+
* Number(aValue) + Number(ctx.$form.b)
|
|
4069
|
+
* )
|
|
4070
|
+
*/
|
|
4071
|
+
customClientEvaluation(computationFn) {
|
|
4072
|
+
return {
|
|
4073
|
+
$$code: computationFn.toString(),
|
|
4074
|
+
$$field: fieldId,
|
|
4075
|
+
$$subfield: this.$$subfield
|
|
4076
|
+
};
|
|
4077
|
+
}
|
|
4078
|
+
};
|
|
4079
|
+
}
|
|
4080
|
+
|
|
4081
|
+
// ../commons/src/events/state/index.ts
|
|
4082
|
+
function getStatusFromActions(actions) {
|
|
4083
|
+
const acceptedActions = actions.filter(
|
|
4084
|
+
({ status }) => status === ActionStatus.Accepted
|
|
4085
|
+
);
|
|
4086
|
+
const isCurrentlyArchived = acceptedActions.reduce(
|
|
4087
|
+
(archived, action) => {
|
|
4088
|
+
if (action.type === ActionType.ARCHIVE) {
|
|
4089
|
+
return true;
|
|
4090
|
+
}
|
|
4091
|
+
if (action.type === ActionType.UNARCHIVE) {
|
|
4092
|
+
return false;
|
|
4093
|
+
}
|
|
4094
|
+
return archived;
|
|
4095
|
+
},
|
|
4096
|
+
false
|
|
4097
|
+
);
|
|
4098
|
+
if (isCurrentlyArchived) {
|
|
4099
|
+
return EventStatus.enum.ARCHIVED;
|
|
4100
|
+
}
|
|
4101
|
+
return acceptedActions.filter(
|
|
4102
|
+
({ type }) => type !== ActionType.ARCHIVE && type !== ActionType.UNARCHIVE
|
|
4103
|
+
).reduce((status, action) => {
|
|
4104
|
+
switch (action.type) {
|
|
4105
|
+
case ActionType.CREATE:
|
|
4106
|
+
return EventStatus.enum.CREATED;
|
|
4107
|
+
case ActionType.DECLARE:
|
|
4108
|
+
return EventStatus.enum.DECLARED;
|
|
4109
|
+
case ActionType.REGISTER:
|
|
4110
|
+
return EventStatus.enum.REGISTERED;
|
|
4111
|
+
case ActionType.NOTIFY:
|
|
4112
|
+
return EventStatus.enum.NOTIFIED;
|
|
4113
|
+
// Already filtered out above; listed here only to satisfy exhaustiveness.
|
|
4114
|
+
case ActionType.ARCHIVE:
|
|
4115
|
+
case ActionType.UNARCHIVE:
|
|
4116
|
+
case ActionType.CUSTOM:
|
|
4117
|
+
case ActionType.PRINT_CERTIFICATE:
|
|
4118
|
+
case ActionType.ASSIGN:
|
|
4119
|
+
case ActionType.UNASSIGN:
|
|
4120
|
+
case ActionType.REJECT:
|
|
4121
|
+
case ActionType.REQUEST_CORRECTION:
|
|
4122
|
+
case ActionType.APPROVE_CORRECTION:
|
|
4123
|
+
case ActionType.DUPLICATE_DETECTED:
|
|
4124
|
+
case ActionType.MARK_AS_NOT_DUPLICATE:
|
|
4125
|
+
case ActionType.MARK_AS_DUPLICATE:
|
|
4126
|
+
case ActionType.REJECT_CORRECTION:
|
|
4127
|
+
case ActionType.READ:
|
|
4128
|
+
case ActionType.EDIT:
|
|
4129
|
+
default:
|
|
4130
|
+
return status;
|
|
4131
|
+
}
|
|
4132
|
+
}, EventStatus.enum.CREATED);
|
|
4133
|
+
}
|
|
4134
|
+
function getAssignedUserFromActions(actions) {
|
|
4135
|
+
return actions.reduce((user2, action) => {
|
|
4136
|
+
if (action.type === ActionType.ASSIGN) {
|
|
4137
|
+
return action.assignedTo;
|
|
4138
|
+
}
|
|
4139
|
+
if (action.type === ActionType.UNASSIGN) {
|
|
4140
|
+
return null;
|
|
4141
|
+
}
|
|
4142
|
+
return user2;
|
|
4143
|
+
}, null);
|
|
4144
|
+
}
|
|
4145
|
+
function deepDropNulls(obj) {
|
|
4146
|
+
if (Array.isArray(obj)) {
|
|
4147
|
+
return obj.map(deepDropNulls);
|
|
4148
|
+
}
|
|
4149
|
+
if (obj !== null && typeof obj === "object") {
|
|
4150
|
+
return Object.entries(obj).reduce((acc, [key, value]) => {
|
|
4151
|
+
const cleanedValue = deepDropNulls(value);
|
|
4152
|
+
if (cleanedValue !== null) {
|
|
4153
|
+
;
|
|
4154
|
+
acc[key] = cleanedValue;
|
|
4155
|
+
}
|
|
4156
|
+
return acc;
|
|
4157
|
+
}, {});
|
|
4158
|
+
}
|
|
4159
|
+
return obj;
|
|
4160
|
+
}
|
|
4161
|
+
var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
|
|
4162
|
+
function extractDateString(dateTime) {
|
|
4163
|
+
return dateTime.split("T")[0];
|
|
4164
|
+
}
|
|
4165
|
+
function resolveDateOfEvent(eventIndex, declaration, config) {
|
|
4166
|
+
if (!config.dateOfEvent) {
|
|
4167
|
+
return extractDateString(eventIndex[DEFAULT_DATE_OF_EVENT_PROPERTY]);
|
|
4168
|
+
}
|
|
4169
|
+
const parsedDate = isFieldReference(config.dateOfEvent) ? ZodDate.safeParse(declaration[config.dateOfEvent.$$field]) : ZodDateTime.safeParse(
|
|
4170
|
+
getMixedPath(eventIndex, config.dateOfEvent.$$event)
|
|
4171
|
+
);
|
|
4172
|
+
return parsedDate.success ? extractDateString(parsedDate.data) : void 0;
|
|
4173
|
+
}
|
|
4174
|
+
var DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
|
|
4175
|
+
function getParsedUUID(value, oldValue) {
|
|
4176
|
+
const parsed = UUID.safeParse(value);
|
|
4177
|
+
return parsed.success ? parsed.data : oldValue;
|
|
4178
|
+
}
|
|
4179
|
+
function resolvePlaceOfEvent(eventMetadata, declaration, config) {
|
|
4180
|
+
let placeOfEvent = getParsedUUID(
|
|
4181
|
+
eventMetadata[DEFAULT_PLACE_OF_EVENT_PROPERTY]
|
|
4182
|
+
);
|
|
4183
|
+
if (config.placeOfEvent) {
|
|
4184
|
+
const addressFieldValue = AddressFieldValue.safeParse(
|
|
4185
|
+
declaration[config.placeOfEvent.$$field]
|
|
4186
|
+
);
|
|
4187
|
+
if (addressFieldValue.success && addressFieldValue.data.addressType === AddressType.DOMESTIC && addressFieldValue.data.administrativeArea) {
|
|
4188
|
+
placeOfEvent = getParsedUUID(
|
|
4189
|
+
addressFieldValue.data.administrativeArea,
|
|
4190
|
+
placeOfEvent
|
|
4191
|
+
);
|
|
4192
|
+
} else {
|
|
4193
|
+
placeOfEvent = getParsedUUID(
|
|
4194
|
+
declaration[config.placeOfEvent.$$field],
|
|
4195
|
+
placeOfEvent
|
|
4196
|
+
);
|
|
4197
|
+
}
|
|
4198
|
+
}
|
|
4199
|
+
return placeOfEvent;
|
|
4200
|
+
}
|
|
4201
|
+
function extractPotentialDuplicatesFromActions(actions) {
|
|
4202
|
+
return actions.reduce((duplicates, action) => {
|
|
4203
|
+
if (action.type === ActionType.DUPLICATE_DETECTED) {
|
|
4204
|
+
duplicates = action.content.duplicates;
|
|
4205
|
+
}
|
|
4206
|
+
if (action.type === ActionType.MARK_AS_NOT_DUPLICATE || action.type === ActionType.MARK_AS_DUPLICATE) {
|
|
4207
|
+
duplicates = [];
|
|
4208
|
+
}
|
|
4209
|
+
return duplicates;
|
|
4210
|
+
}, []);
|
|
4211
|
+
}
|
|
4212
|
+
function getCurrentEventState(event2, config) {
|
|
4213
|
+
const sortedActions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4214
|
+
const creationAction = sortedActions.find(
|
|
4215
|
+
(action) => action.type === ActionType.CREATE
|
|
4216
|
+
);
|
|
4217
|
+
if (!creationAction) {
|
|
4218
|
+
throw new Error(`Event ${event2.id} has no creation action`);
|
|
4219
|
+
}
|
|
4220
|
+
const acceptedActions = getAcceptedActions(event2).sort(
|
|
4221
|
+
(a, b) => a.createdAt.localeCompare(b.createdAt)
|
|
4222
|
+
);
|
|
4223
|
+
const requestActionMetadata = getActionUpdateMetadata(sortedActions);
|
|
4224
|
+
const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
|
|
4225
|
+
const declaration = aggregateActionDeclarations(event2);
|
|
4226
|
+
const status = getStatusFromActions(sortedActions);
|
|
4227
|
+
const legalStatuses = getLegalStatuses(sortedActions);
|
|
4228
|
+
const base = deepDropNulls({
|
|
4229
|
+
id: event2.id,
|
|
4230
|
+
type: event2.type,
|
|
4231
|
+
status,
|
|
4232
|
+
legalStatuses,
|
|
4233
|
+
createdAt: creationAction.createdAt,
|
|
4234
|
+
createdBy: creationAction.createdBy,
|
|
4235
|
+
createdByUserType: creationAction.createdByUserType,
|
|
4236
|
+
createdAtLocation: creationAction.createdAtLocation,
|
|
4237
|
+
updatedAt: acceptedActionMetadata.createdAt,
|
|
4238
|
+
assignedTo: getAssignedUserFromActions(acceptedActions),
|
|
4239
|
+
updatedBy: requestActionMetadata.createdBy,
|
|
4240
|
+
updatedAtLocation: requestActionMetadata.createdAtLocation,
|
|
4241
|
+
declaration,
|
|
4242
|
+
trackingId: event2.trackingId,
|
|
4243
|
+
updatedByUserRole: requestActionMetadata.createdByRole,
|
|
4244
|
+
placeOfEvent: resolvePlaceOfEvent(
|
|
4245
|
+
{ createdAtLocation: creationAction.createdAtLocation },
|
|
4246
|
+
declaration,
|
|
4247
|
+
config
|
|
4248
|
+
),
|
|
4249
|
+
potentialDuplicates: extractPotentialDuplicatesFromActions(sortedActions),
|
|
4250
|
+
flags: getEventFlags(event2, config)
|
|
4251
|
+
});
|
|
4252
|
+
return deepDropNulls({
|
|
4253
|
+
...base,
|
|
4254
|
+
dateOfEvent: resolveDateOfEvent(base, declaration, config)
|
|
4255
|
+
});
|
|
4256
|
+
}
|
|
4257
|
+
|
|
4258
|
+
// ../commons/src/conditionals/validate.ts
|
|
4259
|
+
var ajv = new import__.default({
|
|
4260
|
+
$data: true,
|
|
4261
|
+
allowUnionTypes: true,
|
|
4262
|
+
strict: false
|
|
4263
|
+
// Allow minContains and other newer features
|
|
4264
|
+
});
|
|
4265
|
+
var DataContext = z32.object({
|
|
4266
|
+
rootData: z32.object({
|
|
4267
|
+
$leafAdminStructureLocationIds: z32.array(z32.object({ id: UUID }))
|
|
4268
|
+
})
|
|
4269
|
+
});
|
|
4270
|
+
function resolveDataPath(rootData, dataPath, instancePath) {
|
|
4271
|
+
const pathParts = dataPath.split("/");
|
|
4272
|
+
const levels = parseInt(pathParts[0], 10);
|
|
4273
|
+
const referencePath = pathParts.slice(1);
|
|
4274
|
+
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
4275
|
+
const traversedParts = instanceParts.slice(0, -levels);
|
|
4276
|
+
let current = rootData;
|
|
4277
|
+
for (const part of traversedParts) {
|
|
4278
|
+
if (current === null || current === void 0) {
|
|
4279
|
+
return void 0;
|
|
4280
|
+
}
|
|
4281
|
+
current = current[part];
|
|
4282
|
+
}
|
|
4283
|
+
for (const part of referencePath) {
|
|
4284
|
+
if (current === null || current === void 0) {
|
|
4285
|
+
return void 0;
|
|
4286
|
+
}
|
|
4287
|
+
current = current[part];
|
|
4288
|
+
}
|
|
4289
|
+
return current;
|
|
4290
|
+
}
|
|
4291
|
+
function todayISO() {
|
|
4292
|
+
return (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
4293
|
+
}
|
|
4294
|
+
var compiledFunctionCache = /* @__PURE__ */ new Map();
|
|
4295
|
+
function compileClientFunction(code) {
|
|
4296
|
+
let fn = compiledFunctionCache.get(code);
|
|
4297
|
+
if (!fn) {
|
|
4298
|
+
fn = new Function(`return (${code})`)();
|
|
4299
|
+
compiledFunctionCache.set(code, fn);
|
|
4300
|
+
}
|
|
4301
|
+
return fn;
|
|
4302
|
+
}
|
|
4303
|
+
(0, import_ajv_formats.default)(ajv);
|
|
4304
|
+
function buildClientFunctionContext(input) {
|
|
4305
|
+
const flags = input.validatorContext?.event && input.validatorContext?.eventConfig ? getCurrentEventState(
|
|
4306
|
+
input.validatorContext?.event,
|
|
4307
|
+
input.validatorContext?.eventConfig
|
|
4308
|
+
)?.flags : [];
|
|
4309
|
+
return {
|
|
4310
|
+
$form: input.form,
|
|
4311
|
+
$flags: flags,
|
|
4312
|
+
$now: todayISO(),
|
|
4313
|
+
// eslint-disable-next-line @typescript-eslint/no-use-before-define
|
|
4314
|
+
$online: isOnline(),
|
|
4315
|
+
$user: input.validatorContext?.user,
|
|
4316
|
+
$event: input.validatorContext?.event,
|
|
4317
|
+
$leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
|
|
4318
|
+
user: input.systemVariables?.user,
|
|
4319
|
+
$window: input.systemVariables?.$window,
|
|
4320
|
+
locations: input.locations,
|
|
4321
|
+
adminLevelIds: input.adminLevelIds
|
|
4322
|
+
};
|
|
4323
|
+
}
|
|
4324
|
+
function runClientFunction(code, data, context) {
|
|
4325
|
+
return compileClientFunction(code)(data, context);
|
|
4326
|
+
}
|
|
4327
|
+
ajv.addKeyword({
|
|
4328
|
+
keyword: "daysFromDate",
|
|
4329
|
+
type: "string",
|
|
4330
|
+
schemaType: "object",
|
|
4331
|
+
$data: true,
|
|
4332
|
+
errors: true,
|
|
4333
|
+
validate(schema, data, _2, dataContext) {
|
|
4334
|
+
if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
|
|
4335
|
+
throw new Error("Validation context must contain $now");
|
|
4336
|
+
}
|
|
4337
|
+
const { days, clause } = schema;
|
|
4338
|
+
if (typeof data !== "string") {
|
|
4339
|
+
return false;
|
|
4340
|
+
}
|
|
4341
|
+
const date = new Date(data);
|
|
4342
|
+
if (isNaN(date.getTime())) {
|
|
4343
|
+
return false;
|
|
4344
|
+
}
|
|
4345
|
+
let referenceDate = schema.referenceDate;
|
|
4346
|
+
if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
|
|
4347
|
+
referenceDate = resolveDataPath(
|
|
4348
|
+
dataContext.rootData,
|
|
4349
|
+
referenceDate.$data,
|
|
4350
|
+
dataContext.instancePath
|
|
4351
|
+
);
|
|
4352
|
+
}
|
|
4353
|
+
if (!referenceDate) {
|
|
4354
|
+
referenceDate = dataContext.rootData.$now;
|
|
4355
|
+
}
|
|
4356
|
+
const baseDate = new Date(referenceDate);
|
|
4357
|
+
if (isNaN(baseDate.getTime())) {
|
|
4358
|
+
return false;
|
|
4359
|
+
}
|
|
4360
|
+
const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
|
|
4361
|
+
return clause === "after" ? (0, import_date_fns2.isAfter)(date, offsetDate) : (0, import_date_fns2.isBefore)(date, offsetDate);
|
|
4362
|
+
}
|
|
4363
|
+
});
|
|
4364
|
+
ajv.addKeyword({
|
|
4365
|
+
keyword: "isLeafLevelLocation",
|
|
4366
|
+
type: "string",
|
|
4367
|
+
schemaType: "boolean",
|
|
4368
|
+
$data: true,
|
|
4369
|
+
errors: true,
|
|
4370
|
+
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
4371
|
+
validate(_schema, data, _2, dataContext) {
|
|
4372
|
+
const locationIdInput = data;
|
|
4373
|
+
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
4374
|
+
return locations.some((location) => location.id === locationIdInput);
|
|
4375
|
+
}
|
|
4376
|
+
});
|
|
4377
|
+
function isAgeValue(value) {
|
|
4378
|
+
return typeof value === "object" && value !== null && "age" in value && typeof value.age === "number";
|
|
4379
|
+
}
|
|
4380
|
+
ajv.addKeyword({
|
|
4381
|
+
keyword: "customClientValidator",
|
|
4382
|
+
schemaType: "object",
|
|
4383
|
+
errors: true,
|
|
4384
|
+
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
4385
|
+
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
4386
|
+
// so the cast holds.
|
|
4387
|
+
validate(schema, data, _2, dataContext) {
|
|
4388
|
+
return Boolean(
|
|
4389
|
+
runClientFunction(
|
|
4390
|
+
schema.code,
|
|
4391
|
+
data,
|
|
4392
|
+
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
4393
|
+
)
|
|
4394
|
+
);
|
|
4395
|
+
}
|
|
4396
|
+
});
|
|
4397
|
+
function validate(schema, data) {
|
|
4398
|
+
const validator = ajv.getSchema(schema.$id) || ajv.compile(schema);
|
|
4399
|
+
if ("$form" in data) {
|
|
4400
|
+
const entries = Object.entries(data.$form).map(([key, value]) => {
|
|
4401
|
+
if (!isAgeValue(value)) {
|
|
4402
|
+
return [key, value];
|
|
4403
|
+
}
|
|
4404
|
+
const age = value.age;
|
|
4405
|
+
const maybeAsOfDate = PlainDate.safeParse(data.$form[value.asOfDateRef]);
|
|
4406
|
+
return [
|
|
4407
|
+
key,
|
|
4408
|
+
{
|
|
4409
|
+
age,
|
|
4410
|
+
dob: ageToDate(
|
|
4411
|
+
age,
|
|
4412
|
+
maybeAsOfDate.success ? maybeAsOfDate.data : PlainDate.parse(data.$now)
|
|
4413
|
+
)
|
|
3883
4414
|
}
|
|
3884
|
-
|
|
3885
|
-
|
|
3886
|
-
|
|
3887
|
-
|
|
3888
|
-
|
|
3889
|
-
|
|
3890
|
-
|
|
3891
|
-
|
|
3892
|
-
|
|
3893
|
-
|
|
3894
|
-
|
|
3895
|
-
|
|
3896
|
-
|
|
3897
|
-
|
|
3898
|
-
|
|
3899
|
-
|
|
3900
|
-
|
|
3901
|
-
|
|
3902
|
-
|
|
3903
|
-
|
|
3904
|
-
|
|
3905
|
-
|
|
3906
|
-
|
|
3907
|
-
|
|
3908
|
-
|
|
3909
|
-
|
|
3910
|
-
|
|
3911
|
-
|
|
3912
|
-
|
|
3913
|
-
|
|
3914
|
-
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
|
|
3918
|
-
|
|
3919
|
-
|
|
3920
|
-
|
|
3921
|
-
|
|
3922
|
-
|
|
3923
|
-
|
|
3924
|
-
|
|
3925
|
-
|
|
3926
|
-
|
|
3927
|
-
|
|
3928
|
-
|
|
3929
|
-
|
|
3930
|
-
|
|
3931
|
-
|
|
3932
|
-
|
|
4415
|
+
];
|
|
4416
|
+
});
|
|
4417
|
+
data.$form = Object.fromEntries(entries);
|
|
4418
|
+
}
|
|
4419
|
+
const result = validator(data);
|
|
4420
|
+
return result;
|
|
4421
|
+
}
|
|
4422
|
+
function isOnline() {
|
|
4423
|
+
if (typeof window !== "undefined" && typeof navigator !== "undefined") {
|
|
4424
|
+
return navigator.onLine;
|
|
4425
|
+
}
|
|
4426
|
+
return true;
|
|
4427
|
+
}
|
|
4428
|
+
|
|
4429
|
+
// ../commons/src/events/utils.ts
|
|
4430
|
+
var import_date_fns3 = require("date-fns");
|
|
4431
|
+
function ageToDate(age, asOfDate) {
|
|
4432
|
+
const date = plainDateToLocalDate(asOfDate);
|
|
4433
|
+
return PlainDate.parse((0, import_date_fns3.format)((0, import_date_fns3.subYears)(date, age), "yyyy-MM-dd"));
|
|
4434
|
+
}
|
|
4435
|
+
function getDeclarationFields(configuration) {
|
|
4436
|
+
return configuration.declaration.pages.flatMap(({ fields }) => fields);
|
|
4437
|
+
}
|
|
4438
|
+
function isActionConfigType(type) {
|
|
4439
|
+
return actionConfigTypes.has(type);
|
|
4440
|
+
}
|
|
4441
|
+
function getActionConfig({
|
|
4442
|
+
eventConfiguration,
|
|
4443
|
+
actionType,
|
|
4444
|
+
customActionType
|
|
4445
|
+
}) {
|
|
4446
|
+
if (actionType === ActionType.NOTIFY) {
|
|
4447
|
+
return eventConfiguration.actions.find((a) => a.type === ActionType.NOTIFY) ?? eventConfiguration.actions.find((a) => a.type === ActionType.DECLARE);
|
|
4448
|
+
}
|
|
4449
|
+
return eventConfiguration.actions.find((a) => {
|
|
4450
|
+
if (a.type === ActionType.CUSTOM && customActionType) {
|
|
4451
|
+
return a.customActionType === customActionType;
|
|
4452
|
+
}
|
|
4453
|
+
return a.type === actionType;
|
|
4454
|
+
});
|
|
4455
|
+
}
|
|
4456
|
+
var getActionAnnotationFields = (actionConfig) => {
|
|
4457
|
+
if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
|
|
4458
|
+
return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
|
|
4459
|
+
}
|
|
4460
|
+
if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
|
|
4461
|
+
return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
|
|
4462
|
+
}
|
|
4463
|
+
const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
|
|
4464
|
+
const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
|
|
4465
|
+
return [...reviewFields, ...formFields];
|
|
4466
|
+
};
|
|
4467
|
+
function getAllAnnotationFields(config) {
|
|
4468
|
+
return (0, import_lodash4.flattenDeep)(config.actions.map(getActionAnnotationFields));
|
|
4469
|
+
}
|
|
4470
|
+
function deepMerge(currentDocument, actionDocument) {
|
|
4471
|
+
const currentDocumentClone = (0, import_lodash4.cloneDeep)(currentDocument);
|
|
4472
|
+
return (0, import_lodash4.mergeWith)(
|
|
4473
|
+
(0, import_lodash4.cloneDeep)(currentDocumentClone),
|
|
4474
|
+
actionDocument,
|
|
4475
|
+
(previousValue, incomingValue) => {
|
|
4476
|
+
if (incomingValue === void 0) {
|
|
4477
|
+
return previousValue;
|
|
4478
|
+
}
|
|
4479
|
+
if ((0, import_lodash4.isArray)(incomingValue)) {
|
|
4480
|
+
return incomingValue;
|
|
4481
|
+
}
|
|
4482
|
+
if ((0, import_lodash4.isObject)(previousValue) && (0, import_lodash4.isObject)(incomingValue)) {
|
|
4483
|
+
return void 0;
|
|
4484
|
+
}
|
|
4485
|
+
return incomingValue;
|
|
4486
|
+
}
|
|
4487
|
+
);
|
|
4488
|
+
}
|
|
4489
|
+
var findAllFields = (config) => {
|
|
4490
|
+
return (0, import_lodash4.flattenDeep)([
|
|
4491
|
+
...getDeclarationFields(config),
|
|
4492
|
+
...getAllAnnotationFields(config)
|
|
4493
|
+
]);
|
|
4494
|
+
};
|
|
4495
|
+
function getMixedPath(obj, path, defaultValue) {
|
|
4496
|
+
const parts = path.split(".");
|
|
4497
|
+
const resolve = (current, segments) => {
|
|
4498
|
+
if (current == null || segments.length === 0) {
|
|
4499
|
+
return current;
|
|
3933
4500
|
}
|
|
4501
|
+
for (let i = segments.length; i > 0; i--) {
|
|
4502
|
+
const compoundKey = segments.slice(0, i).join(".");
|
|
4503
|
+
if ((0, import_lodash4.has)(current, compoundKey)) {
|
|
4504
|
+
const next = (0, import_lodash4.get)(current, compoundKey);
|
|
4505
|
+
return resolve(next, segments.slice(i));
|
|
4506
|
+
}
|
|
4507
|
+
}
|
|
4508
|
+
return void 0;
|
|
3934
4509
|
};
|
|
4510
|
+
const result = resolve(obj, parts);
|
|
4511
|
+
return (0, import_lodash4.isNil)(result) ? defaultValue : result;
|
|
4512
|
+
}
|
|
4513
|
+
function isAcceptedAction(a) {
|
|
4514
|
+
return a.status === ActionStatus.Accepted;
|
|
4515
|
+
}
|
|
4516
|
+
function getCompleteActionAnnotation(event2, action) {
|
|
4517
|
+
if (action.originalActionId) {
|
|
4518
|
+
const originalAction = event2.actions.find(
|
|
4519
|
+
({ id }) => id === action.originalActionId
|
|
4520
|
+
);
|
|
4521
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4522
|
+
return deepMerge(originalAction.annotation ?? {}, action.annotation ?? {});
|
|
4523
|
+
}
|
|
4524
|
+
}
|
|
4525
|
+
return action.annotation ?? {};
|
|
4526
|
+
}
|
|
4527
|
+
function getCompleteActionDeclaration(declaration, event2, action) {
|
|
4528
|
+
if (action.originalActionId) {
|
|
4529
|
+
const originalAction = event2.actions.find(
|
|
4530
|
+
({ id }) => id === action.originalActionId
|
|
4531
|
+
);
|
|
4532
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4533
|
+
return deepMerge(
|
|
4534
|
+
deepMerge(declaration, originalAction.declaration),
|
|
4535
|
+
action.declaration
|
|
4536
|
+
);
|
|
4537
|
+
}
|
|
4538
|
+
}
|
|
4539
|
+
return deepMerge(declaration, action.declaration);
|
|
4540
|
+
}
|
|
4541
|
+
function getAcceptedActions(event2) {
|
|
4542
|
+
return event2.actions.filter(isAcceptedAction).map((action) => ({
|
|
4543
|
+
...action,
|
|
4544
|
+
declaration: getCompleteActionDeclaration({}, event2, action),
|
|
4545
|
+
annotation: getCompleteActionAnnotation(event2, action)
|
|
4546
|
+
}));
|
|
4547
|
+
}
|
|
4548
|
+
var EXCLUDED_ACTIONS = [
|
|
4549
|
+
ActionType.REQUEST_CORRECTION,
|
|
4550
|
+
ActionType.PRINT_CERTIFICATE,
|
|
4551
|
+
ActionType.REJECT_CORRECTION
|
|
4552
|
+
];
|
|
4553
|
+
function aggregateActionDeclarations(event2) {
|
|
4554
|
+
const allAcceptedActions = getAcceptedActions(event2);
|
|
4555
|
+
const aggregatedActions = allAcceptedActions.filter((a) => !EXCLUDED_ACTIONS.some((type) => type === a.type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4556
|
+
return aggregatedActions.reduce((declaration, action) => {
|
|
4557
|
+
if (action.type === ActionType.APPROVE_CORRECTION) {
|
|
4558
|
+
const requestAction = allAcceptedActions.find(
|
|
4559
|
+
({ id }) => id === action.requestId
|
|
4560
|
+
);
|
|
4561
|
+
if (!requestAction) {
|
|
4562
|
+
return declaration;
|
|
4563
|
+
}
|
|
4564
|
+
const declarationWithApprovedCorrection = getCompleteActionDeclaration(
|
|
4565
|
+
declaration,
|
|
4566
|
+
event2,
|
|
4567
|
+
requestAction
|
|
4568
|
+
);
|
|
4569
|
+
return getCompleteActionDeclaration(
|
|
4570
|
+
declarationWithApprovedCorrection,
|
|
4571
|
+
event2,
|
|
4572
|
+
action
|
|
4573
|
+
);
|
|
4574
|
+
}
|
|
4575
|
+
return getCompleteActionDeclaration(declaration, event2, action);
|
|
4576
|
+
}, {});
|
|
4577
|
+
}
|
|
4578
|
+
function aggregateActionAnnotations(event2) {
|
|
4579
|
+
return event2.actions.reduce((ann, sortedAction) => {
|
|
4580
|
+
if (!("annotation" in sortedAction) || !sortedAction.annotation) {
|
|
4581
|
+
return ann;
|
|
4582
|
+
}
|
|
4583
|
+
return deepMerge(ann, sortedAction.annotation);
|
|
4584
|
+
}, {});
|
|
3935
4585
|
}
|
|
3936
4586
|
|
|
3937
4587
|
// ../commons/src/events/eventConfigValidation.ts
|
|
@@ -4671,6 +5321,11 @@ var ArchiveActionInput = BaseActionInput.extend(
|
|
|
4671
5321
|
content: ReasonContent
|
|
4672
5322
|
}).shape
|
|
4673
5323
|
);
|
|
5324
|
+
var UnarchiveActionInput = BaseActionInput.extend(
|
|
5325
|
+
z38.object({
|
|
5326
|
+
type: z38.literal(ActionType.UNARCHIVE).default(ActionType.UNARCHIVE)
|
|
5327
|
+
}).shape
|
|
5328
|
+
);
|
|
4674
5329
|
var AssignActionInput = BaseActionInput.extend(
|
|
4675
5330
|
z38.object({
|
|
4676
5331
|
type: z38.literal(ActionType.ASSIGN),
|
|
@@ -4732,6 +5387,7 @@ var ActionInput = z38.discriminatedUnion("type", [
|
|
|
4732
5387
|
id: "MarkNotDuplicateActionInput"
|
|
4733
5388
|
}),
|
|
4734
5389
|
ArchiveActionInput.meta({ id: "ArchiveActionInput" }),
|
|
5390
|
+
UnarchiveActionInput.meta({ id: "UnarchiveActionInput" }),
|
|
4735
5391
|
AssignActionInput.meta({ id: "AssignActionInput" }),
|
|
4736
5392
|
UnassignActionInput.meta({ id: "UnassignActionInput" }),
|
|
4737
5393
|
PrintCertificateActionInput.meta({ id: "PrintCertificateActionInput" }),
|
|
@@ -4772,14 +5428,14 @@ var DraftInput = BaseActionInput.omit({ waitFor: true }).extend({
|
|
|
4772
5428
|
|
|
4773
5429
|
// ../commons/src/events/EventInput.ts
|
|
4774
5430
|
var z40 = __toESM(require("zod/v4"));
|
|
4775
|
-
var
|
|
5431
|
+
var import_uuid11 = require("uuid");
|
|
4776
5432
|
var EventInput = z40.object({
|
|
4777
5433
|
transactionId: z40.string(),
|
|
4778
5434
|
type: z40.string(),
|
|
4779
5435
|
createdAtLocation: UUID.nullish().describe(
|
|
4780
5436
|
"Location where the event occurred. Required for system users."
|
|
4781
5437
|
)
|
|
4782
|
-
}).meta({ default: { transactionId: (0,
|
|
5438
|
+
}).meta({ default: { transactionId: (0, import_uuid11.v4)(), type: "birth" } });
|
|
4783
5439
|
|
|
4784
5440
|
// ../commons/src/events/EventDocument.ts
|
|
4785
5441
|
var z41 = __toESM(require("zod/v4"));
|
|
@@ -4796,69 +5452,6 @@ var EventDocument = z41.object({
|
|
|
4796
5452
|
)
|
|
4797
5453
|
}).meta({ id: "EventDocument" });
|
|
4798
5454
|
|
|
4799
|
-
// ../commons/src/events/state/index.ts
|
|
4800
|
-
var import_lodash4 = require("lodash");
|
|
4801
|
-
|
|
4802
|
-
// ../commons/src/events/state/utils.ts
|
|
4803
|
-
var import_lodash2 = require("lodash");
|
|
4804
|
-
var updateActions = ActionTypes.extract([
|
|
4805
|
-
ActionType.CREATE,
|
|
4806
|
-
ActionType.NOTIFY,
|
|
4807
|
-
ActionType.EDIT,
|
|
4808
|
-
ActionType.DECLARE,
|
|
4809
|
-
ActionType.REGISTER,
|
|
4810
|
-
ActionType.REJECT,
|
|
4811
|
-
ActionType.ARCHIVE,
|
|
4812
|
-
ActionType.PRINT_CERTIFICATE,
|
|
4813
|
-
ActionType.REQUEST_CORRECTION,
|
|
4814
|
-
ActionType.APPROVE_CORRECTION,
|
|
4815
|
-
ActionType.REJECT_CORRECTION,
|
|
4816
|
-
ActionType.CUSTOM
|
|
4817
|
-
]);
|
|
4818
|
-
|
|
4819
|
-
// ../commons/src/events/state/flags.ts
|
|
4820
|
-
var import_lodash3 = require("lodash");
|
|
4821
|
-
var import_date_fns3 = require("date-fns");
|
|
4822
|
-
var INHERENT_FLAG_RULES = [
|
|
4823
|
-
{
|
|
4824
|
-
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
4825
|
-
setOn: [ActionType.REQUEST_CORRECTION],
|
|
4826
|
-
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
4827
|
-
},
|
|
4828
|
-
{
|
|
4829
|
-
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
4830
|
-
// other status-changing action (see getStatusFromActions).
|
|
4831
|
-
flag: InherentFlags.INCOMPLETE,
|
|
4832
|
-
setOn: [ActionType.NOTIFY],
|
|
4833
|
-
resetOn: [
|
|
4834
|
-
ActionType.CREATE,
|
|
4835
|
-
ActionType.DECLARE,
|
|
4836
|
-
ActionType.REGISTER,
|
|
4837
|
-
ActionType.ARCHIVE
|
|
4838
|
-
]
|
|
4839
|
-
},
|
|
4840
|
-
{
|
|
4841
|
-
flag: InherentFlags.REJECTED,
|
|
4842
|
-
setOn: [ActionType.REJECT],
|
|
4843
|
-
resetOn: [
|
|
4844
|
-
ActionType.NOTIFY,
|
|
4845
|
-
ActionType.DECLARE,
|
|
4846
|
-
ActionType.EDIT,
|
|
4847
|
-
ActionType.REGISTER
|
|
4848
|
-
]
|
|
4849
|
-
},
|
|
4850
|
-
{
|
|
4851
|
-
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
4852
|
-
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
4853
|
-
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
4854
|
-
},
|
|
4855
|
-
{
|
|
4856
|
-
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
4857
|
-
setOn: [ActionType.EDIT],
|
|
4858
|
-
resetOnAnyOtherAction: true
|
|
4859
|
-
}
|
|
4860
|
-
];
|
|
4861
|
-
|
|
4862
5455
|
// ../commons/src/events/defineConfig.ts
|
|
4863
5456
|
var IGNORED_EVENT_TYPES = [
|
|
4864
5457
|
"FOOTBALL_CLUB_MEMBERSHIP",
|
|
@@ -7367,6 +7960,7 @@ var ACTION_SCOPE_MAP = {
|
|
|
7367
7960
|
[ActionType.MARK_AS_DUPLICATE]: ["record.review-duplicates"],
|
|
7368
7961
|
[ActionType.MARK_AS_NOT_DUPLICATE]: ["record.review-duplicates"],
|
|
7369
7962
|
[ActionType.ARCHIVE]: ["record.archive"],
|
|
7963
|
+
[ActionType.UNARCHIVE]: ["record.unarchive"],
|
|
7370
7964
|
[ActionType.REJECT]: ["record.reject"],
|
|
7371
7965
|
[ActionType.ASSIGN]: null,
|
|
7372
7966
|
[ActionType.UNASSIGN]: null,
|
|
@@ -7409,7 +8003,11 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
|
|
|
7409
8003
|
ActionType.CUSTOM,
|
|
7410
8004
|
ClientSpecificAction.REVIEW_CORRECTION_REQUEST
|
|
7411
8005
|
],
|
|
7412
|
-
[EventStatus.enum.ARCHIVED]: [
|
|
8006
|
+
[EventStatus.enum.ARCHIVED]: [
|
|
8007
|
+
ActionType.READ,
|
|
8008
|
+
ActionType.CUSTOM,
|
|
8009
|
+
ActionType.UNARCHIVE
|
|
8010
|
+
]
|
|
7413
8011
|
};
|
|
7414
8012
|
var ACTION_FILTERS = {
|
|
7415
8013
|
[ActionType.PRINT_CERTIFICATE]: (flags) => !flags.includes(InherentFlags.CORRECTION_REQUESTED) && !flags.some((flag) => flag.endsWith(":requested")),
|
|
@@ -7422,6 +8020,7 @@ var ACTION_FILTERS = {
|
|
|
7422
8020
|
[ActionType.REGISTER]: (flags) => !flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
|
|
7423
8021
|
[ActionType.REJECT]: (flags) => !flags.includes(InherentFlags.REJECTED) && !flags.some((flag) => flag.endsWith(":requested")),
|
|
7424
8022
|
[ActionType.ARCHIVE]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
|
|
8023
|
+
[ActionType.UNARCHIVE]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
|
|
7425
8024
|
[ActionType.ASSIGN]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
|
|
7426
8025
|
[ActionType.UNASSIGN]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
|
|
7427
8026
|
[ActionType.CUSTOM]: (flags) => !flags.some((flag) => flag.endsWith(":requested"))
|