@dxos/index-core 0.0.0 → 0.8.4-main.1068cf700f

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

@@ -7,11 +7,20 @@ import type * as SqlError from '@effect/sql/SqlError';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ATTR_DELETED, ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, ATTR_TYPE } from '@dxos/echo/internal';
+import { ATTR_DELETED, ATTR_PARENT, ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, ATTR_TYPE } from '@dxos/echo/internal';
+import { DXN, type ObjectId, type SpaceId } from '@dxos/keys';
 
 import type { IndexerObject } from './interface';
 import type { Index } from './interface';
 
+const _escapeLikePrefix = (prefix: string) => {
+  // Escape LIKE metacharacters in the *literal* prefix (we still append a wildcard for the version suffix).
+  // Backslash is used as the ESCAPE character.
+  // See: https://www.sqlite.org/lang_expr.html#like
+  const escaped = prefix.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_');
+  return `${escaped}:%`;
+};
+
 export const ObjectMeta = Schema.Struct({
   recordId: Schema.Number,
   objectId: Schema.String,
@@ -19,10 +28,13 @@ export const ObjectMeta = Schema.Struct({
   spaceId: Schema.String,
   documentId: Schema.String,
   entityKind: Schema.String,
+  /** The versioned DXN of the type of the object. */
   typeDxn: Schema.String,
   deleted: Schema.Boolean,
   source: Schema.NullOr(Schema.String),
   target: Schema.NullOr(Schema.String),
+  /** Parent object id (nullable). */
+  parent: Schema.NullOr(Schema.String),
   /** Monotonically increasing sequence number assigned on insert/update for tracking indexing order. */
   version: Schema.Number,
 });
@@ -43,23 +55,124 @@ export class ObjectMetaIndex implements Index {
       deleted INTEGER NOT NULL,
       source TEXT,
       target TEXT,
+      parent TEXT,
       version INTEGER NOT NULL
     )`;
 
+    // Add `parent` column for tables created before it was introduced.
+    yield* Effect.catchAll(sql`ALTER TABLE objectMeta ADD COLUMN parent TEXT`, () => Effect.void);
+
     yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_objectId ON objectMeta(spaceId, objectId)`;
     yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_typeDxn ON objectMeta(spaceId, typeDxn)`;
     yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_version ON objectMeta(version)`;
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_parent ON objectMeta(spaceId, parent)`;
   });
 
-  query = Effect.fn('ObjectMetaIndex.queryType')(
+  query = Effect.fn('ObjectMetaIndex.query')(
     (
       query: Pick<ObjectMeta, 'spaceId' | 'typeDxn'>,
     ): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
+        const parsedType = DXN.tryParse(query.typeDxn)?.asTypeDXN();
+
         // SQLite stores booleans as integers, so we need to specify the raw row type.
         const rows =
-          yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND typeDxn = ${query.typeDxn}`;
+          parsedType && parsedType.version === undefined
+            ? yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND (typeDxn = ${
+                query.typeDxn
+              } OR typeDxn LIKE ${_escapeLikePrefix(query.typeDxn)} ESCAPE '\\')`
+            : yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND typeDxn = ${query.typeDxn}`;
+        return rows.map((row) => ({
+          ...row,
+          deleted: !!row.deleted,
+        }));
+      }),
+  );
+
+  queryAll = Effect.fn('ObjectMetaIndex.queryAll')(
+    (query: {
+      spaceIds: readonly ObjectMeta['spaceId'][];
+    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        if (query.spaceIds.length === 0) {
+          return [];
+        }
+
+        const sql = yield* SqlClient.SqlClient;
+        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sql.in('spaceId', query.spaceIds)}`;
+        return rows.map((row) => ({
+          ...row,
+          deleted: !!row.deleted,
+        }));
+      }),
+  );
+
+  queryTypes = Effect.fn('ObjectMetaIndex.queryTypes')(
+    ({
+      spaceIds,
+      typeDxns,
+      inverted = false,
+    }: {
+      spaceIds: readonly ObjectMeta['spaceId'][];
+      typeDxns: readonly ObjectMeta['typeDxn'][];
+      inverted?: boolean;
+    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        if (spaceIds.length === 0) {
+          return [];
+        }
+
+        if (typeDxns.length === 0) {
+          if (!inverted) {
+            return [];
+          }
+
+          const sql = yield* SqlClient.SqlClient;
+          const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sql.in('spaceId', spaceIds)}`;
+          return rows.map((row) => ({
+            ...row,
+            deleted: !!row.deleted,
+          }));
+        }
+        const sql = yield* SqlClient.SqlClient;
+        const spaceWhere = sql.in('spaceId', spaceIds);
+        const typeWhere = sql.or(
+          typeDxns.map((typeDxn) => {
+            const parsedType = DXN.tryParse(typeDxn)?.asTypeDXN();
+            return parsedType && parsedType.version === undefined
+              ? sql.or([sql`typeDxn = ${typeDxn}`, sql`typeDxn LIKE ${_escapeLikePrefix(typeDxn)} ESCAPE '\\'`])
+              : sql`typeDxn = ${typeDxn}`;
+          }),
+        );
+        const rows = inverted
+          ? yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${spaceWhere} AND NOT ${typeWhere}`
+          : yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${spaceWhere} AND ${typeWhere}`;
+        return rows.map((row) => ({
+          ...row,
+          deleted: !!row.deleted,
+        }));
+      }),
+  );
+
+  queryRelations = Effect.fn('ObjectMetaIndex.queryRelations')(
+    ({
+      endpoint,
+      anchorDxns,
+    }: {
+      endpoint: 'source' | 'target';
+      anchorDxns: readonly string[];
+    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        if (anchorDxns.length === 0) {
+          return [];
+        }
+        const sql = yield* SqlClient.SqlClient;
+        const column = endpoint === 'source' ? 'source' : 'target';
+        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE entityKind = 'relation' AND ${sql.in(
+          column,
+          anchorDxns,
+        )}`;
         return rows.map((row) => ({
           ...row,
           deleted: !!row.deleted,
@@ -80,7 +193,6 @@ export class ObjectMetaIndex implements Index {
               const { spaceId, queueId, documentId, data } = object;
 
               // Extract metadata (Logic emulating Echo APIs as strict imports are unavailable).
-              // TODO(agent): Verify property access matches Obj.JSON structure.
               const castData = data;
               const objectId = castData.id;
 
@@ -111,6 +223,8 @@ export class ObjectMetaIndex implements Index {
               // Relations.
               const source = entityKind === 'relation' ? (castData[ATTR_RELATION_SOURCE] ?? null) : null;
               const target = entityKind === 'relation' ? (castData[ATTR_RELATION_TARGET] ?? null) : null;
+              // Parent (nullable).
+              const parent = castData[ATTR_PARENT] ?? null;
 
               if (existing.length > 0) {
                 yield* sql`
@@ -120,18 +234,19 @@ export class ObjectMetaIndex implements Index {
                     typeDxn = ${typeDxn},
                     deleted = ${deleted},
                     source = ${source},
-                    target = ${target}
+                    target = ${target},
+                    parent = ${parent}
                   WHERE recordId = ${existing[0].recordId}
                 `;
               } else {
                 yield* sql`
                   INSERT INTO objectMeta (
                     objectId, queueId, spaceId, documentId, 
-                    entityKind, typeDxn, deleted, source, target, version
+                    entityKind, typeDxn, deleted, source, target, parent, version
                   ) VALUES (
                     ${objectId}, ${queueId ?? ''}, ${spaceId}, ${documentId ?? ''}, 
                     ${entityKind}, ${typeDxn}, ${deleted}, 
-                    ${source}, ${target}, ${version}
+                    ${source}, ${target}, ${parent}, ${version}
                   )
                 `;
               }
@@ -169,7 +284,7 @@ export class ObjectMetaIndex implements Index {
 
           if (result.length === 0) {
             // TODO(mykola): Handle this case gracefully.
-            yield* Effect.die(
+            return yield* Effect.die(
               new Error(`Object not found in ObjectMetaIndex: ${spaceId}/${documentId ?? queueId}/${objectId}`),
             );
           }
@@ -189,11 +304,31 @@ export class ObjectMetaIndex implements Index {
         }
 
         const sql = yield* SqlClient.SqlClient;
-        const placeholders = recordIds.map(() => '?').join(', ');
-        const rows = yield* sql.unsafe<ObjectMeta>(
-          `SELECT * FROM objectMeta WHERE recordId IN (${placeholders})`,
-          recordIds,
-        );
+        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sql.in('recordId', recordIds)}`;
+
+        return rows.map((row) => ({
+          ...row,
+          deleted: !!row.deleted,
+        }));
+      }),
+  );
+
+  /**
+   * Query children by parent object ids.
+   */
+  queryChildren = Effect.fn('ObjectMetaIndex.queryChildren')(
+    (query: {
+      spaceId: SpaceId[];
+      parentIds: ObjectId[];
+    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        if (query.parentIds.length === 0) {
+          return [];
+        }
+
+        const sql = yield* SqlClient.SqlClient;
+        const rows =
+          yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId IN ${sql.in(query.spaceId)} AND parent IN ${sql.in(query.parentIds.map((id) => DXN.fromLocalObjectId(id).toString()))}`;
 
         return rows.map((row) => ({
           ...row,

package/src/utils.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 
 import { invariant } from '@dxos/invariant';
 
-export type ObjectPropPath = (string | number)[];
+export type ObjectPropPath = string[];
 
 /**
  * Escaped property path within an object.