@dxos/echo 0.8.4-main.3a94e84 → 0.8.4-main.3c1ae3b

package/src/Type.ts

@@ -2,45 +2,59 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
-import { type Simplify } from 'effect/Schema';
+import type * as Schema$ from 'effect/Schema';
 
 import { type EncodedReference } from '@dxos/echo-protocol';
-import * as EchoSchema from '@dxos/echo-schema';
-import { type ToMutable } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import type * as Keys from '@dxos/keys';
+import { type DXN } from '@dxos/keys';
+import { type ToMutable } from '@dxos/util';
+
+import type * as Entity$ from './Entity';
+import {
+  type ATTR_RELATION_SOURCE,
+  type ATTR_RELATION_TARGET,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  type EchoRelationSchemaOptions,
+  EchoSchema,
+  Expando as Expando$,
+  type ExpandoEncoded,
+  PersistentSchema,
+  type PersistentSchemaEncoded,
+  Ref as Ref$,
+  type RefFn,
+  type RefSchema,
+  type TypeAnnotation,
+  type TypeMeta,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypeAnnotation,
+  isMutable as isMutable$,
+  toEffectSchema,
+  toJsonSchema,
+} from './internal';
+import type * as Relation$ from './Relation';
+
+// TODO(burdon): Remove toEffectSchema, toJsonSchema (moved to JsonSchema export).
+export { toEffectSchema, toJsonSchema };
 
-import type * as RelationModule from './Relation';
+/**
+ * Returns all properties of an object or relation except for the id and kind.
+ */
+export type Properties<T = any> = Omit<T, 'id' | Entity$.KindId | Relation$.Source | Relation$.Target>;
 
 //
-// Kind
+// Entity
 //
 
