@dxos/echo 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

package/src/internal/object/entity.ts

@@ -1,204 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import type * as Types from 'effect/Types';
-
-import { raise } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
-
-import {
-  EntityKind,
-  type TypeAnnotation,
-  TypeAnnotationId,
-  type TypeMeta,
-  getEntityKind,
-  getSchemaTypename,
-  getTypeIdentifierAnnotation,
-} from '../ast';
-import { type HasId, type ToMutable } from '../types';
-
-import { type RelationSourceTargetRefs } from './relation';
-
-// 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];
-type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<HasId & ToMutable<T> & ExtraFields>;
-
-export interface EchoTypeSchema<Self extends Schema.Schema.Any, ExtraFields = {}>
-  extends TypeMeta,
-    Schema.AnnotableClass<
-      EchoTypeSchema<Self, ExtraFields>,
-      EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>,
-      EchoTypeSchemaProps<Schema.Schema.Encoded<Self>, ExtraFields>,
-      Schema.Schema.Context<Self>
-    > {
-  // make(
-  //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
-  //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
-  //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-  //   options?: MakeOptions,
-  // ): Simplify<Schema.TypeLiteral.Type<Fields, []>>;
-
-  instanceOf(value: unknown): boolean;
-}
-
-/**
- * Pipeable function to add ECHO object annotations to a schema.
- */
-// TODO(dmaretskyi): Rename EchoObjectSchema.
-export const EchoObject: {
-  // TODO(burdon): Tighten Self type to Schema.TypeLiteral or Schema.Struct to facilitate definition of `make` method.
-  // (meta: TypeMeta): <Self extends Schema.Struct<Fields>, Fields extends Schema.Struct.Fields>(self: Self) => EchoObjectSchema<Self, Fields>;
-  (meta: TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => EchoTypeSchema<Self>;
-} = ({ typename, version }) => {
-  return <Self extends Schema.Schema.Any>(self: Self): EchoTypeSchema<Self> => {
-    invariant(typeof TypeAnnotationId === 'symbol', 'Sanity.');
-    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
-
-    // TODO(dmaretskyi): Does `Schema.mutable` work for deep mutability here?
-    // TODO(dmaretskyi): Do not do mutable here.
-    const schemaWithId = Schema.extend(Schema.mutable(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?
-    });
-
-    return makeEchoObjectSchema<Self>(/* self.fields, */ ast, typename, version);
-  };
-};
-
-export type EchoRelationOptions<
-  TSource extends Schema.Schema.AnyNoContext,
-  TTarget extends Schema.Schema.AnyNoContext,
-> = TypeMeta & {
-  source: TSource;
-  target: TTarget;
-};
-
-// TODO(dmaretskyi): Rename EchoRelationSchema.
-export const EchoRelation = <Source extends Schema.Schema.AnyNoContext, Target extends Schema.Schema.AnyNoContext>(
-  options: EchoRelationOptions<Source, Target>,
-) => {
-  const sourceDXN = getDXNForRelationSchemaRef(options.source);
-  const targetDXN = getDXNForRelationSchemaRef(options.target);
-  if (getEntityKind(options.source) !== EntityKind.Object) {
-    raise(new Error('Source schema must be an echo object schema.'));
-  }
-  if (getEntityKind(options.target) !== EntityKind.Object) {
-    raise(new Error('Target schema must be an echo object schema.'));
-  }
-
-  return <Self extends Schema.Schema.Any>(
-    self: Self,
-  ): EchoTypeSchema<Self, RelationSourceTargetRefs<Schema.Schema.Type<Source>, Schema.Schema.Type<Target>>> => {
-    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
-
-    // TODO(dmaretskyi): Does `Schema.mutable` work for deep mutability here?
-    // TODO(dmaretskyi): Do not do mutable here.
-    const schemaWithId = Schema.extend(Schema.mutable(self), Schema.Struct({ id: Schema.String }));
-    const ast = SchemaAST.annotations(schemaWithId.ast, {
-      // TODO(dmaretskyi): `extend` kills the annotations.
-      ...self.ast.annotations,
-      [TypeAnnotationId]: {
-        kind: EntityKind.Relation,
-        typename: options.typename,
-        version: options.version,
-        sourceSchema: sourceDXN,
-        targetSchema: targetDXN,
-      } satisfies TypeAnnotation,
-      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
-    });
-
-    return makeEchoObjectSchema<Self>(/* self.fields, */ ast, options.typename, options.version);
-  };
-};
-
-const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): string => {
-  const identifier = getTypeIdentifierAnnotation(schema);
-  if (identifier) {
-    return identifier;
-  }
-
-  const typename = getSchemaTypename(schema);
-  if (!typename) {
-    throw new Error('Schema must have a typename');
-  }
-
-  return DXN.fromTypename(typename).toString();
-};
-
-// type MakeOptions =
-//   | 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: MakeOptions | undefined): boolean =>
-//   Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
-
-const makeEchoObjectSchema = <Self extends Schema.Schema.Any>(
-  // fields: Fields,
-  ast: SchemaAST.AST,
-  typename: string,
-  version: string,
-): EchoTypeSchema<Self> => {
-  return class EchoObjectSchemaClass extends Schema.make<
-    EchoTypeSchemaProps<Schema.Schema.Type<Self>>,
-    EchoTypeSchemaProps<Schema.Schema.Encoded<Self>>,
-    Schema.Schema.Context<Self>
-  >(ast) {
-    static readonly typename = typename;
-    static readonly version = version;
-
-    static override annotations(
-      annotations: Schema.Annotations.GenericSchema<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>,
-    ): EchoTypeSchema<Self> {
-      const schema = Schema.make<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>(ast).annotations(annotations);
-      return makeEchoObjectSchema<Self>(/* fields, */ schema.ast, typename, version);
-    }
-
-    // static make(
-    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
-    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
-    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-    //   options?: MakeOptions,
-    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
-    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
-    //   return _getDisableValidationMakeOption(options)
-    //     ? propsWithDefaults
-    //     : ParseResult.validateSync(this)(propsWithDefaults);
-    // }
-
-    static instanceOf(value: unknown): boolean {
-      return Schema.is(this)(value);
-    }
-  };
-};

