@zohodesk/library-platform 1.2.0 → 1.2.2-exp.1

package/es/library/custom-component/frameworks/json-schema-validator/__tests__/Validator.test.js

@@ -0,0 +1,478 @@
+import Validator from "../Validator"; // Schemas extracted from src/cc/table-connected/Properties.ts
+
+const preferencesSchema = {
+  type: 'object',
+  properties: {
+    rowActions: {
+      type: 'object',
+      additionalProperties: {
+        width: {
+          type: 'string'
+        }
+      }
+    },
+    fields: {
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        properties: {
+          initialWidth: {
+            type: 'number'
+          },
+          currencyLocale: {
+            type: 'string'
+          },
+          currencySymbol: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    autoColumnSizing: {
+      type: 'boolean'
+    }
+  }
+};
+const moduleNameSchema = {
+  type: 'string'
+};
+const textOverflowConfigSchema = {
+  type: 'object',
+  properties: {
+    isEnabled: {
+      type: 'boolean'
+    },
+    mode: {
+      type: 'string',
+      enum: ['clip', 'wrap']
+    }
+  }
+};
+const nameFieldsConfigSchema = {
+  type: 'object'
+};
+const componentMappingSchema = {
+  type: 'object',
+  properties: {
+    fields: {
+      type: 'object'
+    },
+    rowActionsComponentName: {
+      type: 'string'
+    },
+    emptyState: {
+      type: 'string'
+    }
+  }
+};
+const selectionConfigSchema = {
+  type: 'object',
+  properties: {
+    isEnabled: {
+      type: 'boolean'
+    },
+    maxSelectionCount: {
+      type: 'number'
+    },
+    limitExceedAlertMessage: {
+      type: 'string'
+    },
+    isSelectAllEnabled: {
+      type: 'boolean'
+    }
+  }
+};
+describe('Validator', () => {
+  describe('validate() — direct schema (no schema.schema)', () => {
+    it('should return valid for a correct object value', () => {
+      const result = Validator.validate(preferencesSchema, {
+        fields: {},
+        autoColumnSizing: false
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+    it('should return invalid when a property has wrong type', () => {
+      const result = Validator.validate(preferencesSchema, {
+        fields: 'not-an-object',
+        autoColumnSizing: false
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid for a correct string value', () => {
+      const result = Validator.validate(moduleNameSchema, 'deals');
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return invalid when string expected but number given', () => {
+      const result = Validator.validate(moduleNameSchema, 123);
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid for a value matching an enum', () => {
+      const result = Validator.validate(textOverflowConfigSchema, {
+        isEnabled: true,
+        mode: 'clip'
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return invalid for a value not in enum', () => {
+      const result = Validator.validate(textOverflowConfigSchema, {
+        isEnabled: true,
+        mode: 'scroll'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors.some(e => e.keyword === 'enum')).toBe(true);
+    });
+    it('should return valid for nested object with additionalProperties', () => {
+      const result = Validator.validate(preferencesSchema, {
+        fields: {
+          name: {
+            initialWidth: 200,
+            currencyLocale: 'en-US'
+          }
+        },
+        autoColumnSizing: true
+      });
+      expect(result.isValid).toBe(true);
+    });
+    it('should return invalid for nested additionalProperties with wrong type', () => {
+      const result = Validator.validate(preferencesSchema, {
+        fields: {
+          name: {
+            initialWidth: 'wide'
+          }
+        }
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid for a loose object schema with any object', () => {
+      const result = Validator.validate(nameFieldsConfigSchema, {
+        isEnabled: true,
+        isPreventDefault: false,
+        constructUrl: null,
+        extraProp: 'anything'
+      });
+      expect(result.isValid).toBe(true);
+    });
+    it('should return valid for selectionConfig with correct values', () => {
+      const result = Validator.validate(selectionConfigSchema, {
+        isEnabled: true,
+        maxSelectionCount: 50,
+        limitExceedAlertMessage: 'Maximum records selected',
+        isSelectAllEnabled: false
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return invalid for selectionConfig with wrong types', () => {
+      const result = Validator.validate(selectionConfigSchema, {
+        isEnabled: 'yes',
+        maxSelectionCount: 'fifty'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid for componentMapping with partial properties', () => {
+      const result = Validator.validate(componentMappingSchema, {
+        fields: {},
+        emptyState: 'NoDataComponent'
+      });
+      expect(result.isValid).toBe(true);
+    });
+    it('should return valid for an empty object when no properties are required', () => {
+      const result = Validator.validate(preferencesSchema, {});
+      expect(result.isValid).toBe(true);
+    });
+  });
+  describe('checkFunctionsRecursively() — function type handling', () => {
+    it('should return valid when value is a function for function type schema', () => {
+      const schema = {
+        type: 'function'
+      };
+      const result = Validator.validate(schema, () => {});
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return error when value is not a function for function type schema', () => {
+      const schema = {
+        type: 'function'
+      };
+      const result = Validator.validate(schema, 'not a function');
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
+        keyword: 'type',
+        params: {
+          type: 'function'
+        },
+        message: 'should be function'
+      })]));
+    });
+    it('should validate nested function property in object schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          onClick: {
+            type: 'function'
+          },
+          label: {
+            type: 'string'
+          }
+        }
+      };
+      const result = Validator.validate(schema, {
+        onClick: () => {},
+        label: 'Click me'
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return error with correct dataPath for nested function property', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          onClick: {
+            type: 'function'
+          },
+          label: {
+            type: 'string'
+          }
+        }
+      };
+      const result = Validator.validate(schema, {
+        onClick: 'not a function',
+        label: 'Click me'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
+        keyword: 'type',
+        dataPath: '.onClick',
+        schemaPath: '#/properties/onClick/type',
+        message: 'should be function'
+      })]));
+    });
+    it('should validate function items in array schema', () => {
+      const schema = {
+        type: 'array',
+        items: {
+          type: 'function'
+        }
+      };
+
+      const fn1 = () => {};
+
+      const fn2 = () => {};
+
+      const result = Validator.validate(schema, [fn1, fn2]);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+    it('should return error for non-function item in array of functions', () => {
+      const schema = {
+        type: 'array',
+        items: {
+          type: 'function'
+        }
+      };
+      const result = Validator.validate(schema, [() => {}, 'not a function']);
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
+        keyword: 'type',
+        dataPath: '.[1]',
+        message: 'should be function'
+      })]));
+    });
+    it('should validate deeply nested function in object > object', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          handlers: {
+            type: 'object',
+            properties: {
+              onMount: {
+                type: 'function'
+              }
+            }
+          }
+        }
+      };
+      const result = Validator.validate(schema, {
+        handlers: {
+          onMount: 42
+        }
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.errors).toEqual(expect.arrayContaining([expect.objectContaining({
+        dataPath: '.handlers.onMount',
+        schemaPath: '#/properties/handlers/properties/onMount/type'
+      })]));
+    });
+  });
+  describe('validatePropertySchema() — property schema path (schema.schema exists)', () => {
+    it('should return valid with key for required property provided with correct value', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: true,
+        name: 'moduleName',
+        schema: moduleNameSchema
+      };
+      const result = Validator.validate(propertySchema, 'deals');
+      expect(result.isValid).toBe(true);
+      expect(result.key).toBe('moduleName');
+      expect(result.errors).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+    it('should return invalid for required property provided with wrong type', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: true,
+        name: 'moduleName',
+        schema: moduleNameSchema
+      };
+      const result = Validator.validate(propertySchema, 123);
+      expect(result.isValid).toBe(false);
+      expect(result.key).toBe('moduleName');
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid with warning when required property missing but has default', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        defaultValue: {
+          isEnabled: true
+        },
+        name: 'keyboardControlsConfig',
+        schema: {
+          type: 'object',
+          properties: {
+            isEnabled: {
+              type: 'boolean'
+            }
+          }
+        }
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0].message).toContain('Default value will be used');
+    });
+    it('should return invalid when required property missing and no default', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        name: 'moduleName',
+        schema: moduleNameSchema
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].message).toContain('required but missing');
+    });
+    it('should return invalid when required property missing and default is undefined', () => {
+      const propertySchema = {
+        required: true,
+        isValueProvided: false,
+        defaultValue: undefined,
+        name: 'testProp',
+        schema: moduleNameSchema
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(false);
+      expect(result.errors[0].message).toContain('default value is undefined');
+    });
+    it('should return valid with no warnings for optional property not provided', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: false,
+        name: 'preferences',
+        defaultValue: {
+          fields: {},
+          autoColumnSizing: false
+        },
+        schema: preferencesSchema
+      };
+      const result = Validator.validate(propertySchema, undefined);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+    it('should return invalid for optional property provided with invalid value', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'textOverflowConfig',
+        schema: textOverflowConfigSchema
+      };
+      const result = Validator.validate(propertySchema, {
+        isEnabled: true,
+        mode: 'invalid'
+      });
+      expect(result.isValid).toBe(false);
+      expect(result.key).toBe('textOverflowConfig');
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+    it('should return valid for optional property provided with valid value', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'textOverflowConfig',
+        schema: textOverflowConfigSchema
+      };
+      const result = Validator.validate(propertySchema, {
+        isEnabled: true,
+        mode: 'wrap'
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.key).toBe('textOverflowConfig');
+    });
+    it('should validate componentMapping property schema with valid data', () => {
+      const propertySchema = {
+        required: false,
+        isValueProvided: true,
+        name: 'componentMapping',
+        defaultValue: {
+          fields: {},
+          emptyState: ''
+        },
+        schema: componentMappingSchema
+      };
+      const result = Validator.validate(propertySchema, {
+        fields: {
+          name: 'TextField'
+        },
+        rowActionsComponentName: 'RowActions',
+        emptyState: 'EmptyState'
+      });
+      expect(result.isValid).toBe(true);
+      expect(result.key).toBe('componentMapping');
+    });
+  });
+  describe('AJV useDefaults behavior', () => {
+    it('should fill in default values defined in schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          isEnabled: {
+            type: 'boolean',
+            default: true
+          },
+          mode: {
+            type: 'string',
+            default: 'clip'
+          }
+        }
+      };
+      const value = {};
+      const result = Validator.validate(schema, value);
+      expect(result.isValid).toBe(true);
+      expect(value.isEnabled).toBe(true);
+      expect(value.mode).toBe('clip');
+    });
+  });
+});