-export const KindId: unique symbol = EchoSchema.EntityKindId as any;
-export type KindId = typeof KindId;
-
-export const Kind = EchoSchema.EntityKind;
-
-/**
- * Assigns a kind to an Object or Relation instance.
- */
-// NOTE: Needed to make `isRelation` and `isObject` checks work.
-export interface OfKind<Kind extends EchoSchema.EntityKind> {
-  readonly id: Keys.ObjectId;
-  readonly [KindId]: Kind;
+export namespace Entity {
+  /**
+   * Type.Obj.Any | Type.Relation.Any.
+   */
+  export type Any = Obj.Any | Relation.Any;
 }
 
-/**
- * Base ECHO schema type.
- */
-export type Schema = EchoSchema.EchoSchema;
-
-/**
- * Returns all properties of an object or relation except for the id and kind.
- */
-export type Properties<T> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
-
 //
 // Obj
 //
@@ -55,45 +69,50 @@ interface ObjJsonProps {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface obj<Self extends Schema.Schema.Any>
-  extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+export interface obj<Self extends Schema$.Schema.Any>
+  extends TypeMeta,
+    Schema$.AnnotableClass<
       obj<Self>,
-      OfKind<EchoSchema.EntityKind.Object> & ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<ObjJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+      Entity$.OfKind<typeof Entity$.Kind.Object> & ToMutable<Schema$.Schema.Type<Self>>,
+      Schema$.Simplify<ObjJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,
+      Schema$.Schema.Context<Self>
     > {}
 
 /**
  * Object schema.
  */
 export const Obj: {
-  (opts: EchoSchema.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => obj<Self>;
-} = EchoSchema.EchoObject as any;
+  (opts: TypeMeta): <Self extends Schema$.Schema.Any>(self: Self) => obj<Self>;
+} = EchoObjectSchema as any;
 
 /**
  * Object schema type definitions.
  */
-export namespace Obj {
+export declare namespace Obj {
   /**
    * Type that represents an arbitrary schema type of an object.
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = Schema.Schema.AnyNoContext;
+  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).
+  export type Any = obj<Schema$.Schema.AnyNoContext>;
 }
 
 //
 // Expando
 //
 
-export interface Expando extends OfKind<EchoSchema.EntityKind.Object> {
-  [key: string]: any;
-}
+export const Expando: obj<Schema$.Schema<Expando$, ExpandoEncoded>> = Expando$ as any;
+export type Expando = obj<Schema$.Schema<Expando$, ExpandoEncoded>>;
 
-type ExpandoEncoded = Simplify<ObjJsonProps & { [key: string]: any }>;
+//
+// Schema
+//
+
+export const PersistentType: obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>> = PersistentSchema as any;
+export type PersistentType = obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>>;
 
-export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
+export { EchoSchema as RuntimeType };
 
 //
 // Relation
@@ -101,8 +120,8 @@ export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema
 
 interface RelationJsonProps {
   id: string;
-  [EchoSchema.ATTR_RELATION_SOURCE]: string;
-  [EchoSchema.ATTR_RELATION_TARGET]: string;
+  [ATTR_RELATION_SOURCE]: string;
+  [ATTR_RELATION_TARGET]: string;
 }
 
 /**
@@ -112,28 +131,29 @@ interface RelationJsonProps {
  * See Effect's note on interface types.
  */
 export interface relation<
-  Self extends Schema.Schema.Any,
-  SourceSchema extends Schema.Schema.Any,
-  TargetSchema extends Schema.Schema.Any,
-> extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+  Self extends Schema$.Schema.Any,
+  SourceSchema extends Schema$.Schema.Any,
+  TargetSchema extends Schema$.Schema.Any,
+> extends TypeMeta,
+    Schema$.AnnotableClass<
       relation<Self, SourceSchema, TargetSchema>,
-      OfKind<EchoSchema.EntityKind.Relation> &
-        Relation.Endpoints<Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>> &
-        ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<RelationJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+      Entity$.OfKind<typeof Entity$.Kind.Relation> &
+        Relation.Endpoints<Schema$.Schema.Type<SourceSchema>, Schema$.Schema.Type<TargetSchema>> &
+        ToMutable<Schema$.Schema.Type<Self>>,
+      Schema$.Simplify<RelationJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,
+      Schema$.Schema.Context<Self>
     > {}
 
 /**
  * Relation schema.
  */
 // TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.
+// TODO(burdon): Remove?
 export const Relation: {
-  <Source extends Schema.Schema.AnyNoContext, Target extends Schema.Schema.AnyNoContext>(
-    opts: EchoSchema.EchoRelationOptions<Source, Target>,
-  ): <Self extends Schema.Schema.Any>(self: Self) => relation<Self, Source, Target>;
-} = EchoSchema.EchoRelation as any;
+  <Source extends Schema$.Schema.AnyNoContext, Target extends Schema$.Schema.AnyNoContext>(
+    opts: EchoRelationSchemaOptions<Source, Target>,
+  ): <Self extends Schema$.Schema.Any>(self: Self) => relation<Self, Source, Target>;
+} = EchoRelationSchema as any;
 
 /**
  * Relation schema type definitions.
@@ -144,7 +164,7 @@ export namespace Relation {
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = Schema.Schema.AnyNoContext;
+  export type Any = Schema$.Schema.AnyNoContext;
 
   /**
    * Get relation source type.
@@ -157,13 +177,14 @@ export namespace Relation {
   export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;
 
   export type Endpoints<Source, Target> = {
-    [RelationModule.Source]: Source;
-    [RelationModule.Target]: Target;
+    [Relation$.Source]: Source;
+    [Relation$.Target]: Target;
   };
 }
 
 //
 // Ref
+// TODO(burdon): Reconcile Type.Ref with Ref.Ref.
 //
 
 /**
@@ -172,23 +193,21 @@ export namespace Relation {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface ref<TargetSchema extends Schema.Schema.Any>
-  extends EchoSchema.Ref$<Schema.Schema.Type<TargetSchema>> {}
+export interface ref<TargetSchema extends Schema$.Schema.Any> extends RefSchema<Schema$.Schema.Type<TargetSchema>> {}
 
 /**
  * Ref schema.
  */
-export const Ref: <S extends Obj.Any>(schema: S) => ref<S> = EchoSchema.Ref;
+export const Ref: RefFn = Ref$;
 
-export interface Ref<T> extends Schema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}
+export interface Ref<T> extends Schema$.SchemaClass<Ref$<T>, EncodedReference> {}
 
-// TODO(buurdon): Move to Ref?
 export namespace Ref {
   /**
    * Type that represents an arbitrary schema type of a reference.
    * NOTE: This is not an instance type.
    */
-  export type Any = Schema.Schema<EchoSchema.Ref<any>, EncodedReference>;
+  export type Any = Schema$.Schema<Ref$<any>, EncodedReference>;
 }
 
 /**
@@ -197,16 +216,16 @@ export namespace Ref {
  * @example "dxn:example.com/type/Person:0.1.0"
  * @example "dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX"
  */
-export const getDXN = (schema: Obj.Any | Relation.Any): Keys.DXN | undefined => {
-  return EchoSchema.getSchemaDXN(schema);
+export const getDXN = (schema: Entity.Any): DXN | undefined => {
+  return getSchemaDXN(schema);
 };
 
 /**
  * @param schema - Schema to get the typename from.
  * @returns The typename of the schema. Example: `example.com/type/Person`.
  */
-export const getTypename = (schema: Obj.Any | Relation.Any): string => {
-  const typename = EchoSchema.getSchemaTypename(schema);
+export const getTypename = (schema: Entity.Any): string => {
+  const typename = getSchemaTypename(schema);
   invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');
   return typename;
 };
@@ -215,8 +234,8 @@ export const getTypename = (schema: Obj.Any | Relation.Any): string => {
  * Gets the version of the schema.
  * @example 0.1.0
  */
-export const getVersion = (schema: Obj.Any | Relation.Any): string => {
-  const version = EchoSchema.getSchemaVersion(schema);
+export const getVersion = (schema: Entity.Any): string => {
+  const version = getSchemaVersion(schema);
   invariant(typeof version === 'string' && version.match(/^\d+\.\d+\.\d+$/), 'Invalid version');
   return version;
 };
@@ -224,21 +243,16 @@ export const getVersion = (schema: Obj.Any | Relation.Any): string => {
 /**
  * @returns True if the schema is mutable.
  */
-export const isMutable = EchoSchema.isMutable;
+export const isMutable = isMutable$;
 
 /**
  * ECHO type metadata.
  */
-export type Meta = EchoSchema.TypeAnnotation;
+export type Meta = TypeAnnotation;
 
 /**
  * Gets the meta data of the schema.
  */
-export const getMeta = (schema: Obj.Any | Relation.Any): Meta | undefined => {
-  return EchoSchema.getTypeAnnotation(schema);
+export const getMeta = (schema: Entity.Any): Meta | undefined => {
+  return getTypeAnnotation(schema);
 };
-
-// TODO(dmaretskyi): Remove re-exports.
-export { SpaceId, ObjectId, DXN } from '@dxos/keys';
-
-export { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from '@dxos/echo-schema';

package/src/index.ts

@@ -2,12 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
+export { QueryAST } from '@dxos/echo-protocol';
+// TODO(wittjosiah): Refactor DXN to not use statics similar to Query.
+export { DXN } from '@dxos/keys';
+
+export * as Annotation from './Annotation';
+export * as Database from './Database';
+export * as Entity from './Entity';
+export * as Err from './Err';
+export * as Filter from './Filter';
+export * as Format from './Format';
+export * as Hypergraph from './Hypergraph';
+export * as JsonSchema from './JsonSchema';
 export * as Key from './Key';
 export * as Obj from './Obj';
+export * as Order from './Order';
+export * as Query from './Query';
+export * as QueryResult from './QueryResult';
 export * as Ref from './Ref';
 export * as Relation from './Relation';
+export * as SchemaRegistry from './SchemaRegistry';
+export * as Tag from './Tag';
 export * as Type from './Type';
-
-export { DXN } from '@dxos/keys';
-export { Filter, Query } from './query';
-export { type Live } from '@dxos/live-object';

package/src/internal/README.md

@@ -0,0 +1,87 @@
+## Refactor
+
+1. Remove access from outisde of @dxos/echo-db
+
+- [x] completely restructure @dxos/echo src/internal
+- [x] Remove import "." and ".."! (create lint rule).
+- [x] Unify FOUR different nests of test schema.
+- [x] Remove @deprecated from internal methods and mark @internal (e.g., getSchemaDXN).
+  - NOTE: Internal methods should not use the import \* from Obj/Type APIs.
+- [x] import ObjectId => @dxos/keys
+- [x] Entity.Any = Obj.Any | Relation.Any
+  - NOTE: Relation does not extend (in not polymorphic with) Obj.
+- [x] import LabelAnnotation => Annotation.LabelAnnotation
+- [x] import Expando => Type.Expando
+- [x] live => Obj.make
+- [x] Rename live => makeObject
+- [x] Rename {EchoObject, EchoRelation} => {EchoObjecSchema, EchoRelationSchema}
+- [x] Rename AnyProperties => AnyProperties
+- [x] Created Entity.Any (=> AnyEchoObject).
+- [x] TypeFormat => TypeFormat
+- [x] JsonSchemaType defs
+- [x] Fix database.add() input/output types and search for "Obj.Any = db.add" (also QueryResult types).
+- [x] TODO(burdon): FIX!!!
+- [x] Fix failing tests.
+- [x] Reconcile types/version with entities/model/version
+- [x] Type.Expando => Obj.Any
+- [x] Narrow QueryResult and match Schema and Object generics.
+
+2. Clean-up
+
+- [x] QueryResult namespace
+- [x] SchemaRegistry interface
+- [x] Schema registry should return Type.Entity.Any instead of Schema.Schema.AnyNoContext.
+- [x] Hypergraph interface
+- [ ] Schema registry should use Query.Query.
+- [ ] TODO(wittjosiah): Find a simpler way to define this type.
+- [ ] TODO(wittjosiah): Should be Type.obj<...> or equivalent.
+- [ ] Fix Obj.instanceOf(Type.Expando...
+- [ ] Add Obj.Unknown and Relation.Unknown to match Entity.Unknown.
+- [ ] Ref.Array.targets doesn't satisfy Obj.Any because it uses AnyEchoObject.
+- [ ] Add Relation.MakeProps
+- [ ] Remove echo-db/AnyLiveObject<T> => Obj.Obj<T>
+- [ ] Narrow QueryResult and match Schema and Object generics.
+- [ ] Directly import JSONPath, etc. from @dxos/effect.
+- [ ] DISCUSS: Standradize $ suffix to disambuguate imports (GPT recommended).
+- [ ] Reconcile Type.Ref with Ref.Ref
+- [ ] Promote parts of src/internal/ref to Ref.ts
+- [ ] Rename AnyEchoObject => AnyEntity? (or accept that Object != Obj from naming perspective.)
+- [ ] Remove WithId => AnyEchoObject
+- [ ] Remove WithMeta => AnyEchoObject
+- [ ] BaseSchema
+- [ ] JsonPath, JsonProp, getValue, setValue => Json.Path?
+- [ ] Move EchoSchemaRegistry into hypergraph
+
+3. Audit usage from @dxos/echo-db
+
+- [ ] Ability to extract Struct from Type.Obj
+- [ ] created/updated system props (const { created } = Obj.getTimestamps)?
+- [ ] QueryFn, QueryOptions => Database
+- [ ] Datatbase.query() options?
+- [ ] Expando type is used as a fallback in many plance.
+- [ ] Standardize '@automerge/automerge' imports (A vs. next).
+
+## NOTES
+
+- Marking types as @internal (even for unexported types) erases type information.
+
+## 0.9.0
+
+- [ ] Database, Queue, Space, Type, namespaces.
+- [ ] Support class variant for types.
+- [ ] Support defaults.
+- [ ] Support effect Date, Timestamp formats.
+- [ ] Metadata for created, updated timestamps.
+- [ ] Effect team design review.
+- [ ] @category annotations to group types in the API.
+- [ ] TSdoc and LLM training for function generation.
+- [ ] Rename TypeFormat => Primitive?
+- [ ] Don't re-export effect?
+
+## Issues
+
+- [ ] Build error when changing from TypedObject using Ref$: Type 'Task' does not satisfy the constraint 'WithId' (see echo-schema/testing/schema.ts)
+- [ ] Reconcile all schema variants (Base, Immutable, TypedObject, EchoObject, etc.)
+- [ ] Consolidate getters (getType, getSchema, getTypename, getSchemaTypename, etc.)
+- [ ] ReactiveObject should specify id property? Reconcile AnyProperties, ReactiveObject, HasId, WithId, etc.
+- [ ] Can we us S.is(MyType) to detect objects with our types system? (Branding?)

package/src/internal/annotations/annotations.test.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { EchoObjectSchema } from '../entities';
+
+import { LabelAnnotation, TypenameSchema, VersionSchema, getLabel } from './annotations';
+
+// TODO(dmaretskyi): Use one of the testing schemas.
+const TestObject = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  fallbackName: Schema.optional(Schema.String),
+  other: Schema.String,
+}).pipe(LabelAnnotation.set(['name', 'fallbackName']));
+
+type TestObject = Schema.Schema.Type<typeof TestObject>;
+
+const TestEchoSchema = TestObject.pipe(
+  EchoObjectSchema({
+    typename: 'dxos.org/type/Test',
+    version: '0.1.0',
+  }),
+);
+
+type TestEchoSchema = Schema.Schema.Type<typeof TestEchoSchema>;
+
+describe('annotations', () => {
+  describe('Typename', () => {
+    test('should validate typename', ({ expect }) => {
+      // Valid.
+      expect(TypenameSchema.make('dxos.org/type/foo')).to.exist;
+      expect(TypenameSchema.make('dxos.org/type/foo-bar')).to.exist;
+      expect(TypenameSchema.make('dxos.org/type/foo_bar')).to.exist;
+
+      // Invalid.
+      expect(() => TypenameSchema.make('dxn:dxos.org')).to.throw();
+      expect(() => TypenameSchema.make('2dxos.org')).to.throw();
+      expect(() => TypenameSchema.make('dxos org')).to.throw();
+    });
+
+    test('should validate version', ({ expect }) => {
+      // Valid.
+      expect(VersionSchema.make('0.1.0')).to.exist;
+
+      // Invalid.
+      expect(() => VersionSchema.make('0.1.x')).to.throw();
+      expect(() => VersionSchema.make('0.1.0-alpha')).to.throw();
+    });
+  });
+
+  describe('getLabel', () => {
+    test('should return first available label value', ({ expect }) => {
+      const obj: TestObject = {
+        name: 'Primary Name',
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toEqual('Primary Name');
+    });
+
+    test('should fallback to second path if first is undefined', ({ expect }) => {
+      const obj: TestObject = {
+        name: undefined,
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toEqual('Fallback Name');
+    });
+
+    test('should return undefined if no label paths resolve', ({ expect }) => {
+      const obj: TestObject = {
+        name: undefined,
+        fallbackName: undefined,
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toBeUndefined();
+    });
+
+    test('should return label from echo object', ({ expect }) => {
+      const obj: TestEchoSchema = {
+        id: 'test',
+        name: 'Primary Name',
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestEchoSchema, obj)).toEqual('Primary Name');
+    });
+  });
+});