@dxos/echo 0.8.4-main.7ace549 → 0.8.4-main.8360d9e660

package/src/internal/common/proxy/proxy-utils.ts

@@ -0,0 +1,150 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+
+import { type ReactiveHandler } from './proxy-types';
+
+export const symbolIsProxy = Symbol.for('@dxos/schema/Proxy');
+
+/**
+ * Internal api.
+ */
+export const isProxy = (value: unknown) => !!(value as any)?.[symbolIsProxy];
+
+export const isValidProxyTarget = (value: any): value is object => {
+  if (value == null || value[symbolIsProxy]) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+
+  return typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;
+};
+
+/**
+ * @deprecated
+ */
+export const getProxySlot = <T extends object>(proxy: any): ProxyHandlerSlot<T> => {
+  const value = (proxy as any)[symbolIsProxy];
+  invariant(value instanceof ProxyHandlerSlot);
+  return value;
+};
+
+export const getProxyTarget = <T extends object>(proxy: any): T => {
+  return getProxySlot<T>(proxy).target;
+};
+
+export const getProxyHandler = <T extends object>(proxy: any): ReactiveHandler<T> => {
+  return getProxySlot<T>(proxy).handler;
+};
+
+/**
+ * Unsafe method to override id for debugging/testing and migration purposes.
+ * @deprecated
+ */
+export const dangerouslySetProxyId = <T>(obj: T, id: string) => {
+  (getProxySlot(obj).target as any).id = id;
+};
+
+/**
+ * Create a reactive proxy object.
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+ *
+ * @param target Object or array. Passing in array will enable array methods.
+ * @param handler ReactiveHandler instance.
+ */
+// TODO(burdon): Document.
+// TODO(burdon): Tests for low-level functions.
+export const createProxy = <T extends object>(target: T, handler: ReactiveHandler<T>): T => {
+  const existingProxy = handler._proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+
+  // TODO(dmaretskyi): In the future this should be mutable to allow replacing the handler on-the-fly while maintaining the proxy identity.
+  const proxy = new Proxy(target, new ProxyHandlerSlot<T>(target, handler));
+  handler.init(target);
+
+  // TODO(dmaretskyi): Check if this will actually work; maybe a global WeakMap is better?
+  handler._proxyMap.set(target, proxy);
+  return proxy;
+};
+
+/**
+ * Passed as the handler to the Proxy constructor.
+ * Maintains a mutable slot for the actual handler.
+ */
+class ProxyHandlerSlot<T extends object> implements ProxyHandler<T> {
+  /**
+   * @param target Original object.
+   * @param _handler Handles intercepted operations.
+   */
+  constructor(
+    readonly target: T,
+    private _handler: ReactiveHandler<T>,
+  ) {}
+
+  get handler() {
+    invariant(this._handler);
+    return this._handler;
+  }
+
+  // TODO(burdon): Requires comment.
+  setHandler(handler: ReactiveHandler<T>): void {
+    this._handler = handler;
+  }
+
+  /**
+   * Get value.
+   */
+  get(target: T, prop: string | symbol, receiver: any): any {
+    if (prop === symbolIsProxy) {
+      return this;
+    }
+
+    if (!this._handler || !this._handler.get) {
+      return Reflect.get(target, prop, receiver);
+    }
+
+    return this._handler.get(target, prop, receiver);
+  }
+
+  static {
+    const TRAPS: (keyof ProxyHandler<any>)[] = [
+      'apply',
+      'construct',
+      'defineProperty',
+      'deleteProperty',
+      'get',
+      'getOwnPropertyDescriptor',
+      'getPrototypeOf',
+      'has',
+      'isExtensible',
+      'ownKeys',
+      'preventExtensions',
+      'set',
+      'setPrototypeOf',
+    ];
+
+    for (const trap of TRAPS) {
+      if (trap === 'get') {
+        continue;
+      }
+
+      Object.defineProperty(this.prototype, trap, {
+        enumerable: false,
+        value: function (this: ProxyHandlerSlot<any>, ...args: any[]) {
+          // log.info('trap', { trap, args });
+          if (!this._handler || !this._handler[trap]) {
+            return (Reflect[trap] as Function)(...args);
+          }
+
+          return (this._handler[trap] as Function).apply(this._handler, args);
+        },
+      });
+    }
+  }
+}

package/src/internal/common/proxy/reactive-array.ts

