procode-lowcode-core 1.0.15 → 1.0.17

package/src/DataModel/CoreViewModelHandler.ts

@@ -1,241 +1,221 @@
-import {
-  createService,
-  deleteService,
-  fetchScreenDataService,
-  fetchSupportiveDataService,
-  patchService,
-  updateService,
-} from "../Services/CRUDServices";
-import { EventService } from "../Services/EventService";
-import { ApiConfig } from "../UIElement/UIElementDefinations/ApiConfig";
-import { IViewModelHandler, QueryFilters } from "./IViewModelHandler";
-import {
-  deserializedModel,
-  deserializedSupportiveData,
-  handleFetchRequest,
-  handleRequest,
-  serializedModel,
-  serializedScreenDataQueryParams,
-  serializedSupportiveQueryParams,
-} from "./SupportiveFunctions";
-import { ViewModel } from "./ViewModel";
-
-export class CoreViewModelHandler implements IViewModelHandler {
-  private static instance: CoreViewModelHandler;
-  private static createInstance() {
-    CoreViewModelHandler.instance = new CoreViewModelHandler();
-  }
-
-  static getInstance() {
-    if (!CoreViewModelHandler.instance) CoreViewModelHandler.createInstance();
-    return CoreViewModelHandler.instance;
-  }
-
-  getViewModel = async (
-    screenDataQueryParams: QueryFilters,
-    supportiveQueryParams: string[],
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ): Promise<ViewModel> => {
-    const viewModel: ViewModel = {
-      screenData: null,
-      supportiveData: null,
-    };
-
-    const [supportiveData, screenData] = await Promise.all([
-      apiConfig?.loadSupportiveData?.endPoint &&
-      supportiveQueryParams?.length > 0
-        ? handleFetchRequest(
-            serializedSupportiveQueryParams(
-              eventService,
-              supportiveQueryParams
-            ),
-            apiConfig,
-            eventService,
-            fetchSupportiveDataService,
-            deserializedSupportiveData
-          )
-        : Promise.resolve(null),
-      apiConfig?.get?.endPoint
-        ? handleFetchRequest(
-            serializedScreenDataQueryParams(
-              eventService,
-              screenDataQueryParams
-            ),
-            apiConfig,
-            eventService,
-            fetchScreenDataService,
-            deserializedModel
-          )
-        : Promise.resolve(null),
-    ]);
-
-    viewModel.screenData = screenData;
-    viewModel.supportiveData = supportiveData;
-
-    return viewModel;
-  };
-
-  getModel = async (
-    screenDataQueryParams: QueryFilters,
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ) => {
-    const customAdapterBefore = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.get?.beforeRequestMethodName
-    );
-    const customAdapterAfter = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.get?.afterRequestMethodName
-    );
-
-    const applicableParams = apiConfig?.get?.disableBeforeRequest
-      ? screenDataQueryParams
-      : (customAdapterBefore ?? serializedScreenDataQueryParams)(
-          eventService,
-          screenDataQueryParams
-        );
-
-    const applicableResponse = apiConfig?.get?.disableAfterRequest
-      ? null
-      : customAdapterAfter ?? deserializedModel;
-
-    return handleFetchRequest(
-      applicableParams,
-      apiConfig,
-      eventService,
-      fetchScreenDataService,
-      applicableResponse
-    );
-  };
-
-  getSupportiveData = async (
-    supportiveQueryParams: string[],
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ) => {
-    const customAdapterBefore = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.loadSupportiveData?.beforeRequestMethodName
-    );
-    const customAdapterAfter = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.loadSupportiveData?.afterRequestMethodName
-    );
-
-    const applicableParams = apiConfig?.loadSupportiveData?.disableBeforeRequest
-      ? supportiveQueryParams
-      : (customAdapterBefore ?? serializedSupportiveQueryParams)(
-          eventService,
-          supportiveQueryParams
-        );
-
-    const applicableResponse = apiConfig?.loadSupportiveData
-      ?.disableAfterRequest
-      ? null
-      : customAdapterAfter ?? deserializedSupportiveData;
-
-    return handleFetchRequest(
-      applicableParams,
-      apiConfig,
-      eventService,
-      fetchSupportiveDataService,
-      applicableResponse
-    );
-  };
-
-  createModel = async (
-    model: any,
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ) => {
-    const customAdapterBefore = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.create?.beforeRequestMethodName
-    );
-    const customAdapterAfter = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.create?.afterRequestMethodName
-    );
-
-    const applicableModel = apiConfig?.create?.disableBeforeRequest
-      ? model
-      : (customAdapterBefore ?? serializedModel)(eventService, model);
-
-    return handleRequest(async () => {
-      const servicesResponse = await createService(
-        apiConfig,
-        applicableModel,
-        eventService
-      );
-
-      const applicableResponse = apiConfig?.create?.disableAfterRequest
-        ? servicesResponse
-        : (customAdapterAfter ?? deserializedModel)(
-            eventService,
-            servicesResponse
-          );
-
-      return applicableResponse;
-    }, eventService);
-  };
-
-  updateModel = async (
-    model: any,
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ) => {
-    const customAdapterBefore = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.update?.beforeRequestMethodName
-    );
-    const customAdapterAfter = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.update?.afterRequestMethodName
-    );
-    return handleRequest(async () => {
-      const serviceFc = apiConfig?.update?.isPatchUpdate
-        ? patchService
-        : updateService;
-
-      const applicableModel = apiConfig?.update?.disableBeforeRequest
-        ? model
-        : (customAdapterBefore ?? serializedModel)(eventService, model);
-
-      const servicesResponse = await serviceFc(
-        apiConfig,
-        applicableModel,
-        eventService
-      );
-      const applicableResponse = apiConfig?.update?.disableAfterRequest
-        ? servicesResponse
-        : (customAdapterAfter ?? deserializedModel)(
-            eventService,
-            servicesResponse
-          );
-
-      return applicableResponse;
-    }, eventService);
-  };
-
-  deleteModel = async (
-    screenDataQueryParams: QueryFilters,
-    apiConfig: ApiConfig,
-    eventService: EventService
-  ) => {
-    const customAdapter = eventService.emit(
-      "GET_CUSTOM_ADAPTER_METHOD",
-      apiConfig?.delete?.beforeRequestMethodName
-    );
-    const params = apiConfig?.delete?.disableBeforeRequest
-      ? screenDataQueryParams
-      : (customAdapter ?? serializedScreenDataQueryParams)(
-          eventService,
-          screenDataQueryParams
-        );
-    return handleRequest(async () => {
-      await deleteService(apiConfig, params, eventService);
-    }, eventService);
-  };
-}
+import { AdapterType } from "../Adapter/IAdapterProvider";
+import {
+  createService,
+  deleteService,
+  fetchScreenDataService,
+  fetchSupportiveDataService,
+  patchService,
+  updateService,
+} from "../Services/CRUDServices";
+import { EventService } from "../Services/EventService";
+import { ApiConfig } from "../UIElement/UIElementDefinations/ApiConfig";
+import { IViewModelHandler, QueryFilters } from "./IViewModelHandler";
+import {
+  deserializedModel,
+  deserializedSupportiveData,
+  handleFetchRequest,
+  handleRequest,
+  serializedModel,
+  serializedScreenDataQueryParams,
+  serializedSupportiveQueryParams,
+} from "./SupportiveFunctions";
+import { ViewModel } from "./ViewModel";
+
+type AdapterableOpConfig = {
+  beforeRequestMethodName?: string;
+  afterRequestMethodName?: string;
+  disableBeforeRequest?: boolean;
+  disableAfterRequest?: boolean;
+};
+
+type Adapter<TIn, TOut> = (eventService: EventService, input: TIn) => TOut;
+
+export class CoreViewModelHandler implements IViewModelHandler {
+  private static instance: CoreViewModelHandler;
+  private static createInstance() {
+    CoreViewModelHandler.instance = new CoreViewModelHandler();
+  }
+
+  static getInstance() {
+    if (!CoreViewModelHandler.instance) CoreViewModelHandler.createInstance();
+    return CoreViewModelHandler.instance;
+  }
+
+  // Resolve & apply the configured "before request" adapter to the input.
+  // Order: disable flag wins, then a custom-named adapter from EventService,
+  // then the supplied default serializer.
+  private applyBefore = <TIn>(
+    eventService: EventService,
+    opConfig: AdapterableOpConfig | undefined,
+    input: TIn,
+    defaultSerializer: Adapter<TIn, any>,
+  ): any => {
+    if (opConfig?.disableBeforeRequest) return input;
+    const custom = eventService.emit(
+      AdapterType.GET_CUSTOM_ADAPTER_METHOD,
+      opConfig?.beforeRequestMethodName,
+    );
+    return (custom ?? defaultSerializer)(eventService, input);
+  };
+
+  // Build the "after request" adapter callable. Returns null when disabled,
+  // so it can be passed straight to handleFetchRequest (which treats null as
+  // "skip deserialization") and re-used directly for create/update flows.
+  private resolveAfter = (
+    eventService: EventService,
+    opConfig: AdapterableOpConfig | undefined,
+    defaultDeserializer: Adapter<any, any>,
+  ): Adapter<any, any> | null => {
+    if (opConfig?.disableAfterRequest) return null;
+    const custom = eventService.emit(
+      AdapterType.GET_CUSTOM_ADAPTER_METHOD,
+      opConfig?.afterRequestMethodName,
+    );
+    return custom ?? defaultDeserializer;
+  };
+
+  getViewModel = async (
+    screenDataQueryParams: QueryFilters,
+    supportiveQueryParams: string[],
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ): Promise<ViewModel> => {
+    const [supportiveData, screenData] = await Promise.all([
+      apiConfig?.loadSupportiveData?.endPoint &&
+      supportiveQueryParams?.length > 0
+        ? this.getSupportiveData(supportiveQueryParams, apiConfig, eventService)
+        : Promise.resolve(null),
+      apiConfig?.get?.endPoint
+        ? this.getModel(screenDataQueryParams, apiConfig, eventService)
+        : Promise.resolve(null),
+    ]);
+
+    return { screenData, supportiveData };
+  };
+
+  getModel = async (
+    screenDataQueryParams: QueryFilters,
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ) => {
+    const params = this.applyBefore(
+      eventService,
+      apiConfig?.get,
+      screenDataQueryParams,
+      serializedScreenDataQueryParams,
+    );
+    const after = this.resolveAfter(
+      eventService,
+      apiConfig?.get,
+      deserializedModel,
+    );
+
+    return handleFetchRequest(
+      params,
+      apiConfig,
+      eventService,
+      fetchScreenDataService,
+      after,
+    );
+  };
+
+  getSupportiveData = async (
+    supportiveQueryParams: string[],
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ) => {
+    const params = this.applyBefore(
+      eventService,
+      apiConfig?.loadSupportiveData,
+      supportiveQueryParams,
+      serializedSupportiveQueryParams,
+    );
+    const after = this.resolveAfter(
+      eventService,
+      apiConfig?.loadSupportiveData,
+      deserializedSupportiveData,
+    );
+
+    return handleFetchRequest(
+      params,
+      apiConfig,
+      eventService,
+      fetchSupportiveDataService,
+      after,
+    );
+  };
+
+  createModel = async (
+    model: any,
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ) => {
+    const payload = this.applyBefore(
+      eventService,
+      apiConfig?.create,
+      model,
+      serializedModel,
+    );
+    const after = this.resolveAfter(
+      eventService,
+      apiConfig?.create,
+      deserializedModel,
+    );
+
+    return handleRequest(async () => {
+      const servicesResponse = await createService(
+        apiConfig,
+        payload,
+        eventService,
+      );
+      return after ? after(eventService, servicesResponse) : servicesResponse;
+    }, eventService);
+  };
+
+  updateModel = async (
+    model: any,
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ) => {
+    const serviceFn = apiConfig?.update?.isPatchUpdate
+      ? patchService
+      : updateService;
+    const payload = this.applyBefore(
+      eventService,
+      apiConfig?.update,
+      model,
+      serializedModel,
+    );
+    const after = this.resolveAfter(
+      eventService,
+      apiConfig?.update,
+      deserializedModel,
+    );
+
+    return handleRequest(async () => {
+      const servicesResponse = await serviceFn(
+        apiConfig,
+        payload,
+        eventService,
+      );
+      return after ? after(eventService, servicesResponse) : servicesResponse;
+    }, eventService);
+  };
+
+  deleteModel = async (
+    screenDataQueryParams: QueryFilters,
+    apiConfig: ApiConfig,
+    eventService: EventService,
+  ) => {
+    const params = this.applyBefore(
+      eventService,
+      apiConfig?.delete,
+      screenDataQueryParams,
+      serializedScreenDataQueryParams,
+    );
+
+    return handleRequest(async () => {
+      await deleteService(apiConfig, params, eventService);
+    }, eventService);
+  };
+}

