@woltz/rich-domain 1.0.0 → 1.2.0

package/src/utils/criteria-operator-validation.ts

@@ -0,0 +1,171 @@
+import {
+  ArrayOperators,
+  BooleanOperators,
+  DateOperators,
+  FILTER_OPERATORS,
+  FilterOperator,
+  NumberOperators,
+  StringOperators,
+} from "../types";
+
+export function isValidOperatorForType(
+  value: unknown,
+  operator: FilterOperator
+): boolean {
+  // Handle null/undefined
+  if (value === null || value === undefined) {
+    return ["isNull", "isNotNull", "equals", "notEquals"].includes(operator);
+  }
+
+  // Special case: between operator with array [min, max]
+  if (operator === "between" && Array.isArray(value) && value.length === 2) {
+    // Validate based on the type of the first element
+    const elementType = typeof value[0];
+    if (elementType === "number" || value[0] instanceof Date) {
+      return true;
+    }
+    return false;
+  }
+
+  const valueType = typeof value;
+
+  // String operators
+  if (valueType === "string") {
+    const validOps: StringOperators[] = [
+      "equals",
+      "notEquals",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "in",
+      "notIn",
+      "isNull",
+      "isNotNull",
+    ];
+    return validOps.includes(operator as StringOperators);
+  }
+
+  // Number operators
+  if (valueType === "number") {
+    const validOps: NumberOperators[] = [
+      "equals",
+      "notEquals",
+      "greaterThan",
+      "greaterThanOrEqual",
+      "lessThan",
+      "lessThanOrEqual",
+      "in",
+      "notIn",
+      "between",
+      "isNull",
+      "isNotNull",
+    ];
+    return validOps.includes(operator as NumberOperators);
+  }
+
+  // Boolean operators
+  if (valueType === "boolean") {
+    const validOps: BooleanOperators[] = [
+      "equals",
+      "notEquals",
+      "isNull",
+      "isNotNull",
+    ];
+    return validOps.includes(operator as BooleanOperators);
+  }
+
+  // Date operators
+  if (value instanceof Date) {
+    const validOps: DateOperators[] = [
+      "equals",
+      "notEquals",
+      "greaterThan",
+      "greaterThanOrEqual",
+      "lessThan",
+      "lessThanOrEqual",
+      "in",
+      "notIn",
+      "between",
+      "isNull",
+      "isNotNull",
+    ];
+    return validOps.includes(operator as DateOperators);
+  }
+
+  // Array operators
+  if (Array.isArray(value)) {
+    const validOps: ArrayOperators[] = ["in", "notIn", "isNull", "isNotNull"];
+    return validOps.includes(operator as ArrayOperators);
+  }
+
+  // For unknown types, allow all operators
+  return true;
+}
+
+export function getValidOperatorsForType(value: unknown): FilterOperator[] {
+  if (value === null || value === undefined) {
+    return ["isNull", "isNotNull", "equals", "notEquals"];
+  }
+
+  const valueType = typeof value;
+
+  if (valueType === "string" && Number.isNaN(Number(value))) {
+    return [
+      "equals",
+      "notEquals",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "in",
+      "notIn",
+      "isNull",
+      "isNotNull",
+    ];
+  }
+
+  if (valueType === "number") {
+    return [
+      "equals",
+      "notEquals",
+      "greaterThan",
+      "greaterThanOrEqual",
+      "lessThan",
+      "lessThanOrEqual",
+      "in",
+      "notIn",
+      "between",
+      "isNull",
+      "isNotNull",
+    ];
+  }
+
+  if (valueType === "boolean") {
+    return ["equals", "notEquals", "isNull", "isNotNull"];
+  }
+
+  if (value instanceof Date) {
+    return [
+      "equals",
+      "notEquals",
+      "greaterThan",
+      "greaterThanOrEqual",
+      "lessThan",
+      "lessThanOrEqual",
+      "in",
+      "notIn",
+      "between",
+      "isNull",
+      "isNotNull",
+    ];
+  }
+
+  if (Array.isArray(value)) {
+    return ["in", "notIn", "isNull", "isNotNull"];
+  }
+
+  return [...FILTER_OPERATORS];
+}
+
+export function isOperator(value: string): value is FilterOperator {
+  return FILTER_OPERATORS.includes(value as FilterOperator);
+}

package/src/utils/helpers.ts

@@ -0,0 +1,6 @@
+export function parseQueryValue(value: string): any {
+  if (!isNaN(Number(value))) return Number(value); // number
+  if (value === "true" || value === "false") return value === "true"; // boolean
+  if (!isNaN(Date.parse(value))) return new Date(value); // Date
+  return value; // string
+}

package/src/validation-error.ts

