@dxos/echo 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

package/src/internal/proxy/typed-handler.test.ts

@@ -5,10 +5,13 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { Ref, TypedObject, create, foreignKey, getMeta, getSchema, isInstanceOf } from '..';
-import { Testing } from '../testing';
+import { TestSchema } from '../../testing';
+import { isInstanceOf } from '../annotations';
+import { TypedObject, createObject } from '../object';
+import { Ref } from '../ref';
+import { foreignKey, getMeta, getSchema } from '../types';
 
-import { live } from './reactive-object';
+import { makeObject } from './make-object';
 
 describe('complex schema validations', () => {
   const setValue = (target: any, prop: string, value: any) => {
@@ -17,20 +20,20 @@ describe('complex schema validations', () => {
 
   test('any', () => {
     const schema = Schema.Struct({ field: Schema.Any });
-    const object = live(schema, { field: { nested: { value: 100 } } });
+    const object = makeObject(schema, { field: { nested: { value: 100 } } });
     expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
   });
 
   test('meta', () => {
     const source = 'test';
     const schema = Schema.Struct({ field: Schema.Number });
-    const object = live(schema, { field: 42 }, { keys: [foreignKey(source, '123')] });
+    const object = makeObject(schema, { field: 42 }, { keys: [foreignKey(source, '123')] });
     expect(getMeta(object).keys).to.deep.eq([foreignKey(source, '123')]);
   });
 
   test('object', () => {
     const schema = Schema.Struct({ field: Schema.optional(Schema.Object) });
-    const object = live(schema, { field: { nested: { value: 100 } } });
+    const object = makeObject(schema, { field: { nested: { value: 100 } } });
     expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
   });
 
@@ -38,15 +41,15 @@ describe('complex schema validations', () => {
     class Foo extends TypedObject({ typename: 'example.com/type/Foo', version: '0.1.0' })({ field: Schema.String }) {}
     class Bar extends TypedObject({ typename: 'example.com/type/Bar', version: '0.1.0' })({ fooRef: Ref(Foo) }) {}
     const field = 'hello';
-    expect(() => live(Bar, { fooRef: { id: '1', field } as any })).to.throw();
-    expect(() => live(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
-    const bar = live(Bar, { fooRef: Ref.make(live(Foo, { field })) });
+    expect(() => makeObject(Bar, { fooRef: { id: '1', field } as any })).to.throw();
+    expect(() => makeObject(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
+    const bar = makeObject(Bar, { fooRef: Ref.make(makeObject(Foo, { field })) });
     expect(bar.fooRef.target?.field).to.eq(field);
   });
 
   test('index signatures', () => {
     const schema = Schema.Struct({}, { key: Schema.String, value: Schema.Number });
-    const object = live(schema, { unknownField: 1 });
+    const object = makeObject(schema, { unknownField: 1 });
     expect(() => setValue(object, 'field', '42')).to.throw();
     expect(() => setValue(object, 'unknown_field', 42)).not.to.throw();
   });
@@ -57,7 +60,7 @@ describe('complex schema validations', () => {
       object: Schema.optional(Schema.suspend(() => Schema.Union(Schema.Null, Schema.Struct({ field: Schema.Number })))),
     });
 
-    const object = live(schema, { array: [1, 2, null], object: { field: 3 } });
+    const object = makeObject(schema, { array: [1, 2, null], object: { field: 3 } });
     expect(() => setValue(object, 'object', { field: 4 })).not.to.throw();
     expect(() => setValue(object.object, 'field', 4)).not.to.throw();
     expect(() => setValue(object.array, '0', 4)).not.to.throw();
@@ -65,38 +68,35 @@ describe('complex schema validations', () => {
   });
 
   test('nesting static objects with schema in the live object', () => {
-    const contact1 = create(Testing.Contact, {
+    const contact1 = createObject(TestSchema.Person, {
       name: 'Robert Smith',
       email: 'robert@example.com',
     } as any);
-    const contact2 = create(Testing.Contact, {
+    const contact2 = createObject(TestSchema.Person, {
       name: 'Katy Perry',
       email: 'katy@example.com',
     } as any);
 
-    const contactBook = live({
-      contacts: [contact1],
-    });
-
-    expect(isInstanceOf(Testing.Contact, contactBook.contacts[0])).to.eq(true);
-    expect(getSchema(contactBook.contacts[0])).to.eq(Testing.Contact);
+    const network = makeObject({ contacts: [contact1] });
+    expect(isInstanceOf(TestSchema.Person, network.contacts[0])).to.eq(true);
+    expect(getSchema(network.contacts[0])).to.eq(TestSchema.Person);
 
-    contactBook.contacts.push(contact2);
-    expect(isInstanceOf(Testing.Contact, contactBook.contacts[1])).to.eq(true);
-    expect(getSchema(contactBook.contacts[1])).to.eq(Testing.Contact);
+    network.contacts.push(contact2);
+    expect(isInstanceOf(TestSchema.Person, network.contacts[1])).to.eq(true);
+    expect(getSchema(network.contacts[1])).to.eq(TestSchema.Person);
   });
 
   test('creating an object with data from another object', () => {
-    const contact = live(Testing.Contact, {
+    const contact = makeObject(TestSchema.Person, {
       name: 'Robert Smith',
       email: 'robert@example.com',
     });
-    const TestSchema = Schema.Struct({
-      value: Schema.Unknown,
-    });
-    const data = live(TestSchema, {
+
+    const TempSchema = Schema.Struct({ value: Schema.Unknown });
+    const object = makeObject(TempSchema, {
       value: contact,
     });
-    expect((data.value as any).name).to.eq('Robert Smith');
+
+    expect((object.value as any).name).to.eq('Robert Smith');
   });
 });

package/src/internal/proxy/typed-handler.ts

@@ -20,8 +20,10 @@ import {
   symbolIsProxy,
 } from '@dxos/live-object';
 
-import { getSchemaDXN } from '../ast';
-import { DeletedId, SchemaId, SchemaValidator, TypeId } from '../object';
+import { getSchemaDXN } from '../annotations';
+import { ObjectDeletedId } from '../entities';
+import { SchemaValidator } from '../object';
+import { SchemaId, TypeId } from '../types';
 
 const symbolSignal = Symbol('signal');
 const symbolPropertySignal = Symbol('property-signal');
@@ -68,7 +70,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
       defineHiddenProperty(target, symbolPropertySignal, compositeRuntime.createSignal());
     }
 
-    defineHiddenProperty(target, DeletedId, false);
+    defineHiddenProperty(target, ObjectDeletedId, false);
 
     for (const key of Object.getOwnPropertyNames(target)) {
       const descriptor = Object.getOwnPropertyDescriptor(target, key)!;
@@ -90,6 +92,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
 
   get(target: ProxyTarget, prop: string | symbol, receiver: any): any {
     switch (prop) {
+      // TODO(burdon): Remove?
       case objectData: {
         target[symbolSignal].notifyRead();
         return toJSON(target);
@@ -165,18 +168,20 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
     options: InspectOptionsStylized,
     inspectFn: (value: any, options?: InspectOptionsStylized) => string,
   ): string {
-    return `Typed ${inspectFn(this, {
+    const inspected = inspectFn(this, {
       ...options,
-      compact: true,
       showHidden: false,
       customInspect: false,
-    })}`;
+    });
+
+    return `Typed ${inspected}`;
   }
 }
 
 /**
  * @deprecated Use `Obj.toJSON` instead.
  */
+// TODO(burdon): Remove?
 const toJSON = (target: ProxyTarget): any => {
   return { '@type': 'TypedReactiveObject', ...target };
 };

package/src/internal/proxy/typed-object.test.ts

@@ -5,14 +5,16 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { EchoObject, TypedObject, getSchema } from '..';
+import { EchoObjectSchema } from '../entities';
+import { TypedObject } from '../object';
+import { getSchema } from '../types';
 
-import { live } from './reactive-object';
+import { makeObject } from './make-object';
 
 const Organization = Schema.Struct({
   name: Schema.String,
 }).pipe(
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Organization',
     version: '0.1.0',
   }),
@@ -24,11 +26,14 @@ const Contact = Schema.Struct(
   {
     name: Schema.String,
   },
-  { key: Schema.String, value: Schema.Any },
+  {
+    key: Schema.String,
+    value: Schema.Any,
+  },
 ).pipe(
   Schema.partial,
-  EchoObject({
-    typename: 'example.com/type/Contact',
+  EchoObjectSchema({
+    typename: 'example.com/type/Person',
     version: '0.1.0',
   }),
 );
@@ -37,15 +42,15 @@ interface Contact extends Schema.Schema.Type<typeof Contact> {}
 
 const TEST_ORG: Omit<Organization, 'id'> = { name: 'Test' };
 
-describe('EchoObject class DSL', () => {
+describe('EchoObjectSchema class DSL', () => {
   test('can get object schema', async () => {
-    const obj = live(Organization, TEST_ORG);
+    const obj = makeObject(Organization, TEST_ORG);
     expect(getSchema(obj)).to.deep.eq(Organization);
   });
 
   describe('class options', () => {
     test('can assign undefined to partial fields', async () => {
-      const person = live(Contact, { name: 'John' });
+      const person = makeObject(Contact, { name: 'John' });
       person.name = undefined;
       person.recordField = 'hello';
       expect(person.name).to.be.undefined;
@@ -65,13 +70,13 @@ describe('EchoObject class DSL', () => {
     );
 
     {
-      const object = live(schema, {});
+      const object = makeObject(schema, {});
       (object.meta ??= {}).test = 100;
       expect(object.meta.test).to.eq(100);
     }
 
     {
-      const object = live(schema, {});
+      const object = makeObject(schema, {});
       object.meta = { test: { value: 300 } };
       expect(object.meta.test.value).to.eq(300);
     }
@@ -92,7 +97,7 @@ describe('EchoObject class DSL', () => {
         meta: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
       }) {}
 
-      const object = live(Test2, {});
+      const object = makeObject(Test2, {});
       (object.meta ??= {}).test = 100;
       expect(object.meta.test).to.eq(100);
     }

package/src/internal/ref/ref.test.ts

@@ -7,14 +7,15 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { EchoObject, create, getObjectDXN } from '../object';
+import { EchoObjectSchema, getObjectDXN } from '../entities';
+import { createObject } from '../object';
 
 import { Ref, getReferenceAst } from './ref';
 
 const Task = Schema.Struct({
   title: Schema.optional(Schema.String),
 }).pipe(
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Task',
     version: '0.1.0',
   }),
@@ -27,8 +28,8 @@ const Contact = Schema.Struct({
   email: Schema.optional(Schema.String),
   tasks: Schema.mutable(Schema.Array(Ref(Task))),
 }).pipe(
-  EchoObject({
-    typename: 'example.com/type/Contact',
+  EchoObjectSchema({
+    typename: 'example.com/type/Person',
     version: '0.1.0',
   }),
 );
@@ -49,8 +50,8 @@ describe('Ref', () => {
 
   // TODO(dmaretskyi): Figure out how to expose this in the API.
   test.skip('encode with inlined target', () => {
-    const task = create(Task, { title: 'Fix bugs' });
-    const contact = create(Contact, { name: 'John Doe', tasks: [Ref.make(task)] });
+    const task = createObject(Task, { title: 'Fix bugs' });
+    const contact = createObject(Contact, { name: 'John Doe', tasks: [Ref.make(task)] });
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
@@ -70,8 +71,8 @@ describe('Ref', () => {
   });
 
   test('encode without inlining target', () => {
-    const task = create(Task, { title: 'Fix bugs' });
-    const contact = create(Contact, { name: 'John Doe', tasks: [Ref.make(task).noInline()] });
+    const task = createObject(Task, { title: 'Fix bugs' });
+    const contact = createObject(Contact, { name: 'John Doe', tasks: [Ref.make(task).noInline()] });
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({

package/src/internal/ref/ref.ts

@@ -13,16 +13,15 @@ import { compositeRuntime } from '@dxos/echo-signals/runtime';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../ast';
+import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../annotations';
 import { type JsonSchemaType } from '../json-schema';
-import type { BaseObject, WithId } from '../types';
+import type { AnyProperties, WithId } from '../types';
 
 /**
  * The `$id` and `$ref` fields for an ECHO reference schema.
  */
 export const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';
 
-// TODO(burdon): Define return type.
 export const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {
   const { $id, reference: { schema: { $ref } = {} } = {} } = property;
   if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
@@ -71,16 +70,18 @@ export const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');
 /**
  * Reference Schema.
  */
-export interface Ref$<T extends WithId> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}
+export interface RefSchema<T extends WithId> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}
 
-// Type of the `Ref` function and extra methods attached to it.
+/**
+ * Type of the `Ref` function and extra methods attached to it.
+ */
 export interface RefFn {
-  <S extends Schema.Schema.Any>(schema: S): Ref$<Schema.Schema.Type<S>>;
+  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;
 
   /**
    * @returns True if the object is a reference.
    */
-  isRef: (obj: any) => obj is Ref<any>;
+  isRef: (obj: unknown) => obj is Ref<any>;
 
   /**
    * @returns True if the reference points to the given object id.
@@ -90,7 +91,7 @@ export interface RefFn {
   /**
    * @returns True if the schema is a reference schema.
    */
-  isRefSchema: (schema: Schema.Schema<any, any>) => schema is Ref$<any>;
+  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;
 
   /**
    * @returns True if the schema AST is a reference schema.
@@ -100,7 +101,7 @@ export interface RefFn {
   /**
    * Constructs a reference that points to the given object.
    */
-  // TODO(burdon): Tighten type of T?
+  // TODO(burdon): Narrow to Obj.Any?
   make: <T extends WithId>(object: T) => Ref<T>;
 
   /**
@@ -108,10 +109,11 @@ export interface RefFn {
    */
   fromDXN: (dxn: DXN) => Ref<any>;
 }
+
 /**
  * Schema builder for references.
  */
-export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): Ref$<Schema.Schema.Type<S>> => {
+export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {
   assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');
 
   const annotation = getTypeAnnotation(schema);
@@ -201,7 +203,7 @@ Ref.isRef = (obj: any): obj is Ref<any> => {
 
 Ref.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
 
-Ref.isRefSchema = (schema: Schema.Schema<any, any>): schema is Ref$<any> => {
+Ref.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {
   return Ref.isRefSchemaAST(schema.ast);
 };
 
@@ -209,7 +211,7 @@ Ref.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {
   return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);
 };
 
-Ref.make = <T extends BaseObject>(obj: T): Ref<T> => {
+Ref.make = <T extends AnyProperties>(obj: T): Ref<T> => {
   if (typeof obj !== 'object' || obj === null) {
     throw new TypeError('Expected: ECHO object.');
   }
@@ -242,7 +244,7 @@ export const createEchoReferenceSchema = (
   echoId: string | undefined,
   typename: string | undefined,
   version: string | undefined,
-  schemaName?: string,
+  schemaName?: string, // TODO(burdon): Not used.
 ): Schema.SchemaClass<Ref<any>, EncodedReference> => {
   if (!echoId && !typename) {
     throw new TypeError('Either echoId or typename must be provided.');
@@ -315,12 +317,12 @@ export interface RefResolver {
    * @param load If true the resolver should attempt to load the object from disk.
    * @param onLoad Callback to call when the object is loaded.
    */
-  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): BaseObject | undefined;
+  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;
 
   /**
    * Resolver ref asynchronously.
    */
-  resolve(dxn: DXN): Promise<BaseObject | undefined>;
+  resolve(dxn: DXN): Promise<AnyProperties | undefined>;
 
   // TODO(dmaretskyi): Combine with `resolve`.
   resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;
@@ -432,6 +434,7 @@ export class RefImpl<T> implements Ref<T> {
 
   /**
    * Internal method to set the resolver.
+   *
    * @internal
    */
   _setResolver(resolver: RefResolver): void {
@@ -441,6 +444,7 @@ export class RefImpl<T> implements Ref<T> {
   /**
    * Internal method to get the saved target.
    * Not the same as `target` which is resolved from the resolver.
+   *
    * @internal
    */
   _getSavedTarget(): T | undefined {
@@ -459,7 +463,7 @@ export const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {
 /**
  * Internal API for getting the saved target on a reference.
  */
-export const getRefSavedTarget = (ref: Ref<any>): BaseObject | undefined => {
+export const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {
   invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');
   return ref._getSavedTarget();
 };
@@ -482,10 +486,10 @@ export const refFromEncodedReference = (encodedReference: EncodedReference, reso
 };
 
 export class StaticRefResolver implements RefResolver {
-  public objects = new Map<ObjectId, BaseObject>();
+  public objects = new Map<ObjectId, AnyProperties>();
   public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();
 
-  addObject(obj: BaseObject): this {
+  addObject(obj: AnyProperties): this {
     this.objects.set(obj.id, obj);
     return this;
   }
@@ -497,7 +501,7 @@ export class StaticRefResolver implements RefResolver {
     return this;
   }
 
-  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): BaseObject | undefined {
+  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {
     const id = dxn?.asEchoDXN()?.echoId;
     if (id == null) {
       return undefined;
@@ -506,7 +510,7 @@ export class StaticRefResolver implements RefResolver {
     return this.objects.get(id);
   }
 
-  async resolve(dxn: DXN): Promise<BaseObject | undefined> {
+  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {
     const id = dxn?.asEchoDXN()?.echoId;
     if (id == null) {
       return undefined;

package/src/internal/{projection → schema}/compose.test.ts

@@ -5,10 +5,9 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { FieldPath } from '../ast';
-import { FormatAnnotation, FormatEnum } from '../formats';
-import { toJsonSchema } from '../json';
-import { ECHO_ANNOTATIONS_NS_KEY } from '../json-schema';
+import { FieldPath } from '../annotations';
+import { FormatAnnotation, TypeFormat } from '../formats';
+import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../json-schema';
 import { TypedObject } from '../object';
 
 import { composeSchema } from './compose';
@@ -21,7 +20,7 @@ describe('schema composition', () => {
     }) {}
 
     const OverlaySchema = Schema.Struct({
-      email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(FormatEnum.Email)),
+      email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(TypeFormat.Email)),
     });
 
     const baseSchema = toJsonSchema(BaseType);
@@ -30,7 +29,7 @@ describe('schema composition', () => {
     expect(composedSchema.properties).to.deep.eq({
       email: {
         type: 'string',
-        format: FormatEnum.Email,
+        format: TypeFormat.Email,
         // TODO(dmaretskyi): Should use the new field.
         [ECHO_ANNOTATIONS_NS_KEY]: {
           meta: {

package/src/internal/{projection → schema}/compose.ts

@@ -5,7 +5,8 @@
 import { invariant } from '@dxos/invariant';
 
 import { type JsonSchemaType } from '../json-schema';
-import { getSnapshot } from '../schema';
+
+import { getSnapshot } from './snapshot';
 
 /**
  * Creates a composite schema from the source and projection schemas.