package/es/library/custom-component/frameworks/ui/DependencyFactory.js

@@ -4,12 +4,28 @@ import Controller from "../../adapters/controllers/Controller";
 import Repository from "../../adapters/gateways/repository/Repository";
 import Validator from "../json-schema-validator/Validator";
 import EventManager from "../../adapters/gateways/event-manager/EventManager";
+// One-time registration of precompiled validators
+let precompiledRegistered = false;
+
+function ensurePrecompiledRegistered() {
+  if (precompiledRegistered) return;
+  precompiledRegistered = true;
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const registry = require("../json-schema-validator/__generated__/registry");
+
+    Validator.registerPrecompiled(registry.default || registry);
+  } catch (e) {// __generated__ not available (e.g., first build) — runtime fallback
+  }
+}
 
 class DependencyFactory {
   static create(_ref, input) {
     let {
       updateState
     } = _ref;
+    ensurePrecompiledRegistered();
     const repository = new Repository();
     const presenter = new Presenter({
       updateState

package/es/platform/client-actions/behaviour/zclient-actions/adapters/presenters/FilterUtils.js

@@ -0,0 +1,11 @@
+function validateClientActionLocation(actualLocation, expectedLocation) {
+  return actualLocation === expectedLocation || actualLocation.endsWith(`.${expectedLocation}`);
+}
+
+function validateClientAction(clientAction, location) {
+  return clientAction.location && validateClientActionLocation(clientAction.location, location);
+}
+
+export function filterClientActionsByLocation(clientActions, location) {
+  return clientActions.filter(clientAction => clientAction && validateClientAction(clientAction, location));
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/resources/ClientActionsFetchSDK.js

@@ -0,0 +1,76 @@
+import FetchGateWay from "../../../../../zhttp/adapters/gateway/FetchGateWay";
+import APITemplate from "../../../../../zdata-source/domain/entities/APITemplate";
+import getClientActions from "../../../../../data-source/http-template/getPageClientActions";
+import TemplateHelpers from "../../../../../zdata-source/adapters/gateways/TemplateHelpers";
+
+//TODO: Remove this SDK when smart page is ready for production
+// Use this SDK only for fetching client actions at page level in desk_client_app until smart page is ready
+class ClientActionsFetchSDK {
+  getClientActionsAPIDetails(args) {
+    const apiTemplate = new APITemplate(getClientActions, new TemplateHelpers());
+    const apiArgs = { ...args,
+      servicePrefix: 'supportapi/zd',
+      // @ts-ignore - custom property
+      orgName: window.currentOrg.portalName
+    };
+    const apiDetailsModel = apiTemplate.getApiDetails(apiArgs);
+    return { ...apiDetailsModel,
+      options: {
+        headers: {
+          // @ts-ignore - custom property
+          orgId: window.currentOrg.id
+        },
+        method: apiDetailsModel.method
+      }
+    };
+  }
+
+  mapClientActionsByInstanceLocation(clientActions) {
+    const filteredClientActionsMap = new Map();
+
+    for (const clientAction of clientActions) {
+      const {
+        location,
+        component
+      } = clientAction;
+      const locationPathArr = location.split('.');
+      const instanceName = locationPathArr[1] || component;
+      const locationName = locationPathArr[2] || location;
+
+      if (!instanceName || !locationName) {
+        continue;
+      }
+
+      if (!filteredClientActionsMap.has(instanceName)) {
+        filteredClientActionsMap.set(instanceName, {});
+      }
+
+      const instanceActions = filteredClientActionsMap.get(instanceName);
+
+      if (!instanceActions[locationName]) {
+        instanceActions[locationName] = [];
+      }
+
+      instanceActions[locationName].push(clientAction);
+    }
+
+    return filteredClientActionsMap;
+  }
+
+  async fetchClientActions(params) {
+    const apiDetails = this.getClientActionsAPIDetails(params);
+    const fetchGateway = new FetchGateWay(window.fetch.bind(window));
+    return new Promise((resolve, reject) => {
+      fetchGateway.fetch(apiDetails.url, apiDetails.options).then(response => response.json()).then(clientActions => {
+        this.clientActions = clientActions;
+        const filteredClientActionsMap = this.mapClientActionsByInstanceLocation(this.clientActions);
+        return resolve(filteredClientActionsMap);
+      }).catch(err => {
+        reject(err);
+      });
+    });
+  }
+
+}
+
+export default ClientActionsFetchSDK;

package/es/platform/client-actions/behaviour/zclient-actions/applications/interfaces/ClientActionsAPIGatewayParams.js

@@ -0,0 +1 @@
+export {};

package/es/platform/client-actions/behaviour/zclient-actions/applications/interfaces/ClientActionsFetchSDKParams.js

@@ -0,0 +1,10 @@
+var ClientActionPage = /*#__PURE__*/function (ClientActionPage) {
+  ClientActionPage["LIST"] = "list";
+  ClientActionPage["DETAILS"] = "details";
+  ClientActionPage["CREATE_PAGE"] = "createPage";
+  ClientActionPage["EDIT_PAGE"] = "editPage";
+  ClientActionPage["ALL_PAGES"] = "allPages";
+  return ClientActionPage;
+}(ClientActionPage || {});
+
+export {};

package/es/platform/client-actions/cc/action-event-mediator/Properties.js

@@ -1,5 +1,19 @@
-import { ActionViewGap } from "../../components/interfaces/ActionViewModel";
-import { clientScriptsSchema } from "../../../client-scripts/cc/zclient-scripts-execution/clientScriptsSchema";
+// OPTIMIZE: Duplicated clientScriptsSchema in cc/table-list/row/Properties.ts
+const clientScriptsSchema = {
+  type: 'array',
+  minItems: 0,
+  items: {
+    type: 'object',
+    properties: {
+      targetEventName: {
+        type: 'string'
+      },
+      clientScript: {
+        type: 'string'
+      }
+    }
+  }
+};
 export const actionSchema = {
   type: 'object',
   properties: {
@@ -104,11 +118,11 @@ export default {
   },
   gap: {
     required: false,
-    defaultValue: ActionViewGap.NONE,
+    defaultValue: 'none',
     typeMetadata: {
       schema: {
         type: 'string',
-        enum: Object.values(ActionViewGap)
+        enum: ['none', 'small', 'xmedium', 'medium', 'large', 'xlarge']
       }
     }
   }

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/resources/ClientScriptsFetchSDK.js

@@ -0,0 +1,43 @@
+import APITemplate from "../../../../../zdata-source/domain/entities/APITemplate";
+import TemplateHelpers from "../../../../../zdata-source/adapters/gateways/TemplateHelpers";
+import FetchGateWay from "../../../../../zhttp/adapters/gateway/FetchGateWay";
+import getClientScripts from "../../../../../data-source/http-template/getClientScripts";
+
+//TODO: Remove this SDK when smart page is ready for production
+// Use this SDK only for fetching client actions at page level in desk_client_app until smart page is ready
+class ClientScriptsFetchSDK {
+  getClientScriptsAPIDetails(args) {
+    const apiTemplate = new APITemplate(getClientScripts, new TemplateHelpers());
+    const apiArgs = { ...args,
+      servicePrefix: 'supportapi/zd',
+      // @ts-ignore - custom property
+      orgName: window.currentOrg.portalName
+    };
+    const apiDetailsModel = apiTemplate.getApiDetails(apiArgs);
+    return { ...apiDetailsModel,
+      options: {
+        headers: {
+          // @ts-ignore - custom property
+          orgId: window.currentOrg.id
+        },
+        method: apiDetailsModel.method
+      }
+    };
+  }
+
+  async fetchClientScripts(params) {
+    const apiDetails = this.getClientScriptsAPIDetails(params);
+    const fetchGateway = new FetchGateWay(window.fetch.bind(window));
+    return new Promise((resolve, reject) => {
+      fetchGateway.fetch(apiDetails.url, apiDetails.options).then(response => response.json()).then(clientScripts => {
+        this.clientScripts = clientScripts;
+        return resolve(clientScripts);
+      }).catch(err => {
+        reject(err);
+      });
+    });
+  }
+
+}
+
+export default ClientScriptsFetchSDK;

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/interfaces/ClientScriptsAPIGatewayParams.js

@@ -0,0 +1 @@
+export {};

package/es/platform/client-scripts/behaviour/zclient-scripts-fetch/applications/interfaces/ClientScriptsSDKFetchParams.js

@@ -0,0 +1 @@
+export {};