impaktapps-ui-builder 1.0.105 → 1.0.107

package/dist/src/impaktapps-ui-builder/builder/build/buildUiSchema.d.ts

@@ -3,6 +3,11 @@ export declare let schema: {
     properties: {};
     required: any[];
 };
-export declare function buildSchema(config: any): any;
+export declare function buildSchemaFromConfig(config: any, parentSchema: any): void;
+export declare const buildSchema: (config: any) => {
+    type: string;
+    properties: {};
+    required: any[];
+};
 declare const buildUiSchema: (config: any, store?: any) => any;
 export default buildUiSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "impaktapps-ui-builder",
-    "version": "1.0.105",
+    "version": "1.0.107",
     "scripts": {
         "dev": "vite",
         "build": "tsc && vite build",

package/src/impaktapps-ui-builder/builder/build/buildUiSchema.ts

@@ -51,111 +51,70 @@ function buildOneOf(values: any[]) {
     title: e.label
   }));
 }
-function applyValidations(
-  schemaNode: any,
-  validations: any[] = [],
-  requiredArr?: string[],
-  fieldName?: string
-) {
-  validations.forEach((rule) => {
-    if (rule.validationType === "readOnly") {
-      schemaNode.disabled = true
-    }
-    if (rule.validationType === "required") {
-      if (requiredArr && fieldName) {
-        requiredArr.push(fieldName);
-      }
-    } else {
-      schemaNode.type = "string";
-      schemaNode[rule.validationType] =
-        isNaN(rule.validationValue)
-          ? rule.validationValue
-          : Number(rule.validationValue);
-    }
-  });
-}
-
-function buildNode(config: any): any {
-  if (config.type === "Array") {
-    const arraySchema: any = {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {},
-        required: []
-      }
-    };
-
-    config.elements?.forEach((child: any) => {
-      const childNode = buildNode(child);
-      if (!childNode) return;
-
-      arraySchema.items.properties[child.name] = childNode.schema;
-
-      if (childNode.required?.length) {
-        arraySchema.items.required.push(child.name);
-      }
-    });
+export function buildSchemaFromConfig(config: any, parentSchema: any) {
+  if (config.elements) {
+    if (config.type === "Array") {
+      parentSchema.properties ??= {};
+      parentSchema.properties[config.name] ??= {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      };
 
-    return { schema: arraySchema };
-  }
+      const arrayItemSchema = parentSchema.properties[config.name].items;
 
-  let fieldSchema: any = {};
-  if (
-    (config.type === "Select" || config.type === "MultipleSelect") &&
-    config.value?.length > 0
-  ) {
-    if (config.type === "Select") {
-      fieldSchema.oneOf = buildOneOf(config.value);
+      config.elements?.forEach((child: any) =>
+        buildSchemaFromConfig(child, arrayItemSchema)
+      );
+      return;
     } else {
-      fieldSchema.type = "array";
-      fieldSchema.items = {
-        oneOf: buildOneOf(config.value)
-      };
+      config.elements?.forEach((child: any) =>
+        buildSchemaFromConfig(child, parentSchema)
+      );
+      return;
     }
   }
-
-  if (config.validation) {
-    applyValidations(fieldSchema, config.validation);
-  }
-
-  const required =
-    config.validation?.some(
-      (v: any) => v.validationType === "required"
-    )
-      ? [config.name]
-      : [];
-
-  return {
-    schema: fieldSchema,
-    required
-  };
-}
-
-export function buildSchema(config: any): any {
-  const schema: any = {
-    type: "object",
-    properties: {},
-    required: []
-  };
-
-  config.elements?.forEach((element: any) => {
-    const node = buildNode(element);
-    if (!node) return;
-
-    schema.properties[element.name] = node.schema;
-
-    if (node.required?.length) {
-      schema.required.push(element.name);
+  parentSchema.properties ??= {};
+  parentSchema.properties[config.name] ??= {};
+  const fieldSchema = parentSchema.properties[config.name];
+  config.validation?.forEach((v: any) => {
+    if (v.validationType === "required") {
+      parentSchema.required ??= [];
+      parentSchema.required.push(config.name);
+    } else if (v.validationType === "readOnly") {
+      fieldSchema.type = "string";
+      fieldSchema.disabled = true;
+    } else {
+      fieldSchema.type = "string";
+      fieldSchema[v.validationType] = isNaN(v.validationValue)
+        ? v.validationValue
+        : Number(v.validationValue);
     }
   });
-
-  if (schema.required.length === 0) {
-    delete schema.required;
+  if (config.type === "Select" && config.value?.length) {
+    fieldSchema.oneOf = config.value.map((v: any) => ({
+      const: v.value,
+      title: v.label,
+    }));
+  }
+  if (config.type === "MultipleSelect" && config.value?.length) {
+    fieldSchema.type = "array";
+    fieldSchema.items = {
+      oneOf: config.value.map((v: any) => ({
+        const: v.value,
+        title: v.label,
+      })),
+    };
   }
+}
 
+export const buildSchema = (config) => {
+  buildSchemaFromConfig(config, schema)
   return schema;
-};
+}
 
 const buildUiSchema = (config: any, store?: any) => {
   let elements: any = {};

package/src/impaktapps-ui-builder/runtime/services/events.ts

@@ -68,8 +68,7 @@ function executeEventsHandler(params: handlersProps) {
       params.componentName,
       params.config,
       params.store,
-      params.service,
-      params.formDataHolder
+      params.formDataHolder,
     );
   } else if (params.config.Handler === "onBackHandler") {
     return params.store.functionParameters?.handleBack();
@@ -144,8 +143,7 @@ function executeCustomHandler(params: handlersProps) {
   }
 
 }
-
-function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, service: any, formDataHolder: any) {
+function mergeFormdata(handlerResponse: any, componentName: string, eventConfig: any, store: any, formDataHolder: any) {
   if (eventConfig.type === "Select" && handlerResponse?.data) {
     if (!_.isEmpty(handlerResponse?.data)) {
       store.setSchema((pre) => {
@@ -183,23 +181,21 @@ function mergeFormdata(handlerResponse: any, componentName: string, eventConfig:
         ...store.newData,
         ...handlerResponse?.data
       }
-      store.setFormdata((pre: any) => { return { ...pre, ...handlerResponse?.data } })
+      formDataHolder = { ...formDataHolder, ...handlerResponse?.data }
     }
   }
   else if (eventConfig.type === "Table" && eventConfig.lazyLoading) {
     if (handlerResponse && handlerResponse?.data) {
       formDataHolder[componentName] = handlerResponse.data?.data
       formDataHolder[`${componentName}_RowCount`] = handlerResponse.data?.meta?.totalRowCount
-      store.setFormdata((pre) => { return { ...pre, ...formDataHolder } });
     }
   }
   else {
     if (handlerResponse) {
       formDataHolder[componentName] = handlerResponse.data
-      store.setFormdata((pre) => { return { ...pre, ...formDataHolder } });
     }
   }
-}
+};
 
 const buildBodyFormat = (body: any[], formData: any, userValue: any, store: any) => {
   let finalBody = { ...userValue?.payload };

package/src/impaktapps-ui-builder/runtime/services/service.ts

@@ -90,9 +90,9 @@ export default (funcParams: funcParamsProps) => {
         config: {}, componentName: "",
         store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
         functionsProvider: funcParams.functionsProvider,
-        serviceHolder: this, eventGroups, formDataHolder
+        serviceHolder: this, eventGroups, formDataHolder,
       }
-
+    
       funcParams.store.setSchema(
         (pre: any) => {
           return {
@@ -104,9 +104,9 @@ export default (funcParams: funcParamsProps) => {
       await executeRefreshHandler({
         config: {}, componentName: "",
         store: funcParams.store, dynamicData: funcParams.dynamicData, userValue: funcParams.userValue, service: funcParams.service,
-        serviceHolder: this, eventGroups, formDataHolder: {}
+        serviceHolder: this, eventGroups, formDataHolder: formDataHolder
       })
-
+      funcParams.store.setFormdata((pre) => ({ ...pre, ...formDataHolder }))
       uiSchema.elements.push(notifyUiSchema);
       funcParams.store.setUiSchema(uiSchema);
     },
@@ -247,13 +247,23 @@ export default (funcParams: funcParamsProps) => {
     callHandler: async function (eventType: string, functionParameters?: any) {
       const path = funcParams.dynamicData?.tableButtonPath || funcParams.dynamicData.path.split(".")[funcParams.dynamicData.path.split(".").length - 1];
       if (eventGroups?.[eventType]?.[path] !== undefined) {
-        Promise.all(eventGroups?.[eventType]?.[path].map((eventConfig) => {
+       await Promise.all(eventGroups?.[eventType]?.[path].map(async (eventConfig) => {
           executeEventsParameters.store.functionParameters = functionParameters
-          executeEvents({
-            ...executeEventsParameters,
-            config: eventConfig,
-            componentName: path
-          })
+          if (eventConfig.Handler === "refresh") {
+            await executeRefreshHandler({
+              ...executeEventsParameters,
+              config: eventConfig,
+              componentName: path,
+              formDataHolder: formDataHolder
+            })
+            funcParams.store.setFormdata((pre) => ({ ...pre, ...formDataHolder }));
+          } else {
+            executeEvents({
+              ...executeEventsParameters,
+              config: eventConfig,
+              componentName: path
+            })
+          }
         }))
       }
     },