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

package/es/index.js

@@ -5,7 +5,9 @@ import ExternalConstants from "./cc/table-connected/constants/ExternalConstants"
 import ActionEventMediator from "./platform/client-actions/components/action-event-mediator/frameworks/ui/ActionEventMediator";
 import RowActionsRenderer from "./platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActions/RowActionsRenderer";
 import AdaptiveRowActionsRenderer from "./platform/client-actions/components/row-actions-renderer/frameworks/ui/AdaptiveRowActions/AdaptiveRowActionsRenderer";
-import ClientActionReordererRegistry from "./platform/client-actions/components/action-event-mediator/frameworks/ui/ClientActionReordererRegistry"; // Rebuild SmartTableConstants without Events
+import ClientActionReordererRegistry from "./platform/client-actions/components/action-event-mediator/frameworks/ui/ClientActionReordererRegistry";
+import ClientActionsFetchSDK from "./platform/client-actions/behaviour/zclient-actions/adapters/resources/ClientActionsFetchSDK";
+import ClientScriptsFetchSDK from "./platform/client-scripts/behaviour/zclient-scripts-fetch/adapters/resources/ClientScriptsFetchSDK"; // Rebuild SmartTableConstants without Events
 
 const SmartTableConstants = {
   ExternalConstants
@@ -40,4 +42,6 @@ export const Behaviours = {
   FieldSectionEventMappingBehaviourFactory
 };
 export * from "./library/analytics";
-export { ClientActionReordererRegistry };
+export { ClientActionReordererRegistry };
+export { ClientActionsFetchSDK };
+export { ClientScriptsFetchSDK };

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

@@ -1,164 +1 @@
-/* eslint-disable complexity */
-import Ajv from 'ajv';
-let jsonValidator = new Ajv({
-  useDefaults: true
-});
-
-class Validator {
-  static validate(schema, value) {
-    if (schema.schema) {
-      return Validator.validatePropertySchema(schema, value);
-    }
-
-    let errors = [];
-    Validator.checkFunctionsRecursively(schema, value, '', '#', errors); // Use AJV for the rest of the validation, ignoring functions
-
-    const ajvSchema = JSON.parse(JSON.stringify(schema, (key, val) => val === 'function' ? undefined : val)); // validate is a type guard for MyData - type is inferred from schema type
-    // const validate = jsonValidator.compile(schema);
-
-    const validate = jsonValidator.compile(ajvSchema);
-    const isValid = validate(value);
-
-    if (!isValid) {
-      // errors = validate.errors;
-      validate.errors && errors.push(...validate.errors);
-    }
-
-    return {
-      isValid: isValid && errors.length === 0,
-      errors,
-      warnings: []
-    };
-  }
-
-  static checkFunctionsRecursively(schema, value) {
-    let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-    let schemaPath = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '#';
-    let errors = arguments.length > 4 ? arguments[4] : undefined;
-
-    if (schema.type === 'function') {
-      if (typeof value !== 'function') {
-        errors.push({
-          keyword: 'type',
-          dataPath: path ? `.${path}` : '',
-          schemaPath: `${schemaPath}/type`,
-          params: {
-            type: 'function'
-          },
-          message: 'should be function'
-        });
-      }
-
-      return;
-    }
-
-    if (schema.type === 'object' && schema.properties && typeof value === 'object' && value !== null) {
-      for (const key in schema.properties) {
-        Validator.checkFunctionsRecursively(schema.properties[key], value[key], path ? `${path}.${key}` : key, `${schemaPath}/properties/${key}`, errors);
-      }
-    }
-
-    if (schema.type === 'array' && Array.isArray(value) && schema.items) {
-      value.forEach((item, index) => {
-        Validator.checkFunctionsRecursively(schema.items, item, `${path}[${index}]`, `${schemaPath}/items`, errors);
-      });
-    } // if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    //   const subErrors = [];
-    //   const valid = schema.anyOf.some((subSchema, idx) => {
-    //     const tmpErrors = [];
-    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/anyOf/${idx}`, tmpErrors);
-    //     return tmpErrors.length === 0;
-    //   });
-    //   if (!valid) {
-    //     errors.push({ keyword: "anyOf", dataPath: path ? `.${path}` : "", schemaPath: `${schemaPath}/anyOf`, params: {}, message: "should match some schema in anyOf" });
-    //   }
-    //   return;
-    // }
-    // if (schema.allOf && Array.isArray(schema.allOf)) {
-    //   schema.allOf.forEach((subSchema, idx) => {
-    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/allOf/${idx}`, errors);
-    //   });
-    //   return;
-    // }
-    // if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    //   let matchCount = 0;
-    //   schema.oneOf.forEach((subSchema, idx) => {
-    //     const tmpErrors = [];
-    //     Validator.checkFunctionsRecursively(subSchema, value, path, `${schemaPath}/oneOf/${idx}`, tmpErrors);
-    //     if (tmpErrors.length === 0) matchCount++;
-    //   });
-    //   if (matchCount !== 1) {
-    //     errors.push({ keyword: "oneOf", dataPath: path ? `.${path}` : "", schemaPath: `${schemaPath}/oneOf`, params: {}, message: "should match exactly one schema in oneOf" });
-    //   }
-    //   return;
-    // }
-
-  }
-
-  static validatePropertySchema(propertySchema, value) {
-    const {
-      schema
-    } = propertySchema;
-    const result = Validator.validateRequired(propertySchema, value);
-    const isProvided = propertySchema.isValueProvided;
-
-    if (result.isValid === false) {
-      return result;
-    }
-
-    if (!isProvided) {
-      return {
-        isValid: true,
-        errors: [],
-        warnings: result.warnings
-      };
-    }
-
-    const {
-      isValid,
-      errors,
-      warnings
-    } = Validator.validate(schema, value);
-    return {
-      key: propertySchema.name,
-      isValid,
-      errors,
-      warnings: [...result.warnings, ...warnings]
-    };
-  }
-
-  static validateRequired(propertySchema, value) {
-    const errors = [];
-    const warnings = [];
-    const isRequired = propertySchema.required === true;
-    const hasDefault = Object.prototype.hasOwnProperty.call(propertySchema, 'defaultValue');
-    const isProvided = propertySchema.isValueProvided;
-
-    if (!isProvided && isRequired) {
-      if (hasDefault) {
-        if (propertySchema.defaultValue === undefined) {
-          errors.push({
-            message: `is required but missing. So, default value is undefined.`
-          });
-        } else {
-          warnings.push({
-            message: `is required but missing. So, Default value will be used.`
-          });
-        }
-      } else {
-        errors.push({
-          message: `is required but missing. And, neither a value nor a default value is present.`
-        });
-      }
-    }
-
-    return {
-      isValid: errors.length === 0,
-      warnings,
-      errors
-    };
-  }
-
-}
-
-export default Validator;
+export { default } from "../../../json-schema-validator/Validator";

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