@@ -0,0 +1,71 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { isInChangeContext } from './change-context';
+import { createArrayMethodError } from './errors';
+import { batchEvents } from './event-batch';
+import { getEchoRoot } from './ownership';
+import { getProxyTarget, isProxy } from './proxy-utils';
+import { ChangeId, EventId } from './symbols';
+
+/**
+ * Check if array mutation is allowed (inside a change context).
+ * Throws a descriptive error if not.
+ */
+const checkArrayMutationAllowed = (arr: any, method: string): void => {
+  // Get the raw target - if arr is a proxy, get its underlying target.
+  const target = isProxy(arr) ? getProxyTarget(arr) : arr;
+
+  // Find the root ECHO object.
+  const echoRoot = getEchoRoot(target);
+
+  // Check if initialized (has ChangeId marker or EventId).
+  const isInitialized = (echoRoot as any)[ChangeId] === true || EventId in echoRoot;
+  if (!isInitialized) {
+    // Array is still being initialized, allow mutations.
+    return;
+  }
+
+  if (!isInChangeContext(echoRoot)) {
+    throw createArrayMethodError(method);
+  }
+};
+
+/**
+ * Extends the native array to make sure that arrays methods are correctly reactive.
+ * Enforces that mutations only happen within Obj.change() context.
+ */
+export class ReactiveArray<T> extends Array<T> {
+  static override get [Symbol.species]() {
+    return Array;
+  }
+
+  static {
+    /**
+     * These methods will trigger proxy traps like `set` and `defineProperty` and emit event notifications.
+     * We wrap them in a batch to avoid unnecessary event notifications.
+     * Change context is checked before allowing mutations.
+     *
+     * Note: When called on a proxy, `this` will be the proxy, so array mutations
+     * go through the proxy's set trap which handles event emission.
+     */
+    const BATCHED_METHODS = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'] as const;
+
+    for (const method of BATCHED_METHODS) {
+      Object.defineProperty(this.prototype, method, {
+        enumerable: false,
+        value: function (this: ReactiveArray<any>, ...args: any[]) {
+          // Check change context before allowing mutation.
+          checkArrayMutationAllowed(this, method);
+
+          let result!: any;
+          batchEvents(() => {
+            result = Array.prototype[method].apply(this, args);
+          });
+          return result;
+        },
+      });
+    }
+  }
+}

package/src/internal/common/proxy/reactive.ts

@@ -0,0 +1,69 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type RefTypeId } from '../../Ref/ref';
+
+import { getProxyTarget } from './proxy-utils';
+import { ChangeId, EventId } from './symbols';
+
+/**
+ * Subscribe to changes on a reactive object.
+ * @param obj - The reactive object to subscribe to.
+ * @param callback - Called when the object changes.
+ * @returns Unsubscribe function.
+ */
+// TODO(wittjosiah): Consider throwing if obj doesn't have EventId instead of returning no-op.
+export const subscribe = (obj: unknown, callback: () => void): (() => void) => {
+  const target = getProxyTarget(obj as any);
+  if (target && EventId in target) {
+    return (target as any)[EventId].on(callback);
+  }
+  return () => {};
+};
+
+/**
+ * Deeply removes readonly modifiers from all properties of T.
+ * Inside Obj.change, all properties are fully mutable regardless of schema definition.
+ * Ref types are preserved as-is since they are value-like objects that are replaced, not mutated.
+ * Primitive types (including branded primitives) are preserved as-is.
+ */
+export type Mutable<T> = T extends string | number | boolean | bigint | symbol | null | undefined
+  ? T // Primitives (including branded primitives like JsonPath) stay as-is.
+  : T extends { [RefTypeId]: any }
+    ? T // Keep Ref types as-is (they're value-like, not mutated in place).
+    : T extends object
+      ? T extends readonly (infer U)[]
+        ? Mutable<U>[]
+        : { -readonly [K in keyof T]: Mutable<T[K]> }
+      : T;
+
+/**
+ * Callback type for the change function.
+ */
+export type ChangeCallback<T> = (mutableObj: Mutable<T>) => void;
+
+/**
+ * Perform mutations on a reactive object within a change context.
+ *
+ * If the object has a change handler (via ChangeId), it will be called with the callback.
+ * This allows handlers to implement features like:
+ * - Readonly enforcement (mutations only allowed within change context)
+ * - Batched notifications (single notification for all mutations in the callback)
+ * - Transaction semantics
+ *
+ * If the object doesn't have a change handler, the callback is called directly.
+ *
+ * @param obj - The reactive object to mutate.
+ * @param callback - Callback that receives a mutable view of the object.
+ */
+export const change = <T>(obj: T, callback: ChangeCallback<T>): void => {
+  // Check proxy first (allows handler to intercept), then fall back to target.
+  // This order is important for EchoReactiveHandler which handles ChangeId in the proxy trap.
+  const changeFn = (obj as any)[ChangeId];
+  if (changeFn) {
+    changeFn(callback);
+  } else {
+    callback(obj as Mutable<T>);
+  }
+};

