@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

package/src/internal/object/typename.ts

@@ -1,61 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
-
-import { getSchemaTypename } from '../ast';
-import { type BaseObject } from '../types';
-
-import { getSchema } from './accessors';
-import { TypeId } from './model';
-
-/**
- * Gets the typename of the object without the version.
- * Returns only the name portion, not the DXN.
- * @example "example.org/type/Contact"
- */
-export const getTypename = (obj: BaseObject): string | undefined => {
-  const schema = getSchema(obj);
-  if (schema != null) {
-    // Try to extract typename from DXN.
-    return getSchemaTypename(schema);
-  } else {
-    const type = getType(obj);
-    return type?.asTypeDXN()?.type;
-  }
-};
-
-/**
- * @internal
- */
-// TODO(dmaretskyi): Rename setTypeDXN.
-export const setTypename = (obj: any, typename: DXN) => {
-  invariant(typename instanceof DXN, 'Invalid type.');
-  Object.defineProperty(obj, TypeId, {
-    value: typename,
-    writable: false,
-    enumerable: false,
-    configurable: false,
-  });
-};
-
-/**
- * @returns Object type as {@link DXN}.
- * @returns undefined if the object doesn't have a type.
- * @example `dxn:example.com/type/Person:1.0.0`
- */
-export const getType = (obj: BaseObject): DXN | undefined => {
-  if (!obj) {
-    return undefined;
-  }
-
-  const type = (obj as any)[TypeId];
-  if (!type) {
-    return undefined;
-  }
-
-  invariant(type instanceof DXN, 'Invalid object.');
-  return type;
-};

package/src/internal/object/version.ts

@@ -1,22 +0,0 @@
-//
-// NOTE: Those types must match the ones defined at @dxos/echo. We duplicated them murely due to technical constrains.
-//
-
-/**
- * Getter to get object version.
- */
-//
-// Copyright 2025 DXOS.org
-//
-
-export const VersionTypeId: unique symbol = Symbol('@dxos/echo/Version');
-
-/**
- * Represent object version.
- * May be backed by Automerge.
- * Objects with no history are not versioned.
- */
-export interface Version {
-  [VersionTypeId]: {};
-  automergeHeads?: string[];
-}

package/src/internal/projection/index.ts

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

package/src/internal/query/index.ts

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

package/src/internal/schema/stored-schema.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { SchemaVersion, Typename } from '../ast';
-import { JsonSchemaType } from '../json-schema';
-import { EchoObject } from '../object';
-
-/**
- * Persistent representation of a schema.
- */
-export const StoredSchema = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  typename: Typename,
-  version: SchemaVersion,
-  jsonSchema: JsonSchemaType,
-}).pipe(
-  EchoObject({
-    typename: 'dxos.org/type/Schema',
-    version: '0.1.0',
-  }),
-);
-
-export type StoredSchema = Schema.Schema.Type<typeof StoredSchema>;

package/src/internal/testing/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './types';
-export * from './utils';

package/src/internal/testing/types.ts

