@woltz/rich-domain 1.9.1 → 1.9.2

package/src/utils/crypto.ts

@@ -0,0 +1,31 @@
+const customCrypto = {
+  randomUUID: () => {
+    if (
+      typeof globalThis !== "undefined" &&
+      globalThis?.crypto &&
+      typeof globalThis.crypto.randomUUID === "function"
+    ) {
+      return globalThis.crypto.randomUUID();
+    }
+
+    const hexChars = "0123456789abcdef";
+    let uuid = "";
+
+    for (let i = 0; i < 36; i++) {
+      if (i === 8 || i === 13 || i === 18 || i === 23) {
+        uuid += "-";
+      } else if (i === 14) {
+        uuid += "4";
+      } else if (i === 19) {
+        uuid += hexChars.charAt(Math.floor(Math.random() * 4) + 8);
+      } else {
+        uuid += hexChars.charAt(Math.floor(Math.random() * 16));
+      }
+    }
+
+    return uuid;
+  },
+};
+
+export const UUID = customCrypto.randomUUID;
+export default UUID;

package/src/utils/helpers.ts

@@ -0,0 +1,50 @@
+export function parseQueryValue(value: unknown): any {
+  if (value === null || value === undefined) return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  if (value instanceof Date) return value;
+  if (Array.isArray(value)) return value;
+  if (typeof value === "object") return value;
+
+  const str = String(value);
+  if (str === "true" || str === "false") return str === "true";
+  if (str.trim() !== "" && !isNaN(Number(str))) return Number(str);
+  if (!isNaN(Date.parse(str))) return new Date(str);
+
+  return str;
+}
+
+export function levenshteinDistance(a: string, b: string): number {
+  const matrix: number[][] = [];
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1, // insertion
+          matrix[i - 1][j] + 1 // deletion
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+export function getStaticProperty<T>(
+  instance: any,
+  propertyName: string
+): T | undefined {
+  return instance.constructor[propertyName];
+}

package/src/validation-error.ts

@@ -0,0 +1,219 @@
+export interface ValidationIssue {
+  path: string[];
+  message: string;
+}
+
+export type FormattedValidationError = {
+  path: string;
+  message: string;
+};
+
+export class ValidationIssueCollector {
+  private issues: ValidationIssue[] = [];
+
+  add(path: string | string[], message: string): void {
+    this.issues.push(createValidationIssue(path, message));
+  }
+
+  getIssues(): readonly ValidationIssue[] {
+    return this.issues;
+  }
+
+  hasIssues(): boolean {
+    return this.issues.length > 0;
+  }
+
+  clear(): void {
+    this.issues = [];
+  }
+
+  toValidationError(options?: {
+    entityName?: string;
+  }): ValidationError | undefined {
+    if (!this.hasIssues()) {
+      return undefined;
+    }
+    return new ValidationError([...this.issues], options);
+  }
+}
+
+export class ValidationError extends Error {
+  public readonly issues: ValidationIssue[];
+  public readonly __isValidationError = true;
+  public readonly entityName?: string;
+
+  constructor(
+    issues: ValidationIssue[],
+    options?: { message?: string; entityName?: string }
+  ) {
+    const errorMessage =
+      options?.message ||
+      ValidationError.formatMessage(issues, options?.entityName);
+    super(errorMessage);
+    this.name = "ValidationError";
+    this.issues = issues;
+    this.entityName = options?.entityName;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+
+  static fromIssues(
+    issues: ValidationIssue[],
+    options?: { message?: string; entityName?: string }
+  ): ValidationError {
+    return new ValidationError(issues, options);
+  }
+
+  static merge(
+    existing: ValidationError | undefined,
+    extra: ValidationIssue[],
+    options?: { entityName?: string }
+  ): ValidationError | undefined {
+    if (!existing && extra.length === 0) {
+      return undefined;
+    }
+
+    const allIssues = [...(existing?.issues ?? []), ...extra];
+    return new ValidationError(allIssues, {
+      entityName: options?.entityName ?? existing?.entityName,
+    });
+  }
+
+  private static formatMessage(
+    issues: ValidationIssue[],
+    entityName?: string
+  ): string {
+    const entityPrefix = entityName ? `[${entityName}] ` : "";
+
+    if (issues.length === 0) {
+      return `${entityPrefix}Validation failed`;
+    }
+
+    if (issues.length === 1) {
+      const issue = issues[0];
+      const pathStr =
+        issue.path.length > 0 ? ` at "${issue.path.join(".")}"` : "";
+      return `${entityPrefix}Validation failed${pathStr}: ${issue.message}`;
+    }
+
+    const errorLines = issues
+      .map((issue, index) => {
+        const pathStr =
+          issue.path.length > 0 ? ` at "${issue.path.join(".")}"` : "";
+        return `  ${index + 1}. ${issue.message}${pathStr}`;
+      })
+      .join("\n");
+
+    return `${entityPrefix}Validation failed with ${issues.length} error(s):\n${errorLines}`;
+  }
+
+  private static normalizePath(path: string | string[]): string {
+    return Array.isArray(path) ? path.join(".") : path;
+  }
+
+  /**
+   * Check if an error is a ValidationError (works across module boundaries)
+   */
+  static isValidationError(error: unknown): error is ValidationError {
+    if (error instanceof ValidationError) {
+      return true;
+    }
+    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 | string[]): ValidationIssue[] {
+    const normalized = ValidationError.normalizePath(path);
+    return this.issues.filter((i) => i.path.join(".") === normalized);
+  }
+
+  /**
+   * Check if a specific path has errors
+   */
+  hasErrorsForPath(path: string | string[]): boolean {
+    return this.getErrorsForPath(path).length > 0;
+  }
+
+  /**
+   * Convert to a plain object for serialization
+   */
+  toJSON(): {
+    name: string;
+    message: string;
+    issues: ValidationIssue[];
+    entityName?: string;
+  } {
+    return {
+      name: this.name,
+      message: this.message,
+      issues: this.issues,
+      entityName: this.entityName,
+    };
+  }
+
+  /**
+   * Get validation errors formatted for UI/API consumption
+   */
+  getFormattedErrors(): FormattedValidationError[] {
+    return this.issues.map((issue) => ({
+      path: issue.path.length > 0 ? issue.path.join(".") : "",
+      message: issue.message,
+    }));
+  }
+
+  /**
+   * Get a summary of the error for logging
+   */
+  getSummary(): string {
+    const entityPrefix = this.entityName ? `[${this.entityName}] ` : "";
+    const paths = this.issues
+      .filter((i) => i.path.length > 0)
+      .map((i) => i.path.join("."));
+
+    if (paths.length === 0) {
+      return `${entityPrefix}Validation failed with ${this.issues.length} error(s)`;
+    }
+
+    const uniquePaths = Array.from(new Set(paths));
+    return `${entityPrefix}Validation failed on: ${uniquePaths.join(", ")} (${this.issues.length} error(s))`;
+  }
+}
+
+/**
+ * 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)]);
+}