@dxos/echo 0.8.4-main.c85a9c8dae → 0.8.4-main.cb12b3f963

package/src/Extension.ts

@@ -0,0 +1,122 @@
+// @import-as-namespace
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import type * as Types from 'effect/Types';
+
+// @import-as-namespace
+
+/**
+ * Extensions allow objects to contain typed properties that are not part of the schema.
+ */
+
+export const TypeId = '~@dxos/echo/Extension' as const;
+export type TypeId = typeof TypeId;
+
+export interface Extension<T> extends Record<
+  TypeId,
+  {
+    _Type: T;
+  }
+> {
+  readonly [TypeId]: {
+    _Type: T;
+  };
+
+  readonly key: Key;
+  readonly valueSchema: Schema.Schema<T>;
+}
+
+/**
+ * Create a new typed extension.
+ *
+ * ```ts
+ * const ColorExtension = Extension.make('color', Schema.String);
+ *
+ * const obj = Obj.make(Person, {
+ *   [Obj.Meta]: { keys: [{ source: 'external', id: '123' }] },
+ *   name: 'John',
+ *   email: 'john@example.com',
+ * });
+ *
+ * Obj.update(obj, (obj) => {
+ *   Extension.set(obj.extensions, ColorExtension, 'red');
+ * });
+ *
+ * console.log(Extension.get(obj.extensions, ColorExtension)); // 'red'
+ * ```
+ */
+export const make = <S extends Schema.Schema.AnyNoContext>(
+  key: string,
+  valueSchema: S,
+): Extension<Schema.Schema.Type<S>> => {
+  return {
+    [TypeId]: {} as any,
+    key: Key.make(key),
+    valueSchema,
+  };
+};
+
+/**
+ * Unique identifier for an extension.
+ */
+// TODO(dmaretskyi): filter to be fully qualified: (e.g., org.dxos.extension.color)
+export const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/ExtensionKey'));
+export type Key = Schema.Schema.Type<typeof Key>;
+
+/**
+ * Set of extension values.
+ *
+ * Can be used inside an object/relation schema:
+ *
+ * ```ts
+ * const Person = Schema.Struct({
+ *   name: Schema.String,
+ *   extensions: Extension.Values,
+ * });
+ * ```
+ */
+export const Values = Schema.Record({ key: Key, value: Schema.Unknown });
+export interface Values extends Schema.Schema.Type<typeof Values> {}
+
+/**
+ * Get the value of an extension from a set of values.
+ */
+export const get: {
+  <T>(extension: Extension<T>): (values: Values) => Option.Option<T>;
+  <T>(values: Values, extension: Extension<T>): Option.Option<T>;
+} = Function.dual<
+  <T>(extension: Extension<T>) => (values: Values) => Option.Option<T>,
+  <T>(values: Values, extension: Extension<T>) => Option.Option<T>
+>(2, (values, extension) => {
+  if (!(extension.key in values)) {
+    return Option.none();
+  }
+
+  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);
+});
+
+/**
+ * Set the value of an extension in a set of values.
+ *
+ * Can also be used within Obj.update callback:
+ *
+ * ```ts
+ * Obj.update(obj, (obj) => {
+ *   Extension.set(obj.extensions, ColorExtension, 'red');
+ * });
+ * ```
+ */
+export const set: {
+  <T>(extension: Extension<T>, value: T): (values: Values) => void;
+  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T): void;
+} = Function.dual<
+  <T>(extension: Extension<T>, value: T) => (values: Values) => void,
+  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T) => void
+>(3, (values, extension, value) => {
+  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);
+});

package/src/Feed.ts

@@ -2,14 +2,17 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import type * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 
-import { DXN } from '@dxos/keys';
+import { DXN, type ObjectId } 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';
@@ -23,7 +26,7 @@ import * as Type from './Type';
  *
  * @example
  * ```ts
- * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'dxos.org/plugin/notifications/v1' });
+ * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });
  * ```
  */
 export const Feed = Schema.Struct({
@@ -31,11 +34,24 @@ 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: 'dxos.org/type/Feed',
+    typename: 'org.dxos.type.feed',
     version: '0.1.0',
   }),
