@proteinjs/db 1.3.3 → 1.5.0

package/src/reference/ReferenceArray.ts

@@ -4,7 +4,7 @@ import { Record } from '../Record';
 import { tableByName } from '../Table';
 import { ReferenceArraySerializerId } from '../serializers/ReferenceArraySerializer';
 import { QueryBuilderFactory } from '../QueryBuilderFactory';
-
+import { Logger } from '@proteinjs/util';
 /**
  * The object returned by Db functions for each field of type ReferenceArrayColumn in a record.
  * The reason for this is to make loading of reference records on-demand. For theoretically
@@ -21,78 +21,55 @@ import { QueryBuilderFactory } from '../QueryBuilderFactory';
  */
 export class ReferenceArray<T extends Record> implements CustomSerializableObject {
   public __serializerId = ReferenceArraySerializerId;
-
   constructor(
     public _table: string,
     public _ids: string[],
     public _objects?: T[]
-  ) {
-    if (this._objects) {
-      this._objects = this.createProxy(this._objects);
-    }
-  }
+  ) {}
 
   static fromObjects<T extends Record>(table: string, objects: (T | (Partial<T> & { id: string }))[]) {
     const ids = objects.map((object) => object.id);
     return new ReferenceArray<T>(table, ids, objects as T[]);
   }
 
-  /**
-   * Used to keep `_ids` in sync with `_objects`
-   */
-  private createProxy(objects: T[]): T[] {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const referenceArray = this;
-    const handler: ProxyHandler<T[]> = {
-      get(target: T[], property: string | symbol, receiver: any) {
-        const value = Reflect.get(target, property, receiver);
-        if (typeof value === 'function' && ['push', 'pop', 'splice'].includes(property as string)) {
-          return function (...args: any[]) {
-            const result = (target as any)[property](...args);
-            referenceArray._ids = target.map((obj: T) => obj.id);
-            return result;
-          };
-        }
-        return value;
-      },
-      set(target: T[], property: string | symbol, value: any, receiver: any) {
-        const result = Reflect.set(target, property, value, receiver);
-        if (typeof property === 'number' || !isNaN(Number(property))) {
-          referenceArray._ids = target.map((obj: T) => obj.id);
-        }
-        return result;
-      },
-      deleteProperty(target: T[], property: string | symbol) {
-        if (typeof property === 'number' || !isNaN(Number(property))) {
-          target.splice(Number(property), 1);
-        }
-        referenceArray._ids = target.map((obj: T) => obj.id);
-        return true;
-      },
-    };
-    return new Proxy(objects, handler);
+  isLoaded(): boolean {
+    return this._objects !== undefined;
   }
 
   async get(): Promise<T[]> {
     if (!this._objects) {
       if (this._ids.length < 1) {
-        this._objects = this.createProxy([]);
+        this._objects = [];
       } else {
         const table = tableByName(this._table);
         const db = getDb();
         const qb = new QueryBuilderFactory().getQueryBuilder(table);
         qb.condition({ field: 'id', operator: 'IN', value: this._ids });
         qb.sort([{ field: 'id', byValues: this._ids }]);
-        const objects = await db.query(table, qb);
-        this._objects = this.createProxy(objects);
+        this._objects = await db.query(table, qb);
       }
     }
 
     return this._objects;
   }
 
+  getIfExists(): T[] | undefined {
+    if (this._objects) {
+      return this._objects;
+    }
+
+    return undefined;
+  }
+
+  getLength(): number {
+    if (this._objects) {
+      return this._objects.length;
+    }
+
+    return this._ids.length;
+  }
+
   set(objects: T[]) {
-    this._objects = this.createProxy(objects);
-    this._ids = objects.map((object) => object.id);
+    this._objects = objects;
   }
 }

package/test/ReferenceArray.test.ts

