@woltz/rich-domain 1.3.0 → 1.3.2

package/src/types/criteria.ts

@@ -1,159 +0,0 @@
-import { Primitive } from "./utils";
-
-export const FILTER_OPERATORS = [
-  "equals",
-  "notEquals",
-  "greaterThan",
-  "greaterThanOrEqual",
-  "lessThan",
-  "lessThanOrEqual",
-  "contains",
-  "startsWith",
-  "endsWith",
-  "in",
-  "notIn",
-  "between",
-  "isNull",
-  "isNotNull",
-] as const;
-
-export type FilterOperator = (typeof FILTER_OPERATORS)[number];
-
-export type StringOperators =
-  | "equals"
-  | "notEquals"
-  | "contains"
-  | "startsWith"
-  | "endsWith"
-  | "in"
-  | "notIn"
-  | "isNull"
-  | "isNotNull";
-
-export type NumberOperators =
-  | "equals"
-  | "notEquals"
-  | "greaterThan"
-  | "greaterThanOrEqual"
-  | "lessThan"
-  | "lessThanOrEqual"
-  | "in"
-  | "notIn"
-  | "between"
-  | "isNull"
-  | "isNotNull";
-
-export type DateOperators =
-  | "equals"
-  | "notEquals"
-  | "greaterThan"
-  | "greaterThanOrEqual"
-  | "lessThan"
-  | "lessThanOrEqual"
-  | "in"
-  | "notIn"
-  | "between"
-  | "isNull"
-  | "isNotNull";
-
-export type BooleanOperators = "equals" | "notEquals" | "isNull" | "isNotNull";
-
-export type ArrayOperators = "in" | "notIn" | "isNull" | "isNotNull";
-
-export type OperatorsForType<T> = T extends string
-  ? StringOperators
-  : T extends number
-  ? NumberOperators
-  : T extends Date
-  ? DateOperators
-  : T extends boolean
-  ? BooleanOperators
-  : T extends Array<any>
-  ? ArrayOperators
-  : FilterOperator;
-
-export type FilterValueFor<T> =
-  | T
-  | (T extends number | Date ? [T, T] : never)
-  | T[]
-  | null;
-
-export type PathValue<
-  T,
-  P extends string
-> = P extends `${infer K}.${infer Rest}`
-  ? K extends keyof T
-    ? T[K] extends Array<infer U>
-      ? PathValue<U, Rest>
-      : PathValue<T[K], Rest>
-    : never
-  : P extends keyof T
-  ? T[P]
-  : never;
-
-export interface Filter<TField = string, TValue = unknown> {
-  field: TField;
-  operator: unknown extends TValue ? FilterOperator : OperatorsForType<TValue>;
-  value: TValue;
-  options?: CriteriaOptions;
-}
-
-export type TypedFilter<T> = {
-  [K in FieldPath<T>]: {
-    field: K;
-    operator: OperatorsForType<NonNullable<PathValue<T, K>>>;
-    value: FilterValueFor<NonNullable<PathValue<T, K>>>;
-    options?: CriteriaOptions;
-  };
-}[FieldPath<T>];
-
-export type CriteriaAdapter<Input, Output> = {
-  [K in FieldPath<Input>]?: FieldPath<Output>;
-};
-
-export type OrderDirection = "asc" | "desc";
-
-export interface Order {
-  field: string;
-  direction: OrderDirection;
-}
-
-export type TypedOrder<T> = {
-  field: FieldPath<T>;
-  direction: OrderDirection;
-};
-
-export interface Pagination {
-  page: number;
-  limit: number;
-  offset: number;
-}
-
-export type Search = string;
-
-export interface PaginationMeta {
-  page: number;
-  limit: number;
-  total: number;
-  totalPages: number;
-  hasNext: boolean;
-  hasPrevious: boolean;
-}
-
-export interface CriteriaOptions {
-  quantifier?: "some" | "every" | "none";
-}
-
-type ExcludeBuiltInKeys<T> = Exclude<keyof T, keyof any[] | number | symbol>;
-
-export type FieldPath<T> = T extends Primitive
-  ? never
-  : {
-      [K in ExcludeBuiltInKeys<T> & string]: NonNullable<T[K]> extends Primitive
-        ? K
-        : NonNullable<T[K]> extends Array<infer U>
-        ? U extends Primitive
-          ? K
-          : K | `${K}.${FieldPath<U>}`
-        : `${K}.${FieldPath<NonNullable<T[K]>>}`;
-    }[ExcludeBuiltInKeys<T> & string];

package/src/types/domain-event.ts

