@vidyano-labs/virtual-service 0.1.0 → 0.2.0

package/README.md

@@ -336,8 +336,10 @@ console.log(contact.getAttribute("Email").validationError);
 Register your own validation rules for domain-specific requirements:
 
 ```typescript
+import type { RuleValidationContext } from "@vidyano-labs/virtual-service";
+
 // Register a custom rule (before registerPersistentObject)
-service.registerBusinessRule("IsPhoneNumber", (value: any) => {
+service.registerBusinessRule("IsPhoneNumber", (value: any, context: RuleValidationContext) => {
     if (value == null || value === "") return;
     const phoneRegex = /^\+?[\d\s-()]+$/;
     if (!phoneRegex.test(String(value)))
@@ -357,8 +359,39 @@ service.registerPersistentObject({
 });
 ```
 
+**Validation context:**
+The `RuleValidationContext` parameter provides access to:
+- `context.persistentObject` - The persistent object being validated (wrapped with helper methods)
+- `context.attribute` - The attribute being validated (wrapped with helper methods)
+
+This allows cross-field validation:
+
+```typescript
+// Validate password confirmation matches password
+service.registerBusinessRule("MatchesPassword", (value: any, context: RuleValidationContext) => {
+    if (!value) return;
+
+    const passwordValue = context.persistentObject.getAttributeValue("Password");
+    if (value !== passwordValue)
+        throw new Error("Passwords do not match");
+});
+
+service.registerPersistentObject({
+    type: "User",
+    attributes: [
+        { name: "Password", type: "String" },
+        {
+            name: "ConfirmPassword",
+            type: "String",
+            rules: "MatchesPassword"
+        }
+    ]
+});
+```
+
 **Custom rule requirements:**
 - Must be registered before `registerPersistentObject()`
+- Receives two parameters: `value` (the attribute value) and `context` (validation context)
 - Throw an `Error` with a message if validation fails
 - Return nothing (or undefined) if validation passes
 - Cannot override built-in rules
