@ecrvs/opencrvs-toolkit 1.8.1-rc.a7ee8fb

package/dist/commons/events/scopes.d.ts

@@ -0,0 +1,55 @@
+import { ConfigurableScopeType, Scope } from '../scopes';
+import { DisplayableAction } from './ActionType';
+import { EventIndex } from './EventIndex';
+export declare const ACTION_SCOPE_MAP: {
+    READ: "record.read"[];
+    CREATE: "record.create"[];
+    NOTIFY: "record.notify"[];
+    DECLARE: ("record.register" | "record.declare" | "record.declared.validate")[];
+    DELETE: "record.declare"[];
+    VALIDATE: ("record.register" | "record.declared.validate")[];
+    REGISTER: "record.register"[];
+    PRINT_CERTIFICATE: "record.registered.print-certified-copies"[];
+    REQUEST_CORRECTION: ("record.registered.request-correction" | "record.registered.correct")[];
+    REVIEW_CORRECTION_REQUEST: "record.registered.correct"[];
+    REJECT_CORRECTION: "record.registered.correct"[];
+    APPROVE_CORRECTION: "record.registered.correct"[];
+    MARK_AS_DUPLICATE: "record.declared.review-duplicates"[];
+    MARK_AS_NOT_DUPLICATE: "record.declared.review-duplicates"[];
+    ARCHIVE: "record.declared.archive"[];
+    REJECT: "record.declared.reject"[];
+    ASSIGN: null;
+    UNASSIGN: null;
+    DUPLICATE_DETECTED: never[];
+};
+export declare function hasAnyOfScopes(a: Scope[], b: Scope[]): boolean;
+export declare function configurableEventScopeAllowed(scopes: Scope[], allowedConfigurableScopes: ConfigurableScopeType[], eventType: string): boolean;
+/**
+ * Checks if a given action is allowed for the provided scopes and event type.
+ *
+ * This function determines whether the user, with the given set of scopes, is authorized
+ * to perform the specified action on an event of the given type. It checks both "plain" scopes
+ * (hardcoded, non-configurable) and "configurable" scopes (which may be tied to specific event types).
+ *
+ * @param {Scope[]} scopes - The list of scopes the user possesses.
+ * @param {DisplayableAction} action - The action to check authorization for.
+ * @param {string} eventType - The type of event for which the action is being checked.
+ * @returns {boolean} True if the action is in scope for the user, otherwise false.
+ */
+export declare function isActionInScope(scopes: Scope[], action: DisplayableAction, eventType: string): boolean;
+/**
+ * A shared utility to check if the user can read a record.
+ * This will be removed in 1.10 and implemented by scopes.
+ *
+ * In order for us to limit the usage of 'record.read' scope, we allow users to view records they have created on system-level.
+ *
+ * @deprecated - Will be removed in 1.10
+ */
+export declare function canUserReadEvent(event: EventIndex | {
+    createdBy: string;
+    type: string;
+}, { userId, scopes }: {
+    userId: string;
+    scopes: string[];
+}): boolean;
+//# sourceMappingURL=scopes.d.ts.map

package/dist/commons/events/serializer.d.ts

@@ -0,0 +1,2 @@
+export { deserializeQuery } from './serializers/user/deserializer';
+//# sourceMappingURL=serializer.d.ts.map

package/dist/commons/events/state/availableActions.d.ts

@@ -0,0 +1,6 @@
+import { DisplayableAction } from '../ActionType';
+import { EventIndex } from '../EventIndex';
+import { EventStatus, Flag } from '../EventMetadata';
+export declare function getAvailableActions(status: EventStatus, flags: Flag[]): DisplayableAction[];
+export declare function getAvailableActionsForEvent(event: EventIndex): DisplayableAction[];
+//# sourceMappingURL=availableActions.d.ts.map

package/dist/commons/events/state/flags.d.ts

@@ -0,0 +1,4 @@
+import { Action } from '../ActionDocument';
+import { Flag } from '../EventMetadata';
+export declare function getFlagsFromActions(actions: Action[]): Flag[];
+//# sourceMappingURL=flags.d.ts.map

package/dist/commons/events/state/index.d.ts