@@ -1,144 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { EchoObject, EchoRelation, TypedObject } from '../object';
-import { Ref, type Ref$ } from '../ref';
-
-/**
- * @deprecated
- */
-// TOOD(burdon): Reconcile with ../testing (remove this).
-export namespace Testing {
-  //
-  // Primitives
-  //
-
-  const Circle = Schema.Struct({ type: Schema.Literal('circle'), radius: Schema.Number });
-  const Square = Schema.Struct({ type: Schema.Literal('square'), side: Schema.Number });
-  const Shape = Schema.Union(Circle, Square);
-
-  //
-  // Simple types
-  //
-
-  const TestNestedSchema = Schema.mutable(Schema.Struct({ field: Schema.String }));
-  export type TestNestedSchema = Schema.Schema.Type<typeof TestNestedSchema>;
-  export const TestNestedType = TestNestedSchema.pipe(
-    EchoObject({ typename: 'example.com/type/TestNested', version: '0.1.0' }),
-  );
-
-  //
-  // Complex types
-  // TODO(burdon): Change to Type.Obj.
-  //
-
-  export class EmptySchemaType extends TypedObject({
-    typename: 'example.com/type/Empty',
-    version: '0.1.0',
-  })({}) {}
-
-  const fields = {
-    string: Schema.String,
-    number: Schema.Number,
-    nullableShapeArray: Schema.mutable(Schema.Array(Schema.Union(Shape, Schema.Null))),
-    boolean: Schema.Boolean,
-    null: Schema.Null,
-    undefined: Schema.Undefined,
-    stringArray: Schema.mutable(Schema.Array(Schema.String)),
-    twoDimNumberArray: Schema.mutable(Schema.Array(Schema.mutable(Schema.Array(Schema.Number)))),
-    object: TestNestedSchema,
-    objectArray: Schema.mutable(Schema.Array(TestNestedSchema)),
-    nested: Schema.optional(Ref(TestNestedType)),
-    other: Schema.Any,
-  };
-
-  export const TestSchema = Schema.mutable(Schema.partial(Schema.Struct(fields)));
-  export type TestSchema = Schema.Schema.Type<typeof TestSchema>;
-
-  export class TestSchemaType extends TypedObject({
-    typename: 'example.com/type/Test',
-    version: '0.1.0',
-  })(fields, { partial: true }) {} // TODO(burdon): Partial?
-
-  // TODO(burdon): Why do we use need this rather then TestSchemaType?
-  export const TestType = TestSchema.pipe(
-    EchoObject({
-      typename: 'example.com/type/Test',
-      version: '0.1.0',
-    }),
-  );
-
-  export class TestClass {
-    field = 'value';
-    toJSON() {
-      return { field: this.field };
-    }
-  }
-
-  // TODO(dmaretskyi): Another top-level Schema.mutable call as a workaround for the regression in the last minor.
-  export const TestSchemaWithClass = Schema.mutable(
-    Schema.extend(
-      TestSchema,
-      Schema.mutable(
-        Schema.Struct({
-          classInstance: Schema.optional(Schema.instanceOf(TestClass)),
-        }),
-      ),
-    ),
-  );
-
-  export type TestSchemaWithClass = Schema.Schema.Type<typeof TestSchemaWithClass>;
-
-  export class Person extends TypedObject({
-    typename: 'example.com/type/Person',
-    version: '0.1.0',
-  })(
-    {
-      name: Schema.String,
-      username: Schema.String,
-      email: Schema.String,
-      phoneNumbers: Schema.optional(Schema.Array(Schema.Struct({ label: Schema.String, number: Schema.String }))),
-      tasks: Schema.suspend((): Schema.mutable<Schema.Array$<Ref$<Task>>> => Schema.mutable(Schema.Array(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),
-        }),
-      }),
-    },
-    { partial: true },
-  ) {}
-
-  export class Task extends TypedObject({
-    typename: 'example.com/type/Task',
-    version: '0.1.0',
-  })(
-    {
-      title: Schema.optional(Schema.String),
-      completed: Schema.optional(Schema.Boolean),
-      assignee: Schema.optional(Ref(Person)),
-      previous: Schema.optional(Schema.suspend((): Ref$<Task> => Ref(Task))),
-      subTasks: Schema.optional(Schema.mutable(Schema.Array(Schema.suspend((): Ref$<Task> => Ref(Task))))),
-      description: Schema.optional(Schema.String),
-    },
-    { partial: true },
-  ) {}
-
-  export const HasManager = Schema.Struct({
-    since: Schema.optional(Schema.String),
-  }).pipe(
-    EchoRelation({
-      typename: 'example.com/type/HasManager',
-      version: '0.1.0',
-      source: Person,
-      target: Person,
-    }),
-  );
-  export interface HasManager extends Schema.Schema.Type<typeof HasManager> {}
-}

