@dxos/echo 0.8.4-main.c4373fc → 0.8.4-main.d05673bc65

package/src/internal/proxy/reactive-object.ts

@@ -1,108 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type * as Schema from 'effect/Schema';
-
-import { ObjectId } from '@dxos/keys';
-import {
-  type Live,
-  UntypedReactiveHandler,
-  createProxy,
-  defineHiddenProperty,
-  isValidProxyTarget,
-} from '@dxos/live-object';
-
-import { getTypeAnnotation } from '../ast';
-import { EntityKindId, Expando, MetaId, type ObjectMeta, ObjectMetaSchema, attachTypedJsonSerializer } from '../object';
-import type { BaseObject, CreationProps } from '../types';
-
-import { TypedReactiveHandler, prepareTypedTarget } from './typed-handler';
-
-/**
- * Creates a reactive object from a plain Javascript object.
- * Optionally provides a TS-effect schema.
- *
- * @depreacted Use `Obj.make`.
- */
-// TODO(dmaretskyi): Deep mutability.
-// TODO(dmaretskyi): Invert generics (generic over schema) to have better error messages.
-// TODO(dmaretskyi): Could mutate original object making it unusable.
-// TODO(burdon): Use Schema.make() to handle defaults?
-export const live: {
-  <T extends BaseObject>(obj: T): Live<T>;
-  <T extends BaseObject>(
-    schema: Schema.Schema<T, any, never>,
-    obj: NoInfer<CreationProps<T>>,
-    meta?: ObjectMeta,
-  ): Live<T>;
-} = <T extends BaseObject>(
-  objOrSchema: Schema.Schema<T, any> | T,
-  obj?: CreationProps<T>,
-  meta?: ObjectMeta,
-): Live<T> => {
-  // TODO(dmaretskyi): Remove Expando special case.
-  if (obj && (objOrSchema as any) !== Expando) {
-    return createReactiveObject<T>({ ...obj } as T, meta, objOrSchema as Schema.Schema<T, any>);
-  } else if (obj && (objOrSchema as any) === Expando) {
-    return createReactiveObject<T>({ ...obj } as T, meta, undefined, { expando: true });
-  } else {
-    return createReactiveObject<T>(objOrSchema as T, meta);
-  }
-};
-
-const createReactiveObject = <T extends BaseObject>(
-  obj: T,
-  meta?: ObjectMeta,
-  schema?: Schema.Schema<T>,
-  options?: { expando?: boolean },
-): Live<T> => {
-  if (!isValidProxyTarget(obj)) {
-    throw new Error('Value cannot be made into a reactive object.');
-  }
-
-  if (schema) {
-    const annotation = getTypeAnnotation(schema);
-    const shouldGenerateId = options?.expando || !!annotation;
-    if (shouldGenerateId) {
-      setIdOnTarget(obj);
-    }
-    if (annotation) {
-      defineHiddenProperty(obj, EntityKindId, annotation.kind);
-    }
-    initMeta(obj, meta);
-    prepareTypedTarget(obj, schema);
-    attachTypedJsonSerializer(obj);
-    return createProxy<T>(obj, TypedReactiveHandler.instance);
-  } else {
-    if (options?.expando) {
-      setIdOnTarget(obj);
-    }
-    initMeta(obj, meta);
-    return createProxy<T>(obj, UntypedReactiveHandler.instance);
-  }
-};
-
-/**
- * Set ID on ECHO object targets during creation.
- * Used for objects with schema and the ones explicitly marked as Expando.
- */
-const setIdOnTarget = (target: any) => {
-  // invariant(!('id' in target), 'Object already has an `id` field, which is reserved.');
-  if ('id' in target && target.id !== undefined && target.id !== null) {
-    if (!ObjectId.isValid(target.id)) {
-      throw new Error('Invalid object id format.');
-    }
-  } else {
-    target.id = ObjectId.random();
-  }
-};
-
-/**
- * Set metadata on object.
- */
-// TODO(dmaretskyi): Move to echo-schema.
-const initMeta = <T>(obj: T, meta: ObjectMeta = { keys: [] }) => {
-  prepareTypedTarget(meta, ObjectMetaSchema);
-  defineHiddenProperty(obj, MetaId, createProxy(meta, TypedReactiveHandler.instance as any));
-};

package/src/internal/proxy/typed-handler.test.ts

