feat: schema-builder and resolver-builder can handle relations (#2398)

* feat: wip add relation

* feat: add relation for custom and standards objects

* fix: use enum instead of magic string

* fix: remove dead code & fix tests

* fix: typo

* fix: BooleanFilter is missing

* fix: Malformed result error

server/src/tenant/query-runner/utils/__tests__/parse-result.spec.ts

@@ -0,0 +1,105 @@
+import {
+  isSpecialKey,
+  handleSpecialKey,
+  parseResult,
+} from 'src/tenant/query-runner/utils/parse-result.util';
+
+describe('isSpecialKey', () => {
+  test('should return true if the key starts with "___"', () => {
+    expect(isSpecialKey('___specialKey')).toBe(true);
+  });
+
+  test('should return false if the key does not start with "___"', () => {
+    expect(isSpecialKey('normalKey')).toBe(false);
+  });
+});
+
+describe('handleSpecialKey', () => {
+  let result;
+
+  beforeEach(() => {
+    result = {};
+  });
+
+  test('should correctly process a special key and add it to the result object', () => {
+    handleSpecialKey(result, '___complexField_link', 'value1');
+    expect(result).toEqual({
+      complexField: {
+        link: 'value1',
+      },
+    });
+  });
+
+  test('should add values under the same newKey if called multiple times', () => {
+    handleSpecialKey(result, '___complexField_link', 'value1');
+    handleSpecialKey(result, '___complexField_text', 'value2');
+    expect(result).toEqual({
+      complexField: {
+        link: 'value1',
+        text: 'value2',
+      },
+    });
+  });
+
+  test('should not create a new field if the special key is not correctly formed', () => {
+    handleSpecialKey(result, '___complexField', 'value1');
+    expect(result).toEqual({});
+  });
+});
+
+describe('parseResult', () => {
+  test('should recursively parse an object and handle special keys', () => {
+    const obj = {
+      normalField: 'value1',
+      ___specialField_part1: 'value2',
+      nested: {
+        ___specialFieldNested_part2: 'value3',
+      },
+    };
+
+    const expectedResult = {
+      normalField: 'value1',
+      specialField: {
+        part1: 'value2',
+      },
+      nested: {
+        specialFieldNested: {
+          part2: 'value3',
+        },
+      },
+    };
+
+    expect(parseResult(obj)).toEqual(expectedResult);
+  });
+
+  test('should handle arrays and parse each element', () => {
+    const objArray = [
+      {
+        ___specialField_part1: 'value1',
+      },
+      {
+        ___specialField_part2: 'value2',
+      },
+    ];
+
+    const expectedResult = [
+      {
+        specialField: {
+          part1: 'value1',
+        },
+      },
+      {
+        specialField: {
+          part2: 'value2',
+        },
+      },
+    ];
+
+    expect(parseResult(objArray)).toEqual(expectedResult);
+  });
+
+  test('should return the original value if it is not an object or array', () => {
+    expect(parseResult('stringValue')).toBe('stringValue');
+    expect(parseResult(12345)).toBe(12345);
+  });
+});