+  internal.SystemTypeAnnotation.set(true),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--rows--regular',
+    hue: 'yellow',
+  }),
 );
 
 /**
@@ -47,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 = 'dxos.org/key/feed';
-
 /**
  * Opaque cursor for iterating over feed items.
  */
@@ -79,21 +89,45 @@ export interface RetentionOptions {
  *
  * @example
  * ```ts
- * const feed = Feed.make({ name: 'notifications', kind: 'dxos.org/plugin/notifications/v1' });
+ * const feed = Feed.make({ name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });
  * ```
  */
 // TODO(wittjosiah): How to control the feed namespace (data/trace)? Why do feeds have namespaces?
-export const make = (props: Obj.MakeProps<typeof Feed>): Feed => Obj.make(Feed, props);
+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]);
+};
+
+/**
+ * Creates a Feed object from a queue DXN, inferring the feed's id and namespace from the DXN parts.
+ *
+ * The resulting Feed, when added to the same space as the queue, will have a queue DXN
+ * equal to the input (see `Feed.getQueueDxn`). Useful when migrating `Ref(Queue)` fields to
+ * `Ref(Feed.Feed)`.
+ *
+ * @remarks Unsafe because the caller must ensure the queue DXN's space matches the database
+ * the feed is added to; the feed id is set from the queue id, bypassing id generation.
+ */
+export const unsafeFromQueueDXN = (queueDxn: DXN): Feed => {
+  const parts = queueDxn.asQueueDXN();
+  if (!parts) {
+    throw new Error(`Expected a queue DXN, got: ${queueDxn.toString()}`);
+  }
+  return Obj.make(Feed, {
+    id: parts.queueId as ObjectId,
+    namespace: parts.subspaceTag === 'trace' ? 'trace' : undefined,
+  });
 };
 
 //
@@ -105,8 +139,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.
@@ -129,21 +163,31 @@ export class Service extends Context.Tag('@dxos/echo/Feed/Service')<
   }
 >() {}
 
+/**
+ * @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>);
+} as Context.Tag.Service<FeedService>);
 
 //
 // Operations
@@ -157,9 +201,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));
   });
 
@@ -172,9 +216,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));
   });
@@ -193,10 +237,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.
@@ -207,8 +257,8 @@ 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())));
 
@@ -223,21 +273,21 @@ 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');
 
 /**
@@ -250,5 +300,5 @@ export const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<
  * ```
  */
 // TODO(feed): Implement when queue retention is supported.
-export const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, Service> =>
+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

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Match from 'effect/Match';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
@@ -12,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;
 }
@@ -276,7 +279,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,
@@ -300,7 +303,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,
@@ -308,6 +311,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.
  */
@@ -387,3 +447,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/Format.ts

@@ -4,6 +4,6 @@
 
 import type * as internal from './internal';
 
-export * from './internal/formats';
+export * from './internal/Format';
 
 export type Format = internal.TypeFormat;

package/src/Hypergraph.ts

@@ -43,9 +43,8 @@ export interface RefResolverOptions {
 }
 
 /**
- *
+ * Manages cross-space database interactions.
  */
-// TODO(burdon): Comment required.
 export interface Hypergraph extends Database.Queryable {
   get schemaRegistry(): SchemaRegistry.SchemaRegistry;
 
@@ -71,4 +70,10 @@ export interface Hypergraph extends Database.Queryable {
    */
   // TODO(dmaretskyi): Restructure API: Remove middleware.
   createRefResolver(options: RefResolverOptions): Ref.Resolver;
+
+  /**
+   * Get a database by space ID.
+   * @returns The database for the given space ID, or undefined if not found.
+   */
+  getDatabase(spaceId: Key.SpaceId): Database.Database | undefined;
 }