@opencrvs/toolkit 2.1.0-rc.7f423f1 → 2.1.0-rc.811fc78
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 +200 -190
- package/dist/commons/api/router.d.ts +1516 -1692
- package/dist/commons/application-config/index.d.ts +6 -6
- package/dist/commons/conditionals/conditionals.d.ts +2102 -259
- package/dist/commons/conditionals/validate.d.ts +2 -1
- package/dist/commons/events/ActionConfig.d.ts +126 -105
- package/dist/commons/events/ActionDocument.d.ts +111 -117
- package/dist/commons/events/ActionStatus.d.ts +14 -0
- package/dist/commons/events/ActionType.d.ts +62 -62
- package/dist/commons/events/AdvancedSearchConfig.d.ts +513 -513
- package/dist/commons/events/AuditLog.d.ts +42 -104
- package/dist/commons/events/CompositeFieldValue.d.ts +4 -4
- package/dist/commons/events/Conditional.d.ts +3 -3
- package/dist/commons/events/CountryConfigQueryInput.d.ts +608 -590
- package/dist/commons/events/Draft.d.ts +37 -37
- package/dist/commons/events/DynamicFieldValue.d.ts +9 -9
- package/dist/commons/events/EventConfig.d.ts +5 -5
- package/dist/commons/events/EventDocument.d.ts +46 -46
- package/dist/commons/events/EventIndex.d.ts +52 -71
- package/dist/commons/events/EventMetadata.d.ts +41 -40
- package/dist/commons/events/FieldConfig.d.ts +342 -342
- package/dist/commons/events/FieldType.d.ts +51 -51
- package/dist/commons/events/FieldTypeMapping.d.ts +100 -100
- package/dist/commons/events/FieldValue.d.ts +12 -12
- package/dist/commons/events/Flag.d.ts +63 -15
- package/dist/commons/events/TemplateConfig.d.ts +1 -1
- package/dist/commons/events/WorkqueueColumnConfig.d.ts +40 -40
- package/dist/commons/events/WorkqueueConfig.d.ts +835 -820
- package/dist/commons/events/deduplication.d.ts +1 -1
- package/dist/commons/events/event.d.ts +2 -2
- package/dist/commons/events/field.d.ts +895 -78
- package/dist/commons/events/index.d.ts +0 -1
- package/dist/commons/events/locations.d.ts +6 -103
- package/dist/commons/events/mocks.test.utils.d.ts +4 -18
- package/dist/commons/events/scopes.d.ts +4 -4
- package/dist/commons/events/state/index.d.ts +17 -17
- package/dist/commons/events/state/utils.d.ts +7 -7
- package/dist/commons/events/test.utils.d.ts +40 -40
- package/dist/commons/events/utils.d.ts +114 -114
- package/dist/commons/notification/UserNotifications.d.ts +10 -10
- package/dist/conditionals/index.js +303 -56
- package/dist/environment/derived-variables.d.ts +119 -119
- package/dist/environment/derived-variables.d.ts.map +1 -1
- package/dist/environment/logger.d.ts.map +1 -1
- package/dist/environment/questions.d.ts +74 -75
- package/dist/environment/questions.d.ts.map +1 -1
- package/dist/environment/setup-environment.js +14 -8
- package/dist/environment/utils.d.ts +1 -1
- package/dist/events/deduplication.d.ts +1 -1
- package/dist/events/index.js +3278 -3355
- package/dist/migrations/v2.0/migrate-application-config-url.js +3 -4
- package/dist/notification/index.js +1492 -1018
- package/dist/scopes/index.d.ts +396 -148
- package/dist/scopes/index.js +304 -56
- package/opencrvs-toolkit-2.1.0-rc.811fc78.tgz +0 -0
- package/package.json +4 -3
- package/tsconfig.tsbuildinfo +1 -1
- package/dist/commons/events/locationPayloads.d.ts +0 -95
- package/opencrvs-toolkit-2.1.0-rc.7f423f1.tgz +0 -0
|
@@ -38,7 +38,7 @@ __export(notification_exports, {
|
|
|
38
38
|
triggerUserEventNotification: () => triggerUserEventNotification
|
|
39
39
|
});
|
|
40
40
|
module.exports = __toCommonJS(notification_exports);
|
|
41
|
-
var
|
|
41
|
+
var z45 = __toESM(require("zod/v4"));
|
|
42
42
|
|
|
43
43
|
// ../commons/src/url.ts
|
|
44
44
|
function joinUrl(base, path) {
|
|
@@ -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",
|
|
@@ -88,7 +340,7 @@ var RecordScopeTypeV2 = z2.enum([
|
|
|
88
340
|
"record.unassign-others",
|
|
89
341
|
"record.custom-action"
|
|
90
342
|
]);
|
|
91
|
-
var PlainScopeType =
|
|
343
|
+
var PlainScopeType = z6.enum([
|
|
92
344
|
// Misc. system scopes
|
|
93
345
|
"bypassratelimit",
|
|
94
346
|
"record.reindex",
|
|
@@ -96,7 +348,6 @@ var PlainScopeType = z2.enum([
|
|
|
96
348
|
"integration.create",
|
|
97
349
|
"record.import",
|
|
98
350
|
"config.update-all",
|
|
99
|
-
"location.edit",
|
|
100
351
|
"attachment.upload",
|
|
101
352
|
"profile.electronic-signature",
|
|
102
353
|
"user.read-only-my-audit",
|
|
@@ -108,15 +359,15 @@ var PlainScopeType = z2.enum([
|
|
|
108
359
|
"record.confirm-registration",
|
|
109
360
|
"record.reject-registration"
|
|
110
361
|
]);
|
|
111
|
-
var scopeByEvent =
|
|
362
|
+
var scopeByEvent = z6.preprocess(
|
|
112
363
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
113
|
-
|
|
364
|
+
z6.array(z6.string()).optional()
|
|
114
365
|
).describe("Event type, e.g. birth, death");
|
|
115
|
-
var userRole =
|
|
366
|
+
var userRole = z6.preprocess(
|
|
116
367
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
117
|
-
|
|
368
|
+
z6.array(z6.string()).optional()
|
|
118
369
|
).describe("User role, e.g. admin, field agent");
|
|
119
|
-
var scopeOptionsPlaceEvent =
|
|
370
|
+
var scopeOptionsPlaceEvent = z6.object({
|
|
120
371
|
event: scopeByEvent,
|
|
121
372
|
placeOfEvent: JurisdictionFilter.optional()
|
|
122
373
|
}).describe("Options applicable to all record scopes.");
|
|
@@ -128,36 +379,37 @@ var scopeOptionsDeclaredOrNotified = scopeOptionsPlaceEvent.extend({
|
|
|
128
379
|
}).describe("Options applicable to actions that may take place after DECLARE");
|
|
129
380
|
var AllRecordScopeOptions = scopeOptionsDeclaredOrNotified.extend({
|
|
130
381
|
registeredIn: JurisdictionFilter.optional(),
|
|
131
|
-
registeredBy: UserFilter.optional()
|
|
382
|
+
registeredBy: UserFilter.optional(),
|
|
383
|
+
flags: ContainsFlags.optional()
|
|
132
384
|
}).describe(
|
|
133
385
|
"Options applicable to actions that may take place after REGISTER, with full filtering capabilities."
|
|
134
386
|
);
|
|
135
387
|
var CustomActionScopeOptions = AllRecordScopeOptions.extend({
|
|
136
|
-
customActionTypes:
|
|
388
|
+
customActionTypes: z6.preprocess(
|
|
137
389
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
138
|
-
|
|
390
|
+
z6.array(z6.string()).optional()
|
|
139
391
|
).describe("Allowed custom action types")
|
|
140
392
|
});
|
|
141
|
-
var AccessLevelOptions =
|
|
393
|
+
var AccessLevelOptions = z6.object({
|
|
142
394
|
accessLevel: JurisdictionFilter.optional()
|
|
143
395
|
});
|
|
144
396
|
var AllUserScopeOptions = AccessLevelOptions.extend({
|
|
145
397
|
role: userRole.optional()
|
|
146
398
|
});
|
|
147
|
-
var WorkqueueOrDashboardOptions =
|
|
148
|
-
ids:
|
|
399
|
+
var WorkqueueOrDashboardOptions = z6.object({
|
|
400
|
+
ids: z6.preprocess(
|
|
149
401
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
150
|
-
|
|
402
|
+
z6.array(z6.string())
|
|
151
403
|
).describe("Must contain a list of workqueue or dashboard ids.")
|
|
152
404
|
});
|
|
153
|
-
var AllScopeOptions =
|
|
405
|
+
var AllScopeOptions = z6.object({
|
|
154
406
|
...AllRecordScopeOptions.shape,
|
|
155
407
|
...AccessLevelOptions.shape,
|
|
156
408
|
...AllUserScopeOptions.shape,
|
|
157
409
|
...WorkqueueOrDashboardOptions.shape
|
|
158
410
|
});
|
|
159
411
|
var ScopeOptionKey = AllScopeOptions.keyof();
|
|
160
|
-
var ResolvedScopeOptionsPlaceEvent =
|
|
412
|
+
var ResolvedScopeOptionsPlaceEvent = z6.object({
|
|
161
413
|
event: scopeByEvent,
|
|
162
414
|
placeOfEvent: UUID.nullish()
|
|
163
415
|
}).describe(
|
|
@@ -165,15 +417,16 @@ var ResolvedScopeOptionsPlaceEvent = z2.object({
|
|
|
165
417
|
);
|
|
166
418
|
var ResolvedScopeOptionsDeclared = ResolvedScopeOptionsPlaceEvent.extend({
|
|
167
419
|
notifiedIn: UUID.nullish(),
|
|
168
|
-
notifiedBy:
|
|
420
|
+
notifiedBy: z6.string().optional(),
|
|
169
421
|
declaredIn: UUID.nullish(),
|
|
170
|
-
declaredBy:
|
|
422
|
+
declaredBy: z6.string().optional()
|
|
171
423
|
}).describe(
|
|
172
424
|
"Resolved options applicable to actions that may take place after DECLARE, with location ID and user ID instead of filters."
|
|
173
425
|
);
|
|
174
426
|
var ResolvedScopeOptionsFull = ResolvedScopeOptionsDeclared.extend({
|
|
175
427
|
registeredIn: UUID.nullish(),
|
|
176
|
-
registeredBy:
|
|
428
|
+
registeredBy: z6.string().optional(),
|
|
429
|
+
flags: ContainsFlags.optional()
|
|
177
430
|
}).describe(
|
|
178
431
|
"Resolved options applicable to actions that may take place after REGISTER, with full filtering capabilities and location/user IDs instead of filters."
|
|
179
432
|
);
|
|
@@ -198,38 +451,38 @@ var ScopesWithFullOptions = RecordScopeTypeV2.extract([
|
|
|
198
451
|
"record.unassign-others"
|
|
199
452
|
]);
|
|
200
453
|
var ScopeOptionsPrintCertifiedCopies = AllRecordScopeOptions.extend({
|
|
201
|
-
templates:
|
|
454
|
+
templates: z6.preprocess(
|
|
202
455
|
(val) => val === void 0 ? void 0 : [val].flat(),
|
|
203
|
-
|
|
456
|
+
z6.array(z6.string()).optional()
|
|
204
457
|
).describe(
|
|
205
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."
|
|
206
459
|
)
|
|
207
460
|
});
|
|
208
|
-
var RecordScopeV2 =
|
|
209
|
-
|
|
461
|
+
var RecordScopeV2 = z6.discriminatedUnion("type", [
|
|
462
|
+
z6.object({
|
|
210
463
|
type: ScopesWithPlaceEventOptions,
|
|
211
464
|
options: scopeOptionsPlaceEvent.optional()
|
|
212
465
|
}),
|
|
213
|
-
|
|
466
|
+
z6.object({
|
|
214
467
|
type: ScopesWithDeclaredOptions,
|
|
215
468
|
options: scopeOptionsDeclaredOrNotified.optional()
|
|
216
469
|
}),
|
|
217
|
-
|
|
470
|
+
z6.object({
|
|
218
471
|
type: ScopesWithFullOptions,
|
|
219
472
|
options: AllRecordScopeOptions.optional()
|
|
220
473
|
}),
|
|
221
|
-
|
|
222
|
-
type:
|
|
474
|
+
z6.object({
|
|
475
|
+
type: z6.literal("record.custom-action"),
|
|
223
476
|
options: CustomActionScopeOptions.optional()
|
|
224
477
|
}),
|
|
225
|
-
|
|
226
|
-
type:
|
|
478
|
+
z6.object({
|
|
479
|
+
type: z6.literal("record.print-certified-copies"),
|
|
227
480
|
options: ScopeOptionsPrintCertifiedCopies.optional()
|
|
228
481
|
})
|
|
229
482
|
]).describe(
|
|
230
483
|
"Scopes used to check user's permission to perform actions on a record."
|
|
231
484
|
);
|
|
232
|
-
var SystemScopeType =
|
|
485
|
+
var SystemScopeType = z6.enum([
|
|
233
486
|
"organisation.read-locations",
|
|
234
487
|
"user.read",
|
|
235
488
|
"user.create",
|
|
@@ -243,61 +496,61 @@ var UserScopeType = SystemScopeType.extract([
|
|
|
243
496
|
"user.search"
|
|
244
497
|
]);
|
|
245
498
|
var ScopesWithRoleOption = UserScopeType.extract(["user.edit", "user.create"]);
|
|
246
|
-
var UserScopeV2 =
|
|
247
|
-
|
|
499
|
+
var UserScopeV2 = z6.discriminatedUnion("type", [
|
|
500
|
+
z6.object({
|
|
248
501
|
type: ScopesWithRoleOption,
|
|
249
502
|
options: AllUserScopeOptions.optional()
|
|
250
503
|
}),
|
|
251
|
-
|
|
504
|
+
z6.object({
|
|
252
505
|
type: UserScopeType.extract(["user.read", "user.search"]),
|
|
253
506
|
options: AccessLevelOptions.optional()
|
|
254
507
|
})
|
|
255
508
|
]);
|
|
256
|
-
var ResolvedRecordScopeV2 =
|
|
257
|
-
|
|
509
|
+
var ResolvedRecordScopeV2 = z6.discriminatedUnion("type", [
|
|
510
|
+
z6.object({
|
|
258
511
|
type: ScopesWithPlaceEventOptions,
|
|
259
512
|
options: ResolvedScopeOptionsPlaceEvent.optional()
|
|
260
513
|
}),
|
|
261
|
-
|
|
514
|
+
z6.object({
|
|
262
515
|
type: ScopesWithDeclaredOptions,
|
|
263
516
|
options: ResolvedScopeOptionsDeclared.optional()
|
|
264
517
|
}),
|
|
265
|
-
|
|
518
|
+
z6.object({
|
|
266
519
|
type: ScopesWithFullOptions,
|
|
267
520
|
options: ResolvedScopeOptionsFull.optional()
|
|
268
521
|
}),
|
|
269
|
-
|
|
270
|
-
type:
|
|
522
|
+
z6.object({
|
|
523
|
+
type: z6.literal("record.print-certified-copies"),
|
|
271
524
|
options: ResolvedScopeOptionsFull.extend({
|
|
272
|
-
templates:
|
|
525
|
+
templates: z6.array(z6.string()).optional()
|
|
273
526
|
}).optional()
|
|
274
527
|
})
|
|
275
528
|
]).describe("Resolved scope with location/user IDs instead of filters.");
|
|
276
|
-
var Scope =
|
|
277
|
-
|
|
529
|
+
var Scope = z6.discriminatedUnion("type", [
|
|
530
|
+
z6.object({ type: PlainScopeType }),
|
|
278
531
|
...RecordScopeV2.options,
|
|
279
532
|
...UserScopeV2.options,
|
|
280
|
-
|
|
281
|
-
type:
|
|
533
|
+
z6.object({
|
|
534
|
+
type: z6.literal("organisation.read-locations"),
|
|
282
535
|
options: AccessLevelOptions.optional()
|
|
283
536
|
}),
|
|
284
|
-
|
|
285
|
-
type:
|
|
537
|
+
z6.object({
|
|
538
|
+
type: z6.literal("workqueue"),
|
|
286
539
|
options: WorkqueueOrDashboardOptions
|
|
287
540
|
}),
|
|
288
|
-
|
|
289
|
-
type:
|
|
541
|
+
z6.object({
|
|
542
|
+
type: z6.literal("dashboard.view"),
|
|
290
543
|
options: WorkqueueOrDashboardOptions
|
|
291
544
|
})
|
|
292
545
|
]);
|
|
293
|
-
var ScopeType =
|
|
546
|
+
var ScopeType = z6.enum([
|
|
294
547
|
...SystemScopeType.options,
|
|
295
548
|
...RecordScopeTypeV2.options,
|
|
296
549
|
...PlainScopeType.options,
|
|
297
550
|
"workqueue",
|
|
298
551
|
"dashboard.view"
|
|
299
552
|
]);
|
|
300
|
-
var EncodedScope =
|
|
553
|
+
var EncodedScope = z6.string().brand("EncodedScope");
|
|
301
554
|
var DEFAULT_SCOPE_OPTIONS = {
|
|
302
555
|
placeOfEvent: JurisdictionFilter.enum.all,
|
|
303
556
|
accessLevel: JurisdictionFilter.enum.all,
|
|
@@ -307,162 +560,51 @@ var DEFAULT_SCOPE_OPTIONS = {
|
|
|
307
560
|
};
|
|
308
561
|
|
|
309
562
|
// ../commons/src/authentication.ts
|
|
310
|
-
var TokenUserType =
|
|
311
|
-
var TokenWithBearer =
|
|
312
|
-
|
|
313
|
-
// ../commons/src/events/ActionType.ts
|
|
314
|
-
var z4 = __toESM(require("zod/v4"));
|
|
315
|
-
var ActionType = {
|
|
316
|
-
// Pre-declaration actions
|
|
317
|
-
DELETE: "DELETE",
|
|
318
|
-
CREATE: "CREATE",
|
|
319
|
-
NOTIFY: "NOTIFY",
|
|
320
|
-
// Declaration actions
|
|
321
|
-
DECLARE: "DECLARE",
|
|
322
|
-
REGISTER: "REGISTER",
|
|
323
|
-
EDIT: "EDIT",
|
|
324
|
-
// Declaration system actions. Non-configurable.
|
|
325
|
-
DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
|
|
326
|
-
REJECT: "REJECT",
|
|
327
|
-
// REJECT_DECLARATION
|
|
328
|
-
MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
|
|
329
|
-
MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
|
|
330
|
-
ARCHIVE: "ARCHIVE",
|
|
331
|
-
UNARCHIVE: "UNARCHIVE",
|
|
332
|
-
// Record actions
|
|
333
|
-
PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
|
|
334
|
-
REQUEST_CORRECTION: "REQUEST_CORRECTION",
|
|
335
|
-
REJECT_CORRECTION: "REJECT_CORRECTION",
|
|
336
|
-
APPROVE_CORRECTION: "APPROVE_CORRECTION",
|
|
337
|
-
// General actions
|
|
338
|
-
READ: "READ",
|
|
339
|
-
ASSIGN: "ASSIGN",
|
|
340
|
-
UNASSIGN: "UNASSIGN",
|
|
341
|
-
// Custom action
|
|
342
|
-
CUSTOM: "CUSTOM"
|
|
343
|
-
};
|
|
344
|
-
var ConfirmableActions = [
|
|
345
|
-
ActionType.NOTIFY,
|
|
346
|
-
ActionType.DECLARE,
|
|
347
|
-
ActionType.EDIT,
|
|
348
|
-
ActionType.REGISTER,
|
|
349
|
-
ActionType.REJECT,
|
|
350
|
-
ActionType.ARCHIVE,
|
|
351
|
-
ActionType.UNARCHIVE,
|
|
352
|
-
ActionType.PRINT_CERTIFICATE,
|
|
353
|
-
ActionType.REQUEST_CORRECTION,
|
|
354
|
-
ActionType.APPROVE_CORRECTION,
|
|
355
|
-
ActionType.REJECT_CORRECTION,
|
|
356
|
-
ActionType.CUSTOM
|
|
357
|
-
];
|
|
358
|
-
var ActionTypes = z4.enum([
|
|
359
|
-
"DELETE",
|
|
360
|
-
"CREATE",
|
|
361
|
-
"NOTIFY",
|
|
362
|
-
"DECLARE",
|
|
363
|
-
"EDIT",
|
|
364
|
-
"REGISTER",
|
|
365
|
-
"DUPLICATE_DETECTED",
|
|
366
|
-
"REJECT",
|
|
367
|
-
"MARK_AS_DUPLICATE",
|
|
368
|
-
"MARK_AS_NOT_DUPLICATE",
|
|
369
|
-
"ARCHIVE",
|
|
370
|
-
"UNARCHIVE",
|
|
371
|
-
"PRINT_CERTIFICATE",
|
|
372
|
-
"REQUEST_CORRECTION",
|
|
373
|
-
"REJECT_CORRECTION",
|
|
374
|
-
"APPROVE_CORRECTION",
|
|
375
|
-
"READ",
|
|
376
|
-
"ASSIGN",
|
|
377
|
-
"UNASSIGN",
|
|
378
|
-
"CUSTOM"
|
|
379
|
-
]);
|
|
380
|
-
var ClientSpecificAction = {
|
|
381
|
-
REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
|
|
382
|
-
};
|
|
383
|
-
var declarationActionValues = [
|
|
384
|
-
ActionTypes.enum.DECLARE,
|
|
385
|
-
ActionTypes.enum.EDIT,
|
|
386
|
-
ActionTypes.enum.REGISTER,
|
|
387
|
-
ActionTypes.enum.NOTIFY,
|
|
388
|
-
ActionTypes.enum.DUPLICATE_DETECTED
|
|
389
|
-
];
|
|
390
|
-
var DeclarationActions = ActionTypes.extract(declarationActionValues);
|
|
391
|
-
var declarationUpdateActionValues = [
|
|
392
|
-
...declarationActionValues,
|
|
393
|
-
ActionTypes.enum.REQUEST_CORRECTION
|
|
394
|
-
];
|
|
395
|
-
var DeclarationUpdateActions = ActionTypes.extract(
|
|
396
|
-
declarationUpdateActionValues
|
|
397
|
-
);
|
|
398
|
-
var annotationActions = ActionTypes.exclude(declarationActionValues);
|
|
399
|
-
var writeActions = ActionTypes.exclude([
|
|
400
|
-
ActionType.CREATE,
|
|
401
|
-
ActionType.READ,
|
|
402
|
-
ActionType.ASSIGN,
|
|
403
|
-
ActionType.UNASSIGN
|
|
404
|
-
]);
|
|
405
|
-
var WorkqueueActionType = ActionTypes.extract([
|
|
406
|
-
ActionType.READ,
|
|
407
|
-
ActionType.DELETE,
|
|
408
|
-
ActionType.DECLARE,
|
|
409
|
-
ActionType.REGISTER,
|
|
410
|
-
ActionType.EDIT,
|
|
411
|
-
ActionType.REJECT,
|
|
412
|
-
ActionType.MARK_AS_DUPLICATE,
|
|
413
|
-
ActionType.ARCHIVE,
|
|
414
|
-
ActionType.UNARCHIVE,
|
|
415
|
-
ActionType.PRINT_CERTIFICATE,
|
|
416
|
-
ActionType.REQUEST_CORRECTION
|
|
417
|
-
]);
|
|
418
|
-
var META_ACTIONS = [
|
|
419
|
-
ActionType.ASSIGN,
|
|
420
|
-
ActionType.UNASSIGN,
|
|
421
|
-
ActionType.READ
|
|
422
|
-
];
|
|
563
|
+
var TokenUserType = z7.enum(["user", "system"]);
|
|
564
|
+
var TokenWithBearer = z7.string().regex(/^Bearer\s/);
|
|
423
565
|
|
|
424
566
|
// ../commons/src/events/AuditLog.ts
|
|
425
|
-
var AuditLogEntryBase =
|
|
426
|
-
id:
|
|
427
|
-
clientId:
|
|
567
|
+
var AuditLogEntryBase = z8.object({
|
|
568
|
+
id: z8.string(),
|
|
569
|
+
clientId: z8.string(),
|
|
428
570
|
clientType: TokenUserType,
|
|
429
|
-
createdAt:
|
|
571
|
+
createdAt: z8.string()
|
|
430
572
|
});
|
|
431
573
|
var EventCreateEntrySchema = AuditLogEntryBase.extend({
|
|
432
|
-
operation:
|
|
433
|
-
requestData:
|
|
434
|
-
transactionId:
|
|
435
|
-
type:
|
|
436
|
-
createdAtLocation:
|
|
574
|
+
operation: z8.literal("event.create"),
|
|
575
|
+
requestData: z8.object({
|
|
576
|
+
transactionId: z8.string(),
|
|
577
|
+
type: z8.string(),
|
|
578
|
+
createdAtLocation: z8.string().nullable()
|
|
437
579
|
}),
|
|
438
|
-
responseSummary:
|
|
439
|
-
eventId:
|
|
440
|
-
trackingId:
|
|
580
|
+
responseSummary: z8.object({
|
|
581
|
+
eventId: z8.string(),
|
|
582
|
+
trackingId: z8.string()
|
|
441
583
|
})
|
|
442
584
|
});
|
|
443
585
|
var EventGetEntrySchema = AuditLogEntryBase.extend({
|
|
444
|
-
operation:
|
|
445
|
-
requestData:
|
|
446
|
-
responseSummary:
|
|
447
|
-
eventType:
|
|
448
|
-
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()
|
|
449
591
|
})
|
|
450
592
|
});
|
|
451
593
|
var EventSearchEntrySchema = AuditLogEntryBase.extend({
|
|
452
|
-
operation:
|
|
453
|
-
clientType:
|
|
454
|
-
requestData:
|
|
455
|
-
query:
|
|
456
|
-
limit:
|
|
457
|
-
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()
|
|
458
600
|
}),
|
|
459
|
-
responseSummary:
|
|
460
|
-
total:
|
|
461
|
-
eventIds:
|
|
601
|
+
responseSummary: z8.object({
|
|
602
|
+
total: z8.number(),
|
|
603
|
+
eventIds: z8.array(z8.string())
|
|
462
604
|
})
|
|
463
605
|
});
|
|
464
606
|
var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
465
|
-
operation:
|
|
607
|
+
operation: z8.enum([
|
|
466
608
|
"event.actions.notify.request",
|
|
467
609
|
"event.actions.declare.request",
|
|
468
610
|
"event.actions.register.request",
|
|
@@ -482,128 +624,83 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
|
|
|
482
624
|
"event.actions.mark_as_duplicate.request",
|
|
483
625
|
"event.actions.mark_as_not_duplicate.request"
|
|
484
626
|
]),
|
|
485
|
-
requestData:
|
|
486
|
-
eventId:
|
|
487
|
-
actionType:
|
|
488
|
-
eventType:
|
|
489
|
-
trackingId:
|
|
490
|
-
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()
|
|
491
633
|
})
|
|
492
634
|
});
|
|
493
635
|
var EventCustomActionEntrySchema = AuditLogEntryBase.extend({
|
|
494
|
-
operation:
|
|
495
|
-
requestData:
|
|
496
|
-
eventId:
|
|
497
|
-
actionType:
|
|
498
|
-
customAction:
|
|
499
|
-
eventType:
|
|
500
|
-
trackingId:
|
|
501
|
-
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()
|
|
502
644
|
})
|
|
503
645
|
});
|
|
504
646
|
var IntegrationCreateEntrySchema = AuditLogEntryBase.extend({
|
|
505
|
-
operation:
|
|
506
|
-
requestData:
|
|
507
|
-
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() })
|
|
508
650
|
});
|
|
509
651
|
var IntegrationRefreshTokenEntrySchema = AuditLogEntryBase.extend({
|
|
510
|
-
operation:
|
|
511
|
-
requestData:
|
|
512
|
-
responseSummary:
|
|
652
|
+
operation: z8.literal("integrations.refreshToken"),
|
|
653
|
+
requestData: z8.object({ clientId: z8.string() }),
|
|
654
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
513
655
|
});
|
|
514
656
|
var IntegrationDeactivateEntrySchema = AuditLogEntryBase.extend({
|
|
515
|
-
operation:
|
|
516
|
-
requestData:
|
|
517
|
-
responseSummary:
|
|
657
|
+
operation: z8.literal("integrations.deactivate"),
|
|
658
|
+
requestData: z8.object({ id: z8.string() }),
|
|
659
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
518
660
|
});
|
|
519
661
|
var IntegrationActivateEntrySchema = AuditLogEntryBase.extend({
|
|
520
|
-
operation:
|
|
521
|
-
requestData:
|
|
522
|
-
responseSummary:
|
|
662
|
+
operation: z8.literal("integrations.activate"),
|
|
663
|
+
requestData: z8.object({ id: z8.string() }),
|
|
664
|
+
responseSummary: z8.object({ id: z8.string(), status: z8.string() })
|
|
523
665
|
});
|
|
524
666
|
var IntegrationDeleteEntrySchema = AuditLogEntryBase.extend({
|
|
525
|
-
operation:
|
|
526
|
-
requestData:
|
|
527
|
-
responseSummary:
|
|
667
|
+
operation: z8.literal("integrations.delete"),
|
|
668
|
+
requestData: z8.object({ id: z8.string() }),
|
|
669
|
+
responseSummary: z8.object({ id: z8.string(), name: z8.string() })
|
|
528
670
|
});
|
|
529
671
|
var IntegrationRefreshSecretEntrySchema = AuditLogEntryBase.extend({
|
|
530
|
-
operation:
|
|
531
|
-
requestData:
|
|
532
|
-
responseSummary:
|
|
533
|
-
});
|
|
534
|
-
var LocationCreateEntrySchema = AuditLogEntryBase.extend({
|
|
535
|
-
operation: z5.enum(["locations.create", "administrativeAreas.create"]),
|
|
536
|
-
requestData: z5.object({
|
|
537
|
-
id: z5.string(),
|
|
538
|
-
versionId: z5.string(),
|
|
539
|
-
name: z5.string(),
|
|
540
|
-
externalId: z5.string().nullish(),
|
|
541
|
-
administrativeAreaId: z5.string().nullish(),
|
|
542
|
-
// locations only
|
|
543
|
-
parentId: z5.string().nullish(),
|
|
544
|
-
// administrative areas only
|
|
545
|
-
locationType: z5.string().nullish(),
|
|
546
|
-
// locations only
|
|
547
|
-
effectiveFrom: z5.string(),
|
|
548
|
-
status: z5.string()
|
|
549
|
-
})
|
|
550
|
-
});
|
|
551
|
-
var ChangedStringField = z5.object({ from: z5.string(), to: z5.string() });
|
|
552
|
-
var ChangedNullableStringField = z5.object({
|
|
553
|
-
from: z5.string().nullable(),
|
|
554
|
-
to: z5.string().nullable()
|
|
555
|
-
});
|
|
556
|
-
var LocationUpdateEntrySchema = AuditLogEntryBase.extend({
|
|
557
|
-
operation: z5.enum(["locations.update", "administrativeAreas.update"]),
|
|
558
|
-
/** The submitted snapshot, with server-resolved `versionId`/`effectiveFrom`. */
|
|
559
|
-
requestData: z5.object({
|
|
560
|
-
id: z5.string(),
|
|
561
|
-
versionId: z5.string(),
|
|
562
|
-
name: z5.string(),
|
|
563
|
-
externalId: z5.string().nullish(),
|
|
564
|
-
status: z5.string(),
|
|
565
|
-
effectiveFrom: z5.string(),
|
|
566
|
-
lastVersionId: z5.string()
|
|
567
|
-
}),
|
|
568
|
-
/** The diff against the previous version — only fields that changed. */
|
|
569
|
-
responseSummary: z5.object({
|
|
570
|
-
previousVersionId: z5.string(),
|
|
571
|
-
versionId: z5.string(),
|
|
572
|
-
changed: z5.object({
|
|
573
|
-
name: ChangedStringField.optional(),
|
|
574
|
-
externalId: ChangedNullableStringField.optional(),
|
|
575
|
-
status: ChangedStringField.optional()
|
|
576
|
-
})
|
|
577
|
-
})
|
|
672
|
+
operation: z8.literal("integrations.refreshSecret"),
|
|
673
|
+
requestData: z8.object({ id: z8.string() }),
|
|
674
|
+
responseSummary: z8.object({ clientId: z8.string() })
|
|
578
675
|
});
|
|
579
676
|
var AttachmentUploadEntrySchema = AuditLogEntryBase.extend({
|
|
580
|
-
operation:
|
|
581
|
-
requestData:
|
|
582
|
-
transactionId:
|
|
583
|
-
path:
|
|
677
|
+
operation: z8.literal("attachments.upload"),
|
|
678
|
+
requestData: z8.object({
|
|
679
|
+
transactionId: z8.string(),
|
|
680
|
+
path: z8.string().nullable()
|
|
584
681
|
}),
|
|
585
|
-
responseSummary:
|
|
682
|
+
responseSummary: z8.object({ fileUrl: z8.string() })
|
|
586
683
|
});
|
|
587
|
-
var subjectOnly =
|
|
588
|
-
var subjectWithReason =
|
|
589
|
-
subjectId:
|
|
590
|
-
reason:
|
|
591
|
-
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()
|
|
592
689
|
});
|
|
593
690
|
var UserCreateEntrySchema = AuditLogEntryBase.extend({
|
|
594
|
-
operation:
|
|
595
|
-
requestData:
|
|
596
|
-
subjectId:
|
|
597
|
-
role:
|
|
598
|
-
primaryOfficeId:
|
|
691
|
+
operation: z8.literal("user.create_user"),
|
|
692
|
+
requestData: z8.object({
|
|
693
|
+
subjectId: z8.string(),
|
|
694
|
+
role: z8.string(),
|
|
695
|
+
primaryOfficeId: z8.string()
|
|
599
696
|
})
|
|
600
697
|
});
|
|
601
698
|
var UserReasonEntrySchema = AuditLogEntryBase.extend({
|
|
602
|
-
operation:
|
|
699
|
+
operation: z8.enum(["user.deactivate", "user.reactivate"]),
|
|
603
700
|
requestData: subjectWithReason
|
|
604
701
|
});
|
|
605
702
|
var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
606
|
-
operation:
|
|
703
|
+
operation: z8.enum([
|
|
607
704
|
"user.edit_user",
|
|
608
705
|
"user.logged_in",
|
|
609
706
|
"user.logged_out",
|
|
@@ -617,14 +714,14 @@ var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
|
|
|
617
714
|
requestData: subjectOnly
|
|
618
715
|
});
|
|
619
716
|
var UserEmailChangedEntrySchema = AuditLogEntryBase.extend({
|
|
620
|
-
operation:
|
|
717
|
+
operation: z8.literal("user.email_address_changed"),
|
|
621
718
|
requestData: subjectOnly,
|
|
622
|
-
responseSummary:
|
|
719
|
+
responseSummary: z8.object({ email: z8.string() })
|
|
623
720
|
});
|
|
624
721
|
var UserPhoneChangedEntrySchema = AuditLogEntryBase.extend({
|
|
625
|
-
operation:
|
|
722
|
+
operation: z8.literal("user.phone_number_changed"),
|
|
626
723
|
requestData: subjectOnly,
|
|
627
|
-
responseSummary:
|
|
724
|
+
responseSummary: z8.object({ phoneNumber: z8.string() })
|
|
628
725
|
});
|
|
629
726
|
var userBaseOmit = {
|
|
630
727
|
id: true,
|
|
@@ -632,14 +729,14 @@ var userBaseOmit = {
|
|
|
632
729
|
clientType: true,
|
|
633
730
|
createdAt: true
|
|
634
731
|
};
|
|
635
|
-
var UserAuditRecordInput =
|
|
732
|
+
var UserAuditRecordInput = z8.discriminatedUnion("operation", [
|
|
636
733
|
UserCreateEntrySchema.omit(userBaseOmit),
|
|
637
734
|
UserReasonEntrySchema.omit(userBaseOmit),
|
|
638
735
|
UserSubjectOnlyEntrySchema.omit(userBaseOmit),
|
|
639
736
|
UserEmailChangedEntrySchema.omit(userBaseOmit),
|
|
640
737
|
UserPhoneChangedEntrySchema.omit(userBaseOmit)
|
|
641
738
|
]);
|
|
642
|
-
var AuditLogEntrySchema =
|
|
739
|
+
var AuditLogEntrySchema = z8.discriminatedUnion("operation", [
|
|
643
740
|
EventCreateEntrySchema,
|
|
644
741
|
EventGetEntrySchema,
|
|
645
742
|
EventSearchEntrySchema,
|
|
@@ -651,8 +748,6 @@ var AuditLogEntrySchema = z5.discriminatedUnion("operation", [
|
|
|
651
748
|
IntegrationActivateEntrySchema,
|
|
652
749
|
IntegrationDeleteEntrySchema,
|
|
653
750
|
IntegrationRefreshSecretEntrySchema,
|
|
654
|
-
LocationCreateEntrySchema,
|
|
655
|
-
LocationUpdateEntrySchema,
|
|
656
751
|
AttachmentUploadEntrySchema,
|
|
657
752
|
UserCreateEntrySchema,
|
|
658
753
|
UserReasonEntrySchema,
|
|
@@ -668,76 +763,11 @@ var CHILD_ONBOARDING_EVENT = "child-onboarding";
|
|
|
668
763
|
// ../commons/src/events/ActionConfig.ts
|
|
669
764
|
var z24 = __toESM(require("zod/v4"));
|
|
670
765
|
|
|
671
|
-
// ../commons/src/events/TranslationConfig.ts
|
|
672
|
-
var z6 = __toESM(require("zod/v4"));
|
|
673
|
-
var TranslationConfig = z6.object({
|
|
674
|
-
id: z6.string().describe(
|
|
675
|
-
"The identifier of the translation referred in translation CSV files"
|
|
676
|
-
),
|
|
677
|
-
defaultMessage: z6.string().describe("Default translation message"),
|
|
678
|
-
description: z6.string().describe(
|
|
679
|
-
"Describe the translation for a translator to be able to identify it."
|
|
680
|
-
)
|
|
681
|
-
}).meta({
|
|
682
|
-
description: "Translation configuration",
|
|
683
|
-
id: "TranslationConfig"
|
|
684
|
-
});
|
|
685
|
-
|
|
686
766
|
// ../commons/src/events/FieldConfig.ts
|
|
687
767
|
var import_v43 = __toESM(require("zod/v4"));
|
|
688
768
|
|
|
689
|
-
// ../commons/src/events/Conditional.ts
|
|
690
|
-
var z7 = __toESM(require("zod/v4"));
|
|
691
|
-
var Conditional = z7.any().describe("JSONSchema").meta({
|
|
692
|
-
description: "JSON schema conditional configuration",
|
|
693
|
-
id: "Conditional"
|
|
694
|
-
});
|
|
695
|
-
var ConditionalType = {
|
|
696
|
-
SHOW: "SHOW",
|
|
697
|
-
ENABLE: "ENABLE",
|
|
698
|
-
DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
|
|
699
|
-
};
|
|
700
|
-
var ShowConditional = z7.object({
|
|
701
|
-
type: z7.literal(ConditionalType.SHOW),
|
|
702
|
-
conditional: Conditional
|
|
703
|
-
}).describe(
|
|
704
|
-
"If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
|
|
705
|
-
);
|
|
706
|
-
var EnableConditional = z7.object({
|
|
707
|
-
type: z7.literal(ConditionalType.ENABLE),
|
|
708
|
-
conditional: Conditional
|
|
709
|
-
}).describe(
|
|
710
|
-
"If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
|
|
711
|
-
);
|
|
712
|
-
var ActionConditional = z7.discriminatedUnion("type", [
|
|
713
|
-
// Action can be shown / hidden
|
|
714
|
-
ShowConditional,
|
|
715
|
-
// Action can be shown to the user in the list but as disabled
|
|
716
|
-
EnableConditional
|
|
717
|
-
]).meta({
|
|
718
|
-
id: "ActionConditional",
|
|
719
|
-
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."
|
|
720
|
-
});
|
|
721
|
-
var DisplayOnReviewConditional = z7.object({
|
|
722
|
-
type: z7.literal(ConditionalType.DISPLAY_ON_REVIEW),
|
|
723
|
-
conditional: Conditional
|
|
724
|
-
}).describe(
|
|
725
|
-
"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."
|
|
726
|
-
);
|
|
727
|
-
var FieldConditional = z7.discriminatedUnion("type", [
|
|
728
|
-
// Field input can be shown / hidden
|
|
729
|
-
ShowConditional,
|
|
730
|
-
// Field input can be shown to the user but as disabled
|
|
731
|
-
EnableConditional,
|
|
732
|
-
// Field output can be shown / hidden on the review page
|
|
733
|
-
DisplayOnReviewConditional
|
|
734
|
-
]).meta({
|
|
735
|
-
id: "FieldConditional",
|
|
736
|
-
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."
|
|
737
|
-
});
|
|
738
|
-
|
|
739
769
|
// ../commons/src/events/FieldType.ts
|
|
740
|
-
var
|
|
770
|
+
var z9 = __toESM(require("zod/v4"));
|
|
741
771
|
var FieldType = {
|
|
742
772
|
NAME: "NAME",
|
|
743
773
|
PHONE: "PHONE",
|
|
@@ -801,7 +831,7 @@ var FieldType = {
|
|
|
801
831
|
*/
|
|
802
832
|
_EXPERIMENTAL_CUSTOM: "CUSTOM"
|
|
803
833
|
};
|
|
804
|
-
var FileFieldType =
|
|
834
|
+
var FileFieldType = z9.enum([
|
|
805
835
|
FieldType.FILE,
|
|
806
836
|
FieldType.FILE_WITH_OPTIONS,
|
|
807
837
|
FieldType.SIGNATURE
|
|
@@ -837,160 +867,164 @@ var HiddenFieldTypes = [
|
|
|
837
867
|
];
|
|
838
868
|
|
|
839
869
|
// ../commons/src/events/FieldValue.ts
|
|
840
|
-
var
|
|
870
|
+
var z13 = __toESM(require("zod/v4"));
|
|
841
871
|
|
|
842
872
|
// ../commons/src/documents.ts
|
|
843
|
-
var
|
|
844
|
-
var FullDocumentUrl =
|
|
873
|
+
var z10 = __toESM(require("zod/v4"));
|
|
874
|
+
var FullDocumentUrl = z10.string().brand("FullDocumentUrl").describe(
|
|
845
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"
|
|
846
876
|
);
|
|
847
|
-
var FullDocumentPath =
|
|
877
|
+
var FullDocumentPath = z10.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
|
|
848
878
|
"A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
|
|
849
879
|
);
|
|
850
|
-
var DocumentPath =
|
|
880
|
+
var DocumentPath = z10.string().brand("DocumentPath").describe(
|
|
851
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."
|
|
852
882
|
);
|
|
853
883
|
|
|
854
884
|
// ../commons/src/events/CompositeFieldValue.ts
|
|
855
|
-
var
|
|
885
|
+
var z11 = __toESM(require("zod/v4"));
|
|
856
886
|
var AddressType = {
|
|
857
887
|
DOMESTIC: "DOMESTIC",
|
|
858
888
|
INTERNATIONAL: "INTERNATIONAL"
|
|
859
889
|
};
|
|
860
|
-
var FileFieldValue =
|
|
890
|
+
var FileFieldValue = z11.object({
|
|
861
891
|
path: DocumentPath,
|
|
862
|
-
originalFilename:
|
|
863
|
-
type:
|
|
864
|
-
});
|
|
865
|
-
var NameFieldValue =
|
|
866
|
-
firstname:
|
|
867
|
-
surname:
|
|
868
|
-
middlename:
|
|
869
|
-
});
|
|
870
|
-
var NameFieldUpdateValue =
|
|
871
|
-
firstname:
|
|
872
|
-
surname:
|
|
873
|
-
middlename:
|
|
874
|
-
}).or(
|
|
875
|
-
var StreetLevelDetailsValue =
|
|
876
|
-
var StreetLevelDetailsUpdateValue =
|
|
877
|
-
var BaseAddressFieldValue =
|
|
878
|
-
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(),
|
|
879
909
|
streetLevelDetails: StreetLevelDetailsValue
|
|
880
910
|
});
|
|
881
|
-
var BaseAddressFieldUpdateValue =
|
|
882
|
-
country:
|
|
911
|
+
var BaseAddressFieldUpdateValue = z11.object({
|
|
912
|
+
country: z11.string().nullish(),
|
|
883
913
|
streetLevelDetails: StreetLevelDetailsUpdateValue
|
|
884
914
|
});
|
|
885
915
|
var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
|
|
886
|
-
addressType:
|
|
887
|
-
administrativeArea:
|
|
916
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
917
|
+
administrativeArea: z11.string().uuid()
|
|
888
918
|
});
|
|
889
919
|
var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
|
|
890
|
-
addressType:
|
|
920
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
891
921
|
});
|
|
892
|
-
var AddressFieldValue =
|
|
922
|
+
var AddressFieldValue = z11.discriminatedUnion("addressType", [
|
|
893
923
|
DomesticAddressFieldValue,
|
|
894
924
|
InternationalAddressFieldValue
|
|
895
925
|
]);
|
|
896
926
|
var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
|
|
897
|
-
addressType:
|
|
898
|
-
administrativeArea:
|
|
927
|
+
addressType: z11.literal(AddressType.DOMESTIC),
|
|
928
|
+
administrativeArea: z11.string().uuid().nullish()
|
|
899
929
|
/* Leaf level admin structure */
|
|
900
930
|
});
|
|
901
931
|
var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
|
|
902
932
|
{
|
|
903
|
-
addressType:
|
|
933
|
+
addressType: z11.literal(AddressType.INTERNATIONAL)
|
|
904
934
|
}
|
|
905
935
|
);
|
|
906
|
-
var AddressFieldUpdateValue =
|
|
936
|
+
var AddressFieldUpdateValue = z11.discriminatedUnion("addressType", [
|
|
907
937
|
DomesticAddressUpdateFieldValue,
|
|
908
938
|
InternationalAddressUpdateFieldValue
|
|
909
939
|
]).nullish();
|
|
910
|
-
var FileFieldValueWithOption =
|
|
940
|
+
var FileFieldValueWithOption = z11.object({
|
|
911
941
|
path: DocumentPath,
|
|
912
|
-
originalFilename:
|
|
913
|
-
type:
|
|
914
|
-
option:
|
|
915
|
-
});
|
|
916
|
-
var FileFieldWithOptionValue =
|
|
917
|
-
var HttpFieldValue =
|
|
918
|
-
loading:
|
|
919
|
-
error:
|
|
920
|
-
data:
|
|
921
|
-
});
|
|
922
|
-
var HttpFieldUpdateValue =
|
|
923
|
-
loading:
|
|
924
|
-
error:
|
|
925
|
-
data:
|
|
926
|
-
}).or(
|
|
927
|
-
var QueryParamReaderFieldValue =
|
|
928
|
-
data:
|
|
929
|
-
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()
|
|
930
960
|
}).nullish();
|
|
931
|
-
var QueryParamReaderFieldUpdateValue =
|
|
932
|
-
data:
|
|
961
|
+
var QueryParamReaderFieldUpdateValue = z11.object({
|
|
962
|
+
data: z11.record(z11.string(), z11.string())
|
|
933
963
|
});
|
|
934
|
-
var ReadDataValue =
|
|
935
|
-
data:
|
|
964
|
+
var ReadDataValue = z11.object({
|
|
965
|
+
data: z11.any()
|
|
936
966
|
});
|
|
937
967
|
var QrReaderFieldValue = ReadDataValue;
|
|
938
968
|
var IdReaderFieldValue = ReadDataValue;
|
|
939
|
-
var NumberWithUnitFieldValue =
|
|
940
|
-
numericValue:
|
|
941
|
-
unit:
|
|
969
|
+
var NumberWithUnitFieldValue = z11.object({
|
|
970
|
+
numericValue: z11.number(),
|
|
971
|
+
unit: z11.string()
|
|
942
972
|
});
|
|
943
|
-
var NumberWithUnitFieldUpdateValue =
|
|
944
|
-
numericValue:
|
|
945
|
-
unit:
|
|
973
|
+
var NumberWithUnitFieldUpdateValue = z11.object({
|
|
974
|
+
numericValue: z11.number().optional(),
|
|
975
|
+
unit: z11.string().optional()
|
|
946
976
|
});
|
|
947
|
-
var CustomFieldValue =
|
|
977
|
+
var CustomFieldValue = z11.unknown().brand("CustomFieldValue");
|
|
948
978
|
|
|
949
979
|
// ../commons/src/events/PlainDate.ts
|
|
950
980
|
var import_zod = require("zod");
|
|
951
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
|
+
}
|
|
952
986
|
|
|
953
987
|
// ../commons/src/events/FieldValue.ts
|
|
954
|
-
var TextValue =
|
|
955
|
-
var HiddenFieldValue =
|
|
956
|
-
var NonEmptyTextValue =
|
|
957
|
-
var DateValue =
|
|
958
|
-
var AgeValue =
|
|
959
|
-
age:
|
|
960
|
-
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()
|
|
961
995
|
});
|
|
962
996
|
var AgeUpdateValue = AgeValue.optional().nullable();
|
|
963
|
-
var AutocompleteValue =
|
|
964
|
-
label:
|
|
965
|
-
value:
|
|
997
|
+
var AutocompleteValue = z13.object({
|
|
998
|
+
label: z13.string(),
|
|
999
|
+
value: z13.string()
|
|
966
1000
|
});
|
|
967
1001
|
var AutocompleteUpdateValue = AutocompleteValue.optional().nullable();
|
|
968
|
-
var TimeValue =
|
|
969
|
-
var DatetimeValue =
|
|
970
|
-
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([
|
|
971
1005
|
"last7Days",
|
|
972
1006
|
"last30Days",
|
|
973
1007
|
"last90Days",
|
|
974
1008
|
"last365Days"
|
|
975
1009
|
]);
|
|
976
|
-
var DateRangeFieldValue =
|
|
1010
|
+
var DateRangeFieldValue = z13.object({
|
|
977
1011
|
start: PlainDate,
|
|
978
1012
|
end: PlainDate
|
|
979
1013
|
}).or(PlainDate).describe(
|
|
980
1014
|
"Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
|
|
981
1015
|
);
|
|
982
|
-
var EmailValue =
|
|
983
|
-
var CheckboxFieldValue =
|
|
984
|
-
var NumberFieldValue =
|
|
1016
|
+
var EmailValue = z13.email();
|
|
1017
|
+
var CheckboxFieldValue = z13.boolean();
|
|
1018
|
+
var NumberFieldValue = z13.number();
|
|
985
1019
|
var SignatureFieldValue = FileFieldValue;
|
|
986
|
-
var ButtonFieldValue =
|
|
987
|
-
var VerificationStatusValue =
|
|
1020
|
+
var ButtonFieldValue = z13.number();
|
|
1021
|
+
var VerificationStatusValue = z13.enum([
|
|
988
1022
|
"verified",
|
|
989
1023
|
"authenticated",
|
|
990
1024
|
"failed",
|
|
991
1025
|
"pending"
|
|
992
1026
|
]);
|
|
993
|
-
var LeafFieldValues =
|
|
1027
|
+
var LeafFieldValues = z13.union([
|
|
994
1028
|
AddressFieldValue,
|
|
995
1029
|
TextValue,
|
|
996
1030
|
PlainDate,
|
|
@@ -1016,11 +1050,11 @@ var LeafFieldValues = z12.union([
|
|
|
1016
1050
|
AutocompleteValue,
|
|
1017
1051
|
AutocompleteUpdateValue
|
|
1018
1052
|
]);
|
|
1019
|
-
var FieldGroupValue =
|
|
1020
|
-
var DataFieldValue =
|
|
1021
|
-
data:
|
|
1053
|
+
var FieldGroupValue = z13.record(z13.string(), LeafFieldValues);
|
|
1054
|
+
var DataFieldValue = z13.object({
|
|
1055
|
+
data: z13.record(z13.string(), LeafFieldValues)
|
|
1022
1056
|
}).nullish();
|
|
1023
|
-
var FieldValue =
|
|
1057
|
+
var FieldValue = z13.union([
|
|
1024
1058
|
LeafFieldValues,
|
|
1025
1059
|
DataFieldValue,
|
|
1026
1060
|
FieldGroupValue
|
|
@@ -1054,7 +1088,7 @@ function safeUnion(schemas) {
|
|
|
1054
1088
|
const sortedSchemas = [...schemas].sort(
|
|
1055
1089
|
(a, b) => schemaPriority(a) - schemaPriority(b)
|
|
1056
1090
|
);
|
|
1057
|
-
return
|
|
1091
|
+
return z13.any().superRefine((val, ctx) => {
|
|
1058
1092
|
for (const schema of sortedSchemas) {
|
|
1059
1093
|
if (schema.safeParse(val).success) {
|
|
1060
1094
|
return;
|
|
@@ -1093,9 +1127,9 @@ var FieldUpdateValue = safeUnion([
|
|
|
1093
1127
|
]);
|
|
1094
1128
|
|
|
1095
1129
|
// ../commons/src/events/serializers/user/serializer.ts
|
|
1096
|
-
var
|
|
1097
|
-
var SerializedUserField =
|
|
1098
|
-
$userField:
|
|
1130
|
+
var z14 = __toESM(require("zod/v4"));
|
|
1131
|
+
var SerializedUserField = z14.object({
|
|
1132
|
+
$userField: z14.enum([
|
|
1099
1133
|
"id",
|
|
1100
1134
|
"name",
|
|
1101
1135
|
"role",
|
|
@@ -1109,7 +1143,7 @@ var SerializedUserField = z13.object({
|
|
|
1109
1143
|
"primaryOfficeId",
|
|
1110
1144
|
"administrativeAreaId"
|
|
1111
1145
|
]),
|
|
1112
|
-
$location:
|
|
1146
|
+
$location: z14.string().optional()
|
|
1113
1147
|
});
|
|
1114
1148
|
function userSerializer(userField) {
|
|
1115
1149
|
return {
|
|
@@ -1135,27 +1169,22 @@ var import_v4 = require("zod/v4");
|
|
|
1135
1169
|
var z16 = __toESM(require("zod/v4"));
|
|
1136
1170
|
|
|
1137
1171
|
// ../commons/src/events/ActionDocument.ts
|
|
1138
|
-
var
|
|
1139
|
-
var ActionUpdate =
|
|
1172
|
+
var z15 = __toESM(require("zod/v4"));
|
|
1173
|
+
var ActionUpdate = z15.record(z15.string(), FieldUpdateValue).describe(
|
|
1140
1174
|
"Record of field-level changes made by an action. Supports partial updates and nullable values."
|
|
1141
1175
|
);
|
|
1142
|
-
var EventState =
|
|
1176
|
+
var EventState = z15.record(z15.string(), FieldValue).describe(
|
|
1143
1177
|
"Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
|
|
1144
1178
|
);
|
|
1145
|
-
var
|
|
1146
|
-
Requested: "Requested",
|
|
1147
|
-
Accepted: "Accepted",
|
|
1148
|
-
Rejected: "Rejected"
|
|
1149
|
-
};
|
|
1150
|
-
var ActionBase = z14.object({
|
|
1179
|
+
var ActionBase = z15.object({
|
|
1151
1180
|
id: UUID.describe("Unique identifier of the action."),
|
|
1152
|
-
transactionId:
|
|
1181
|
+
transactionId: z15.string().describe("Unique identifier of the transaction."),
|
|
1153
1182
|
createdByUserType: TokenUserType.describe(
|
|
1154
1183
|
"Indicates whether the action was created by a human-user or by a system-user."
|
|
1155
1184
|
),
|
|
1156
|
-
createdAt:
|
|
1157
|
-
createdBy:
|
|
1158
|
-
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."),
|
|
1159
1188
|
createdBySignature: DocumentPath.nullish().describe(
|
|
1160
1189
|
"Reference to the signature of the user who created the action."
|
|
1161
1190
|
),
|
|
@@ -1167,7 +1196,7 @@ var ActionBase = z14.object({
|
|
|
1167
1196
|
"Declaration data defined by the ActionConfig. Supports partial updates."
|
|
1168
1197
|
),
|
|
1169
1198
|
annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
|
|
1170
|
-
status:
|
|
1199
|
+
status: z15.enum([
|
|
1171
1200
|
ActionStatus.Requested,
|
|
1172
1201
|
ActionStatus.Accepted,
|
|
1173
1202
|
ActionStatus.Rejected
|
|
@@ -1179,139 +1208,139 @@ var ActionBase = z14.object({
|
|
|
1179
1208
|
)
|
|
1180
1209
|
});
|
|
1181
1210
|
var AssignedAction = ActionBase.extend(
|
|
1182
|
-
|
|
1183
|
-
type:
|
|
1184
|
-
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.")
|
|
1185
1214
|
// TODO move into 'content' property
|
|
1186
1215
|
}).shape
|
|
1187
1216
|
);
|
|
1188
1217
|
var UnassignedAction = ActionBase.extend(
|
|
1189
|
-
|
|
1190
|
-
type:
|
|
1218
|
+
z15.object({
|
|
1219
|
+
type: z15.literal(ActionType.UNASSIGN)
|
|
1191
1220
|
}).shape
|
|
1192
1221
|
);
|
|
1193
1222
|
var RegisterAction = ActionBase.extend(
|
|
1194
|
-
|
|
1195
|
-
type:
|
|
1196
|
-
registrationNumber:
|
|
1223
|
+
z15.object({
|
|
1224
|
+
type: z15.literal(ActionType.REGISTER),
|
|
1225
|
+
registrationNumber: z15.string().optional().describe(
|
|
1197
1226
|
"Registration number of the event. Always present for accepted registrations."
|
|
1198
1227
|
)
|
|
1199
1228
|
// TODO move into 'content' property
|
|
1200
1229
|
}).shape
|
|
1201
1230
|
);
|
|
1202
1231
|
var DeclareAction = ActionBase.extend(
|
|
1203
|
-
|
|
1204
|
-
type:
|
|
1232
|
+
z15.object({
|
|
1233
|
+
type: z15.literal(ActionType.DECLARE)
|
|
1205
1234
|
}).shape
|
|
1206
1235
|
);
|
|
1207
|
-
var ReasonContent =
|
|
1208
|
-
reason:
|
|
1236
|
+
var ReasonContent = z15.object({
|
|
1237
|
+
reason: z15.string().min(1, { error: "Message cannot be empty" }).describe(
|
|
1209
1238
|
"Message describing the reason for rejecting or archiving the event."
|
|
1210
1239
|
)
|
|
1211
1240
|
});
|
|
1212
1241
|
var RejectAction = ActionBase.extend(
|
|
1213
|
-
|
|
1214
|
-
type:
|
|
1242
|
+
z15.object({
|
|
1243
|
+
type: z15.literal(ActionType.REJECT),
|
|
1215
1244
|
content: ReasonContent
|
|
1216
1245
|
}).shape
|
|
1217
1246
|
);
|
|
1218
|
-
var PotentialDuplicate =
|
|
1247
|
+
var PotentialDuplicate = z15.object({
|
|
1219
1248
|
id: UUID,
|
|
1220
|
-
trackingId:
|
|
1249
|
+
trackingId: z15.string()
|
|
1221
1250
|
});
|
|
1222
1251
|
var DuplicateDetectedAction = ActionBase.extend(
|
|
1223
|
-
|
|
1224
|
-
type:
|
|
1225
|
-
content:
|
|
1226
|
-
duplicates:
|
|
1252
|
+
z15.object({
|
|
1253
|
+
type: z15.literal(ActionType.DUPLICATE_DETECTED),
|
|
1254
|
+
content: z15.object({
|
|
1255
|
+
duplicates: z15.array(PotentialDuplicate)
|
|
1227
1256
|
})
|
|
1228
1257
|
}).shape
|
|
1229
1258
|
);
|
|
1230
1259
|
var MarkNotDuplicateAction = ActionBase.extend(
|
|
1231
|
-
|
|
1232
|
-
type:
|
|
1260
|
+
z15.object({
|
|
1261
|
+
type: z15.literal(ActionType.MARK_AS_NOT_DUPLICATE)
|
|
1233
1262
|
}).shape
|
|
1234
1263
|
);
|
|
1235
1264
|
var MarkAsDuplicateAction = ActionBase.extend(
|
|
1236
|
-
|
|
1237
|
-
type:
|
|
1238
|
-
content:
|
|
1265
|
+
z15.object({
|
|
1266
|
+
type: z15.literal(ActionType.MARK_AS_DUPLICATE),
|
|
1267
|
+
content: z15.object({
|
|
1239
1268
|
duplicateOf: UUID
|
|
1240
1269
|
}).optional()
|
|
1241
1270
|
}).shape
|
|
1242
1271
|
);
|
|
1243
1272
|
var ArchiveAction = ActionBase.extend(
|
|
1244
|
-
|
|
1245
|
-
type:
|
|
1273
|
+
z15.object({
|
|
1274
|
+
type: z15.literal(ActionType.ARCHIVE),
|
|
1246
1275
|
content: ReasonContent
|
|
1247
1276
|
}).shape
|
|
1248
1277
|
);
|
|
1249
1278
|
var UnarchiveAction = ActionBase.extend(
|
|
1250
|
-
|
|
1251
|
-
type:
|
|
1279
|
+
z15.object({
|
|
1280
|
+
type: z15.literal(ActionType.UNARCHIVE)
|
|
1252
1281
|
}).shape
|
|
1253
1282
|
);
|
|
1254
1283
|
var CreatedAction = ActionBase.extend(
|
|
1255
|
-
|
|
1256
|
-
type:
|
|
1284
|
+
z15.object({
|
|
1285
|
+
type: z15.literal(ActionType.CREATE)
|
|
1257
1286
|
}).shape
|
|
1258
1287
|
);
|
|
1259
1288
|
var NotifiedAction = ActionBase.extend(
|
|
1260
|
-
|
|
1261
|
-
type:
|
|
1289
|
+
z15.object({
|
|
1290
|
+
type: z15.literal(ActionType.NOTIFY)
|
|
1262
1291
|
}).shape
|
|
1263
1292
|
);
|
|
1264
1293
|
var EditAction = ActionBase.extend(
|
|
1265
|
-
|
|
1266
|
-
type:
|
|
1294
|
+
z15.object({
|
|
1295
|
+
type: z15.literal(ActionType.EDIT),
|
|
1267
1296
|
/** @deprecated New Edit-actions should no longer contain content. This is kept for old 2.0 edits. */
|
|
1268
|
-
content:
|
|
1269
|
-
comment:
|
|
1297
|
+
content: z15.object({
|
|
1298
|
+
comment: z15.string().describe("Comment for the edit action.").optional()
|
|
1270
1299
|
}).optional()
|
|
1271
1300
|
}).shape
|
|
1272
1301
|
);
|
|
1273
|
-
var PrintContent =
|
|
1274
|
-
templateId:
|
|
1302
|
+
var PrintContent = z15.object({
|
|
1303
|
+
templateId: z15.string().optional()
|
|
1275
1304
|
});
|
|
1276
1305
|
var PrintCertificateAction = ActionBase.extend(
|
|
1277
|
-
|
|
1278
|
-
type:
|
|
1306
|
+
z15.object({
|
|
1307
|
+
type: z15.literal(ActionType.PRINT_CERTIFICATE),
|
|
1279
1308
|
content: PrintContent.optional().nullable()
|
|
1280
1309
|
}).shape
|
|
1281
1310
|
);
|
|
1282
1311
|
var RequestedCorrectionAction = ActionBase.extend(
|
|
1283
|
-
|
|
1284
|
-
type:
|
|
1312
|
+
z15.object({
|
|
1313
|
+
type: z15.literal(ActionType.REQUEST_CORRECTION)
|
|
1285
1314
|
}).shape
|
|
1286
1315
|
);
|
|
1287
1316
|
var ApprovedCorrectionAction = ActionBase.extend(
|
|
1288
|
-
|
|
1289
|
-
type:
|
|
1290
|
-
requestId:
|
|
1317
|
+
z15.object({
|
|
1318
|
+
type: z15.literal(ActionType.APPROVE_CORRECTION),
|
|
1319
|
+
requestId: z15.string(),
|
|
1291
1320
|
// TODO move into 'content' property
|
|
1292
|
-
content:
|
|
1321
|
+
content: z15.object({ immediateCorrection: z15.boolean().optional() }).optional()
|
|
1293
1322
|
}).shape
|
|
1294
1323
|
);
|
|
1295
1324
|
var RejectedCorrectionAction = ActionBase.extend(
|
|
1296
|
-
|
|
1297
|
-
type:
|
|
1298
|
-
requestId:
|
|
1325
|
+
z15.object({
|
|
1326
|
+
type: z15.literal(ActionType.REJECT_CORRECTION),
|
|
1327
|
+
requestId: z15.string(),
|
|
1299
1328
|
// TODO move into 'content' property
|
|
1300
1329
|
content: ReasonContent
|
|
1301
1330
|
}).shape
|
|
1302
1331
|
);
|
|
1303
1332
|
var ReadAction = ActionBase.extend(
|
|
1304
|
-
|
|
1305
|
-
type:
|
|
1333
|
+
z15.object({
|
|
1334
|
+
type: z15.literal(ActionType.READ)
|
|
1306
1335
|
}).shape
|
|
1307
1336
|
);
|
|
1308
1337
|
var CustomAction = ActionBase.merge(
|
|
1309
|
-
|
|
1310
|
-
type:
|
|
1311
|
-
customActionType:
|
|
1338
|
+
z15.object({
|
|
1339
|
+
type: z15.literal(ActionType.CUSTOM),
|
|
1340
|
+
customActionType: z15.string()
|
|
1312
1341
|
})
|
|
1313
1342
|
);
|
|
1314
|
-
var ActionDocument =
|
|
1343
|
+
var ActionDocument = z15.discriminatedUnion("type", [
|
|
1315
1344
|
CreatedAction.meta({ id: "CreatedAction" }),
|
|
1316
1345
|
RejectAction.meta({ id: "RejectAction" }),
|
|
1317
1346
|
DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
|
|
@@ -1338,64 +1367,12 @@ var AsyncRejectActionDocument = ActionBase.omit({
|
|
|
1338
1367
|
declaration: true,
|
|
1339
1368
|
annotation: true
|
|
1340
1369
|
}).extend(
|
|
1341
|
-
|
|
1342
|
-
type:
|
|
1343
|
-
status:
|
|
1370
|
+
z15.object({
|
|
1371
|
+
type: z15.enum(ConfirmableActions),
|
|
1372
|
+
status: z15.literal(ActionStatus.Rejected)
|
|
1344
1373
|
}).shape
|
|
1345
1374
|
);
|
|
1346
|
-
var Action =
|
|
1347
|
-
|
|
1348
|
-
// ../commons/src/events/Flag.ts
|
|
1349
|
-
var z15 = __toESM(require("zod/v4"));
|
|
1350
|
-
var InherentFlags = {
|
|
1351
|
-
INCOMPLETE: "incomplete",
|
|
1352
|
-
REJECTED: "rejected",
|
|
1353
|
-
CORRECTION_REQUESTED: "correction-requested",
|
|
1354
|
-
POTENTIAL_DUPLICATE: "potential-duplicate",
|
|
1355
|
-
/**
|
|
1356
|
-
* This flag is set by the Edit-action and removed after the declaration or registration.
|
|
1357
|
-
* A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
|
|
1358
|
-
*
|
|
1359
|
-
* We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
|
|
1360
|
-
*/
|
|
1361
|
-
EDIT_IN_PROGRESS: "edit-in-progress"
|
|
1362
|
-
};
|
|
1363
|
-
var ActionFlag = z15.string().regex(
|
|
1364
|
-
new RegExp(
|
|
1365
|
-
`^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
|
|
1366
|
-
ActionStatus
|
|
1367
|
-
).join("|").toLowerCase()})$`
|
|
1368
|
-
),
|
|
1369
|
-
"Flag must be in the format ActionType:ActionStatus (lowerCase)"
|
|
1370
|
-
);
|
|
1371
|
-
var CustomFlag = z15.string().refine((val) => !Object.values(InherentFlags).includes(val), {
|
|
1372
|
-
message: `Custom flag cannot be one of the inherent flags: ${Object.values(
|
|
1373
|
-
InherentFlags
|
|
1374
|
-
).join(", ")}`
|
|
1375
|
-
}).refine((val) => !ActionFlag.safeParse(val).success, {
|
|
1376
|
-
message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
|
|
1377
|
-
}).describe("Custom flag identifier defined by the country config.");
|
|
1378
|
-
var Flag = ActionFlag.or(z15.enum(InherentFlags)).or(CustomFlag);
|
|
1379
|
-
var FlagConfig = z15.object({
|
|
1380
|
-
id: CustomFlag,
|
|
1381
|
-
requiresAction: z15.boolean().describe(
|
|
1382
|
-
"Indicates if this flag expects an action to be performed to be cleared."
|
|
1383
|
-
),
|
|
1384
|
-
label: TranslationConfig.describe("Human readable label of the flag.")
|
|
1385
|
-
}).meta({
|
|
1386
|
-
id: "FlagConfig",
|
|
1387
|
-
description: "Configuration for a custom flag that can be added to or removed from records by event actions."
|
|
1388
|
-
});
|
|
1389
|
-
var ActionFlagConfig = z15.object({
|
|
1390
|
-
id: Flag,
|
|
1391
|
-
operation: z15.enum(["add", "remove"]).describe("Operation to perform on the flag."),
|
|
1392
|
-
conditional: Conditional.optional().describe(
|
|
1393
|
-
"When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
|
|
1394
|
-
)
|
|
1395
|
-
}).meta({
|
|
1396
|
-
id: "ActionFlagConfig",
|
|
1397
|
-
description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
|
|
1398
|
-
});
|
|
1375
|
+
var Action = z15.union([ActionDocument, AsyncRejectActionDocument]);
|
|
1399
1376
|
|
|
1400
1377
|
// ../commons/src/events/EventMetadata.ts
|
|
1401
1378
|
var EventStatus = z16.enum([
|
|
@@ -1553,13 +1530,6 @@ var Range = import_v4.z.object({
|
|
|
1553
1530
|
}).meta({
|
|
1554
1531
|
id: "Range"
|
|
1555
1532
|
});
|
|
1556
|
-
var ContainsFlags = import_v4.z.object({
|
|
1557
|
-
anyOf: import_v4.z.array(Flag).optional(),
|
|
1558
|
-
noneOf: import_v4.z.array(Flag).optional(),
|
|
1559
|
-
allOf: import_v4.z.array(Flag).optional()
|
|
1560
|
-
}).meta({
|
|
1561
|
-
id: "ContainsFlags"
|
|
1562
|
-
});
|
|
1563
1533
|
var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
|
|
1564
1534
|
id: "Within"
|
|
1565
1535
|
});
|
|
@@ -3193,13 +3163,13 @@ var AdvancedSearchConfig = z28.object({
|
|
|
3193
3163
|
});
|
|
3194
3164
|
|
|
3195
3165
|
// ../commons/src/events/utils.ts
|
|
3196
|
-
var
|
|
3166
|
+
var import_lodash4 = require("lodash");
|
|
3197
3167
|
|
|
3198
3168
|
// ../commons/src/conditionals/validate.ts
|
|
3199
3169
|
var import__ = __toESM(require("ajv/dist/2019"));
|
|
3200
3170
|
var import_ajv_formats = __toESM(require("ajv-formats"));
|
|
3201
|
-
var
|
|
3202
|
-
var
|
|
3171
|
+
var z32 = __toESM(require("zod/v4"));
|
|
3172
|
+
var import_date_fns2 = require("date-fns");
|
|
3203
3173
|
|
|
3204
3174
|
// ../commons/src/events/FieldTypeMapping.ts
|
|
3205
3175
|
var z30 = __toESM(require("zod/v4"));
|
|
@@ -3207,152 +3177,26 @@ var z30 = __toESM(require("zod/v4"));
|
|
|
3207
3177
|
// ../commons/src/events/DynamicFieldValue.ts
|
|
3208
3178
|
var z29 = __toESM(require("zod/v4"));
|
|
3209
3179
|
|
|
3210
|
-
// ../commons/src/
|
|
3211
|
-
var
|
|
3212
|
-
$data: true,
|
|
3213
|
-
allowUnionTypes: true,
|
|
3214
|
-
strict: false
|
|
3215
|
-
// Allow minContains and other newer features
|
|
3216
|
-
});
|
|
3217
|
-
var DataContext = z31.object({
|
|
3218
|
-
rootData: z31.object({
|
|
3219
|
-
$leafAdminStructureLocationIds: z31.array(z31.object({ id: UUID }))
|
|
3220
|
-
})
|
|
3221
|
-
});
|
|
3222
|
-
function resolveDataPath(rootData, dataPath, instancePath) {
|
|
3223
|
-
const pathParts = dataPath.split("/");
|
|
3224
|
-
const levels = parseInt(pathParts[0], 10);
|
|
3225
|
-
const referencePath = pathParts.slice(1);
|
|
3226
|
-
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
3227
|
-
const traversedParts = instanceParts.slice(0, -levels);
|
|
3228
|
-
let current = rootData;
|
|
3229
|
-
for (const part of traversedParts) {
|
|
3230
|
-
if (current === null || current === void 0) {
|
|
3231
|
-
return void 0;
|
|
3232
|
-
}
|
|
3233
|
-
current = current[part];
|
|
3234
|
-
}
|
|
3235
|
-
for (const part of referencePath) {
|
|
3236
|
-
if (current === null || current === void 0) {
|
|
3237
|
-
return void 0;
|
|
3238
|
-
}
|
|
3239
|
-
current = current[part];
|
|
3240
|
-
}
|
|
3241
|
-
return current;
|
|
3242
|
-
}
|
|
3243
|
-
function todayISO() {
|
|
3244
|
-
return (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
3245
|
-
}
|
|
3246
|
-
var compiledFunctionCache = /* @__PURE__ */ new Map();
|
|
3247
|
-
function compileClientFunction(code) {
|
|
3248
|
-
let fn = compiledFunctionCache.get(code);
|
|
3249
|
-
if (!fn) {
|
|
3250
|
-
fn = new Function(`return (${code})`)();
|
|
3251
|
-
compiledFunctionCache.set(code, fn);
|
|
3252
|
-
}
|
|
3253
|
-
return fn;
|
|
3254
|
-
}
|
|
3255
|
-
(0, import_ajv_formats.default)(ajv);
|
|
3256
|
-
function buildClientFunctionContext(input) {
|
|
3257
|
-
return {
|
|
3258
|
-
$form: input.form,
|
|
3259
|
-
$now: todayISO(),
|
|
3260
|
-
// eslint-disable-next-line @typescript-eslint/no-use-before-define
|
|
3261
|
-
$online: isOnline(),
|
|
3262
|
-
$user: input.validatorContext?.user,
|
|
3263
|
-
$event: input.validatorContext?.event,
|
|
3264
|
-
$leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
|
|
3265
|
-
user: input.systemVariables?.user,
|
|
3266
|
-
$window: input.systemVariables?.$window,
|
|
3267
|
-
locations: input.locations,
|
|
3268
|
-
adminLevelIds: input.adminLevelIds
|
|
3269
|
-
};
|
|
3270
|
-
}
|
|
3271
|
-
function runClientFunction(code, data, context) {
|
|
3272
|
-
return compileClientFunction(code)(data, context);
|
|
3273
|
-
}
|
|
3274
|
-
ajv.addKeyword({
|
|
3275
|
-
keyword: "daysFromDate",
|
|
3276
|
-
type: "string",
|
|
3277
|
-
schemaType: "object",
|
|
3278
|
-
$data: true,
|
|
3279
|
-
errors: true,
|
|
3280
|
-
validate(schema, data, _2, dataContext) {
|
|
3281
|
-
if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
|
|
3282
|
-
throw new Error("Validation context must contain $now");
|
|
3283
|
-
}
|
|
3284
|
-
const { days, clause } = schema;
|
|
3285
|
-
if (typeof data !== "string") {
|
|
3286
|
-
return false;
|
|
3287
|
-
}
|
|
3288
|
-
const date = new Date(data);
|
|
3289
|
-
if (isNaN(date.getTime())) {
|
|
3290
|
-
return false;
|
|
3291
|
-
}
|
|
3292
|
-
let referenceDate = schema.referenceDate;
|
|
3293
|
-
if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
|
|
3294
|
-
referenceDate = resolveDataPath(
|
|
3295
|
-
dataContext.rootData,
|
|
3296
|
-
referenceDate.$data,
|
|
3297
|
-
dataContext.instancePath
|
|
3298
|
-
);
|
|
3299
|
-
}
|
|
3300
|
-
if (!referenceDate) {
|
|
3301
|
-
referenceDate = dataContext.rootData.$now;
|
|
3302
|
-
}
|
|
3303
|
-
const baseDate = new Date(referenceDate);
|
|
3304
|
-
if (isNaN(baseDate.getTime())) {
|
|
3305
|
-
return false;
|
|
3306
|
-
}
|
|
3307
|
-
const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
|
|
3308
|
-
return clause === "after" ? (0, import_date_fns.isAfter)(date, offsetDate) : (0, import_date_fns.isBefore)(date, offsetDate);
|
|
3309
|
-
}
|
|
3310
|
-
});
|
|
3311
|
-
ajv.addKeyword({
|
|
3312
|
-
keyword: "isLeafLevelLocation",
|
|
3313
|
-
type: "string",
|
|
3314
|
-
schemaType: "boolean",
|
|
3315
|
-
$data: true,
|
|
3316
|
-
errors: true,
|
|
3317
|
-
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
3318
|
-
validate(_schema, data, _2, dataContext) {
|
|
3319
|
-
const locationIdInput = data;
|
|
3320
|
-
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
3321
|
-
return locations.some((location) => location.id === locationIdInput);
|
|
3322
|
-
}
|
|
3323
|
-
});
|
|
3324
|
-
ajv.addKeyword({
|
|
3325
|
-
keyword: "customClientValidator",
|
|
3326
|
-
schemaType: "object",
|
|
3327
|
-
errors: true,
|
|
3328
|
-
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
3329
|
-
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
3330
|
-
// so the cast holds.
|
|
3331
|
-
validate(schema, data, _2, dataContext) {
|
|
3332
|
-
return Boolean(
|
|
3333
|
-
runClientFunction(
|
|
3334
|
-
schema.code,
|
|
3335
|
-
data,
|
|
3336
|
-
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
3337
|
-
)
|
|
3338
|
-
);
|
|
3339
|
-
}
|
|
3340
|
-
});
|
|
3341
|
-
function isOnline() {
|
|
3342
|
-
if (typeof window !== "undefined" && typeof navigator !== "undefined") {
|
|
3343
|
-
return navigator.onLine;
|
|
3344
|
-
}
|
|
3345
|
-
return true;
|
|
3346
|
-
}
|
|
3180
|
+
// ../commons/src/events/state/index.ts
|
|
3181
|
+
var import_lodash3 = require("lodash");
|
|
3347
3182
|
|
|
3348
3183
|
// ../commons/src/utils.ts
|
|
3349
|
-
var
|
|
3184
|
+
var z31 = __toESM(require("zod/v4"));
|
|
3350
3185
|
var _ = __toESM(require("lodash"));
|
|
3351
|
-
|
|
3352
|
-
|
|
3353
|
-
|
|
3354
|
-
|
|
3355
|
-
|
|
3186
|
+
function getOrThrow(x, message) {
|
|
3187
|
+
if (x === void 0 || x === null) {
|
|
3188
|
+
throw new Error(message);
|
|
3189
|
+
}
|
|
3190
|
+
return x;
|
|
3191
|
+
}
|
|
3192
|
+
function joinValues(values, separator = " ") {
|
|
3193
|
+
return values.filter((value) => !!value).join(separator).trim();
|
|
3194
|
+
}
|
|
3195
|
+
var FullNameV1 = z31.array(
|
|
3196
|
+
z31.object({
|
|
3197
|
+
use: z31.string(),
|
|
3198
|
+
family: z31.string(),
|
|
3199
|
+
given: z31.array(z31.string())
|
|
3356
3200
|
})
|
|
3357
3201
|
);
|
|
3358
3202
|
function omitKeyDeep(obj, keyToRemove) {
|
|
@@ -3371,36 +3215,262 @@ function omitKeyDeep(obj, keyToRemove) {
|
|
|
3371
3215
|
return newObj;
|
|
3372
3216
|
}
|
|
3373
3217
|
|
|
3374
|
-
// ../commons/src/events/utils.ts
|
|
3375
|
-
var
|
|
3376
|
-
function
|
|
3377
|
-
|
|
3218
|
+
// ../commons/src/events/state/utils.ts
|
|
3219
|
+
var import_lodash = require("lodash");
|
|
3220
|
+
function getActionRequests(actionType, actions) {
|
|
3221
|
+
const filtered = actions.filter((action) => action.type === actionType).reverse();
|
|
3222
|
+
const accept = filtered.find(
|
|
3223
|
+
(action) => action.status === ActionStatus.Accepted
|
|
3224
|
+
);
|
|
3225
|
+
const request = filtered.find(
|
|
3226
|
+
(action) => action.status === ActionStatus.Requested
|
|
3227
|
+
);
|
|
3228
|
+
const reject = filtered.find(
|
|
3229
|
+
(action) => action.status === ActionStatus.Rejected
|
|
3230
|
+
);
|
|
3231
|
+
return {
|
|
3232
|
+
reject,
|
|
3233
|
+
accept,
|
|
3234
|
+
request
|
|
3235
|
+
};
|
|
3378
3236
|
}
|
|
3379
|
-
|
|
3380
|
-
|
|
3381
|
-
|
|
3382
|
-
|
|
3383
|
-
|
|
3384
|
-
|
|
3237
|
+
function getDeclarationActionCreationMetadata(actionType, actions) {
|
|
3238
|
+
const { accept: acceptAction, request: requestAction } = getActionRequests(
|
|
3239
|
+
actionType,
|
|
3240
|
+
actions
|
|
3241
|
+
);
|
|
3242
|
+
if (!acceptAction) {
|
|
3243
|
+
return null;
|
|
3385
3244
|
}
|
|
3386
|
-
const
|
|
3387
|
-
|
|
3388
|
-
|
|
3389
|
-
|
|
3390
|
-
|
|
3391
|
-
|
|
3245
|
+
const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
|
|
3246
|
+
return {
|
|
3247
|
+
// When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
|
|
3248
|
+
createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
|
|
3249
|
+
createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
|
|
3250
|
+
createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
|
|
3251
|
+
createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
|
|
3252
|
+
acceptedAt: acceptAction.createdAt,
|
|
3253
|
+
createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
|
|
3254
|
+
registrationNumber
|
|
3255
|
+
};
|
|
3392
3256
|
}
|
|
3393
|
-
var
|
|
3394
|
-
|
|
3395
|
-
|
|
3396
|
-
|
|
3397
|
-
|
|
3398
|
-
|
|
3399
|
-
|
|
3400
|
-
ActionType.
|
|
3257
|
+
var updateActions = ActionTypes.extract([
|
|
3258
|
+
ActionType.CREATE,
|
|
3259
|
+
ActionType.NOTIFY,
|
|
3260
|
+
ActionType.EDIT,
|
|
3261
|
+
ActionType.DECLARE,
|
|
3262
|
+
ActionType.REGISTER,
|
|
3263
|
+
ActionType.REJECT,
|
|
3264
|
+
ActionType.ARCHIVE,
|
|
3265
|
+
ActionType.UNARCHIVE,
|
|
3401
3266
|
ActionType.PRINT_CERTIFICATE,
|
|
3402
|
-
ActionType.
|
|
3267
|
+
ActionType.REQUEST_CORRECTION,
|
|
3268
|
+
ActionType.APPROVE_CORRECTION,
|
|
3269
|
+
ActionType.REJECT_CORRECTION,
|
|
3270
|
+
ActionType.CUSTOM
|
|
3271
|
+
]);
|
|
3272
|
+
function getActionUpdateMetadata(actions) {
|
|
3273
|
+
const createAction = getOrThrow(
|
|
3274
|
+
actions.find((action) => action.type === ActionType.CREATE),
|
|
3275
|
+
`Event has no ${ActionType.CREATE} action`
|
|
3276
|
+
);
|
|
3277
|
+
const metadataFields = [
|
|
3278
|
+
"createdAt",
|
|
3279
|
+
"createdBy",
|
|
3280
|
+
"createdByUserType",
|
|
3281
|
+
"createdAtLocation",
|
|
3282
|
+
"createdByRole"
|
|
3283
|
+
];
|
|
3284
|
+
return actions.filter(({ type }) => updateActions.safeParse(type).success).reduce(
|
|
3285
|
+
(_2, action) => {
|
|
3286
|
+
if (action.originalActionId) {
|
|
3287
|
+
const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
|
|
3288
|
+
return (0, import_lodash.pick)(originalAction, metadataFields);
|
|
3289
|
+
}
|
|
3290
|
+
return (0, import_lodash.pick)(action, metadataFields);
|
|
3291
|
+
},
|
|
3292
|
+
(0, import_lodash.pick)(createAction, metadataFields)
|
|
3293
|
+
);
|
|
3294
|
+
}
|
|
3295
|
+
function getLegalStatuses(actions) {
|
|
3296
|
+
return {
|
|
3297
|
+
[EventStatus.enum.NOTIFIED]: getDeclarationActionCreationMetadata(
|
|
3298
|
+
ActionType.NOTIFY,
|
|
3299
|
+
actions
|
|
3300
|
+
),
|
|
3301
|
+
[EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
|
|
3302
|
+
ActionType.DECLARE,
|
|
3303
|
+
actions
|
|
3304
|
+
),
|
|
3305
|
+
[EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
|
|
3306
|
+
ActionType.REGISTER,
|
|
3307
|
+
actions
|
|
3308
|
+
)
|
|
3309
|
+
};
|
|
3310
|
+
}
|
|
3311
|
+
|
|
3312
|
+
// ../commons/src/events/state/flags.ts
|
|
3313
|
+
var import_lodash2 = require("lodash");
|
|
3314
|
+
var import_date_fns = require("date-fns");
|
|
3315
|
+
function isFlagConditionMet(conditional, form, action) {
|
|
3316
|
+
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" });
|
|
3317
|
+
return validate(conditional, {
|
|
3318
|
+
$form: form,
|
|
3319
|
+
$now: now2,
|
|
3320
|
+
$online: true,
|
|
3321
|
+
$user: {
|
|
3322
|
+
sub: "",
|
|
3323
|
+
exp: "",
|
|
3324
|
+
role: action.createdByRole,
|
|
3325
|
+
algorithm: "",
|
|
3326
|
+
scope: [],
|
|
3327
|
+
userType: action.createdByUserType
|
|
3328
|
+
}
|
|
3329
|
+
});
|
|
3330
|
+
}
|
|
3331
|
+
function actionConfigRemovesFlag(action, flagId, actionsUpToAndIncluding, event2, eventConfiguration) {
|
|
3332
|
+
if (!isActionConfigType(action.type)) {
|
|
3333
|
+
return false;
|
|
3334
|
+
}
|
|
3335
|
+
const actionConfig = getActionConfig({
|
|
3336
|
+
eventConfiguration,
|
|
3337
|
+
actionType: action.type,
|
|
3338
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3339
|
+
});
|
|
3340
|
+
const removeOperations = (actionConfig?.flags ?? []).filter(
|
|
3341
|
+
({ id, operation }) => id === flagId && operation === "remove"
|
|
3342
|
+
);
|
|
3343
|
+
if (removeOperations.length === 0) {
|
|
3344
|
+
return false;
|
|
3345
|
+
}
|
|
3346
|
+
const eventUpToThisAction = { ...event2, actions: actionsUpToAndIncluding };
|
|
3347
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3348
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3349
|
+
const form = { ...declaration, ...annotation };
|
|
3350
|
+
return removeOperations.some(
|
|
3351
|
+
({ conditional }) => conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3352
|
+
);
|
|
3353
|
+
}
|
|
3354
|
+
var INHERENT_FLAG_RULES = [
|
|
3355
|
+
{
|
|
3356
|
+
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
3357
|
+
setOn: [ActionType.REQUEST_CORRECTION],
|
|
3358
|
+
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
3359
|
+
},
|
|
3360
|
+
{
|
|
3361
|
+
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
3362
|
+
// other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
|
|
3363
|
+
// are deliberately excluded so the flag freezes across an archive/unarchive
|
|
3364
|
+
// round trip and comes back exactly as it was.
|
|
3365
|
+
flag: InherentFlags.INCOMPLETE,
|
|
3366
|
+
setOn: [ActionType.NOTIFY],
|
|
3367
|
+
resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
|
|
3368
|
+
},
|
|
3369
|
+
{
|
|
3370
|
+
flag: InherentFlags.REJECTED,
|
|
3371
|
+
setOn: [ActionType.REJECT],
|
|
3372
|
+
resetOn: [
|
|
3373
|
+
ActionType.NOTIFY,
|
|
3374
|
+
ActionType.DECLARE,
|
|
3375
|
+
ActionType.EDIT,
|
|
3376
|
+
ActionType.REGISTER
|
|
3377
|
+
]
|
|
3378
|
+
},
|
|
3379
|
+
{
|
|
3380
|
+
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
3381
|
+
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
3382
|
+
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
3383
|
+
},
|
|
3384
|
+
{
|
|
3385
|
+
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
3386
|
+
setOn: [ActionType.EDIT],
|
|
3387
|
+
resetOnAnyOtherAction: true
|
|
3388
|
+
}
|
|
3403
3389
|
];
|
|
3390
|
+
function resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration) {
|
|
3391
|
+
return acceptedActions.reduce((present, action, idx) => {
|
|
3392
|
+
if (rule.setOn.includes(action.type)) {
|
|
3393
|
+
return true;
|
|
3394
|
+
}
|
|
3395
|
+
if (rule.resetOnAnyOtherAction || (rule.resetOn ?? []).includes(action.type)) {
|
|
3396
|
+
return false;
|
|
3397
|
+
}
|
|
3398
|
+
if (actionConfigRemovesFlag(
|
|
3399
|
+
action,
|
|
3400
|
+
rule.flag,
|
|
3401
|
+
acceptedActions.slice(0, idx + 1),
|
|
3402
|
+
event2,
|
|
3403
|
+
eventConfiguration
|
|
3404
|
+
)) {
|
|
3405
|
+
return false;
|
|
3406
|
+
}
|
|
3407
|
+
return present;
|
|
3408
|
+
}, false);
|
|
3409
|
+
}
|
|
3410
|
+
function resolveEventCustomFlags(event2, eventConfiguration) {
|
|
3411
|
+
const actions = getAcceptedActions(event2).filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3412
|
+
return actions.reduce((acc, action, idx) => {
|
|
3413
|
+
let actionConfig;
|
|
3414
|
+
if (isActionConfigType(action.type)) {
|
|
3415
|
+
actionConfig = getActionConfig({
|
|
3416
|
+
eventConfiguration,
|
|
3417
|
+
actionType: action.type,
|
|
3418
|
+
customActionType: "customActionType" in action ? action.customActionType : void 0
|
|
3419
|
+
});
|
|
3420
|
+
}
|
|
3421
|
+
if (!actionConfig) {
|
|
3422
|
+
return acc;
|
|
3423
|
+
}
|
|
3424
|
+
const eventUpToThisAction = {
|
|
3425
|
+
...event2,
|
|
3426
|
+
actions: actions.slice(0, idx + 1)
|
|
3427
|
+
};
|
|
3428
|
+
const declaration = aggregateActionDeclarations(eventUpToThisAction);
|
|
3429
|
+
const annotation = aggregateActionAnnotations(eventUpToThisAction);
|
|
3430
|
+
const form = { ...declaration, ...annotation };
|
|
3431
|
+
const flagsWithMetConditions = (actionConfig.flags ?? []).filter(
|
|
3432
|
+
({ conditional }) => (
|
|
3433
|
+
// If conditional is not provided, the flag is resolved
|
|
3434
|
+
conditional ? isFlagConditionMet(conditional, form, action) : true
|
|
3435
|
+
)
|
|
3436
|
+
);
|
|
3437
|
+
const addedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "add").map(({ id }) => id);
|
|
3438
|
+
const removedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "remove").map(({ id }) => id);
|
|
3439
|
+
const flags = [...acc, ...addedFlags].filter(
|
|
3440
|
+
(flagId) => !removedFlags.includes(flagId)
|
|
3441
|
+
);
|
|
3442
|
+
return (0, import_lodash2.uniq)(flags);
|
|
3443
|
+
}, []);
|
|
3444
|
+
}
|
|
3445
|
+
function getActionStatusFlags(sortedActions) {
|
|
3446
|
+
const actionStatus = sortedActions.reduce(
|
|
3447
|
+
(actionStatuses, { type, status }) => ({
|
|
3448
|
+
...actionStatuses,
|
|
3449
|
+
[type]: status
|
|
3450
|
+
}),
|
|
3451
|
+
{}
|
|
3452
|
+
);
|
|
3453
|
+
return Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
|
|
3454
|
+
const flag = joinValues([type, status], ":").toLowerCase();
|
|
3455
|
+
return flag;
|
|
3456
|
+
});
|
|
3457
|
+
}
|
|
3458
|
+
function getInherentFlags(sortedActions, event2, eventConfiguration) {
|
|
3459
|
+
const acceptedActions = sortedActions.filter(
|
|
3460
|
+
({ status }) => status === ActionStatus.Accepted
|
|
3461
|
+
);
|
|
3462
|
+
return INHERENT_FLAG_RULES.filter(
|
|
3463
|
+
(rule) => resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration)
|
|
3464
|
+
).map(({ flag }) => flag);
|
|
3465
|
+
}
|
|
3466
|
+
function getEventFlags(event2, config) {
|
|
3467
|
+
const sortedActions = event2.actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
3468
|
+
return [
|
|
3469
|
+
...getActionStatusFlags(sortedActions),
|
|
3470
|
+
...getInherentFlags(sortedActions, event2, config),
|
|
3471
|
+
...resolveEventCustomFlags(event2, config)
|
|
3472
|
+
];
|
|
3473
|
+
}
|
|
3404
3474
|
|
|
3405
3475
|
// ../commons/src/conditionals/conditionals.ts
|
|
3406
3476
|
var objectHash = __toESM(require("object-hash"));
|
|
@@ -3929,84 +3999,590 @@ function createFieldConditionals(fieldId) {
|
|
|
3929
3999
|
},
|
|
3930
4000
|
this.$$subfield
|
|
3931
4001
|
)
|
|
3932
|
-
},
|
|
3933
|
-
required: [fieldId]
|
|
3934
|
-
});
|
|
3935
|
-
},
|
|
3936
|
-
getId: () => ({ fieldId }),
|
|
3937
|
-
/**
|
|
3938
|
-
* @deprecated
|
|
3939
|
-
* use field(fieldId).get(nestedProperty) instead
|
|
3940
|
-
* with 'and' combinator e.g.
|
|
3941
|
-
* and(
|
|
3942
|
-
* field('child.name').get('firstname').isEqualTo('John'),
|
|
3943
|
-
* field('child.name').get('surname').isEqualTo('Doe')
|
|
3944
|
-
* )
|
|
3945
|
-
*/
|
|
3946
|
-
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
3947
|
-
object: (options) => defineFormConditional({
|
|
3948
|
-
type: "object",
|
|
3949
|
-
properties: {
|
|
3950
|
-
[fieldId]: {
|
|
3951
|
-
type: "object",
|
|
3952
|
-
properties: Object.fromEntries(
|
|
3953
|
-
Object.entries(options).map(([key, value]) => {
|
|
3954
|
-
return [key, value.properties.$form.properties[key]];
|
|
3955
|
-
})
|
|
3956
|
-
),
|
|
3957
|
-
required: Object.keys(options)
|
|
4002
|
+
},
|
|
4003
|
+
required: [fieldId]
|
|
4004
|
+
});
|
|
4005
|
+
},
|
|
4006
|
+
getId: () => ({ fieldId }),
|
|
4007
|
+
/**
|
|
4008
|
+
* @deprecated
|
|
4009
|
+
* use field(fieldId).get(nestedProperty) instead
|
|
4010
|
+
* with 'and' combinator e.g.
|
|
4011
|
+
* and(
|
|
4012
|
+
* field('child.name').get('firstname').isEqualTo('John'),
|
|
4013
|
+
* field('child.name').get('surname').isEqualTo('Doe')
|
|
4014
|
+
* )
|
|
4015
|
+
*/
|
|
4016
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
4017
|
+
object: (options) => defineFormConditional({
|
|
4018
|
+
type: "object",
|
|
4019
|
+
properties: {
|
|
4020
|
+
[fieldId]: {
|
|
4021
|
+
type: "object",
|
|
4022
|
+
properties: Object.fromEntries(
|
|
4023
|
+
Object.entries(options).map(([key, value]) => {
|
|
4024
|
+
return [key, value.properties.$form.properties[key]];
|
|
4025
|
+
})
|
|
4026
|
+
),
|
|
4027
|
+
required: Object.keys(options)
|
|
4028
|
+
}
|
|
4029
|
+
},
|
|
4030
|
+
required: [fieldId]
|
|
4031
|
+
}),
|
|
4032
|
+
/**
|
|
4033
|
+
* Custom client-side validator. The provided function is serialised and executed
|
|
4034
|
+
* just-in-time on the client only. External references (e.g. lodash) are not
|
|
4035
|
+
* available inside the function body — all logic must be self-contained.
|
|
4036
|
+
*
|
|
4037
|
+
* @example
|
|
4038
|
+
* field('nid').customClientValidator((value) => {
|
|
4039
|
+
* // LUHN check — all logic must be inline
|
|
4040
|
+
* const digits = String(value).split('').map(Number)
|
|
4041
|
+
* // ...
|
|
4042
|
+
* return isValid
|
|
4043
|
+
* })
|
|
4044
|
+
*/
|
|
4045
|
+
customClientValidator(validationFn) {
|
|
4046
|
+
const code = validationFn.toString();
|
|
4047
|
+
return defineFormConditional({
|
|
4048
|
+
type: "object",
|
|
4049
|
+
properties: wrapToPath(
|
|
4050
|
+
{ [fieldId]: { customClientValidator: { code } } },
|
|
4051
|
+
this.$$subfield
|
|
4052
|
+
),
|
|
4053
|
+
required: [fieldId]
|
|
4054
|
+
});
|
|
4055
|
+
},
|
|
4056
|
+
/**
|
|
4057
|
+
* Custom client-side evaluation. Returns a {@link FieldReference} descriptor
|
|
4058
|
+
* that can be used as the `value` property or a DATA component entry.
|
|
4059
|
+
* The function receives the referenced field's value as the first argument and
|
|
4060
|
+
* the full form context as the second; its return value replaces the field reference.
|
|
4061
|
+
* The function is serialised and executed just-in-time on the client only.
|
|
4062
|
+
* External references (e.g. lodash) are not available inside the function body.
|
|
4063
|
+
*
|
|
4064
|
+
* For computing a default value without referencing a specific field, use
|
|
4065
|
+
* `evaluate(fn)` in the `defaultValue` property instead.
|
|
4066
|
+
*
|
|
4067
|
+
* @example
|
|
4068
|
+
* field('a').customClientEvaluation((aValue, ctx) =>
|
|
4069
|
+
* Number(aValue) + Number(ctx.$form.b)
|
|
4070
|
+
* )
|
|
4071
|
+
*/
|
|
4072
|
+
customClientEvaluation(computationFn) {
|
|
4073
|
+
return {
|
|
4074
|
+
$$code: computationFn.toString(),
|
|
4075
|
+
$$field: fieldId,
|
|
4076
|
+
$$subfield: this.$$subfield
|
|
4077
|
+
};
|
|
4078
|
+
}
|
|
4079
|
+
};
|
|
4080
|
+
}
|
|
4081
|
+
|
|
4082
|
+
// ../commons/src/events/state/index.ts
|
|
4083
|
+
function getStatusFromActions(actions) {
|
|
4084
|
+
const acceptedActions = actions.filter(
|
|
4085
|
+
({ status }) => status === ActionStatus.Accepted
|
|
4086
|
+
);
|
|
4087
|
+
const isCurrentlyArchived = acceptedActions.reduce(
|
|
4088
|
+
(archived, action) => {
|
|
4089
|
+
if (action.type === ActionType.ARCHIVE) {
|
|
4090
|
+
return true;
|
|
4091
|
+
}
|
|
4092
|
+
if (action.type === ActionType.UNARCHIVE) {
|
|
4093
|
+
return false;
|
|
4094
|
+
}
|
|
4095
|
+
return archived;
|
|
4096
|
+
},
|
|
4097
|
+
false
|
|
4098
|
+
);
|
|
4099
|
+
if (isCurrentlyArchived) {
|
|
4100
|
+
return EventStatus.enum.ARCHIVED;
|
|
4101
|
+
}
|
|
4102
|
+
return acceptedActions.filter(
|
|
4103
|
+
({ type }) => type !== ActionType.ARCHIVE && type !== ActionType.UNARCHIVE
|
|
4104
|
+
).reduce((status, action) => {
|
|
4105
|
+
switch (action.type) {
|
|
4106
|
+
case ActionType.CREATE:
|
|
4107
|
+
return EventStatus.enum.CREATED;
|
|
4108
|
+
case ActionType.DECLARE:
|
|
4109
|
+
return EventStatus.enum.DECLARED;
|
|
4110
|
+
case ActionType.REGISTER:
|
|
4111
|
+
return EventStatus.enum.REGISTERED;
|
|
4112
|
+
case ActionType.NOTIFY:
|
|
4113
|
+
return EventStatus.enum.NOTIFIED;
|
|
4114
|
+
// Already filtered out above; listed here only to satisfy exhaustiveness.
|
|
4115
|
+
case ActionType.ARCHIVE:
|
|
4116
|
+
case ActionType.UNARCHIVE:
|
|
4117
|
+
case ActionType.CUSTOM:
|
|
4118
|
+
case ActionType.PRINT_CERTIFICATE:
|
|
4119
|
+
case ActionType.ASSIGN:
|
|
4120
|
+
case ActionType.UNASSIGN:
|
|
4121
|
+
case ActionType.REJECT:
|
|
4122
|
+
case ActionType.REQUEST_CORRECTION:
|
|
4123
|
+
case ActionType.APPROVE_CORRECTION:
|
|
4124
|
+
case ActionType.DUPLICATE_DETECTED:
|
|
4125
|
+
case ActionType.MARK_AS_NOT_DUPLICATE:
|
|
4126
|
+
case ActionType.MARK_AS_DUPLICATE:
|
|
4127
|
+
case ActionType.REJECT_CORRECTION:
|
|
4128
|
+
case ActionType.READ:
|
|
4129
|
+
case ActionType.EDIT:
|
|
4130
|
+
default:
|
|
4131
|
+
return status;
|
|
4132
|
+
}
|
|
4133
|
+
}, EventStatus.enum.CREATED);
|
|
4134
|
+
}
|
|
4135
|
+
function getAssignedUserFromActions(actions) {
|
|
4136
|
+
return actions.reduce((user2, action) => {
|
|
4137
|
+
if (action.type === ActionType.ASSIGN) {
|
|
4138
|
+
return action.assignedTo;
|
|
4139
|
+
}
|
|
4140
|
+
if (action.type === ActionType.UNASSIGN) {
|
|
4141
|
+
return null;
|
|
4142
|
+
}
|
|
4143
|
+
return user2;
|
|
4144
|
+
}, null);
|
|
4145
|
+
}
|
|
4146
|
+
function deepDropNulls(obj) {
|
|
4147
|
+
if (Array.isArray(obj)) {
|
|
4148
|
+
return obj.map(deepDropNulls);
|
|
4149
|
+
}
|
|
4150
|
+
if (obj !== null && typeof obj === "object") {
|
|
4151
|
+
return Object.entries(obj).reduce((acc, [key, value]) => {
|
|
4152
|
+
const cleanedValue = deepDropNulls(value);
|
|
4153
|
+
if (cleanedValue !== null) {
|
|
4154
|
+
;
|
|
4155
|
+
acc[key] = cleanedValue;
|
|
4156
|
+
}
|
|
4157
|
+
return acc;
|
|
4158
|
+
}, {});
|
|
4159
|
+
}
|
|
4160
|
+
return obj;
|
|
4161
|
+
}
|
|
4162
|
+
var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
|
|
4163
|
+
function extractDateString(dateTime) {
|
|
4164
|
+
return dateTime.split("T")[0];
|
|
4165
|
+
}
|
|
4166
|
+
function resolveDateOfEvent(eventIndex, declaration, config) {
|
|
4167
|
+
if (!config.dateOfEvent) {
|
|
4168
|
+
return extractDateString(eventIndex[DEFAULT_DATE_OF_EVENT_PROPERTY]);
|
|
4169
|
+
}
|
|
4170
|
+
const parsedDate = isFieldReference(config.dateOfEvent) ? ZodDate.safeParse(declaration[config.dateOfEvent.$$field]) : ZodDateTime.safeParse(
|
|
4171
|
+
getMixedPath(eventIndex, config.dateOfEvent.$$event)
|
|
4172
|
+
);
|
|
4173
|
+
return parsedDate.success ? extractDateString(parsedDate.data) : void 0;
|
|
4174
|
+
}
|
|
4175
|
+
var DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
|
|
4176
|
+
function getParsedUUID(value, oldValue) {
|
|
4177
|
+
const parsed = UUID.safeParse(value);
|
|
4178
|
+
return parsed.success ? parsed.data : oldValue;
|
|
4179
|
+
}
|
|
4180
|
+
function resolvePlaceOfEvent(eventMetadata, declaration, config) {
|
|
4181
|
+
let placeOfEvent = getParsedUUID(
|
|
4182
|
+
eventMetadata[DEFAULT_PLACE_OF_EVENT_PROPERTY]
|
|
4183
|
+
);
|
|
4184
|
+
if (config.placeOfEvent) {
|
|
4185
|
+
const addressFieldValue = AddressFieldValue.safeParse(
|
|
4186
|
+
declaration[config.placeOfEvent.$$field]
|
|
4187
|
+
);
|
|
4188
|
+
if (addressFieldValue.success && addressFieldValue.data.addressType === AddressType.DOMESTIC && addressFieldValue.data.administrativeArea) {
|
|
4189
|
+
placeOfEvent = getParsedUUID(
|
|
4190
|
+
addressFieldValue.data.administrativeArea,
|
|
4191
|
+
placeOfEvent
|
|
4192
|
+
);
|
|
4193
|
+
} else {
|
|
4194
|
+
placeOfEvent = getParsedUUID(
|
|
4195
|
+
declaration[config.placeOfEvent.$$field],
|
|
4196
|
+
placeOfEvent
|
|
4197
|
+
);
|
|
4198
|
+
}
|
|
4199
|
+
}
|
|
4200
|
+
return placeOfEvent;
|
|
4201
|
+
}
|
|
4202
|
+
function extractPotentialDuplicatesFromActions(actions) {
|
|
4203
|
+
return actions.reduce((duplicates, action) => {
|
|
4204
|
+
if (action.type === ActionType.DUPLICATE_DETECTED) {
|
|
4205
|
+
duplicates = action.content.duplicates;
|
|
4206
|
+
}
|
|
4207
|
+
if (action.type === ActionType.MARK_AS_NOT_DUPLICATE || action.type === ActionType.MARK_AS_DUPLICATE) {
|
|
4208
|
+
duplicates = [];
|
|
4209
|
+
}
|
|
4210
|
+
return duplicates;
|
|
4211
|
+
}, []);
|
|
4212
|
+
}
|
|
4213
|
+
function getCurrentEventState(event2, config) {
|
|
4214
|
+
const sortedActions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4215
|
+
const creationAction = sortedActions.find(
|
|
4216
|
+
(action) => action.type === ActionType.CREATE
|
|
4217
|
+
);
|
|
4218
|
+
if (!creationAction) {
|
|
4219
|
+
throw new Error(`Event ${event2.id} has no creation action`);
|
|
4220
|
+
}
|
|
4221
|
+
const acceptedActions = getAcceptedActions(event2).sort(
|
|
4222
|
+
(a, b) => a.createdAt.localeCompare(b.createdAt)
|
|
4223
|
+
);
|
|
4224
|
+
const requestActionMetadata = getActionUpdateMetadata(sortedActions);
|
|
4225
|
+
const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
|
|
4226
|
+
const declaration = aggregateActionDeclarations(event2);
|
|
4227
|
+
const status = getStatusFromActions(sortedActions);
|
|
4228
|
+
const legalStatuses = getLegalStatuses(sortedActions);
|
|
4229
|
+
const base = deepDropNulls({
|
|
4230
|
+
id: event2.id,
|
|
4231
|
+
type: event2.type,
|
|
4232
|
+
status,
|
|
4233
|
+
legalStatuses,
|
|
4234
|
+
createdAt: creationAction.createdAt,
|
|
4235
|
+
createdBy: creationAction.createdBy,
|
|
4236
|
+
createdByUserType: creationAction.createdByUserType,
|
|
4237
|
+
createdAtLocation: creationAction.createdAtLocation,
|
|
4238
|
+
updatedAt: acceptedActionMetadata.createdAt,
|
|
4239
|
+
assignedTo: getAssignedUserFromActions(acceptedActions),
|
|
4240
|
+
updatedBy: requestActionMetadata.createdBy,
|
|
4241
|
+
updatedAtLocation: requestActionMetadata.createdAtLocation,
|
|
4242
|
+
declaration,
|
|
4243
|
+
trackingId: event2.trackingId,
|
|
4244
|
+
updatedByUserRole: requestActionMetadata.createdByRole,
|
|
4245
|
+
placeOfEvent: resolvePlaceOfEvent(
|
|
4246
|
+
{ createdAtLocation: creationAction.createdAtLocation },
|
|
4247
|
+
declaration,
|
|
4248
|
+
config
|
|
4249
|
+
),
|
|
4250
|
+
potentialDuplicates: extractPotentialDuplicatesFromActions(sortedActions),
|
|
4251
|
+
flags: getEventFlags(event2, config)
|
|
4252
|
+
});
|
|
4253
|
+
return deepDropNulls({
|
|
4254
|
+
...base,
|
|
4255
|
+
dateOfEvent: resolveDateOfEvent(base, declaration, config)
|
|
4256
|
+
});
|
|
4257
|
+
}
|
|
4258
|
+
|
|
4259
|
+
// ../commons/src/conditionals/validate.ts
|
|
4260
|
+
var ajv = new import__.default({
|
|
4261
|
+
$data: true,
|
|
4262
|
+
allowUnionTypes: true,
|
|
4263
|
+
strict: false
|
|
4264
|
+
// Allow minContains and other newer features
|
|
4265
|
+
});
|
|
4266
|
+
var DataContext = z32.object({
|
|
4267
|
+
rootData: z32.object({
|
|
4268
|
+
$leafAdminStructureLocationIds: z32.array(z32.object({ id: UUID }))
|
|
4269
|
+
})
|
|
4270
|
+
});
|
|
4271
|
+
function resolveDataPath(rootData, dataPath, instancePath) {
|
|
4272
|
+
const pathParts = dataPath.split("/");
|
|
4273
|
+
const levels = parseInt(pathParts[0], 10);
|
|
4274
|
+
const referencePath = pathParts.slice(1);
|
|
4275
|
+
const instanceParts = instancePath.split("/").filter(Boolean);
|
|
4276
|
+
const traversedParts = instanceParts.slice(0, -levels);
|
|
4277
|
+
let current = rootData;
|
|
4278
|
+
for (const part of traversedParts) {
|
|
4279
|
+
if (current === null || current === void 0) {
|
|
4280
|
+
return void 0;
|
|
4281
|
+
}
|
|
4282
|
+
current = current[part];
|
|
4283
|
+
}
|
|
4284
|
+
for (const part of referencePath) {
|
|
4285
|
+
if (current === null || current === void 0) {
|
|
4286
|
+
return void 0;
|
|
4287
|
+
}
|
|
4288
|
+
current = current[part];
|
|
4289
|
+
}
|
|
4290
|
+
return current;
|
|
4291
|
+
}
|
|
4292
|
+
function todayISO() {
|
|
4293
|
+
return (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
|
|
4294
|
+
}
|
|
4295
|
+
var compiledFunctionCache = /* @__PURE__ */ new Map();
|
|
4296
|
+
function compileClientFunction(code) {
|
|
4297
|
+
let fn = compiledFunctionCache.get(code);
|
|
4298
|
+
if (!fn) {
|
|
4299
|
+
fn = new Function(`return (${code})`)();
|
|
4300
|
+
compiledFunctionCache.set(code, fn);
|
|
4301
|
+
}
|
|
4302
|
+
return fn;
|
|
4303
|
+
}
|
|
4304
|
+
(0, import_ajv_formats.default)(ajv);
|
|
4305
|
+
function buildClientFunctionContext(input) {
|
|
4306
|
+
const flags = input.validatorContext?.event && input.validatorContext?.eventConfig ? getCurrentEventState(
|
|
4307
|
+
input.validatorContext?.event,
|
|
4308
|
+
input.validatorContext?.eventConfig
|
|
4309
|
+
)?.flags : [];
|
|
4310
|
+
return {
|
|
4311
|
+
$form: input.form,
|
|
4312
|
+
$flags: flags,
|
|
4313
|
+
$now: todayISO(),
|
|
4314
|
+
// eslint-disable-next-line @typescript-eslint/no-use-before-define
|
|
4315
|
+
$online: isOnline(),
|
|
4316
|
+
$user: input.validatorContext?.user,
|
|
4317
|
+
$event: input.validatorContext?.event,
|
|
4318
|
+
$leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
|
|
4319
|
+
user: input.systemVariables?.user,
|
|
4320
|
+
$window: input.systemVariables?.$window,
|
|
4321
|
+
locations: input.locations,
|
|
4322
|
+
adminLevelIds: input.adminLevelIds
|
|
4323
|
+
};
|
|
4324
|
+
}
|
|
4325
|
+
function runClientFunction(code, data, context) {
|
|
4326
|
+
return compileClientFunction(code)(data, context);
|
|
4327
|
+
}
|
|
4328
|
+
ajv.addKeyword({
|
|
4329
|
+
keyword: "daysFromDate",
|
|
4330
|
+
type: "string",
|
|
4331
|
+
schemaType: "object",
|
|
4332
|
+
$data: true,
|
|
4333
|
+
errors: true,
|
|
4334
|
+
validate(schema, data, _2, dataContext) {
|
|
4335
|
+
if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
|
|
4336
|
+
throw new Error("Validation context must contain $now");
|
|
4337
|
+
}
|
|
4338
|
+
const { days, clause } = schema;
|
|
4339
|
+
if (typeof data !== "string") {
|
|
4340
|
+
return false;
|
|
4341
|
+
}
|
|
4342
|
+
const date = new Date(data);
|
|
4343
|
+
if (isNaN(date.getTime())) {
|
|
4344
|
+
return false;
|
|
4345
|
+
}
|
|
4346
|
+
let referenceDate = schema.referenceDate;
|
|
4347
|
+
if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
|
|
4348
|
+
referenceDate = resolveDataPath(
|
|
4349
|
+
dataContext.rootData,
|
|
4350
|
+
referenceDate.$data,
|
|
4351
|
+
dataContext.instancePath
|
|
4352
|
+
);
|
|
4353
|
+
}
|
|
4354
|
+
if (!referenceDate) {
|
|
4355
|
+
referenceDate = dataContext.rootData.$now;
|
|
4356
|
+
}
|
|
4357
|
+
const baseDate = new Date(referenceDate);
|
|
4358
|
+
if (isNaN(baseDate.getTime())) {
|
|
4359
|
+
return false;
|
|
4360
|
+
}
|
|
4361
|
+
const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
|
|
4362
|
+
return clause === "after" ? (0, import_date_fns2.isAfter)(date, offsetDate) : (0, import_date_fns2.isBefore)(date, offsetDate);
|
|
4363
|
+
}
|
|
4364
|
+
});
|
|
4365
|
+
ajv.addKeyword({
|
|
4366
|
+
keyword: "isLeafLevelLocation",
|
|
4367
|
+
type: "string",
|
|
4368
|
+
schemaType: "boolean",
|
|
4369
|
+
$data: true,
|
|
4370
|
+
errors: true,
|
|
4371
|
+
// @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
|
|
4372
|
+
validate(_schema, data, _2, dataContext) {
|
|
4373
|
+
const locationIdInput = data;
|
|
4374
|
+
const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
|
|
4375
|
+
return locations.some((location) => location.id === locationIdInput);
|
|
4376
|
+
}
|
|
4377
|
+
});
|
|
4378
|
+
function isAgeValue(value) {
|
|
4379
|
+
return typeof value === "object" && value !== null && "age" in value && typeof value.age === "number";
|
|
4380
|
+
}
|
|
4381
|
+
ajv.addKeyword({
|
|
4382
|
+
keyword: "customClientValidator",
|
|
4383
|
+
schemaType: "object",
|
|
4384
|
+
errors: true,
|
|
4385
|
+
// @ts-expect-error -- AJV's public types don't expose `rootData`. All
|
|
4386
|
+
// `validate()` callers build root data via `buildClientFunctionContext`,
|
|
4387
|
+
// so the cast holds.
|
|
4388
|
+
validate(schema, data, _2, dataContext) {
|
|
4389
|
+
return Boolean(
|
|
4390
|
+
runClientFunction(
|
|
4391
|
+
schema.code,
|
|
4392
|
+
data,
|
|
4393
|
+
dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
|
|
4394
|
+
)
|
|
4395
|
+
);
|
|
4396
|
+
}
|
|
4397
|
+
});
|
|
4398
|
+
function validate(schema, data) {
|
|
4399
|
+
const validator = ajv.getSchema(schema.$id) || ajv.compile(schema);
|
|
4400
|
+
if ("$form" in data) {
|
|
4401
|
+
const entries = Object.entries(data.$form).map(([key, value]) => {
|
|
4402
|
+
if (!isAgeValue(value)) {
|
|
4403
|
+
return [key, value];
|
|
4404
|
+
}
|
|
4405
|
+
const age = value.age;
|
|
4406
|
+
const maybeAsOfDate = PlainDate.safeParse(data.$form[value.asOfDateRef]);
|
|
4407
|
+
return [
|
|
4408
|
+
key,
|
|
4409
|
+
{
|
|
4410
|
+
age,
|
|
4411
|
+
dob: ageToDate(
|
|
4412
|
+
age,
|
|
4413
|
+
maybeAsOfDate.success ? maybeAsOfDate.data : PlainDate.parse(data.$now)
|
|
4414
|
+
)
|
|
3958
4415
|
}
|
|
3959
|
-
|
|
3960
|
-
|
|
3961
|
-
|
|
3962
|
-
|
|
3963
|
-
|
|
3964
|
-
|
|
3965
|
-
|
|
3966
|
-
|
|
3967
|
-
|
|
3968
|
-
|
|
3969
|
-
|
|
3970
|
-
|
|
3971
|
-
|
|
3972
|
-
|
|
3973
|
-
|
|
3974
|
-
|
|
3975
|
-
|
|
3976
|
-
|
|
3977
|
-
|
|
3978
|
-
|
|
3979
|
-
|
|
3980
|
-
|
|
3981
|
-
|
|
3982
|
-
|
|
3983
|
-
|
|
3984
|
-
|
|
3985
|
-
|
|
3986
|
-
|
|
3987
|
-
|
|
3988
|
-
|
|
3989
|
-
|
|
3990
|
-
|
|
3991
|
-
|
|
3992
|
-
|
|
3993
|
-
|
|
3994
|
-
|
|
3995
|
-
|
|
3996
|
-
|
|
3997
|
-
|
|
3998
|
-
|
|
3999
|
-
|
|
4000
|
-
|
|
4001
|
-
|
|
4002
|
-
|
|
4003
|
-
|
|
4004
|
-
|
|
4005
|
-
|
|
4006
|
-
|
|
4007
|
-
|
|
4416
|
+
];
|
|
4417
|
+
});
|
|
4418
|
+
data.$form = Object.fromEntries(entries);
|
|
4419
|
+
}
|
|
4420
|
+
const result = validator(data);
|
|
4421
|
+
return result;
|
|
4422
|
+
}
|
|
4423
|
+
function isOnline() {
|
|
4424
|
+
if (typeof window !== "undefined" && typeof navigator !== "undefined") {
|
|
4425
|
+
return navigator.onLine;
|
|
4426
|
+
}
|
|
4427
|
+
return true;
|
|
4428
|
+
}
|
|
4429
|
+
|
|
4430
|
+
// ../commons/src/events/utils.ts
|
|
4431
|
+
var import_date_fns3 = require("date-fns");
|
|
4432
|
+
function ageToDate(age, asOfDate) {
|
|
4433
|
+
const date = plainDateToLocalDate(asOfDate);
|
|
4434
|
+
return PlainDate.parse((0, import_date_fns3.format)((0, import_date_fns3.subYears)(date, age), "yyyy-MM-dd"));
|
|
4435
|
+
}
|
|
4436
|
+
function getDeclarationFields(configuration) {
|
|
4437
|
+
return configuration.declaration.pages.flatMap(({ fields }) => fields);
|
|
4438
|
+
}
|
|
4439
|
+
function isActionConfigType(type) {
|
|
4440
|
+
return actionConfigTypes.has(type);
|
|
4441
|
+
}
|
|
4442
|
+
function getActionConfig({
|
|
4443
|
+
eventConfiguration,
|
|
4444
|
+
actionType,
|
|
4445
|
+
customActionType
|
|
4446
|
+
}) {
|
|
4447
|
+
if (actionType === ActionType.NOTIFY) {
|
|
4448
|
+
return eventConfiguration.actions.find((a) => a.type === ActionType.NOTIFY) ?? eventConfiguration.actions.find((a) => a.type === ActionType.DECLARE);
|
|
4449
|
+
}
|
|
4450
|
+
return eventConfiguration.actions.find((a) => {
|
|
4451
|
+
if (a.type === ActionType.CUSTOM && customActionType) {
|
|
4452
|
+
return a.customActionType === customActionType;
|
|
4453
|
+
}
|
|
4454
|
+
return a.type === actionType;
|
|
4455
|
+
});
|
|
4456
|
+
}
|
|
4457
|
+
var getActionAnnotationFields = (actionConfig) => {
|
|
4458
|
+
if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
|
|
4459
|
+
return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
|
|
4460
|
+
}
|
|
4461
|
+
if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
|
|
4462
|
+
return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
|
|
4463
|
+
}
|
|
4464
|
+
const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
|
|
4465
|
+
const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
|
|
4466
|
+
return [...reviewFields, ...formFields];
|
|
4467
|
+
};
|
|
4468
|
+
function getAllAnnotationFields(config) {
|
|
4469
|
+
return (0, import_lodash4.flattenDeep)(config.actions.map(getActionAnnotationFields));
|
|
4470
|
+
}
|
|
4471
|
+
function deepMerge(currentDocument, actionDocument) {
|
|
4472
|
+
const currentDocumentClone = (0, import_lodash4.cloneDeep)(currentDocument);
|
|
4473
|
+
return (0, import_lodash4.mergeWith)(
|
|
4474
|
+
(0, import_lodash4.cloneDeep)(currentDocumentClone),
|
|
4475
|
+
actionDocument,
|
|
4476
|
+
(previousValue, incomingValue) => {
|
|
4477
|
+
if (incomingValue === void 0) {
|
|
4478
|
+
return previousValue;
|
|
4479
|
+
}
|
|
4480
|
+
if ((0, import_lodash4.isArray)(incomingValue)) {
|
|
4481
|
+
return incomingValue;
|
|
4482
|
+
}
|
|
4483
|
+
if ((0, import_lodash4.isObject)(previousValue) && (0, import_lodash4.isObject)(incomingValue)) {
|
|
4484
|
+
return void 0;
|
|
4485
|
+
}
|
|
4486
|
+
return incomingValue;
|
|
4008
4487
|
}
|
|
4488
|
+
);
|
|
4489
|
+
}
|
|
4490
|
+
var findAllFields = (config) => {
|
|
4491
|
+
return (0, import_lodash4.flattenDeep)([
|
|
4492
|
+
...getDeclarationFields(config),
|
|
4493
|
+
...getAllAnnotationFields(config)
|
|
4494
|
+
]);
|
|
4495
|
+
};
|
|
4496
|
+
function getMixedPath(obj, path, defaultValue) {
|
|
4497
|
+
const parts = path.split(".");
|
|
4498
|
+
const resolve = (current, segments) => {
|
|
4499
|
+
if (current == null || segments.length === 0) {
|
|
4500
|
+
return current;
|
|
4501
|
+
}
|
|
4502
|
+
for (let i = segments.length; i > 0; i--) {
|
|
4503
|
+
const compoundKey = segments.slice(0, i).join(".");
|
|
4504
|
+
if ((0, import_lodash4.has)(current, compoundKey)) {
|
|
4505
|
+
const next = (0, import_lodash4.get)(current, compoundKey);
|
|
4506
|
+
return resolve(next, segments.slice(i));
|
|
4507
|
+
}
|
|
4508
|
+
}
|
|
4509
|
+
return void 0;
|
|
4009
4510
|
};
|
|
4511
|
+
const result = resolve(obj, parts);
|
|
4512
|
+
return (0, import_lodash4.isNil)(result) ? defaultValue : result;
|
|
4513
|
+
}
|
|
4514
|
+
function isAcceptedAction(a) {
|
|
4515
|
+
return a.status === ActionStatus.Accepted;
|
|
4516
|
+
}
|
|
4517
|
+
function getCompleteActionAnnotation(event2, action) {
|
|
4518
|
+
if (action.originalActionId) {
|
|
4519
|
+
const originalAction = event2.actions.find(
|
|
4520
|
+
({ id }) => id === action.originalActionId
|
|
4521
|
+
);
|
|
4522
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4523
|
+
return deepMerge(originalAction.annotation ?? {}, action.annotation ?? {});
|
|
4524
|
+
}
|
|
4525
|
+
}
|
|
4526
|
+
return action.annotation ?? {};
|
|
4527
|
+
}
|
|
4528
|
+
function getCompleteActionDeclaration(declaration, event2, action) {
|
|
4529
|
+
if (action.originalActionId) {
|
|
4530
|
+
const originalAction = event2.actions.find(
|
|
4531
|
+
({ id }) => id === action.originalActionId
|
|
4532
|
+
);
|
|
4533
|
+
if (originalAction?.status === ActionStatus.Requested) {
|
|
4534
|
+
return deepMerge(
|
|
4535
|
+
deepMerge(declaration, originalAction.declaration),
|
|
4536
|
+
action.declaration
|
|
4537
|
+
);
|
|
4538
|
+
}
|
|
4539
|
+
}
|
|
4540
|
+
return deepMerge(declaration, action.declaration);
|
|
4541
|
+
}
|
|
4542
|
+
function getAcceptedActions(event2) {
|
|
4543
|
+
return event2.actions.filter(isAcceptedAction).map((action) => ({
|
|
4544
|
+
...action,
|
|
4545
|
+
declaration: getCompleteActionDeclaration({}, event2, action),
|
|
4546
|
+
annotation: getCompleteActionAnnotation(event2, action)
|
|
4547
|
+
}));
|
|
4548
|
+
}
|
|
4549
|
+
var EXCLUDED_ACTIONS = [
|
|
4550
|
+
ActionType.REQUEST_CORRECTION,
|
|
4551
|
+
ActionType.PRINT_CERTIFICATE,
|
|
4552
|
+
ActionType.REJECT_CORRECTION
|
|
4553
|
+
];
|
|
4554
|
+
function aggregateActionDeclarations(event2) {
|
|
4555
|
+
const allAcceptedActions = getAcceptedActions(event2);
|
|
4556
|
+
const aggregatedActions = allAcceptedActions.filter((a) => !EXCLUDED_ACTIONS.some((type) => type === a.type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
|
|
4557
|
+
return aggregatedActions.reduce((declaration, action) => {
|
|
4558
|
+
if (action.type === ActionType.APPROVE_CORRECTION) {
|
|
4559
|
+
const requestAction = allAcceptedActions.find(
|
|
4560
|
+
({ id }) => id === action.requestId
|
|
4561
|
+
);
|
|
4562
|
+
if (!requestAction) {
|
|
4563
|
+
return declaration;
|
|
4564
|
+
}
|
|
4565
|
+
const declarationWithApprovedCorrection = getCompleteActionDeclaration(
|
|
4566
|
+
declaration,
|
|
4567
|
+
event2,
|
|
4568
|
+
requestAction
|
|
4569
|
+
);
|
|
4570
|
+
return getCompleteActionDeclaration(
|
|
4571
|
+
declarationWithApprovedCorrection,
|
|
4572
|
+
event2,
|
|
4573
|
+
action
|
|
4574
|
+
);
|
|
4575
|
+
}
|
|
4576
|
+
return getCompleteActionDeclaration(declaration, event2, action);
|
|
4577
|
+
}, {});
|
|
4578
|
+
}
|
|
4579
|
+
function aggregateActionAnnotations(event2) {
|
|
4580
|
+
return event2.actions.reduce((ann, sortedAction) => {
|
|
4581
|
+
if (!("annotation" in sortedAction) || !sortedAction.annotation) {
|
|
4582
|
+
return ann;
|
|
4583
|
+
}
|
|
4584
|
+
return deepMerge(ann, sortedAction.annotation);
|
|
4585
|
+
}, {});
|
|
4010
4586
|
}
|
|
4011
4587
|
|
|
4012
4588
|
// ../commons/src/events/eventConfigValidation.ts
|
|
@@ -4850,14 +5426,14 @@ var DraftInput = BaseActionInput.omit({ waitFor: true }).extend({
|
|
|
4850
5426
|
|
|
4851
5427
|
// ../commons/src/events/EventInput.ts
|
|
4852
5428
|
var z40 = __toESM(require("zod/v4"));
|
|
4853
|
-
var
|
|
5429
|
+
var import_uuid11 = require("uuid");
|
|
4854
5430
|
var EventInput = z40.object({
|
|
4855
5431
|
transactionId: z40.string(),
|
|
4856
5432
|
type: z40.string(),
|
|
4857
5433
|
createdAtLocation: UUID.nullish().describe(
|
|
4858
5434
|
"Location where the event occurred. Required for system users."
|
|
4859
5435
|
)
|
|
4860
|
-
}).meta({ default: { transactionId: (0,
|
|
5436
|
+
}).meta({ default: { transactionId: (0, import_uuid11.v4)(), type: "birth" } });
|
|
4861
5437
|
|
|
4862
5438
|
// ../commons/src/events/EventDocument.ts
|
|
4863
5439
|
var z41 = __toESM(require("zod/v4"));
|
|
@@ -4874,67 +5450,6 @@ var EventDocument = z41.object({
|
|
|
4874
5450
|
)
|
|
4875
5451
|
}).meta({ id: "EventDocument" });
|
|
4876
5452
|
|
|
4877
|
-
// ../commons/src/events/state/index.ts
|
|
4878
|
-
var import_lodash4 = require("lodash");
|
|
4879
|
-
|
|
4880
|
-
// ../commons/src/events/state/utils.ts
|
|
4881
|
-
var import_lodash2 = require("lodash");
|
|
4882
|
-
var updateActions = ActionTypes.extract([
|
|
4883
|
-
ActionType.CREATE,
|
|
4884
|
-
ActionType.NOTIFY,
|
|
4885
|
-
ActionType.EDIT,
|
|
4886
|
-
ActionType.DECLARE,
|
|
4887
|
-
ActionType.REGISTER,
|
|
4888
|
-
ActionType.REJECT,
|
|
4889
|
-
ActionType.ARCHIVE,
|
|
4890
|
-
ActionType.UNARCHIVE,
|
|
4891
|
-
ActionType.PRINT_CERTIFICATE,
|
|
4892
|
-
ActionType.REQUEST_CORRECTION,
|
|
4893
|
-
ActionType.APPROVE_CORRECTION,
|
|
4894
|
-
ActionType.REJECT_CORRECTION,
|
|
4895
|
-
ActionType.CUSTOM
|
|
4896
|
-
]);
|
|
4897
|
-
|
|
4898
|
-
// ../commons/src/events/state/flags.ts
|
|
4899
|
-
var import_lodash3 = require("lodash");
|
|
4900
|
-
var import_date_fns3 = require("date-fns");
|
|
4901
|
-
var INHERENT_FLAG_RULES = [
|
|
4902
|
-
{
|
|
4903
|
-
flag: InherentFlags.CORRECTION_REQUESTED,
|
|
4904
|
-
setOn: [ActionType.REQUEST_CORRECTION],
|
|
4905
|
-
resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
|
|
4906
|
-
},
|
|
4907
|
-
{
|
|
4908
|
-
// INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
|
|
4909
|
-
// other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
|
|
4910
|
-
// are deliberately excluded so the flag freezes across an archive/unarchive
|
|
4911
|
-
// round trip and comes back exactly as it was.
|
|
4912
|
-
flag: InherentFlags.INCOMPLETE,
|
|
4913
|
-
setOn: [ActionType.NOTIFY],
|
|
4914
|
-
resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
|
|
4915
|
-
},
|
|
4916
|
-
{
|
|
4917
|
-
flag: InherentFlags.REJECTED,
|
|
4918
|
-
setOn: [ActionType.REJECT],
|
|
4919
|
-
resetOn: [
|
|
4920
|
-
ActionType.NOTIFY,
|
|
4921
|
-
ActionType.DECLARE,
|
|
4922
|
-
ActionType.EDIT,
|
|
4923
|
-
ActionType.REGISTER
|
|
4924
|
-
]
|
|
4925
|
-
},
|
|
4926
|
-
{
|
|
4927
|
-
flag: InherentFlags.POTENTIAL_DUPLICATE,
|
|
4928
|
-
setOn: [ActionType.DUPLICATE_DETECTED],
|
|
4929
|
-
resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
|
|
4930
|
-
},
|
|
4931
|
-
{
|
|
4932
|
-
flag: InherentFlags.EDIT_IN_PROGRESS,
|
|
4933
|
-
setOn: [ActionType.EDIT],
|
|
4934
|
-
resetOnAnyOtherAction: true
|
|
4935
|
-
}
|
|
4936
|
-
];
|
|
4937
|
-
|
|
4938
5453
|
// ../commons/src/events/defineConfig.ts
|
|
4939
5454
|
var IGNORED_EVENT_TYPES = [
|
|
4940
5455
|
"FOOTBALL_CLUB_MEMBERSHIP",
|
|
@@ -7407,44 +7922,21 @@ var LocationTypeV1 = z43.enum([
|
|
|
7407
7922
|
"CRVS_OFFICE",
|
|
7408
7923
|
"HEALTH_FACILITY"
|
|
7409
7924
|
]);
|
|
7410
|
-
var LocationStatus = z43.enum(["active", "inactive"]);
|
|
7411
|
-
var LocationVersion = z43.object({
|
|
7412
|
-
versionId: UUID,
|
|
7413
|
-
effectiveFrom: z43.iso.date(),
|
|
7414
|
-
name: z43.string(),
|
|
7415
|
-
externalId: z43.string().nullish(),
|
|
7416
|
-
status: LocationStatus
|
|
7417
|
-
});
|
|
7418
7925
|
var AdministrativeArea = z43.object({
|
|
7419
7926
|
id: UUID,
|
|
7420
7927
|
name: z43.string(),
|
|
7421
7928
|
externalId: z43.string().nullish(),
|
|
7422
7929
|
parentId: UUID.nullable(),
|
|
7423
|
-
|
|
7424
|
-
versions: z43.array(LocationVersion)
|
|
7930
|
+
validUntil: z43.iso.datetime().nullable()
|
|
7425
7931
|
});
|
|
7426
7932
|
var Location = z43.object({
|
|
7427
7933
|
id: UUID,
|
|
7428
7934
|
name: z43.string(),
|
|
7429
7935
|
externalId: z43.string().nullish(),
|
|
7430
7936
|
administrativeAreaId: UUID.nullable(),
|
|
7431
|
-
|
|
7432
|
-
status: LocationStatus,
|
|
7433
|
-
versions: z43.array(LocationVersion)
|
|
7434
|
-
});
|
|
7435
|
-
var SetLocationPayload = z43.object({
|
|
7436
|
-
id: UUID,
|
|
7437
|
-
name: z43.string(),
|
|
7438
|
-
externalId: z43.string().nullish(),
|
|
7439
|
-
administrativeAreaId: UUID.nullable(),
|
|
7937
|
+
validUntil: z43.iso.datetime().nullable(),
|
|
7440
7938
|
locationType: z43.string().nullable()
|
|
7441
7939
|
});
|
|
7442
|
-
var SetAdministrativeAreaPayload = z43.object({
|
|
7443
|
-
id: UUID,
|
|
7444
|
-
name: z43.string(),
|
|
7445
|
-
externalId: z43.string().nullish(),
|
|
7446
|
-
parentId: UUID.nullable()
|
|
7447
|
-
});
|
|
7448
7940
|
|
|
7449
7941
|
// ../commons/src/events/scopes.ts
|
|
7450
7942
|
var ACTION_SCOPE_MAP = {
|
|
@@ -7543,80 +8035,75 @@ var REJECTED_ACTIONS = [
|
|
|
7543
8035
|
var import_lodash7 = require("lodash");
|
|
7544
8036
|
|
|
7545
8037
|
// ../commons/src/events/mocks.test.utils.ts
|
|
7546
|
-
|
|
7547
|
-
return {
|
|
7548
|
-
...entity,
|
|
7549
|
-
status: "active",
|
|
7550
|
-
versions: [
|
|
7551
|
-
{
|
|
7552
|
-
versionId: entity.id,
|
|
7553
|
-
effectiveFrom: "0001-01-01",
|
|
7554
|
-
name: entity.name,
|
|
7555
|
-
externalId: entity.externalId ?? null,
|
|
7556
|
-
status: "active"
|
|
7557
|
-
}
|
|
7558
|
-
]
|
|
7559
|
-
};
|
|
7560
|
-
}
|
|
7561
|
-
var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
8038
|
+
var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
|
|
7562
8039
|
{
|
|
7563
8040
|
id: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
7564
8041
|
name: "Central",
|
|
7565
8042
|
parentId: null,
|
|
8043
|
+
validUntil: null,
|
|
7566
8044
|
externalId: "ydyJb1RAy4U1"
|
|
7567
8045
|
},
|
|
7568
8046
|
{
|
|
7569
8047
|
id: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
7570
8048
|
name: "Sulaka",
|
|
7571
8049
|
parentId: null,
|
|
8050
|
+
validUntil: null,
|
|
7572
8051
|
externalId: "pQ8nGxWmZ2Q3"
|
|
7573
8052
|
},
|
|
7574
8053
|
{
|
|
7575
8054
|
id: "7ef2b9c7-5e6d-49f6-ae05-656207d0fc64",
|
|
7576
8055
|
name: "Pualula",
|
|
7577
8056
|
parentId: null,
|
|
8057
|
+
validUntil: null,
|
|
7578
8058
|
externalId: "Aq91DweLmT8k"
|
|
7579
8059
|
},
|
|
7580
8060
|
{
|
|
7581
8061
|
id: "6d1a59df-988c-4021-a846-ccbc021931a7",
|
|
7582
8062
|
name: "Chuminga",
|
|
7583
8063
|
parentId: null,
|
|
8064
|
+
validUntil: null,
|
|
7584
8065
|
externalId: "Rw0fYNh2Xk9a"
|
|
7585
8066
|
},
|
|
7586
8067
|
{
|
|
7587
8068
|
id: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
7588
8069
|
name: "Ibombo",
|
|
7589
8070
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8071
|
+
validUntil: null,
|
|
7590
8072
|
externalId: "k7DsP4vbN1Qe"
|
|
7591
8073
|
},
|
|
7592
8074
|
{
|
|
7593
8075
|
id: "27160bbd-32d1-4625-812f-860226bfb92a",
|
|
7594
8076
|
name: "Isango",
|
|
7595
8077
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8078
|
+
validUntil: null,
|
|
7596
8079
|
externalId: "Gm3Z9eQpHw4L"
|
|
7597
8080
|
},
|
|
7598
8081
|
{
|
|
7599
8082
|
id: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
7600
8083
|
name: "Isamba",
|
|
7601
8084
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8085
|
+
validUntil: null,
|
|
7602
8086
|
externalId: "sT0xVu1KqJ7r"
|
|
7603
8087
|
},
|
|
7604
8088
|
{
|
|
7605
8089
|
id: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
7606
8090
|
name: "Itambo",
|
|
7607
8091
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8092
|
+
validUntil: null,
|
|
7608
8093
|
externalId: "Nq6Bv2HpL9Te"
|
|
7609
8094
|
},
|
|
7610
8095
|
{
|
|
7611
8096
|
id: "d42ab2fe-e7ed-470e-8b31-4fb27f9b8250",
|
|
7612
8097
|
name: "Ezhi",
|
|
7613
8098
|
parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8099
|
+
validUntil: null,
|
|
7614
8100
|
externalId: "xK8cQ0ZRy5Wd"
|
|
7615
8101
|
},
|
|
7616
8102
|
{
|
|
7617
8103
|
id: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
|
|
7618
8104
|
name: "Ilanga",
|
|
7619
8105
|
parentId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
8106
|
+
validUntil: null,
|
|
7620
8107
|
externalId: "Cq4Jm1XvN8Ls"
|
|
7621
8108
|
},
|
|
7622
8109
|
// Villages under Ibombo (62a0ccb4-880d-4f30-8882-f256007dfff9)
|
|
@@ -7624,42 +8111,49 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7624
8111
|
id: "1d4e5f6a-7b8c-4912-8efa-345678901234",
|
|
7625
8112
|
name: "Klow",
|
|
7626
8113
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8114
|
+
validUntil: null,
|
|
7627
8115
|
externalId: "IkYcYBUcyY2"
|
|
7628
8116
|
},
|
|
7629
8117
|
{
|
|
7630
8118
|
id: "2e5f6a7b-8c9d-4a23-8fab-456789012345",
|
|
7631
8119
|
name: "Mbondo",
|
|
7632
8120
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8121
|
+
validUntil: null,
|
|
7633
8122
|
externalId: "Qhvv5hvo3mY"
|
|
7634
8123
|
},
|
|
7635
8124
|
{
|
|
7636
8125
|
id: "3f6a7b8c-9d0e-4b34-8abc-567890123456",
|
|
7637
8126
|
name: "Ndara",
|
|
7638
8127
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8128
|
+
validUntil: null,
|
|
7639
8129
|
externalId: "crXh068O9TR"
|
|
7640
8130
|
},
|
|
7641
8131
|
{
|
|
7642
8132
|
id: "4a7b8c9d-0e1f-4c45-abcd-678901234567",
|
|
7643
8133
|
name: "Olani",
|
|
7644
8134
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8135
|
+
validUntil: null,
|
|
7645
8136
|
externalId: "r00It8Tvvp7"
|
|
7646
8137
|
},
|
|
7647
8138
|
{
|
|
7648
8139
|
id: "5b8c9d0e-1f2a-4d56-bcde-789012345678",
|
|
7649
8140
|
name: "Pemba",
|
|
7650
8141
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8142
|
+
validUntil: null,
|
|
7651
8143
|
externalId: "ZnUWsbONIaH"
|
|
7652
8144
|
},
|
|
7653
8145
|
{
|
|
7654
8146
|
id: "6c9d0e1f-2a3b-4e67-8def-890123456789",
|
|
7655
8147
|
name: "Quanza",
|
|
7656
8148
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8149
|
+
validUntil: null,
|
|
7657
8150
|
externalId: "fDZycvQTa7l"
|
|
7658
8151
|
},
|
|
7659
8152
|
{
|
|
7660
8153
|
id: "7d0e1f2a-3b4c-4f78-8efa-901234567890",
|
|
7661
8154
|
name: "Rivka",
|
|
7662
8155
|
parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8156
|
+
validUntil: null,
|
|
7663
8157
|
externalId: "KqswxCGTELa"
|
|
7664
8158
|
},
|
|
7665
8159
|
// Villages under Isamba (967032fd-3f81-478a-826c-30cb8fe121bd)
|
|
@@ -7667,30 +8161,35 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7667
8161
|
id: "8e1f2a3b-4c5d-4089-8fab-012345678901",
|
|
7668
8162
|
name: "Mbula",
|
|
7669
8163
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8164
|
+
validUntil: null,
|
|
7670
8165
|
externalId: "osEbKjRc9Kg"
|
|
7671
8166
|
},
|
|
7672
8167
|
{
|
|
7673
8168
|
id: "9f2a3b4c-5d6e-4190-8abf-123456789012",
|
|
7674
8169
|
name: "Ndoki",
|
|
7675
8170
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8171
|
+
validUntil: null,
|
|
7676
8172
|
externalId: "aq4daBUAGr3"
|
|
7677
8173
|
},
|
|
7678
8174
|
{
|
|
7679
8175
|
id: "0a3b4c5d-6e7f-4201-abcd-234567890123",
|
|
7680
8176
|
name: "Tsanga",
|
|
7681
8177
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8178
|
+
validUntil: null,
|
|
7682
8179
|
externalId: "cqis6Y8trbJ"
|
|
7683
8180
|
},
|
|
7684
8181
|
{
|
|
7685
8182
|
id: "1b4c5d6e-7f8a-4312-bcde-345678901234",
|
|
7686
8183
|
name: "Waziri",
|
|
7687
8184
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8185
|
+
validUntil: null,
|
|
7688
8186
|
externalId: "LMijHPyyx6d"
|
|
7689
8187
|
},
|
|
7690
8188
|
{
|
|
7691
8189
|
id: "2c5d6e7f-8a9b-4423-8def-456789012345",
|
|
7692
8190
|
name: "Zimbi",
|
|
7693
8191
|
parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8192
|
+
validUntil: null,
|
|
7694
8193
|
externalId: "pcQYbPuKGZ7"
|
|
7695
8194
|
},
|
|
7696
8195
|
// Villages under Itambo (89a33893-b17d-481d-a26d-6461e7ac1651)
|
|
@@ -7698,59 +8197,67 @@ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
|
|
|
7698
8197
|
id: "3d6e7f8a-9b0c-4534-8efa-567890123456",
|
|
7699
8198
|
name: "Felani",
|
|
7700
8199
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8200
|
+
validUntil: null,
|
|
7701
8201
|
externalId: "gSqpoCGdMXp"
|
|
7702
8202
|
},
|
|
7703
8203
|
{
|
|
7704
8204
|
id: "4e7f8a9b-0c1d-4645-8fab-678901234567",
|
|
7705
8205
|
name: "Goroma",
|
|
7706
8206
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8207
|
+
validUntil: null,
|
|
7707
8208
|
externalId: "KvAAIaNqVrp"
|
|
7708
8209
|
},
|
|
7709
8210
|
{
|
|
7710
8211
|
id: "5f8a9b0c-1d2e-4756-8abc-789012345678",
|
|
7711
8212
|
name: "Halifu",
|
|
7712
8213
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8214
|
+
validUntil: null,
|
|
7713
8215
|
externalId: "qe4UnEVt1hv"
|
|
7714
8216
|
},
|
|
7715
8217
|
{
|
|
7716
8218
|
id: "6a9b0c1d-2e3f-4867-abcd-890123456789",
|
|
7717
8219
|
name: "Jabari",
|
|
7718
8220
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8221
|
+
validUntil: null,
|
|
7719
8222
|
externalId: "yHH9Nz4rLOt"
|
|
7720
8223
|
},
|
|
7721
8224
|
{
|
|
7722
8225
|
id: "7b0c1d2e-3f4a-4978-bcde-901234567890",
|
|
7723
8226
|
name: "Kifani",
|
|
7724
8227
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8228
|
+
validUntil: null,
|
|
7725
8229
|
externalId: "eSWmXIGeu1I"
|
|
7726
8230
|
},
|
|
7727
8231
|
{
|
|
7728
8232
|
id: "8c1d2e3f-4a5b-4089-8def-012345678901",
|
|
7729
8233
|
name: "Lumela",
|
|
7730
8234
|
parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
|
|
8235
|
+
validUntil: null,
|
|
7731
8236
|
externalId: "bh0b3aI1uP3"
|
|
7732
8237
|
}
|
|
7733
8238
|
];
|
|
7734
|
-
var
|
|
7735
|
-
var MOCK_LOCATIONS_BASE = [
|
|
8239
|
+
var V2_DEFAULT_MOCK_LOCATIONS = [
|
|
7736
8240
|
{
|
|
7737
8241
|
id: "6f6186ce-cd5f-4a5f-810a-2d99e7c4ba12",
|
|
7738
8242
|
name: "Central Provincial Office",
|
|
7739
8243
|
locationType: "CRVS_OFFICE",
|
|
7740
8244
|
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8245
|
+
validUntil: null,
|
|
7741
8246
|
externalId: "Xr3Df8WpK6Ys"
|
|
7742
8247
|
},
|
|
7743
8248
|
{
|
|
7744
8249
|
id: "b1c2d3e4-f5a6-7890-bcde-f12345678901",
|
|
7745
8250
|
name: "Central Health Post",
|
|
7746
8251
|
locationType: "HEALTH_FACILITY",
|
|
7747
|
-
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c"
|
|
8252
|
+
administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
|
|
8253
|
+
validUntil: null
|
|
7748
8254
|
},
|
|
7749
8255
|
{
|
|
7750
8256
|
id: "028d2c85-ca31-426d-b5d1-2cef545a4902",
|
|
7751
8257
|
name: "Ibombo District Office",
|
|
7752
8258
|
locationType: "CRVS_OFFICE",
|
|
7753
8259
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8260
|
+
validUntil: null,
|
|
7754
8261
|
externalId: "Sm4Nw7GrD2Vy"
|
|
7755
8262
|
},
|
|
7756
8263
|
{
|
|
@@ -7758,6 +8265,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7758
8265
|
name: "Isamba District Office",
|
|
7759
8266
|
locationType: "CRVS_OFFICE",
|
|
7760
8267
|
administrativeAreaId: "967032fd-3f81-478a-826c-30cb8fe121bd",
|
|
8268
|
+
validUntil: null,
|
|
7761
8269
|
externalId: "Vg1Bq5XeH9Lt"
|
|
7762
8270
|
},
|
|
7763
8271
|
{
|
|
@@ -7765,6 +8273,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7765
8273
|
name: "Isango District Office",
|
|
7766
8274
|
locationType: "CRVS_OFFICE",
|
|
7767
8275
|
administrativeAreaId: "27160bbd-32d1-4625-812f-860226bfb92a",
|
|
8276
|
+
validUntil: null,
|
|
7768
8277
|
externalId: "Je7Lm2XqN9Vz"
|
|
7769
8278
|
},
|
|
7770
8279
|
{
|
|
@@ -7772,6 +8281,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7772
8281
|
name: "Sulaka Provincial Office",
|
|
7773
8282
|
locationType: "CRVS_OFFICE",
|
|
7774
8283
|
administrativeAreaId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
|
|
8284
|
+
validUntil: null,
|
|
7775
8285
|
externalId: "Ht2Wp9KcX5Qv"
|
|
7776
8286
|
},
|
|
7777
8287
|
{
|
|
@@ -7779,6 +8289,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7779
8289
|
name: "Ilanga District Office",
|
|
7780
8290
|
locationType: "CRVS_OFFICE",
|
|
7781
8291
|
administrativeAreaId: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
|
|
8292
|
+
validUntil: null,
|
|
7782
8293
|
externalId: "Yp6Ds1WqN3Xz"
|
|
7783
8294
|
},
|
|
7784
8295
|
{
|
|
@@ -7786,6 +8297,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7786
8297
|
name: "Chamakubi Health Post",
|
|
7787
8298
|
locationType: "HEALTH_FACILITY",
|
|
7788
8299
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8300
|
+
validUntil: null,
|
|
7789
8301
|
externalId: "M1nFr8LbC2Qy"
|
|
7790
8302
|
},
|
|
7791
8303
|
{
|
|
@@ -7793,6 +8305,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7793
8305
|
name: "Ibombo Rural Health Centre",
|
|
7794
8306
|
locationType: "HEALTH_FACILITY",
|
|
7795
8307
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8308
|
+
validUntil: null,
|
|
7796
8309
|
externalId: "bT7pV6YrW0Xc"
|
|
7797
8310
|
},
|
|
7798
8311
|
{
|
|
@@ -7800,6 +8313,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7800
8313
|
name: "Chikobo Rural Health Centre",
|
|
7801
8314
|
locationType: "HEALTH_FACILITY",
|
|
7802
8315
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8316
|
+
validUntil: null,
|
|
7803
8317
|
externalId: "zE4qPn2SgJ5d"
|
|
7804
8318
|
},
|
|
7805
8319
|
{
|
|
@@ -7807,6 +8321,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7807
8321
|
name: "Chilochabalenje Health Post",
|
|
7808
8322
|
locationType: "HEALTH_FACILITY",
|
|
7809
8323
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8324
|
+
validUntil: null,
|
|
7810
8325
|
externalId: "H8vDs1MqR4Uf"
|
|
7811
8326
|
},
|
|
7812
8327
|
{
|
|
@@ -7814,6 +8329,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7814
8329
|
name: "Chipeso Rural Health Centre",
|
|
7815
8330
|
locationType: "HEALTH_FACILITY",
|
|
7816
8331
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8332
|
+
validUntil: null,
|
|
7817
8333
|
externalId: "Qw3uZ9KfX6Lm"
|
|
7818
8334
|
},
|
|
7819
8335
|
{
|
|
@@ -7821,6 +8337,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7821
8337
|
name: "Chisamba Rural Health Centre",
|
|
7822
8338
|
locationType: "HEALTH_FACILITY",
|
|
7823
8339
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8340
|
+
validUntil: null,
|
|
7824
8341
|
externalId: "Yr0pCg8LdM2s"
|
|
7825
8342
|
},
|
|
7826
8343
|
{
|
|
@@ -7828,6 +8345,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7828
8345
|
name: "Chitanda Rural Health Centre",
|
|
7829
8346
|
locationType: "HEALTH_FACILITY",
|
|
7830
8347
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8348
|
+
validUntil: null,
|
|
7831
8349
|
externalId: "tS9gJ4PwB1Qx"
|
|
7832
8350
|
},
|
|
7833
8351
|
{
|
|
@@ -7835,6 +8353,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7835
8353
|
name: "Golden Valley Rural Health Centre",
|
|
7836
8354
|
locationType: "HEALTH_FACILITY",
|
|
7837
8355
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8356
|
+
validUntil: null,
|
|
7838
8357
|
externalId: "Ld7Qm3XsA8Vr"
|
|
7839
8358
|
},
|
|
7840
8359
|
{
|
|
@@ -7842,6 +8361,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7842
8361
|
name: "Ipongo Rural Health Centre",
|
|
7843
8362
|
locationType: "HEALTH_FACILITY",
|
|
7844
8363
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8364
|
+
validUntil: null,
|
|
7845
8365
|
externalId: "kF2sW9DmH0Bt"
|
|
7846
8366
|
},
|
|
7847
8367
|
{
|
|
@@ -7849,6 +8369,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7849
8369
|
name: "Itumbwe Health Post",
|
|
7850
8370
|
locationType: "HEALTH_FACILITY",
|
|
7851
8371
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8372
|
+
validUntil: null,
|
|
7852
8373
|
externalId: "Ue5Xb3VaC7Pq"
|
|
7853
8374
|
},
|
|
7854
8375
|
{
|
|
@@ -7856,6 +8377,7 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7856
8377
|
name: "Kabangalala Rural Health Centre",
|
|
7857
8378
|
locationType: "HEALTH_FACILITY",
|
|
7858
8379
|
administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
|
|
8380
|
+
validUntil: null,
|
|
7859
8381
|
externalId: "Pz8Kc1TqH6Jn"
|
|
7860
8382
|
},
|
|
7861
8383
|
// Village offices
|
|
@@ -7864,10 +8386,10 @@ var MOCK_LOCATIONS_BASE = [
|
|
|
7864
8386
|
name: "Klow Village Office",
|
|
7865
8387
|
locationType: "CRVS_OFFICE",
|
|
7866
8388
|
administrativeAreaId: "1d4e5f6a-7b8c-4912-8efa-345678901234",
|
|
8389
|
+
validUntil: null,
|
|
7867
8390
|
externalId: "PmAyxAJkxiJ"
|
|
7868
8391
|
}
|
|
7869
8392
|
];
|
|
7870
|
-
var V2_DEFAULT_MOCK_LOCATIONS = MOCK_LOCATIONS_BASE.map(withVersionFields);
|
|
7871
8393
|
var V2_DEFAULT_MOCK_LOCATIONS_MAP = new Map(
|
|
7872
8394
|
V2_DEFAULT_MOCK_LOCATIONS.map((l) => [l.id, l])
|
|
7873
8395
|
);
|
|
@@ -7875,56 +8397,8 @@ var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS_MAP = new Map(
|
|
|
7875
8397
|
V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS.map((a) => [a.id, a])
|
|
7876
8398
|
);
|
|
7877
8399
|
|
|
7878
|
-
// ../commons/src/events/locationPayloads.ts
|
|
7879
|
-
var z44 = __toESM(require("zod/v4"));
|
|
7880
|
-
var CreateLocationPayload = z44.object({
|
|
7881
|
-
id: UUID.optional(),
|
|
7882
|
-
versionId: UUID.optional(),
|
|
7883
|
-
name: z44.string(),
|
|
7884
|
-
externalId: z44.string().nullish(),
|
|
7885
|
-
administrativeAreaId: UUID.nullable(),
|
|
7886
|
-
locationType: z44.string().nullable(),
|
|
7887
|
-
effectiveFrom: z44.iso.date().optional(),
|
|
7888
|
-
status: LocationStatus.default("active")
|
|
7889
|
-
});
|
|
7890
|
-
var UpdateLocationPayload = z44.strictObject({
|
|
7891
|
-
id: UUID,
|
|
7892
|
-
versionId: UUID.optional(),
|
|
7893
|
-
name: z44.string(),
|
|
7894
|
-
externalId: z44.string().nullish(),
|
|
7895
|
-
status: LocationStatus,
|
|
7896
|
-
effectiveFrom: z44.iso.date().optional(),
|
|
7897
|
-
lastVersionId: UUID
|
|
7898
|
-
});
|
|
7899
|
-
var WithdrawLocationVersionPayload = z44.object({
|
|
7900
|
-
id: UUID,
|
|
7901
|
-
versionId: UUID
|
|
7902
|
-
});
|
|
7903
|
-
var CreateAdministrativeAreaPayload = z44.object({
|
|
7904
|
-
id: UUID.optional(),
|
|
7905
|
-
versionId: UUID.optional(),
|
|
7906
|
-
name: z44.string(),
|
|
7907
|
-
externalId: z44.string().nullish(),
|
|
7908
|
-
parentId: UUID.nullable(),
|
|
7909
|
-
effectiveFrom: z44.iso.date().optional(),
|
|
7910
|
-
status: LocationStatus.default("active")
|
|
7911
|
-
});
|
|
7912
|
-
var UpdateAdministrativeAreaPayload = z44.strictObject({
|
|
7913
|
-
id: UUID,
|
|
7914
|
-
versionId: UUID.optional(),
|
|
7915
|
-
name: z44.string(),
|
|
7916
|
-
externalId: z44.string().nullish(),
|
|
7917
|
-
status: LocationStatus,
|
|
7918
|
-
effectiveFrom: z44.iso.date().optional(),
|
|
7919
|
-
lastVersionId: UUID
|
|
7920
|
-
});
|
|
7921
|
-
var WithdrawAdministrativeAreaVersionPayload = z44.object({
|
|
7922
|
-
id: UUID,
|
|
7923
|
-
versionId: UUID
|
|
7924
|
-
});
|
|
7925
|
-
|
|
7926
8400
|
// ../commons/src/notification/UserNotifications.ts
|
|
7927
|
-
var
|
|
8401
|
+
var z44 = __toESM(require("zod/v4"));
|
|
7928
8402
|
var TriggerEvent = {
|
|
7929
8403
|
USER_CREATED: "user-created",
|
|
7930
8404
|
USER_UPDATED: "user-updated",
|
|
@@ -7937,54 +8411,54 @@ var TriggerEvent = {
|
|
|
7937
8411
|
CHANGE_PHONE_NUMBER: "change-phone-number",
|
|
7938
8412
|
CHANGE_EMAIL_ADDRESS: "change-email-address"
|
|
7939
8413
|
};
|
|
7940
|
-
var Recipient =
|
|
8414
|
+
var Recipient = z44.object({
|
|
7941
8415
|
name: NameFieldValue.optional(),
|
|
7942
|
-
mobile:
|
|
7943
|
-
email:
|
|
7944
|
-
bcc:
|
|
8416
|
+
mobile: z44.string().optional(),
|
|
8417
|
+
email: z44.string().optional(),
|
|
8418
|
+
bcc: z44.array(z44.string()).optional()
|
|
7945
8419
|
});
|
|
7946
|
-
var BasePayload =
|
|
8420
|
+
var BasePayload = z44.object({
|
|
7947
8421
|
recipient: Recipient
|
|
7948
8422
|
});
|
|
7949
8423
|
var TriggerPayload = {
|
|
7950
8424
|
[TriggerEvent.USER_CREATED]: BasePayload.extend({
|
|
7951
|
-
username:
|
|
7952
|
-
temporaryPassword:
|
|
8425
|
+
username: z44.string(),
|
|
8426
|
+
temporaryPassword: z44.string()
|
|
7953
8427
|
}),
|
|
7954
8428
|
[TriggerEvent.USER_UPDATED]: BasePayload.extend({
|
|
7955
|
-
oldUsername:
|
|
7956
|
-
newUsername:
|
|
8429
|
+
oldUsername: z44.string(),
|
|
8430
|
+
newUsername: z44.string()
|
|
7957
8431
|
}),
|
|
7958
8432
|
[TriggerEvent.USERNAME_REMINDER]: BasePayload.extend({
|
|
7959
|
-
username:
|
|
8433
|
+
username: z44.string()
|
|
7960
8434
|
}),
|
|
7961
8435
|
[TriggerEvent.RESET_PASSWORD]: BasePayload.extend({
|
|
7962
|
-
code:
|
|
8436
|
+
code: z44.string()
|
|
7963
8437
|
}),
|
|
7964
8438
|
[TriggerEvent.RESET_PASSWORD_BY_ADMIN]: BasePayload.extend({
|
|
7965
|
-
temporaryPassword:
|
|
7966
|
-
admin:
|
|
7967
|
-
id:
|
|
8439
|
+
temporaryPassword: z44.string(),
|
|
8440
|
+
admin: z44.object({
|
|
8441
|
+
id: z44.string(),
|
|
7968
8442
|
name: NameFieldValue,
|
|
7969
|
-
role:
|
|
8443
|
+
role: z44.string()
|
|
7970
8444
|
})
|
|
7971
8445
|
}),
|
|
7972
8446
|
[TriggerEvent.RESEND_INVITE]: BasePayload.extend({
|
|
7973
|
-
username:
|
|
7974
|
-
temporaryPassword:
|
|
8447
|
+
username: z44.string(),
|
|
8448
|
+
temporaryPassword: z44.string()
|
|
7975
8449
|
}),
|
|
7976
8450
|
[TriggerEvent.TWO_FA]: BasePayload.extend({
|
|
7977
|
-
code:
|
|
8451
|
+
code: z44.string()
|
|
7978
8452
|
}),
|
|
7979
8453
|
[TriggerEvent.ALL_USER_NOTIFICATION]: BasePayload.extend({
|
|
7980
|
-
subject:
|
|
7981
|
-
body:
|
|
8454
|
+
subject: z44.string(),
|
|
8455
|
+
body: z44.string()
|
|
7982
8456
|
}),
|
|
7983
8457
|
[TriggerEvent.CHANGE_PHONE_NUMBER]: BasePayload.extend({
|
|
7984
|
-
code:
|
|
8458
|
+
code: z44.string()
|
|
7985
8459
|
}),
|
|
7986
8460
|
[TriggerEvent.CHANGE_EMAIL_ADDRESS]: BasePayload.extend({
|
|
7987
|
-
code:
|
|
8461
|
+
code: z44.string()
|
|
7988
8462
|
})
|
|
7989
8463
|
};
|
|
7990
8464
|
async function triggerUserEventNotification({
|
|
@@ -8008,4 +8482,4 @@ function parseUserEventTrigger(event2, body) {
|
|
|
8008
8482
|
}
|
|
8009
8483
|
|
|
8010
8484
|
// src/notification/index.ts
|
|
8011
|
-
|
|
8485
|
+
z45.globalRegistry.clear();
|