@@ -1,102 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import { describe, expect, test } from 'vitest';
-
-import { Ref, TypedObject, create, foreignKey, getMeta, getSchema, isInstanceOf } from '..';
-import { Testing } from '../testing';
-
-import { live } from './reactive-object';
-
-describe('complex schema validations', () => {
-  const setValue = (target: any, prop: string, value: any) => {
-    target[prop] = value;
-  };
-
-  test('any', () => {
-    const schema = Schema.Struct({ field: Schema.Any });
-    const object = live(schema, { field: { nested: { value: 100 } } });
-    expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
-  });
-
-  test('meta', () => {
-    const source = 'test';
-    const schema = Schema.Struct({ field: Schema.Number });
-    const object = live(schema, { field: 42 }, { keys: [foreignKey(source, '123')] });
-    expect(getMeta(object).keys).to.deep.eq([foreignKey(source, '123')]);
-  });
-
-  test('object', () => {
-    const schema = Schema.Struct({ field: Schema.optional(Schema.Object) });
-    const object = live(schema, { field: { nested: { value: 100 } } });
-    expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
-  });
-
-  test('references', () => {
-    class Foo extends TypedObject({ typename: 'example.com/type/Foo', version: '0.1.0' })({ field: Schema.String }) {}
-    class Bar extends TypedObject({ typename: 'example.com/type/Bar', version: '0.1.0' })({ fooRef: Ref(Foo) }) {}
-    const field = 'hello';
-    expect(() => live(Bar, { fooRef: { id: '1', field } as any })).to.throw();
-    expect(() => live(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
-    const bar = live(Bar, { fooRef: Ref.make(live(Foo, { field })) });
-    expect(bar.fooRef.target?.field).to.eq(field);
-  });
-
-  test('index signatures', () => {
-    const schema = Schema.Struct({}, { key: Schema.String, value: Schema.Number });
-    const object = live(schema, { unknownField: 1 });
-    expect(() => setValue(object, 'field', '42')).to.throw();
-    expect(() => setValue(object, 'unknown_field', 42)).not.to.throw();
-  });
-
-  test('suspend', () => {
-    const schema = Schema.Struct({
-      array: Schema.optional(Schema.suspend(() => Schema.Array(Schema.Union(Schema.Null, Schema.Number)))),
-      object: Schema.optional(Schema.suspend(() => Schema.Union(Schema.Null, Schema.Struct({ field: Schema.Number })))),
-    });
-
-    const object = live(schema, { array: [1, 2, null], object: { field: 3 } });
-    expect(() => setValue(object, 'object', { field: 4 })).not.to.throw();
-    expect(() => setValue(object.object, 'field', 4)).not.to.throw();
-    expect(() => setValue(object.array, '0', 4)).not.to.throw();
-    expect(() => setValue(object.array, '0', '4')).to.throw();
-  });
-
-  test('nesting static objects with schema in the live object', () => {
-    const contact1 = create(Testing.Contact, {
-      name: 'Robert Smith',
-      email: 'robert@example.com',
-    } as any);
-    const contact2 = create(Testing.Contact, {
-      name: 'Katy Perry',
-      email: 'katy@example.com',
-    } as any);
-
-    const contactBook = live({
-      contacts: [contact1],
-    });
-
-    expect(isInstanceOf(Testing.Contact, contactBook.contacts[0])).to.eq(true);
-    expect(getSchema(contactBook.contacts[0])).to.eq(Testing.Contact);
-
-    contactBook.contacts.push(contact2);
-    expect(isInstanceOf(Testing.Contact, contactBook.contacts[1])).to.eq(true);
-    expect(getSchema(contactBook.contacts[1])).to.eq(Testing.Contact);
-  });
-
-  test('creating an object with data from another object', () => {
-    const contact = live(Testing.Contact, {
-      name: 'Robert Smith',
-      email: 'robert@example.com',
-    });
-    const TestSchema = Schema.Struct({
-      value: Schema.Unknown,
-    });
-    const data = live(TestSchema, {
-      value: contact,
-    });
-    expect((data.value as any).name).to.eq('Robert Smith');
-  });
-});

package/src/internal/proxy/typed-handler.ts

@@ -1,228 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type InspectOptionsStylized } from 'node:util';
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { inspectCustom } from '@dxos/debug';
-import { type GenericSignal, compositeRuntime } from '@dxos/echo-signals/runtime';
-import { invariant } from '@dxos/invariant';
-import {
-  ReactiveArray,
-  type ReactiveHandler,
-  createProxy,
-  defineHiddenProperty,
-  isValidProxyTarget,
-  objectData,
-  symbolIsProxy,
-} from '@dxos/live-object';
-
-import { getSchemaDXN } from '../ast';
-import { DeletedId, SchemaId, SchemaValidator, TypeId } from '../object';
-
-const symbolSignal = Symbol('signal');
-const symbolPropertySignal = Symbol('property-signal');
-
-type ProxyTarget = {
-  /**
-   * Typename or type DXN.
-   */
-  [TypeId]: string;
-
-  /**
-   * Schema for the root.
-   */
-  [SchemaId]: Schema.Schema.AnyNoContext;
-
-  /**
-   * For get and set operations on value properties.
-   */
-  // TODO(dmaretskyi): Turn into a map of signals per-field.
-  [symbolSignal]: GenericSignal;
-
-  /**
-   * For modifying the structure of the object.
-   */
-  [symbolPropertySignal]: GenericSignal;
-} & ({ [key: keyof any]: any } | any[]);
-
-/**
- * Typed in-memory reactive store (with Schema).
- */
-export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
-  public static readonly instance: ReactiveHandler<any> = new TypedReactiveHandler();
-
-  readonly _proxyMap = new WeakMap<object, any>();
-
-  private constructor() {}
-
-  init(target: ProxyTarget): void {
-    invariant(typeof target === 'object' && target !== null);
-    invariant(SchemaId in target, 'Schema is not defined for the target');
-
-    if (!(symbolSignal in target)) {
-      defineHiddenProperty(target, symbolSignal, compositeRuntime.createSignal());
-      defineHiddenProperty(target, symbolPropertySignal, compositeRuntime.createSignal());
-    }
-
-    defineHiddenProperty(target, DeletedId, false);
-
-    for (const key of Object.getOwnPropertyNames(target)) {
-      const descriptor = Object.getOwnPropertyDescriptor(target, key)!;
-      if (descriptor.get) {
-        // Ignore getters.
-        continue;
-      }
-
-      // Array reactivity is already handled by the schema validator.
-    }
-
-    // Maybe have been set by `create`.
-    Object.defineProperty(target, inspectCustom, {
-      enumerable: false,
-      configurable: true,
-      value: this._inspect.bind(target),
-    });
-  }
-
-  get(target: ProxyTarget, prop: string | symbol, receiver: any): any {
-    switch (prop) {
-      case objectData: {
-        target[symbolSignal].notifyRead();
-        return toJSON(target);
-      }
-    }
-
-    // Handle getter properties. Will not subscribe the value signal.
-    if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
-      target[symbolPropertySignal].notifyRead();
-
-      // TODO(dmaretskyi): Turn getters into computed fields.
-      return Reflect.get(target, prop, receiver);
-    }
-
-    target[symbolSignal].notifyRead();
-    target[symbolPropertySignal].notifyRead();
-
-    const value = Reflect.get(target, prop, receiver);
-    if (isValidProxyTarget(value)) {
-      return createProxy(value, this);
-    }
-
-    return value;
-  }
-
-  set(target: ProxyTarget, prop: string | symbol, value: any, receiver: any): boolean {
-    // Convert arrays to reactive arrays on write.
-    if (Array.isArray(value)) {
-      value = ReactiveArray.from(value);
-    }
-
-    let result: boolean = false;
-    compositeRuntime.batch(() => {
-      const validatedValue = this._validateValue(target, prop, value);
-      result = Reflect.set(target, prop, validatedValue, receiver);
-      target[symbolSignal].notifyWrite();
-    });
-    return result;
-  }
-
-  ownKeys(target: ProxyTarget): ArrayLike<string | symbol> {
-    // Touch both signals since `set` and `delete` operations may create or remove properties.
-    target[symbolSignal].notifyRead();
-    target[symbolPropertySignal].notifyRead();
-    return Reflect.ownKeys(target);
-  }
-
-  defineProperty(target: ProxyTarget, property: string | symbol, attributes: PropertyDescriptor): boolean {
-    const validatedValue = this._validateValue(target, property, attributes.value);
-    const result = Reflect.defineProperty(target, property, {
-      ...attributes,
-      value: validatedValue,
-    });
-    target[symbolPropertySignal].notifyWrite();
-    return result;
-  }
-
-  private _validateValue(target: any, prop: string | symbol, value: any) {
-    const schema = SchemaValidator.getTargetPropertySchema(target, prop);
-    const _ = Schema.asserts(schema)(value);
-    if (Array.isArray(value)) {
-      value = new ReactiveArray(...value);
-    }
-    if (isValidProxyTarget(value)) {
-      setSchemaProperties(value, schema);
-    }
-
-    return value;
-  }
-
-  private _inspect(
-    _: number,
-    options: InspectOptionsStylized,
-    inspectFn: (value: any, options?: InspectOptionsStylized) => string,
-  ): string {
-    return `Typed ${inspectFn(this, {
-      ...options,
-      compact: true,
-      showHidden: false,
-      customInspect: false,
-    })}`;
-  }
-}
-
-/**
- * @deprecated Use `Obj.toJSON` instead.
- */
-const toJSON = (target: ProxyTarget): any => {
-  return { '@type': 'TypedReactiveObject', ...target };
-};
-
-/**
- * Recursively set AST on all potential proxy targets.
- */
-const setSchemaProperties = (obj: any, schema: Schema.Schema.AnyNoContext) => {
-  const schemaType = getSchemaDXN(schema);
-  if (schemaType != null) {
-    defineHiddenProperty(obj, TypeId, schemaType);
-  }
-
-  defineHiddenProperty(obj, SchemaId, schema);
-  for (const key in obj) {
-    if (isValidProxyTarget(obj[key])) {
-      const elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
-      if (elementSchema != null) {
-        setSchemaProperties(obj[key], elementSchema);
-      }
-    }
-  }
-};
-
-export const prepareTypedTarget = <T>(target: T, schema: Schema.Schema<T>) => {
-  // log.info('prepareTypedTarget', { target, schema });
-  if (!SchemaAST.isTypeLiteral(schema.ast)) {
-    throw new Error('schema has to describe an object type');
-  }
-
-  SchemaValidator.validateSchema(schema);
-  const _ = Schema.asserts(schema)(target);
-  makeArraysReactive(target);
-  setSchemaProperties(target, schema);
-};
-
-const makeArraysReactive = (target: any) => {
-  for (const key in target) {
-    if (target[symbolIsProxy]) {
-      continue;
-    }
-    if (Array.isArray(target[key])) {
-      target[key] = ReactiveArray.from(target[key]);
-    }
-    if (typeof target[key] === 'object') {
-      makeArraysReactive(target[key]);
-    }
-  }
-};

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

