@dxos/echo 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/internal/Annotation/annotations.ts

@@ -0,0 +1,609 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { SchemaEx } from '@dxos/effect';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { DXN, URI } from '@dxos/keys';
+import { type Primitive } from '@dxos/util';
+
+import type * as Annotation from '../../Annotation';
+import { type Mutable } from '../common/proxy';
+import { type AnyProperties, EntityKind, TypeId, getSchema } from '../common/types';
+import { createAnnotationHelper } from './util';
+
+const ANNOTATION_TYPE_ID: Annotation.TypeId = '~@dxos/echo/Annotation' as const;
+
+/**
+ * @internal
+ */
+export const FIELD_PATH_ANNOTATION = 'path';
+
+/**
+ * Sets the path for the field.
+ * @param path Data source path in the json path format. This is the field path in the source object.
+ */
+// TODO(burdon): Field, vs. path vs. property.
+export const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+
+//
+// Type
+//
+
+/**
+ * ECHO identifier (for a stored schema).
+ * Must be an `echo:` URI.
+ */
+export const TypeIdentifierAnnotationId = Symbol.for('@dxos/schema/annotation/TypeIdentifier');
+
+export const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>
+  Function.flow(
+    SchemaAST.getAnnotation<string>(TypeIdentifierAnnotationId),
+    Option.getOrElse(() => undefined),
+  )(schema.ast);
+
+/**
+ * @returns The schema's type identifier URI — whichever URI fits.
+ *
+ * - Stored (dynamic) schemas: the schema-as-object's EID, so loaded objects ride
+ *   along with their schema as a strong dependency.
+ * - Non-stored (static) schemas: the typename DXN built from `TypeAnnotation`.
+ *
+ * This URI is what gets written to an object's `system.type`; queries that filter by
+ * type also use it (see `Filter.type` / `getTypeURIFromSpecifier`), so both sides
+ * stay symmetric without per-schema branching.
+ */
+export const getSchemaURI = (schema: Schema.Schema.All): URI.URI | undefined => {
+  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return URI.make(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (objectAnnotation) {
+    return DXN.make(objectAnnotation.typename, objectAnnotation.version);
+  }
+  return undefined;
+};
+
+//
+// TypeAnnotation
+//
+
+/**
+ * Fully qualified globally unique typename.
+ * Example: `org.dxos.type.message`
+ */
+// TODO(wittjosiah): Factor out to DXN spec.
+export const TypenameSchema = Schema.String.pipe(
+  Schema.pattern(
+    /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/,
+  ),
+).annotations({
+  description: 'Fully qualified globally unique typename in reverse-DNS form.',
+  example: 'org.dxos.type.message',
+});
+
+/**
+ * Semantic version format: `major.minor.patch`
+ * Example: `1.0.0`
+ */
+export const VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
+  description: 'Semantic version format: `major.minor.patch`',
+  example: '1.0.0',
+});
+
+export const TypeMeta = Schema.Struct({
+  typename: TypenameSchema,
+  version: VersionSchema,
+});
+
+export interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}
+
+/**
+ * Entity type.
+ */
+export const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');
+
+/**
+ * Payload stored under {@link TypeAnnotationId}.
+ */
+export const TypeAnnotation = Schema.extend(
+  TypeMeta,
+  Schema.Struct({
+    kind: Schema.Enums(EntityKind),
+
+    /**
+     * If this is a relation, the schema of the source object.
+     * Must be present if entity kind is {@link EntityKind.Relation}.
+     */
+    sourceSchema: Schema.optional(DXN.Schema),
+
+    /**
+     * If this is a relation, the schema of the target object.
+     * Must be present if entity kind is {@link EntityKind.Relation}.
+     */
+    targetSchema: Schema.optional(DXN.Schema),
+  }),
+);
+
+export interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}
+
+/**
+ * @returns {@link TypeAnnotation} from a schema.
+ * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.
+ */
+export const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {
+  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');
+  return Function.flow(
+    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),
+    Option.getOrElse(() => undefined),
+  )(schema.ast);
+};
+
+/**
+ * @returns {@link EntityKind} from a schema.
+ */
+export const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;
+
+/**
+ * @internal
+ * @returns Schema typename (without dxn: prefix or version number).
+ */
+export const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;
+
+/**
+ * @internal
+ * @returns Schema version in semver format.
+ */
+export const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;
+
+/**
+ * Gets the typename of the object without the version.
+ * Returns only the name portion, not the DXN.
+ * @example "org.example.type.contact"
+ *
+ * @internal (use Obj.getTypename)
+ */
+export const getTypename = (obj: AnyProperties): string | undefined => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    // Try to extract typename from DXN.
+    return getSchemaTypename(schema);
+  } else {
+    // `obj` may be an arbitrary value (e.g. from `isInstanceOf`); read TypeId
+    // directly so we return undefined for non-entities instead of throwing.
+    const type = (obj as any)?.[TypeId];
+    // Parse the URI string to extract typename.
+    if (DXN.isDXN(type)) {
+      const parsed = DXN.tryMake(type);
+      return parsed && DXN.getName(parsed);
+    }
+    return undefined;
+  }
+};
+
+/**
+ * @internal (use Type.setTypename)
+ */
+// TODO(dmaretskyi): Rename setTypeDXN.
+export const setTypename = (obj: any, typename: URI.URI): void => {
+  assertArgument(typeof typename === 'string', 'typename', 'Invalid type.');
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false,
+  });
+};
+
+/**
+ * @returns Object type URI — either a typename {@link DXN} or an `echo:` reference to a stored Schema object.
+ * @returns undefined if the object has no registered type URI (e.g. unresolved query result).
+ * @example `dxn:com.example.type.person:1.0.0`
+ * @example `echo:/01KKKG2FHWCMTR0BY00GJSVT1X` (stored schema)
+ *
+ * @internal (use Obj.getTypeURI)
+ */
+export const getTypeURI = (obj: AnyProperties): URI.URI | undefined => {
+  if (obj == null) {
+    return undefined;
+  }
+  const type = (obj as any)[TypeId];
+  if (type == null) {
+    return undefined;
+  }
+  invariant(URI.isURI(type), 'Invalid object.');
+  return type;
+};
+
+//
+// PropertyMeta
+//
+
+/**
+ * PropertyMeta (metadata for dynamic schema properties).
+ * For user-defined annotations.
+ */
+export const PropertyMetaAnnotationId = Symbol.for('@dxos/schema/annotation/PropertyMeta');
+
+export type PropertyMetaValue = Primitive | Record<string, Primitive> | Primitive[];
+
+export type PropertyMetaAnnotation = {
+  [name: string]: PropertyMetaValue;
+};
+
+// TODO(wittjosiah): Align with other annotations.
+// TODO(wittjosiah): Why is this separate from FormatAnnotation?
+/**
+ * Apply property-level metadata to an Effect schema. Only accepts
+ * `Schema.Schema.Any` — apply BEFORE wrapping the schema with
+ * `Type.makeObject` / `Type.makeRelation`. To read property meta off a
+ * `Type.Type` entity, unwrap it first with `Type.getSchema(entity)`.
+ */
+export const PropertyMeta = (name: string, value: PropertyMetaValue) => {
+  return <A, I, R>(self: Schema.Schema<A, I, R>): Schema.Schema<A, I, R> => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId] as PropertyMetaAnnotation;
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value,
+      },
+    });
+  };
+};
+
+export const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature, name: string) =>
+  Function.pipe(
+    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(prop.type),
+    Option.map((meta) => meta[name] as T),
+    Option.getOrElse(() => undefined),
+  );
+
+//
+// Reference
+//
+
+/**
+ * Schema reference.
+ */
+export const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');
+export type ReferenceAnnotationValue = TypeAnnotation;
+export const ReferenceAnnotation = createAnnotationHelper<ReferenceAnnotationValue>(ReferenceAnnotationId);
+
+/**
+ * SchemaMeta.
+ */
+export const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');
+export type SchemaMeta = TypeMeta & { id: string };
+
+/**
+ * Identifies a schema as hidden from user-facing surfaces (like dotfiles — visible only via an advanced setting).
+ */
+export const HiddenAnnotationId = Symbol.for('@dxos/schema/annotation/Hidden');
+export const HiddenAnnotation = createAnnotationHelper<boolean>(HiddenAnnotationId);
+
+/**
+ * Identifies label property or JSON path expression.
+ * Either a string or an array of strings representing field accessors each matched in priority order.
+ */
+export const LabelAnnotationId = Symbol.for('@dxos/schema/annotation/Label');
+export const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationId);
+
+/**
+ * Returns the label for a given object based on {@link LabelAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
+ * Skips empty strings and whitespace-only strings, continuing to the next field.
+ */
+// TODO(burdon): Convert to SchemaEx.JsonPath?
+export const getLabelWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+): string | undefined => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));
+  for (const accessor of annotation) {
+    assertArgument(
+      typeof accessor === 'string',
+      'accessor',
+      'Label annotation must be a string or an array of strings',
+    );
+    const value = SchemaEx.getField(object, accessor as SchemaEx.JsonPath);
+    switch (typeof value) {
+      case 'string': {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+          return value;
+        }
+        continue;
+      }
+      case 'number':
+      case 'boolean':
+      case 'bigint':
+      case 'symbol':
+        return value.toString();
+      case 'undefined':
+      case 'object':
+      case 'function':
+        continue;
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Sets the label for a given object based on {@link LabelAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
+ */
+export const setLabelWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+  label: string,
+) => {
+  const annotation = LabelAnnotation.get(schema).pipe(
+    Option.map((field) => field[0]),
+    Option.getOrElse(() => 'name'),
+  );
+  object[annotation] = label;
+};
+
+/**
+ * Identifies description property or JSON path expression.
+ * A string representing field accessor.
+ */
+export const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');
+export const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);
+
+/**
+ * Returns the description for a given object based on {@link DescriptionAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
+ */
+// TODO(burdon): Convert to SchemaEx.JsonPath?
+export const getDescriptionWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+): string | undefined => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));
+  assertArgument(typeof accessor === 'string', 'accessor', 'Description annotation must be a string');
+  const value = SchemaEx.getField(object, accessor as SchemaEx.JsonPath);
+  switch (typeof value) {
+    case 'string':
+    case 'number':
+    case 'boolean':
+    case 'bigint':
+    case 'symbol':
+      return value.toString();
+    case 'undefined':
+    case 'object':
+    case 'function':
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * Sets the description for a given object based on {@link DescriptionAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
+ */
+export const setDescriptionWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+  description: string,
+) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));
+  object[accessor] = description;
+};
+
+/**
+ * Identifies if a property should be included in a form or not.
+ * By default, all properties are included in forms, so this is opt-out.
+ */
+export const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');
+export const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);
+
+/**
+ * When set on a `Ref` property, the form renders the referenced object's own
+ * fields inline (a nested form bound to the target) instead of a picker.
+ */
+export const FormInlineAnnotationId = Symbol.for('@dxos/schema/annotation/FormInline');
+export const FormInlineAnnotation = createAnnotationHelper<boolean>(FormInlineAnnotationId);
+
+/**
+ * Default field to be used on referenced schema to lookup the value.
+ */
+export const FieldLookupAnnotationId = Symbol.for('@dxos/schema/annotation/FieldLookup');
+
+/**
+ * Generate test data.
+ */
+export const GeneratorAnnotationId = Symbol.for('@dxos/schema/annotation/Generator');
+
+export type GeneratorAnnotationValue =
+  | string
+  | {
+      generator: string;
+      args?: any[];
+      probability?: number;
+    };
+
+export const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);
+
+interface MakeAnnoationsProps<T> {
+  id: string;
+  schema: Schema.Schema<T, any, never>;
+}
+
+// Annotation ids use the same NSID / reverse-DNS format as TypenameSchema —
+// dot-separated segments, middle segments may be hyphenated, final segment may be camelCase.
+// At least 3 segments are required (e.g. org.dxos.annotation.example).
+export const makeUserAnnotation = <T>(props: MakeAnnoationsProps<T>): Annotation.Annotation<T> => {
+  assertArgument(
+    /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?){2,}(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)?$/.test(
+      props.id,
+    ),
+    'id',
+    'Annotation id must be in the FQN format (org.dxos.annotation.example or org.dxos.space.rootCollection).',
+  );
+
+  const annotation: Annotation.Annotation<T> = {
+    [ANNOTATION_TYPE_ID]: { _Type: {} as T },
+    key: props.id as Annotation.Key,
+    schema: props.schema,
+    get: (schema) => getFromAst(schema.ast, annotation),
+    getFromAst: (ast) => getFromAst(ast, annotation),
+    set: (value) =>
+      PropertyMeta(props.id, Schema.encodeSync(props.schema)(value)) as <S extends Schema.Schema.Any>(schema: S) => S,
+  };
+
+  return annotation;
+};
+
+const IconAnnotationSchema = Schema.Struct({
+  /**
+   * Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)
+   */
+  icon: Schema.String.pipe(Schema.pattern(/^ph--[a-z-]+--[a-z]+$/)),
+
+  /**
+   * Color name.
+   *
+   * List of colors:
+   *  - 'red'
+   *  - 'orange'
+   *  - 'amber'
+   *  - 'yellow'
+   *  - 'lime'
+   *  - 'green'
+   *  - 'emerald'
+   *  - 'teal'
+   *  - 'cyan'
+   *  - 'violet'
+   *  - 'purple'
+   *  - 'fuchsia'
+   *  - 'pink'
+   *  - 'rose'
+   */
+  hue: Schema.optional(Schema.String),
+});
+
+export interface IconAnnotation extends Schema.Schema.Type<typeof IconAnnotationSchema> {}
+
+/**
+ * Icon to render in the UI.
+ */
+export const IconAnnotation = makeUserAnnotation<IconAnnotation>({
+  id: 'org.dxos.annotation.icon',
+  schema: IconAnnotationSchema,
+});
+
+/**
+ * Indicates that this entity's icon should be resolved from a property whose value is a `Ref`
+ * to another entity. Consumers (e.g. graph node builders) resolve the ref target and use that
+ * target's schema `IconAnnotation` in place of the static one declared on this schema.
+ *
+ * Useful for wrapper schemas that delegate their visual identity to a referenced sub-entity
+ * (e.g. a generic `Game` whose icon should come from its `variant` ref's typed state).
+ */
+export const IconFromRefAnnotation = makeUserAnnotation<string>({
+  id: 'org.dxos.annotation.icon.from-ref',
+  schema: Schema.String,
+});
+
+/**
+ * Options for {@link getLabel}.
+ */
+export type GetLabelOptions = {
+  /**
+   * Strategy for deriving a label when the entity has no `LabelAnnotation` value.
+   * - `'typename'`: use the entity's typename (e.g. `org.dxos.type.table`).
+   *   Useful for Card.Title chrome that must always display something, even
+   *   for unlabeled objects.
+   */
+  fallback?: 'typename';
+};
+
+/**
+ * Get the label of an entity.
+ * Accepts both reactive entities and snapshots.
+ *
+ * If `options.fallback === 'typename'` and no label is set, returns the
+ * entity's typename instead.
+ */
+export const getLabel = (entity: AnyProperties, options?: GetLabelOptions): string | undefined => {
+  const schema = getSchema(entity);
+  const label = schema != null ? getLabelWithSchema(schema, entity) : undefined;
+  if (label != null) {
+    return label;
+  }
+  if (options?.fallback === 'typename') {
+    return getTypename(entity);
+  }
+  return undefined;
+};
+
+/**
+ * Set the label of an entity.
+ * Must be called within an Obj.update or Relation.update callback.
+ */
+export const setLabel = (entity: Mutable<AnyProperties>, label: string) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabelWithSchema(schema, entity, label);
+  }
+};
+
+/**
+ * Get the description of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getDescription = (entity: AnyProperties): string | undefined => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescriptionWithSchema(schema, entity);
+  }
+};
+
+/**
+ * Get the icon annotation for an entity, resolved via its type-level `IconAnnotation`.
+ * Accepts both reactive entities and snapshots.
+ *
+ * Returns the full `{ icon, hue }` annotation so callers can use both the phosphor icon
+ * name and the suggested colour. Callers wanting just the icon name typically write
+ * `Obj.getIcon(obj)?.icon ?? 'ph--cube--regular'`.
+ *
+ * Note: this is the "static" icon from the object's own schema. It does not follow
+ * `IconFromRefAnnotation` delegation — call sites needing that (e.g. app-graph node
+ * builders) should resolve the ref themselves.
+ */
+export const getIcon = (entity: AnyProperties): IconAnnotation | undefined => {
+  const schema = getSchema(entity);
+  if (schema == null) {
+    return undefined;
+  }
+  return Option.getOrUndefined(IconAnnotation.get(schema));
+};
+
+/**
+ * Set the description of an entity.
+ * Must be called within an Obj.update or Relation.update callback.
+ */
+export const setDescription = (entity: Mutable<AnyProperties>, description: string) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescriptionWithSchema(schema, entity, description);
+  }
+};
+
+export { Dictionary, Key, getDictionary, setDictionary } from './dictionary';
+
+export const getFromAst = <T>(ast: SchemaAST.AST, annotation: Annotation.Annotation<T>): Option.Option<T> => {
+  return SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(ast).pipe(
+    Option.flatMap((meta) => Option.fromNullable(meta[annotation.key])),
+    Option.map(Schema.decodeUnknownSync(annotation.schema)),
+  );
+};

