@dxos/echo 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/Feed.ts

@@ -12,6 +12,7 @@ import * as Schema from 'effect/Schema';
 
 import { DXN } from '@dxos/keys';
 
+import * as Annotation from './Annotation';
 import type * as Entity from './Entity';
 import type * as Filter from './Filter';
 import * as internal from './internal';
@@ -19,7 +20,6 @@ import * as Obj from './Obj';
 import type * as Query from './Query';
 import type * as QueryResult from './QueryResult';
 import * as Type from './Type';
-import * as Annotation from './Annotation';
 
 /**
  * Runtime schema for a Feed object.
@@ -34,6 +34,14 @@ export const Feed = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   /** Identifier for the feed's kind (e.g., plugin id). */
   kind: Schema.String.pipe(internal.FormInputAnnotation.set(false), Schema.optional),
+
+  /**
+   * Feed namespace.
+   * Controls how feed data is stored and replicated.
+   * - `data`: Data feed (default).
+   * - `trace`: Trace feed.
+   */
+  namespace: Schema.optional(Schema.Literal('data', 'trace')),
 }).pipe(
   Type.object({
     typename: 'org.dxos.type.feed',
@@ -55,12 +63,6 @@ export interface Feed extends Schema.Schema.Type<typeof Feed> {}
 // Types
 //
 
-/**
- * Meta key source for storing the backing DXN bound to a feed object.
- */
-// TODO(dmaretskyi): Enforce that Feed ObjectId = feed storage ID. And remove this key.
-export const DXN_KEY = 'org.dxos.key.feed';
-
 /**
  * Opaque cursor for iterating over feed items.
  */
@@ -78,6 +80,16 @@ export interface RetentionOptions {
   cursor?: string;
 }
 
+/**
+ * Sync options for a feed.
+ */
+export interface SyncOptions {
+  /** Push local changes to the server. Defaults to true. */
+  shouldPush?: boolean;
+  /** Pull remote changes from the server. Defaults to true. */
+  shouldPull?: boolean;
+}
+
 //
 // Factory
 //
@@ -94,14 +106,17 @@ export interface RetentionOptions {
 export const make = (props: Obj.MakeProps<typeof Feed> = {}): Feed => Obj.make(Feed, props);
 
 /**
- * Reads the queue DXN from feed metadata.
+ * Derives the queue DXN from the feed object's DXN.
+ * Returns `undefined` when the feed is not stored in a space yet.
  *
- * @deprecated
+ * Used internally by the feed service layer.
  */
-// TODO(wittjosiah): Align backing feed dxn's with object DXN.
 export const getQueueDxn = (feed: Feed): DXN | undefined => {
-  const keys = Obj.getKeys(feed, DXN_KEY);
-  return keys.length === 0 ? undefined : DXN.parse(keys[0].id);
+  const self = Obj.getDXN(feed).asEchoDXN();
+  if (!self || !self.spaceId) {
+    return undefined;
+  }
+  return new DXN(DXN.kind.QUEUE, [feed.namespace ?? 'data', self.spaceId, self.echoId]);
 };
 
 //
@@ -113,8 +128,8 @@ export const getQueueDxn = (feed: Feed): DXN | undefined => {
  * Provides the bridge to the underlying storage implementation.
  * Must be provided by the application layer (e.g., echo-db).
  */
-export class Service extends Context.Tag('@dxos/echo/Feed/Service')<
-  Service,
+export class FeedService extends Context.Tag('@dxos/echo/Feed/FeedService')<
+  FeedService,
   {
     /**
      * Appends items to a feed.
@@ -134,24 +149,61 @@ export class Service extends Context.Tag('@dxos/echo/Feed/Service')<
       <Q extends Query.Any>(feed: Feed, query: Q): QueryResult.QueryResult<Query.Type<Q>>;
       <F extends Filter.Any>(feed: Feed, filter: F): QueryResult.QueryResult<Filter.Type<F>>;
     };
+
+    /**
+     * Syncs the feed with the server.
+     */
+    sync(feed: Feed, options?: SyncOptions): Promise<void>;
   }
 >() {}
 
+/**
+ * @deprecated Use `FeedService` instead.
+ */
+export type Service = FeedService;
+
+/**
+ * @deprecated Use `FeedService` instead.
+ */
+export const Service = FeedService;
+
 /**
  * Layer that provides a Feed service that throws when accessed.
  * Useful as a default layer when no feed service is available.
  */
-export const notAvailable: Layer.Layer<Service> = Layer.succeed(Service, {
+export const notAvailable: Layer.Layer<FeedService> = Layer.succeed(FeedService, {
   append: () => {
-    throw new Error('Feed.Service not available');
+    throw new Error('Feed.FeedService not available');
   },
   remove: () => {
-    throw new Error('Feed.Service not available');
+    throw new Error('Feed.FeedService not available');
   },
   query: () => {
-    throw new Error('Feed.Service not available');
+    throw new Error('Feed.FeedService not available');
   },
-} as Context.Tag.Service<Service>);
+  sync: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+} as Context.Tag.Service<FeedService>);
+
+//
+// Context (per-call) service
+//
+
+/**
+ * Effect service exposing a single `Feed.Feed` as the "current" feed for a call site.
+ *
+ * @deprecated Prefer threading a `Feed.Feed` explicitly through function signatures
+ * over hiding it behind a context service.
+ */
+export class ContextFeedService extends Context.Tag('@dxos/echo/Feed/ContextFeedService')<
+  ContextFeedService,
+  {
+    readonly feed: Feed;
+  }
+>() {
+  static layer = (feed: Feed): Layer.Layer<ContextFeedService> => Layer.succeed(ContextFeedService, { feed });
+}
 
 //
 // Operations
@@ -165,9 +217,9 @@ export const notAvailable: Layer.Layer<Service> = Layer.succeed(Service, {
  * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);
  * ```
  */
-export const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, Service> =>
+export const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, FeedService> =>
   Effect.gen(function* () {
-    const service = yield* Service;
+    const service = yield* FeedService;
     yield* Effect.promise(() => service.append(feed, items));
   });
 
@@ -180,9 +232,9 @@ export const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void,
  * ```
  */
 // TODO(dmaretskyi): Should we allow snapshots here? - what does it mean to remove a snapshot?
-export const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, Service> =>
+export const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, FeedService> =>
   Effect.gen(function* () {
-    const service = yield* Service;
+    const service = yield* FeedService;
     const ids = items.map((item) => item.id);
     yield* Effect.promise(() => service.remove(feed, ids));
   });
@@ -201,10 +253,16 @@ export const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Ef
 //                   const object = yield* feed.pipe(Feed.query(Filter.type(Person))).first;
 // ... unify for Database and schema queries.
 export const query: {
-  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;
-  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;
+  <Q extends Query.Any>(
+    feed: Feed,
+    query: Q,
+  ): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, FeedService>;
+  <F extends Filter.Any>(
+    feed: Feed,
+    filter: F,
+  ): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, FeedService>;
 } = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>
-  Service.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));
+  FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));
 
 /**
  * Executes a feed query once and returns the results.
@@ -215,11 +273,26 @@ export const query: {
  * ```
  */
 export const runQuery: {
-  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;
-  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;
+  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, FeedService>;
+  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, FeedService>;
 } = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>
   query(feed, queryOrFilter as any).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));
 
