@proteinjs/db 1.3.2 → 1.4.0

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']);
   });
 });