@dxos/echo 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/src/internal/common/types/entity.ts

@@ -0,0 +1,133 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.
+//   Unique symbols cause TS4023 "cannot be named" errors when external packages
+//   try to export types that reference this key (e.g., `export const Graph = ...`).
+//   TypeScript cannot emit declaration files that reference unique symbols from
+//   external modules. Using a string literal allows the type to be inlined in
+//   declaration files, making the API portable across package boundaries.
+
+/**
+ * String key used to identify the kind of an entity instance (object or relation).
+ */
+export const KindId = '~@dxos/echo/Kind' as const;
+export type KindId = typeof KindId;
+
+/**
+ * String key used to identify the kind of a schema (object schema or relation schema).
+ * Parallels KindId which identifies instance kinds.
+ */
+export const SchemaKindId = '~@dxos/echo/SchemaKind' as const;
+export type SchemaKindId = typeof SchemaKindId;
+
+/**
+ * String key used to brand snapshot types.
+ * Snapshots have SnapshotKindId instead of KindId, making them
+ * distinguishable from reactive objects at the type level.
+ */
+export const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;
+export type SnapshotKindId = typeof SnapshotKindId;
+
+/**
+ * Hidden slot on a static `Type.Type` entity that holds the source Effect
+ * Schema. `Type.getSchema(...)` reads this for static types; persisted types
+ * rebuild from `jsonSchema` instead. Stored as a string key for declaration
+ * portability (see KindId comment above).
+ */
+export const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;
+export type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;
+
+/**
+ * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.
+ * Returns `undefined` for raw schemas (no slot) and non-object inputs.
+ * Single point-of-cast for the slot lookup.
+ */
+export const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];
+};
+
+/**
+ * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw
+ * schemas (which don't carry the brand on their static type) and non-object
+ * inputs. Single point-of-cast for the brand lookup.
+ */
+export const getSchemaKind = (value: unknown): EntityKind | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];
+};
+
+/**
+ * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas
+ * and non-object inputs. Companion to {@link getSchemaKind}.
+ */
+export const getEntityKindBrand = (value: unknown): EntityKind | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [KindId]?: EntityKind })[KindId];
+};
+
+/**
+ * Phantom string key on `Type<A>` entities that carries the instance type `A`.
+ * Lets internal helpers (`makeObject`, `createObject`, etc.) pattern-match the
+ * instance type from an entity input without importing from the top-level
+ * `Type` module. Mirrors `Type.InstancePhantomId` (declared in `Type.ts`).
+ *
+ * Stored as a string key so declarations remain portable across packages
+ * (see KindId comment above).
+ */
+export const InstancePhantomId = '~@dxos/echo/Type.Instance' as const;
+export type InstancePhantomId = typeof InstancePhantomId;
+
+/**
+ * Nominal brand carried by the well-known "any object" / "any relation"
+ * schemas (`Obj.Unknown`, `Relation.Unknown`). The brand lets `Ref.Ref`,
+ * `Filter.type`, and `Query.type` accept these schemas in addition to
+ * `Type.Type` entities, without opening the door to arbitrary raw schemas.
+ *
+ * Stored as a string key so declarations remain portable across packages
+ * (see KindId comment above).
+ */
+export const UnknownTypeSchemaBrandId = '~@dxos/echo/UnknownTypeSchemaBrand' as const;
+export type UnknownTypeSchemaBrandId = typeof UnknownTypeSchemaBrandId;
+
+/**
+ * Schema-side companion to `Type.Type` entities for the "any object" /
+ * "any relation" cases. Branded so `Ref.Ref` / `Filter.type` / `Query.type`
+ * can pattern-match on it; arbitrary `Schema.Schema` values do not satisfy
+ * this shape.
+ */
+export interface UnknownTypeSchema<A, K extends EntityKind> extends Schema.Schema<A, any, never> {
+  readonly [UnknownTypeSchemaBrandId]: K;
+}
+
+/**
+ * Kinds of entities stored in ECHO: objects, relations, and types.
+ */
+export enum EntityKind {
+  Object = 'object',
+  Relation = 'relation',
+  Type = 'type',
+}
+
+export const EntityKindSchema = Schema.Enums(EntityKind);
+
+/**
+ * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).
+ * Used when referencing any object without a specific schema.
+ */
+export const ANY_OBJECT_TYPENAME = 'org.dxos.schema.anyObject';
+
+/**
+ * Version for generic object references.
+ */
+export const ANY_OBJECT_VERSION = '0.0.0';

package/src/internal/{types → common/types}/index.ts

@@ -5,5 +5,6 @@
 export * from './base';
 export * from './entity';
 export * from './meta';
+export * from './model-symbols';
 export * from './typename';
 export * from './version';

package/src/internal/{types → common/types}/meta.ts

@@ -8,6 +8,7 @@ import { ForeignKey } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import { type Comparator, intersection } from '@dxos/util';
 
+import type * as Entity from '../../../Entity';
 import { type AnyProperties } from './base';
 
 /**
@@ -18,7 +19,7 @@ export const ATTR_META = '@meta';
 /**
  * Metadata section.
  */
