@vidyano-labs/virtual-service 0.1.1 → 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

@@ -77,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.
      */

package/index.js

@@ -215,15 +215,15 @@ 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, po);
@@ -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
@@ -1257,16 +1276,9 @@ class BusinessRuleValidator {
         };
         // Get the converted value (e.g., boolean from "True"/"False", number from string)
         const convertedValue = this.#getConvertedValue(attr);
-        // Check isRequired first
-        if (attr.isRequired) {
-            try {
-                this.#validateNotEmpty(convertedValue, context);
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : String(error);
-            }
-        }
         // 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);
@@ -1407,9 +1419,13 @@ class BusinessRuleValidator {
         if (num < minimum)
             throw new Error(`Minimum value is ${minimum}`);
     }
+    #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 is required");
+            throw new Error("This field cannot be empty");
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidyano-labs/virtual-service",
-  "version": "0.1.1",
+  "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": "c69d76d2dd9e0289838ca50f1cc89a81fa9a89c3"
+  "gitHash": "a8a427169445d844bc42c226c93da215441e6242"
 }