@dxos/echo 0.8.4-main.e098934 → 0.8.4-main.ead640a

package/src/internal/object/create.test.ts

@@ -0,0 +1,118 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { inspect } from 'util';
+
+import * as Schema from 'effect/Schema';
+import { describe, expect, test } from 'vitest';
+
+import { DXN } from '@dxos/keys';
+
+import { getSchemaDXN } from '../ast';
+import { Testing } from '../testing';
+import { isInstanceOf } from '../types';
+
+import { getSchema } from './accessors';
+import { create } from './create';
+import { objectToJSON } from './json-serializer';
+import { RelationSourceId, RelationTargetId } from './model';
+import { getType } from './typename';
+
+describe('create (static version)', () => {
+  test('defaults', ({ expect }) => {
+    const Contact = Schema.Struct({
+      name: Schema.String.pipe(
+        Schema.optional,
+        Schema.withConstructorDefault(() => 'Anonymous'),
+      ),
+      email: Schema.String.pipe(Schema.optional),
+    });
+
+    const obj = Contact.make({});
+    expect(obj.name).toBe('Anonymous');
+  });
+
+  test('create static object', () => {
+    const contact = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+
+    expect(contact.id).toBeDefined();
+    expect(contact.name).toBe('Bot');
+    expect(contact.email).toBe('bot@example.com');
+    expect((contact as any)['@type']).toBeUndefined();
+    expect(getType(contact)?.toString()).toBe(getSchemaDXN(Testing.Contact)!.toString());
+    expect(isInstanceOf(Testing.Contact, contact)).toBe(true);
+  });
+
+  test('JSON encoding', () => {
+    const contact = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+
+    const json = JSON.parse(JSON.stringify(contact));
+    expect(json).toEqual({
+      id: contact.id,
+      '@type': DXN.fromTypenameAndVersion(Testing.Contact.typename, Testing.Contact.version).toString(),
+      '@meta': {
+        keys: [],
+      },
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+    expect(objectToJSON(contact)).toStrictEqual(json);
+  });
+
+  test('JSON encoding with relation', () => {
+    const contactA = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+    const contactB = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+    const hasManager = create(Testing.HasManager, {
+      [RelationSourceId]: contactA,
+      [RelationTargetId]: contactB,
+    });
+
+    const json = JSON.parse(JSON.stringify(hasManager));
+    expect(json).toEqual({
+      id: hasManager.id,
+      '@type': DXN.fromTypenameAndVersion(Testing.HasManager.typename, Testing.HasManager.version).toString(),
+      '@relationSource': DXN.fromLocalObjectId(contactA.id).toString(),
+      '@relationTarget': DXN.fromLocalObjectId(contactB.id).toString(),
+      '@meta': {
+        keys: [],
+      },
+    });
+  });
+
+  test('getSchema', () => {
+    const contact = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+
+    expect(getSchema(contact)).toBe(Testing.Contact);
+  });
+
+  test('inspect', () => {
+    const contact = create(Testing.Contact, {
+      name: 'Bot',
+      email: 'bot@example.com',
+    });
+
+    // console.log(contact);
+
+    const text = inspect(contact);
+    expect(text).toContain('Bot');
+    expect(text).toContain('bot@example.com');
+    expect(text).toContain('example.com/type/Contact');
+    expect(text).toContain('0.1.0');
+  });
+});

package/src/internal/object/create.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+
+import { raise } from '@dxos/debug';
+import { assertArgument, failedInvariant } from '@dxos/invariant';
+import { ObjectId } from '@dxos/keys';
+import { defineHiddenProperty } from '@dxos/live-object';
+
+import { EntityKind, getSchemaDXN, getTypeAnnotation } from '../ast';
+
+import { getObjectDXN, setSchema } from './accessors';
+import { attachedTypedObjectInspector } from './inspect';
+import { attachTypedJsonSerializer } from './json-serializer';
+import {
+  EntityKindId,
+  MetaId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  assertObjectModelShape,
+} from './model';
+import { setTypename } from './typename';
+
+// Make `id` optional.
+type CreateData<T> = T extends { id: string } ? Omit<T, 'id' | typeof EntityKindId> & { id?: string } : T;
+
+/**
+ * Creates a new object instance from a schema and data, without signal reactivity.
+ * This static version creates plain JavaScript objects that are not reactive/observable.
+ * For reactive objects that automatically update UI when changed, use the regular live() function.
+ *
+ * @param schema - The Effect schema that defines the object's structure and type, piped into EchoObject
+ * @param data - The data to initialize the object with. The id and @type fields are handled automatically.
+ * @returns A new non-reactive object instance conforming to the schema
+ * @throws {Error} If the schema is not an object schema
+ * @throws {TypeError} If data contains an @type field
+ *
+ * @example
+ * ```ts
+ * const Contact = Schema.Struct({
+ *   name: Schema.String,
+ *   email: Schema.String,
+ * }).pipe(Type.Obj({
+ *   typename: 'example.com/type/Contact',
+ *   version: '0.1.0',
+ * }))
+ *
+ * // Creates a non-reactive contact object
+ * const contact = create(Contact, {
+ *   name: "John",
+ *   email: "john@example.com",
+ * })
+ * ```
+ */
+// TODO(burdon): Rename make.
+// TODO(burdon): Handle defaults (see Schema.make).
+// TODO(dmaretskyi): Use `Obj.make` and `Relation.make` from '@dxos/echo' instead.
+export const create = <S extends Schema.Schema.AnyNoContext>(
+  schema: S,
+  data: CreateData<Schema.Schema.Type<S>>,
+): CreateData<Schema.Schema.Type<S>> & { id: string } => {
+  const annotation = getTypeAnnotation(schema);
+  if (!annotation) {
+    throw new Error('Schema is not an object schema');
+  }
+  assertArgument(!('@type' in data), 'data', '@type is not allowed');
+  assertArgument(!(RelationSourceDXNId in data), 'data', 'Relation source DXN is not allowed in the constructor');
+  assertArgument(!(RelationTargetDXNId in data), 'data', 'Relation target DXN is not allowed in the constructor');
+  assertArgument(
+    RelationSourceId in data === RelationTargetId in data,
+    'data',
+    'Relation source and target must be provided together',
+  );
+
+  const obj = { ...data, id: data.id ?? ObjectId.random() };
+  const kind = RelationSourceId in data ? EntityKind.Relation : EntityKind.Object;
+  defineHiddenProperty(obj, EntityKindId, kind);
+  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant('Missing schema DXN'));
+  setSchema(obj, schema);
+  attachTypedJsonSerializer(obj);
+  attachedTypedObjectInspector(obj);
+  defineHiddenProperty(obj, MetaId, { keys: [] });
+  if (kind === EntityKind.Relation) {
+    const sourceDXN = getObjectDXN(data[RelationSourceId]) ?? raise(new Error('Unresolved relation source'));
+    const targetDXN = getObjectDXN(data[RelationTargetId]) ?? raise(new Error('Unresolved relation target'));
+    defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
+    defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
+  }
+
+  assertObjectModelShape(obj);
+  return obj;
+};

package/src/internal/object/deleted.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { BaseObject } from '../types';
+
+import { DeletedId } from './model';
+
+/**
+ * @returns `true` if the object has been marked as deleted.
+ */
+export const isDeleted = (obj: BaseObject): boolean => {
+  if ((obj as any)[DeletedId] === undefined) {
+    // TODO(dmaretskyi): Return to prior behavior of throwing.
+    // throw new Error('Object does not support deletion marker');
+    return false;
+  }
+  return (obj as any)[DeletedId] ?? false;
+};

package/src/internal/object/entity.ts

@@ -0,0 +1,248 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import type * as Types from 'effect/Types';
+
+import { raise } from '@dxos/debug';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+import {
+  EntityKind,
+  type TypeAnnotation,
+  TypeAnnotationId,
+  type TypeMeta,
+  getEntityKind,
+  getSchemaTypename,
+  getTypeIdentifierAnnotation,
+} from '../ast';
+import { type HasId, type ToMutable } from '../types';
+
+import { type RelationSourceTargetRefs } from './relation';
+
+// TODO(burdon): Define Schema type for `typename` and use consistently for all DXN-like properties.
+
+// type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<HasId & ToMutable<T> & ExtraFields>;
+
+export interface EchoTypeSchema<Self extends Schema.Schema.Any, ExtraFields = {}>
+  extends TypeMeta,
+    Schema.AnnotableClass<
+      EchoTypeSchema<Self, ExtraFields>,
+      EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>,
+      EchoTypeSchemaProps<Schema.Schema.Encoded<Self>, ExtraFields>,
+      Schema.Schema.Context<Self>
+    > {
+  // make(
+  //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
+  //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
+  //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
+  //   options?: MakeOptions,
+  // ): Simplify<Schema.TypeLiteral.Type<Fields, []>>;
+
+  instanceOf(value: unknown): boolean;
+}
+
+/**
+ * Pipeable function to add ECHO object annotations to a schema.
+ */
+// TODO(dmaretskyi): Rename EchoObjectSchema.
+export const EchoObject: {
+  // TODO(burdon): Tighten Self type to Schema.TypeLiteral or Schema.Struct to facilitate definition of `make` method.
+  // (meta: TypeMeta): <Self extends Schema.Struct<Fields>, Fields extends Schema.Struct.Fields>(self: Self) => EchoObjectSchema<Self, Fields>;
+  (meta: TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => EchoTypeSchema<Self>;
+} = ({ typename, version }) => {
+  return <Self extends Schema.Schema.Any>(self: Self): EchoTypeSchema<Self> => {
+    invariant(typeof TypeAnnotationId === 'symbol', 'Sanity.');
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    // TODO(dmaretskyi): Does `Schema.mutable` work for deep mutability here?
+    // TODO(dmaretskyi): Do not do mutable here.
+    const schemaWithId = Schema.extend(Schema.mutable(self), Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: { kind: EntityKind.Object, typename, version } satisfies TypeAnnotation,
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version,
+      }),
+    });
+
+    return makeEchoObjectSchema<Self>(/* self.fields, */ ast, typename, version);
+  };
+};
+
+export type EchoRelationOptions<
+  TSource extends Schema.Schema.AnyNoContext,
+  TTarget extends Schema.Schema.AnyNoContext,
+> = TypeMeta & {
+  source: TSource;
+  target: TTarget;
+};
+
+// TODO(dmaretskyi): Rename EchoRelationSchema.
+export const EchoRelation = <Source extends Schema.Schema.AnyNoContext, Target extends Schema.Schema.AnyNoContext>(
+  options: EchoRelationOptions<Source, Target>,
+) => {
+  assertArgument(Schema.isSchema(options.source), 'source');
+  assertArgument(Schema.isSchema(options.target), 'target');
+  const sourceDXN = getDXNForRelationSchemaRef(options.source);
+  const targetDXN = getDXNForRelationSchemaRef(options.target);
+  if (getEntityKind(options.source) !== EntityKind.Object) {
+    raise(new Error('Source schema must be an echo object schema.'));
+  }
+  if (getEntityKind(options.target) !== EntityKind.Object) {
+    raise(new Error('Target schema must be an echo object schema.'));
+  }
+
+  return <Self extends Schema.Schema.Any>(
+    self: Self,
+  ): EchoTypeSchema<Self, RelationSourceTargetRefs<Schema.Schema.Type<Source>, Schema.Schema.Type<Target>>> => {
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    // TODO(dmaretskyi): Does `Schema.mutable` work for deep mutability here?
+    // TODO(dmaretskyi): Do not do mutable here.
+    const schemaWithId = Schema.extend(Schema.mutable(self), Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Relation,
+        typename: options.typename,
+        version: options.version,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN,
+      } satisfies TypeAnnotation,
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename: options.typename,
+        version: options.version,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN,
+      }),
+    });
+
+    return makeEchoObjectSchema<Self>(/* self.fields, */ ast, options.typename, options.version);
+  };
+};
+
+/**
+ * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.
+ */
+export const makeTypeJsonSchemaAnnotation = (options: {
+  identifier?: string;
+  kind: EntityKind;
+  typename: string;
+  version: string;
+  relationSource?: string;
+  relationTarget?: string;
+}) => {
+  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');
+  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');
+
+  const obj = {
+    // TODO(dmaretskyi): Should this include the version?
+    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename,
+  } as any;
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = { $ref: options.relationSource };
+    obj.relationTarget = { $ref: options.relationTarget };
+  }
+  return obj;
+};
+
+const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): string => {
+  assertArgument(Schema.isSchema(schema), 'schema');
+  const identifier = getTypeIdentifierAnnotation(schema);
+  if (identifier) {
+    return identifier;
+  }
+
+  const typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error('Schema must have a typename');
+  }
+
+  return DXN.fromTypename(typename).toString();
+};
+
+// type MakeOptions =
+//   | boolean
+//   | {
+//       readonly disableValidation?: boolean;
+//     };
+
+// NOTE: Utils copied from Effect `Schema.ts`.
+// const _ownKeys = (o: object): Array<PropertyKey> =>
+//   (Object.keys(o) as Array<PropertyKey>).concat(Object.getOwnPropertySymbols(o));
+
+// const _lazilyMergeDefaults = (
+//   fields: Schema.Struct.Fields,
+//   out: Record<PropertyKey, unknown>,
+// ): { [x: string | symbol]: unknown } => {
+//   const ownKeys = _ownKeys(fields);
+//   for (const key of ownKeys) {
+//     const field = fields[key];
+//     if (out[key] === undefined && Schema.isPropertySignature(field)) {
+//       const ast = field.ast;
+//       const defaultValue = ast._tag === 'PropertySignatureDeclaration' ? ast.defaultValue : ast.to.defaultValue;
+//       if (defaultValue !== undefined) {
+//         out[key] = defaultValue();
+//       }
+//     }
+//   }
+//   return out;
+// };
+
+// const _getDisableValidationMakeOption = (options: MakeOptions | undefined): boolean =>
+//   Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
+
+const makeEchoObjectSchema = <Self extends Schema.Schema.Any>(
+  // fields: Fields,
+  ast: SchemaAST.AST,
+  typename: string,
+  version: string,
+): EchoTypeSchema<Self> => {
+  return class EchoObjectSchemaClass extends Schema.make<
+    EchoTypeSchemaProps<Schema.Schema.Type<Self>>,
+    EchoTypeSchemaProps<Schema.Schema.Encoded<Self>>,
+    Schema.Schema.Context<Self>
+  >(ast) {
+    static readonly typename = typename;
+    static readonly version = version;
+
+    static override annotations(
+      annotations: Schema.Annotations.GenericSchema<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>,
+    ): EchoTypeSchema<Self> {
+      const schema = Schema.make<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>(ast).annotations(annotations);
+      return makeEchoObjectSchema<Self>(/* fields, */ schema.ast, typename, version);
+    }
+
+    // static make(
+    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
+    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
+    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
+    //   options?: MakeOptions,
+    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
+    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
+    //   return _getDisableValidationMakeOption(options)
+    //     ? propsWithDefaults
+    //     : ParseResult.validateSync(this)(propsWithDefaults);
+    // }
+
+    static instanceOf(value: unknown): boolean {
+      return Schema.is(this)(value);
+    }
+  };
+};