package/src/internal/object/model.ts

@@ -1,170 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type * as Schema from 'effect/Schema';
-
-import { type ForeignKey } from '@dxos/echo-protocol';
-import { invariant } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
-import { assumeType } from '@dxos/util';
-
-import { EntityKind } from '../ast';
-
-import { type ObjectMeta } from './meta';
-import type { Version } from './version';
-
-//
-// Defines the internal model of the echo object.
-//
-
-/**
- * Entity kind.
- */
-export const EntityKindId = Symbol('@dxos/echo/EntityKind');
-
-/**
- * DXN to the object itself.
- */
-export const SelfDXNId = Symbol('@dxos/echo/DXN');
-
-/**
- * Property name for self DXN when object is serialized to JSON.
- */
-export const ATTR_SELF_DXN = '@dxn';
-
-/**
- * DXN to the object type.
- */
-export const TypeId = Symbol('@dxos/echo/Type');
-
-/**
- * Property name for typename when object is serialized to JSON.
- */
-export const ATTR_TYPE = '@type';
-
-/**
- * Reference to the object schema.
- */
-export const SchemaId = Symbol('@dxos/echo/Schema');
-
-/**
- * Deletion marker.
- */
-export const DeletedId = Symbol('@dxos/echo/Deleted');
-
-/**
- * Property name for deleted when object is serialized to JSON.
- */
-export const ATTR_DELETED = '@deleted';
-
-/**
- * Metadata section.
- */
-export const MetaId = Symbol('@dxos/echo/Meta');
-
-/**
- * Property name for meta when object is serialized to JSON.
- */
-export const ATTR_META = '@meta';
-
-/**
- * Used to access relation source ref on live ECHO objects.
- * Reading this symbol must return `Live<EchoObject<any>>` or a DXN.
- */
-export const RelationSourceDXNId: unique symbol = Symbol('@dxos/echo/RelationSourceDXN');
-
-/**
- * Property name for relation source when object is serialized to JSON.
- */
-export const ATTR_RELATION_SOURCE = '@relationSource';
-
-/**
- * Used to access relation target ref on live ECHO objects.
- * Reading this symbol must return `Live<EchoObject<any>>` or a DXN.
- */
-export const RelationTargetDXNId: unique symbol = Symbol('@dxos/echo/RelationTargetDXN');
-
-/**
- * Property name for relation target when object is serialized to JSON.
- */
-export const ATTR_RELATION_TARGET = '@relationTarget';
-
-/**
- * Used to access relation source ref on live ECHO objects.
- * Reading this symbol must return `Live<EchoObject<any>>` or a DXN.
- */
-export const RelationSourceId: unique symbol = Symbol('@dxos/echo/RelationSource');
-
-/**
- * Used to access relation target ref on live ECHO objects.
- * Reading this symbol must return `Live<EchoObject<any>>` or a DXN.
- */
-export const RelationTargetId: unique symbol = Symbol('@dxos/echo/RelationTarget');
-
-/**
- * Getter to get object version.
- */
-export const ObjectVersionId: unique symbol = Symbol('@dxos/echo/ObjectVersion');
-
-/**
- * Internal runtime representation of an object.
- * The fields are accessed through getter functions.
- */
-export interface InternalObjectProps {
-  id: ObjectId;
-  readonly [SelfDXNId]?: DXN;
-
-  // Echo supports untyped objects O_O.
-  readonly [TypeId]?: DXN;
-
-  /**
-   * Returns the schema for the object.
-   */
-  readonly [SchemaId]?: Schema.Schema.AnyNoContext;
-  readonly [EntityKindId]: EntityKind;
-  readonly [DeletedId]?: boolean;
-  readonly [MetaId]?: ObjectMeta;
-  readonly [RelationSourceDXNId]?: DXN;
-  readonly [RelationTargetDXNId]?: DXN;
-  readonly [RelationSourceId]?: InternalObjectProps;
-  readonly [RelationTargetId]?: InternalObjectProps;
-  readonly [ObjectVersionId]?: Version;
-}
-
-/**
- * JSON representation of an object or relation.
- */
-export interface ObjectJSON {
-  id: string;
-  [ATTR_SELF_DXN]?: DXN.String;
-  [ATTR_TYPE]: DXN.String;
-  [ATTR_DELETED]?: boolean;
-  [ATTR_META]?: ObjectMetaJSON;
-  [ATTR_RELATION_SOURCE]?: DXN.String;
-  [ATTR_RELATION_TARGET]?: DXN.String;
-}
-
-export interface ObjectMetaJSON {
-  keys: ForeignKey[];
-  tags?: string[];
-}
-
-// NOTE: Keep as `function` to avoid type inference issues.
-// eslint-disable-next-line prefer-arrow-functions/prefer-arrow-functions
-export function assertObjectModelShape(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 || obj[TypeId] instanceof DXN, 'Invalid object model: invalid type');
-  invariant(
-    obj[EntityKindId] === EntityKind.Object || obj[EntityKindId] === EntityKind.Relation,
-    'Invalid object model: invalid entity kind',
-  );
-  if (obj[EntityKindId] === EntityKind.Relation) {
-    invariant(obj[RelationSourceDXNId] instanceof DXN, 'Invalid object model: invalid relation source');
-    invariant(obj[RelationTargetDXNId] instanceof DXN, 'Invalid object model: invalid relation target');
-    invariant(!(obj[RelationSourceId] instanceof DXN), 'Invalid object model: source pointer is a DXN');
-    invariant(!(obj[RelationTargetId] instanceof DXN), 'Invalid object model: target pointer is a DXN');
-  }
-}