@@ -1,100 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import { describe, expect, test } from 'vitest';
-
-import { EchoObject, TypedObject, getSchema } from '..';
-
-import { live } from './reactive-object';
-
-const Organization = Schema.Struct({
-  name: Schema.String,
-}).pipe(
-  EchoObject({
-    typename: 'example.com/type/Organization',
-    version: '0.1.0',
-  }),
-);
-
-interface Organization extends Schema.Schema.Type<typeof Organization> {}
-
-const Contact = Schema.Struct(
-  {
-    name: Schema.String,
-  },
-  { key: Schema.String, value: Schema.Any },
-).pipe(
-  Schema.partial,
-  EchoObject({
-    typename: 'example.com/type/Contact',
-    version: '0.1.0',
-  }),
-);
-
-interface Contact extends Schema.Schema.Type<typeof Contact> {}
-
-const TEST_ORG: Omit<Organization, 'id'> = { name: 'Test' };
-
-describe('EchoObject class DSL', () => {
-  test('can get object schema', async () => {
-    const obj = live(Organization, TEST_ORG);
-    expect(getSchema(obj)).to.deep.eq(Organization);
-  });
-
-  describe('class options', () => {
-    test('can assign undefined to partial fields', async () => {
-      const person = live(Contact, { name: 'John' });
-      person.name = undefined;
-      person.recordField = 'hello';
-      expect(person.name).to.be.undefined;
-      expect(person.recordField).to.eq('hello');
-    });
-  });
-
-  test('record', () => {
-    const schema = Schema.mutable(
-      Schema.Struct({
-        meta: Schema.optional(Schema.mutable(Schema.Any)),
-        // NOTE: Schema.Record only supports shallow values.
-        // https://www.npmjs.com/package/@effect/schema#mutable-records
-        // meta: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
-        // meta: Schema.optional(Schema.mutable(Schema.object)),
-      }),
-    );
-
-    {
-      const object = live(schema, {});
-      (object.meta ??= {}).test = 100;
-      expect(object.meta.test).to.eq(100);
-    }
-
-    {
-      const object = live(schema, {});
-      object.meta = { test: { value: 300 } };
-      expect(object.meta.test.value).to.eq(300);
-    }
-
-    {
-      type Test1 = Schema.Schema.Type<typeof schema>;
-
-      const object: Test1 = {};
-      (object.meta ??= {}).test = 100;
-      expect(object.meta.test).to.eq(100);
-    }
-
-    {
-      class Test2 extends TypedObject({
-        typename: 'dxos.org/type/FunctionTrigger',
-        version: '0.1.0',
-      })({
-        meta: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
-      }) {}
-
-      const object = live(Test2, {});
-      (object.meta ??= {}).test = 100;
-      expect(object.meta.test).to.eq(100);
-    }
-  });
-});

