@woltz/rich-domain 1.2.4 → 1.3.0

package/src/change-tracker.ts

@@ -431,9 +431,18 @@ export class ChangeTracker {
 
       const { depth, parentId, parentEntity } = arrayState.metadata;
 
+      const relationField = this.extractRelationField(path);
+
       for (const item of created) {
         const itemEntityName = this.getEntityName(item);
-        changes.addCreate(itemEntityName, item, depth, parentId, parentEntity);
+        changes.addCreate(
+          itemEntityName,
+          item,
+          depth,
+          parentId,
+          parentEntity,
+          relationField
+        );
 
         this.markNestedItemsAsCreated(item, depth, changes);
       }
@@ -458,7 +467,15 @@ export class ChangeTracker {
         if (id || key) {
           const itemEntityName = this.getEntityName(item);
           const deleteId = id || key!;
-          changes.addDelete(itemEntityName, deleteId, item, depth);
+          changes.addDelete(
+            itemEntityName,
+            deleteId,
+            item,
+            depth,
+            relationField,
+            parentId,
+            parentEntity
+          );
 
           this.markNestedItemsAsDeleted(item, depth, changes, rootTracker);
         }
@@ -476,37 +493,41 @@ export class ChangeTracker {
   ): void {
     if (!item || typeof item !== "object") return;
 
-    const itemId = this.getEntityId(item);
-    if (!itemId) return;
-
-    const props = item.props || item;
+    const propsToScan = item.props || item;
+    const parentId = this.getEntityId(item);
+    const parentEntity = this.getEntityName(item);
 
-    for (const [propName, value] of Object.entries(props)) {
+    for (const [propName, value] of Object.entries(propsToScan)) {
       if (propName === "id") continue;
 
       if (Array.isArray(value)) {
-        for (const nestedItem of value) {
-          if (this.isEntityOrVO(nestedItem)) {
-            const nestedId = this.getEntityId(nestedItem);
-            const nestedKey = this.getItemKey(nestedItem);
-            if (nestedId || nestedKey) {
-              const entityName = this.getEntityName(nestedItem);
-              changes.addCreate(
-                entityName,
-                nestedItem,
-                parentDepth + 1,
-                itemId,
-                this.getEntityName(item)
-              );
-
-              this.markNestedItemsAsCreated(
-                nestedItem,
-                parentDepth + 1,
-                changes
-              );
-            }
+        const relationField = propName;
+
+        for (const child of value) {
+          if (this.isEntityOrVO(child)) {
+            const childEntityName = this.getEntityName(child);
+            changes.addCreate(
+              childEntityName,
+              child,
+              parentDepth + 1,
+              parentId,
+              parentEntity,
+              relationField
+            );
+            this.markNestedItemsAsCreated(child, parentDepth + 1, changes);
           }
         }
+      } else if (this.isEntityOrVO(value)) {
+        const childEntityName = this.getEntityName(value);
+        changes.addCreate(
+          childEntityName,
+          value,
+          parentDepth + 1,
+          parentId,
+          parentEntity,
+          propName
+        );
+        this.markNestedItemsAsCreated(value, parentDepth + 1, changes);
       }
     }
   }
@@ -526,8 +547,12 @@ export class ChangeTracker {
     const itemId = this.getEntityId(item);
     if (!itemId) return;
 
-    for (const [, arrayState] of rootTracker.trackedArrays) {
+    for (const [path, arrayState] of rootTracker.trackedArrays) {
       if (arrayState.metadata.parentId === itemId) {
+        const relationField = this.extractRelationField(path);
+        const parentEntity = arrayState.metadata.parentEntity;
+        const parentId = arrayState.metadata.parentId;
+
         for (const nestedItem of arrayState.cloned) {
           const id =
             typeof nestedItem === "object" && nestedItem !== null
@@ -535,7 +560,15 @@ export class ChangeTracker {
               : undefined;
           if (id) {
             const entityName = arrayState.metadata.entityName;
-            changes.addDelete(entityName, id, nestedItem, parentDepth + 1);
+            changes.addDelete(
+              entityName,
+              id,
+              nestedItem,
+              parentDepth + 1,
+              relationField,
+              parentEntity,
+              parentId
+            );
 
             this.markNestedJsonItemAsDeleted(
               id,
@@ -559,21 +592,28 @@ export class ChangeTracker {
     changes: AggregateChanges<any>,
     rootTracker: ChangeTracker
   ): void {
-    for (const [, arrayState] of rootTracker.trackedArrays) {
+    for (const [path, arrayState] of rootTracker.trackedArrays) {
       if (arrayState.metadata.parentId === itemId) {
+        const relationField = this.extractRelationField(path);
+
         for (const nestedJsonItem of arrayState.cloned) {
           if (typeof nestedJsonItem !== "object" || nestedJsonItem === null)
             continue;
 
           const nestedId = nestedJsonItem.id;
           const entityName = arrayState.metadata.entityName;
+          const parentEntity = arrayState.metadata.parentEntity;
+          const parentId = arrayState.metadata.parentId;
 
           if (nestedId) {
             changes.addDelete(
               entityName,
               nestedId,
               nestedJsonItem,
-              parentDepth + 1
+              parentDepth + 1,
+              relationField,
+              parentId,
+              parentEntity
             );
 
             this.markNestedJsonItemAsDeleted(
@@ -592,7 +632,10 @@ export class ChangeTracker {
                 entityName,
                 key,
                 nestedJsonItem,
-                parentDepth + 1
+                parentDepth + 1,
+                relationField,
+                parentId,
+                parentEntity
               );
             }
           }
@@ -668,6 +711,8 @@ export class ChangeTracker {
       const { entityName, depth, parentId, parentEntity } =
         trackedItem.metadata;
 
+      const relationField = this.extractRelationField(path);
+
       const state = this.detectEntityChangeState(originalValue, currentValue);
 
       switch (state) {
@@ -677,28 +722,46 @@ export class ChangeTracker {
             currentValue,
             depth,
             parentId,
-            parentEntity
+            parentEntity,
+            relationField
           );
           break;
 
         case "deleted":
           const id = this.getEntityId(originalValue);
           if (id) {
-            changes.addDelete(entityName, id, originalEntity, depth);
+            changes.addDelete(
+              entityName,
+              id,
+              originalEntity,
+              depth,
+              relationField,
+              parentId,
+              parentEntity
+            );
           }
           break;
 
         case "replaced":
           const oldId = this.getEntityId(originalValue);
           if (oldId) {
-            changes.addDelete(entityName, oldId, originalEntity, depth);
+            changes.addDelete(
+              entityName,
+              oldId,
+              originalEntity,
+              depth,
+              relationField,
+              parentId,
+              parentEntity
+            );
           }
           changes.addCreate(
             entityName,
             currentValue,
             depth,
             parentId,
-            parentEntity
+            parentEntity,
+            relationField
           );
           break;
 
@@ -894,6 +957,12 @@ export class ChangeTracker {
     return current;
   }
 
+  private extractRelationField(path: string): string {
+    const withoutIndices = path.replace(/\[\d+\]/g, "");
+    const parts = withoutIndices.split(".");
+    return parts[parts.length - 1];
+  }
+
   private getItemKey(item: any): string | undefined {
     const id = this.getEntityId(item);
     if (id) return id;
@@ -998,8 +1067,8 @@ export class ChangeTracker {
       return obj.value;
     }
 
-    if (typeof obj.toJson === "function") {
-      return obj.toJson();
+    if (typeof obj.toJSON === "function") {
+      return obj.toJSON();
     }
 
     if (Array.isArray(obj)) {

package/src/criteria.ts

@@ -27,7 +27,7 @@ export class Criteria<T = any> {
   private _filters: Filter<FieldPath<T>, any>[] = [];
   private _orders: Order[] = [];
   private _pagination: Pagination = { page: 1, limit: 20, offset: 0 };
-  private _search?: Search<T>;
+  private _search?: Search;
   private _adapter?: CriteriaAdapter<any, any>;
 
   private constructor() {}
@@ -155,11 +155,8 @@ export class Criteria<T = any> {
     return this.orderBy(field, "desc");
   }
 
-  search<K extends FieldPath<T>>(fields: K[], value: string): this {
-    this._search = {
-      fields: fields.map(this.resolveFieldPath),
-      value,
-    };
+  search(value: string): this {
+    this._search = value;
     return this;
   }
 
@@ -167,13 +164,8 @@ export class Criteria<T = any> {
     return !!this._search;
   }
 
-  getSearch() {
-    return this._search
-      ? {
-          fields: this._search.fields.map(this.resolveFieldPath),
-          value: this._search.value,
-        }
-      : undefined;
+  getSearch(): Search | undefined {
+    return this._search;
   }
 
   paginate(page: number, limit: number): this {
@@ -241,12 +233,7 @@ export class Criteria<T = any> {
       })),
     ];
     cloned._pagination = { ...this._pagination };
-    cloned._search = this._search
-      ? {
-          fields: this._search.fields.map(this.resolveFieldPath),
-          value: this._search.value,
-        }
-      : undefined;
+    cloned._search = this._search;
 
     if (this._adapter) {
       cloned.useAdapter(this._adapter);
@@ -268,12 +255,7 @@ export class Criteria<T = any> {
         direction: order.direction,
       })),
       pagination: this._pagination,
-      search: this._search
-        ? {
-            fields: this._search.fields.map(this.resolveFieldPath),
-            value: this._search.value,
-          }
-        : undefined,
+      search: this._search,
     };
   }
 
@@ -282,7 +264,7 @@ export class Criteria<T = any> {
       filters?: TypedFilter<T>[];
       orders?: TypedOrder<T>[];
       pagination?: Pagination;
-      search?: { fields: FieldPath<T>[]; value: string };
+      search?: Search;
     },
     adapter?: CriteriaAdapter<any, any>
   ): Criteria<T> {
@@ -307,11 +289,7 @@ export class Criteria<T = any> {
         })),
       ];
     if (obj.pagination) criteria._pagination = { ...obj.pagination };
-    if (obj.search)
-      criteria._search = {
-        ...obj.search,
-        fields: obj.search.fields.map(criteria.resolveFieldPath),
-      };
+    if (obj.search) criteria._search = obj.search;
 
     return criteria;
   }
@@ -337,10 +315,12 @@ export class Criteria<T = any> {
     return field;
   }
 
-  static fromQueryParams<T>(
-    query: Record<string, any>,
+  static fromQueryParams<T = any>(
+    query: Record<string, any> | undefined,
     adapter?: CriteriaAdapter<any, any>
   ): Criteria<T> {
+    if (!query) return Criteria.create<T>();
+
     const criteria = Criteria.create<T>();
 
     if (adapter) {
@@ -354,80 +334,95 @@ export class Criteria<T = any> {
       if (key === "limit") {
         continue;
       }
-      if (key === "sort") {
-        continue;
-      }
 
-      const [field, operatorWithQuantifier] = key.split(":");
+      if (key === "filters") {
+        const filters: Record<string, any> = criteria.parseFilterValue(value);
 
-      if (!operatorWithQuantifier || !field) continue;
+        for (let [filterKey, filterValue] of Object.entries(filters)) {
+          const [field, operatorWithQuantifier] = filterKey.split(":");
 
-      const [operatorRaw, quantifierRaw] = operatorWithQuantifier.split("@");
-      const operator = isOperator(operatorRaw) ? operatorRaw : null;
-      if (!operator) {
-        throw new InvalidCriteriaError(`Invalid filter operator`, operatorRaw);
-      }
+          if (!operatorWithQuantifier || !field) continue;
 
-      const validQuantifiers = ["some", "every", "none"];
-      const quantifier =
-        quantifierRaw && validQuantifiers.includes(quantifierRaw)
-          ? (quantifierRaw as CriteriaOptions["quantifier"])
-          : undefined;
-
-      if (quantifierRaw && !quantifier) {
-        throw new InvalidCriteriaError(
-          `Invalid quantifier. Valid values: ${validQuantifiers.join(", ")}`,
-          quantifierRaw
-        );
-      }
+          const [operatorRaw, quantifierRaw] =
+            operatorWithQuantifier.split("@");
+          const operator = isOperator(operatorRaw) ? operatorRaw : null;
+          if (!operator) {
+            throw new InvalidCriteriaError(
+              `Invalid filter operator`,
+              operatorRaw
+            );
+          }
 
-      const options: CriteriaOptions | undefined = quantifier
-        ? { quantifier }
-        : undefined;
+          const validQuantifiers = ["some", "every", "none"];
+          const quantifier =
+            quantifierRaw && validQuantifiers.includes(quantifierRaw)
+              ? (quantifierRaw as CriteriaOptions["quantifier"])
+              : undefined;
+
+          if (quantifierRaw && !quantifier) {
+            throw new InvalidCriteriaError(
+              `Invalid quantifier. Valid values: ${validQuantifiers.join(
+                ", "
+              )}`,
+              quantifierRaw
+            );
+          }
 
-      let parsedValue: any = value;
+          const options: CriteriaOptions | undefined = quantifier
+            ? { quantifier }
+            : undefined;
 
-      const resolvedField = criteria.resolveFieldPath(field as FieldPath<T>);
+          let parsedValue: any = filterValue;
 
-      if (operator === "between") {
-        parsedValue = value
-          .split(",")
-          .map((v: any) => parseQueryValue(v.trim()));
-        if (parsedValue.length === 2) {
-          criteria.where(
-            resolvedField,
-            "between" as OperatorsForType<PathValue<T, FieldPath<T>>>,
-            [parsedValue[0], parsedValue[1]] as [
-              PathValue<T, FieldPath<T>>,
-              PathValue<T, FieldPath<T>>
-            ],
-            options
+          const resolvedField = criteria.resolveFieldPath(
+            field as FieldPath<T>
           );
-        }
-        continue;
-      }
 
-      if (operator === "in" || operator === "notIn") {
-        parsedValue = value.split(",").map(parseQueryValue);
-        criteria.where(
-          field as any,
-          operator as OperatorsForType<PathValue<T, FieldPath<T>>>,
-          parsedValue,
-          options
-        );
-        continue;
-      }
+          if (operator === "between") {
+            parsedValue = criteria
+              .parseFilterValue(filterValue)
+              .map((v: any) => parseQueryValue(v.trim()));
+
+            if (parsedValue.length === 2) {
+              criteria.where(
+                resolvedField,
+                "between" as OperatorsForType<PathValue<T, FieldPath<T>>>,
+                [parsedValue[0], parsedValue[1]] as [
+                  PathValue<T, FieldPath<T>>,
+                  PathValue<T, FieldPath<T>>
+                ],
+                options
+              );
+            }
+            continue;
+          }
 
-      const parsedFinalValue = parseQueryValue(value);
+          if (operator === "in" || operator === "notIn") {
+            parsedValue = criteria
+              .parseFilterValue(filterValue)
+              .map(parseQueryValue);
+
+            criteria.where(
+              field as any,
+              operator as OperatorsForType<PathValue<T, FieldPath<T>>>,
+              parsedValue,
+              options
+            );
+            continue;
+          }
 
-      criteria.validateOperator(operator, parsedFinalValue);
+          const parsedFinalValue = parseQueryValue(filterValue);
 
-      criteria.where(
-        field as FieldPath<T>,
-        operator as OperatorsForType<PathValue<T, FieldPath<T>>>,
-        parsedFinalValue,
-        options
-      );
+          criteria.validateOperator(operator, parsedFinalValue);
+
+          criteria.where(
+            field as FieldPath<T>,
+            operator as OperatorsForType<PathValue<T, FieldPath<T>>>,
+            parsedFinalValue,
+            options
+          );
+        }
+      }
     }
 
     const page = query.page ? parseInt(query.page) : undefined;
@@ -437,24 +432,60 @@ export class Criteria<T = any> {
       criteria.paginate(page, limit);
     }
 
+    // 1. orderBy=["field:asc","field2:desc"]
     if (query.orderBy) {
-      const sortParts = query.orderBy.split(",");
-      sortParts.forEach((part: string) => {
-        const [field, direction] = part.split(":");
-        criteria.orderBy(
-          field as FieldPath<T>,
-          (direction as OrderDirection) || "asc"
-        );
-      });
+      const orderByValue = query.orderBy;
+
+      if (
+        typeof orderByValue === "string" &&
+        orderByValue.trim().startsWith("[")
+      ) {
+        try {
+          const orderArray = JSON.parse(orderByValue);
+          if (Array.isArray(orderArray)) {
+            orderArray.forEach((item: string) => {
+              const [field, direction] = item.split(":");
+              criteria.orderBy(
+                field as FieldPath<T>,
+                (direction as OrderDirection) || "asc"
+              );
+            });
+          }
+        } catch {
+          throw new InvalidCriteriaError(
+            "Invalid JSON array format for orderBy",
+            orderByValue
+          );
+        }
+      } else if (Array.isArray(orderByValue)) {
+        orderByValue.forEach((item: string) => {
+          const [field, direction] = item.split(":");
+          criteria.orderBy(
+            field as FieldPath<T>,
+            (direction as OrderDirection) || "asc"
+          );
+        });
+      }
+      // 2. orderBy="field:asc,field2:desc"
+      else if (typeof orderByValue === "string" && orderByValue.includes(":")) {
+        const sortParts = orderByValue.split(",");
+        sortParts.forEach((part: string) => {
+          const [field, direction] = part.split(":");
+          criteria.orderBy(
+            field as FieldPath<T>,
+            (direction as OrderDirection) || "asc"
+          );
+        });
+      }
+      // 3. orderBy="field" + orderDirection="asc"
+      else {
+        const direction = (query.orderDirection as OrderDirection) || "asc";
+        criteria.orderBy(orderByValue as FieldPath<T>, direction);
+      }
     }
 
-    if (query.search && query.searchFields) {
-      const fields = (query.searchFields as string)
-        .split(",")
-        .filter(Boolean) as FieldPath<T>[];
-
-      const resolvedFields = fields.map(criteria.resolveFieldPath);
-      criteria.search(resolvedFields, query.search as string);
+    if (query.search && typeof query.search === "string") {
+      criteria.search(query.search);
     }
 
     return criteria;
@@ -476,4 +507,15 @@ export class Criteria<T = any> {
       );
     }
   }
+
+  private parseFilterValue(value: any) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        throw new InvalidCriteriaError(`Invalid filter value`, value);
+      }
+    }
+    return parseQueryValue(value);
+  }
 }