@dxos/index-core 0.0.0 → 0.8.4-main.03d5cd7b56

package/src/indexes/object-meta-index.test.ts

@@ -14,9 +14,13 @@ import { DXN, ObjectId, SpaceId } from '@dxos/keys';
 import type { IndexerObject } from './interface';
 import { ObjectMetaIndex } from './object-meta-index';
 
-const TYPE_PERSON = DXN.parse('dxn:type:example.com/type/Person:0.1.0').toString();
-const TYPE_RELATION = DXN.parse('dxn:type:example.com/type/Relation:0.1.0').toString();
-const TYPE_RELATION_UPDATED = DXN.parse('dxn:type:example.com/type/RelationUpdated:0.1.0').toString();
+const TYPE_PERSON = DXN.parse('dxn:type:com.example.type.person:0.1.0').toString();
+const TYPE_PERSON_VERSIONLESS = DXN.parse('dxn:type:com.example.type.person').toString();
+const TYPE_RELATION = DXN.parse('dxn:type:com.example.type.relation:0.1.0').toString();
+const TYPE_RELATION_UPDATED = DXN.parse('dxn:type:com.example.type.relation-updated:0.1.0').toString();
+const TYPE_WITH_UNDERSCORE = DXN.parse('dxn:type:com.example.type.person-extra:0.1.0').toString();
+const TYPE_WITH_UNDERSCORE_VERSIONLESS = DXN.parse('dxn:type:com.example.type.person-extra').toString();
+const TYPE_UNDERSCORE_FALSE_POSITIVE = DXN.parse('dxn:type:com.example.type.person-a-extra:0.1.0').toString();
 
 const TestLayer = Layer.merge(
   SqliteClient.layer({
@@ -26,6 +30,93 @@ const TestLayer = Layer.merge(
 );
 
 describe('ObjectMetaIndex', () => {
+  it.effect('should match versioned types when queried by versionless type', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const objectId = ObjectId.random();
+
+      const item: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: objectId,
+          [ATTR_TYPE]: TYPE_PERSON,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      yield* index.update([item]);
+
+      const results = yield* index.query({ spaceId, typeDxn: TYPE_PERSON_VERSIONLESS });
+      expect(results.map((_) => _.objectId)).toEqual([objectId]);
+
+      const otherTypeResults = yield* index.query({
+        spaceId,
+        typeDxn: DXN.parse('dxn:type:com.example.type.other').toString(),
+      });
+      expect(otherTypeResults).toEqual([]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should not treat LIKE wildcards in versionless type queries', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const objectIdMatch = ObjectId.random();
+      const objectIdFalsePositive = ObjectId.random();
+
+      const match: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: objectIdMatch,
+          [ATTR_TYPE]: TYPE_WITH_UNDERSCORE,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      // Would match prior implementation because '_' is a LIKE wildcard.
+      const falsePositive: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: objectIdFalsePositive,
+          [ATTR_TYPE]: TYPE_UNDERSCORE_FALSE_POSITIVE,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      yield* index.update([match, falsePositive]);
+
+      const queryResults = yield* index.query({ spaceId, typeDxn: TYPE_WITH_UNDERSCORE_VERSIONLESS });
+      expect(queryResults.map((_) => _.objectId)).toEqual([objectIdMatch]);
+
+      const queryTypesResults = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_WITH_UNDERSCORE_VERSIONLESS],
+        includeAllQueues: true,
+      });
+      expect(queryTypesResults.map((_) => _.objectId)).toEqual([objectIdMatch]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
   it.effect('should store and update object metadata', () =>
     Effect.gen(function* () {
       const index = new ObjectMetaIndex();
@@ -38,8 +129,10 @@ describe('ObjectMetaIndex', () => {
       const item1: IndexerObject = {
         spaceId,
         queueId: ObjectId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        updatedAt: Date.now(),
         data: {
           id: objectId1,
           [ATTR_TYPE]: TYPE_PERSON,
@@ -50,8 +143,10 @@ describe('ObjectMetaIndex', () => {
       const item2: IndexerObject = {
         spaceId,
         queueId: null,
+        queueNamespace: null,
         documentId: 'doc-123',
         recordId: null,
+        updatedAt: Date.now(),
         data: {
           id: objectId2,
           [ATTR_TYPE]: TYPE_RELATION,
@@ -116,4 +211,267 @@ describe('ObjectMetaIndex', () => {
       expect(oldTypeResults.length).toBe(0);
     }).pipe(Effect.provide(TestLayer)),
   );
+
+  it.effect('should support queryAll/queryTypes/queryRelations', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const objectId1 = ObjectId.random();
+      const objectId2 = ObjectId.random();
+      const relationId = ObjectId.random();
+
+      const item1: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: objectId1,
+          [ATTR_TYPE]: TYPE_PERSON,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      const item2: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: objectId2,
+          [ATTR_TYPE]: TYPE_RELATION,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      const relation: IndexerObject = {
+        spaceId,
+        queueId: ObjectId.random(),
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: relationId,
+          [ATTR_TYPE]: TYPE_RELATION,
+          [ATTR_RELATION_SOURCE]: DXN.fromLocalObjectId(objectId1).toString(),
+          [ATTR_RELATION_TARGET]: DXN.fromLocalObjectId(objectId2).toString(),
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      yield* index.update([item1, item2, relation]);
+
+      const all = yield* index.queryAll({ spaceIds: [spaceId], includeAllQueues: true });
+      expect(all.map((_) => _.objectId).sort()).toEqual([objectId1, objectId2, relationId].sort());
+
+      const allNoQueues = yield* index.queryAll({ spaceIds: [spaceId] });
+      expect(allNoQueues).toEqual([]);
+
+      const types = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_PERSON, TYPE_RELATION],
+        includeAllQueues: true,
+      });
+      expect(types.map((_) => _.objectId).sort()).toEqual([objectId1, objectId2, relationId].sort());
+
+      const onlyPerson = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_PERSON],
+        includeAllQueues: true,
+      });
+      expect(onlyPerson.map((_) => _.objectId)).toEqual([objectId1]);
+
+      const onlyPersonVersionless = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_PERSON_VERSIONLESS],
+        includeAllQueues: true,
+      });
+      expect(onlyPersonVersionless.map((_) => _.objectId)).toEqual([objectId1]);
+
+      const notPerson = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_PERSON],
+        inverted: true,
+        includeAllQueues: true,
+      });
+      expect(notPerson.map((_) => _.objectId).sort()).toEqual([objectId2, relationId].sort());
+
+      const notPersonVersionless = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [TYPE_PERSON_VERSIONLESS],
+        inverted: true,
+        includeAllQueues: true,
+      });
+      expect(notPersonVersionless.map((_) => _.objectId).sort()).toEqual([objectId2, relationId].sort());
+
+      const emptyTypes = yield* index.queryTypes({ spaceIds: [spaceId], typeDxns: [] });
+      expect(emptyTypes).toEqual([]);
+
+      const notEmptyTypes = yield* index.queryTypes({
+        spaceIds: [spaceId],
+        typeDxns: [],
+        inverted: true,
+        includeAllQueues: true,
+      });
+      expect(notEmptyTypes.map((_) => _.objectId).sort()).toEqual([objectId1, objectId2, relationId].sort());
+
+      const bySource = yield* index.queryRelations({
+        endpoint: 'source',
+        anchorDxns: [DXN.fromLocalObjectId(objectId1).toString()],
+      });
+      expect(bySource.map((_) => _.objectId)).toEqual([relationId]);
+
+      const byTarget = yield* index.queryRelations({
+        endpoint: 'target',
+        anchorDxns: [DXN.fromLocalObjectId(objectId2).toString()],
+      });
+      expect(byTarget.map((_) => _.objectId)).toEqual([relationId]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should set createdAt and updatedAt from source timestamp on insert and updatedAt on update', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const objectId = ObjectId.random();
+      const queueId = ObjectId.random();
+
+      const insertTimestamp = 1700000000000;
+      const item: IndexerObject = {
+        spaceId,
+        queueId,
+        queueNamespace: 'data',
+        documentId: null,
+        recordId: null,
+        updatedAt: insertTimestamp,
+        data: {
+          id: objectId,
+          [ATTR_TYPE]: TYPE_PERSON,
+          [ATTR_DELETED]: false,
+        },
+      };
+
+      yield* index.update([item]);
+
+      const results = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      expect(results.length).toBe(1);
+      expect(results[0].createdAt).toBe(insertTimestamp);
+      expect(results[0].updatedAt).toBe(insertTimestamp);
+
+      const updateTimestamp = 1700001000000;
+      yield* index.update([{ ...item, updatedAt: updateTimestamp, data: { ...item.data, [ATTR_DELETED]: true } }]);
+
+      const updated = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      expect(updated[0].createdAt).toBe(insertTimestamp);
+      expect(updated[0].updatedAt).toBe(updateTimestamp);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should query by time range', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const queueId1 = ObjectId.random();
+      const queueId2 = ObjectId.random();
+      const objectId1 = ObjectId.random();
+      const objectId2 = ObjectId.random();
+
+      const earlyTimestamp = 1700000000000;
+      const midpoint = 1700000500000;
+      const lateTimestamp = 1700001000000;
+
+      yield* index.update([
+        {
+          spaceId,
+          queueId: queueId1,
+          queueNamespace: 'data',
+          documentId: null,
+          recordId: null,
+          updatedAt: earlyTimestamp,
+          data: { id: objectId1, [ATTR_TYPE]: TYPE_PERSON, [ATTR_DELETED]: false },
+        },
+      ]);
+
+      yield* index.update([
+        {
+          spaceId,
+          queueId: queueId2,
+          queueNamespace: 'data',
+          documentId: null,
+          recordId: null,
+          updatedAt: lateTimestamp,
+          data: { id: objectId2, [ATTR_TYPE]: TYPE_PERSON, [ATTR_DELETED]: false },
+        },
+      ]);
+
+      // Query all -- both should match.
+      const all = yield* index.queryByTimeRange({ spaceIds: [spaceId], includeAllQueues: true });
+      expect(all.map((_) => _.objectId).sort()).toEqual([objectId1, objectId2].sort());
+
+      // Query only objects updated after midpoint (object2 has lateTimestamp).
+      const afterMid = yield* index.queryByTimeRange({
+        spaceIds: [spaceId],
+        updatedAfter: midpoint,
+        includeAllQueues: true,
+      });
+      expect(afterMid.map((_) => _.objectId)).toEqual([objectId2]);
+
+      // Query only objects created before midpoint (object1 has earlyTimestamp).
+      const beforeMid = yield* index.queryByTimeRange({
+        spaceIds: [spaceId],
+        createdBefore: midpoint,
+        includeAllQueues: true,
+      });
+      expect(beforeMid.map((_) => _.objectId)).toEqual([objectId1]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should round-trip queueNamespace and persist it through updates', () =>
+    Effect.gen(function* () {
+      const index = new ObjectMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const traceQueueId = ObjectId.random();
+      const traceObjectId = ObjectId.random();
+
+      // Initial insert with 'trace' namespace.
+      const traceItem: IndexerObject = {
+        spaceId,
+        queueId: traceQueueId,
+        queueNamespace: 'trace',
+        documentId: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: traceObjectId,
+          [ATTR_TYPE]: TYPE_PERSON,
+          [ATTR_DELETED]: false,
+        },
+      };
+      yield* index.update([traceItem]);
+
+      const initial = yield* index.queryAll({ spaceIds: [spaceId], includeAllQueues: true });
+      expect(initial).toHaveLength(1);
+      expect(initial[0].queueNamespace).toBe('trace');
+
+      // Re-index the same object: the UPDATE branch must preserve the namespace.
+      yield* index.update([{ ...traceItem, updatedAt: Date.now() + 1 }]);
+
+      const afterUpdate = yield* index.queryAll({ spaceIds: [spaceId], includeAllQueues: true });
+      expect(afterUpdate).toHaveLength(1);
+      expect(afterUpdate[0].queueNamespace).toBe('trace');
+    }).pipe(Effect.provide(TestLayer)),
+  );
 });