package/src/internal/types/types.test.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { describe, test } from 'vitest';
-
-import { type JsonPath } from '@dxos/effect';
-
-import { type BaseObject, getValue, setValue } from './types';
-
-describe('Types', () => {
-  test('checks sanity', async ({ expect }) => {
-    const obj: BaseObject = {};
-    expect(obj).to.exist;
-  });
-});
-
-describe('get/set deep', () => {
-  test('get/set operations', ({ expect }) => {
-    const obj = {
-      name: 'test',
-      items: ['a', 'b', 'c'],
-      nested: {
-        prop: 'value',
-        arr: [1, 2, 3],
-      },
-    };
-
-    // Basic property access.
-    expect(getValue(obj, 'name' as JsonPath)).toBe('test');
-
-    // Array index access.
-    expect(getValue(obj, 'items[1]' as JsonPath)).toBe('b');
-
-    // Nested property access.
-    expect(getValue(obj, 'nested.prop' as JsonPath)).toBe('value');
-
-    // Nested array access.
-    expect(getValue(obj, 'nested.arr[2]' as JsonPath)).toBe(3);
-
-    // Setting values.
-    const updated1 = setValue(obj, 'items[1]' as JsonPath, 'x');
-    expect(updated1.items[1]).toBe('x');
-
-    const updated2 = setValue(obj, 'nested.arr[0]' as JsonPath, 99);
-    expect(updated2.nested.arr[0]).toBe(99);
-  });
-});

package/src/internal/types/types.ts