-export const MetaId = Symbol.for('@dxos/echo/Meta');
+export const MetaId: Entity.Meta = Symbol.for('@dxos/echo/Meta') as any;
 
 //
 // ObjectMeta
@@ -35,7 +36,20 @@ export const ObjectMetaSchema = Schema.Struct({
    */
   // TODO(dmaretskyi): Has to be optional for compatibility with old data.
   // Defaulting to an empty array is possible but requires a bit more work.
+  // TODO(dmaretskyi): In automerge this should be a map of { [tag]: boolean } for uniqueness and conflict resolution.
   tags: Schema.optional(Schema.Array(Schema.String)),
+
+  /**
+   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+   * Identifies the canonical registry entry the object instance was created from.
+   */
+  key: Schema.optional(Schema.String),
+
+  /**
+   * Semantic version of the registry entry the object was created from.
+   * Must be a valid semver string (e.g. `1.2.3`).
+   */
+  version: Schema.optional(Schema.String),
 });
 
 export type ObjectMeta = Schema.Schema.Type<typeof ObjectMetaSchema>;

package/src/internal/common/types/model-symbols.ts

@@ -0,0 +1,74 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/**
+ * Internal symbol/string constants for the echo object model.
+ * Defined in common/ so proxy/ can use them without importing from Entity/.
+ * Entity/ re-exports these for external consumers.
+ */
+
+/**
+ * Property name for the object's own URI when serialized to JSON.
+ */
+export const ATTR_SELF_URI = '@uri';
+
+/**
+ * @deprecated Legacy JSON property name accepted on read for backward compat.
+ */
+export const ATTR_SELF_URI_LEGACY = '@dxn';
+
+/**
+ * Symbol carrying the object's own URI on live entities.
+ */
+export const SelfURIId = Symbol.for('@dxos/echo/URI');
+
+/**
+ * Property name for deleted when object is serialized to JSON.
+ */
+export const ATTR_DELETED = '@deleted';
+
+/**
+ * Deletion marker.
+ */
+export const ObjectDeletedId = Symbol.for('@dxos/echo/Deleted');
+
+/**
+ * Object version accessor symbol.
+ */
+export const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/Version');
+
+/**
+ * Object database accessor symbol.
+ */
+export const ObjectDatabaseId = Symbol.for('@dxos/echo/Database');
+
+/**
+ * Property name for relation source when object is serialized to JSON.
+ */
+export const ATTR_RELATION_SOURCE = '@relationSource';
+
+/**
+ * Used to access relation source ref on live ECHO objects.
+ */
+export const RelationSourceId: unique symbol = Symbol.for('@dxos/echo/RelationSource');
+
+/**
+ * Used to access relation source DXN on live ECHO objects.
+ */
+export const RelationSourceDXNId: unique symbol = Symbol.for('@dxos/echo/RelationSourceDXN');
+
+/**
+ * Property name for relation target when object is serialized to JSON.
+ */
+export const ATTR_RELATION_TARGET = '@relationTarget';
+
+/**
+ * Used to access relation target ref on live ECHO objects.
+ */
+export const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTarget');
+
+/**
+ * Used to access relation target DXN on live ECHO objects.
+ */
+export const RelationTargetDXNId: unique symbol = Symbol.for('@dxos/echo/RelationTargetDXN');

package/src/internal/common/types/typename.ts

