@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/src/Feed.ts

@@ -0,0 +1,352 @@
+//
+// 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, EID } 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';
+import * as Obj from './Obj';
+import type * as Query from './Query';
+import type * as QueryResult from './QueryResult';
+import * as Type from './Type';
+
+/**
+ * Runtime schema for a Feed object.
+ *
+ * @example
+ * ```ts
+ * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });
+ * ```
+ */
+export const Feed = Schema.Struct({
+  /** User-facing display name. */
+  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(
+  internal.HiddenAnnotation.set(true),
+  Annotation.IconAnnotation.set({ icon: 'ph--rows--regular', hue: 'yellow' }),
+  Type.makeObject(DXN.make('org.dxos.type.feed', '0.1.0')),
+);
+
+/**
+ * TypeScript instance type for a Feed object.
+ */
+export type Feed = Type.InstanceType<typeof Feed>;
+
+//
+// Types
+//
+
+/**
+ * Opaque cursor for iterating over feed items.
+ */
+// TODO(dmaretskyi): T needs to be referenced in the type structure for typescript to respect it during inference and type-checking.
+export interface Cursor<T = Obj.Snapshot> {
+  readonly _tag: 'Cursor';
+}
+
+/**
+ * Retention options for a feed.
+ */
+export interface RetentionOptions {
+  /** Retain items after this cursor position. */
+  // TODO(wittjosiah): Use FeedCursor from @dxos/feed?
+  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;
+}
+
+/**
+ * Queue replication backlog for a feed namespace.
+ * `0` / `0` means caught up on pull and push.
+ */
+export interface SyncState {
+  /** Blocks still to pull from remote. */
+  blocksToPull: number;
+  /** Unpositioned blocks still to push to remote. */
+  blocksToPush: number;
+  /** Total blocks stored locally for the feed namespace. */
+  totalBlocks: number;
+}
+
+//
+// Factory
+//
+
+/**
+ * Creates a new feed object.
+ *
+ * @example
+ * ```ts
+ * 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);
+
+/**
+ * Returns the feed object's EID when the feed is stored in a space.
+ *
+ * Used internally by the feed service layer.
+ */
+export const getQueueUri = (feed: Feed): EID.EID | undefined => EID.tryParse(Obj.getURI(feed));
+
+//
+// Service
+//
+
+/**
+ * Effect service for feed operations.
+ * Provides the bridge to the underlying storage implementation.
+ * Must be provided by the application layer (e.g., echo-db).
+ */
+export class FeedService extends Context.Tag('@dxos/echo/Feed/FeedService')<
+  FeedService,
+  {
+    /**
+     * Appends items to a feed.
+     */
+    append(feed: Feed, items: Entity.Unknown[]): Promise<void>;
+
+    /**
+     * Removes items from a feed by ID.
+     */
+    remove(feed: Feed, ids: string[]): Promise<void>;
+
+    /**
+     * Queries items in a feed.
+     */
+    query: {
+      <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>;
+
+    /**
+     * Returns queue replication backlog for the feed's namespace.
+     */
+    getSyncState(feed: Feed): Promise<SyncState>;
+  }
+>() {}
+
+/**
+ * @deprecated Use `FeedService` instead.
+ */
+export type Service = FeedService;
+
+/**
+ * @deprecated Use `FeedService` instead.
+ */
+export const Service = FeedService;
+
+/**
+ * Effect context service that holds the current feed for a scoped operation.
+ *
+ * @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 });
+}
+
+/**
+ * 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<FeedService> = Layer.succeed(FeedService, {
+  append: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+  remove: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+  query: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+  sync: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+  getSyncState: () => {
+    throw new Error('Feed.FeedService not available');
+  },
+} as Context.Tag.Service<FeedService>);
+
+//
+// Operations
+//
+
+/**
+ * Appends items to a feed.
+ *
+ * @example
+ * ```ts
+ * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);
+ * ```
+ */
+export const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, FeedService> =>
+  Effect.gen(function* () {
+    const service = yield* FeedService;
+    yield* Effect.promise(() => service.append(feed, items));
+  });
+
+/**
+ * Removes items from a feed.
+ *
+ * @example
+ * ```ts
+ * yield* Feed.remove(feed, [item]);
+ * ```
+ */
+// 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, FeedService> =>
+  Effect.gen(function* () {
+    const service = yield* FeedService;
+    const ids = items.map((item) => item.id);
+    yield* Effect.promise(() => service.remove(feed, ids));
+  });
+
+/**
+ * Creates a reactive query over items in a feed.
+ *
+ * @example
+ * ```ts
+ * const result = yield* Feed.query(feed, Filter.type(Person));
+ * ```
+ */
+// TODO(dmaretskyi): Suport chained queries:
+//                   const result = yield* feed.pipe(Feed.query(Filter.type(Person))); result.subscribe(...)
+//                   const objects = yield* feed.pipe(Feed.query(Filter.type(Person))).run;
+//                   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, 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) =>
+  FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));
+
+/**
+ * Executes a feed query once and returns the results.
+ *
+ * @example
+ * ```ts
+ * const items = yield* Feed.runQuery(feed, Filter.type(Person));
+ * ```
+ */
+export const runQuery: {
+  <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));
+  });
+
+/**
+ * Returns queue replication backlog for the feed's namespace.
+ *
+ * @example
+ * ```ts
+ * const { blocksToPull, blocksToPush } = yield* Feed.getSyncState(feed);
+ * ```
+ */
+export const getSyncState = (feed: Feed): Effect.Effect<SyncState, never, FeedService> =>
+  Effect.gen(function* () {
+    const service = yield* FeedService;
+    return yield* Effect.promise(() => service.getSyncState(feed));
+  });
+
+/**
+ * Creates a cursor for iterating over feed items.
+ * Currently stubbed — cursor operations are not yet implemented.
+ *
+ * @example
+ * ```ts
+ * const cursor = yield* Feed.cursor<Person>(feed);
+ * const item = yield* Feed.next(cursor);
+ * ```
+ */
+// TODO(wittjosiah): Implement cursor operations. Use Effect streams?
+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, 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, FeedService> =>
+  Effect.die('Feed.nextOption is not yet implemented');
+
+/**
+ * Sets the local retention policy for a feed.
+ * Currently stubbed — feeds do not yet support retention.
+ *
+ * @example
+ * ```ts
+ * yield* Feed.setRetention(feed, { count: 1000 });
+ * ```
+ */
+// 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);
+  });
+});