@@ -1,38 +0,0 @@
-/**
- * Interface for all domain events
- */
-export interface IDomainEvent {
-  /**
-   * Unique identifier for this event occurrence
-   */
-  readonly eventId: string;
-
-  /**
-   * When the event occurred
-   */
-  readonly occurredOn: Date;
-
-  /**
-   * Name/type of the event (e.g., "UserCreated", "OrderPlaced")
-   */
-  readonly eventName: string;
-
-  /**
-   * ID of the aggregate that raised this event
-   */
-  readonly aggregateId: string;
-}
-
-/**
- * Event handler function type
- */
-export type DomainEventHandler<T extends IDomainEvent = IDomainEvent> = (
-  event: T
-) => void | Promise<void>;
-
-/**
- * Event handler class type
- */
-export interface IDomainEventHandler<T extends IDomainEvent = IDomainEvent> {
-  handle(event: T): void | Promise<void>;
-}

package/src/types/domain.ts

@@ -1,34 +0,0 @@
-import { Id } from "../id";
-import { StandardSchema } from "./standard-schema";
-
-export interface BaseProps {
-  id: Id;
-}
-
-interface DomainValidation<T> {
-  schema: StandardSchema<T>;
-  config?: ValidationConfig;
-}
-
-export type EntityValidation<T> = DomainValidation<T>;
-export type VOValidation<T> = DomainValidation<T>;
-
-export interface VOHooks<T, E> {
-  onBeforeCreate?: (props: T) => void;
-  onBeforeUpdate?: (entity: E, snapshot: T) => boolean;
-  onCreate?: (entity: E) => void;
-  rules?: (entity: E) => void;
-}
-
-export interface EntityHooks<T extends BaseProps, E> {
-  onBeforeCreate?: (props: T) => void;
-  onBeforeUpdate?: (entity: E, snapshot: T) => boolean;
-  onCreate?: (entity: E) => void;
-  rules?: (entity: E) => void;
-}
-
-export interface ValidationConfig {
-  onCreate?: boolean;
-  onUpdate?: boolean;
-  throwOnError?: boolean;
-}

package/src/types/index.ts

@@ -1,7 +0,0 @@
-export * from "./criteria";
-export * from "./domain";
-export * from "./standard-schema";
-export * from "./utils";
-export * from "./unit-of-work";
-export * from "./domain-event";
-export * from "./change-tracker";

package/src/types/standard-schema.ts

@@ -1,19 +0,0 @@
-export interface StandardSchemaIssue {
-  message: string;
-  path?: ReadonlyArray<unknown>;
-}
-
-export interface StandardSchemaResult<T> {
-  value?: T;
-  issues?: ReadonlyArray<StandardSchemaIssue>;
-}
-
-export interface StandardSchemaProps<T> {
-  validate: (
-    value: unknown
-  ) => StandardSchemaResult<T> | Promise<StandardSchemaResult<T>>;
-}
-
-export interface StandardSchema<T = unknown> {
-  "~standard": StandardSchemaProps<T>;
-}

package/src/types/unit-of-work.ts

@@ -1,46 +0,0 @@
-import { Aggregate } from "../entity";
-import { Repository } from "../repository/base-repository";
-
-/**
- * Transaction context for Unit of Work
- */
-export interface TransactionContext {
-  /**
-   * Commit all changes
-   */
-  commit(): Promise<void>;
-
-  /**
-   * Rollback all changes
-   */
-  rollback(): Promise<void>;
-
-  /**
-   * Check if transaction is active
-   */
-  isActive(): boolean;
-}
-
-/**
- * Unit of Work interface
- * Manages transactions across multiple repositories
- */
-export interface IUnitOfWork {
-  /**
-   * Start a new transaction
-   */
-  begin(): Promise<TransactionContext>;
-
-  /**
-   * Execute work within a transaction
-   * Auto-commits on success, rolls back on error
-   */
-  transaction<T>(work: (ctx: TransactionContext) => Promise<T>): Promise<T>;
-
-  /**
-   * Get repository within transaction context
-   */
-  getRepository<TDomain extends Aggregate<any>>(
-    repository: new (...args: any[]) => Repository<TDomain>
-  ): Repository<TDomain>;
-}

package/src/types/utils.ts

