@diffson/core 1.0.0

package/src/service/diff/Diff.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from "bun:test";
+import { DiffService } from "./DiffService";
+
+describe("DiffService", () => {
+  describe("diffElement", () => {
+    it("should return empty array for identical objects", () => {
+      const left = { name: "test", value: 1 };
+      const right = { name: "test", value: 1 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results).toEqual([]);
+    });
+
+    it("should detect modified values", () => {
+      const left = { name: "test", value: 1 };
+      const right = { name: "test", value: 2 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].diffType).toBe("MODIFY");
+      expect(results[0].leftPath).toBe("value");
+      expect(results[0].left).toBe("1");
+      expect(results[0].right).toBe("2");
+    });
+
+    it("should detect added fields", () => {
+      const left = { name: "test" };
+      const right = { name: "test", value: 1 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].diffType).toBe("ADD");
+      expect(results[0].rightPath).toBe("value");
+    });
+
+    it("should detect deleted fields", () => {
+      const left = { name: "test", value: 1 };
+      const right = { name: "test" };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].diffType).toBe("DELETE");
+      expect(results[0].leftPath).toBe("value");
+    });
+  });
+
+  describe("diffJson", () => {
+    it("should parse JSON strings and diff them", () => {
+      const leftJson = '{"name":"test","value":1}';
+      const rightJson = '{"name":"test","value":2}';
+
+      const diffService = new DiffService();
+      const results = diffService.diffJson(leftJson, rightJson);
+
+      expect(results.length).toBe(1);
+      expect(results[0].diffType).toBe("MODIFY");
+      expect(results[0].leftPath).toBe("value");
+      expect(results[0].left).toBe("1");
+      expect(results[0].right).toBe("2");
+    });
+
+    it("should return empty array for identical JSON strings", () => {
+      const leftJson = '{"name":"test","value":1}';
+      const rightJson = '{"name":"test","value":1}';
+
+      const diffService = new DiffService();
+      const results = diffService.diffJson(leftJson, rightJson);
+
+      expect(results).toEqual([]);
+    });
+
+    it("should throw error for invalid left JSON string", () => {
+      const leftJson = '{invalid json}';
+      const rightJson = '{"name":"test"}';
+
+      const diffService = new DiffService();
+
+      expect(() => diffService.diffJson(leftJson, rightJson)).toThrow("Failed to parse left JSON string");
+    });
+
+    it("should throw error for invalid right JSON string", () => {
+      const leftJson = '{"name":"test"}';
+      const rightJson = '{invalid json}';
+
+      const diffService = new DiffService();
+
+      expect(() => diffService.diffJson(leftJson, rightJson)).toThrow("Failed to parse right JSON string");
+    });
+  });
+
+  describe("nested objects", () => {
+    it("should handle nested objects", () => {
+      const left = { user: { name: "Alice", age: 30 } };
+      const right = { user: { name: "Bob", age: 30 } };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].leftPath).toBe("user.name");
+      expect(results[0].left).toBe("Alice");
+      expect(results[0].right).toBe("Bob");
+    });
+  });
+});

package/src/service/diff/DiffContext.ts

@@ -0,0 +1,37 @@
+import { SingleNodeDifference } from "../../contract/type";
+
+export class DiffContext {
+  private _isSame: boolean;
+  private singleNodeDifferences: SingleNodeDifference[];
+  private specialPathResult: string[] | null;
+
+  constructor(isSame: boolean = true) {
+    this._isSame = isSame;
+    this.singleNodeDifferences = [];
+    this.specialPathResult = null;
+  }
+
+  isSame(): boolean {
+    return this._isSame;
+  }
+
+  setSame(same: boolean): void {
+    this._isSame = same;
+  }
+
+  getDiffResultModels(): SingleNodeDifference[] {
+    return this.singleNodeDifferences;
+  }
+
+  setDiffResultModels(singleNodeDifferences: SingleNodeDifference[]): void {
+    this.singleNodeDifferences = singleNodeDifferences;
+  }
+
+  getSpecialPathResult(): string[] | null {
+    return this.specialPathResult;
+  }
+
+  setSpecialPathResult(specialPathResult: string[]): void {
+    this.specialPathResult = specialPathResult;
+  }
+}

