@dxos/echo 0.8.3-main.672df60 → 0.8.3-staging.0fa589b

package/src/test/api.test.ts

@@ -8,7 +8,7 @@ import { describe, test } from 'vitest';
 import { raise } from '@dxos/debug';
 import { FormatEnum, FormatAnnotation } from '@dxos/echo-schema';
 
-import { Obj, Ref, Type, type Live } from '../index';
+import { Obj, Ref, Relation, Type, type Live } from '../index';
 
 namespace Testing {
   export const Organization = Schema.Struct({
@@ -61,12 +61,11 @@ namespace Testing {
     // id: Type.ObjectId,
     role: Schema.String,
   }).pipe(
-    // Type.Relation
-    Type.Obj({
-      typename: 'example.com/type/WorksFor',
+    Type.Relation({
+      typename: 'example.com/relation/WorksFor',
       version: '0.1.0',
-      // source: Person,
-      // target: Organization,
+      source: Person,
+      target: Organization,
     }),
   );
 
@@ -116,13 +115,59 @@ describe('Experimental API review', () => {
     });
 
     expect(Schema.is(Testing.Person)(contact)).to.be.true;
-    expect(Testing.Person.instanceOf(contact)).to.be.true;
-    expect(Obj.instanceOf(Testing.Person)(contact)).to.be.true;
-    expect(Obj.instanceOf(Testing.Organization)(organization)).to.be.true;
+    expect(Obj.instanceOf(Testing.Person, contact)).to.be.true;
+    expect(Obj.instanceOf(Testing.Organization, organization)).to.be.true;
+
+    const isPerson = Obj.instanceOf(Testing.Person);
+    const x: any = {};
+    if (isPerson(x)) {
+      x.name;
+    }
   });
 
   test('default props', ({ expect }) => {
     const message = Obj.make(Testing.Message, Testing.MessageStruct.make({}));
     expect(message.timestamp).to.exist;
   });
+
+  test('Obj.isObject', ({ expect }) => {
+    const guy = Obj.make(Testing.Person, { name: 'Test' });
+    expect(Obj.isObject(guy)).to.be.true;
+    expect(Obj.isObject(null)).to.be.false;
+    expect(Obj.isObject(undefined)).to.be.false;
+    expect(Obj.isObject(1)).to.be.false;
+    expect(Obj.isObject('string')).to.be.false;
+  });
+
+  test('create relation', ({ expect }) => {
+    const person = Obj.make(Testing.Person, { name: 'Test' });
+    const organization = Obj.make(Testing.Organization, { name: 'DXOS' });
+    const worksFor = Relation.make(Testing.WorksFor, {
+      [Relation.Source]: person,
+      [Relation.Target]: organization,
+      role: 'CEO',
+    });
+    expect(Relation.getSource(worksFor)).to.eq(person);
+    expect(Relation.getTarget(worksFor)).to.eq(organization);
+  });
+
+  test.skip('type narrowing', () => {
+    const a: Obj.Any | Relation.Any = null as any;
+
+    {
+      if (Obj.isObject(a)) {
+        a;
+      } else {
+        a;
+      }
+    }
+
+    {
+      if (Relation.isRelation(a)) {
+        a;
+      } else {
+        a;
+      }
+    }
+  });
 });

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './types';

package/src/testing/types.ts

@@ -0,0 +1,91 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { Type } from '..';
+
+// TODO(burdon): These are non-canonical test types, so we really shouldn't export and use in other classes (compare with @dxos/sdk/testing).
+export namespace Testing {
+  const _Contact = Schema.Struct({
+    name: Schema.String,
+    username: Schema.String,
+    email: Schema.String,
+    tasks: Schema.mutable(Schema.Array(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task)))),
+    address: Schema.Struct({
+      city: Schema.optional(Schema.String),
+      state: Schema.optional(Schema.String),
+      zip: Schema.optional(Schema.String),
+      coordinates: Schema.Struct({
+        lat: Schema.optional(Schema.Number),
+        lng: Schema.optional(Schema.Number),
+      }),
+    }),
+  }).pipe(
+    Schema.partial,
+    Type.Obj({
+      typename: 'example.com/type/Contact',
+      version: '0.1.0',
+    }),
+  );
+  export interface Contact extends Schema.Schema.Type<typeof _Contact> {}
+  export const Contact: Schema.Schema<Contact, Schema.Schema.Encoded<typeof _Contact>, never> = _Contact;
+
+  const _Task = Schema.Struct({
+    title: Schema.optional(Schema.String),
+    completed: Schema.optional(Schema.Boolean),
+    assignee: Schema.optional(Type.Ref(Contact)),
+    previous: Schema.optional(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task))),
+    subTasks: Schema.optional(Schema.mutable(Schema.Array(Schema.suspend((): Type.Ref<Task> => Type.Ref(Task))))),
+    description: Schema.optional(Schema.String),
+  }).pipe(
+    Schema.partial,
+    Type.Obj({
+      typename: 'example.com/type/Task',
+      version: '0.1.0',
+    }),
+  );
+  export interface Task extends Schema.Schema.Type<typeof _Task> {}
+  export const Task: Schema.Schema<Task, Schema.Schema.Encoded<typeof _Task>, never> = _Task;
+
+  export enum RecordType {
+    UNDEFINED = 0,
+    PERSONAL = 1,
+    WORK = 2,
+  }
+
+  export const Container = Schema.Struct({
+    objects: Schema.mutable(Schema.Array(Type.Ref(Type.Expando))),
+    records: Schema.mutable(
+      Schema.Array(
+        Schema.partial(
+          Schema.Struct({
+            title: Schema.String,
+            description: Schema.String,
+            contacts: Schema.mutable(Schema.Array(Type.Ref(Contact))),
+            type: Schema.Enums(RecordType),
+          }),
+        ),
+      ),
+    ),
+  }).pipe(
+    Schema.partial,
+    Type.Obj({
+      typename: 'example.com/type/Container',
+      version: '0.1.0',
+    }),
+  );
+
+  export const WorksFor = Schema.Struct({
+    since: Schema.optional(Schema.String),
+  }).pipe(
+    Type.Relation({
+      typename: 'example.com/type/WorksFor',
+      version: '0.1.0',
+      source: Contact,
+      target: Contact,
+    }),
+  );
+  export interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
+}