ngx-t-forms-types 0.0.1

package/dist/interfaces/upgradeFunctions/interfaces/init-form.d.ts

@@ -0,0 +1,268 @@
+import { MatFormFieldAppearance } from "@angular/material/form-field";
+interface conditionalInputRule {
+    formControlName: string;
+    label: string;
+    testType: string;
+    valueMatch: string;
+    id: string;
+}
+interface MinimumInputRequiredInterface {
+    name: string;
+    type: 'default' | 'mapto' | 'mapDocFilter' | undefined;
+    primaryKey?: boolean;
+    value?: string;
+    mapTo?: MinInputMapInput | Array<MinInputMapInput> | undefined;
+    defaultValue?: string;
+    dataFor?: string;
+    activeChangeId: string | undefined;
+}
+interface MinInputMapInput {
+    activeChangeId: string | undefined;
+    formControlName: string;
+    dataType: string;
+    element: string;
+}
+interface DataFetchingBaseConfig {
+    valueAccessRules: FormInputBasicOptionInterface;
+}
+interface APIDataFetchingConfigurationInterface extends DataFetchingBaseConfig {
+    _id: string;
+    name: string;
+    httpEndPoint: string;
+    inputSourceId?: string;
+    httpMethod: 'GET' | 'POST';
+    postFormData: boolean;
+    backEndConfig: {
+        minimumInputRequired: MinimumInputRequiredInterface[];
+    };
+}
+interface MongoDbPipeLineConfigInterface extends DataFetchingBaseConfig {
+    workflowId: string;
+    pipeline: any[];
+}
+interface FormInputBasicOptionInterface {
+    label: string;
+    value: string;
+}
+interface calculationVariableInterface {
+    formControlName: string;
+    label: string;
+    variable: string;
+    id: string;
+    function?: string;
+    parentInputId?: string;
+    parentInputFormControl?: string;
+    applyFunctionToCol?: string;
+    applyFunctionToLabel?: string;
+    filterValuesByThisColLabel?: string;
+    filterValuesByCol?: string;
+    tableCell?: boolean;
+}
+interface MatDataOptionsInterface {
+    source?: {
+        value?: string;
+        options?: string;
+    } | 'local';
+    optionType?: 'user';
+    options?: Array<FormInputBasicOptionInterface | DynamicObjectInterface>;
+    fetchFor?: string | 'valueForOptions';
+    fetch: {
+        value?: APIDataFetchingConfigurationInterface | MongoDbPipeLineConfigInterface;
+        options?: APIDataFetchingConfigurationInterface | MongoDbPipeLineConfigInterface;
+    };
+}
+interface DynamicObjectInterface {
+    [key: string | number]: number | string | boolean | object;
+}
+declare enum MaxMinCustomScripts {
+    IServeBudgetPeriods = "IServePeriods",
+    IServeDateLimiter = "IServeDateLimiter"
+}
+interface calculatedFieldRules {
+    formular: string;
+    variables: calculationVariableInterface[];
+}
+interface TableConfigurationsInterface {
+    displayedColumnsInOrder: string[];
+    columnsConfig: {
+        [key: string]: TableColumnConfigInterface | any;
+    };
+}
+interface TableColumnConfigInterface {
+    type: 'caluculated' | 'property' | 'checkBox' | 'primaryKey';
+    property: string;
+    reductionFunction?: 'sum';
+    calculatedFieldRules: calculatedFieldRules;
+    label: string;
+    inEdit: boolean;
+    checkUpto: string;
+    colorScale?: string;
+}
+interface BasicFormInputInterface {
+    element: string;
+    matOptions?: MatDataOptionsInterface;
+    appearance: MatFormFieldAppearance;
+    required: boolean;
+    type: string;
+    color?: string;
+    colSize: number;
+    validators: Array<FormControlCustomValidatorsInterface | string>;
+    label: string;
+    formControlName: string;
+    labelPosition?: 'before' | 'after';
+    handleIcon: string;
+    startMinDate?: Date;
+    endMaxDate?: Date;
+    startMaxDate?: Date;
+    endDateControl?: string;
+    startDateControl?: string;
+    endMinDate?: Date;
+    id: string;
+    sectionId: string;
+    handleLabel?: string;
+    pipe?: {
+        pipeType: string;
+        param: string;
+    };
+    hintLabel?: string;
+    tourContent?: string;
+    value?: any;
+    min?: number | string | Date | MaxMinCustomScripts;
+    max?: number | string | Date | MaxMinCustomScripts;
+    maxLength?: string;
+    minLength?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    pattern?: string;
+    spellcheck?: boolean;
+    rows?: number;
+    autocapitalize?: string | 'none' | 'sentences' | 'words' | 'characters';
+    wrap?: string | 'hard' | 'soft';
+    autocomplete?: string | 'on' | 'off';
+    multipleInputInEditId?: string;
+    suffixText?: string;
+    prefixText?: string;
+    prefixIcon?: string;
+    suffixIcon?: string;
+    disabled?: boolean;
+    conditionalInputConfig?: conditionalInputRule[];
+    calculatedFieldRules?: calculatedFieldRules;
+    viewType?: string;
+}
+interface multipleInterface extends BasicFormInputInterface {
+    itemLabels: {
+        label: string;
+        key: string;
+        property?: string;
+    }[];
+    formInputs: Array<IAllInputs>;
+    showTotalsOf: Array<string>;
+    groupBy: Array<string>;
+}
+interface IIncludedSegmentConfig {
+    segment: string;
+    label: string;
+    readOnly: boolean;
+}
+interface IMscoaInputConfig {
+    inputs: IAllInputs[];
+    segments: IIncludedSegmentConfig[];
+    showAllSegments: boolean;
+}
+interface matrixInputInterface extends BasicFormInputInterface {
+    matrixTableConfig: {
+        dataSource: string;
+    };
+    tableConfig: TableConfigurationsInterface;
+}
+interface MscoaInput extends BasicFormInputInterface {
+    mscoaConfig: IMscoaInputConfig;
+}
+interface TableSelectionInput extends BasicFormInputInterface {
+    selectUpto: number | undefined;
+    tableConfig: TableConfigurationsInterface;
+}
+interface fileUploadInputInterface extends BasicFormInputInterface {
+    fileType: string;
+    singleSelect?: boolean;
+    accept: string;
+}
+interface FormControlCustomValidatorsInterface {
+    id: string;
+    message: string;
+    expression: string;
+    canOverride: boolean;
+    inputsObservedForChanges: string[];
+}
+type IAllInputs = BasicFormInputInterface | multipleInterface | TableSelectionInput | MscoaInput | fileUploadInputInterface | matrixInputInterface;
+interface SlideContentRowInterface {
+    columns: Array<IAllInputs>;
+    rowType: string;
+}
+interface FormSlideInterface {
+    sectionId: string;
+    slideContentRows: Array<SlideContentRowInterface>;
+}
+interface FormSubmisionHandleInterface {
+    innerComponentShowSubmitButton?: boolean;
+    localAction: boolean;
+    activeSubmisionMode?: boolean;
+    canSubmitAPI?: SubmissionAPI;
+    submissionId: SubmissionAPI;
+    handle: SubmissionHandle;
+}
+interface SubmissionAPI {
+    _id: string;
+    httpEndPoint: string;
+    httpMethod: 'POST' | 'GET';
+}
+interface SubmissionHandle {
+    submissionMessage: string;
+}
+interface SectionsDefinitionsInterface {
+    sectionId: string;
+    label: string;
+    subStep: boolean;
+    inEdit?: boolean;
+    expanded?: boolean;
+    sectionType?: string;
+}
+interface CustomConfigInterface {
+    showProgressBar?: boolean;
+    formBackground?: string;
+    closeAfterSubmission?: string;
+    formPrePopulationOption?: {
+        listHeading: string;
+        matTooltip: string;
+        label: string;
+        submissionId: string;
+    };
+}
+interface OLD_FormInterface {
+    slides: Array<FormSlideInterface>;
+    activeSlideNumber: number | 0;
+    horizontal?: boolean;
+    submisionHandle: FormSubmisionHandleInterface;
+    formId: string | any;
+    formTitle: string;
+    formSectionSteps: Array<SectionsDefinitionsInterface>;
+    prePopulationRules?: PrepopulateDataInterface;
+    customConfig?: CustomConfigInterface;
+    createdAt?: Date;
+    updatedAt?: Date;
+    originDocId?: string;
+    previousDocRef?: string;
+    doc_reference?: string;
+}
+interface PrepopulateDataInterface {
+    localFetchData?: FecthLocalStateData;
+    dbFecthData?: string;
+    fetchedInformations?: any;
+}
+interface FecthLocalStateData {
+    service: string;
+    method: string;
+    param: string;
+    passFunction?: string;
+}
+export { OLD_FormInterface, IAllInputs };