package/src/internal/object/relation.ts

@@ -1,24 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import type { RelationSourceId, RelationTargetId } from './model';
-
-/**
- * Source and target props on relations.
- */
-// TODO(burdon): any?
-export type RelationSourceTargetRefs<Source = any, Target = any> = {
-  /**
-   * Source ECHO live object.
-   */
-  [RelationSourceId]: Source;
-
-  /**
-   * Target ECHO live object.
-   */
-  [RelationTargetId]: Target;
-};
-
-export type RelationSource<R> = R extends RelationSourceTargetRefs<infer Source, infer _Target> ? Source : never;
-export type RelationTarget<R> = R extends RelationSourceTargetRefs<infer _Source, infer Target> ? Target : never;

package/src/internal/object/typed-relation.ts

@@ -1,85 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { invariant } from '@dxos/invariant';
-
-import { EntityKind, SchemaVersion, type TypeAnnotation, TypeAnnotationId, type TypeMeta, Typename } from '../ast';
-import { type HasId } from '../types';
-
-import { type TypedObjectFields, type TypedObjectOptions, makeTypedEntityClass } from './common';
-import { type RelationSourceTargetRefs } from './relation';
-
-/**
- * Definition for an object type that can be stored in an ECHO database.
- * Implements effect schema to define object properties.
- * Has a typename and version.
- *
- * In contrast to {@link EchoSchema} this definition is not recorded in the database.
- */
-export interface TypedRelation<A = any, I = any> extends TypeMeta, Schema.Schema<A, I> {}
-
-/**
- * Typed object that could be used as a prototype in class definitions.
- * This is an internal API type.
- * Use {@link TypedRelation} for the common use-cases.
- */
-export interface TypedRelationPrototype<A = any, I = any> extends TypedRelation<A, I> {
-  /** Type constructor. */
-  new (): HasId & A;
-}
-
-export type TypedRelationProps = TypeMeta & {
-  // TODO(dmaretskyi): Remove after all legacy types has been removed.
-  disableValidation?: boolean;
-};
-
-/**
- * Base class factory for typed objects.
- * @deprecated Use {@link EchoRelation} instead.
- */
-export const TypedRelation = ({
-  typename: typenameParam,
-  version: versionParam,
-  disableValidation,
-}: TypedRelationProps) => {
-  const typename = Typename.make(typenameParam, { disableValidation });
-  const version = SchemaVersion.make(versionParam, { disableValidation });
-
-  /**
-   * Return class definition factory.
-   */
-  return <SchemaFields extends Schema.Struct.Fields, Options extends TypedObjectOptions>(
-    fields: SchemaFields,
-    options?: Options,
-  ): TypedRelationPrototype<
-    TypedObjectFields<SchemaFields, Options> & RelationSourceTargetRefs,
-    Schema.Struct.Encoded<SchemaFields>
-  > => {
-    // Create schema from fields.
-    const schema: Schema.Schema.All = options?.record
-      ? Schema.Struct(fields, { key: Schema.String, value: Schema.Any })
-      : Schema.Struct(fields);
-
-    // Set ECHO object id property.
-    const typeSchema = Schema.extend(
-      Schema.mutable(options?.partial ? Schema.partial(schema) : schema),
-      Schema.Struct({ id: Schema.String }),
-    );
-
-    // Set ECHO annotations.
-    invariant(typeof EntityKind.Relation === 'string');
-    const annotatedSchema = typeSchema.annotations({
-      [TypeAnnotationId]: { kind: EntityKind.Relation, typename, version } satisfies TypeAnnotation,
-    });
-
-    /**
-     * Return class definition.
-     * NOTE: Actual reactive ECHO objects must be created via the `live(Type)` function.
-     */
-    // TODO(burdon): This is missing fields required by TypedRelation (e.g., Type, Encoded, Context)?
-    return class TypedRelation extends makeTypedEntityClass(typename, version, annotatedSchema as any) {} as any;
-  };
-};

