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

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;
-};

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>;