package/dist/interfaces/upgradeFunctions/interfaces/init-form.js

@@ -0,0 +1,6 @@
+var MaxMinCustomScripts;
+(function (MaxMinCustomScripts) {
+    MaxMinCustomScripts["IServeBudgetPeriods"] = "IServePeriods";
+    MaxMinCustomScripts["IServeDateLimiter"] = "IServeDateLimiter";
+})(MaxMinCustomScripts || (MaxMinCustomScripts = {}));
+export {};

package/dist/schemas/CalculatedFieldRulesSchema.d.ts

@@ -0,0 +1,6 @@
+import * as Joi from 'joi';
+export declare const calculatedFieldRulesSchema: Joi.ObjectSchema<any>;
+export declare function validateCalculatedFieldRules(value: any): {
+    error: Joi.ValidationError | undefined;
+    value: any;
+};

package/dist/schemas/CalculatedFieldRulesSchema.js

@@ -0,0 +1,27 @@
+import * as Joi from 'joi';
+const calculationVariableSchema = Joi.object({
+    formControlName: Joi.string().required(),
+    label: Joi.string().required(),
+    variable: Joi.string().required(),
+    id: Joi.string().required(),
+    inputId: Joi.string().required(),
+    function: Joi.string().valid('avg', 'sum', 'max', 'min').optional(),
+    parentInputId: Joi.string().optional(),
+    parentInputFormControl: Joi.string().optional(),
+    applyFunctionToCol: Joi.string().optional(),
+    applyFunctionToLabel: Joi.string().optional(),
+    filterValuesByThisColLabel: Joi.string().optional(),
+    filterValuesByCol: Joi.string().optional(),
+    tableCell: Joi.boolean().optional()
+});
+export const calculatedFieldRulesSchema = Joi.object({
+    formula: Joi.string().required(),
+    variables: Joi.array().items(calculationVariableSchema).required(),
+    getFormulaFromAFormInput: Joi.boolean().optional(),
+    formControlWithFormula: Joi.string().optional()
+});
+export function validateCalculatedFieldRules(value) {
+    const { error, value: validatedValue } = calculatedFieldRulesSchema.validate(value);
+    return { error, value: validatedValue };
+}
+console.error("ffffffffffffff");