@@ -1,20 +0,0 @@
-import { Id } from "../id";
-
-export type DeepJsonResult<T> = {
-  [K in keyof T]: T[K] extends Id
-    ? string
-    : T[K] extends { toJSON(): infer U }
-    ? U
-    : T[K] extends Array<infer U>
-    ? U extends { toJSON(): infer V }
-      ? V[]
-      : U extends Id
-      ? string[]
-      : U[]
-    : T[K];
-};
-
-export type Primitive = string | number | boolean | Date | null | undefined;
-export type UnwrapArray<T> = T extends Array<infer U> ? U : never;
-export type IsArray<T> = T extends Array<any> ? true : false;
-export type NonUndefined<T> = T extends undefined ? never : T;

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

@@ -1,209 +0,0 @@
-import {
-  ArrayOperators,
-  BooleanOperators,
-  DateOperators,
-  FILTER_OPERATORS,
-  FilterOperator,
-  NumberOperators,
-  StringOperators,
-} from "../types";
-
-const FORCE_STRING_OPERATORS = new Set(["contains", "startsWith", "endsWith"]);
-
-export function sanitizeFieldValue(
-  value: unknown,
-  operator: FilterOperator
-): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeFieldValue(item, operator));
-  }
-
-  if (value instanceof Date) {
-    return value;
-  }
-
-  const stringValue = String(value).trim();
-
-  if (stringValue === "") {
-    return "";
-  }
-
-  if (operator && FORCE_STRING_OPERATORS.has(operator)) {
-    return stringValue;
-  }
-
-  if (stringValue === "true" || stringValue === "false") {
-    return stringValue === "true";
-  }
-
-  const numberValue = Number(stringValue);
-  if (!Number.isNaN(numberValue)) {
-    return numberValue;
-  }
-
-  const dateObj = new Date(stringValue);
-  if (!Number.isNaN(dateObj.getTime())) {
-    return dateObj;
-  }
-
-  return stringValue;
-}
-
-export function isValidOperatorForType(
-  value: unknown,
-  operator: FilterOperator
-): boolean {
-  const sanitizedValue = sanitizeFieldValue(value, operator);
-
-  if (
-    operator === "between" &&
-    Array.isArray(sanitizedValue) &&
-    sanitizedValue.length === 2
-  ) {
-    const elementType = typeof sanitizedValue[0];
-    if (elementType === "number" || sanitizedValue[0] instanceof Date) {
-      return true;
-    }
-    return false;
-  }
-
-  const valueType = typeof sanitizedValue;
-
-  if (valueType === "string") {
-    const validOps: StringOperators[] = [
-      "equals",
-      "notEquals",
-      "contains",
-      "startsWith",
-      "endsWith",
-      "in",
-      "notIn",
-      "isNull",
-      "isNotNull",
-    ];
-    return validOps.includes(operator as StringOperators);
-  }
-
-  if (valueType === "number") {
-    const validOps: NumberOperators[] = [
-      "equals",
-      "notEquals",
-      "greaterThan",
-      "greaterThanOrEqual",
-      "lessThan",
-      "lessThanOrEqual",
-      "in",
-      "notIn",
-      "between",
-      "isNull",
-      "isNotNull",
-    ];
-    return validOps.includes(operator as NumberOperators);
-  }
-
-  if (valueType === "boolean") {
-    const validOps: BooleanOperators[] = [
-      "equals",
-      "notEquals",
-      "isNull",
-      "isNotNull",
-    ];
-    return validOps.includes(operator as BooleanOperators);
-  }
-
-  if (sanitizedValue instanceof Date) {
-    const validOps: DateOperators[] = [
-      "equals",
-      "notEquals",
-      "greaterThan",
-      "greaterThanOrEqual",
-      "lessThan",
-      "lessThanOrEqual",
-      "in",
-      "notIn",
-      "between",
-      "isNull",
-      "isNotNull",
-    ];
-    return validOps.includes(operator as DateOperators);
-  }
-
-  if (Array.isArray(sanitizedValue)) {
-    const validOps: ArrayOperators[] = ["in", "notIn", "isNull", "isNotNull"];
-    return validOps.includes(operator as ArrayOperators);
-  }
-
-  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

@@ -1,34 +0,0 @@
-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
-}
-
-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];
-}

package/src/validation-error.ts

@@ -1,91 +0,0 @@
-export interface ValidationIssue {
-  path: string[];
-  message: string;
-}
-
-export class ValidationError extends Error {
-  public readonly issues: ValidationIssue[];
-  public readonly __isValidationError = true;
-
-  constructor(issues: ValidationIssue[], message?: string) {
-    const errorMessage =
-      message || `Validation failed: ${issues.map(i => i.message).join(', ')}`;
-    super(errorMessage);
-    this.name = 'ValidationError';
-    this.issues = issues;
-
-    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;
-    }
-    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)]);
-}