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

package/src/internal/Annotation/util.ts

@@ -0,0 +1,93 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { assertArgument } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+import { EntityKind } from '../common/types';
+
+export interface AnnotationHelper<T> {
+  /**
+   * Get the annotation value from an Effect schema.
+   *
+   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`
+   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the
+   * annotation pipeline single-shaped and forces annotations to live on the
+   * source schema, not on the post-construction Type entity.
+   */
+  get: (schema: Schema.Schema.Any) => Option.Option<T>;
+  /**
+   * Get the annotation value from the AST.
+   */
+  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;
+  /**
+   * Set the annotation on an Effect schema.
+   *
+   * Only accepts `Schema.Schema.Any` — annotations must be applied to the
+   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.
+   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.
+   */
+  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;
+}
+
+/**
+ * Note: only for system annotations.
+ */
+// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.
+export const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),
+    set:
+      (value) =>
+      <S extends Schema.Schema.Any>(schema: S): S =>
+        schema.annotations({ [id]: value }) as S,
+  };
+};
+
+/**
+ * If property is optional returns the nested property, otherwise returns the property.
+ */
+// TODO(wittjosiah): Is there a way to do this as a generic?
+export const unwrapOptional = (property: SchemaAST.PropertySignature) => {
+  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {
+    return property;
+  }
+
+  return property.type.types[0];
+};
+
+/**
+ * @see JSONSchemaAnnotationId
+ * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.
+ */
+// TODO(burdon): Required type.
+export const makeTypeJsonSchemaAnnotation = (options: {
+  identifier?: string;
+  kind: EntityKind;
+  typename: string;
+  version: string;
+  relationSource?: string;
+  relationTarget?: string;
+}) => {
+  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');
+  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');
+
+  const obj: Record<string, unknown> = {
+    $id: options.identifier ?? DXN.make(options.typename, options.version),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename,
+  };
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = { $ref: options.relationSource };
+    obj.relationTarget = { $ref: options.relationTarget };
+  }
+
+  return obj;
+};