@@ -1,176 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { Reference } from '@dxos/echo-protocol';
-import { type JsonPath, splitJsonPath } from '@dxos/effect';
-import { DXN, type ObjectId } from '@dxos/keys';
-import { getDeep, setDeep } from '@dxos/util';
-
-import { getSchemaDXN } from '../ast';
-import { type EntityKindId, type ObjectMeta, getType, getTypename } from '../object';
-import { ATTR_META } from '../object/model';
-
-/**
- * Base type for all data objects (reactive, ECHO, and other raw objects).
- * NOTE: This describes the base type for all database objects.
- * It is stricter than `T extends {}` or `T extends object`.
- */
-// TODO(dmaretskyi): Rename AnyProperties.
-// TODO(dmaretskyi): Prefer `Record<string, unknown>` over `any`.
-/**
- * @deprecated use Obj.Any
- */
-export type BaseObject = Record<string, any>;
-
-/**
- * Marker interface for object with an `id`.
- */
-export interface HasId {
-  readonly id: ObjectId;
-}
-
-// TODO(dmaretskyi): Remove; this type effectively disables type safety due to `any`.
-export type WithId<T extends BaseObject = BaseObject> = T & HasId;
-
-export type ExcludeId<T extends BaseObject> = Omit<T, 'id'>;
-
-/**
- * Properties that are required for object creation.
- */
-// TODO(dmaretskyi): Rename `MakeProps`?
-export type CreationProps<T extends BaseObject> = Omit<T, 'id' | typeof EntityKindId>;
-
-export type PropertyKey<T extends BaseObject> = Extract<keyof ExcludeId<T>, string>;
-
-// TODO(dmaretskyi): Remove. This should be using the symbol type.
-export type WithMeta = { [ATTR_META]?: ObjectMeta };
-
-/**
- * The raw object should not include the ECHO id, but may include metadata.
- */
-export const RawObject = <S extends Schema.Schema.AnyNoContext>(
-  schema: S,
-): Schema.Schema<ExcludeId<Schema.Schema.Type<S>> & WithMeta, Schema.Schema.Encoded<S>> => {
-  return Schema.make(SchemaAST.omit(schema.ast, ['id']));
-};
-
-//
-// Utils
-//
-
-/**
- * Utility to split meta property from raw object.
- * @deprecated Bad API.
- */
-export const splitMeta = <T>(object: T & WithMeta): { object: T; meta?: ObjectMeta } => {
-  const meta = object[ATTR_META];
-  delete object[ATTR_META];
-  return { meta, object };
-};
-
-// TODO(burdon): Move to `@dxos/util`.
-export const getValue = <T extends object>(obj: T, path: JsonPath): any => {
-  return getDeep(
-    obj,
-    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
-  );
-};
-
-// TODO(burdon): Move to `@dxos/util`.
-export const setValue = <T extends object>(obj: T, path: JsonPath, value: any): T => {
-  return setDeep(
-    obj,
-    splitJsonPath(path).map((p) => p.replace(/[[\]]/g, '')),
-    value,
-  );
-};
-
-/**
- * Returns a reference that will be used to point to a schema.
- * @deprecated Use {@link getSchemaDXN} instead.
- */
-export const getTypeReference = (schema: Schema.Schema.All | undefined): Reference | undefined => {
-  if (!schema) {
-    return undefined;
-  }
-
-  const schemaDXN = getSchemaDXN(schema);
-  if (!schemaDXN) {
-    return undefined;
-  }
-  return Reference.fromDXN(schemaDXN);
-};
-
-/**
- * Returns a reference that will be used to point to a schema.
- * @throws If it is not possible to reference this schema.
- *
- * @deprecated Use {@link getSchemaDXN} instead.
- */
-export const requireTypeReference = (schema: Schema.Schema.AnyNoContext): Reference => {
-  const typeReference = getTypeReference(schema);
-  if (typeReference == null) {
-    // TODO(burdon): Catalog user-facing errors (this is too verbose).
-    throw new Error('Schema must be defined via TypedObject.');
-  }
-
-  return typeReference;
-};
-
-// TODO(burdon): Can we use `Schema.is`?
-/**
- * Checks if the object is an instance of the schema.
- * Only typename is compared, the schema version is ignored.
- *
- * The following cases are considered to mean that the object is an instance of the schema:
- *  - Object was created with this exact schema.
- *  - Object was created with a different version of this schema.
- *  - Object was created with a different schema (maybe dynamic) that has the same typename.
- */
-export const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(
-  schema: Schema,
-  object: any,
-): object is Schema.Schema.Type<Schema> => {
-  if (object == null) {
-    return false;
-  }
-
-  const schemaDXN = getSchemaDXN(schema);
-  if (!schemaDXN) {
-    throw new Error('Schema must have an object annotation.');
-  }
-
-  const type = getType(object);
-  if (type && DXN.equals(type, schemaDXN)) {
-    return true;
-  }
-
-  const typename = getTypename(object);
-  if (!typename) {
-    return false;
-  }
-
-  const typeDXN = schemaDXN.asTypeDXN();
-  if (!typeDXN) {
-    return false;
-  }
-
-  return typeDXN.type === typename;
-};
-
-/**
- * Object that has an associated typename.
- * The typename is retrievable using {@link getTypename}.
- * The object can be used with {@link isInstanceOf} to check if it is an instance of a schema.
- */
-export type HasTypename = {};
-
-/**
- * Canonical type for all ECHO objects.
- */
-// TODO(burdon): Reconcile with Obj.Any, Relation.Any.
-export interface AnyEchoObject extends HasId, HasTypename {}

package/src/internal/types/util.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type BaseObject } from './types';
-
-export type ToMutable<T> = T extends BaseObject
-  ? { -readonly [K in keyof T]: T[K] extends readonly (infer U)[] ? U[] : T[K] }
-  : T;

package/src/test/api.test.ts

