procode-lowcode-core 1.0.10 → 1.0.11

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

@@ -1,7 +1,15 @@
 export declare enum StandardValidationType {
     REQUIRED = "REQUIRED",
     EMAIL = "EMAIL",
-    BULK_EMAIL = "BULK_EMAIL"
+    BULK_EMAIL = "BULK_EMAIL",
+    MIN_CHAR_COUNT = "MIN_CHAR_COUNT",
+    MAX_CHAR_COUNT = "MAX_CHAR_COUNT",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_EQUAL = "GREATER_THAN_EQUAL",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_EQUAL = "LESS_THAN_EQUAL",
+    BETWEEN = "BETWEEN",
+    NOT_BETWEEN = "NOT_BETWEEN"
 }
 export type ValidationFcResponse = {
     isValid: boolean;

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { ViewModel } from "../../DataModel/ViewModel";
+export type CompareDataType = "number" | "date" | "list";
+/**
+ * Resolves a comparison value from either a static param or a field path in the viewModel.
+ * fieldPath takes priority over static value when both are provided.
+ */
+export declare const resolveCompareValue: (staticValue: any, fieldPath: string | undefined, viewModel: ViewModel) => any;
+/**
+ * Parses a raw value into a comparable numeric representation based on dataType.
+ * Returns null if the value cannot be parsed.
+ */
+export declare const parseValue: (raw: any, dataType: CompareDataType) => number | null;
+/**
+ * Formats a raw value for display in validation messages.
+ */
+export declare const formatValueForMessage: (raw: any, dataType: CompareDataType) => string;
+/**
+ * Checks if a raw value is empty (null, undefined, or empty string).
+ */
+export declare const isEmpty: (value: any) => boolean;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -13,6 +13,7 @@ export type Validation = {
     executeMode: ExecuteMode;
     disabled: boolean;
     screenDataField?: string;
+    params?: Record<string, any>;
 };
 export type ValidationInvokerProperties = {
     validations: Validation[];

package/package.json

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

package/src/Action/StandardActions/handleAPICreate.ts

@@ -3,16 +3,31 @@ import { eventServiceType } from "../../Constant";
 import { ActionInvokerProperties } from "../Types";
 import { AppDependenceyProvider } from "../../ApplicationStart/AppDependenceyProvider";
 
+const replaceEndPointParams = (endPoint: string, data: any): string => {
+  if (!endPoint || !data || typeof data !== "object") return endPoint;
+  return endPoint.replace(/:([a-zA-Z0-9_]+)/g, (match, paramName) => {
+    return data[paramName] !== undefined && data[paramName] !== null
+      ? encodeURIComponent(String(data[paramName]))
+      : match;
+  });
+};
+
 const handleAPICreate = async (
   actionInvokerProps: ActionInvokerProperties,
-  data: any | any[]
+  data: any | any[],
 ) => {
   const eventService = actionInvokerProps.eventService;
   const uiSchema = eventService?.emit(eventServiceType.UISCHEMA);
-  const apiConfig =
-    actionInvokerProps.actionProps.config.apiConfig ??
-    _.cloneDeep(uiSchema.apiConfig);
+  const apiConfig = _.cloneDeep(
+    actionInvokerProps.actionProps.config.apiConfig ?? uiSchema.apiConfig,
+  );
 
+  if (apiConfig?.create?.endPoint && data) {
+    apiConfig.create.endPoint = replaceEndPointParams(
+      apiConfig.create.endPoint,
+      Array.isArray(data) ? data[0] : data,
+    );
+  }
   const response = await AppDependenceyProvider.getInstance()
     .getViewModelHandler()
     ?.createModel(data, apiConfig, eventService);

package/src/Validation/IValidationFactory.ts

@@ -2,6 +2,14 @@ export enum StandardValidationType {
   REQUIRED = "REQUIRED",
   EMAIL = "EMAIL",
   BULK_EMAIL = "BULK_EMAIL",
+  MIN_CHAR_COUNT = "MIN_CHAR_COUNT",
+  MAX_CHAR_COUNT = "MAX_CHAR_COUNT",
+  GREATER_THAN = "GREATER_THAN",
+  GREATER_THAN_EQUAL = "GREATER_THAN_EQUAL",
+  LESS_THAN = "LESS_THAN",
+  LESS_THAN_EQUAL = "LESS_THAN_EQUAL",
+  BETWEEN = "BETWEEN",
+  NOT_BETWEEN = "NOT_BETWEEN",
 }
 
 export type ValidationFcResponse = { isValid: boolean; message: string };

package/src/Validation/StandardValidations/StandardValidationFactory.ts

@@ -1,8 +1,16 @@
 import IValidationFactory, {
   StandardValidationType,
 } from "../IValidationFactory";
+import { betweenValidation } from "./betweenValidation";
 import { emailBulkValidation } from "./emailBulkValidation";
 import { emailValidation } from "./emailValidation";
+import { greaterThanEqualValidation } from "./greaterThanEqualValidation";
+import { greaterThanValidation } from "./greaterThanValidation";
+import { lessThanEqualValidation } from "./lessThanEqualValidation";
+import { lessThanValidation } from "./lessThanValidation";
+import { maxCharCountValidation } from "./maxCharCountValidation";
+import { minCharCountValidation } from "./minCharCountValidation";
+import { notBetweenValidation } from "./notBetweenValidation";
 import { requiredValidation } from "./requiredValidation";
 
 class StandardValidationFactory implements IValidationFactory {
@@ -10,6 +18,14 @@ class StandardValidationFactory implements IValidationFactory {
     [StandardValidationType.REQUIRED]: requiredValidation,
     [StandardValidationType.EMAIL]: emailValidation,
     [StandardValidationType.BULK_EMAIL]: emailBulkValidation,
+    [StandardValidationType.MIN_CHAR_COUNT]: minCharCountValidation,
+    [StandardValidationType.MAX_CHAR_COUNT]: maxCharCountValidation,
+    [StandardValidationType.GREATER_THAN]: greaterThanValidation,
+    [StandardValidationType.GREATER_THAN_EQUAL]: greaterThanEqualValidation,
+    [StandardValidationType.LESS_THAN]: lessThanValidation,
+    [StandardValidationType.LESS_THAN_EQUAL]: lessThanEqualValidation,
+    [StandardValidationType.BETWEEN]: betweenValidation,
+    [StandardValidationType.NOT_BETWEEN]: notBetweenValidation,
   };
 
   getValidationFc(key: StandardValidationType) {

package/src/Validation/StandardValidations/betweenValidation.ts

@@ -0,0 +1,62 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const betweenValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const {
+    minValue,
+    minFieldPath,
+    maxValue,
+    maxFieldPath,
+    dataType = "number",
+  } = validation.params || {};
+
+  if (minValue === undefined && !minFieldPath) {
+    console.error(
+      "BETWEEN validation requires 'minValue' or 'minFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: min boundary is missing" };
+  }
+
+  if (maxValue === undefined && !maxFieldPath) {
+    console.error(
+      "BETWEEN validation requires 'maxValue' or 'maxFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: max boundary is missing" };
+  }
+
+  if (isEmpty(value)) return { isValid: true, message: "" };
+
+  const rawMin = resolveCompareValue(minValue, minFieldPath, viewModel);
+  const rawMax = resolveCompareValue(maxValue, maxFieldPath, viewModel);
+
+  if (isEmpty(rawMin) || isEmpty(rawMax)) return { isValid: true, message: "" };
+
+  const parsedValue = parseValue(value, dataType);
+  const parsedMin = parseValue(rawMin, dataType);
+  const parsedMax = parseValue(rawMax, dataType);
+
+  if (parsedValue === null || parsedMin === null || parsedMax === null) {
+    return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+  }
+
+  const isValid = parsedValue >= parsedMin && parsedValue <= parsedMax;
+  const minLabel = formatValueForMessage(rawMin, dataType);
+  const maxLabel = formatValueForMessage(rawMax, dataType);
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message ||
+        `Value must be between ${minLabel} and ${maxLabel}`,
+  };
+};

package/src/Validation/StandardValidations/comparisonValidationHelper.ts

@@ -0,0 +1,74 @@
+import { ViewModel } from "../../DataModel/ViewModel";
+import { getValueFromNestedObject } from "../../Utils/getValueFromNestedObject";
+
+export type CompareDataType = "number" | "date" | "list";
+
+/**
+ * Resolves a comparison value from either a static param or a field path in the viewModel.
+ * fieldPath takes priority over static value when both are provided.
+ */
+export const resolveCompareValue = (
+  staticValue: any,
+  fieldPath: string | undefined,
+  viewModel: ViewModel
+): any => {
+  if (fieldPath) {
+    return getValueFromNestedObject(fieldPath, viewModel);
+  }
+  return staticValue;
+};
+
+/**
+ * Parses a raw value into a comparable numeric representation based on dataType.
+ * Returns null if the value cannot be parsed.
+ */
+export const parseValue = (
+  raw: any,
+  dataType: CompareDataType
+): number | null => {
+  if (raw === null || raw === undefined || raw === "") return null;
+
+  if (dataType === "number") {
+    const num = Number(raw);
+    return isNaN(num) ? null : num;
+  }
+
+  if (dataType === "date") {
+    const timestamp = new Date(raw).getTime();
+    return isNaN(timestamp) ? null : timestamp;
+  }
+
+  if (dataType === "list") {
+    if (Array.isArray(raw)) return raw.length;
+    const num = Number(raw);
+    return isNaN(num) ? null : num;
+  }
+
+  return null;
+};
+
+/**
+ * Formats a raw value for display in validation messages.
+ */
+export const formatValueForMessage = (
+  raw: any,
+  dataType: CompareDataType
+): string => {
+  if (dataType === "date") {
+    const date = new Date(raw);
+    return isNaN(date.getTime()) ? String(raw) : date.toLocaleDateString();
+  }
+  if (dataType === "list") {
+    return `${raw} item${Number(raw) === 1 ? "" : "s"}`;
+  }
+  return String(raw);
+};
+
+/**
+ * Checks if a raw value is empty (null, undefined, or empty string).
+ */
+export const isEmpty = (value: any): boolean =>
+  value === null ||
+  value === undefined ||
+  value === "" ||
+  (Array.isArray(value) && value.length === 0);

package/src/Validation/StandardValidations/greaterThanEqualValidation.ts

@@ -0,0 +1,49 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const greaterThanEqualValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const { compareValue, compareFieldPath, dataType = "number" } =
+    validation.params || {};
+
+  if (compareValue === undefined && !compareFieldPath) {
+    console.error(
+      "GREATER_THAN_EQUAL validation requires 'compareValue' or 'compareFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+  }
+
+  if (isEmpty(value)) return { isValid: true, message: "" };
+
+  const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+
+  if (isEmpty(rawCompare)) return { isValid: true, message: "" };
+
+  const parsedValue = parseValue(value, dataType);
+  const parsedCompare = parseValue(rawCompare, dataType);
+
+  if (parsedValue === null || parsedCompare === null) {
+    return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+  }
+
+  const isValid = parsedValue >= parsedCompare;
+  const compareLabel = compareFieldPath
+    ? formatValueForMessage(rawCompare, dataType)
+    : formatValueForMessage(compareValue, dataType);
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message ||
+        `Value must be greater than or equal to ${compareLabel}`,
+  };
+};

package/src/Validation/StandardValidations/greaterThanValidation.ts

@@ -0,0 +1,48 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const greaterThanValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const { compareValue, compareFieldPath, dataType = "number" } =
+    validation.params || {};
+
+  if (compareValue === undefined && !compareFieldPath) {
+    console.error(
+      "GREATER_THAN validation requires 'compareValue' or 'compareFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+  }
+
+  if (isEmpty(value)) return { isValid: true, message: "" };
+
+  const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+
+  if (isEmpty(rawCompare)) return { isValid: true, message: "" };
+
+  const parsedValue = parseValue(value, dataType);
+  const parsedCompare = parseValue(rawCompare, dataType);
+
+  if (parsedValue === null || parsedCompare === null) {
+    return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+  }
+
+  const isValid = parsedValue > parsedCompare;
+  const compareLabel = compareFieldPath
+    ? formatValueForMessage(rawCompare, dataType)
+    : formatValueForMessage(compareValue, dataType);
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message || `Value must be greater than ${compareLabel}`,
+  };
+};

package/src/Validation/StandardValidations/lessThanEqualValidation.ts

@@ -0,0 +1,49 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const lessThanEqualValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const { compareValue, compareFieldPath, dataType = "number" } =
+    validation.params || {};
+
+  if (compareValue === undefined && !compareFieldPath) {
+    console.error(
+      "LESS_THAN_EQUAL validation requires 'compareValue' or 'compareFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+  }
+
+  if (isEmpty(value)) return { isValid: true, message: "" };
+
+  const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+
+  if (isEmpty(rawCompare)) return { isValid: true, message: "" };
+
+  const parsedValue = parseValue(value, dataType);
+  const parsedCompare = parseValue(rawCompare, dataType);
+
+  if (parsedValue === null || parsedCompare === null) {
+    return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+  }
+
+  const isValid = parsedValue <= parsedCompare;
+  const compareLabel = compareFieldPath
+    ? formatValueForMessage(rawCompare, dataType)
+    : formatValueForMessage(compareValue, dataType);
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message ||
+        `Value must be less than or equal to ${compareLabel}`,
+  };
+};

package/src/Validation/StandardValidations/lessThanValidation.ts

@@ -0,0 +1,48 @@
+import { ValidationFcProperties } from "../Types";
+import {
+  resolveCompareValue,
+  parseValue,
+  formatValueForMessage,
+  isEmpty,
+} from "./comparisonValidationHelper";
+
+export const lessThanValidation = ({
+  validation,
+  viewModel,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const { compareValue, compareFieldPath, dataType = "number" } =
+    validation.params || {};
+
+  if (compareValue === undefined && !compareFieldPath) {
+    console.error(
+      "LESS_THAN validation requires 'compareValue' or 'compareFieldPath' in params"
+    );
+    return { isValid: false, message: "Validation misconfigured: comparison value is missing" };
+  }
+
+  if (isEmpty(value)) return { isValid: true, message: "" };
+
+  const rawCompare = resolveCompareValue(compareValue, compareFieldPath, viewModel);
+
+  if (isEmpty(rawCompare)) return { isValid: true, message: "" };
+
+  const parsedValue = parseValue(value, dataType);
+  const parsedCompare = parseValue(rawCompare, dataType);
+
+  if (parsedValue === null || parsedCompare === null) {
+    return { isValid: false, message: validation.message || `Invalid ${dataType} value` };
+  }
+
+  const isValid = parsedValue < parsedCompare;
+  const compareLabel = compareFieldPath
+    ? formatValueForMessage(rawCompare, dataType)
+    : formatValueForMessage(compareValue, dataType);
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message || `Value must be less than ${compareLabel}`,
+  };
+};

package/src/Validation/StandardValidations/maxCharCountValidation.ts

@@ -0,0 +1,27 @@
+import { ValidationFcProperties } from "../Types";
+
+export const maxCharCountValidation = ({
+  validation,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const maxCharCount = validation.params?.maxCharCount;
+
+  if (maxCharCount === undefined || maxCharCount === null) {
+    console.error("MAX_CHAR_COUNT validation requires 'maxCharCount' in params");
+    return { isValid: false, message: "Validation misconfigured: maxCharCount param is missing" };
+  }
+
+  if (value === null || value === undefined || value === "") {
+    return { isValid: true, message: "" };
+  }
+
+  const strValue = String(value);
+  const isValid = strValue.length <= maxCharCount;
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message || `Maximum ${maxCharCount} characters allowed`,
+  };
+};

package/src/Validation/StandardValidations/minCharCountValidation.ts

@@ -0,0 +1,27 @@
+import { ValidationFcProperties } from "../Types";
+
+export const minCharCountValidation = ({
+  validation,
+  value,
+}: ValidationFcProperties): { isValid: boolean; message: string } => {
+  const minCharCount = validation.params?.minCharCount;
+
+  if (minCharCount === undefined || minCharCount === null) {
+    console.error("MIN_CHAR_COUNT validation requires 'minCharCount' in params");
+    return { isValid: false, message: "Validation misconfigured: minCharCount param is missing" };
+  }
+
+  if (value === null || value === undefined || value === "") {
+    return { isValid: true, message: "" };
+  }
+
+  const strValue = String(value);
+  const isValid = strValue.length >= minCharCount;
+
+  return {
+    isValid,
+    message: isValid
+      ? ""
+      : validation.message || `Minimum ${minCharCount} characters required`,
+  };
+};