package/dist/schemas/FormInputSchema.d.ts

@@ -0,0 +1,15 @@
+import Joi from 'joi';
+import { FormColumnInputs } from '../interfaces/Form';
+import { ValidationError, ValidationOptions } from '../interfaces/formInput/schema';
+declare const formColumnInputsSchema: Joi.ObjectSchema<any>;
+declare function validateFormColumnInputs(data: FormColumnInputs): {
+    key: string;
+    message: string;
+}[];
+/**
+ * Validates form column inputs by separating required and optional fields
+ * @param options - ValidationOptions containing data and required keys
+ * @returns Array of ValidationError objects
+ */
+declare function validateFormColumnInputsWithRequired({ data, requiredKeys }: ValidationOptions): ValidationError[];
+export { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired };

package/dist/schemas/FormInputSchema.js

@@ -0,0 +1,197 @@
+import Joi from 'joi';
+import { AllFormInputPrimaryKeys } from '../interfaces/FormBuilder';
+import { AutocapitalizeOptions, ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../interfaces/formInput';
+// import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface';
+// import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface';
+// import { MscoaInputConfigSchema } from './MscoaConfigSchema';
+// import { calculatedFieldRulesSchema } from './CalculatedFieldRulesSchema';
+// import { MatDataOptionsSchema } from './MatOptionsSchema';
+import { formControlCustomValidatorSchema } from './customValidationSchema';
+import { InputFileType } from '../interfaces/formInput/FileUploadInputInterface';
+import { LabelPosition } from '../interfaces/formInput/ToggleInputInterface';
+import { calculatedFieldRulesSchema } from './CalculatedFieldRulesSchema';
+import { MscoaInputConfigSchema } from './MscoaConfigSchema';
+import { MatDataOptionsSchema } from './MatOptionsSchema';
+import { CalculationFunctions } from '../interfaces/formInput/calculationVariableInterface';
+import { RichTextEditorType } from '../interfaces/formInput/RichTextEditorInput';
+import { InputViewTypes } from '../interfaces/formInput/BasicFormInputInterface';
+const baseFormColumnInputsSchema = Joi.object({
+    [AllFormInputPrimaryKeys.Id]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.SectionId]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.Element]: Joi.string().valid(...Object.values(ElementTypes)).required(),
+    [AllFormInputPrimaryKeys.ColSize]: Joi.number().integer().min(1).max(12).required(),
+    [AllFormInputPrimaryKeys.Label]: Joi.string().required(),
+    [AllFormInputPrimaryKeys.FormControlName]: Joi.string().required(),
+    [AllFormInputPrimaryKeys.Appearance]: Joi.string().valid("fill", "outline").required(),
+    [AllFormInputPrimaryKeys.Required]: Joi.boolean().required(),
+    [AllFormInputPrimaryKeys.StartDateControl]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.EndDateControl]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.Type]: Joi.string().valid(...Object.values(InputTypes)).optional(),
+    [AllFormInputPrimaryKeys.FileType]: Joi.string().valid(...Object.values(InputFileType)).optional(),
+    [AllFormInputPrimaryKeys.SingleSelect]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.LabelPosition]: Joi.string().valid(...Object.values(LabelPosition)).optional(),
+    [AllFormInputPrimaryKeys.Min]: Joi.alternatives().try(Joi.number(), Joi.string(), Joi.date()).optional(),
+    [AllFormInputPrimaryKeys.Max]: Joi.alternatives().try(Joi.number(), Joi.string(), Joi.date()).optional(),
+    [AllFormInputPrimaryKeys.MinLength]: Joi.number().integer().optional(),
+    [AllFormInputPrimaryKeys.MaxLength]: Joi.number().integer().optional(),
+    [AllFormInputPrimaryKeys.MscoaConfig]: MscoaInputConfigSchema.optional(),
+    [AllFormInputPrimaryKeys.Value]: Joi.alternatives().try(Joi.number(), Joi.string().allow(''), Joi.boolean(), Joi.date(), Joi.object(), Joi.array().items(Joi.object())).optional(),
+    [AllFormInputPrimaryKeys.DataType]: Joi.string().valid(...Object.values(InputDataTypes)).required(),
+    [AllFormInputPrimaryKeys.Readonly]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.IServeInputWithRequisitionItems]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.CalculatedFieldRules]: calculatedFieldRulesSchema.optional(), // Assuming it's an object, adjust as needed
+    [AllFormInputPrimaryKeys.MatOptions]: MatDataOptionsSchema.optional(), // Assuming it's an object, adjust as needed
+    [AllFormInputPrimaryKeys.HintLabel]: Joi.string().allow('').optional(),
+    [AllFormInputPrimaryKeys.TourContent]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.Spellcheck]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.Pipe]: Joi.object({
+        pipeType: Joi.string().valid(...Object.values(InputPipeTypes)).required(),
+        param: Joi.string().required()
+    }).optional(),
+    [AllFormInputPrimaryKeys.Script]: Joi.object().optional(),
+    [AllFormInputPrimaryKeys.Validators]: Joi.array().items(Joi.alternatives().try(Joi.string(), formControlCustomValidatorSchema)).required(),
+    [AllFormInputPrimaryKeys.Accept]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.CalculateListFunctions]: Joi.array().items(Joi.object({
+        id: Joi.string().required(),
+        func: Joi.string().valid(...Object.values(CalculationFunctions)).required(),
+    })).optional(),
+    [AllFormInputPrimaryKeys.HandleLabel]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.MultipleInputInEditId]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.ShowAsLabel]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.Autocapitalize]: Joi.string().valid(...Object.values(AutocapitalizeOptions)).optional(),
+    [AllFormInputPrimaryKeys.Rows]: Joi.number().integer().optional(),
+    [AllFormInputPrimaryKeys.Wrap]: Joi.string().valid('hard', 'soft').optional(),
+    [AllFormInputPrimaryKeys.RichTextEditorLibrary]: Joi.string().valid(...Object.values(RichTextEditorType)).optional(),
+    [AllFormInputPrimaryKeys.OnlySetTempErrorOnTouch]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.IsCalculatedField]: Joi.boolean().optional(),
+    [AllFormInputPrimaryKeys.TemporaryHint]: Joi.string().optional(),
+    [AllFormInputPrimaryKeys.ValueUpdatedAt]: Joi.date().optional(),
+    [AllFormInputPrimaryKeys.Status]: Joi.object().pattern(Joi.string(), Joi.string()).optional(),
+    [AllFormInputPrimaryKeys.ViewType]: Joi.string().valid(...Object.values(InputViewTypes)).optional(),
+    [AllFormInputPrimaryKeys.FormIsOpen]: Joi.boolean().optional(),
+}).id('formColumnInputs');
+const formColumnInputsSchema = baseFormColumnInputsSchema.append({
+    [AllFormInputPrimaryKeys.FormInputs]: Joi.array().items(Joi.link('#formColumnInputs')).optional()
+}).shared(baseFormColumnInputsSchema);
+function validateFormColumnInputs(data) {
+    const isTitleInput = data[AllFormInputPrimaryKeys.Element] === ElementTypes.SectionTitle;
+    if (isTitleInput) {
+        return [];
+    }
+    const { error } = formColumnInputsSchema.validate(data, { abortEarly: false });
+    if (error) {
+        return error.details.map(detail => ({
+            key: detail.path.join('.'),
+            message: detail.message
+        }));
+    }
+    return [];
+}
+/**
+ * Validates form column inputs by separating required and optional fields
+ * @param options - ValidationOptions containing data and required keys
+ * @returns Array of ValidationError objects
+ */
+function validateFormColumnInputsWithRequired({ data, requiredKeys }) {
+    try {
+        // Validate that all requiredKeys exist in schema
+        const schemaKeys = Object.values(AllFormInputPrimaryKeys);
+        const invalidRequiredKeys = requiredKeys.filter(key => !schemaKeys.includes(key));
+        if (invalidRequiredKeys.length > 0) {
+            return [{
+                    key: 'validation',
+                    message: `Invalid required keys: ${invalidRequiredKeys.join(', ')}`
+                }];
+        }
+        // Get all valid keys from the data object
+        const dataKeys = Object.keys(data);
+        const invalidDataKeys = dataKeys.filter(key => !schemaKeys.includes(key));
+        if (invalidDataKeys.length > 0) {
+            return [{
+                    key: 'validation',
+                    message: `Invalid data keys: ${invalidDataKeys.join(', ')}`
+                }];
+        }
+        const calculationRulesRequiredKeys = (data[AllFormInputPrimaryKeys.IsCalculatedField] === true && (!data[AllFormInputPrimaryKeys.CalculatedFieldRules] ||
+            Object.keys(data[AllFormInputPrimaryKeys.CalculatedFieldRules]).length === 0));
+        const allRequiredKeys = [...requiredKeys, ...(calculationRulesRequiredKeys ? [AllFormInputPrimaryKeys.CalculatedFieldRules] : [])];
+        // Validate required fields
+        const requiredValidationErrors = allRequiredKeys
+            .map(key => validateFormColumnInputKey(key, data[key], true));
+        // Validate optional fields (fields in data that aren't required)
+        const optionalValidationErrors = dataKeys
+            .filter(key => !requiredKeys.includes(key))
+            .map(key => validateFormColumnInputKey(key, data[key], false));
+        // Combine and flatten all validation errors
+        const allErrors = [
+            ...requiredValidationErrors,
+            ...optionalValidationErrors
+        ].flat();
+        return allErrors;
+    }
+    catch (err) {
+        // Enhanced error handling
+        if (err instanceof Error) {
+            return [{
+                    key: 'validation',
+                    message: err.message
+                }];
+        }
+        return [{
+                key: 'validation',
+                message: 'An unknown error occurred during validation'
+            }];
+    }
+}
+/**
+ * Validates a single key from the form input data
+ * @param key - The key to validate
+ * @param value - The value to validate
+ * @param isRequired - Whether this field should be treated as required
+ * @returns ValidationError[] - Empty array if valid, array with error if invalid
+ */
+function validateFormColumnInputKey(key, value, isRequired = false) {
+    try {
+        // Get the original field schema
+        const fieldSchema = formColumnInputsSchema.extract(key);
+        if (!fieldSchema) {
+            return [{
+                    key,
+                    message: `Invalid field: ${key} does not exist in schema`
+                }];
+        }
+        // Apply required/optional state while preserving all other rules
+        const modifiedFieldSchema = isRequired ? fieldSchema.required() : fieldSchema.optional();
+        // Validate the single field
+        const { error } = modifiedFieldSchema.validate(value, {
+            abortEarly: false,
+            presence: isRequired ? 'required' : 'optional'
+        });
+        if (error) {
+            return error.details.map(detail => ({
+                key,
+                message: detail.message
+            }));
+        }
+        return [];
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            if ('isJoi' in err && err.isJoi) {
+                return [{
+                        key,
+                        message: `Schema validation error: ${err.message}`
+                    }];
+            }
+            return [{
+                    key,
+                    message: err.message
+                }];
+        }
+        return [{
+                key,
+                message: 'An unknown error occurred during validation'
+            }];
+    }
+}
+export { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired };

