@dxos/echo 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/src/Err.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import { BaseError, type BaseErrorOptions } from '@dxos/errors';
 import { type DXN } from '@dxos/keys';
 
@@ -16,3 +18,23 @@ export class ObjectNotFoundError extends BaseError.extend('ObjectNotFoundError',
     super({ context: { dxn }, ...options });
   }
 }
+
+/**
+ * Reason why getting a reactive object from a snapshot failed.
+ * - `no-database`: The snapshot is not associated with a database.
+ * - `object-not-found`: The object was removed or does not exist in the database.
+ */
+export type GetReactiveErrorReason = 'no-database' | 'object-not-found';
+
+/**
+ * Error thrown when a reactive object cannot be resolved from a snapshot.
+ * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.
+ */
+export class GetReactiveError extends BaseError.extend(
+  'GetReactiveError',
+  'Failed to get reactive object from snapshot',
+) {
+  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {
+    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });
+  }
+}

package/src/Extension.test.ts

@@ -0,0 +1,235 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import * as Extension from './Extension';
+
+describe('Extension', () => {
+  describe('make', () => {
+    test('creates an extension with a string schema', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+
+      expect(ColorExtension.key).toBe('color');
+      expect(ColorExtension.valueSchema).toBe(Schema.String);
+      expect(ColorExtension[Extension.TypeId]).toBeDefined();
+    });
+
+    test('creates an extension with a number schema', ({ expect }) => {
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+
+      expect(PriorityExtension.key).toBe('priority');
+      expect(PriorityExtension.valueSchema).toBe(Schema.Number);
+    });
+
+    test('creates an extension with a complex schema', ({ expect }) => {
+      const MetadataSchema = Schema.Struct({
+        author: Schema.String,
+        version: Schema.Number,
+        tags: Schema.Array(Schema.String),
+      });
+      const MetadataExtension = Extension.make('metadata', MetadataSchema);
+
+      expect(MetadataExtension.key).toBe('metadata');
+      expect(MetadataExtension.valueSchema).toBe(MetadataSchema);
+    });
+  });
+
+  describe('get and set', () => {
+    test('set and get a string value', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'red');
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('red');
+    });
+
+    test('set and get a number value', ({ expect }) => {
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+      const values: Extension.Values = {};
+
+      Extension.set(values, PriorityExtension, 42);
+      const result = Extension.get(values, PriorityExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(42);
+    });
+
+    test('set and get a boolean value', ({ expect }) => {
+      const EnabledExtension = Extension.make('enabled', Schema.Boolean);
+      const values: Extension.Values = {};
+
+      Extension.set(values, EnabledExtension, true);
+      const result = Extension.get(values, EnabledExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(true);
+    });
+
+    test('set and get a complex object value', ({ expect }) => {
+      const ConfigSchema = Schema.Struct({
+        theme: Schema.String,
+        fontSize: Schema.Number,
+        darkMode: Schema.Boolean,
+      });
+      const ConfigExtension = Extension.make('config', ConfigSchema);
+      const values: Extension.Values = {};
+
+      const config = { theme: 'modern', fontSize: 14, darkMode: true };
+      Extension.set(values, ConfigExtension, config);
+      const result = Extension.get(values, ConfigExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(config);
+    });
+
+    test('set and get an array value', ({ expect }) => {
+      const TagsExtension = Extension.make('tags', Schema.Array(Schema.String));
+      const values: Extension.Values = {};
+
+      const tags = ['important', 'urgent', 'review'];
+      Extension.set(values, TagsExtension, tags);
+      const result = Extension.get(values, TagsExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(tags);
+    });
+
+    test('get returns None for missing extension', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isNone(result)).toBe(true);
+    });
+
+    test('overwriting an extension value', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'red');
+      Extension.set(values, ColorExtension, 'blue');
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('blue');
+    });
+
+    test('multiple extensions on the same values object', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+      const EnabledExtension = Extension.make('enabled', Schema.Boolean);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'green');
+      Extension.set(values, PriorityExtension, 5);
+      Extension.set(values, EnabledExtension, false);
+
+      expect(Option.getOrThrow(Extension.get(values, ColorExtension))).toBe('green');
+      expect(Option.getOrThrow(Extension.get(values, PriorityExtension))).toBe(5);
+      expect(Option.getOrThrow(Extension.get(values, EnabledExtension))).toBe(false);
+    });
+  });
+
+  describe('curried forms', () => {
+    test('get curried form', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+      Extension.set(values, ColorExtension, 'purple');
+
+      const getColor = Extension.get(ColorExtension);
+      const result = getColor(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('purple');
+    });
+
+    test('set curried form', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      const setOrange = Extension.set(ColorExtension, 'orange');
+      setOrange(values);
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('orange');
+    });
+
+    test('curried forms work in pipelines', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(ColorExtension, 'cyan')(values);
+      const result = Extension.get(ColorExtension)(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('cyan');
+    });
+  });
+
+  describe('Key', () => {
+    test('Key.make creates a branded key', ({ expect }) => {
+      const key = Extension.Key.make('my-extension');
+
+      expect(key).toBe('my-extension');
+      expect(typeof key).toBe('string');
+    });
+  });
+
+  describe('Values schema', () => {
+    test('Values can be used as a schema', ({ expect }) => {
+      const PersonWithExtensions = Schema.Struct({
+        name: Schema.String,
+        extensions: Extension.Values,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithExtensions)({
+        name: 'Alice',
+        extensions: {},
+      });
+
+      expect(person.name).toBe('Alice');
+      expect(person.extensions).toEqual({});
+    });
+
+    test('Values schema accepts extension data', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+      Extension.set(values, ColorExtension, 'red');
+
+      const PersonWithExtensions = Schema.Struct({
+        name: Schema.String,
+        extensions: Extension.Values,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithExtensions)({
+        name: 'Bob',
+        extensions: values,
+      });
+
+      expect(person.name).toBe('Bob');
+      const color = Extension.get(person.extensions, ColorExtension);
+      expect(Option.getOrThrow(color)).toBe('red');
+    });
+  });
+
+  describe('TypeId', () => {
+    test('TypeId is a unique symbol-like string', ({ expect }) => {
+      expect(Extension.TypeId).toBe('~@dxos/echo/Extension');
+    });
+
+    test('extensions have TypeId property', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+
+      expect(Extension.TypeId in ColorExtension).toBe(true);
+    });
+  });
+});

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);
+});