@aphexcms/cms-core 0.1.17 → 0.2.2

package/dist/field-validation/utils.js

@@ -1,4 +1,5 @@
 import { Rule } from './rule.js';
+import { normalizeDateFields } from './date-utils.js';
 /**
  * Check if a field is required based on its validation rules
  */
@@ -20,39 +21,106 @@ export function isFieldRequired(field) {
  * Validate a field value against its validation rules
  */
 export async function validateField(field, value, context = {}) {
-    if (!field.validation) {
-        return { isValid: true, errors: [] };
+    console.log(`[validateField] Validating field "${field.name}"`, {
+        type: field.type,
+        value,
+        hasValidation: !!field.validation
+    });
+    const allErrors = [];
+    // Add automatic validation for date/datetime/url fields based on type
+    if (field.type === 'date') {
+        const dateField = field;
+        const dateFormat = dateField.options?.dateFormat || 'YYYY-MM-DD';
+        console.log(`[validateField] Adding automatic DATE validation for "${field.name}"`, {
+            dateFormat
+        });
+        const autoRule = new Rule().date(dateFormat);
+        const markers = await autoRule.validate(value, {
+            path: [field.name],
+            ...context
+        });
+        allErrors.push(...markers.map((marker) => ({
+            level: marker.level,
+            message: marker.message
+        })));
     }
-    try {
-        const validationFunctions = Array.isArray(field.validation)
-            ? field.validation
-            : [field.validation];
-        const allErrors = [];
-        for (const validationFn of validationFunctions) {
-            const rule = validationFn(new Rule());
-            if (!(rule instanceof Rule)) {
-                console.error(`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`);
-                continue;
+    else if (field.type === 'datetime') {
+        const dateTimeField = field;
+        const dateFormat = dateTimeField.options?.dateFormat || 'YYYY-MM-DD';
+        const timeFormat = dateTimeField.options?.timeFormat || 'HH:mm';
+        console.log(`[validateField] Adding automatic DATETIME validation for "${field.name}"`, {
+            dateFormat,
+            timeFormat
+        });
+        const autoRule = new Rule().datetime(dateFormat, timeFormat);
+        const markers = await autoRule.validate(value, {
+            path: [field.name],
+            ...context
+        });
+        allErrors.push(...markers.map((marker) => ({
+            level: marker.level,
+            message: marker.message
+        })));
+    }
+    else if (field.type === 'url') {
+        // Only add automatic URL validation if there's no custom validation
+        // This allows custom validation to specify different options (scheme, allowRelative, relativeOnly)
+        if (!field.validation) {
+            console.log(`[validateField] Adding automatic URL validation for "${field.name}"`);
+            // Automatic URL validation - only validate if there's a value
+            if (value && value !== '') {
+                const autoRule = new Rule().uri();
+                const markers = await autoRule.validate(value, {
+                    path: [field.name],
+                    ...context
+                });
+                allErrors.push(...markers.map((marker) => ({
+                    level: marker.level,
+                    message: marker.message
+                })));
             }
-            const markers = await rule.validate(value, {
-                path: [field.name],
-                ...context
-            });
-            allErrors.push(...markers.map((marker) => ({
-                level: marker.level,
-                message: marker.message
-            })));
         }
-        const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
-        return { isValid, errors: allErrors };
+        else {
+            console.log(`[validateField] Skipping automatic URL validation for "${field.name}" (has custom validation)`);
+        }
+    }
+    // Run user-defined validation rules if present
+    if (!field.validation) {
+        console.log(`[validateField] No custom validation rules for "${field.name}"`);
     }
-    catch (error) {
-        console.error('Validation error:', error);
-        return {
-            isValid: false,
-            errors: [{ level: 'error', message: 'Validation failed' }]
-        };
+    else {
+        try {
+            const validationFunctions = Array.isArray(field.validation)
+                ? field.validation
+                : [field.validation];
+            console.log(`[validateField] Field "${field.name}" has ${validationFunctions.length} custom validation function(s)`);
+            for (const validationFn of validationFunctions) {
+                const rule = validationFn(new Rule());
+                if (!(rule instanceof Rule)) {
+                    console.error(`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`);
+                    continue;
+                }
+                const markers = await rule.validate(value, {
+                    path: [field.name],
+                    ...context
+                });
+                allErrors.push(...markers.map((marker) => ({
+                    level: marker.level,
+                    message: marker.message
+                })));
+            }
+        }
+        catch (error) {
+            console.error(`[validateField] Validation error for "${field.name}":`, error);
+            allErrors.push({ level: 'error', message: 'Validation failed' });
+        }
     }
+    const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
+    console.log(`[validateField] Field "${field.name}" validation complete`, {
+        isValid,
+        errors: allErrors
+    });
+    return { isValid, errors: allErrors };
 }
 /**
  * Get validation CSS classes for input styling
@@ -66,20 +134,41 @@ export function getValidationClasses(hasErrors) {
 }
 /**
  * Validate an entire document's data against a schema
- * This function validates all fields in a schema against the provided data
- * and returns any validation errors found.
+ * This function:
+ * 1. Normalizes date fields (converts user format to ISO for storage)
+ * 2. Converts ISO dates to user format for validation
+ * 3. Validates all fields and returns errors
+ * 4. Returns normalized data (with ISO dates) for storage
  *
  * @param schema - The schema type containing field definitions
  * @param data - The document data to validate
  * @param context - Optional context to pass to field validators
- * @returns Validation result with isValid flag and array of field errors
+ * @returns Validation result with isValid flag, errors, and normalized data
  */
 export async function validateDocumentData(schema, data, context = {}) {
+    console.log('[validateDocumentData] Starting validation', {
+        schemaName: schema.name,
+        data
+    });
     const validationErrors = [];
-    // Validate each field in the schema
+    // Normalize date fields: convert to ISO for storage, user format for validation
+    const { normalizedData, dataForValidation } = normalizeDateFields(data, schema);
+    console.log('[validateDocumentData] After normalization', {
+        normalizedData,
+        dataForValidation
+    });
+    // Validate each field using the user-formatted data
     for (const field of schema.fields) {
-        const value = data[field.name];
-        const result = await validateField(field, value, { ...context, ...data });
+        const value = dataForValidation[field.name];
+        console.log(`[validateDocumentData] Validating field "${field.name}"`, {
+            type: field.type,
+            value
+        });
+        const result = await validateField(field, value, { ...context, ...dataForValidation });
+        console.log(`[validateDocumentData] Field "${field.name}" validation result`, {
+            isValid: result.isValid,
+            errors: result.errors
+        });
         if (!result.isValid) {
             const errorMessages = result.errors.filter((e) => e.level === 'error').map((e) => e.message);
             if (errorMessages.length > 0) {
@@ -90,8 +179,13 @@ export async function validateDocumentData(schema, data, context = {}) {
             }
         }
     }
-    return {
+    console.log('[validateDocumentData] Final result', {
         isValid: validationErrors.length === 0,
         errors: validationErrors
+    });
+    return {
+        isValid: validationErrors.length === 0,
+        errors: validationErrors,
+        normalizedData
     };
 }

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAA8B,MAAM,eAAe,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,OAAO,EAAa,SAAS,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlE,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,YAAY,CAAC,EAAE,GAAG,CACjB,MAAM,EACN;QAAE,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC7E,CAAC;CACF;AA4ED,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAyHvD"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAA8B,MAAM,eAAe,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,OAAO,EAAa,SAAS,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlE,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,YAAY,CAAC,EAAE,GAAG,CACjB,MAAM,EACN;QAAE,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC7E,CAAC;CACF;AAgFD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAgIvD"}

package/dist/hooks.js

@@ -4,13 +4,17 @@ import { AssetService as AssetServiceClass } from './services/asset-service.js';
 import { createCMS } from './engine.js';
 import { createLocalAPI } from './local-api/index.js';
 let cmsInstances = null;
-let lastConfigHash = null;
-// Helper to generate a simple hash of schema types for change detection
-function getConfigHash(config) {
-    const schemaNames = config.schemaTypes
-        .map((s) => `${s.name}:${s.fields.length}:${JSON.stringify(s.fields)}`)
-        .join(',');
-    return schemaNames;
+let schemaError = null;
+/**
+ * Check if schemas are dirty (changed via Vite HMR)
+ * Vite plugin sets a global flag when schema files change
+ */
+function checkSchemasDirty() {
+    const dirty = global.__aphexSchemasDirty === true;
+    if (dirty) {
+        global.__aphexSchemasDirty = false; // Reset the flag
+    }
+    return dirty;
 }
 // Factory function to create the default local storage adapter
 function createDefaultStorageAdapter() {
@@ -68,8 +72,6 @@ export function createCMSHook(config) {
     return async ({ event, resolve }) => {
         // Note: In dev mode, /storage/ might be accessible via Vite dev server
         // In production, only /static/ folder is served - /storage/ is private
-        const currentConfigHash = getConfigHash(config);
-        const configChanged = lastConfigHash !== null && currentConfigHash !== lastConfigHash;
         // Initialize CMS instances once at application startup
         if (!cmsInstances) {
             console.log('🚀 Initializing CMS...');
@@ -81,7 +83,14 @@ export function createCMSHook(config) {
             const cmsEngine = createCMS(config, databaseAdapter);
             // Initialize Local API (unified operations layer)
             const localAPI = createLocalAPI(config, databaseAdapter);
-            await cmsEngine.initialize();
+            // Initialize schemas with validation
+            try {
+                await cmsEngine.initialize();
+            }
+            catch (error) {
+                console.error('❌ Failed to initialize CMS:', error);
+                schemaError = error instanceof Error ? error : new Error(String(error));
+            }
             // Build plugin route map and install plugins (do this ONCE at startup)
             const pluginRoutes = new Map();
             // Resolve and install plugins
@@ -130,18 +139,26 @@ export function createCMSHook(config) {
                 auth: config.auth?.provider,
                 pluginRoutes
             };
-            lastConfigHash = currentConfigHash;
         }
-        else if (configChanged) {
-            // HMR: Config changed, re-sync schemas
-            console.log('🔄 Schema types changed, re-syncing...');
-            console.log('Old hash:', lastConfigHash?.substring(0, 100) + '...');
-            console.log('New hash:', currentConfigHash.substring(0, 100) + '...');
-            console.log('Schema types being updated:', config.schemaTypes.map((s) => s.name));
-            cmsInstances.cmsEngine.updateConfig(config);
-            await cmsInstances.cmsEngine.initialize();
-            lastConfigHash = currentConfigHash;
-            console.log('✅ Schema sync complete');
+        else if (checkSchemasDirty()) {
+            // HMR: Schemas changed, re-sync with database
+            try {
+                console.log('🔄 Syncing changed schemas to database...');
+                cmsInstances.cmsEngine.updateConfig(config);
+                await cmsInstances.cmsEngine.initialize();
+                schemaError = null; // Clear any previous errors
+                console.log('✅ Schema sync complete');
+            }
+            catch (error) {
+                console.error('❌ Failed to sync schemas:', error);
+                schemaError = error instanceof Error ? error : new Error(String(error));
+                // Don't crash the app, just store the error
+                // The old schemas in DB will remain until the error is fixed
+            }
+        }
+        // Attach schema error to instances so it can be accessed in load functions
+        if (cmsInstances) {
+            cmsInstances.schemaError = schemaError;
         }
         // Inject shared CMS services into locals (reuse singleton instances)
         event.locals.aphexCMS = cmsInstances;

package/dist/lib/field-validation/date-utils.js

@@ -0,0 +1,147 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+/**
+ * Convert a date value to user format for validation
+ * Handles both ISO format and user format inputs
+ */
+export function convertDateToUserFormat(value, userFormat) {
+    // Try parsing as ISO format first (what DateField stores)
+    // Use strict mode to reject invalid dates
+    const parsedISO = dayjs(value, 'YYYY-MM-DD', true);
+    if (parsedISO.isValid()) {
+        return parsedISO.format(userFormat);
+    }
+    // Try parsing as user format (what API might send)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return value; // Already in user format
+    }
+    // Invalid date - return as-is for validation to catch
+    return value;
+}
+/**
+ * Convert a date value to ISO format for storage
+ * Returns ISO if already valid, or original value if invalid
+ */
+export function convertDateToISO(value, userFormat) {
+    // Try parsing as user format first (for API consumers)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return parsedUser.format('YYYY-MM-DD');
+    }
+    // Try parsing as ISO (for DateField component)
+    // Use strict mode
+    const parsedISO = dayjs(value, 'YYYY-MM-DD', true);
+    if (parsedISO.isValid()) {
+        return value; // Already ISO
+    }
+    // Invalid date - return as-is
+    return value;
+}
+/**
+ * Convert a datetime value to user format for validation
+ * Handles both ISO datetime and user format inputs
+ */
+export function convertDateTimeToUserFormat(value, dateFormat, timeFormat = 'HH:mm') {
+    const userFormat = `${dateFormat} ${timeFormat}`;
+    // Try parsing as ISO datetime first (what DateTimeField stores)
+    // Use strict mode to reject invalid dates
+    const parsedISO = dayjs(value, 'YYYY-MM-DDTHH:mm:ss[Z]', true);
+    if (parsedISO.isValid()) {
+        return parsedISO.format(userFormat);
+    }
+    // Try parsing as user format (what API might send)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        return value; // Already in user format
+    }
+    // Invalid datetime - return as-is for validation to catch
+    return value;
+}
+/**
+ * Convert a datetime value to ISO UTC format for storage
+ * Returns ISO UTC if already valid, or original value if invalid
+ */
+export function convertDateTimeToISO(value, dateFormat, timeFormat = 'HH:mm') {
+    const userFormat = `${dateFormat} ${timeFormat}`;
+    console.log('[convertDateTimeToISO]', { value, userFormat });
+    // Try parsing as user format first (for API consumers)
+    // Use strict mode to reject invalid dates like Feb 31st
+    const parsedUser = dayjs(value, userFormat, true);
+    if (parsedUser.isValid()) {
+        const result = parsedUser.utc().format('YYYY-MM-DDTHH:mm:ss[Z]');
+        console.log('[convertDateTimeToISO] User format parse successful, converting to UTC:', result);
+        return result;
+    }
+    // Try parsing as ISO datetime (for DateTimeField component)
+    // Use strict mode with ISO format
+    const parsedISO = dayjs(value, 'YYYY-MM-DDTHH:mm:ss[Z]', true);
+    if (parsedISO.isValid()) {
+        const result = parsedISO.utc().format('YYYY-MM-DDTHH:mm:ss[Z]');
+        console.log('[convertDateTimeToISO] ISO parse successful:', result);
+        return result;
+    }
+    // Invalid datetime - return as-is
+    console.log('[convertDateTimeToISO] Invalid - returning as-is');
+    return value;
+}
+/**
+ * Normalize date fields in data object
+ * Converts dates to ISO for storage and creates a parallel object with user-formatted dates for validation
+ */
+export function normalizeDateFields(data, schema) {
+    const normalizedData = { ...data };
+    const dataForValidation = { ...data };
+    console.log('[normalizeDateFields] Starting normalization...');
+    console.log('[normalizeDateFields] Input data:', data);
+    for (const field of schema.fields) {
+        if (field.type === 'date' && normalizedData[field.name]) {
+            const dateField = field;
+            const userFormat = dateField.options?.dateFormat || 'YYYY-MM-DD';
+            const dateValue = normalizedData[field.name];
+            console.log(`[normalizeDateFields] Processing DATE field "${field.name}"`, {
+                originalValue: dateValue,
+                userFormat
+            });
+            if (typeof dateValue === 'string') {
+                normalizedData[field.name] = convertDateToISO(dateValue, userFormat);
+                dataForValidation[field.name] = convertDateToUserFormat(dateValue, userFormat);
+                console.log(`[normalizeDateFields] Converted DATE field "${field.name}"`, {
+                    normalizedValue: normalizedData[field.name],
+                    validationValue: dataForValidation[field.name]
+                });
+            }
+        }
+        else if (field.type === 'datetime' && normalizedData[field.name]) {
+            const dateTimeField = field;
+            const dateFormat = dateTimeField.options?.dateFormat || 'YYYY-MM-DD';
+            const timeFormat = dateTimeField.options?.timeFormat || 'HH:mm';
+            const dateTimeValue = normalizedData[field.name];
+            console.log(`[normalizeDateFields] Processing DATETIME field "${field.name}"`, {
+                originalValue: dateTimeValue,
+                dateFormat,
+                timeFormat,
+                combinedFormat: `${dateFormat} ${timeFormat}`
+            });
+            if (typeof dateTimeValue === 'string') {
+                normalizedData[field.name] = convertDateTimeToISO(dateTimeValue, dateFormat, timeFormat);
+                dataForValidation[field.name] = convertDateTimeToUserFormat(dateTimeValue, dateFormat, timeFormat);
+                console.log(`[normalizeDateFields] Converted DATETIME field "${field.name}"`, {
+                    normalizedValue: normalizedData[field.name],
+                    validationValue: dataForValidation[field.name]
+                });
+            }
+        }
+    }
+    console.log('[normalizeDateFields] Final result:', {
+        normalizedData,
+        dataForValidation
+    });
+    return { normalizedData, dataForValidation };
+}

package/dist/lib/field-validation/rule.js

@@ -1,3 +1,8 @@
+// Sanity-style validation Rule implementation
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+// Enable strict parsing
+dayjs.extend(customParseFormat);
 export class Rule {
     _required = false;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -39,6 +44,11 @@ export class Rule {
         newRule._rules.push({ type: 'length', constraint: len });
         return newRule;
     }
+    unique() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'unique' });
+        return newRule;
+    }
     email() {
         const newRule = this.clone();
         newRule._rules.push({ type: 'email' });
@@ -79,6 +89,17 @@ export class Rule {
         newRule._rules.push({ type: 'lessThan', constraint: num });
         return newRule;
     }
+    date(format) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'date', constraint: format || 'YYYY-MM-DD' });
+        return newRule;
+    }
+    datetime(dateFormat, timeFormat) {
+        const newRule = this.clone();
+        const fullFormat = `${dateFormat || 'YYYY-MM-DD'} ${timeFormat || 'HH:mm'}`;
+        newRule._rules.push({ type: 'datetime', constraint: fullFormat });
+        return newRule;
+    }
     custom(fn) {
         const newRule = this.clone();
         newRule._rules.push({ type: 'custom', constraint: fn });
@@ -155,6 +176,9 @@ export class Rule {
                 if (typeof value === 'number' && value < rule.constraint) {
                     return `Must be at least ${rule.constraint}`;
                 }
+                if (Array.isArray(value) && value.length < rule.constraint) {
+                    return `Must have at least ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
                 break;
             case 'max':
                 if (typeof value === 'string' && value.length > rule.constraint) {
@@ -163,6 +187,31 @@ export class Rule {
                 if (typeof value === 'number' && value > rule.constraint) {
                     return `Must be at most ${rule.constraint}`;
                 }
+                if (Array.isArray(value) && value.length > rule.constraint) {
+                    return `Must have at most ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
+                break;
+            case 'length':
+                if (Array.isArray(value) && value.length !== rule.constraint) {
+                    return `Must have exactly ${rule.constraint} item${rule.constraint === 1 ? '' : 's'}`;
+                }
+                if (typeof value === 'string' && value.length !== rule.constraint) {
+                    return `Must be exactly ${rule.constraint} characters`;
+                }
+                break;
+            case 'unique':
+                if (Array.isArray(value)) {
+                    const seen = new Set();
+                    for (const item of value) {
+                        // Deep comparison excluding _key property
+                        const normalized = this.normalizeForComparison(item);
+                        const serialized = JSON.stringify(normalized);
+                        if (seen.has(serialized)) {
+                            return 'All items must be unique';
+                        }
+                        seen.add(serialized);
+                    }
+                }
                 break;
             case 'email':
                 if (typeof value === 'string' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
@@ -171,11 +220,57 @@ export class Rule {
                 break;
             case 'uri':
                 if (typeof value === 'string') {
-                    try {
-                        new URL(value);
+                    const opts = rule.constraint || {};
+                    const schemes = opts.scheme || [/^https?$/];
+                    const allowRelative = opts.allowRelative || false;
+                    const relativeOnly = opts.relativeOnly || false;
+                    // Check if URL is relative (doesn't have a scheme)
+                    const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(value);
+                    const isProtocolRelative = value.startsWith('//');
+                    if (relativeOnly) {
+                        // Only allow relative URLs
+                        if (hasScheme || isProtocolRelative) {
+                            return 'Must be a relative URL';
+                        }
+                        // Validate it's a reasonable path
+                        if (!value.startsWith('/') &&
+                            !value.startsWith('.') &&
+                            !value.startsWith('#') &&
+                            !value.startsWith('?')) {
+                            return 'Must be a relative URL starting with /, ., #, or ?';
+                        }
                     }
-                    catch {
-                        return 'Must be a valid URL';
+                    else if (!hasScheme && !isProtocolRelative) {
+                        // It's a relative URL
+                        if (!allowRelative) {
+                            return 'Must be an absolute URL';
+                        }
+                        // Validate it's a reasonable relative path
+                        if (!value.startsWith('/') &&
+                            !value.startsWith('.') &&
+                            !value.startsWith('#') &&
+                            !value.startsWith('?')) {
+                            return 'Must be a valid relative URL';
+                        }
+                    }
+                    else {
+                        // It's an absolute URL, validate with URL constructor
+                        try {
+                            const url = new URL(value);
+                            // Extract scheme without the trailing colon
+                            const urlScheme = url.protocol.slice(0, -1);
+                            // Check if scheme is allowed
+                            const schemeMatches = schemes.some((s) => s instanceof RegExp ? s.test(urlScheme) : s === urlScheme);
+                            if (!schemeMatches) {
+                                const schemeList = schemes
+                                    .map((s) => (s instanceof RegExp ? s.toString() : s))
+                                    .join(', ');
+                                return `URL scheme must be one of: ${schemeList}`;
+                            }
+                        }
+                        catch {
+                            return 'Must be a valid URL';
+                        }
                     }
                 }
                 break;
@@ -199,6 +294,58 @@ export class Rule {
                     return 'Must be an integer';
                 }
                 break;
+            case 'date': {
+                if (typeof value === 'string') {
+                    const format = rule.constraint || 'YYYY-MM-DD';
+                    console.log('[Rule.validate] DATE validation', { value, format });
+                    // Parse with strict mode
+                    const parsed = dayjs(value, format, true);
+                    console.log('[Rule.validate] DATE parsed', {
+                        isValid: parsed.isValid(),
+                        parsed: parsed.format()
+                    });
+                    if (!parsed.isValid()) {
+                        console.log('[Rule.validate] DATE validation FAILED - invalid format');
+                        return `Invalid date format. Expected: ${format}`;
+                    }
+                    // Verify the parsed date matches the input (catches invalid dates like 2025-02-31)
+                    if (parsed.format(format) !== value) {
+                        console.log('[Rule.validate] DATE validation FAILED - format mismatch', {
+                            expected: value,
+                            got: parsed.format(format)
+                        });
+                        return `Invalid date. Expected format: ${format}`;
+                    }
+                    console.log('[Rule.validate] DATE validation PASSED');
+                }
+                break;
+            }
+            case 'datetime': {
+                if (typeof value === 'string') {
+                    const format = rule.constraint || 'YYYY-MM-DD HH:mm';
+                    console.log('[Rule.validate] DATETIME validation', { value, format });
+                    // Parse with strict mode
+                    const parsed = dayjs(value, format, true);
+                    console.log('[Rule.validate] DATETIME parsed', {
+                        isValid: parsed.isValid(),
+                        parsed: parsed.format()
+                    });
+                    if (!parsed.isValid()) {
+                        console.log('[Rule.validate] DATETIME validation FAILED - invalid format');
+                        return `Invalid datetime format. Expected: ${format}`;
+                    }
+                    // Verify the parsed datetime matches the input (catches invalid dates like 2025-02-31 23:59)
+                    if (parsed.format(format) !== value) {
+                        console.log('[Rule.validate] DATETIME validation FAILED - format mismatch', {
+                            expected: value,
+                            got: parsed.format(format)
+                        });
+                        return `Invalid datetime. Expected format: ${format}`;
+                    }
+                    console.log('[Rule.validate] DATETIME validation PASSED');
+                }
+                break;
+            }
             case 'custom': {
                 const customResult = await rule.constraint(value, context);
                 if (customResult === false) {
@@ -218,4 +365,23 @@ export class Rule {
     isRequired() {
         return this._required;
     }
+    // Helper method to normalize objects for comparison (exclude _key)
+    normalizeForComparison(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.normalizeForComparison(item));
+        }
+        if (typeof value === 'object') {
+            const normalized = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== '_key') {
+                    normalized[key] = this.normalizeForComparison(val);
+                }
+            }
+            return normalized;
+        }
+        return value;
+    }
 }