@@ -1,180 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import { describe, test } from 'vitest';
-
-import { raise } from '@dxos/debug';
-import { FormatAnnotation, FormatEnum } from '@dxos/echo/internal';
-
-import { type Live, Obj, Ref, Relation, Type } from '../index';
-
-namespace Testing {
-  export const Organization = Schema.Struct({
-    id: Type.ObjectId,
-    name: Schema.String,
-  }).pipe(
-    Type.Obj({
-      typename: 'example.com/type/Organization',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Organization extends Schema.Schema.Type<typeof Organization> {}
-
-  export const Person = Schema.Struct({
-    name: Schema.String,
-    dob: Schema.optional(Schema.String),
-    email: Schema.optional(Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email))),
-    organization: Schema.optional(Type.Ref(Organization)),
-  }).pipe(
-    Type.Obj({
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Person extends Schema.Schema.Type<typeof Person> {}
-
-  // export const WorksFor = S.Struct({
-  //   id: Type.ObjectId,
-  //   since: S.String,
-  //   jobTitle: S.String,
-  //   ...Range({ from, to }),
-  //   ...Provenance({ source: 'duckduckgo.com', confidence: 0.9 }), // keys
-  //   ...Relation.make({ source: Contact, target: Organization }),
-  // }).pipe(
-  //   Type.Relation({
-  //     typename: 'example.com/relation/WorksFor',
-  //     version: '0.1.0',
-  //   }),
-  // );
-
-  // {
-  //   const contact = db.add(create(Contact, { name: 'Test' }));
-  //   const organization = db.add(create(Organization, { name: 'DXOS' }));
-  //   db.add(create(WorksFor, { source: contact, target: organization }));
-  // }
-
-  export const WorksFor = Schema.Struct({
-    // id: Type.ObjectId,
-    role: Schema.String,
-  }).pipe(
-    Type.Relation({
-      typename: 'example.com/relation/WorksFor',
-      version: '0.1.0',
-      source: Person,
-      target: Organization,
-    }),
-  );
-
-  export interface WorksFor extends Schema.Schema.Type<typeof WorksFor> {}
-
-  // TODO(burdon): Fix (Type.Obj currently removes TypeLiteral that implements the `make` function).
-  //  Property 'make' does not exist on type 'EchoObjectSchema<Struct<{ timestamp: PropertySignature<":", string, never, ":", string, true, never>; }>>'.ts(2339)
-  export const MessageStruct = Schema.Struct({
-    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
-    // TODO(burdon): Support defaults (update create and create).
-    timestamp: Schema.String.pipe(
-      Schema.propertySignature,
-      Schema.withConstructorDefault(() => new Date().toISOString()),
-    ),
-  });
-
-  export const Message = MessageStruct.pipe(
-    Type.Obj({
-      typename: 'example.com/type/Message',
-      version: '0.1.0',
-    }),
-  );
-
-  export interface Message extends Schema.Schema.Type<typeof Message> {}
-}
-
-describe('Experimental API review', () => {
-  test('type checks', ({ expect }) => {
-    const contact = Obj.make(Testing.Person, { name: 'Test' });
-    const type: Schema.Schema<Testing.Person> = Obj.getSchema(contact) ?? raise(new Error('No schema found'));
-
-    expect(Type.getDXN(type)?.typename).to.eq(Testing.Person.typename);
-    expect(Type.getTypename(type)).to.eq('example.com/type/Person');
-    expect(Type.getVersion(type)).to.eq('0.1.0');
-    expect(Type.getMeta(type)).to.deep.eq({
-      kind: Type.Kind.Object,
-      typename: 'example.com/type/Person',
-      version: '0.1.0',
-    });
-  });
-
-  test('instance checks', ({ expect }) => {
-    const organization: Live<Testing.Organization> = Obj.make(Testing.Organization, { name: 'DXOS' });
-    const contact: Live<Testing.Person> = Obj.make(Testing.Person, {
-      name: 'Test',
-      organization: Ref.make(organization),
-    });
-
-    expect(Schema.is(Testing.Person)(contact)).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('version', ({ expect }) => {
-    const person = Obj.make(Testing.Person, { name: 'Test' });
-    const version = Obj.version(person);
-    expect(Obj.isVersion(version)).to.be.true;
-    expect(Obj.versionValid(version)).to.be.false;
-  });
-
-  test.skip('type narrowing', () => {
-    const any: Obj.Any | Relation.Any = null as any;
-
-    {
-      if (Obj.isObject(any)) {
-        any;
-      } else {
-        any;
-      }
-    }
-
-    {
-      if (Relation.isRelation(any)) {
-        any;
-      } else {
-        any;
-      }
-    }
-  });
-});