package/src/internal/object/expando.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { EchoObject } from './entity';
+
+export const EXPANDO_TYPENAME = 'dxos.org/type/Expando';
+
+const ExpandoSchema = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
+  EchoObject({ typename: EXPANDO_TYPENAME, version: '0.1.0' }),
+);
+
+/**
+ * Expando object is an object with an arbitrary set of properties.
+ */
+// TODO(dmaretskyi): Can we consider expando a top-type, i.e. have a ref to expando potentially be a valid ref to any object?
+export interface Expando extends Schema.Schema.Type<typeof ExpandoSchema> {}
+
+export const Expando: Schema.Schema<Expando> = ExpandoSchema;

package/src/internal/object/ids.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { DXN, ObjectId, QueueSubspaceTags, SpaceId } from '@dxos/keys';
+
+// TODO(burdon): Move to @dxos/keys once ObjectId is moved there.
+/**
+ * @deprecated Use `db.queues.create()`
+ */
+export const createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId.random()) =>
+  new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, spaceId, queueId]);

package/src/internal/object/index.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './common';
+export * from './create';
+export * from './entity';
+export * from './expando';
+export * from './ids';
+export * from './json-serializer';
+export * from './meta';
+export type * from './relation';
+export * from './typed-object';
+export * from './typename';
+export * from './deleted';
+export * from './model';
+export * from './accessors';
+export * from './schema-validator';
+export * from './version';