package/src/service/diff/DiffService.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect } from "bun:test";
+import { DiffService } from "./DiffService";
+import { LeftJoinObjectComparator, SequentialArrayComparator } from "#service";
+import { PresetName } from "#contract";
+
+describe("DiffService", () => {
+  describe("basic comparison", () => {
+    it("should return empty array for identical objects", () => {
+      const left = { name: "test", value: 1 };
+      const right = { name: "test", value: 1 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results).toEqual([]);
+    });
+
+    it("should detect modified values", () => {
+      const left = { name: "test", value: 1 };
+      const right = { name: "test", value: 2 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].diffType).toBe("MODIFY");
+      expect(results[0].leftPath).toBe("value");
+      expect(results[0].left).toBe("1");
+      expect(results[0].right).toBe("2");
+    });
+  });
+
+  describe("withArrayComparator", () => {
+    it("should use sequential array comparator when configured", () => {
+      const left = { items: [1, 2, 3] };
+      const right = { items: [1, 4, 3] };
+
+      const diffService = new DiffService().withArrayComparator(SequentialArrayComparator);
+      const results = diffService.diffElement(left, right);
+      console.log(results);
+
+      expect(results.length).toBe(1);
+      expect(results[0].leftPath).toBe("items.[1]");
+      expect(results[0].left).toBe("2");
+      expect(results[0].right).toBe("4");
+    });
+
+    it("should reuse injector when configuration changes", () => {
+      const diffService = new DiffService();
+
+      // First comparison with default comparator
+      const left1 = { items: [1, 2] };
+      const right1 = { items: [2, 1] };
+      const results1 = diffService.diffElement(left1, right1);
+
+      // Should match similar elements (default behavior)
+      expect(results1).toEqual([]);
+
+      // Change to sequential comparator
+      diffService.withArrayComparator(SequentialArrayComparator);
+
+      // Second comparison with sequential comparator
+      const results2 = diffService.diffElement(left1, right1);
+
+      // Should detect differences at each index
+      expect(results2.length).toBe(2);
+    });
+  });
+
+  describe("preset", () => {
+    it("should use FullOrdered preset", () => {
+      const left = { items: [1, 2, 3] };
+      const right = { items: [1, 4, 3] };
+
+      const diffService = new DiffService(PresetName.FullOrdered);
+      const results = diffService.diffElement(left, right);
+
+      expect(results.length).toBe(1);
+      expect(results[0].leftPath).toBe("items.[1]");
+    });
+
+    it("should use LeftSmart preset", () => {
+      const left = { a: 1, b: 2 };
+      const right = { a: 1, b: 2, c: 3 };
+
+      const diffService = new DiffService(PresetName.LeftSmart);
+      const results = diffService.diffElement(left, right);
+
+      // LeftSmart only compares keys from left object
+      expect(results).toEqual([]);
+    });
+
+    it("should use LeftOrdered preset", () => {
+      const left = { a: 1, items: [1, 2] };
+      const right = { a: 1, b: 2, items: [2, 1] };
+
+      const diffService = new DiffService(PresetName.LeftOrdered);
+      const results = diffService.diffElement(left, right);
+
+      // Should use leftJoin for objects and sequential for arrays
+      expect(results.length).toBe(2); // Two array differences
+      expect(results[0].leftPath).toBe("items.[0]");
+      expect(results[1].leftPath).toBe("items.[1]");
+    });
+  });
+
+  describe("compareWithOptions", () => {
+    it("should ignore noise paths", () => {
+      const left = { name: "test", timestamp: 1000 };
+      const right = { name: "test", timestamp: 2000 };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right, {
+        noisePath: ["timestamp"],
+      });
+
+      expect(results).toEqual([]);
+    });
+
+    it("should handle special paths", () => {
+      const left = { name: "test", special: "value1" };
+      const right = { name: "test", special: "value2" };
+
+      const diffService = new DiffService();
+      const results = diffService.diffElement(left, right, {
+        specialPath: ["special"],
+      });
+
+      // Special paths are tracked differently
+      expect(results.length).toBe(1);
+    });
+  });
+
+  describe("fluent API", () => {
+    it("should support method chaining", () => {
+      const diffService = new DiffService()
+        .withArrayComparator(SequentialArrayComparator)
+        .withObjectComparator(LeftJoinObjectComparator);
+
+      const left = { a: 1, items: [1, 2] };
+      const right = { a: 1, b: 2, items: [2, 1] };
+
+      const results = diffService.diffElement(left, right);
+
+      // Should use both custom comparators
+      expect(results.length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe("DiffService - parseNestedJson", () => {
+  it("should parse nested JSON strings when parseNestedJson option is true", () => {
+    const leftJson = JSON.stringify({
+      user: '{"name": "Alice", "age": 30}',
+      settings: '{"theme": "dark", "notifications": true}'
+    });
+
+    const rightJson = JSON.stringify({
+      user: '{"name": "Bob", "age": 25}',
+      settings: '{"theme": "light", "notifications": false}'
+    });
+
+    const diffService = new DiffService();
+    const results = diffService.diffJson(leftJson, rightJson, {
+      parseNestedJson: true
+    });
+
+    // 应该能检测到嵌套对象内部的差异
+    expect(results.length).toBeGreaterThan(0);
+
+    // 验证路径能正确指向嵌套对象的属性
+    const nameDiff = results.find(r => r.leftPath === "user.name");
+    expect(nameDiff).toBeDefined();
+    expect(nameDiff?.left).toBe("Alice");
+    expect(nameDiff?.right).toBe("Bob");
+
+    const themeDiff = results.find(r => r.leftPath === "settings.theme");
+    expect(themeDiff).toBeDefined();
+    expect(themeDiff?.left).toBe("dark");
+    expect(themeDiff?.right).toBe("light");
+  });
+
+  it("should not parse nested JSON strings when parseNestedJson option is false or undefined", () => {
+    const leftJson = JSON.stringify({
+      user: '{"name": "Alice", "age": 30}'
+    });
+
+    const rightJson = JSON.stringify({
+      user: '{"name": "Bob", "age": 25}'
+    });
+
+    const diffService = new DiffService();
+    const results = diffService.diffJson(leftJson, rightJson);
+
+    // 不应该解析嵌套 JSON，应该把整个字符串当作一个值
+    expect(results.length).toBe(1);
+    expect(results[0].leftPath).toBe("user");
+    expect(results[0].left).toBe('{"name": "Alice", "age": 30}');
+    expect(results[0].right).toBe('{"name": "Bob", "age": 25}');
+  });
+
+  it("should handle deeply nested JSON strings", () => {
+    const leftJson = JSON.stringify({
+      data: '{"level1": {"level2": "value1"}}'
+    });
+
+    const rightJson = JSON.stringify({
+      data: '{"level1": {"level2": "value2"}}'
+    });
+
+    const diffService = new DiffService();
+    const results = diffService.diffJson(leftJson, rightJson, {
+      parseNestedJson: true
+    });
+
+    // 应该能检测到多层嵌套的差异
+    const deepDiff = results.find(r => r.leftPath === "data.level1.level2");
+    expect(deepDiff).toBeDefined();
+    expect(deepDiff?.left).toBe("value1");
+    expect(deepDiff?.right).toBe("value2");
+  });
+
+  it("should handle arrays containing JSON strings", () => {
+    const leftJson = JSON.stringify({
+      items: ['{"id": 1, "name": "Item1"}', '{"id": 2, "name": "Item2"}']
+    });
+
+    const rightJson = JSON.stringify({
+      items: ['{"id": 1, "name": "Item1"}', '{"id": 2, "name": "Item2Modified"}']
+    });
+
+    const diffService = new DiffService();
+    const results = diffService.diffJson(leftJson, rightJson, {
+      parseNestedJson: true
+    });
+
+    // 应该能检测到数组元素中嵌套对象的差异
+    const itemDiff = results.find(r => r.leftPath === "items.[1].name");
+    expect(itemDiff).toBeDefined();
+    expect(itemDiff?.left).toBe("Item2");
+    expect(itemDiff?.right).toBe("Item2Modified");
+  });
+
+  it("should handle mixed content with both JSON strings and regular strings", () => {
+    const leftJson = JSON.stringify({
+      regularString: "Hello",
+      jsonString: '{"key": "value1"}',
+      number: 42
+    });
+
+    const rightJson = JSON.stringify({
+      regularString: "World",
+      jsonString: '{"key": "value2"}',
+      number: 42
+    });
+
+    const diffService = new DiffService(PresetName.LeftOrdered);
+    const results = diffService.diffJson(leftJson, rightJson, {
+      parseNestedJson: true
+    });
+
+    expect(results.length).toBe(2);
+
+    const regularDiff = results.find(r => r.leftPath === "regularString");
+    expect(regularDiff?.left).toBe("Hello");
+    expect(regularDiff?.right).toBe("World");
+
+    const jsonDiff = results.find(r => r.leftPath === "jsonString.key");
+    expect(jsonDiff?.left).toBe("value1");
+    expect(jsonDiff?.right).toBe("value2");
+  });
+
+  it("should not fail on invalid JSON strings", () => {
+    const leftJson = JSON.stringify({
+      invalid: '{"not valid json'
+    });
+
+    const rightJson = JSON.stringify({
+      invalid: '{"not valid json'
+    });
+
+    const diffService = new DiffService();
+    const results = diffService.diffJson(leftJson, rightJson, {
+      parseNestedJson: true
+    });
+
+    // 无效的 JSON 字符串应该保持原样
+    expect(results.length).toBe(0);
+  });
+});
+
+

package/src/service/diff/DiffService.ts

@@ -0,0 +1,245 @@
+import isJSON from "is-json";
+import { Injector } from "@wendellhu/redi";
+import {
+  type JsonValue,
+  Result,
+  SingleNodeDifference,
+  type IDiffService,
+  IComparatorOrchestrator,
+  IObjectComparator,
+  IArrayComparator,
+  IPrimitiveComparator,
+  INullComparator,
+  IOtherComparator,
+  type IComparatorOrchestrator as IComparatorOrchestratorType,
+  PresetName,
+} from "#contract";
+import { SPLIT_PATH, OBJECT_NULL, TYPE_MODIFY, TYPE_ADD, TYPE_DELETE } from "#contract";
+import { DiffContext } from "./DiffContext";
+import { PathTracker } from "./PathTracker";
+import { ComparatorOrchestrator } from "../comparator/ComparatorOrchestrator";
+import { UnionKeyObjectComparator } from "../comparator/object/UnionKeyObjectComparator";
+import { LeftJoinObjectComparator } from "../comparator/object/LeftJoinObjectComparator";
+import { SimilarArrayComparator } from "../comparator/array/SimilarArrayComparator";
+import { SequentialArrayComparator } from "../comparator/array/SequentialArrayComparator";
+import { DefaultPrimitiveComparator } from "../comparator/primitive/DefaultPrimitiveComparator";
+import { DefaultNullComparator } from "../comparator/nulls/DefaultNullComparator";
+import { DefaultOtherComparator } from "../comparator/other/DefaultOtherComparator";
+
+export class DiffService implements IDiffService {
+  private config: {
+    objectComparator: new (orchestrator: IComparatorOrchestrator) => IObjectComparator;
+    arrayComparator: new (orchestrator: IComparatorOrchestrator) => IArrayComparator;
+    primitiveComparator: new () => IPrimitiveComparator;
+    nullComparator: new () => INullComparator;
+    otherComparator: new () => IOtherComparator;
+  };
+
+  constructor(preset: PresetName = PresetName.FullSmart) {
+    this.config = {
+      objectComparator: UnionKeyObjectComparator,
+      arrayComparator: SimilarArrayComparator,
+      primitiveComparator: DefaultPrimitiveComparator,
+      nullComparator: DefaultNullComparator,
+      otherComparator: DefaultOtherComparator,
+    };
+
+    switch (preset) {
+      case PresetName.FullOrdered:
+        this.config.arrayComparator = SequentialArrayComparator;
+        break;
+      case PresetName.LeftSmart:
+        this.config.objectComparator = LeftJoinObjectComparator;
+        break;
+      case PresetName.LeftOrdered:
+        this.config.objectComparator = LeftJoinObjectComparator;
+        this.config.arrayComparator = SequentialArrayComparator;
+        break;
+      case PresetName.FullSmart:
+      default:
+        this.config.objectComparator = UnionKeyObjectComparator;
+        this.config.arrayComparator = SimilarArrayComparator;
+        break;
+    }
+  }
+
+  withObjectComparator(cls: new (orchestrator: IComparatorOrchestrator) => IObjectComparator): this {
+    this.config.objectComparator = cls;
+    return this;
+  }
+
+  withArrayComparator(cls: new (orchestrator: IComparatorOrchestrator) => IArrayComparator): this {
+    this.config.arrayComparator = cls;
+    return this;
+  }
+
+  withPrimitiveComparator(cls: new () => IPrimitiveComparator): this {
+    this.config.primitiveComparator = cls;
+    return this;
+  }
+
+  withNullComparator(cls: new () => INullComparator): this {
+    this.config.nullComparator = cls;
+    return this;
+  }
+
+  withOtherComparator(cls: new () => IOtherComparator): this {
+    this.config.otherComparator = cls;
+    return this;
+  }
+
+  diffJson(leftJson: string, rightJson: string, options?: {
+    noisePath?: string[];
+    specialPath?: string[];
+    parseNestedJson?: boolean;
+  }): Result[] {
+    let left: JsonValue;
+    let right: JsonValue;
+
+    try {
+      left = JSON.parse(leftJson);
+    } catch (error) {
+      throw new Error(`Failed to parse left JSON string: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    try {
+      right = JSON.parse(rightJson);
+    } catch (error) {
+      throw new Error(`Failed to parse right JSON string: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    // 将解析后的对象和选项传递给 diffElement
+    return this.diffElement(left, right, options);
+  }
+
+  diffElement(
+    left: JsonValue,
+    right: JsonValue,
+    options?: {
+      noisePath?: string[];
+      specialPath?: string[];
+      parseNestedJson?: boolean;
+    }
+  ): Result[] {
+    // 如果启用递归解析嵌套 JSON
+    if (options?.parseNestedJson) {
+      left = this.parseNestedJsonStrings(left);
+      right = this.parseNestedJsonStrings(right);
+    }
+
+    const orchestrator = this.getOrCreateOrchestrator();
+    const diffContext = this.compareInternal(left, right, orchestrator, options);
+    return this.constructResult(diffContext);
+  }
+
+  private getOrCreateOrchestrator(): IComparatorOrchestratorType {
+    const injector = new Injector([
+      [IComparatorOrchestrator, { useClass: ComparatorOrchestrator, lazy: true }],
+      [IObjectComparator, { useClass: this.config.objectComparator }],
+      [IArrayComparator, { useClass: this.config.arrayComparator }],
+      [IPrimitiveComparator, { useClass: this.config.primitiveComparator }],
+      [INullComparator, { useClass: this.config.nullComparator }],
+      [IOtherComparator, { useClass: this.config.otherComparator }],
+    ]);
+    return injector.get(IComparatorOrchestrator);
+  }
+
+  private constructResult(diffContext: DiffContext): Result[] {
+    const list: Result[] = [];
+
+    for (const resultModel of diffContext.getDiffResultModels()) {
+      const printModel = this.convert(resultModel);
+      const leftAndRightBothNull =
+        resultModel.left === OBJECT_NULL && resultModel.right === OBJECT_NULL;
+
+      if (leftAndRightBothNull) {
+        printModel.diffType = TYPE_MODIFY;
+      } else if (resultModel.left === OBJECT_NULL) {
+        printModel.diffType = TYPE_ADD;
+        printModel.leftPath = null;
+      } else if (resultModel.right === OBJECT_NULL) {
+        printModel.diffType = TYPE_DELETE;
+        printModel.rightPath = null;
+      } else {
+        printModel.diffType = TYPE_MODIFY;
+      }
+      list.push(printModel);
+    }
+    return list;
+  }
+
+  private convert(resultModel: SingleNodeDifference): Result {
+    const printModel = new Result();
+    printModel.left = resultModel.left;
+    printModel.right = resultModel.right;
+    printModel.leftPath = resultModel.leftPath;
+    printModel.rightPath = resultModel.rightPath;
+    return printModel;
+  }
+
+  private compareInternal(
+    left: JsonValue,
+    right: JsonValue,
+    orchestrator: IComparatorOrchestratorType,
+    options?: {
+      noisePath?: string[];
+      specialPath?: string[];
+    }
+  ): DiffContext {
+    const pathTracker = new PathTracker(null, null);
+
+    if (options?.noisePath) {
+      pathTracker.setNoisePahList(this.splitPath(options.noisePath));
+    }
+    if (options?.specialPath) {
+      pathTracker.setSpecialPath(this.splitPath(options.specialPath));
+    }
+
+    return orchestrator.diffElement(left, right, pathTracker);
+  }
+
+  private splitPath(pathList: string[]): string[] {
+    const result: string[] = [];
+    for (const path of pathList) {
+      const parts = path.split(SPLIT_PATH);
+      result.push(parts.join("."));
+    }
+    return result;
+  }
+
+  private parseNestedJsonStrings(value: JsonValue): JsonValue {
+    // 如果是字符串，尝试解析为 JSON
+    if (typeof value === "string") {
+      if (isJSON(value)) {
+        try {
+          const parsed = JSON.parse(value);
+          // 递归处理解析后的值
+          return this.parseNestedJsonStrings(parsed);
+        } catch {
+          // 如果解析失败，返回原字符串
+          return value;
+        }
+      }
+      return value;
+    }
+
+    // 如果是数组，递归处理每个元素
+    if (Array.isArray(value)) {
+      return value.map(item => this.parseNestedJsonStrings(item));
+    }
+
+    // 如果是对象，递归处理每个属性值
+    if (typeof value === "object" && value !== null) {
+      const result: Record<string, JsonValue> = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = this.parseNestedJsonStrings(value[key]);
+        }
+      }
+      return result;
+    }
+
+    // 其他类型（number, boolean, null）直接返回
+    return value;
+  }
+}