package/src/internal/query/index.ts

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

package/src/internal/query/query.ts

@@ -1,23 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-// TODO(wittjosiah): Remove. Use ordering in queries instead.
-
-/** @deprecated */
-const SortDirection = Schema.Union(Schema.Literal('asc'), Schema.Literal('desc'));
-/** @deprecated */
-export type SortDirectionType = Schema.Schema.Type<typeof SortDirection>;
-
-/** @deprecated */
-const FieldSort = Schema.Struct({
-  fieldId: Schema.String,
-  direction: SortDirection,
-}).pipe(Schema.mutable);
-
-/** @deprecated */
-export interface FieldSortType extends Schema.Schema.Type<typeof FieldSort> {}
-/** @deprecated */
-export const FieldSortType: Schema.Schema<FieldSortType> = FieldSort;

package/src/internal/schema/index.ts

@@ -1,10 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './echo-schema';
-export * from './snapshot';
-export * from './stored-schema';
-export * from './runtime-schema-registry';
-export * from './manipulation';
-export * from './echo-schema';

package/src/internal/schema/runtime-schema-registry.ts

@@ -1,78 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import type * as Schema from 'effect/Schema';
-
-import { raise } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
-import { type DXN } from '@dxos/keys';
-import { defaultMap } from '@dxos/util';
-
-import { getSchemaTypename, getSchemaVersion } from '../ast';
-
-import { StoredSchema } from './stored-schema';
-
-/**
- * Runtime registry of static schema objects (i.e., not Dynamic .
- */
-// TODO(burdon): Reconcile with EchoSchemaRegistry.
-export class RuntimeSchemaRegistry {
-  private readonly _registry = new Map<string, Schema.Schema.AnyNoContext[]>();
-
-  constructor() {
-    this._registry.set(StoredSchema.typename, [StoredSchema]);
-  }
-
-  get schemas(): Schema.Schema.AnyNoContext[] {
-    return Array.from(this._registry.values()).flat();
-  }
-
-  hasSchema<S extends Schema.Schema.AnyNoContext>(schema: S): boolean {
-    const typename = getSchemaTypename(schema);
-    const version = getSchemaVersion(schema);
-    invariant(typename, 'Invalid schema');
-
-    const schemas = this._registry.get(typename);
-    return schemas?.some((schema) => getSchemaVersion(schema) === version) ?? false;
-  }
-
-  getSchemaByDXN(dxn: DXN): Schema.Schema.AnyNoContext | undefined {
-    const components = dxn.asTypeDXN();
-    if (!components) {
-      return undefined;
-    }
-
-    const { type, version } = components;
-    const allSchemas = this._registry.get(type) ?? [];
-    if (version) {
-      return allSchemas.find((s) => getSchemaVersion(s) === version);
-    } else {
-      // If no version is specified, return the earliest version for backwards compatibility.
-      // TODO(dmaretskyi): Probably not correct to compare lexicographically, but it's good enough for now.
-      return allSchemas.sort((a, b) =>
-        (getSchemaVersion(a) ?? '0.0.0').localeCompare(getSchemaVersion(b) ?? '0.0.0'),
-      )[0];
-    }
-  }
-
-  /**
-   * @deprecated Use getSchemaByDXN.
-   */
-  getSchema(typename: string): Schema.Schema.AnyNoContext | undefined {
-    return this._registry.get(typename)?.[0];
-  }
-
-  addSchema(types: Schema.Schema.AnyNoContext[]): void {
-    types.forEach((schema) => {
-      const typename = getSchemaTypename(schema) ?? raise(new TypeError('Schema has no typename'));
-      const version = getSchemaVersion(schema) ?? raise(new TypeError('Schema has no version'));
-      const versions = defaultMap(this._registry, typename, () => []);
-      if (versions.some((schema) => getSchemaVersion(schema) === version)) {
-        throw new Error(`Schema version already registered: ${typename}:${version}`);
-      }
-
-      versions.push(schema);
-    });
-  }
-}

package/src/internal/schema/snapshot.ts

@@ -1,25 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-/**
- * Returns a non-reactive snapshot of the given live object.
- * @deprecated Use `getSnapshot` from `@dxos/live-object` instead.
- */
-// TODO(wittjosiah): Types.
-export const getSnapshot = (object: any): any => {
-  if (typeof object !== 'object') {
-    return object;
-  }
-
-  if (Array.isArray(object)) {
-    return object.map(getSnapshot);
-  }
-
-  const result: any = {};
-  for (const key in object) {
-    result[key] = getSnapshot(object[key]);
-  }
-
-  return result;
-};