package/src/DataModel/SupportiveFunctions/index.ts

@@ -47,10 +47,12 @@ export const fetchDataAndDeserialize = async (
     queryParam: string,
     eventService: EventService
   ) => Promise<ServicesResponse>,
-  deserializeFn: (
-    eventService: EventService,
-    servicesResponse: ServicesResponse
-  ) => any
+  deserializeFn:
+    | ((
+        eventService: EventService,
+        servicesResponse: ServicesResponse
+      ) => any)
+    | null
 ): Promise<any> => {
   const servicesResponse = await fetchService(
     apiConfig,
@@ -86,10 +88,12 @@ export const handleFetchRequest = async (
     queryParam: string,
     eventService: EventService
   ) => Promise<ServicesResponse>,
-  deserializeFn: (
-    eventService: EventService,
-    servicesResponse: ServicesResponse
-  ) => any
+  deserializeFn:
+    | ((
+        eventService: EventService,
+        servicesResponse: ServicesResponse
+      ) => any)
+    | null
 ) => {
   return handleRequest(
     () =>

package/src/Services/CentralService.ts

@@ -9,6 +9,7 @@ import {
   ResponseConfig,
 } from "../UIElement/UIElementDefinations/ApiConfig";
 import NotificationService from "../ApplicationStart/HOC/NotificationService";
+import FieldValidationDispatcher from "../ApplicationStart/HOC/FieldValidationDispatcher";
 import { getStatusBaseNotifiType } from "./helpers/getStatusBaseNotifiType";
 
 export interface CustomAxiosRequestConfig extends AxiosRequestConfig {
@@ -18,7 +19,7 @@ export interface CustomAxiosRequestConfig extends AxiosRequestConfig {
 
 export class CentralService {
   private static instance: CentralService;
-  private _axiosInstance: AxiosInstance | null = null;
+  private _axiosInstance: AxiosInstance;
 
   private constructor() {
     const axiosInstance = axios.create();
@@ -28,64 +29,74 @@ export class CentralService {
     this._axiosInstance = axiosInstance;
   }
 
-  private setHeaders = (base: any, customHeaders: any) => {
+  private setHeaders = (base: any, customHeaders: any): void => {
     if (customHeaders) {
       Object.keys(customHeaders)?.forEach((key) => {
         base.headers[key] = customHeaders[key];
       });
     }
-    return base;
   };
 
   private getMessage = (
     response: AxiosResponse<any, any>,
     responseConfig?: ResponseConfig,
   ) => {
-    const statusRelatedConfig = (responseConfig ?? {})[response?.status];
-    let errorMessage = "";
-    if (statusRelatedConfig?.enableMessage) {
-      errorMessage =
-        statusRelatedConfig?.message ||
-        response?.data?.message ||
-        ErrorMessageProvider.get(
-          response.config.method as RequestType,
-          response?.status,
-        );
-    }
-
-    return errorMessage;
+    const status = response?.data?.status;
+    const statusRelatedConfig = (responseConfig ?? {})[status];
+    if (!statusRelatedConfig?.enableMessage) return "";
+
+    const payloadMessage = response?.data?.message;
+    return (
+      statusRelatedConfig?.message ||
+      (typeof payloadMessage === "string" ? payloadMessage : "") ||
+      ErrorMessageProvider.get(
+        response.config.method as RequestType,
+        status,
+      )
+    );
   };
 
   private handleResponseStatus = (response: AxiosResponse<any, any>) => {
-    if (response?.data?.status === 401) {
-      window.location.href = env.baseLogoutUrl || "/";
-    } else if (response?.data?.status >= 200 && response?.data?.status < 500) {
-      const customAxiosRequestConfig =
-        response.config as CustomAxiosRequestConfig;
+    const status = response?.data?.status;
 
-      response.data.message = this.getMessage(
-        response,
-        customAxiosRequestConfig?.responseConfig,
-      );
+    if (status === 401) {
+      window.location.href = env.baseLogoutUrl || "/";
+      return;
+    }
+    if (!(status >= 200 && status < 500)) {
+      throw new Error("Unhandled response status " + status);
+    }
 
-      response.data.alertType =
-        customAxiosRequestConfig?.responseConfig?.[response?.data?.status]
-          ?.alertType || AlertType.TOAST;
+    const customAxiosRequestConfig =
+      response.config as CustomAxiosRequestConfig;
+    const responseConfig = customAxiosRequestConfig?.responseConfig;
+    const statusRelatedConfig = (responseConfig ?? {})[status];
+    const alertType = statusRelatedConfig?.alertType || AlertType.TOAST;
+    response.data.alertType = alertType;
+
+    if (alertType === AlertType.FIELDVALIDATION) {
+      // Structured payload (default convention {propertyName, message}, or
+      // whatever shape the registered fieldErrorMapper recognizes): route to
+      // the per-field validation slice. If the mapper finds nothing — e.g.
+      // the server returned a plain string — fall through to the toast path
+      // below, so the message still surfaces as a notification.
+      const fieldErrorMapper = AppDependenceyProvider.getInstance()
+        .getFieldErrorMapper();
+      const fieldErrors = fieldErrorMapper(response.data?.message);
+      if (Object.keys(fieldErrors).length > 0) {
+        response.data.fieldErrors = fieldErrors;
+        FieldValidationDispatcher.dispatch(fieldErrors);
+        return;
+      }
+    }
 
-      const statusRelatedConfig = (customAxiosRequestConfig?.responseConfig ??
-        {})[response?.data?.status];
+    response.data.message = this.getMessage(response, responseConfig);
 
-      if (
-        response.data.alertType === AlertType.TOAST &&
-        statusRelatedConfig?.enableMessage
-      ) {
-        NotificationService.showNotification(
-          response.data.message,
-          getStatusBaseNotifiType(response?.data?.status),
-        );
-      }
-    } else {
-      throw new Error("Unhandled response status " + response?.data?.status);
+    if (statusRelatedConfig?.enableMessage) {
+      NotificationService.showNotification(
+        response.data.message,
+        getStatusBaseNotifiType(status),
+      );
     }
   };
 
@@ -113,21 +124,19 @@ export class CentralService {
   };
 
   private setInterceptorsRequest = (axiosInstance: AxiosInstance) => {
-    if (axiosInstance) {
-      axiosInstance.interceptors.request.use(
-        (request) => {
-          this.setHeaders(
-            request,
-            AppDependenceyProvider.getInstance().getRequestHeaders(),
-          );
-          return request;
-        },
-        (error) => {
-          console.error("Request error:", error);
-          throw error;
-        },
-      );
-    }
+    axiosInstance.interceptors.request.use(
+      (request) => {
+        this.setHeaders(
+          request,
+          AppDependenceyProvider.getInstance().getRequestHeaders(),
+        );
+        return request;
+      },
+      (error) => {
+        console.error("Request error:", error);
+        throw error;
+      },
+    );
   };
 
   private static initInstance(): void {
@@ -141,5 +150,5 @@ export class CentralService {
     return CentralService.instance;
   }
 
-  public getAxioInstance = (): AxiosInstance | null => this._axiosInstance;
+  public getAxioInstance = (): AxiosInstance => this._axiosInstance;
 }