package/src/internal/Annotation/dictionary.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as Types from 'effect/Types';
+
+import type * as Annotation from '../../Annotation';
+
+/**
+ * Unique identifier for an annotation.
+ */
+export const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/AnnotationKey'));
+export type Key = Schema.Schema.Type<typeof Key>;
+
+/**
+ * Set of annotation values stored on entity meta or nested in schemas.
+ */
+export const Dictionary = Schema.Record({ key: Key, value: Schema.Unknown });
+export interface Dictionary extends Schema.Schema.Type<typeof Dictionary> {}
+
+/**
+ * Get the value of an annotation from a dictionary.
+ */
+export const getDictionary = <T>(
+  values: Annotation.Dictionary,
+  annotation: Annotation.Annotation<T>,
+): Option.Option<T> => {
+  if (!(annotation.key in values)) {
+    return Option.none();
+  }
+
+  return Function.pipe(values[annotation.key], Schema.decodeUnknownSync(annotation.schema), Option.some);
+};
+
+/**
+ * Set the value of an annotation in a dictionary.
+ */
+export const setDictionary = <T>(
+  values: Types.Mutable<Annotation.Dictionary>,
+  annotation: Annotation.Annotation<T>,
+  value: T,
+): void => {
+  values[annotation.key] = Schema.encodeSync(annotation.schema)(value);
+};