@ecrvs/opencrvs-toolkit 1.8.1-rc.a7ee8fb

package/dist/commons/conditionals/conditionals.d.ts

@@ -0,0 +1,194 @@
+import { EventDocument } from '../events/EventDocument';
+import { EventState } from '../events/ActionDocument';
+import { ITokenPayload as TokenPayload, Scope } from '../authentication';
+import { PartialSchema as AjvJSONSchemaType } from 'ajv/dist/types/json-schema';
+import { userSerializer } from '../events/serializers/user/serializer';
+import { UUID } from '../uuid';
+/** @knipignore */
+export type JSONSchema = {
+    $id: string;
+    readonly __nominal__type: 'JSONSchema';
+};
+export declare function defineConditional(schema: any): JSONSchema;
+export declare function defineFormConditional(schema: Record<string, unknown>): JSONSchema;
+export type UserConditionalParameters = {
+    $now: string;
+    $online: boolean;
+    $user: TokenPayload;
+};
+export type EventConditionalParameters = {
+    $now: string;
+    $online: boolean;
+    $event: EventDocument;
+};
+export type FormConditionalParameters = {
+    $now: string;
+    $online: boolean;
+    $form: EventState | Record<string, any>;
+    $locations?: Array<{
+        id: UUID;
+    }>;
+};
+export type ConditionalParameters = UserConditionalParameters | EventConditionalParameters | FormConditionalParameters;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type AjvJSONSchema = AjvJSONSchemaType<UnionToIntersection<ConditionalParameters>>;
+/**
+ * Returns an empty JSON Schema object, which is treated as always valid.
+ *
+ * @returns {AjvJSONSchema} An empty schema object `{}` that always evaluates to true.
+ */
+export declare function alwaysTrue(): AjvJSONSchema;
+/**
+ * Universal boolean connector to be used with any type of conditional. (user, event, field)
+ *
+ * @example and(field('foo').isEqualTo('bar'), field('baz').isUndefined())
+ */
+export declare function and(...conditions: AjvJSONSchema[]): JSONSchema;
+/**
+ * Universal boolean connector to be used with any type of conditional. (user, event, field)
+ *
+ * @example or(field('foo').isEqualTo('bar'), field('baz').isUndefined())
+ */
+export declare function or(...conditions: AjvJSONSchema[]): JSONSchema;
+/**
+ * Universal boolean connector to be used with any type of conditional. (user, event, field)
+ *
+ * @example not(field('foo').isEqualTo('bar'))
+ */
+export declare function not(condition: AjvJSONSchema): JSONSchema;
+/**
+ * Returns an JSON Schema object, which is treated as always invalid.
+ *
+ * @returns {JSONSchema} An schema object that always evaluates to false.
+ */
+export declare function never(): JSONSchema;
+/**
+ *
+ * Generate conditional rules for user.
+ */
+export declare const user: typeof userSerializer & {
+    hasScope: (scope: Scope) => JSONSchema;
+    isOnline: () => JSONSchema;
+    locationLevel: (adminLevelId: string) => {
+        $user: {
+            $location: string;
+        };
+    };
+};
+type FieldReference = {
+    $$field: string;
+};
+/**
+ * Generate conditional rules for a form field.
+ *
+ * @param fieldId - The field ID condition is applied to.
+ * @example to combine multiple conditions, utilise connectors like `and`, `or`, `not`:
+ *  and(field('foo').isEqualTo('bar'), field('baz').isUndefined())
+ *
+ */
+export declare function createFieldConditionals(fieldId: string): {
+    /**
+     * @private Internal property used for field reference tracking.
+     */
+    $$field: string;
+    /**
+     * @private Internal property used for solving a object path within field's value
+     */
+    $$subfield: string[];
+    get(fieldPath: string): {
+        $$subfield: string[];
+        /**
+         * @private Internal property used for field reference tracking.
+         */
+        $$field: string;
+        get(fieldPath: string): any;
+        isAfter: () => {
+            days: (days: number) => {
+                inPast: () => JSONSchema;
+                inFuture: () => JSONSchema;
+            };
+            date: (date: string | FieldReference) => JSONSchema;
+            now: () => JSONSchema;
+        };
+        isBefore: () => {
+            days: (days: number) => {
+                inPast: () => JSONSchema;
+                inFuture: () => JSONSchema;
+            };
+            date: (date: `${string}-${string}-${string}` | FieldReference) => JSONSchema;
+            now: () => JSONSchema;
+        };
+        isGreaterThan: (value: number | FieldReference) => JSONSchema;
+        isLessThan: (value: number | FieldReference) => JSONSchema;
+        isEqualTo(value: string | boolean | FieldReference): JSONSchema;
+        /**
+         * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
+         * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
+         * @returns whether the field is falsy (undefined, false, null, empty string)
+         *
+         * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
+         *
+         */
+        isFalsy(): JSONSchema;
+        isUndefined(): JSONSchema;
+        inArray: (values: string[]) => JSONSchema;
+        isValidEnglishName: () => JSONSchema;
+        isValidAdministrativeLeafLevel: () => JSONSchema;
+        /**
+         * Checks if the field value matches a given regular expression pattern.
+         * @param pattern - The regular expression pattern to match the field value against.
+         * @returns A JSONSchema conditional that validates the field value against the pattern.
+         */
+        matches: (pattern: string) => JSONSchema;
+        isBetween: (min: number, max: number) => JSONSchema;
+        getId: () => {
+            fieldId: string;
+        };
+        object: (options: Record<string, any>) => JSONSchema;
+    };
+    isAfter: () => {
+        days: (days: number) => {
+            inPast: () => JSONSchema;
+            inFuture: () => JSONSchema;
+        };
+        date: (date: string | FieldReference) => JSONSchema;
+        now: () => JSONSchema;
+    };
+    isBefore: () => {
+        days: (days: number) => {
+            inPast: () => JSONSchema;
+            inFuture: () => JSONSchema;
+        };
+        date: (date: `${string}-${string}-${string}` | FieldReference) => JSONSchema;
+        now: () => JSONSchema;
+    };
+    isGreaterThan: (value: number | FieldReference) => JSONSchema;
+    isLessThan: (value: number | FieldReference) => JSONSchema;
+    isEqualTo(value: string | boolean | FieldReference): JSONSchema;
+    /**
+     * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
+     * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
+     * @returns whether the field is falsy (undefined, false, null, empty string)
+     *
+     * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
+     *
+     */
+    isFalsy(): JSONSchema;
+    isUndefined(): JSONSchema;
+    inArray: (values: string[]) => JSONSchema;
+    isValidEnglishName: () => JSONSchema;
+    isValidAdministrativeLeafLevel: () => JSONSchema;
+    /**
+     * Checks if the field value matches a given regular expression pattern.
+     * @param pattern - The regular expression pattern to match the field value against.
+     * @returns A JSONSchema conditional that validates the field value against the pattern.
+     */
+    matches: (pattern: string) => JSONSchema;
+    isBetween: (min: number, max: number) => JSONSchema;
+    getId: () => {
+        fieldId: string;
+    };
+    object: (options: Record<string, any>) => JSONSchema;
+};
+export {};
+//# sourceMappingURL=conditionals.d.ts.map