package/dist/schemas/FormSchema.d.ts

@@ -0,0 +1,26 @@
+import * as Joi from 'joi';
+import { FormInterface } from "../interfaces/Form";
+export declare const FormSlideSchema: Joi.ObjectSchema<any>;
+export declare const FormSubmissionHandleSchema: Joi.ObjectSchema<any>;
+export declare const FormSchema: Joi.ObjectSchema<any>;
+export declare const DatabaseFormSchema: Joi.ObjectSchema<any>;
+export declare function validateFormSlide(data: any): {
+    key: string;
+    message: string;
+}[];
+export declare function validateForm(data: FormInterface): {
+    key: string;
+    message: string;
+}[];
+export declare function validateApiDataFetchingConfiguration(data: any): {
+    key: string;
+    message: string;
+}[];
+export declare function validateDatabaseForm(data: any): {
+    key: string;
+    message: string;
+}[];
+export declare function validateSubmissionHandle(data: any): {
+    key: string;
+    message: string;
+}[];

package/dist/schemas/FormSchema.js

@@ -0,0 +1,134 @@
+import * as Joi from 'joi';
+import { formColumnInputsSchema } from "./FormInputSchema";
+import { APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema } from "./MatOptionsSchema";
+export const FormSlideSchema = Joi.object({
+    sectionId: Joi.string().required(),
+    label: Joi.string().required(),
+    columns: Joi.array().items(formColumnInputsSchema).min(1).required(),
+    inEdit: Joi.boolean().optional()
+});
+export const FormSubmissionHandleSchema = Joi.object({
+    innerComponentShowSubmitButton: Joi.boolean().optional(),
+    canSubmitAPI: Joi.array().items(APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema).optional(),
+    submissionAPI: Joi.array().items(APIDataFetchingConfigurationSchema).min(1).required(),
+    submissionMessage: Joi.string().optional()
+});
+export const FormSchema = Joi.object({
+    slides: Joi.array().items(FormSlideSchema).min(1).required(),
+    submissionHandle: FormSubmissionHandleSchema.required(),
+    formId: Joi.string().optional(),
+    formTitle: Joi.string().required(),
+    systemDefault: Joi.boolean().optional(),
+});
+export const DatabaseFormSchema = Joi.object({
+    _id: Joi.string().required(),
+    systemDefault: Joi.boolean().required(),
+    archive: Joi.boolean().required(),
+    userId: Joi.string().required(),
+    defaultDepartment: Joi.string().required(),
+    form: FormSchema.required(),
+    createdAt: Joi.date().required(),
+    updatedAt: Joi.date().required(),
+    __v: Joi.number().required
+});
+export function validateFormSlide(data) {
+    const { error } = FormSlideSchema.validate(data);
+    if (error) {
+        return error.details.map((detail) => ({
+            key: detail.path.join('.'),
+            message: transformValidationError(detail.message)
+        }));
+    }
+    return [];
+}
+export function validateForm(data) {
+    try {
+        if (typeof data !== 'object' || data === null) {
+            return [
+                {
+                    key: 'validation',
+                    message: 'Form is required and must be an object'
+                }
+            ];
+        }
+        const form = {
+            ...data,
+            slides: data.slides.map(slide => ({
+                ...slide,
+                columns: (slide.columns || []).filter(column => column.element !== 'sectionTitle')
+            }))
+        };
+        const { error } = FormSchema.validate(form, {
+            abortEarly: false,
+        });
+        if (error) {
+            return error.details.map((detail) => ({
+                key: detail.path.join('.'),
+                message: transformValidationError(detail.message)
+            }));
+        }
+        return [];
+    }
+    catch (error) {
+        console.error(error);
+        return [
+            {
+                key: 'validation',
+                message: 'An error occurred while validating the form'
+            }
+        ];
+    }
+}
+export function validateApiDataFetchingConfiguration(data) {
+    const { error } = APIDataFetchingConfigurationSchema.validate(data);
+    if (error) {
+        return error.details.map(detail => ({
+            key: detail.path.join('.'),
+            message: transformValidationError(detail.message)
+        }));
+    }
+    return [];
+}
+export function validateDatabaseForm(data) {
+    const { error } = DatabaseFormSchema.validate(data);
+    if (error) {
+        return error.details.map((detail) => ({
+            key: detail.path.join('.'),
+            message: transformValidationError(detail.message)
+        }));
+    }
+    return [];
+}
+export function validateSubmissionHandle(data) {
+    const { error } = FormSubmissionHandleSchema.validate(data);
+    if (error) {
+        return error.details.map((detail) => ({
+            key: detail.path.join('.'),
+            message: transformValidationError(detail.message)
+        }));
+    }
+    return [];
+}
+function transformValidationError(errorMessage) {
+    // Extract text between quotes and keep track of the full message
+    const quotedTextRegex = /"([^"]+)"/;
+    const match = errorMessage.match(quotedTextRegex);
+    if (!match)
+        return errorMessage;
+    const originalQuotedText = match[0]; // includes quotes
+    const path = match[1]; // just the path
+    // Transform the path into readable text
+    const transformedPath = (path || '')
+        .split(/[\[\].]+/)
+        .filter(part => part && isNaN(Number(part)))
+        .map(part => {
+        const words = part.replace(/([A-Z])/g, ' $1').toLowerCase();
+        return words
+            .split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    })
+        .join(' > ');
+    // Replace only the quoted part while preserving the rest of the message
+    return errorMessage.replace(originalQuotedText, `"${transformedPath}"`);
+}