@dxos/echo 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/internal/Obj/set-value.test.ts

@@ -5,6 +5,8 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
+import { DXN } from '@dxos/keys';
+
 import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
 import * as Type from '../../Type';
@@ -60,12 +62,7 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 
@@ -151,12 +148,7 @@ describe('Obj.setValue', () => {
   test('handles two-dimensional arrays', ({ expect }) => {
     const Matrix = Schema.Struct({
       values: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Matrix',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.matrix', '0.1.0')));
 
     const matrix = Obj.make(Matrix, {});
 
@@ -205,12 +197,7 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 
@@ -232,12 +219,7 @@ describe('Obj.setValue', () => {
     const TodoList = Schema.Struct({
       name: Schema.String,
       tasks: Schema.optional(Schema.Array(Task)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/TodoList',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.todoList', '0.1.0')));
 
     const todoList = Obj.make(TodoList, { name: 'My Tasks' });
 
@@ -261,12 +243,7 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 

package/src/internal/Obj/snapshot.ts

@@ -7,18 +7,20 @@ import { deepMapValues } from '@dxos/util';
 
 import {
   KindId,
-  MetaId,
   ObjectDatabaseId,
   ObjectDeletedId,
+  ParentId,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
   SchemaId,
-  SelfDXNId,
+  SelfURIId,
   SnapshotKindId,
+  TypeEntityId,
   TypeId,
 } from '../common/types';
+import { MetaId } from '../common/types/meta';
 
 /**
  * Copy a Symbol-keyed property from source to target if it has a defined value.
@@ -83,16 +85,21 @@ export const getSnapshot = <T extends object>(obj: T): T => {
   // Type introspection symbols.
   copySymbolProperty(source, snapshot, TypeId);
   copySymbolProperty(source, snapshot, SchemaId);
-  copySymbolProperty(source, snapshot, SelfDXNId);
+  copySymbolProperty(source, snapshot, TypeEntityId);
+  copySymbolProperty(source, snapshot, SelfURIId);
 
   // Database reference (required for Obj.getDatabase to work on snapshots).
   copySymbolProperty(source, snapshot, ObjectDatabaseId);
   copySymbolProperty(source, snapshot, ObjectDeletedId);
 
-  // Metadata symbol. Copy arrays so the snapshot is not affected by mutations to the live meta's keys/tags.
+  // Parent reference (required for Obj.getParent to work on snapshots).
+  copySymbolProperty(source, snapshot, ParentId);
+
+  // Metadata symbol. Copy arrays/objects so the snapshot is not affected by mutations to the live meta.
   copySymbolProperty(source, snapshot, MetaId, (meta: any) => ({
     keys: [...(meta?.keys ?? [])],
     tags: [...(meta?.tags ?? [])],
+    ...(meta?.annotations ? { annotations: { ...meta.annotations } } : {}),
   }));
 
   // Relation endpoint symbols.

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

@@ -6,29 +6,27 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
+import { DXN } from '@dxos/keys';
+
+import * as Type from '../../Type';
 import { EchoObjectSchema } from '../Entity';
 
 const Organization = Schema.Struct({
   name: Schema.String,
-}).pipe(
-  EchoObjectSchema({
-    typename: 'com.example.type.organization',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObjectSchema(DXN.make('com.example.type.organization', '0.1.0')));
 
-interface Organization extends Schema.Schema.Type<typeof Organization> {}
+type Organization = Type.InstanceType<typeof Organization>;
 
 describe('EchoObjectSchema DSL', () => {
-  test('type is a valid schema', async () => {
-    expect(Schema.isSchema(Organization)).to.be.true;
+  test('type is a Type.Type entity', async () => {
+    expect(Schema.isSchema(Type.getSchema(Organization))).to.be.true;
   });
 
   test('static typename accessor', async () => {
-    expect(Organization.typename).to.eq('com.example.type.organization');
+    expect(Type.getTypename(Organization)).to.eq('com.example.type.organization');
   });
 
   test('expect schema', async () => {
-    expect(SchemaAST.isTypeLiteral(Organization.ast)).to.be.true;
+    expect(SchemaAST.isTypeLiteral(Type.getSchema(Organization).ast)).to.be.true;
   });
 });

package/src/internal/Obj/typed-object.ts

@@ -12,7 +12,7 @@ import { type AnyEntity } from '../common/types';
  * Implements effect schema to define object properties.
  * Has a typename and version.
  *
- * In contrast to {@link EchoSchema} this definition is not recorded in the database.
+ * In contrast to a stored `Type.Type` entity, this definition is not recorded in the database.
  *
  * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */

package/src/internal/Query.ts

@@ -135,18 +135,21 @@ export const prettyQuery = (query: QueryAST.Query): string => {
     }
     case 'from': {
       if (query.from._tag === 'scope') {
-        const scope = query.from.scope;
-        const parts: string[] = [];
-        if (scope.spaceIds !== undefined) {
-          parts.push(`spaceIds: [${scope.spaceIds.map((s) => JSON.stringify(s)).join(', ')}]`);
+        if (query.from.scopes.length === 0) {
+          return `${prettyQuery(query.query)}.from('all-accessible-spaces')`;
         }
-        if (scope.feeds !== undefined) {
-          parts.push(`feeds: [${scope.feeds.map(String).join(', ')}]`);
-        }
-        if (scope.allFeedsFromSpaces !== undefined) {
-          parts.push(`allFeedsFromSpaces: ${scope.allFeedsFromSpaces}`);
-        }
-        return `${prettyQuery(query.query)}.from({ ${parts.join(', ')} })`;
+        const scopeStrs = query.from.scopes.map((scope) => {
+          if (scope._tag === 'space') {
+            return scope.includeAllFeeds
+              ? `{ space: ${JSON.stringify(scope.spaceId)}, includeAllFeeds: true }`
+              : `{ space: ${JSON.stringify(scope.spaceId)} }`;
+          }
+          if (scope._tag === 'feed') {
+            return `{ feed: ${JSON.stringify(String(scope.feedUri))} }`;
+          }
+          return `{ registry: ${JSON.stringify(scope.location)} }`;
+        });
+        return `${prettyQuery(query.query)}.from([${scopeStrs.join(', ')}])`;
       }
       return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
     }

package/src/internal/Ref/ref-array.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type ObjectId } from '@dxos/keys';
+import { type EntityId } from '@dxos/keys';
 import { isNonNullable } from '@dxos/util';
 
 import { type AnyEntity } from '../common/types';
@@ -29,8 +29,8 @@ export const RefArray = Object.freeze({
   /**
    * Removes the ref with the given id.
    */
-  removeById: (refs: Ref<AnyEntity>[], id: ObjectId) => {
-    const index = refs.findIndex(Ref.hasObjectId(id));
+  removeById: (refs: Ref<AnyEntity>[], id: EntityId) => {
+    const index = refs.findIndex(Ref.hasEntityId(id));
     if (index >= 0) {
       refs.splice(index, 1);
     }

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

@@ -5,46 +5,37 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { DXN, ObjectId } from '@dxos/keys';
+import { EID, EntityId, DXN } from '@dxos/keys';
 
-import { EchoObjectSchema, getObjectDXN } from '../Entity';
+import * as Type from '../../Type';
+import { EchoObjectSchema, getObjectEchoUri } from '../Entity';
 import { createObject } from '../Obj';
 import { Ref, getReferenceAst } from './ref';
 
 const Task = Schema.Struct({
   title: Schema.optional(Schema.String),
-}).pipe(
-  EchoObjectSchema({
-    typename: 'com.example.type.task',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObjectSchema(DXN.make('com.example.type.task', '0.1.0')));
 
-type Task = Schema.Schema.Type<typeof Task>;
+type Task = Type.InstanceType<typeof Task>;
 
 const Contact = Schema.Struct({
   name: Schema.String,
   email: Schema.optional(Schema.String),
   tasks: Schema.Array(Ref(Task)),
-}).pipe(
-  EchoObjectSchema({
-    typename: 'com.example.type.person',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObjectSchema(DXN.make('com.example.type.person', '0.1.0')));
 
-type Contact = Schema.Schema.Type<typeof Contact>;
+type Contact = Type.InstanceType<typeof Contact>;
 
 describe('Ref', () => {
   test('Schema is', () => {
-    Ref(Contact).pipe(Schema.is)(Ref.fromDXN(DXN.parse(`dxn:echo:@:${ObjectId.random()}`)));
+    Ref(Contact).pipe(Schema.is)(Ref.fromURI(EID.make({ entityId: EntityId.random() })));
   });
 
   test('ref ast', () => {
     const ref = Ref(Task);
     expect(ref.ast._tag).toEqual('Declaration');
     const refAst = getReferenceAst(ref.ast);
-    expect(refAst).toEqual({ typename: Task.typename, version: Task.version });
+    expect(refAst).toEqual({ typename: Type.getTypename(Task), version: Type.getVersion(Task) });
   });
 
   // TODO(dmaretskyi): Figure out how to expose this in the API.
@@ -55,14 +46,14 @@ describe('Ref', () => {
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
       id: contact.id,
-      '@type': `dxn:type:${Contact.typename}:${Contact.version}`,
+      '@type': `dxn:${Type.getTypename(Contact)}:${Type.getVersion(Contact)}`,
       '@meta': {
         keys: [],
       },
       name: 'John Doe',
       tasks: [
         {
-          '/': getObjectDXN(task as any)!.toString(),
+          '/': getObjectEchoUri(task)!.toString(),
           target: JSON.parse(JSON.stringify(task)),
         },
       ],
@@ -76,25 +67,25 @@ describe('Ref', () => {
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
       id: contact.id,
-      '@type': `dxn:type:${Contact.typename}:${Contact.version}`,
+      '@type': `dxn:${Type.getTypename(Contact)}:${Type.getVersion(Contact)}`,
       '@meta': {
         keys: [],
       },
       name: 'John Doe',
-      tasks: [{ '/': getObjectDXN(task)!.toString() }],
+      tasks: [{ '/': getObjectEchoUri(task)!.toString() }],
     });
   });
 
   test('decode object', () => {
-    const id = ObjectId.random();
+    const id = EntityId.random();
     const contactData = {
-      id: ObjectId.random(),
+      id: EntityId.random(),
       name: 'John Doe',
       tasks: [{ '/': `dxn:echo:@:${id}` }],
     };
 
-    const contact = Contact.pipe(Schema.decodeUnknownSync)(contactData);
+    const contact = Type.getSchema(Contact).pipe(Schema.decodeUnknownSync)(contactData);
     expect(Ref.isRef(contact.tasks[0])).toEqual(true);
-    expect(contact.tasks[0].dxn.toString()).toEqual(`dxn:echo:@:${id}`);
+    expect(contact.tasks[0].uri.toString()).toEqual(`dxn:echo:@:${id}`);
   });
 });