package/src/internal/object/typename.ts

@@ -1,61 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
-
-import { getSchemaTypename } from '../ast';
-import { type BaseObject } from '../types';
-
-import { getSchema } from './accessors';
-import { TypeId } from './model';
-
-/**
- * Gets the typename of the object without the version.
- * Returns only the name portion, not the DXN.
- * @example "example.org/type/Contact"
- */
-export const getTypename = (obj: BaseObject): string | undefined => {
-  const schema = getSchema(obj);
-  if (schema != null) {
-    // Try to extract typename from DXN.
-    return getSchemaTypename(schema);
-  } else {
-    const type = getType(obj);
-    return type?.asTypeDXN()?.type;
-  }
-};
-
-/**
- * @internal
- */
-// TODO(dmaretskyi): Rename setTypeDXN.
-export const setTypename = (obj: any, typename: DXN) => {
-  invariant(typename instanceof DXN, 'Invalid type.');
-  Object.defineProperty(obj, TypeId, {
-    value: typename,
-    writable: false,
-    enumerable: false,
-    configurable: false,
-  });
-};
-
-/**
- * @returns Object type as {@link DXN}.
- * @returns undefined if the object doesn't have a type.
- * @example `dxn:example.com/type/Contact:1.0.0`
- */
-export const getType = (obj: BaseObject): DXN | undefined => {
-  if (!obj) {
-    return undefined;
-  }
-
-  const type = (obj as any)[TypeId];
-  if (!type) {
-    return undefined;
-  }
-
-  invariant(type instanceof DXN, 'Invalid object.');
-  return type;
-};

package/src/internal/object/version.ts

@@ -1,22 +0,0 @@
-//
-// NOTE: Those types must match the ones defined at @dxos/echo. We duplicated them murely due to technical constrains.
-//
-
-/**
- * Getter to get object version.
- */
-//
-// Copyright 2025 DXOS.org
-//
-
-export const VersionTypeId: unique symbol = Symbol('@dxos/echo/Version');
-
-/**
- * Represent object version.
- * May be backed by Automerge.
- * Objects with no history are not versioned.
- */
-export interface Version {
-  [VersionTypeId]: {};
-  automergeHeads?: string[];
-}

package/src/internal/projection/index.ts

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

package/src/internal/query/index.ts

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

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

package/src/internal/testing/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './types';
-export * from './utils';