@@ -1097,7 +1130,8 @@ import type {
     ActionHandler,
     ActionArgs,
     ActionContext,
-    RuleValidatorFn
+    RuleValidatorFn,
+    RuleValidationContext
 } from "@vidyano-labs/virtual-service";
 ```
 

package/index.d.ts

@@ -1,5 +1,58 @@
 import { Dto, ServiceHooks, Service, Application } from '@vidyano/core';
 
+/**
+ * VirtualPersistentObjectAttribute combines a PersistentObjectAttributeDto with helper methods
+ * This allows clean syntax like attr.getValue() and attr.setValue() while keeping the underlying DTO unchanged
+ */
+type VirtualPersistentObjectAttribute = Dto.PersistentObjectAttributeDto & {
+    /**
+     * Gets the converted value of this attribute (e.g., Boolean as boolean, Int32 as number)
+     */
+    getValue(): any;
+    /**
+     * Sets the value of this attribute with automatic type conversion
+     */
+    setValue(value: any): void;
+    /**
+     * Sets a validation error on this attribute
+     */
+    setValidationError(error: string): void;
+    /**
+     * Clears the validation error on this attribute
+     */
+    clearValidationError(): void;
+};
+/**
+ * VirtualPersistentObject combines a PersistentObjectDto with helper methods
+ * This allows clean syntax like obj.setAttributeValue() while keeping the underlying DTO unchanged
+ */
+type VirtualPersistentObject = Dto.PersistentObjectDto & {
+    /**
+     * Gets an attribute by name, wrapped with getValue/setValue methods
+     */
+    getAttribute(name: string): VirtualPersistentObjectAttribute | undefined;
+    /**
+     * Gets the value of an attribute by name
+     */
+    getAttributeValue(name: string): any;
+    /**
+     * Sets the value of an attribute by name
+     */
+    setAttributeValue(name: string, value: any): void;
+    /**
+     * Sets a validation error for an attribute
+     */
+    setValidationError(name: string, error: string): void;
+    /**
+     * Clears a validation error for an attribute
+     */
+    clearValidationError(name: string): void;
+    /**
+     * Sets a notification message on the persistent object
+     */
+    setNotification(message: string, type: Dto.NotificationType, duration?: number): void;
+};
+
 /**
  * Simplified attribute configuration - converted to PersistentObjectAttributeDto
  */
@@ -24,10 +77,6 @@ type VirtualPersistentObjectAttributeConfig = {
      * Initial value for the attribute.
      */
     value?: any;
-    /**
-     * Indicates whether this attribute is required. Defaults to false.
-     */
-    isRequired?: boolean;
     /**
      * Indicates whether the value of this attribute can be changed. Defaults to false.
      */
@@ -184,6 +233,19 @@ type ActionContext = {
      */
     setNotification: (message: string, type: Dto.NotificationType, duration?: number) => void;
 };
+/**
+ * Context provided to business rule validators for accessing the persistent object
+ */
+type RuleValidationContext = {
+    /**
+     * The persistent object being validated (wrapped with helper methods)
+     */
+    persistentObject: VirtualPersistentObject;
+    /**
+     * The attribute being validated (wrapped with helper methods)
+     */
+    attribute: VirtualPersistentObjectAttribute;
+};
 /**
  * PersistentObject configuration - converted to PersistentObjectDto
  */
@@ -286,60 +348,7 @@ type VirtualQueryConfig = {
 /**
  * Rule validator function that throws an error if invalid, or returns nothing if valid
  */
-type RuleValidatorFn = (value: any, ...params: any[]) => void;
-
-/**
- * VirtualPersistentObjectAttribute combines a PersistentObjectAttributeDto with helper methods
- * This allows clean syntax like attr.getValue() and attr.setValue() while keeping the underlying DTO unchanged
- */
-type VirtualPersistentObjectAttribute = Dto.PersistentObjectAttributeDto & {
-    /**
-     * Gets the converted value of this attribute (e.g., Boolean as boolean, Int32 as number)
-     */
-    getValue(): any;
-    /**
-     * Sets the value of this attribute with automatic type conversion
-     */
-    setValue(value: any): void;
-    /**
-     * Sets a validation error on this attribute
-     */
-    setValidationError(error: string): void;
-    /**
-     * Clears the validation error on this attribute
-     */
-    clearValidationError(): void;
-};
-/**
- * VirtualPersistentObject combines a PersistentObjectDto with helper methods
- * This allows clean syntax like obj.setAttributeValue() while keeping the underlying DTO unchanged
- */
-type VirtualPersistentObject = Dto.PersistentObjectDto & {
-    /**
-     * Gets an attribute by name, wrapped with getValue/setValue methods
-     */
-    getAttribute(name: string): VirtualPersistentObjectAttribute | undefined;
-    /**
-     * Gets the value of an attribute by name
-     */
-    getAttributeValue(name: string): any;
-    /**
-     * Sets the value of an attribute by name
-     */
-    setAttributeValue(name: string, value: any): void;
-    /**
-     * Sets a validation error for an attribute
-     */
-    setValidationError(name: string, error: string): void;
-    /**
-     * Clears a validation error for an attribute
-     */
-    clearValidationError(name: string): void;
-    /**
-     * Sets a notification message on the persistent object
-     */
-    setNotification(message: string, type: Dto.NotificationType, duration?: number): void;
-};
+type RuleValidatorFn = (value: any, context: RuleValidationContext, ...params: any[]) => void;
 
 /**
  * Base class for PersistentObject lifecycle methods
@@ -556,4 +565,4 @@ declare class VirtualService extends Service {
 }
 
 export { VirtualPersistentObjectActions, VirtualService, VirtualServiceHooks };
-export type { ActionArgs, ActionConfig, ActionContext, ActionHandler, RuleValidatorFn, VirtualPersistentObject, VirtualPersistentObjectAttribute, VirtualPersistentObjectAttributeConfig, VirtualPersistentObjectConfig, VirtualQueryConfig, VirtualQueryExecuteResult };
+export type { ActionArgs, ActionConfig, ActionContext, ActionHandler, RuleValidationContext, RuleValidatorFn, VirtualPersistentObject, VirtualPersistentObjectAttribute, VirtualPersistentObjectAttributeConfig, VirtualPersistentObjectConfig, VirtualQueryConfig, VirtualQueryExecuteResult };

package/index.js

@@ -215,18 +215,18 @@ class VirtualPersistentObjectRegistry {
         for (const attr of po.attributes) {
             // Clear previous validation errors
             attr.validationError = undefined;
-            // Find the attribute config to get rules and isRequired
+            // Find the attribute config to get rules
             const attrConfig = config.attributes.find(a => a.name === attr.name);
             if (!attrConfig)
                 continue;
-            // Create a DTO with the rules and isRequired from config
+            // Always use server config for rules and isRequired (never trust client values)
             const attrWithRules = {
                 ...attr,
                 rules: attrConfig.rules,
-                isRequired: attrConfig.isRequired || false
+                isRequired: hasRequiredRule(attrConfig.rules)
             };
             // Validate the attribute
-            const error = this.#validator.validateAttribute(attrWithRules);
+            const error = this.#validator.validateAttribute(attrWithRules, po);
             if (error) {
                 attr.validationError = error;
                 hasErrors = true;
@@ -345,17 +345,36 @@ async function buildPersistentObjectDto(config, queryRegistry, objectId, isNew)
         queries
     };
 }
+/**
+ * Checks if rules string contains NotEmpty or Required
+ */
+function hasRequiredRule(rules) {
+    if (!rules)
+        return false;
+    // Parse the rules string (semicolon-separated)
+    const ruleNames = rules
+        .split(";")
+        .map(rule => rule.trim())
+        .map(rule => {
+        // Extract just the rule name (before any parentheses)
+        const match = rule.match(/^(\w+)/);
+        return match ? match[1] : "";
+    });
+    return ruleNames.includes("NotEmpty") || ruleNames.includes("Required");
+}
 /**
  * Builds a PersistentObjectAttributeDto from configuration
  */
 async function buildAttributeDto(config, index, queryRegistry) {
+    // Automatically set isRequired if rules contain NotEmpty or Required
+    const isRequired = hasRequiredRule(config.rules);
     const baseDto = {
         id: config.id || crypto.randomUUID(),
         name: config.name,
         type: config.type || "String",
         label: config.label || config.name,
         value: config.value,
-        isRequired: config.isRequired || false,
+        isRequired,
         isReadOnly: config.isReadOnly || false,
         rules: config.rules,
         visibility: config.visibility || "Always",
@@ -1221,7 +1240,7 @@ class BusinessRuleValidator {
         this.#builtInRules.set("MinLength", this.#validateMinLength.bind(this));
         this.#builtInRules.set("MinValue", this.#validateMinValue.bind(this));
         this.#builtInRules.set("NotEmpty", this.#validateNotEmpty.bind(this));
-        this.#builtInRules.set("Required", this.#validateNotEmpty.bind(this)); // Required is same as NotEmpty
+        this.#builtInRules.set("Required", this.#validateRequired.bind(this));
     }
     /**
      * Register a custom business rule
@@ -1234,19 +1253,32 @@ class BusinessRuleValidator {
     }
     /**
      * Validate an attribute against its rules
+     * @param attr - The attribute to validate
+     * @param po - The persistent object containing the attribute
      * @returns Error message if validation fails, null if valid
      */
-    validateAttribute(attr) {
-        // Check isRequired first
-        if (attr.isRequired) {
-            try {
-                this.#validateNotEmpty(attr.value);
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : String(error);
+    validateAttribute(attr, po) {
+        // Create conversion context for wrappers
+        const conversionContext = {
+            getConvertedValue: (attribute) => this.#getConvertedValue(attribute),
+            setConvertedValue: (attribute, value) => {
+                attribute.value = toServiceValue(value, attribute.type);
+                attribute.isValueChanged = true;
             }
-        }
+        };
+        // Create wrapped objects for the validation context
+        const wrappedPo = createVirtualPersistentObject(po, conversionContext);
+        const wrappedAttr = createVirtualPersistentObjectAttribute(attr, conversionContext);
+        // Create validation context
+        const context = {
+            persistentObject: wrappedPo,
+            attribute: wrappedAttr
+        };
+        // Get the converted value (e.g., boolean from "True"/"False", number from string)
+        const convertedValue = this.#getConvertedValue(attr);
         // Parse and validate rules string
+        // Note: isRequired is auto-set from rules for UI purposes only (e.g., showing asterisks)
+        // All validation logic is handled by the rules themselves
         if (!attr.rules)
             return null;
         const rules = this.parseRules(attr.rules);
@@ -1255,7 +1287,7 @@ class BusinessRuleValidator {
             if (!validator)
                 throw new Error(`Unknown business rule: ${rule.name}`);
             try {
-                validator(attr.value, ...rule.params);
+                validator(convertedValue, context, ...rule.params);
             }
             catch (error) {
                 return error instanceof Error ? error.message : String(error);
@@ -1308,15 +1340,19 @@ class BusinessRuleValidator {
         });
         return { name, params };
     }
+    // Helper to convert attribute values based on type
+    #getConvertedValue(attr) {
+        return fromServiceValue(attr.value, attr.type);
+    }
     // Built-in validators - throw errors instead of returning strings
-    #validateIsBase64(value) {
+    #validateIsBase64(value, context) {
         if (value == null || value === "")
             return;
         const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
         if (!base64Regex.test(String(value)))
             throw new Error("Value must be a valid base64 string");
     }
-    #validateIsEmail(value) {
+    #validateIsEmail(value, context) {
         if (value == null || value === "")
             return;
         // Only allow ASCII characters in email addresses
@@ -1324,7 +1360,7 @@ class BusinessRuleValidator {
         if (!emailRegex.test(String(value)))
             throw new Error("Email format is invalid");
     }
-    #validateIsRegex(value) {
+    #validateIsRegex(value, context) {
         if (value == null || value === "")
             return;
         try {
@@ -1334,7 +1370,7 @@ class BusinessRuleValidator {
             throw new Error("Value must be a valid regular expression");
         }
     }
-    #validateIsUrl(value) {
+    #validateIsUrl(value, context) {
         if (value == null || value === "")
             return;
         try {
@@ -1344,21 +1380,21 @@ class BusinessRuleValidator {
             throw new Error("Value must be a valid URL");
         }
     }
-    #validateIsWord(value) {
+    #validateIsWord(value, context) {
         if (value == null || value === "")
             return;
         const wordRegex = /^\w+$/;
         if (!wordRegex.test(String(value)))
             throw new Error("Value must contain only word characters");
     }
-    #validateMaxLength(value, maxLength) {
+    #validateMaxLength(value, context, maxLength) {
         if (value == null || value === "")
             return;
         const length = String(value).length;
         if (length > maxLength)
             throw new Error(`Maximum length is ${maxLength} characters`);
     }
-    #validateMaxValue(value, maximum) {
+    #validateMaxValue(value, context, maximum) {
         if (value == null || value === "")
             return;
         const num = Number(value);
@@ -1367,14 +1403,14 @@ class BusinessRuleValidator {
         if (num > maximum)
             throw new Error(`Maximum value is ${maximum}`);
     }
-    #validateMinLength(value, minLength) {
+    #validateMinLength(value, context, minLength) {
         if (value == null || value === "")
             return;
         const length = String(value).length;
         if (length < minLength)
             throw new Error(`Minimum length is ${minLength} characters`);
     }
-    #validateMinValue(value, minimum) {
+    #validateMinValue(value, context, minimum) {
         if (value == null || value === "")
             return;
         const num = Number(value);
@@ -1383,10 +1419,14 @@ class BusinessRuleValidator {
         if (num < minimum)
             throw new Error(`Minimum value is ${minimum}`);
     }
-    #validateNotEmpty(value) {
-        if (value == null || value === "" || (typeof value === "string" && value.trim() === ""))
+    #validateRequired(value, context) {
+        if (value == null)
             throw new Error("This field is required");
     }
+    #validateNotEmpty(value, context) {
+        if (value == null || value === "" || (typeof value === "string" && value.trim() === ""))
+            throw new Error("This field cannot be empty");
+    }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidyano-labs/virtual-service",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Virtual service implementation for testing Vidyano applications",
   "type": "module",
   "main": "index.js",
@@ -20,5 +20,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHash": "d6564e9eb23cc8e31609a91945e4ae852ad0b2d9"
+  "gitHash": "a8a427169445d844bc42c226c93da215441e6242"
 }