@dxos/echo 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

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

@@ -4,9 +4,9 @@
 
 import { describe, test } from 'vitest';
 
-import * as Obj from '../../Obj';
-import * as Relation from '../../Relation';
-import { TestSchema } from '../../testing';
+import * as Obj from '../../../Obj';
+import * as Relation from '../../../Relation';
+import { TestSchema } from '../../../testing';
 
 /**
  * Tests for Obj.change context enforcement and mutator type safety.
@@ -59,8 +59,8 @@ describe('Obj.change enforcement', () => {
     test('getMeta returns mutable ObjectMeta inside change callback', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (mutableObj) => {
-        const meta = Obj.getMeta(mutableObj);
+      Obj.change(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
 
         // These should compile without errors because meta is ObjectMeta (mutable).
         meta.keys = [];
@@ -76,9 +76,9 @@ describe('Obj.change enforcement', () => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
       // These should compile without errors inside change callback.
-      Obj.change(obj, (mutableObj) => {
-        Obj.addTag(mutableObj, 'my-tag');
-        Obj.setValue(mutableObj, ['name'], 'Updated');
+      Obj.change(obj, (obj) => {
+        Obj.addTag(obj, 'my-tag');
+        Obj.setValue(obj, ['name'], 'Updated');
       });
 
       expect(obj.name).toBe('Updated');
@@ -122,8 +122,8 @@ describe('Obj.change enforcement', () => {
       // Person schema uses 'name' as label field.
       expect(Obj.getLabel(obj)).toBe('John');
 
-      Obj.change(obj, (o) => {
-        Obj.setLabel(o, 'Jane');
+      Obj.change(obj, (obj) => {
+        Obj.setLabel(obj, 'Jane');
       });
 
       // setLabel updates the name field.
@@ -140,8 +140,8 @@ describe('Obj.change enforcement', () => {
 
       // setDescription only works if schema has description annotation.
       // For schemas without it, this is a no-op.
-      Obj.change(obj, (o) => {
-        Obj.setDescription(o, 'My Description');
+      Obj.change(obj, (obj) => {
+        Obj.setDescription(obj, 'My Description');
       });
 
       // Verify setDescription doesn't throw.
@@ -153,15 +153,15 @@ describe('Obj.change enforcement', () => {
 
       expect(Obj.getMeta(obj).tags).toBeUndefined();
 
-      Obj.change(obj, (o) => {
-        Obj.addTag(o, 'tag-1');
-        Obj.addTag(o, 'tag-2');
+      Obj.change(obj, (obj) => {
+        Obj.addTag(obj, 'tag-1');
+        Obj.addTag(obj, 'tag-2');
       });
 
       expect(Obj.getMeta(obj).tags).toEqual(['tag-1', 'tag-2']);
 
-      Obj.change(obj, (o) => {
-        Obj.removeTag(o, 'tag-1');
+      Obj.change(obj, (obj) => {
+        Obj.removeTag(obj, 'tag-1');
       });
 
       expect(Obj.getMeta(obj).tags).toEqual(['tag-2']);
@@ -170,8 +170,8 @@ describe('Obj.change enforcement', () => {
     test('deleteKeys removes foreign keys by source', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        const meta = Obj.getMeta(o);
+      Obj.change(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
         meta.keys.push({ source: 'source-a', id: '1' });
         meta.keys.push({ source: 'source-a', id: '2' });
         meta.keys.push({ source: 'source-b', id: '3' });
@@ -179,8 +179,8 @@ describe('Obj.change enforcement', () => {
 
       expect(Obj.getMeta(obj).keys).toHaveLength(3);
 
-      Obj.change(obj, (o) => {
-        Obj.deleteKeys(o, 'source-a');
+      Obj.change(obj, (obj) => {
+        Obj.deleteKeys(obj, 'source-a');
       });
 
       expect(Obj.getMeta(obj).keys).toHaveLength(1);
@@ -190,8 +190,8 @@ describe('Obj.change enforcement', () => {
     test('setValue sets nested properties', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        Obj.setValue(o, ['name'], 'Updated Name');
+      Obj.change(obj, (obj) => {
+        Obj.setValue(obj, ['name'], 'Updated Name');
       });
 
       expect(obj.name).toBe('Updated Name');
@@ -200,8 +200,8 @@ describe('Obj.change enforcement', () => {
     test('getMeta is mutable inside change and changes persist', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        const meta = Obj.getMeta(o);
+      Obj.change(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
         meta.tags = ['tag-1', 'tag-2'];
         meta.keys.push({ source: 'external', id: '123' });
       });
@@ -214,12 +214,12 @@ describe('Obj.change enforcement', () => {
     test('multiple mutations in single change all persist', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        o.name = 'Name 1';
-        o.name = 'Name 2';
-        o.name = 'Name 3';
-        Obj.addTag(o, 'tag-1');
-        Obj.addTag(o, 'tag-2');
+      Obj.change(obj, (obj) => {
+        obj.name = 'Name 1';
+        obj.name = 'Name 2';
+        obj.name = 'Name 3';
+        Obj.addTag(obj, 'tag-1');
+        Obj.addTag(obj, 'tag-2');
       });
 
       // All mutations should persist.
@@ -237,9 +237,9 @@ describe('Obj.change enforcement', () => {
         notificationCount++;
       });
 
-      Obj.change(obj, (p) => {
-        p.name = 'Jane';
-        p.age = 30;
+      Obj.change(obj, (obj) => {
+        obj.name = 'Jane';
+        obj.age = 30;
       });
 
       // Should only fire one notification for all changes.
@@ -256,8 +256,8 @@ describe('Obj.change enforcement', () => {
         address: { city: 'NYC', coordinates: {} },
       });
 
-      Obj.change(obj, (p) => {
-        p.address!.state = 'NY';
+      Obj.change(obj, (obj) => {
+        obj.address!.state = 'NY';
       });
 
       expect(obj.address?.state).toBe('NY');
@@ -270,9 +270,9 @@ describe('Obj.change enforcement', () => {
         address: { city: 'NYC', coordinates: { lat: 40.7128, lng: -74.006 } },
       });
 
-      Obj.change(obj, (p) => {
-        p.address!.coordinates!.lat = 51.5074;
-        p.address!.coordinates!.lng = -0.1278;
+      Obj.change(obj, (obj) => {
+        obj.address!.coordinates!.lat = 51.5074;
+        obj.address!.coordinates!.lng = -0.1278;
       });
 
       expect(obj.address?.coordinates?.lat).toBe(51.5074);
@@ -306,12 +306,12 @@ describe('Obj.change enforcement', () => {
     test('nested Obj.change calls work correctly', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'John' });
 
-      Obj.change(obj, (p) => {
-        p.name = 'Jane';
+      Obj.change(obj, (obj) => {
+        obj.name = 'Jane';
 
         // Nested change should work (already in change context).
-        Obj.change(obj, (p2) => {
-          p2.age = 30;
+        Obj.change(obj, (obj) => {
+          obj.age = 30;
         });
       });
 
@@ -323,8 +323,8 @@ describe('Obj.change enforcement', () => {
       const obj = Obj.make(TestSchema.Person, { name: 'John' });
 
       expect(() => {
-        Obj.change(obj, (p) => {
-          p.name = 'Jane';
+        Obj.change(obj, (obj) => {
+          obj.name = 'Jane';
           throw new Error('Test error');
         });
       }).toThrow('Test error');
@@ -344,8 +344,8 @@ describe('Obj.change enforcement', () => {
         fields: [{ label: 'tag1', value: 'val1' }],
       });
 
-      Obj.change(obj, (p) => {
-        p.fields!.push({ label: 'tag2', value: 'val2' });
+      Obj.change(obj, (obj) => {
+        obj.fields!.push({ label: 'tag2', value: 'val2' });
       });
 
       expect(obj.fields).toHaveLength(2);
@@ -362,8 +362,8 @@ describe('Obj.change enforcement', () => {
       });
 
       let popped: any;
-      Obj.change(obj, (p) => {
-        popped = p.fields!.pop();
+      Obj.change(obj, (obj) => {
+        popped = obj.fields!.pop();
       });
 
       expect(popped.label).toBe('b');
@@ -380,8 +380,8 @@ describe('Obj.change enforcement', () => {
         ],
       });
 
-      Obj.change(obj, (p) => {
-        p.fields!.splice(1, 1, { label: 'x', value: 'x' });
+      Obj.change(obj, (obj) => {
+        obj.fields!.splice(1, 1, { label: 'x', value: 'x' });
       });
 
       expect(obj.fields).toHaveLength(3);
@@ -429,8 +429,8 @@ describe('Obj.change enforcement', () => {
     test('delete property within Obj.change', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'John', age: 25 });
 
-      Obj.change(obj, (p) => {
-        delete p.age;
+      Obj.change(obj, (obj) => {
+        delete obj.age;
       });
 
       expect(obj.age).toBeUndefined();
@@ -455,8 +455,8 @@ describe('Obj.change enforcement', () => {
         [Relation.Target]: target,
       });
 
-      Relation.change(rel, (r) => {
-        const meta = Relation.getMeta(r);
+      Relation.change(rel, (rel) => {
+        const meta = Relation.getMeta(rel);
         meta.tags = ['rel-tag'];
         meta.keys.push({ source: 'rel-source', id: 'rel-key' });
       });
@@ -473,14 +473,14 @@ describe('Obj.change enforcement', () => {
         [Relation.Target]: target,
       });
 
-      Relation.change(rel, (r) => {
-        Relation.addTag(r, 'important');
+      Relation.change(rel, (rel) => {
+        Relation.addTag(rel, 'important');
       });
 
       expect(Relation.getMeta(rel).tags).toContain('important');
 
-      Relation.change(rel, (r) => {
-        Relation.removeTag(r, 'important');
+      Relation.change(rel, (rel) => {
+        Relation.removeTag(rel, 'important');
       });
 
       expect(Relation.getMeta(rel).tags).not.toContain('important');
@@ -494,8 +494,8 @@ describe('Obj.change enforcement', () => {
 
       // Direct assignment of root ECHO objects (created with Obj.make) is not allowed.
       expect(() => {
-        Obj.change(obj, (o) => {
-          o.other = other;
+        Obj.change(obj, (obj) => {
+          obj.other = other;
         });
       }).toThrow(/Object references must be wrapped with `Ref\.make`/);
     });
@@ -504,14 +504,14 @@ describe('Obj.change enforcement', () => {
       const obj = Obj.make(TestSchema.Expando, {});
 
       // Assign a plain object (not created with Obj.make).
-      Obj.change(obj, (o) => {
-        o.nested = { value: 'initial' };
+      Obj.change(obj, (obj) => {
+        obj.nested = { value: 'initial' };
       });
       expect(obj.nested.value).toBe('initial');
 
       // Modify plain nested object through parent's change context.
-      Obj.change(obj, (o) => {
-        o.nested.value = 'modified';
+      Obj.change(obj, (obj) => {
+        obj.nested.value = 'modified';
       });
       expect(obj.nested.value).toBe('modified');
     });

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

@@ -3,15 +3,13 @@
 //
 
 import { inspect } from 'node:util';
-
 import { describe, expect, test } from 'vitest';
 
 import { isNode } from '@dxos/util';
 
-import { TestSchema, updateCounter } from '../../testing';
-import { createObject } from '../object';
+import { TestSchema, updateCounter } from '../../../testing';
+import { createObject } from '../../Obj';
 import { ATTR_META } from '../types';
-
 import { makeObject } from './make-object';
 import { objectData } from './proxy-types';
 import { change } from './reactive';

package/src/internal/{proxy → common/proxy}/json-serializer.ts

@@ -7,16 +7,19 @@ import { invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 import { deepMapValues } from '@dxos/util';
 
+import { Ref } from '../../Ref';
 import {
+  ATTR_META,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
   ATTR_SELF_DXN,
+  ATTR_TYPE,
+  MetaId,
   RelationSourceDXNId,
   RelationTargetDXNId,
   SelfDXNId,
-} from '../entities';
-import { Ref } from '../ref';
-import { ATTR_META, ATTR_TYPE, MetaId, TypeId } from '../types';
+  TypeId,
+} from '../types';
 
 /**
  * Attaches a toJSON method to the object for typed serialization.

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

@@ -6,9 +6,8 @@ import type * as Schema from 'effect/Schema';
 
 import { ObjectId } from '@dxos/keys';
 
-import { getTypeAnnotation } from '../annotations';
-import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema } from '../types';
-
+import { getTypeAnnotation } from '../../Annotation';
+import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema, ParentId } from '../types';
 import { defineHiddenProperty } from './define-hidden-property';
 import { attachTypedJsonSerializer } from './json-serializer';
 import { createProxy, getProxyTarget, isValidProxyTarget } from './proxy-utils';
@@ -35,7 +34,8 @@ export const makeObject: {
     meta?: ObjectMeta,
   ): T;
 } = <T extends AnyProperties>(schema: Schema.Schema<T, any>, obj: MakeObjectProps<T>, meta?: ObjectMeta): T => {
-  return createReactiveObject<T>({ ...obj } as T, meta, schema);
+  // Use Object.assign to copy symbol properties (like ParentId) that spread operator doesn't copy.
+  return createReactiveObject<T>(Object.assign({}, obj) as T, meta, schema);
 };
 
 const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta, schema?: Schema.Schema<T>): T => {
@@ -47,12 +47,21 @@ const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta
     throw new Error('Schema is required for reactive objects. Use Atom for untyped reactive state.');
   }
 
+  // Extract parent from props (can be set via [Obj.Parent]).
+  const parent = (obj as any)[ParentId];
+  if (parent !== undefined) {
+    delete (obj as any)[ParentId];
+  }
+
   const annotation = getTypeAnnotation(schema);
   if (annotation) {
     setIdOnTarget(obj);
     defineHiddenProperty(obj, KindId, annotation.kind);
   }
   initMeta(obj, meta);
+  if (parent !== undefined) {
+    defineHiddenProperty(obj, ParentId, parent);
+  }
   prepareTypedTarget(obj, schema);
   attachTypedJsonSerializer(obj);
   const proxy = createProxy<T>(obj, TypedReactiveHandler.instance);

package/src/internal/{proxy → common/proxy}/ownership.ts

@@ -5,7 +5,6 @@
 import { invariant } from '@dxos/invariant';
 
 import { KindId } from '../types';
-
 import { queueOwnerNotification } from './change-context';
 import { defineHiddenProperty } from './define-hidden-property';
 import { getProxyTarget, isProxy, isValidProxyTarget } from './proxy-utils';

package/src/internal/{proxy → common/proxy}/reactive.ts

@@ -2,8 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type RefTypeId } from '../ref/ref';
-
+import { type RefTypeId } from '../../Ref/ref';
 import { getProxyTarget } from './proxy-utils';
 import { ChangeId, EventId } from './symbols';
 

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

@@ -6,14 +6,14 @@ 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 { EchoObjectSchema } from '../entities';
+import { createEchoSchema } from '../../../testing';
+import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../../Annotation';
+import { EchoObjectSchema } from '../../Entity';
 
 // TODO(dmaretskyi): Comment.
 const EmptySchemaType = Schema.Struct({}).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Empty',
+    typename: 'com.example.type.empty',
     version: '0.1.0',
   }),
 );
@@ -27,7 +27,7 @@ describe('dynamic schema', () => {
       field2: Schema.Boolean,
     }).pipe(
       EchoObjectSchema({
-        typename: 'example.com/type/Test',
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -44,7 +44,7 @@ describe('dynamic schema', () => {
       field1: Schema.String,
     }).pipe(
       EchoObjectSchema({
-        typename: 'example.com/type/Test',
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -95,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);
@@ -111,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.
@@ -132,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/{proxy → common/proxy}/typed-handler.test.ts

@@ -5,12 +5,11 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { TestSchema } from '../../testing';
-import { EchoObjectSchema } from '../entities';
-import { setValue } from '../object';
-import { Ref } from '../ref';
+import { TestSchema } from '../../../testing';
+import { EchoObjectSchema } from '../../Entity';
+import { setValue } from '../../Obj';
+import { Ref } from '../../Ref';
 import { foreignKey, getMeta } from '../types';
-
 import { makeObject } from './make-object';
 import { change, subscribe } from './reactive';
 
@@ -40,10 +39,10 @@ describe('complex schema validations', () => {
 
   test('references', () => {
     const Foo = Schema.Struct({ field: Schema.String }).pipe(
-      EchoObjectSchema({ typename: 'example.com/type/Foo', version: '0.1.0' }),
+      EchoObjectSchema({ typename: 'com.example.type.foo', version: '0.1.0' }),
     );
     const Bar = Schema.Struct({ fooRef: Ref(Foo) }).pipe(
-      EchoObjectSchema({ typename: 'example.com/type/Bar', version: '0.1.0' }),
+      EchoObjectSchema({ typename: 'com.example.type.bar', version: '0.1.0' }),
     );
     const field = 'hello';
     expect(() => makeObject(Bar, { fooRef: { id: '1', field } as any })).to.throw();
@@ -94,7 +93,7 @@ describe('complex schema validations', () => {
   });
 
   test('subscribe', () => {
-    const TestSchema = Schema.mutable(Schema.Struct({ field: Schema.String })).pipe(
+    const TestSchema = Schema.Struct({ field: Schema.String }).pipe(
       EchoObjectSchema({ typename: 'Test', version: '0.1.0' }),
     );
     const object = makeObject(TestSchema, { field: 'value' });
@@ -117,12 +116,10 @@ describe('complex schema validations', () => {
 });
 
 describe('object structure restrictions', () => {
-  const NestedSchema = Schema.mutable(
-    Schema.Struct({
-      data: Schema.optional(Schema.Any),
-      nested: Schema.optional(Schema.Any),
-    }),
-  );
+  const NestedSchema = Schema.Struct({
+    data: Schema.optional(Schema.Any),
+    nested: Schema.optional(Schema.Any),
+  });
 
   test('prevents direct cycles', () => {
     const obj = makeObject(NestedSchema, { data: null });
@@ -226,11 +223,9 @@ describe('object structure restrictions', () => {
   });
 
   test('array elements are owned by root ECHO object', () => {
-    const ArraySchema = Schema.mutable(
-      Schema.Struct({
-        items: Schema.mutable(Schema.Array(Schema.Any)),
-      }),
-    );
+    const ArraySchema = Schema.Struct({
+      items: Schema.Array(Schema.Any),
+    });
 
     const obj1 = makeObject(ArraySchema, {
       items: [{ id: 1 }, { id: 2 }, { id: 3 }],

package/src/internal/{proxy → common/proxy}/typed-handler.ts

@@ -2,19 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type InspectOptionsStylized } from 'node:util';
-
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { type InspectOptionsStylized } from 'node:util';
 
 import { Event } from '@dxos/async';
 import { inspectCustom } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 
-import { getSchemaDXN } from '../annotations';
-import { ObjectDeletedId } from '../entities';
-import { SchemaId, TypeId } from '../types';
-
+import { getSchemaDXN } from '../../Annotation';
+import { ObjectDeletedId, ParentId, SchemaId, TypeId } from '../types';
 import { executeChange, isInChangeContext, queueNotification } from './change-context';
 import { defineHiddenProperty } from './define-hidden-property';
 import { createPropertyDeleteError } from './errors';
@@ -47,6 +44,7 @@ type ProxyTarget = {
    * Schema for the root.
    */
   [SchemaId]: Schema.Schema.AnyNoContext;
+  [ParentId]?: any;
 
   /**
    * For modifications.
@@ -320,6 +318,10 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   ): { echoRoot: object; preparedValue: any } {
     const echoRoot = getEchoRoot(target);
 
+    if (prop === ParentId) {
+      return { echoRoot, preparedValue: value }; // Short-circuit for parent assignment.
+    }
+
     // Check for cycles before assignment.
     if (isValidProxyTarget(value) || isProxy(value)) {
       if (wouldCreateCycle(echoRoot, value)) {
@@ -363,6 +365,9 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   }
 
   private _validateValue(target: any, prop: string | symbol, value: any) {
+    if (prop === ParentId) {
+      return value;
+    }
     const schema = SchemaValidator.getTargetPropertySchema(target, prop);
     const _ = Schema.asserts(schema)(value);
     if (isValidProxyTarget(value)) {