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

package/es/cc/table-connected/SdkContract.js

@@ -1,30 +1,5 @@
-// OPTIMIZE: Duplicated comparator values from bc/zrecord/Types.ts enums (CommonComparators, TextComparators, NumberComparators, DateComparators)
-const filterConfigSchema = {
-  type: 'object',
-  properties: {
-    conditions: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          fieldName: {
-            type: 'string'
-          },
-          condition: {
-            type: 'string',
-            enum: ['is empty', 'is not empty', 'is', "isn't", 'starts with', 'ends with', 'contains', "doesn't contain", '=', '<>', '<', '<=', '>', '>=', 'is after', 'is before', 'between', 'not between']
-          },
-          value: {}
-        },
-        required: ['fieldName', 'condition', 'value']
-      }
-    },
-    pattern: {
-      type: 'string'
-    }
-  },
-  required: ['conditions', 'pattern']
-};
+import { SortOrder } from "../../bc/zlist/Types";
+import { filterConfigSchema } from "../../bc/zrecord/Schemas";
 export const SdkContracts = {
   getRecordInputMeta: {
     type: 'object',
@@ -192,7 +167,7 @@ export const SdkContracts = {
       },
       order: {
         type: 'string',
-        enum: ['ASC', 'DES', 'NONE']
+        enum: [SortOrder.ASC, SortOrder.DES, SortOrder.NONE]
       }
     }
   },

package/es/cc/table-list/Properties.js

@@ -1,8 +1,7 @@
+import { Alignment, Width, SortedBy } from "./data-types/Header";
+import RowCursor from "./data-types/RowCursor";
 import SelectionConfigProperties from "../../bc/list-selection/Properties";
-const actionsSchema = {
-  type: 'array',
-  minItems: 0
-};
+import { actionsSchema } from "../../platform/client-actions/cc/action-event-mediator/Properties";
 const TableListProperties = {
   isReOrderLoading: {
     required: false,
@@ -48,7 +47,7 @@ const TableListProperties = {
         properties: {
           order: {
             type: 'string',
-            enum: ['none', 'ascending', 'descending']
+            enum: Object.values(SortedBy)
           },
           name: {
             type: 'string'
@@ -111,7 +110,7 @@ const TableListProperties = {
     required: false,
     defaultValue: {
       hasActions: false,
-      columnWidth: 120
+      columnWidth: Width.XSmall
     },
     typeMetadata: {
       schema: {
@@ -143,7 +142,7 @@ const TableListProperties = {
     typeMetadata: {
       schema: {
         type: 'string',
-        enum: ['default', 'pointer', 'not-allowed']
+        enum: Object.values(RowCursor)
       }
     }
   },
@@ -176,11 +175,11 @@ const TableListProperties = {
               },
               alignment: {
                 type: 'string',
-                enum: ['left', 'center', 'right']
+                enum: Object.values(Alignment)
               },
               sortOrder: {
                 type: 'string',
-                enum: ['none', 'ascending', 'descending']
+                enum: Object.values(SortedBy)
               }
             },
             required: ['id', 'name', 'text']

package/es/cc/table-list/row/Properties.js

@@ -1,19 +1,6 @@
-// OPTIMIZE: Duplicated clientScriptsSchema in platform/client-actions/cc/action-event-mediator/Properties.ts
-const clientScriptsSchema = {
-  type: 'array',
-  minItems: 0,
-  items: {
-    type: 'object',
-    properties: {
-      targetEventName: {
-        type: 'string'
-      },
-      clientScript: {
-        type: 'string'
-      }
-    }
-  }
-};
+import { Width } from "../data-types/Header";
+import RowCursor from "../data-types/RowCursor";
+import { clientScriptsSchema } from "../../../platform/client-scripts/cc/zclient-scripts-execution/clientScriptsSchema";
 const TableRowProperties = {
   isReorderEnabled: {
     required: false,
@@ -102,7 +89,7 @@ const TableRowProperties = {
     typeMetadata: {
       schema: {
         type: 'string',
-        enum: ['default', 'pointer', 'not-allowed']
+        enum: Object.values(RowCursor)
       }
     }
   },
@@ -135,11 +122,11 @@ const TableRowProperties = {
   },
   rowActionsColumnWidth: {
     required: false,
-    defaultValue: 120,
+    defaultValue: Width.XSmall,
     typeMetadata: {
       schema: {
         type: 'number',
-        enum: [120, 160, 200, 240, 280, 320]
+        enum: Object.values(Width)
       }
     }
   },

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

@@ -1,177 +1 @@
-/* eslint-disable complexity */
-// Map from schema object reference to precompiled validator function
-const precompiledSchemaMap = new WeakMap(); // Precompiled registry: JSON-stringified schema → validator function
-
-let precompiledByHash = null;
-
-class Validator {
-  /**
-   * Register precompiled validators from the build-time generated registry.
-   * Builds a hash-based lookup so validate() can auto-match schemas.
-   * Called once at app startup.
-   */
-  static registerPrecompiled(registry) {
-    precompiledByHash = new Map(); // Each precompiled validator has its schema embedded — extract and hash it
-
-    for (const [, validate] of Object.entries(registry)) {
-      if (typeof validate === 'function' && validate.schema) {
-        const hash = JSON.stringify(validate.schema);
-        precompiledByHash.set(hash, validate);
-      }
-    }
-  }
-
-  static normalizeErrors(ajvErrors) {
-    return ajvErrors.map(e => ({ ...e,
-      dataPath: e.instancePath || e.dataPath || ''
-    }));
-  }
-
-  static validate(schema, value) {
-    if (schema.schema) {
-      return Validator.validatePropertySchema(schema, value);
-    }
-
-    let errors = [];
-    Validator.checkFunctionsRecursively(schema, value, '', '#', errors); // Try precompiled validator first (cached by schema reference)
-
-    let precompiled = precompiledSchemaMap.get(schema); // On first encounter, try to match against precompiled registry by schema hash
-
-    if (!precompiled && precompiledByHash) {
-      const ajvSchema = JSON.parse(JSON.stringify(schema, (key, val) => val === 'function' ? undefined : val));
-      const hash = JSON.stringify(ajvSchema);
-      precompiled = precompiledByHash.get(hash);
-
-      if (precompiled) {
-        // Cache for subsequent calls — O(1) lookup from now on
-        precompiledSchemaMap.set(schema, precompiled);
-      }
-    }
-
-    if (precompiled) {
-      const isValid = precompiled(value);
-
-      if (!isValid && precompiled.errors) {
-        errors.push(...Validator.normalizeErrors(precompiled.errors));
-      }
-
-      return {
-        isValid: isValid && errors.length === 0,
-        errors,
-        warnings: []
-      };
-    } // No precompiled validator found — skip AJV validation, return function-check errors only
-
-
-    if (process.env.NODE_ENV === 'development') {
-      console.warn('[Validator] No precompiled validator found for schema. Skipping AJV validation.', schema);
-    }
-
-    return {
-      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);
-      });
-    }
-  }
-
-  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,30 +2,14 @@ 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";
-// 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/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
+    };
+  }
+
+}