@@ -2,7 +2,7 @@ import Presenter from "../../adapters/presenters/Presenter";
 import Service from "../../adapters/gateways/service/Service";
 import Controller from "../../adapters/controllers/Controller";
 import Repository from "../../adapters/gateways/repository/Repository";
-import Validator from "../json-schema-validator/Validator";
+import { Validator } from "../../../json-schema-validator";
 import EventManager from "../../adapters/gateways/event-manager/EventManager";
 
 class DependencyFactory {

package/es/library/json-schema-validator/Validator.js

@@ -0,0 +1,338 @@
+/* eslint-disable complexity */
+export class Validator {
+  static validate(schema, value) {
+    if (schema.schema) {
+      return Validator.validatePropertySchema(schema, value);
+    }
+
+    const errors = [];
+    Validator.validateNode(schema, value, '', errors, schema.definitions || schema.$defs || {});
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings: []
+    };
+  }
+
+  static validateNode(schema, value, dataPath, errors, rootDefinitions) {
+    if (!schema || typeof schema !== 'object') return; // undefined is not a JSON type — skip validation (matches AJV behavior)
+
+    if (value === undefined) return; // $ref resolution
+
+    if (schema.$ref) {
+      const resolved = Validator.resolveRef(schema.$ref, rootDefinitions);
+
+      if (resolved) {
+        Validator.validateNode(resolved, value, dataPath, errors, rootDefinitions);
+      }
+
+      return;
+    } // Hoist definitions from nested schema to root
+
+
+    const definitions = schema.definitions || schema.$defs ? { ...rootDefinitions,
+      ...(schema.definitions || schema.$defs)
+    } : rootDefinitions; // anyOf
+
+    if (schema.anyOf) {
+      const anyOfValid = schema.anyOf.some(subSchema => {
+        const subErrors = [];
+        Validator.validateNode(subSchema, value, dataPath, subErrors, definitions);
+        return subErrors.length === 0;
+      });
+
+      if (!anyOfValid) {
+        errors.push({
+          keyword: 'anyOf',
+          dataPath,
+          message: 'should match at least one schema in anyOf'
+        });
+      }
+
+      return;
+    } // oneOf
+
+
+    if (schema.oneOf) {
+      const matchCount = schema.oneOf.filter(subSchema => {
+        const subErrors = [];
+        Validator.validateNode(subSchema, value, dataPath, subErrors, definitions);
+        return subErrors.length === 0;
+      }).length;
+
+      if (matchCount !== 1) {
+        errors.push({
+          keyword: 'oneOf',
+          dataPath,
+          message: 'should match exactly one schema in oneOf'
+        });
+      }
+
+      return;
+    } // not
+
+
+    if (schema.not) {
+      const notErrors = [];
+      Validator.validateNode(schema.not, value, dataPath, notErrors, definitions);
+
+      if (notErrors.length === 0) {
+        errors.push({
+          keyword: 'not',
+          dataPath,
+          message: 'should NOT match schema in not'
+        });
+      }
+
+      return;
+    } // type validation
+
+
+    if (schema.type) {
+      if (!Validator.checkType(schema.type, value)) {
+        const typeLabel = Array.isArray(schema.type) ? schema.type.join(',') : schema.type;
+        errors.push({
+          keyword: 'type',
+          dataPath,
+          message: `should be ${typeLabel}`
+        });
+        return; // Type mismatch — skip further checks
+      }
+    } // enum
+
+
+    if (schema.enum) {
+      if (!schema.enum.includes(value)) {
+        errors.push({
+          keyword: 'enum',
+          dataPath,
+          message: `should be one of ${JSON.stringify(schema.enum)}`
+        });
+      }
+    } // String constraints
+
+
+    if (typeof value === 'string') {
+      if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+          keyword: 'minLength',
+          dataPath,
+          message: `should have at least ${schema.minLength} characters`
+        });
+      }
+
+      if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+          keyword: 'maxLength',
+          dataPath,
+          message: `should have at most ${schema.maxLength} characters`
+        });
+      }
+
+      if (schema.pattern !== undefined) {
+        const regex = new RegExp(schema.pattern);
+
+        if (!regex.test(value)) {
+          errors.push({
+            keyword: 'pattern',
+            dataPath,
+            message: `should match pattern "${schema.pattern}"`
+          });
+        }
+      }
+    } // Array constraints
+
+
+    if (Array.isArray(value)) {
+      if (schema.minItems !== undefined && value.length < schema.minItems) {
+        errors.push({
+          keyword: 'minItems',
+          dataPath,
+          message: `should have at least ${schema.minItems} items`
+        });
+      }
+
+      if (schema.uniqueItems === true) {
+        const seen = new Set();
+        const hasDuplicates = value.some(item => {
+          const key = typeof item === 'object' ? JSON.stringify(item) : item;
+          if (seen.has(key)) return true;
+          seen.add(key);
+          return false;
+        });
+
+        if (hasDuplicates) {
+          errors.push({
+            keyword: 'uniqueItems',
+            dataPath,
+            message: 'should have unique items'
+          });
+        }
+      }
+
+      if (schema.items) {
+        value.forEach((item, index) => {
+          Validator.validateNode(schema.items, item, `${dataPath}[${index}]`, errors, definitions);
+        });
+      }
+    } // Object constraints
+
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      if (schema.required) {
+        schema.required.forEach(key => {
+          if (!(key in value)) {
+            const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+            errors.push({
+              keyword: 'required',
+              dataPath: propPath,
+              message: `should have required property '${key}'`
+            });
+          }
+        });
+      }
+
+      if (schema.properties) {
+        for (const key in schema.properties) {
+          if (key in value) {
+            const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+            Validator.validateNode(schema.properties[key], value[key], propPath, errors, definitions);
+          }
+        }
+      }
+
+      if (schema.additionalProperties !== undefined && schema.additionalProperties !== true && schema.properties) {
+        const allowed = new Set(Object.keys(schema.properties));
+
+        for (const key in value) {
+          if (!allowed.has(key)) {
+            if (schema.additionalProperties === false) {
+              const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+              errors.push({
+                keyword: 'additionalProperties',
+                dataPath: propPath,
+                message: `should NOT have additional property '${key}'`
+              });
+            } else if (typeof schema.additionalProperties === 'object') {
+              const propPath = dataPath ? `${dataPath}.${key}` : `.${key}`;
+              Validator.validateNode(schema.additionalProperties, value[key], propPath, errors, definitions);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  static checkType(type, value) {
+    if (Array.isArray(type)) {
+      return type.some(t => Validator.checkSingleType(t, value));
+    }
+
+    return Validator.checkSingleType(type, value);
+  }
+
+  static checkSingleType(type, value) {
+    switch (type) {
+      case 'string':
+        return typeof value === 'string';
+
+      case 'number':
+        return typeof value === 'number';
+
+      case 'boolean':
+        return typeof value === 'boolean';
+
+      case 'object':
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+
+      case 'array':
+        return Array.isArray(value);
+
+      case 'null':
+        return value === null;
+
+      case 'function':
+        return typeof value === 'function';
+
+      default:
+        return true;
+      // 'any' or unknown types — accept anything
+    }
+  }
+
+  static resolveRef(ref, definitions) {
+    // Supports: #/definitions/Name and #/$defs/Name
+    const match = ref.match(/^#\/(definitions|\$defs)\/(.+)$/);
+
+    if (match && definitions[match[2]]) {
+      return definitions[match[2]];
+    }
+
+    return null;
+  }
+
+  static validatePropertySchema(propertySchema, value) {
+    const {
+      schema
+    } = propertySchema;
+    const result = Validator.validateRequired(propertySchema, value);
+    const isProvided = propertySchema.isValueProvided;
+
+    if (result.isValid === false) {
+      return result;
+    }
+
+    if (!isProvided) {
+      return {
+        isValid: true,
+        errors: [],
+        warnings: result.warnings
+      };
+    }
+
+    const {
+      isValid,
+      errors,
+      warnings
+    } = Validator.validate(schema, value);
+    return {
+      key: propertySchema.name,
+      isValid,
+      errors,
+      warnings: [...result.warnings, ...warnings]
+    };
+  }
+
+  static validateRequired(propertySchema, value) {
+    const errors = [];
+    const warnings = [];
+    const isRequired = propertySchema.required === true;
+    const hasDefault = Object.prototype.hasOwnProperty.call(propertySchema, 'defaultValue');
+    const isProvided = propertySchema.isValueProvided;
+
+    if (!isProvided && isRequired) {
+      if (hasDefault) {
+        if (propertySchema.defaultValue === undefined) {
+          errors.push({
+            message: `is required but missing. So, default value is undefined.`
+          });
+        } else {
+          warnings.push({
+            message: `is required but missing. So, Default value will be used.`
+          });
+        }
+      } else {
+        errors.push({
+          message: `is required but missing. And, neither a value nor a default value is present.`
+        });
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      warnings,
+      errors
+    };
+  }
+
+}