+/**
+ * Syncs the feed with the server.
+ *
+ * @example
+ * ```ts
+ * yield* Feed.sync(feed);
+ * yield* Feed.sync(feed, { shouldPush: false });
+ * ```
+ */
+export const sync = (feed: Feed, options?: SyncOptions): Effect.Effect<void, never, FeedService> =>
+  Effect.gen(function* () {
+    const service = yield* FeedService;
+    yield* Effect.promise(() => service.sync(feed, options));
+  });
+
 /**
  * Creates a cursor for iterating over feed items.
  * Currently stubbed — cursor operations are not yet implemented.
@@ -231,32 +304,32 @@ export const runQuery: {
  * ```
  */
 // TODO(wittjosiah): Implement cursor operations. Use Effect streams?
-export const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, Service> =>
+export const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, FeedService> =>
   Effect.succeed({ _tag: 'Cursor' } as Cursor<T>);
 
 /**
  * Returns the next item from a feed cursor.
  * Currently stubbed — cursor operations are not yet implemented.
  */
-export const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, Service> =>
+export const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, FeedService> =>
   Effect.die('Feed.next is not yet implemented');
 
 /**
  * Returns the next item from a feed cursor as an Option.
  * Currently stubbed — cursor operations are not yet implemented.
  */
-export const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, Service> =>
+export const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, FeedService> =>
   Effect.die('Feed.nextOption is not yet implemented');
 
 /**
  * Sets the local retention policy for a feed.
- * Currently stubbed — queues do not yet support retention.
+ * Currently stubbed — feeds do not yet support retention.
  *
  * @example
  * ```ts
  * yield* Feed.setRetention(feed, { count: 1000 });
  * ```
  */
