procode-lowcode-core 1.0.16 → 1.0.18

package/dist/types/Action/helpers/hasFieldValidationErrors.d.ts

@@ -0,0 +1,2 @@
+import { EventService } from "../../Services/EventService";
+export declare const hasFieldValidationErrors: (eventService: EventService | undefined) => boolean;

package/dist/types/ApplicationStart/AppDependenceyProvider.d.ts

@@ -1,6 +1,7 @@
 import IAdapterProvider from "../Adapter/IAdapterProvider";
 import { IViewModelHandler } from "../DataModel/IViewModelHandler";
 import { ResponseFormat } from "../Services/helpers/coreResponseFormatter";
+import { FieldErrorMapper } from "../Services/helpers/defaultFieldErrorMapper";
 export declare class AppDependenceyProvider {
     private _adapterProvider?;
     private _viewModelHandler?;
@@ -10,9 +11,10 @@ export declare class AppDependenceyProvider {
     private _requestHeaders?;
     private _getSchemaBySlugService?;
     private _responseFormatter?;
+    private _fieldErrorMapper?;
     private static instance;
     private constructor();
-    static initInstance: ({ adapterProvider, viewModelHandler, widgetProvider, templateWidgetProvider, customWidgetProvider, requestHeaders, getSchemaBySlugService, responseFormatter, }: any) => void;
+    static initInstance: ({ adapterProvider, viewModelHandler, widgetProvider, templateWidgetProvider, customWidgetProvider, requestHeaders, getSchemaBySlugService, responseFormatter, fieldErrorMapper, }: any) => void;
     static getInstance: () => AppDependenceyProvider;
     getAdapterProvider: () => IAdapterProvider;
     getViewModelHandler: () => IViewModelHandler;
@@ -22,4 +24,5 @@ export declare class AppDependenceyProvider {
     getRequestHeaders: () => any;
     getSchemaBySlugService: () => any;
     getResponseFormatter: () => (data: any, status: number) => ResponseFormat;
+    getFieldErrorMapper: () => FieldErrorMapper;
 }

package/dist/types/ApplicationStart/HOC/FieldValidationDispatcher.d.ts

@@ -0,0 +1,9 @@
+type FieldErrors = Record<string, string[]>;
+type Handler = (errors: FieldErrors) => void;
+declare class FieldValidationDispatcher {
+    private static handler?;
+    static registerHandler(handler: Handler): void;
+    static dispatch(errors: FieldErrors): void;
+}
+export default FieldValidationDispatcher;
+export type { FieldErrors };

package/dist/types/Constant.d.ts

@@ -6,6 +6,7 @@ export declare const eventServiceType: {
     UI_SCHEMA_ACTION: string;
     UISCHEMA: string;
     DATASTATE: string;
+    APP_STATE: string;
     REQUEST_START: string;
     REQUEST_END: string;
 };

package/dist/types/DataModel/CoreViewModelHandler.d.ts

@@ -6,6 +6,8 @@ export declare class CoreViewModelHandler implements IViewModelHandler {
     private static instance;
     private static createInstance;
     static getInstance(): CoreViewModelHandler;
+    private applyBefore;
+    private resolveAfter;
     getViewModel: (screenDataQueryParams: QueryFilters, supportiveQueryParams: string[], apiConfig: ApiConfig, eventService: EventService) => Promise<ViewModel>;
     getModel: (screenDataQueryParams: QueryFilters, apiConfig: ApiConfig, eventService: EventService) => Promise<any>;
     getSupportiveData: (supportiveQueryParams: string[], apiConfig: ApiConfig, eventService: EventService) => Promise<any>;

package/dist/types/DataModel/SupportiveFunctions/index.d.ts

@@ -7,6 +7,6 @@ export declare const deserializedSupportiveData: (eventService: EventService, su
 export declare const serializedSupportiveQueryParams: (eventService: EventService, supportiveQueryParams: any) => any;
 export declare const serializedScreenDataQueryParams: (eventService: EventService, screenDataQueryParams: QueryFilters) => any;
 export declare const serializedModel: (eventService: EventService, model: any) => any;
-export declare const fetchDataAndDeserialize: (queryParam: string, apiConfig: ApiConfig, eventService: EventService, fetchService: (apiConfig: ApiConfig, queryParam: string, eventService: EventService) => Promise<ServicesResponse>, deserializeFn: (eventService: EventService, servicesResponse: ServicesResponse) => any) => Promise<any>;
+export declare const fetchDataAndDeserialize: (queryParam: string, apiConfig: ApiConfig, eventService: EventService, fetchService: (apiConfig: ApiConfig, queryParam: string, eventService: EventService) => Promise<ServicesResponse>, deserializeFn: ((eventService: EventService, servicesResponse: ServicesResponse) => any) | null) => Promise<any>;
 export declare const handleRequest: (requestFn: () => Promise<any>, eventService: EventService) => Promise<any>;
-export declare const handleFetchRequest: (queryParam: string, apiConfig: ApiConfig, eventService: EventService, fetchService: (apiConfig: ApiConfig, queryParam: string, eventService: EventService) => Promise<ServicesResponse>, deserializeFn: (eventService: EventService, servicesResponse: ServicesResponse) => any) => Promise<any>;
+export declare const handleFetchRequest: (queryParam: string, apiConfig: ApiConfig, eventService: EventService, fetchService: (apiConfig: ApiConfig, queryParam: string, eventService: EventService) => Promise<ServicesResponse>, deserializeFn: ((eventService: EventService, servicesResponse: ServicesResponse) => any) | null) => Promise<any>;

package/dist/types/Services/CentralService.d.ts

@@ -15,5 +15,5 @@ export declare class CentralService {
     private setInterceptorsRequest;
     private static initInstance;
     static getInstance(): CentralService;
-    getAxioInstance: () => AxiosInstance | null;
+    getAxioInstance: () => AxiosInstance;
 }

package/dist/types/Services/helpers/defaultFieldErrorMapper.d.ts

@@ -0,0 +1,4 @@
+import { FieldErrors } from "../../ApplicationStart/HOC/FieldValidationDispatcher";
+export type FieldErrorMapper = (raw: unknown) => FieldErrors;
+declare const defaultFieldErrorMapper: FieldErrorMapper;
+export default defaultFieldErrorMapper;

package/dist/types/Validation/IValidationFactory.d.ts

@@ -9,7 +9,8 @@ export declare enum StandardValidationType {
     LESS_THAN = "LESS_THAN",
     LESS_THAN_EQUAL = "LESS_THAN_EQUAL",
     BETWEEN = "BETWEEN",
-    NOT_BETWEEN = "NOT_BETWEEN"
+    NOT_BETWEEN = "NOT_BETWEEN",
+    ALPHANUMERIC_SPACE = "ALPHANUMERIC_SPACE"
 }
 export type ValidationFcResponse = {
     isValid: boolean;

package/dist/types/Validation/StandardValidations/StandardValidationFactory.d.ts

@@ -34,6 +34,9 @@ declare class StandardValidationFactory implements IValidationFactory {
     }) | (({ validation, viewModel, value, }: import("../Types").ValidationFcProperties) => {
         isValid: boolean;
         message: string;
+    }) | (({ validation, value, }: import("../Types").ValidationFcProperties) => {
+        isValid: boolean;
+        message: string;
     });
 }
 export default StandardValidationFactory;

package/dist/types/Validation/StandardValidations/alphanumericSpaceValidation.d.ts

@@ -0,0 +1,5 @@
+import { ValidationFcProperties } from "../Types";
+export declare const alphanumericSpaceValidation: ({ validation, value, }: ValidationFcProperties) => {
+    isValid: boolean;
+    message: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "procode-lowcode-core",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "ProCode Core Library - React framework for low-code applications",
   "type": "module",
   "main": "dist/index.js",

package/src/Action/StandardActions/handleCreateAndNavigate.ts

@@ -5,13 +5,13 @@ import { validateUiElementSchema } from "../helpers/validateUiElementSchema";
 import { ActionInvokerProperties } from "../Types";
 import handleNavigation from "./handleNavigation";
 import { appActions } from "../../Store/Slices/appSlice";
+import { hasFieldValidationErrors } from "../helpers/hasFieldValidationErrors";
 
 const handleCreateAndNavigate = async (
   actionInvokerProps: ActionInvokerProperties,
 ) => {
   const eventService = actionInvokerProps.eventService;
   const dispatch = eventService?.emit(eventServiceType.DISPATCH_STORE);
-  // const appActions = eventService?.emit(eventServiceType.DATASTATE_ACTION);
   const uiSchema = eventService?.emit(eventServiceType.UISCHEMA);
 
   const apiConfig =
@@ -38,16 +38,21 @@ const handleCreateAndNavigate = async (
     appActions?.loadValidation(validationResult.schemaInvalidMessages),
   );
 
-  if (validationResult.isSchemaValid) {
-    await AppDependenceyProvider.getInstance()
-      .getViewModelHandler()
-      ?.createModel(
-        actionInvokerProps.viewModel.screenData,
-        apiConfig,
-        eventService,
-      );
+  if (!validationResult.isSchemaValid) return;
 
-    handleNavigation(actionInvokerProps);
-  }
+  await AppDependenceyProvider.getInstance()
+    .getViewModelHandler()
+    ?.createModel(
+      actionInvokerProps.viewModel.screenData,
+      apiConfig,
+      eventService,
+    );
+
+  // The response interceptor pushes server-side field errors into
+  // state.validation via FieldValidationDispatcher. Don't navigate away
+  // from a form the user still has to fix.
+  if (hasFieldValidationErrors(eventService)) return;
+
+  handleNavigation(actionInvokerProps);
 };
 export default handleCreateAndNavigate;

package/src/Action/StandardActions/handleUpdateAndNavigate.ts

@@ -5,13 +5,13 @@ import { validateUiElementSchema } from "../helpers/validateUiElementSchema";
 import { ActionInvokerProperties } from "../Types";
 import handleNavigation from "./handleNavigation";
 import { appActions } from "../../Store/Slices/appSlice";
+import { hasFieldValidationErrors } from "../helpers/hasFieldValidationErrors";
 
 const handleUpdateAndNavigate = async (
   actionInvokerProps: ActionInvokerProperties
 ) => {
   const eventService = actionInvokerProps.eventService;
   const dispatch = eventService?.emit(eventServiceType.DISPATCH_STORE);
-  // const appActions = eventService?.emit(eventServiceType.DATASTATE_ACTION);
   const uiSchema = eventService?.emit(eventServiceType.UISCHEMA);
 
   const apiConfig =
@@ -38,16 +38,21 @@ const handleUpdateAndNavigate = async (
     appActions?.loadValidation(validationResult.schemaInvalidMessages)
   );
 
-  if (validationResult.isSchemaValid) {
-    await AppDependenceyProvider.getInstance()
-      .getViewModelHandler()
-      ?.updateModel(
-        actionInvokerProps.viewModel.screenData,
-        apiConfig,
-        eventService
-      );
+  if (!validationResult.isSchemaValid) return;
 
-    handleNavigation(actionInvokerProps);
-  }
+  await AppDependenceyProvider.getInstance()
+    .getViewModelHandler()
+    ?.updateModel(
+      actionInvokerProps.viewModel.screenData,
+      apiConfig,
+      eventService
+    );
+
+  // The response interceptor pushes server-side field errors into
+  // state.validation via FieldValidationDispatcher. Don't navigate away
+  // from a form the user still has to fix.
+  if (hasFieldValidationErrors(eventService)) return;
+
+  handleNavigation(actionInvokerProps);
 };
 export default handleUpdateAndNavigate;

package/src/Action/helpers/hasFieldValidationErrors.ts

@@ -0,0 +1,16 @@
+import { eventServiceType } from "../../Constant";
+import { EventService } from "../../Services/EventService";
+
+// Reads the latest `state.app.validation` slice and returns true if any field
+// currently carries one or more error messages. Used by save/update actions to
+// skip navigation when server-side field validation has populated errors after
+// the API call resolved.
+export const hasFieldValidationErrors = (
+  eventService: EventService | undefined,
+): boolean => {
+  const appState = eventService?.emit(eventServiceType.APP_STATE);
+  const validation = (appState?.validation ?? {}) as Record<string, string[]>;
+  return Object.values(validation).some(
+    (messages) => Array.isArray(messages) && messages.length > 0,
+  );
+};

package/src/ApplicationStart/AppDependenceyProvider.ts

@@ -5,6 +5,9 @@ import { IViewModelHandler } from "../DataModel/IViewModelHandler";
 import defaultResponseFormatter, {
   ResponseFormat,
 } from "../Services/helpers/coreResponseFormatter";
+import defaultFieldErrorMapper, {
+  FieldErrorMapper,
+} from "../Services/helpers/defaultFieldErrorMapper";
 import defaultSchemaBySlugService from "../Services/SchemaService";
 
 class UninitializedInstanceException extends Error {
@@ -25,6 +28,7 @@ export class AppDependenceyProvider {
   private _responseFormatter?:
     | ((data: any, status: number) => ResponseFormat)
     | undefined;
+  private _fieldErrorMapper?: FieldErrorMapper;
 
   private static instance: AppDependenceyProvider;
 
@@ -37,6 +41,7 @@ export class AppDependenceyProvider {
     requestHeaders,
     getSchemaBySlugService,
     responseFormatter,
+    fieldErrorMapper,
   }: any) {
     this._adapterProvider = adapterProvider;
     this._viewModelHandler = viewModelHandler;
@@ -46,6 +51,7 @@ export class AppDependenceyProvider {
     this._requestHeaders = requestHeaders;
     this._getSchemaBySlugService = getSchemaBySlugService;
     this._responseFormatter = responseFormatter;
+    this._fieldErrorMapper = fieldErrorMapper;
   }
 
   public static initInstance = ({
@@ -57,6 +63,7 @@ export class AppDependenceyProvider {
     requestHeaders,
     getSchemaBySlugService,
     responseFormatter,
+    fieldErrorMapper,
   }: any) => {
     if (!AppDependenceyProvider.instance)
       AppDependenceyProvider.instance = new AppDependenceyProvider({
@@ -68,6 +75,7 @@ export class AppDependenceyProvider {
         requestHeaders,
         getSchemaBySlugService,
         responseFormatter,
+        fieldErrorMapper,
       });
   };
 
@@ -115,4 +123,9 @@ export class AppDependenceyProvider {
     if (!this._responseFormatter) return defaultResponseFormatter;
     return this._responseFormatter;
   };
+
+  public getFieldErrorMapper = (): FieldErrorMapper => {
+    if (!this._fieldErrorMapper) return defaultFieldErrorMapper;
+    return this._fieldErrorMapper;
+  };
 }

package/src/ApplicationStart/HOC/FieldValidationDispatcher.ts

@@ -0,0 +1,21 @@
+type FieldErrors = Record<string, string[]>;
+type Handler = (errors: FieldErrors) => void;
+
+class FieldValidationDispatcher {
+  private static handler?: Handler;
+
+  static registerHandler(handler: Handler) {
+    FieldValidationDispatcher.handler = handler;
+  }
+
+  static dispatch(errors: FieldErrors) {
+    if (FieldValidationDispatcher.handler) {
+      FieldValidationDispatcher.handler(errors);
+    } else {
+      console.warn("Field validation dispatcher handler not registered.");
+    }
+  }
+}
+
+export default FieldValidationDispatcher;
+export type { FieldErrors };

package/src/ApplicationStart/helper/setupStoreAction.ts

@@ -2,23 +2,34 @@ import { eventServiceType, LoadingStatus } from "../../Constant";
 import { appActions } from "../../Store/Slices/appSlice";
 import { metaDataActions } from "../../Store/Slices/metaDataSlice";
 import { commonDataActions } from "../../Store/Slices/commonDataSlice";
+import FieldValidationDispatcher, {
+  FieldErrors,
+} from "../HOC/FieldValidationDispatcher";
 
 let globalEventService: any = null;
 
 const setupStoreAction = (dispatch: any, eventService: any, store: any) => {
   globalEventService = eventService;
-  
+
   const actions = {
     [eventServiceType.DATASTATE_ACTION]: appActions,
     [eventServiceType.UI_SCHEMA_ACTION]: metaDataActions,
     [eventServiceType.DISPATCH_STORE]: dispatch,
     [eventServiceType.DATASTATE]: () => store.getState().app.viewModel,
+    [eventServiceType.APP_STATE]: () => store.getState().app,
   };
 
   Object.entries(actions).forEach(([eventType, action]) => {
     eventService?.subscribe(eventType, () => action);
   });
 
+  // Route server-side field validation errors (alertType=fieldvalidation,
+  // typically 422) into the same redux slice the client validator writes to,
+  // so withValidations can render them under the relevant fields.
+  FieldValidationDispatcher.registerHandler((errors: FieldErrors) => {
+    dispatch(appActions.loadValidation(errors));
+  });
+
   // Register loader handlers for external services
   eventService?.subscribe(eventServiceType.REQUEST_START, () => () => {
     dispatch(commonDataActions.updatePendingRequests(LoadingStatus.INPROCESS));

package/src/Constant.ts

@@ -33,6 +33,7 @@ export const eventServiceType = {
   UI_SCHEMA_ACTION: "UI_SCHEMA_ACTION",
   UISCHEMA: "UISCHEMA",
   DATASTATE: "DATASTATE",
+  APP_STATE: "APP_STATE",
   REQUEST_START: "REQUEST_START",
   REQUEST_END: "REQUEST_END",
 };