package/src/internal/object/inspect.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
+
+import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
+
+import { type AnyEchoObject } from '../types';
+
+import { ATTR_META, ATTR_TYPE, MetaId } from './model';
+import { getType } from './typename';
+
+/*
+ * @internal
+ */
+export const attachedTypedObjectInspector = (obj: any) => {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, inspectCustom);
+  if (descriptor) {
+    return;
+  }
+
+  Object.defineProperty(obj, inspectCustom, {
+    value: typedObjectInspectFunction,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+};
+
+// NOTE: KEEP as function.
+const typedObjectInspectFunction: CustomInspectFunction<AnyEchoObject> = function (
+  this: AnyEchoObject,
+  depth: number,
+  options: InspectOptionsStylized,
+  inspect: typeof inspectFn,
+) {
+  const { id, ...props } = this;
+  return inspect(
+    {
+      id,
+      [ATTR_TYPE]: getType(this),
+      ...props,
+      [ATTR_META]: (this as any)[MetaId], // TODO(dmaretskyi): Couldn't use getMeta since that throw's if the object has no meta.
+    },
+    options,
+  );
+};

package/src/internal/object/json-serializer.test.ts

@@ -0,0 +1,99 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { DXN } from '@dxos/keys';
+
+import { EntityKind, getSchemaDXN, getSchemaTypename } from '../ast';
+import { Ref, StaticRefResolver } from '../ref';
+import { Testing } from '../testing';
+
+import { getObjectDXN, getSchema } from './accessors';
+import { create } from './create';
+import { objectFromJSON, objectToJSON } from './json-serializer';
+import { getMeta } from './meta';
+import { ATTR_TYPE, EntityKindId, MetaId, RelationSourceId, RelationTargetId, TypeId } from './model';
+import { getType, getTypename } from './typename';
+
+describe('Object JSON serializer', () => {
+  test('should serialize and deserialize object', async () => {
+    const contact = create(Testing.Contact, {
+      name: 'John Doe',
+    });
+    getMeta(contact).keys.push({ id: '12345', source: 'crm.example.com' });
+
+    const task = create(Testing.Task, {
+      title: 'Polish my shoes',
+      assignee: Ref.make(contact),
+    });
+
+    const contactJson = objectToJSON(contact);
+    const taskJson = objectToJSON(task);
+
+    expect(contactJson.id).toBe(contact.id);
+    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(Testing.Contact)!.toString());
+    expect(contactJson.name).toEqual('John Doe');
+
+    expect(taskJson.id).toBe(task.id);
+    expect(taskJson[ATTR_TYPE]).toEqual(getSchemaDXN(Testing.Task)!.toString());
+    expect(taskJson.title).toEqual('Polish my shoes');
+    expect(taskJson.assignee).toEqual({ '/': DXN.fromLocalObjectId(contact.id).toString() });
+
+    const refResolver = new StaticRefResolver()
+      .addSchema(Testing.Contact)
+      .addSchema(Testing.Task)
+      .addObject(contact)
+      .addObject(task);
+
+    const contactFromJson = (await objectFromJSON(contactJson, { refResolver })) as Testing.Contact;
+    const taskFromJson = (await objectFromJSON(taskJson, { refResolver })) as Testing.Task;
+
+    expect(contactFromJson.id).toBe(contact.id);
+    expect(contactFromJson.name).toBe('John Doe');
+    expect((contactFromJson as any)[TypeId]).toEqual(getSchemaDXN(Testing.Contact));
+    expect((contactFromJson as any)[EntityKindId]).toBe(EntityKind.Object);
+    expect((contactFromJson as any)[RelationSourceId]).toBeUndefined();
+    expect((contactFromJson as any)[RelationTargetId]).toBeUndefined();
+    expect((contactFromJson as any)[MetaId]).toEqual({
+      keys: [
+        {
+          id: '12345',
+          source: 'crm.example.com',
+        },
+      ],
+    });
+    expect(getType(contactFromJson)?.toString()).toBe(getSchemaDXN(Testing.Contact)!.toString());
+    expect(getTypename(contactFromJson)).toBe(getSchemaTypename(Testing.Contact));
+    expect(getObjectDXN(contactFromJson)?.toString()).toEqual(getObjectDXN(contact)?.toString());
+    expect(getSchema(contactFromJson)).toEqual(Testing.Contact);
+
+    expect(taskFromJson.id).toBe(task.id);
+    expect(taskFromJson.title).toBe('Polish my shoes');
+    expect(taskFromJson.assignee!.dxn).toEqual(DXN.fromLocalObjectId(contact.id));
+    expect(taskFromJson.assignee!.target).toEqual(contact);
+    expect(await taskFromJson.assignee!.load()).toEqual(contact);
+    expect((taskFromJson as any)[TypeId]).toEqual(getSchemaDXN(Testing.Task));
+    expect((taskFromJson as any)[EntityKindId]).toBe(EntityKind.Object);
+    expect((taskFromJson as any)[RelationSourceId]).toBeUndefined();
+    expect((taskFromJson as any)[RelationTargetId]).toBeUndefined();
+    expect((taskFromJson as any)[MetaId]).toEqual({ keys: [] });
+    expect(getSchema(taskFromJson)).toEqual(Testing.Task);
+  });
+
+  test('serialize with unresolved schema', async () => {
+    const contact = create(Testing.Contact, {
+      name: 'John Doe',
+    });
+    const contactJson = objectToJSON(contact);
+    const contactFromJson: any = await objectFromJSON(contactJson);
+
+    expect(contactFromJson.id).toBe(contact.id);
+    expect(contactFromJson.name).toBe('John Doe');
+    expect(getSchema(contactFromJson)).toBeUndefined();
+    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(Testing.Contact));
+    expect(getObjectDXN(contactFromJson)).toEqual(getObjectDXN(contact));
+    expect(getType(contactFromJson)).toEqual(getSchemaDXN(Testing.Contact));
+  });
+});