@@ -0,0 +1,146 @@
+import { ActionType } from '../ActionType';
+import { Action, ActionDocument, ActionUpdate, EventState, PotentialDuplicate } from '../ActionDocument';
+import { EventDocument } from '../EventDocument';
+import { EventIndex } from '../EventIndex';
+import { EventStatus } from '../EventMetadata';
+import { Draft } from '../Draft';
+import { EventConfig } from '../EventConfig';
+import { UUID } from '../../uuid';
+import { DocumentPath, FullDocumentPath, FullDocumentUrl } from '../../documents';
+export declare function getStatusFromActions(actions: Array<Action>): "ARCHIVED" | "DECLARED" | "REGISTERED" | "VALIDATED" | "CREATED" | "NOTIFIED";
+export declare function getAssignedUserFromActions(actions: Array<ActionDocument>): string | null;
+export declare function getAssignedUserSignatureFromActions(actions: Array<ActionDocument>): string | null;
+type NonNullableDeep<T> = T extends [unknown, ...unknown[]] ? {
+    [K in keyof T]: NonNullableDeep<NonNullable<T[K]>>;
+} : T extends UUID ? T : T extends FullDocumentPath ? T : T extends DocumentPath ? T : T extends FullDocumentUrl ? T : T extends (infer U)[] ? NonNullableDeep<U>[] : T extends object ? {
+    [K in keyof T]: NonNullableDeep<NonNullable<T[K]>>;
+} : NonNullable<T>;
+/**
+ * @returns Given arbitrary object, recursively remove all keys with null values
+ *
+ * @example
+ * deepDropNulls({ a: null, b: { c: null, d: 'foo' } }) // { b: { d: 'foo' } }
+ *
+ */
+export declare function deepDropNulls<T>(obj: T): NonNullableDeep<T>;
+export declare function isUndeclaredDraft(status: EventStatus): boolean;
+export declare const DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
+export declare function resolveDateOfEvent(eventMetadata: {
+    createdAt: string;
+}, declaration: EventState, config: EventConfig): string | undefined;
+export declare function extractPotentialDuplicatesFromActions(actions: Action[]): PotentialDuplicate[];
+/**
+ * @returns the current state of the event based on the actions taken.
+ * @see EventIndex for the description of the returned object.
+ */
+export declare function getCurrentEventState(event: EventDocument, config: EventConfig): EventIndex;
+/**
+ * @returns the future state of the event with drafts applied to all fields.
+ *
+ * NOTE: We treat the draft as a new action that is applied to the event. This means that even the status of the is changed as if draft has been accepted.
+ * @see applyDraftToEventIndex to apply the draft to the event without changing the status.
+ *
+ */
+export declare function dangerouslyGetCurrentEventStateWithDrafts({ event, draft, configuration }: {
+    event: EventDocument;
+    draft: Draft;
+    configuration: EventConfig;
+}): EventIndex;
+export declare function applyDeclarationToEventIndex(eventIndex: EventIndex, declaration: EventState | ActionUpdate, eventConfiguration: EventConfig): EventIndex;
+/**
+ * Applies draft to the event index following internal business rules.
+ *
+ * Ensures only necessary fields are updated based on the draft (declaration, updatedAt, flags).
+ * NOTE: When naively applying draft, it leads to incorrect event state, since drafts are 'Accepted' by default.
+ *
+ */
+export declare function applyDraftToEventIndex(eventIndex: EventIndex, draft: Draft, eventConfiguration: EventConfig): {
+    type: string;
+    id: string & import("zod").BRAND<"UUID">;
+    status: "ARCHIVED" | "DECLARED" | "REGISTERED" | "VALIDATED" | "CREATED" | "NOTIFIED";
+    createdAt: string;
+    createdBy: string;
+    declaration: Record<string, string | number | boolean | {
+        type: string;
+        path: string;
+        originalFilename: string;
+    } | {
+        firstname: string;
+        surname: string;
+        middlename?: string | undefined;
+    } | {
+        firstname: string;
+        surname: string;
+        middlename?: string | null | undefined;
+    } | Record<string, string> | {
+        country: string;
+        addressType: "DOMESTIC" | "INTERNATIONAL";
+        administrativeArea?: string | undefined;
+        streetLevelDetails?: Record<string, string> | undefined;
+    } | {
+        type: string;
+        option: string;
+        path: string;
+        originalFilename: string;
+    }[] | {
+        loading: boolean;
+        data?: any;
+        error?: {
+            message: string;
+            statusCode: number;
+        } | null | undefined;
+    } | {
+        start: string;
+        end: string;
+    } | null | undefined>;
+    trackingId: string;
+    updatedAt: string;
+    legalStatuses: {
+        DECLARED?: {
+            createdAt: string;
+            createdBy: string;
+            createdByRole: string;
+            acceptedAt: string;
+            createdByUserType?: "system" | "user" | null | undefined;
+            createdBySignature?: string | null | undefined;
+            createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
+        } | null | undefined;
+        REGISTERED?: {
+            createdAt: string;
+            createdBy: string;
+            createdByRole: string;
+            registrationNumber: string;
+            acceptedAt: string;
+            createdByUserType?: "system" | "user" | null | undefined;
+            createdBySignature?: string | null | undefined;
+            createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
+        } | null | undefined;
+    };
+    updatedByUserRole: string;
+    potentialDuplicates: {
+        id: string & import("zod").BRAND<"UUID">;
+        trackingId: string;
+    }[];
+    flags: string[];
+    createdByUserType?: "system" | "user" | null | undefined;
+    createdBySignature?: string | null | undefined;
+    createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
+    assignedTo?: string | null | undefined;
+    dateOfEvent?: string | null | undefined;
+    updatedAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
+    updatedBy?: string | null | undefined;
+};
+/**
+ * Annotation is always specific to the action. when action with annotation is triggered multiple times,
+ * previous annotations should have no effect on the new action annotation. (e.g. printing once should not pre-select print form fields)
+ *
+ * @returns annotation generated from drafts
+ */
+export declare function getAnnotationFromDrafts(drafts: Draft[]): {};
+export declare function getActionAnnotation({ event, actionType, draft }: {
+    event: EventDocument;
+    actionType: ActionType;
+    draft?: Draft;
+}): EventState;
+export {};
+//# sourceMappingURL=index.d.ts.map