-// TODO(feed): Implement when queue retention is supported.
-export const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, Service> =>
+// TODO(dmaretskyi): Implement when feed retention is supported.
+export const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, FeedService> =>
   Effect.void;

package/src/Filter.test.ts

@@ -0,0 +1,90 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import * as Filter from './Filter';
+
+describe('Filter timestamp builders', () => {
+  test('updated({ after }) produces correct AST', () => {
+    const ts = 1700000000000;
+    const f = Filter.updated({ after: ts });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'updatedAt', operator: 'gte', value: ts });
+  });
+
+  test('updated({ before }) produces correct AST', () => {
+    const ts = 1700000000000;
+    const f = Filter.updated({ before: ts });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'updatedAt', operator: 'lte', value: ts });
+  });
+
+  test('created({ after }) produces correct AST', () => {
+    const ts = 1700000000000;
+    const f = Filter.created({ after: ts });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'createdAt', operator: 'gte', value: ts });
+  });
+
+  test('created({ before }) produces correct AST', () => {
+    const ts = 1700000000000;
+    const f = Filter.created({ before: ts });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'createdAt', operator: 'lte', value: ts });
+  });
+
+  test('updated() accepts Date objects', () => {
+    const date = new Date('2026-03-20T21:00:00Z');
+    const f = Filter.updated({ after: date });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'updatedAt', operator: 'gte', value: date.getTime() });
+  });
+
+  test('created() accepts Date objects', () => {
+    const date = new Date('2026-03-20T09:00:00Z');
+    const f = Filter.created({ before: date });
+    expect(f.ast).toEqual({ type: 'timestamp', field: 'createdAt', operator: 'lte', value: date.getTime() });
+  });
+
+  test('updated({ after, before }) produces AND of two timestamp nodes', () => {
+    const from = 1700000000000;
+    const to = 1700086400000;
+    const f = Filter.updated({ after: from, before: to });
+    expect(f.ast).toEqual({
+      type: 'and',
+      filters: [
+        { type: 'timestamp', field: 'updatedAt', operator: 'gte', value: from },
+        { type: 'timestamp', field: 'updatedAt', operator: 'lte', value: to },
+      ],
+    });
+  });
+
+  test('updated({ after, before }) accepts Date objects', () => {
+    const from = new Date('2026-03-19T00:00:00Z');
+    const to = new Date('2026-03-20T00:00:00Z');
+    const f = Filter.updated({ after: from, before: to });
+    expect(f.ast).toEqual({
+      type: 'and',
+      filters: [
+        { type: 'timestamp', field: 'updatedAt', operator: 'gte', value: from.getTime() },
+        { type: 'timestamp', field: 'updatedAt', operator: 'lte', value: to.getTime() },
+      ],
+    });
+  });
+
+  test('timestamp filters compose with and()', () => {
+    const typeFilter = Filter.everything();
+    const timeFilter = Filter.updated({ after: 1700000000000 });
+    const combined = Filter.and(typeFilter, timeFilter);
+    expect(combined.ast.type).toBe('and');
+    expect((combined.ast as any).filters).toHaveLength(2);
+    expect((combined.ast as any).filters[1]).toEqual({
+      type: 'timestamp',
+      field: 'updatedAt',
+      operator: 'gte',
+      value: 1700000000000,
+    });
+  });
+
+  test('timestamp filters pass the is() check', () => {
+    const f = Filter.updated({ after: Date.now() });
+    expect(Filter.is(f)).toBe(true);
+  });
+});

package/src/Filter.ts

@@ -14,11 +14,12 @@ import { assertArgument } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
 import * as internal from './internal';