package/src/internal/{object → common/proxy}/schema-validator.ts

@@ -6,6 +6,7 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
 
 import { SchemaId } from '../types';
 
@@ -67,7 +68,8 @@ export class SchemaValidator {
           getProperty([...propertyPath.slice(0, i), propertyName]),
         );
         if (propertyType == null) {
-          throw new TypeError(`unknown property: ${String(propertyName)} on object. Path: ${propertyPath}`);
+          log.warn('unknown property', { path: propertyPath, property: propertyName });
+          continue;
         }
 
         schema = Schema.make(propertyType).annotations(propertyType.annotations);

package/src/internal/{proxy → common/proxy}/schema.test.ts

@@ -6,25 +6,31 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
-import { createEchoSchema } from '../../testing';
-import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../annotations';
-import { TypedObject } from '../object';
+import { createEchoSchema } from '../../../testing';
+import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../../Annotation';
+import { EchoObjectSchema } from '../../Entity';
 
 // TODO(dmaretskyi): Comment.
-class EmptySchemaType extends TypedObject({
-  typename: 'example.com/type/Empty',
-  version: '0.1.0',
-})({}) {}
+const EmptySchemaType = Schema.Struct({}).pipe(
+  EchoObjectSchema({
+    typename: 'com.example.type.empty',
+    version: '0.1.0',
+  }),
+);
+
+interface EmptySchemaType extends Schema.Schema.Type<typeof EmptySchemaType> {}
 
 describe('dynamic schema', () => {
   test('getProperties filters out id and unwraps optionality', async () => {
-    class TestSchema extends TypedObject({
-      typename: 'example.com/type/Test',
-      version: '0.1.0',
-    })({
+    const TestSchema = Schema.Struct({
       field1: Schema.String,
       field2: Schema.Boolean,
-    }) {}
+    }).pipe(
+      EchoObjectSchema({
+        typename: 'com.example.type.test',
+        version: '0.1.0',
+      }),
+    );
 
     const registered = createEchoSchema(TestSchema);
     expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
@@ -34,12 +40,14 @@ describe('dynamic schema', () => {
   });
 
   test('addColumns', async () => {
-    class TestSchema extends TypedObject({
-      typename: 'example.com/type/Test',
-      version: '0.1.0',
-    })({
+    const TestSchema = Schema.Struct({
       field1: Schema.String,
-    }) {}
+    }).pipe(
+      EchoObjectSchema({
+        typename: 'com.example.type.test',
+        version: '0.1.0',
+      }),
+    );
 
     const registered = createEchoSchema(TestSchema);
     registered.addFields({ field2: Schema.Boolean });
@@ -87,7 +95,7 @@ describe('dynamic schema', () => {
     registered.updateFields({ field3: Schema.Boolean });
     registered.removeFields(['field2']);
     expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Empty',
+      typename: 'com.example.type.empty',
       version: '0.1.0',
     });
     expect(getPropertyMetaAnnotation(registered.getProperties()[0], metaNamespace)).to.deep.eq(metaInfo);
@@ -103,7 +111,7 @@ describe('dynamic schema', () => {
     });
 
     // First update.
-    const newTypename1 = 'example.com/type/Individual';
+    const newTypename1 = 'com.example.type.individual';
     registered.updateTypename(newTypename1);
 
     // Basic typename update checks.
@@ -124,13 +132,13 @@ describe('dynamic schema', () => {
     expect(nameMeta).toEqual({ maxLength: 10 });
 
     // Second update to ensure multiple updates work.
-    const newTypename2 = 'example.com/type/Person';
+    const newTypename2 = 'com.example.type.person';
     registered.updateTypename(newTypename2);
     expect(registered.typename).toBe(newTypename2);
     expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename2}`);
     expect(registered.jsonSchema.typename).toBe(newTypename2);
     expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Person',
+      typename: 'com.example.type.person',
       version: '0.1.0',
     });
   });

package/src/internal/common/proxy/symbols.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(dmaretskyi): Rename all symbols that are props to end with *Key.
+export const EventId = Symbol.for('@dxos/live-object/EventId');
+export const ChangeId = Symbol.for('@dxos/live-object/ChangeId');