package/dist/commons/conditionals/index.d.ts

@@ -0,0 +1,2 @@
+export * from './conditionals';
+//# sourceMappingURL=index.d.ts.map

package/dist/commons/conditionals/validate.d.ts

@@ -0,0 +1,129 @@
+import { ConditionalParameters, JSONSchema } from './conditionals';
+import { ActionUpdate, EventState } from '../events/ActionDocument';
+import { FieldConditional } from '../events/Conditional';
+import { FieldConfig } from '../events/FieldConfig';
+import { FieldUpdateValue } from '../events/FieldValue';
+import { TranslationConfig } from '../events/TranslationConfig';
+import { UUID } from '../uuid';
+export declare function validate(schema: JSONSchema, data: ConditionalParameters): boolean;
+export declare function isOnline(): boolean;
+export declare function isConditionMet(conditional: JSONSchema, values: Record<string, unknown>): boolean;
+export declare function areConditionsMet(conditions: FieldConditional[], values: Record<string, unknown>): boolean;
+export declare function isFieldVisible(field: FieldConfig, form: ActionUpdate | EventState): boolean;
+export declare function getOnlyVisibleFormValues(field: FieldConfig[], form: EventState): 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>;
+export declare function isFieldEnabled(field: FieldConfig, form: ActionUpdate | EventState): boolean;
+export declare function isFieldDisplayedOnReview(field: FieldConfig, form: ActionUpdate | EventState): boolean;
+export declare const errorMessages: {
+    hiddenField: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    invalidDate: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    invalidEmail: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    requiredField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    invalidInput: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unexpectedField: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    correctionNotAllowed: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+/**
+ * Custom error map for Zod to override the default error messages in intl-formik format.
+ */
+export type CustomZodToIntlErrorMap = {
+    /** Zod by default expects { message: string } */
+    message: {
+        /** Override it to match current intl-formik model */
+        message: TranslationConfig;
+    };
+};
+/**
+ * Validates primitive fields defined by the FieldConfig type.
+ * e.g. email is proper format, date is a valid date, etc.
+ * for custom validations @see runCustomFieldValidations
+ */
+export declare function validateFieldInput({ field, value }: {
+    field: FieldConfig;
+    value: FieldUpdateValue;
+}): {
+    message: TranslationConfig;
+}[];
+export declare function runStructuralValidations({ field, values }: {
+    field: FieldConfig;
+    values: ActionUpdate;
+}): {
+    errors: {
+        message: TranslationConfig;
+    }[];
+};
+export declare function runFieldValidations({ field, values, context }: {
+    field: FieldConfig;
+    values: ActionUpdate;
+    context?: {
+        leafAdminStructureLocationIds: Array<{
+            id: UUID;
+        }>;
+    };
+}): {
+    errors: {
+        message: TranslationConfig;
+    }[];
+};
+export declare function getValidatorsForField(fieldId: FieldConfig['id'], validations: NonNullable<FieldConfig['validation']>): NonNullable<FieldConfig['validation']>;
+export declare function areCertificateConditionsMet(conditions: FieldConditional[], values: Record<string, unknown>): boolean;
+//# sourceMappingURL=validate.d.ts.map