@@ -1,97 +1,97 @@
-// ============================================================================
-// Validation Error - Domain Validation Errors
-// ============================================================================
-
-export interface ValidationIssue {
-  path: string[];
-  message: string;
-}
-
-export class ValidationError extends Error {
-  public readonly issues: ValidationIssue[];
-  public readonly __isValidationError = true; // Brand for identification
-
-  constructor(issues: ValidationIssue[], message?: string) {
-    const errorMessage =
-      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
-    super(errorMessage);
-    this.name = 'ValidationError';
-    this.issues = issues;
-
-    // Maintain proper stack trace
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ValidationError);
-    }
-  }
-
-  /**
-   * Check if an error is a ValidationError (works across module boundaries)
-   */
-  static isValidationError(error: unknown): error is ValidationError {
-    if (error instanceof ValidationError) {
-      return true;
-    }
-    // Check by duck typing for cross-module compatibility
-    return (
-      error instanceof Error &&
-      error.name === 'ValidationError' &&
-      'issues' in error &&
-      Array.isArray((error as any).issues)
-    );
-  }
-
-  /**
-   * Get all error messages as a simple array
-   */
-  getMessages(): string[] {
-    return this.issues.map(i => i.message);
-  }
-
-  /**
-   * Get errors for a specific field path
-   */
-  getErrorsForPath(path: string): ValidationIssue[] {
-    return this.issues.filter(i => i.path.join('.') === path);
-  }
-
-  /**
-   * Check if a specific path has errors
-   */
-  hasErrorsForPath(path: string): boolean {
-    return this.getErrorsForPath(path).length > 0;
-  }
-
-  /**
-   * Convert to a plain object for serialization
-   */
-  toJSON(): { name: string; message: string; issues: ValidationIssue[] } {
-    return {
-      name: this.name,
-      message: this.message,
-      issues: this.issues,
-    };
-  }
-}
-
-/**
- * Helper to create a single validation issue
- */
-export function createValidationIssue(
-  path: string | string[],
-  message: string
-): ValidationIssue {
-  return {
-    path: Array.isArray(path) ? path : path.split('.'),
-    message,
-  };
-}
-
-/**
- * Helper to throw a validation error with a single issue
- */
-export function throwValidationError(
-  path: string | string[],
-  message: string
-): never {
-  throw new ValidationError([createValidationIssue(path, message)]);
-}
+// ============================================================================
+// Validation Error - Domain Validation Errors
+// ============================================================================
+
+export interface ValidationIssue {
+  path: string[];
+  message: string;
+}
+
+export class ValidationError extends Error {
+  public readonly issues: ValidationIssue[];
+  public readonly __isValidationError = true; // Brand for identification
+
+  constructor(issues: ValidationIssue[], message?: string) {
+    const errorMessage =
+      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
+    super(errorMessage);
+    this.name = 'ValidationError';
+    this.issues = issues;
+
+    // Maintain proper stack trace
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+
+  /**
+   * Check if an error is a ValidationError (works across module boundaries)
+   */
+  static isValidationError(error: unknown): error is ValidationError {
+    if (error instanceof ValidationError) {
+      return true;
+    }
+    // Check by duck typing for cross-module compatibility
+    return (
+      error instanceof Error &&
+      error.name === 'ValidationError' &&
+      'issues' in error &&
+      Array.isArray((error as any).issues)
+    );
+  }
+
+  /**
+   * Get all error messages as a simple array
+   */
+  getMessages(): string[] {
+    return this.issues.map(i => i.message);
+  }
+
+  /**
+   * Get errors for a specific field path
+   */
+  getErrorsForPath(path: string): ValidationIssue[] {
+    return this.issues.filter(i => i.path.join('.') === path);
+  }
+
+  /**
+   * Check if a specific path has errors
+   */
+  hasErrorsForPath(path: string): boolean {
+    return this.getErrorsForPath(path).length > 0;
+  }
+
+  /**
+   * Convert to a plain object for serialization
+   */
+  toJSON(): { name: string; message: string; issues: ValidationIssue[] } {
+    return {
+      name: this.name,
+      message: this.message,
+      issues: this.issues,
+    };
+  }
+}
+
+/**
+ * Helper to create a single validation issue
+ */
+export function createValidationIssue(
+  path: string | string[],
+  message: string
+): ValidationIssue {
+  return {
+    path: Array.isArray(path) ? path : path.split('.'),
+    message,
+  };
+}
+
+/**
+ * Helper to throw a validation error with a single issue
+ */
+export function throwValidationError(
+  path: string | string[],
+  message: string
+): never {
+  throw new ValidationError([createValidationIssue(path, message)]);
+}

package/src/value-object.ts

@@ -3,7 +3,7 @@
 // ============================================================================
 
 import { ValidationError } from "./validation-error";
-import { IDomainEvent } from "./domain-event";
+import { IDomainEvent } from ".";
 import {
   VOHooks,
   ValidationConfig,
@@ -11,6 +11,7 @@ import {
   EntityValidation,
 } from "./types";
 import { DEFAULT_VALIDATION_CONFIG } from "./constants";
+import { DomainError } from "./exceptions";
 
 // Helper to get static properties from constructor
 function getStaticProperty<T>(
@@ -50,11 +51,7 @@ export abstract class ValueObject<T> {
       ...validation?.config,
     };
 
-    // Apply defaultValues
     let finalProps = { ...props } as T;
-    if (hooks?.defaultValues) {
-      finalProps = { ...hooks.defaultValues, ...props } as T;
-    }
 
     // Validate schema on creation
     if (this.domainSchema && this.validationConfig.onCreate) {
@@ -84,7 +81,7 @@ export abstract class ValueObject<T> {
     const result = this.domainSchema["~standard"].validate(props);
 
     if (result instanceof Promise) {
-      throw new Error(
+      throw new DomainError(
         "Async validation not supported in constructor. Use sync validation schema."
       );
     }