@@ -0,0 +1,91 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+
+/**
+ * Property name for typename when object is serialized to JSON.
+ */
+export const ATTR_TYPE = '@type';
+
+/**
+ * DXN to the object type.
+ */
+export const TypeId = Symbol.for('@dxos/echo/Type');
+
+/**
+ * Reference to the object schema.
+ */
+export const SchemaId = Symbol.for('@dxos/echo/Schema');
+
+/**
+ * Property name for parent when object is serialized to JSON.
+ */
+export const ATTR_PARENT = '@parent';
+
+/**
+ * Reference to the object parent.
+ */
+export const ParentId = Symbol.for('@dxos/echo/Parent');
+
+/**
+ * Reference to the object's type entity (`Type.Obj`, `Type.Relation`, or
+ * `Type.Type`). Set at instance creation by `createObject` / `makeObject`
+ * when the entity is known. Public read-back via `Obj.getType` / `Relation.getType`
+ * / `Entity.getType`.
+ */
+export const TypeEntityId = Symbol.for('@dxos/echo/TypeEntity');
+
+/**
+ * Returns the Effect Schema for the given object if one is defined.
+ *
+ * @internal
+ * Internal callers needing schema-side validation read from `SchemaId`.
+ * Public callers should use `Type.getSchema(Obj.getType(obj))` instead.
+ */
+// TODO(dmaretskyi): For echo objects, this always returns the root schema.
+export const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {
+  if (obj) {
+    return (obj as any)[SchemaId];
+  }
+};
+
+/**
+ * @internal
+ */
+export const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false,
+  });
+};
+
+/**
+ * Returns the type entity (`Type.AnyEntity`) for the given instance.
+ * Set at instance creation; every entity has a type. Defensive: returns
+ * undefined for null/undefined input so callers can safely probe arbitrary
+ * values via this helper.
+ *
+ * @internal Re-exported via `Obj.getType` / `Relation.getType` / `Entity.getType`.
+ */
+export const getType = (obj: unknown): unknown => {
+  if (obj == null) {
+    return undefined;
+  }
+  return (obj as any)[TypeEntityId];
+};
+
+/**
+ * @internal
+ */
+export const setType = (obj: any, type: unknown): void => {
+  Object.defineProperty(obj, TypeEntityId, {
+    value: type,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+};

package/src/internal/{types → common/types}/version.ts

@@ -3,10 +3,9 @@
 //
 
 /**
- * Version type symbol.
+ * Version type identifier.
  */
-export const VersionTypeId: unique symbol = Symbol.for('@dxos/echo/VersionTypeId');
-
+export const VersionTypeId = '~@dxos/echo/VersionTypeId' as const;
 export type VersionTypeId = typeof VersionTypeId;
 
 /**

package/src/internal/index.ts

@@ -5,35 +5,13 @@
 // TODO(burdon): Import directly (not part of ECHO API).
 export { JsonPath, JsonProp, getValue, splitJsonPath } from '@dxos/effect';
 
-export * from './annotations';
-export * from './api';
-export * from './entities';
-export * from './formats';
-export * from './json-schema';
-export * from './ref';
-export * from './types';
-
+export * from './Annotation';
+export * from './common';
+export * from './Entity';
+export * from './Format';
+export * from './JsonSchema';
 // TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).
-export * from './object';
-export * from './proxy';
-export * from './schema';
-
-// export {
-//   createObject,
-//   createQueueDXN,
-//   isDeleted,
-//   objectFromJSON,
-//   objectToJSON,
-//   setRefResolverOnData,
-//   SchemaValidator,
-//   TypedObject,
-// } from './object';
-// export { makeObject } from './proxy';
-// export {
-//   type BaseSchema,
-//   EchoSchema,
-//   ImmutableSchema,
-//   RuntimeSchemaRegistry,
-//   PersistentSchema,
-//   isMutable,
-// } from './schema';
+export * from './Obj';
+export * from './Query';
+export * from './Ref';
+export * from './Type';

package/src/testing/api.test.ts

@@ -8,22 +8,25 @@ import { describe, test } from 'vitest';
 import { raise } from '@dxos/debug';
 
 import { Entity, Obj, Ref, Relation, Type } from '../index';
-
 import { TestSchema } from './test-schema';
 
 describe('Experimental API review', () => {
   test('type checks', ({ expect }) => {
     const contact = Obj.make(TestSchema.Person, { name: 'Test' });
-    const schema = Obj.getSchema(contact) ?? raise(new Error('No schema found'));
-
-    expect(Type.getDXN(schema)?.typename).to.eq(TestSchema.Person.typename);
-    expect(Type.getTypename(schema)).to.eq('example.com/type/Person');
-    expect(Type.getVersion(schema)).to.eq('0.1.0');
-    expect(Type.getMeta(schema)).to.deep.eq({
-      kind: Entity.Kind.Object,
-      typename: 'example.com/type/Person',
+    const type = Obj.getType(contact) ?? raise(new Error('No type found'));
+
+    expect(Type.getTypename(type)).to.eq(Type.getTypename(TestSchema.Person));
+    expect(Type.getTypename(type)).to.eq('com.example.type.person');
+    expect(Type.getVersion(type)).to.eq('0.1.0');
+    // `Type.getMeta` returns `ObjectMeta` (`{ keys, tags?, key?, version? }`) —
+    // the same shape `Obj.getMeta` and `Relation.getMeta` return. The
+    // schema-kind brand lives on `[SchemaKindId]`, not in meta.
+    expect(Type.getMeta(type)).to.deep.eq({
+      keys: [],
+      key: 'com.example.type.person',
       version: '0.1.0',
     });
+    expect(Type.isObject(type)).to.be.true;
   });
 
   test('instance checks', ({ expect }) => {
@@ -33,7 +36,7 @@ describe('Experimental API review', () => {
       employer: Ref.make(organization),
     });
 
-    expect(Schema.is(TestSchema.Person)(contact)).to.be.true;
+    expect(Schema.is(Type.getSchema(TestSchema.Person))(contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Person, contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Organization, organization)).to.be.true;
 
@@ -110,7 +113,7 @@ describe('Experimental API review', () => {
         expect(expando.content).to.eq('Test');
 
         // This should work: assign to Obj.Obj of the schema's instance type
-        const _typed: Obj.Obj<TestSchema.Expando> = expando;
+        const _typed: Obj.OfShape<TestSchema.Expando> = expando;
       }
 
       {
@@ -119,7 +122,7 @@ describe('Experimental API review', () => {
         expect(person.name).to.eq('Test');
 
         // This should work: assign to Obj.Obj of the schema's instance type
-        const _typed: Obj.Obj<TestSchema.Person> = person;
+        const _typed: Obj.OfShape<TestSchema.Person> = person;
       }
     });
   });