@@ -13,81 +13,52 @@ class MockRecord implements Record {
 describe('ReferenceArray', () => {
   const createMockRecord = (id: string) => new MockRecord(id, moment(), moment());
 
-  it('should initialize with correct ids and objects', () => {
-    const objects = [createMockRecord('1'), createMockRecord('2')];
-    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2'], objects);
-
+  it('should initialize with correct ids', () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2']);
     expect(refArray._ids).toEqual(['1', '2']);
-    expect(refArray._objects).toEqual(objects);
+    expect(refArray._objects).toBeUndefined();
   });
 
-  it('should update ids when objects are modified', async () => {
-    const objects = [createMockRecord('1'), createMockRecord('2')];
-    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2'], objects);
-
-    // Push a new object
-    const refArrayObjects = await refArray.get();
-    if (refArrayObjects) {
-      refArrayObjects.push(createMockRecord('3'));
-      expect(refArray._ids).toEqual(['1', '2', '3']);
-
-      // Modify an object
-      refArrayObjects[1] = createMockRecord('4');
-      expect(refArray._ids).toEqual(['1', '4', '3']);
+  it('should set and get objects', async () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2']);
+    const mockObjects = [createMockRecord('1'), createMockRecord('2')];
 
-      // Delete an object using pop
-      refArrayObjects.pop();
-      expect(refArray._ids).toEqual(['1', '4']);
+    refArray.set(mockObjects);
+    const objects = await refArray.get();
 
-      // Delete an object using splice
-      refArrayObjects.splice(0, 1);
-      expect(refArray._ids).toEqual(['4']);
-    } else {
-      fail('refArrayObjects is undefined');
-    }
+    expect(objects).toEqual(mockObjects);
+    expect(refArray._objects).toBeDefined();
   });
 
-  it('should update ids when objects are set', () => {
-    const objects = [createMockRecord('1'), createMockRecord('2')];
-    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2'], objects);
+  it('should set objects without updating ids', () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2']);
+    const newObjects = [createMockRecord('3'), createMockRecord('4')];
 
-    const newObjects = [createMockRecord('5'), createMockRecord('6')];
     refArray.set(newObjects);
-    expect(refArray._ids).toEqual(['5', '6']);
+    expect(refArray._ids).toEqual(['1', '2']); // ids remain unchanged
     expect(refArray._objects).toEqual(newObjects);
   });
 
-  it('should not leave null or undefined entries in ids array when objects are deleted', () => {
-    const objects = [createMockRecord('1'), createMockRecord('2'), createMockRecord('3')];
-    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2', '3'], objects);
-
-    if (refArray._objects) {
-      // Delete the second object using splice
-      refArray._objects.splice(1, 1);
-      expect(refArray._ids).toEqual(['1', '3']);
-
-      // Delete the first object using splice
-      refArray._objects.splice(0, 1);
-      expect(refArray._ids).toEqual(['3']);
-
-      // Delete the remaining object
-      refArray._objects.pop();
-      expect(refArray._ids).toEqual([]);
-    } else {
-      fail('refArray._objects is undefined');
-    }
-  });
-
   it('should handle initializing with an empty array', async () => {
     const refArray = new ReferenceArray<MockRecord>('mock_table', []);
 
     expect(refArray._ids).toEqual([]);
+    expect(refArray._objects).toBeUndefined();
+
+    const objects = await refArray.get();
+    expect(objects).toEqual([]);
+  });
+
+  it('should not update ids when objects are modified', async () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2']);
+    const initialObjects = [createMockRecord('1'), createMockRecord('2')];
+    refArray.set(initialObjects);
 
-    const refArrayObjects = await refArray.get();
-    expect(refArrayObjects).toEqual([]);
+    const objects = await refArray.get();
+    objects.push(createMockRecord('3'));
+    objects[1] = createMockRecord('4');
+    objects.pop();
 
-    refArrayObjects.push(createMockRecord('1'));
-    expect(refArray._ids).toEqual(['1']);
-    expect(refArrayObjects.length).toEqual(1);
+    expect(refArray._ids).toEqual(['1', '2']); // ids remain unchanged
   });
 });

package/test/ReferenceArraySerializer.test.ts

@@ -27,16 +27,57 @@ describe('ReferenceArraySerializer', () => {
     });
 
     const deserialized = serializer.deserialize(serialized);
+    expect(deserialized).toBeInstanceOf(ReferenceArray);
     expect(deserialized._table).toEqual('mock_table');
     expect(deserialized._ids).toEqual(['1', '2']);
     expect(deserialized._objects).toEqual(objects);
+  });
+
+  it('should handle empty ReferenceArray', () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', []);
+    const serializer = new ReferenceArraySerializer();
+
+    const serialized = serializer.serialize(refArray);
+    expect(serialized).toEqual({
+      _table: 'mock_table',
+      _ids: [],
+      _objects: undefined,
+    });
+
+    const deserialized = serializer.deserialize(serialized);
+    expect(deserialized).toBeInstanceOf(ReferenceArray);
+    expect(deserialized._table).toEqual('mock_table');
+    expect(deserialized._ids).toEqual([]);
+    expect(deserialized._objects).toBeUndefined();
+  });
+
+  it('should handle ReferenceArray with ids but no objects', () => {
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['1', '2']);
+    const serializer = new ReferenceArraySerializer();
+
+    const serialized = serializer.serialize(refArray);
+    expect(serialized).toEqual({
+      _table: 'mock_table',
+      _ids: ['1', '2'],
+      _objects: undefined,
+    });
+
+    const deserialized = serializer.deserialize(serialized);
+    expect(deserialized).toBeInstanceOf(ReferenceArray);
+    expect(deserialized._table).toEqual('mock_table');
+    expect(deserialized._ids).toEqual(['1', '2']);
+    expect(deserialized._objects).toBeUndefined();
+  });
+
+  it('should maintain separate ids and objects after deserialization', () => {
+    const objects = [createMockRecord('1'), createMockRecord('2')];
+    const refArray = new ReferenceArray<MockRecord>('mock_table', ['3', '4'], objects);
+    const serializer = new ReferenceArraySerializer();
+
+    const serialized = serializer.serialize(refArray);
+    const deserialized = serializer.deserialize(serialized);
 
-    // Test if the proxy is correctly applied
-    if (deserialized._objects) {
-      deserialized._objects.push(createMockRecord('3'));
-      expect(deserialized._ids).toEqual(['1', '2', '3']);
-    } else {
-      fail('deserialized._objects is undefined');
-    }
+    expect(deserialized._ids).toEqual(['3', '4']);
+    expect(deserialized._objects?.map((obj) => obj.id)).toEqual(['1', '2']);
   });
 });