@dxos/index-core 0.8.4-main.fcfe5033a5 → 0.9.0

package/src/indexes/{object-meta-index.test.ts → entity-meta-index.test.ts}

@@ -9,18 +9,18 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { ATTR_DELETED, ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, ATTR_TYPE } from '@dxos/echo/internal';
-import { DXN, ObjectId, SpaceId } from '@dxos/keys';
+import { DXN, EID, EntityId, SpaceId } from '@dxos/keys';
 
+import { EntityMetaIndex } from './entity-meta-index';
 import type { IndexerObject } from './interface';
-import { ObjectMetaIndex } from './object-meta-index';
 
-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 TYPE_PERSON = DXN.make('com.example.type.person', '0.1.0');
+const TYPE_PERSON_VERSIONLESS = DXN.make('com.example.type.person');
+const TYPE_RELATION = DXN.make('com.example.type.relation', '0.1.0');
+const TYPE_RELATION_UPDATED = DXN.make('com.example.type.relationUpdated', '0.1.0');
+const TYPE_WITH_UNDERSCORE = DXN.make('com.example.type.personextra', '0.1.0');
+const TYPE_WITH_UNDERSCORE_VERSIONLESS = DXN.make('com.example.type.personextra');
+const TYPE_UNDERSCORE_FALSE_POSITIVE = DXN.make('com.example.type.personaextra', '0.1.0');
 
 const TestLayer = Layer.merge(
   SqliteClient.layer({
@@ -29,20 +29,22 @@ const TestLayer = Layer.merge(
   Reactivity.layer,
 );
 
-describe('ObjectMetaIndex', () => {
+describe('EntityMetaIndex', () => {
   it.effect('should match versioned types when queried by versionless type', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const objectId = ObjectId.random();
+      const objectId = EntityId.random();
 
       const item: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectId,
@@ -53,12 +55,12 @@ describe('ObjectMetaIndex', () => {
 
       yield* index.update([item]);
 
-      const results = yield* index.query({ spaceId, typeDxn: TYPE_PERSON_VERSIONLESS });
+      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(),
+        typeDXN: DXN.make('com.example.type.other'),
       });
       expect(otherTypeResults).toEqual([]);
     }).pipe(Effect.provide(TestLayer)),
@@ -66,18 +68,20 @@ describe('ObjectMetaIndex', () => {
 
   it.effect('should not treat LIKE wildcards in versionless type queries', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const objectIdMatch = ObjectId.random();
-      const objectIdFalsePositive = ObjectId.random();
+      const objectIdMatch = EntityId.random();
+      const objectIdFalsePositive = EntityId.random();
 
       const match: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectIdMatch,
@@ -89,9 +93,11 @@ describe('ObjectMetaIndex', () => {
       // Would match prior implementation because '_' is a LIKE wildcard.
       const falsePositive: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectIdFalsePositive,
@@ -102,7 +108,7 @@ describe('ObjectMetaIndex', () => {
 
       yield* index.update([match, falsePositive]);
 
-      const queryResults = yield* index.query({ spaceId, typeDxn: TYPE_WITH_UNDERSCORE_VERSIONLESS });
+      const queryResults = yield* index.query({ spaceId, typeDXN: TYPE_WITH_UNDERSCORE_VERSIONLESS });
       expect(queryResults.map((_) => _.objectId)).toEqual([objectIdMatch]);
 
       const queryTypesResults = yield* index.queryTypes({
@@ -116,18 +122,20 @@ describe('ObjectMetaIndex', () => {
 
   it.effect('should store and update object metadata', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const objectId1 = ObjectId.random();
-      const objectId2 = ObjectId.random();
+      const objectId1 = EntityId.random();
+      const objectId2 = EntityId.random();
 
       const item1: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectId1,
@@ -139,14 +147,16 @@ describe('ObjectMetaIndex', () => {
       const item2: IndexerObject = {
         spaceId,
         queueId: null,
+        queueNamespace: null,
         documentId: 'doc-123',
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectId2,
           [ATTR_TYPE]: TYPE_RELATION,
-          [ATTR_RELATION_SOURCE]: DXN.parse(`dxn:echo:${spaceId}:${ObjectId.random()}}`).toString(),
-          [ATTR_RELATION_TARGET]: DXN.parse(`dxn:echo:${spaceId}:${ObjectId.random()}}`).toString(),
+          [ATTR_RELATION_SOURCE]: EID.make({ spaceId: spaceId, entityId: EntityId.random() }),
+          [ATTR_RELATION_TARGET]: EID.make({ spaceId: spaceId, entityId: EntityId.random() }),
           [ATTR_DELETED]: false,
         },
       };
@@ -155,12 +165,12 @@ describe('ObjectMetaIndex', () => {
       yield* index.update([item1, item2]);
 
       // Verify Query.
-      const results = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      const results = yield* index.query({ spaceId, typeDXN: TYPE_PERSON });
       expect(results.length).toBe(1);
       expect(results[0].objectId).toBe(objectId1);
       expect(results[0].version).toBe(1);
 
-      const relationResults = yield* index.query({ spaceId, typeDxn: TYPE_RELATION });
+      const relationResults = yield* index.query({ spaceId, typeDXN: TYPE_RELATION });
       expect(relationResults.length).toBe(1);
       expect(relationResults[0].objectId).toBe(objectId2);
       expect(relationResults[0].entityKind).toBe('relation');
@@ -179,7 +189,7 @@ describe('ObjectMetaIndex', () => {
 
       yield* index.update([item1Update]);
 
-      const updatedResults = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      const updatedResults = yield* index.query({ spaceId, typeDXN: TYPE_PERSON });
       // Depending on implementation, query might filter deleted or not.
       // Current implementation is SELECT * without deleted filter for queryType
       expect(updatedResults.length).toBe(1);
@@ -197,31 +207,33 @@ describe('ObjectMetaIndex', () => {
 
       yield* index.update([item2Update]);
 
-      const newTypeResults = yield* index.query({ spaceId, typeDxn: TYPE_RELATION_UPDATED });
+      const newTypeResults = yield* index.query({ spaceId, typeDXN: TYPE_RELATION_UPDATED });
       expect(newTypeResults.length).toBe(1);
       expect(newTypeResults[0].version).toBe(4);
       expect(newTypeResults[0].objectId).toBe(objectId2);
 
-      const oldTypeResults = yield* index.query({ spaceId, typeDxn: TYPE_RELATION });
+      const oldTypeResults = yield* index.query({ spaceId, typeDXN: TYPE_RELATION });
       expect(oldTypeResults.length).toBe(0);
     }).pipe(Effect.provide(TestLayer)),
   );
 
   it.effect('should support queryAll/queryTypes/queryRelations', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const objectId1 = ObjectId.random();
-      const objectId2 = ObjectId.random();
-      const relationId = ObjectId.random();
+      const objectId1 = EntityId.random();
+      const objectId2 = EntityId.random();
+      const relationId = EntityId.random();
 
       const item1: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectId1,
@@ -232,9 +244,11 @@ describe('ObjectMetaIndex', () => {
 
       const item2: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: Date.now(),
         data: {
           id: objectId2,
@@ -245,15 +259,17 @@ describe('ObjectMetaIndex', () => {
 
       const relation: IndexerObject = {
         spaceId,
-        queueId: ObjectId.random(),
+        queueId: EntityId.random(),
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: 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_RELATION_SOURCE]: EID.make({ entityId: objectId1 }),
+          [ATTR_RELATION_TARGET]: EID.make({ entityId: objectId2 }),
           [ATTR_DELETED]: false,
         },
       };
@@ -316,13 +332,13 @@ describe('ObjectMetaIndex', () => {
 
       const bySource = yield* index.queryRelations({
         endpoint: 'source',
-        anchorDxns: [DXN.fromLocalObjectId(objectId1).toString()],
+        anchorDxns: [EID.make({ entityId: objectId1 })],
       });
       expect(bySource.map((_) => _.objectId)).toEqual([relationId]);
 
       const byTarget = yield* index.queryRelations({
         endpoint: 'target',
-        anchorDxns: [DXN.fromLocalObjectId(objectId2).toString()],
+        anchorDxns: [EID.make({ entityId: objectId2 })],
       });
       expect(byTarget.map((_) => _.objectId)).toEqual([relationId]);
     }).pipe(Effect.provide(TestLayer)),
@@ -330,19 +346,21 @@ describe('ObjectMetaIndex', () => {
 
   it.effect('should set createdAt and updatedAt from source timestamp on insert and updatedAt on update', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const objectId = ObjectId.random();
-      const queueId = ObjectId.random();
+      const objectId = EntityId.random();
+      const queueId = EntityId.random();
 
       const insertTimestamp = 1700000000000;
       const item: IndexerObject = {
         spaceId,
         queueId,
+        queueNamespace: 'data',
         documentId: null,
         recordId: null,
+        createdAt: null,
         updatedAt: insertTimestamp,
         data: {
           id: objectId,
@@ -353,7 +371,7 @@ describe('ObjectMetaIndex', () => {
 
       yield* index.update([item]);
 
-      const results = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      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);
@@ -361,7 +379,7 @@ describe('ObjectMetaIndex', () => {
       const updateTimestamp = 1700001000000;
       yield* index.update([{ ...item, updatedAt: updateTimestamp, data: { ...item.data, [ATTR_DELETED]: true } }]);
 
-      const updated = yield* index.query({ spaceId, typeDxn: TYPE_PERSON });
+      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)),
@@ -369,14 +387,14 @@ describe('ObjectMetaIndex', () => {
 
   it.effect('should query by time range', () =>
     Effect.gen(function* () {
-      const index = new ObjectMetaIndex();
+      const index = new EntityMetaIndex();
       yield* index.migrate();
 
       const spaceId = SpaceId.random();
-      const queueId1 = ObjectId.random();
-      const queueId2 = ObjectId.random();
-      const objectId1 = ObjectId.random();
-      const objectId2 = ObjectId.random();
+      const queueId1 = EntityId.random();
+      const queueId2 = EntityId.random();
+      const objectId1 = EntityId.random();
+      const objectId2 = EntityId.random();
 
       const earlyTimestamp = 1700000000000;
       const midpoint = 1700000500000;
@@ -386,8 +404,10 @@ describe('ObjectMetaIndex', () => {
         {
           spaceId,
           queueId: queueId1,
+          queueNamespace: 'data',
           documentId: null,
           recordId: null,
+          createdAt: null,
           updatedAt: earlyTimestamp,
           data: { id: objectId1, [ATTR_TYPE]: TYPE_PERSON, [ATTR_DELETED]: false },
         },
@@ -397,8 +417,10 @@ describe('ObjectMetaIndex', () => {
         {
           spaceId,
           queueId: queueId2,
+          queueNamespace: 'data',
           documentId: null,
           recordId: null,
+          createdAt: null,
           updatedAt: lateTimestamp,
           data: { id: objectId2, [ATTR_TYPE]: TYPE_PERSON, [ATTR_DELETED]: false },
         },
@@ -425,4 +447,43 @@ describe('ObjectMetaIndex', () => {
       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 EntityMetaIndex();
+      yield* index.migrate();
+
+      const spaceId = SpaceId.random();
+      const traceQueueId = EntityId.random();
+      const traceObjectId = EntityId.random();
+
+      // Initial insert with 'trace' namespace.
+      const traceItem: IndexerObject = {
+        spaceId,
+        queueId: traceQueueId,
+        queueNamespace: 'trace',
+        documentId: null,
+        recordId: null,
+        createdAt: 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)),
+  );
 });