@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/src/internal/{ref → Ref}/ref.ts

@@ -3,8 +3,11 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Equal from 'effect/Equal';
+import * as Hash from 'effect/Hash';
 import * as Option from 'effect/Option';
 import * as ParseResult from 'effect/ParseResult';
+import * as Pipeable from 'effect/Pipeable';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import type * as Types from 'effect/Types';
@@ -16,9 +19,9 @@ import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
 import * as Database from '../../Database';
-import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../annotations';
-import { type JsonSchemaType } from '../json-schema';
-import type { AnyEntity, AnyProperties } from '../types';
+import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';
+import { type JsonSchemaType } from '../JsonSchema';
+import type { AnyEntity, AnyProperties } from '../common/types';
 
 /**
  * The `$id` and `$ref` fields for an ECHO reference schema.
@@ -130,7 +133,7 @@ export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Sc
  * Represents materialized reference to a target.
  * This is the data type for the fields marked as ref.
  */
-export interface Ref<T> {
+export interface Ref<T> extends Pipeable.Pipeable {
   /**
    * Target object DXN.
    */
@@ -459,6 +462,21 @@ export class RefImpl<T> implements Ref<T> {
 
   [RefTypeId] = refVariance;
 
+  /**
+   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)
+   * to deduplicate Ref instances that point to the same object.
+   * ECHO proxies return new RefImpl instances on every property access,
+   * so without this, each access would create a separate cache entry.
+   */
+  [Hash.symbol](): number {
+    return Hash.hash(this.#dxn.toString());
+  }
+
+  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
+  [Equal.symbol](that: Equal.Equal): boolean {
+    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();
+  }
+
   /**
    * Internal method to set the resolver.
    *
@@ -474,6 +492,11 @@ export class RefImpl<T> implements Ref<T> {
   _getSavedTarget(): T | undefined {
     return this.#target;
   }
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return Pipeable.pipeArguments(this, arguments);
+  }
 }
 
 /**

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

@@ -5,10 +5,10 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { FieldPath } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-import { FormatAnnotation, TypeFormat } from '../formats';
-import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../json-schema';
+import { FieldPath } from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { FormatAnnotation, TypeFormat } from '../Format';
+import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../JsonSchema';
 
 import { composeSchema } from './compose';
 
@@ -17,7 +17,7 @@ describe('schema composition', () => {
     const BaseType = Schema.Struct({
       name: Schema.String,
       email: Schema.String,
-    }).pipe(EchoObjectSchema({ typename: 'example.com/Person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema({ typename: 'com.example.person', version: '0.1.0' }));
 
     const OverlaySchema = Schema.Struct({
       email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(TypeFormat.Email)),

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

@@ -6,7 +6,7 @@ import type * as Types from 'effect/Types';
 
 import { invariant } from '@dxos/invariant';
 
-import { type JsonSchemaType } from '../json-schema';
+import { type JsonSchemaType } from '../JsonSchema';
 
 /**
  * Creates a composite schema from the source and projection schemas.

package/src/internal/{schema → Type}/echo-schema.ts

@@ -8,11 +8,12 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { type ObjectId } from '@dxos/keys';
 
-import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../annotations';
-import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../json-schema';
-import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../object';
-import { ChangeId } from '../proxy';
-import { EntityKind, SchemaKindId } from '../types';
+import type * as Type from '../../Type';
+import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../Annotation';
+import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../JsonSchema';
+import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../Obj';
+import { ChangeId } from '../common/proxy';
+import { EntityKind, SchemaKindId } from '../common/types';
 
 import {
   addFieldsToSchema,
@@ -177,7 +178,7 @@ const schemaVariance = {
  *
  * @example
  * ```ts
- * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'example.org/type/Table', version: '0.1.0' })){
+ * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'com.example.type.table', version: '0.1.0' })){
  *   title: Schema.String,
  *   schema: Schema.optional(ref(EchoSchema)),
  *   props: Schema.mutable(S.Array(TablePropSchema)),
@@ -192,7 +193,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
 
   /**
    * Schema kind key that marks this as an ECHO schema.
-   * Makes EchoSchema satisfy the Type.Obj.Any type.
+   * Makes EchoSchema satisfy the Type.AnyObj type.
    */
   readonly [SchemaKindId]: EntityKind.Object = EntityKind.Object;
 
@@ -304,8 +305,8 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
   /**
    * Reference to the underlying persistent schema object.
    */
-  public get persistentSchema(): PersistentSchema {
-    return this._persistentSchema;
+  public get persistentSchema(): Type.PersistentType {
+    return this._persistentSchema as Type.PersistentType;
   }
 
   public getProperties(): SchemaAST.PropertySignature[] {
@@ -399,7 +400,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   _rebuild(): void {
     if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._persistentSchema.jsonSchema));
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
       this._isDirty = false;
     }
   }

package/src/internal/{schema → Type}/manipulation.ts

@@ -8,7 +8,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../annotations';
+import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../Annotation';
 
 // TODO(ZaymonFC): Do this one at a time. This might be dangerous.
 export const addFieldsToSchema = (

package/src/internal/{schema → Type}/persistent-schema.ts

@@ -4,9 +4,10 @@
 
 import * as Schema from 'effect/Schema';
 
-import { TypenameSchema, VersionSchema } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-import { JsonSchemaType } from '../json-schema';
+import { IconAnnotation } from '../Annotation';
+import { LabelAnnotation, TypenameSchema, VersionSchema } from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { JsonSchemaType } from '../JsonSchema';
 
 /**
  * Persistent representation of a schema.
@@ -19,9 +20,14 @@ export const PersistentSchema = Schema.Struct({
   jsonSchema: JsonSchemaType,
 }).pipe(
   EchoObjectSchema({
-    typename: 'dxos.org/type/Schema',
+    typename: 'org.dxos.type.schema',
     version: '0.1.0',
   }),
+  LabelAnnotation.set(['name']),
+  IconAnnotation.set({
+    icon: 'ph--database--regular',
+    hue: 'green',
+  }),
 );
 
 export interface PersistentSchema extends Schema.Schema.Type<typeof PersistentSchema> {}

package/src/internal/{README.md → common/README.md}

@@ -30,7 +30,7 @@
 
 - [x] QueryResult namespace
 - [x] SchemaRegistry interface
-- [x] Schema registry should return Type.Entity.Any instead of Schema.Schema.AnyNoContext.
+- [x] Schema registry should return Type.AnyEntity instead of Schema.Schema.AnyNoContext.
 - [x] Hypergraph interface
 - [x] Obj.getDatabase
 - [x] SpaceAction.AddObject target should be a db not a space.

package/src/internal/{api → common/api}/index.ts

@@ -12,8 +12,4 @@
  * and prevent external packages from using internals directly.
  */
 
-export * from './annotations';
-export * from './entity';
 export * from './meta';
-export * from './sorting';
-export * from './version';

package/src/internal/common/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './api';
+export * from './proxy';
+export * from './types';

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.
@@ -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,8 +306,8 @@ 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) => {
@@ -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, (obj) => {
+        const meta = Relation.getMeta(obj);
         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, (obj) => {
+        Relation.addTag(obj, 'important');
       });
 
       expect(Relation.getMeta(rel).tags).toContain('important');
 
-      Relation.change(rel, (r) => {
-        Relation.removeTag(r, 'important');
+      Relation.change(rel, (obj) => {
+        Relation.removeTag(obj, '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

@@ -8,8 +8,8 @@ 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';

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,8 +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';
@@ -35,7 +35,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 +48,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}/reactive.ts

@@ -2,7 +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',
     });
   });