package/src/internal/Entity/api.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+import { type EchoURI } from '@dxos/keys';
+import { assumeType } from '@dxos/util';
+
+import type { AnyEntity } from '../common/types';
+import { type InternalObjectProps, ObjectDatabaseId } from './model';
+import { getObjectEchoUri } from './util';
+
+/**
+ * Get the canonical EchoURI of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getUri = (entity: AnyEntity): EchoURI.EchoURI => {
+  const uri = getObjectEchoUri(entity);
+  invariant(uri != null, 'Invalid entity.');
+  return uri;
+};
+
+/**
+ * Get the database the entity belongs to.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getDatabase = (entity: AnyEntity): any | undefined => {
+  assumeType<InternalObjectProps>(entity);
+  return entity[ObjectDatabaseId];
+};

package/src/internal/Entity/entity.ts

@@ -0,0 +1,246 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import type * as Types from 'effect/Types';
+
+import { DXN, ObjectId } from '@dxos/keys';
+import { type ToMutable } from '@dxos/util';
+
+import { type TypeAnnotation, TypeAnnotationId, makeTypeJsonSchemaAnnotation } from '../Annotation';
+import { defineHiddenProperty } from '../common/proxy/define-hidden-property';
+import { makeObject } from '../common/proxy/make-object';
+import { getProxyTarget } from '../common/proxy/proxy-utils';
+import {
+  type AnyEntity,
+  EntityKind,
+  InstancePhantomId,
+  KindId,
+  type ObjectMeta,
+  SchemaKindId,
+  StaticTypeSchemaSlot,
+} from '../common/types';
+import { JsonSchemaType } from '../JsonSchema';
+
+// TODO(burdon): Define Schema type for `typename` and use consistently for all DXN-like properties.
+
+// type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+export type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<AnyEntity & ToMutable<T> & ExtraFields>;
+
+/**
+ * In-memory `Type.Type` entity shape produced by `Type.makeObject(dxn)` /
+ * `Type.makeRelation({...})`. A live reactive `TypeSchema` instance —
+ * identical to a persisted `Type.Type` except for database attachment.
+ *
+ * NOT a `Schema.Schema`. The underlying Effect Schema is cached on the hidden
+ * `StaticTypeSchemaSlot` slot — retrieve it via `Type.getSchema(...)`.
+ */
+// TODO(burdon): Rename EchoEntitySchema.
+export interface EchoTypeSchema<
+  Self extends Schema.Schema.Any,
+  ExtraFields = {},
+  K extends EntityKind = EntityKind,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> {
+  /**
+   * Entity-kind brand. Type entities are their own kind (`Type`) regardless of
+   * the kind of instance they describe — `[SchemaKindId]` carries the latter.
+   * This lets predicates like `Obj.isObject` / `Relation.isRelation` cleanly
+   * reject type entities without also having to inspect `[SchemaKindId]`.
+   */
+  readonly [KindId]: EntityKind.Type;
+
+  /** Schema-kind brand indicating what kind of instance this type describes. */
+  readonly [SchemaKindId]: K;
+
+  /**
+   * Entity id. Always present — stamped at construction — but NOT the type's
+   * identity while in-memory: an unattached type resolves its URI to the typename
+   * DXN, switching to `echo:/<id>` only once attached to a database (see
+   * `getTypeURIFromSpecifier`, which discriminates by database attachment).
+   */
+  readonly id: ObjectId;
+
+  /** Source Effect Schema (kept on a hidden slot for `Type.getSchema`). */
+  readonly [StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;
+
+  // NOTE: `typename` / `version` are intentionally NOT fields. They live in
+  // `ObjectMeta` (`key` / `version`); read via `Type.getTypename(self)` /
+  // `Type.getVersion(self)`.
+  readonly jsonSchema: JsonSchemaType;
+
+  /** Struct fields for introspection. */
+  readonly fields: Fields;
+
+  /** Phantom — instance type produced by `Obj.make(self, ...)`. */
+  readonly _instance?: EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>;
+
+  /**
+   * Phantom slot mirroring `Type<A>` so internal helpers (`makeObject`,
+   * `createObject`, `Ref.make`) infer the instance type uniformly whether
+   * the caller passes an `EchoTypeSchema` or a top-level `Type.Type` entity.
+   *
+   * Includes the instance-kind brand (`[KindId]`) so the phantom is assignable
+   * to the matching public-side interface in `Type.ts` (`Type.Obj` /
+   * `Type.Relation` / `Type.Type`). Each kind projects identity: instances of
+   * an object-kind schema are object-kind entities, type-kind schemas produce
+   * type-kind (persisted Type.Type) entities — the latter additionally carry
+   * the `[SchemaKindId]` / `[StaticTypeSchemaSlot]` brands the echo-handler
+   * proxy exposes on persisted Type entities.
+   */
+  readonly [InstancePhantomId]?: EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields> & {
+    readonly [KindId]: K;
+  } & (K extends EntityKind.Type
+      ? {
+          readonly [SchemaKindId]: EntityKind.Type;
+          readonly [StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;
+        }
+      : {});
+}
+
+// type MakeProps =
+//   | boolean
+//   | {
+//       readonly disableValidation?: boolean;
+//     };
+
+// NOTE: Utils copied from Effect `Schema.ts`.
+// const _ownKeys = (o: object): Array<PropertyKey> =>
+//   (Object.keys(o) as Array<PropertyKey>).concat(Object.getOwnPropertySymbols(o));
+
+// const _lazilyMergeDefaults = (
+//   fields: Schema.Struct.Fields,
+//   out: Record<PropertyKey, unknown>,
+// ): { [x: string | symbol]: unknown } => {
+//   const ownKeys = _ownKeys(fields);
+//   for (const key of ownKeys) {
+//     const field = fields[key];
+//     if (out[key] === undefined && Schema.isPropertySignature(field)) {
+//       const ast = field.ast;
+//       const defaultValue = ast._tag === 'PropertySignatureDeclaration' ? ast.defaultValue : ast.to.defaultValue;
+//       if (defaultValue !== undefined) {
+//         out[key] = defaultValue();
+//       }
+//     }
+//   }
+//   return out;
+// };
+
+// const _getDisableValidationMakeOption = (options: MakeProps | undefined): boolean =>
+//   Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
+
+/**
+ * Identity (typename + version) of the type meta-schema — the `Type.Type` that
+ * every ECHO type entity is itself an instance of. Shared by the materialisation
+ * vehicle ({@link persistentEntitySchema}) and `TypeSchema` so the two cannot
+ * drift on identity.
+ */
+export const TypeMetaSchemaDXN = DXN.make('org.dxos.type.schema', '0.1.0');
+
+/**
+ * Effect Schema that every `Type.Type` entity is an instance of: the meta-schema
+ * struct `{ name?, jsonSchema, id }` branded as a type-kind ECHO entity. This is
+ * the materialisation vehicle for `makeObject` below — the canonical user-facing
+ * entity is `Type/type-schema.ts`'s `TypeSchema`, which carries the same shape
+ * plus UI annotations.
+ *
+ * Kept self-contained (no import of `TypeSchema`) to avoid a bootstrap cycle:
+ * `TypeSchema` is itself produced via `makeEchoTypeSchema`, so this builder must
+ * not depend on it. `jsonSchema` is declared optional here (only on the
+ * materialisation vehicle — the canonical `TypeSchema` keeps it required) so the
+ * construction-time `Schema.asserts` does not force the field before it is
+ * attached; it is populated immediately after via a lazy accessor (see
+ * `makeEchoTypeSchema`).
+ */
+// TODO(wittjosiah): Reconcile with `TypeSchema` (`Type/type-schema.ts`).
+//   Both describe the same `org.dxos.type.schema` shape.
+const persistentEntitySchema: Schema.Schema.AnyNoContext = (() => {
+  const typename = DXN.getName(TypeMetaSchemaDXN);
+  const version = DXN.getVersion(TypeMetaSchemaDXN)!;
+  const struct = Schema.Struct({
+    name: Schema.optional(Schema.String),
+    jsonSchema: JsonSchemaType.pipe(Schema.optional),
+    id: ObjectId,
+  });
+  const ast = SchemaAST.annotations(struct.ast, {
+    [TypeAnnotationId]: { kind: EntityKind.Type, typename, version } satisfies TypeAnnotation,
+    [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({ kind: EntityKind.Type, typename, version }),
+  });
+  return Schema.make(ast);
+})();
+
+/**
+ * @internal
+ *
+ * Build an in-memory `Type.Type` entity (the value returned by `Type.makeObject`
+ * / `Type.makeRelation`). The result is a LIVE reactive `TypeSchema`
+ * instance — identical in every respect to a persisted `Type.Type` except that
+ * it is not yet attached to a database. It is mutable via `Type.update`, can be
+ * passed to `db.add(...)` (which keeps the same proxy and swaps the handler),
+ * and round-trips through `jsonSchema`.
+ *
+ * The source Effect Schema describing the user's type is cached on
+ * `[StaticTypeSchemaSlot]` so `Type.getSchema(...)` returns it without a
+ * jsonSchema round-trip; the cache is invalidated by the proxy set-trap when
+ * `jsonSchema` is mutated (see `typed-handler.ts`).
+ */
+export const makeEchoTypeSchema = <
+  Self extends Schema.Schema.Any,
+  K extends EntityKind = EntityKind,
+  // TODO(wittjosiah): Can this be inferred from the schema?
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+>(
+  fields: Fields,
+  ast: SchemaAST.AST,
+  typename: string,
+  version: string,
+  kind: K,
+  computeJsonSchema: () => JsonSchemaType,
+): EchoTypeSchema<Self, {}, K, Fields> => {
+  // Source Effect Schema describing the user's type — cached for `Type.getSchema`.
+  const sourceSchema = Schema.make<
+    EchoTypeSchemaProps<Schema.Schema.Type<Self>>,
+    EchoTypeSchemaProps<Schema.Schema.Encoded<Self>>,
+    Schema.Schema.Context<Self>
+  >(ast);
+
+  // `typename` / `version` route through `ObjectMeta` (`key` / `version`) — the
+  // canonical registry-provenance pair — not data fields. `keys` is empty for
+  // in-memory declarations until persisted.
+  const meta: ObjectMeta = { keys: [], key: typename, version };
+
+  // Materialise as a live reactive meta-schema instance. `jsonSchema` is attached
+  // below as a getter (not passed here as data) for two reasons; see that accessor.
+  const entity = makeObject(persistentEntitySchema, {} as any, meta);
+
+  const target = getProxyTarget(entity)!;
+  // `jsonSchema` is always available, but computed once on first read rather than at
+  // construction: serializing the AST walks `Schema.suspend(...)` thunks, and for a
+  // self-referential type (`Schema.suspend(() => Self)`) that thunk hits `Self`'s TDZ
+  // while we're still inside its `const` initializer. A getter also lets reads return
+  // the raw object instead of a child reactive proxy.
+  let memoizedJsonSchema: JsonSchemaType | undefined;
+  Object.defineProperty(target, 'jsonSchema', {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return (memoizedJsonSchema ??= computeJsonSchema());
+    },
+    set(value: JsonSchemaType) {
+      memoizedJsonSchema = value;
+    },
+  });
+  // Cache the source Effect Schema (read by `Type.getSchema` via the proxy's
+  // `[StaticTypeSchemaSlot]` get-trap; invalidated on `jsonSchema` mutation).
+  defineHiddenProperty(target, StaticTypeSchemaSlot, sourceSchema);
+  // Schema-kind brand: what kind of instance this type describes. There is no
+  // database handler to derive it for in-memory entities, so stamp it directly.
+  defineHiddenProperty(target, SchemaKindId, kind);
+  // Struct fields for introspection. A getter (not a data property) so reads return
+  // the raw fields object rather than a child reactive proxy.
+  Object.defineProperty(target, 'fields', { configurable: true, enumerable: false, get: () => fields });
+
+  return entity as unknown as EchoTypeSchema<Self, {}, K, Fields>;
+};

package/src/internal/Entity/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './api';
+export * from './entity';
+export * from './model'; // TODO(burdon): Rename.
+export * from './object';
+export * from './relation';
+export * from './type-kind';
+export * from './type-uri';
+export * from './util';
+export * from './version';

package/src/internal/Entity/model.ts

@@ -0,0 +1,120 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+
+import { type ForeignKey } from '@dxos/echo-protocol';
+import { invariant } from '@dxos/invariant';
+import { EchoURI, ObjectId, type URI } from '@dxos/keys';
+import { assumeType } from '@dxos/util';
+
+import type * as Database from '../../Database';
+import {
+  type ATTR_META,
+  type ATTR_PARENT,
+  type ATTR_TYPE,
+  ATTR_DELETED,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  EntityKind,
+  KindId,
+  type MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  type ObjectMeta,
+  ObjectVersionId,
+  type ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  type SchemaId,
+  SelfURIId,
+  TypeId,
+  type Version,
+} from '../common/types';
+
+export {
+  ATTR_DELETED,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  ObjectVersionId,
+  SelfURIId,
+};
+
+/**
+ * Internal runtime representation of an object.
+ * The fields are accessed through getter functions.
+ */
+// NOTE: Each symbol has a jsdoc describing its purpose.
+export interface InternalObjectProps {
+  readonly id: ObjectId;
+  readonly [SelfURIId]: EchoURI.EchoURI;
+  readonly [KindId]: EntityKind;
+  readonly [SchemaId]: Schema.Schema.AnyNoContext;
+  readonly [TypeId]: URI.URI;
+  readonly [MetaId]?: ObjectMeta;
+  [ParentId]?: InternalObjectProps;
+  readonly [ObjectDatabaseId]?: Database.Database;
+  readonly [ObjectDeletedId]?: boolean;
+  readonly [ObjectVersionId]?: Version;
+  readonly [RelationSourceDXNId]?: EchoURI.EchoURI;
+  readonly [RelationTargetDXNId]?: EchoURI.EchoURI;
+  readonly [RelationSourceId]?: InternalObjectProps;
+  readonly [RelationTargetId]?: InternalObjectProps;
+}
+
+/**
+ * Entity metadata.
+ */
+export interface ObjectMetaJSON {
+  keys: ForeignKey[];
+  tags?: string[];
+  key?: string;
+  version?: string;
+}
+
+/**
+ * JSON representation of an object or relation metadata.
+ */
+export interface ObjectJSON {
+  id: ObjectId;
+  [ATTR_TYPE]?: URI.URI;
+  [ATTR_SELF_URI]?: EchoURI.EchoURI;
+  [ATTR_PARENT]?: EchoURI.EchoURI; // Encoded reference
+  [ATTR_DELETED]?: boolean;
+  [ATTR_META]?: ObjectMetaJSON;
+  [ATTR_RELATION_SOURCE]?: EchoURI.EchoURI;
+  [ATTR_RELATION_TARGET]?: EchoURI.EchoURI;
+
+  /**
+   * Application-specific properties.
+   */
+  [key: string]: unknown;
+}
+
+/**
+ * NOTE: Keep as `function` to avoid type inference issues.
+ */
+export function assertObjectModel(obj: unknown): asserts obj is InternalObjectProps {
+  invariant(typeof obj === 'object' && obj !== null, 'Invalid object model: not an object');
+  assumeType<InternalObjectProps>(obj);
+  invariant(ObjectId.isValid(obj.id), 'Invalid object model: invalid id');
+  invariant(obj[TypeId] === undefined || typeof obj[TypeId] === 'string', 'Invalid object model: invalid type');
+  invariant(
+    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type,
+    'Invalid object model: invalid entity kind',
+  );
+
+  if (obj[KindId] === EntityKind.Relation) {
+    invariant(EchoURI.isEchoURI(obj[RelationSourceDXNId]), 'Invalid object model: invalid relation source');
+    invariant(EchoURI.isEchoURI(obj[RelationTargetDXNId]), 'Invalid object model: invalid relation target');
+    invariant(!EchoURI.isEchoURI(obj[RelationSourceId]), 'Invalid object model: source pointer is a DXN');
+    invariant(!EchoURI.isEchoURI(obj[RelationTargetId]), 'Invalid object model: target pointer is a DXN');
+  }
+}

package/src/internal/Entity/object.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+import { type TypeAnnotation, TypeAnnotationId, makeTypeJsonSchemaAnnotation } from '../Annotation';
+import { EntityKind } from '../common/types';
+import { toJsonSchema } from '../JsonSchema';
+import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * Object schema type with kind marker.
+ */
+export type EchoObjectSchema<
+  Self extends Schema.Schema.Any,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> = EchoTypeSchema<Self, {}, EntityKind.Object, Fields>;
+
+/**
+ * Schema for Obj entity types.
+ * Pipeable function to add ECHO object annotations to a schema.
+ */
+export const EchoObjectSchema: {
+  (
+    dxn: DXN.DXN,
+  ): <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ) => EchoObjectSchema<Self, Fields>;
+} = (dxn) => {
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type.makeObject requires a versioned DXN: ${dxn}`);
+
+  return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ): EchoObjectSchema<Self, Fields> => {
+    invariant(typeof TypeAnnotationId === 'symbol', 'Sanity.');
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    // Extract fields from the schema if available (Struct schemas have .fields).
+    const fields = ((self as any).fields ?? {}) as Fields;
+
+    const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: { kind: EntityKind.Object, typename, version } satisfies TypeAnnotation,
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self, EntityKind.Object, Fields>(fields, ast, typename, version, EntityKind.Object, () =>
+      toJsonSchema(Schema.make(ast)),
+    );
+  };
+};