+import type * as Obj from './Obj';
 import * as Ref from './Ref';
 
 export interface Filter<T> {
   // TODO(dmaretskyi): See new effect-schema approach to variance.
-  '~Filter': { value: Types.Contravariant<T> };
+  '~Filter': { value: Types.Covariant<T> };
 
   ast: QueryAST.Filter;
 }
@@ -157,6 +158,37 @@ export const tag = (tag: string): Any => {
   });
 };
 
+/**
+ * Options for {@link key} filter.
+ */
+export type KeyFilterOptions = {
+  /**
+   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).
+   * Matches the object's meta `version` field against the range.
+   * If omitted, matches any version (including objects with no version).
+   */
+  version?: string;
+};
+
+/**
+ * Filter by registry key stored in object meta.
+ *
+ * @example
+ * ```ts
+ * Filter.key('org.example.type.foo');
+ * Filter.key('org.example.type.foo', { version: '^1.2.3' });
+ * ```
+ */
+export const key = (key: string, options?: KeyFilterOptions): Any => {
+  return new FilterClass({
+    type: 'object',
+    typename: null,
+    props: {},
+    metaKey: key,
+    metaVersion: options?.version,
+  });
+};
+
 /**
  * Filter by properties.
  */
@@ -278,7 +310,7 @@ export const lte = <T>(value: T): Filter<T | undefined> => {
  * Predicate for property to be in the provided array.
  * @param values - Values to check against.
  */
-const in$ = <T>(...values: T[]): Filter<T | undefined> => {
+const in$ = <T>(...values: T[]): Filter<T> => {
   return new FilterClass({
     type: 'in',
     values,
@@ -302,7 +334,7 @@ export const contains = <T>(value: T): Filter<readonly T[] | undefined> => {
  * @param from - Start of the range (inclusive).
  * @param to - End of the range (exclusive).
  */
-export const between = <T>(from: T, to: T): Filter<unknown> => {
+export const between = <T>(from: T, to: T): Filter<T> => {
   return new FilterClass({
     type: 'range',
     from,
@@ -310,6 +342,63 @@ export const between = <T>(from: T, to: T): Filter<unknown> => {
   });
 };
 
+type TimeRange = { after?: Date | number; before?: Date | number };
+
+const _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());
+
+const _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {
+  const filters: Any[] = [];
+  if (range.after != null) {
+    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));
+  }
+  if (range.before != null) {
+    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));
+  }
+  if (filters.length === 0) {
+    return everything();
+  }
+  return filters.length === 1 ? filters[0] : and(...filters);
+};
+
+/**
+ * Filter objects by updatedAt timestamp.
+ */
+export const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);
+
+/**
+ * Filter objects by createdAt timestamp.
+ */
+export const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);
+
+export type ChildOfOptions = {
+  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */
+  transitive?: boolean;
+};
+
+/**
+ * Filter objects that are children of the specified parent(s).
+ * Accepts ECHO objects, Refs, or arrays of either.
+ * Refs are resolved to DXNs without loading; objects use {@link Obj.getDXN}.
+ * With transitive=true (default), also matches grandchildren and beyond.
+ */
+export const childOf = (
+  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],
+  options?: ChildOfOptions,
+): Any => {
+  const items = Array.isArray(parents) ? parents : [parents];
+  const dxns = items.map((item) => {
+    if (Ref.isRef(item)) {
+      return item.dxn.toString();
+    }
+    return internal.getDXN(item).toString();
+  });
+  return new FilterClass({
+    type: 'child-of',
+    parents: dxns,
+    transitive: options?.transitive ?? true,
+  });
+};
+
 /**
  * Negate the filter.
  */
@@ -389,3 +478,8 @@ const processPredicate = (predicate: any): QueryAST.Filter => {
     Match.orElse((value) => eq(value).ast),
   );
 };
+
+/**
+ * Returns a human-readable string representation of a Filter AST.
+ */
+export const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);

package/src/Hypergraph.ts

@@ -22,10 +22,10 @@ export interface RefResolutionContext {
   space?: Key.SpaceId;
 
   /**
-   * Queue that the resolution is happening from.
-   * This queue will be searched first, and then the space it belongs to.
+   * Feed that the resolution is happening from (as the underlying queue DXN).
+   * This feed will be searched first, and then the space it belongs to.
    */
-  queue?: DXN;
+  feed?: DXN;
 }
 
 export interface RefResolverOptions {