@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

package/src/internal/entities/entity.ts

@@ -0,0 +1,109 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import type * as SchemaAST from 'effect/SchemaAST';
+import type * as Types from 'effect/Types';
+
+import { type ToMutable } from '@dxos/util';
+
+import { type TypeMeta } from '../annotations';
+import { type HasId } from '../types';
+
+// 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<HasId & ToMutable<T> & ExtraFields>;
+
+// TODO(burdon): Rename EchoEntitySchema.
+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;
+}
+
+// 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;
+
+/**
+ * @internal
+ */
+export const makeEchoTypeSchema = <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 makeEchoTypeSchema<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 → entities}/expando.ts

@@ -4,18 +4,20 @@
 
 import * as Schema from 'effect/Schema';
 
-import { EchoObject } from './entity';
+import { EchoObjectSchema } from './object';
 
 export const EXPANDO_TYPENAME = 'dxos.org/type/Expando';
 
 const ExpandoSchema = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
-  EchoObject({ typename: EXPANDO_TYPENAME, version: '0.1.0' }),
+  EchoObjectSchema({
+    typename: EXPANDO_TYPENAME,
+    version: '0.1.0',
+  }),
 );
 
 /**
  * Expando object is an object with an arbitrary set of properties.
  */
-// TODO(dmaretskyi): Can we consider expando a top-type, i.e. have a ref to expando potentially be a valid ref to any object?
 export interface Expando extends Schema.Schema.Type<typeof ExpandoSchema> {}
-
-export const Expando: Schema.Schema<Expando> = ExpandoSchema;
+export interface ExpandoEncoded extends Schema.Schema.Encoded<typeof ExpandoSchema> {}
+export const Expando: Schema.Schema<Expando, ExpandoEncoded> = ExpandoSchema;

package/src/internal/entities/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './expando';
+export * from './model'; // TODO(burdon): Rename.
+export * from './object';
+export * from './relation';
+export * from './util';

package/src/internal/{object → entities}/model.ts

@@ -9,49 +9,40 @@ 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';
+import {
+  type ATTR_META,
+  type ATTR_TYPE,
+  EntityKind,
+  KindId,
+  type MetaId,
+  type ObjectMeta,
+  type SchemaId,
+  TypeId,
+  type Version,
+} from '../types';
+
+import {
+  type ATTR_RELATION_SOURCE,
+  type ATTR_RELATION_TARGET,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+} from './relation';
 
 //
 // Defines the internal model of the echo object.
 //
 
-/**
- * Entity kind.
- */
-export const EntityKindId = Symbol.for('@dxos/echo/EntityKind');
-
-/**
- * DXN to the object itself.
- */
-export const SelfDXNId = Symbol.for('@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.for('@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.for('@dxos/echo/Schema');
-
-/**
- * Deletion marker.
+ * DXN to the object itself.
  */
-export const DeletedId = Symbol.for('@dxos/echo/Deleted');
+export const SelfDXNId = Symbol.for('@dxos/echo/DXN');
 
 /**
  * Property name for deleted when object is serialized to JSON.
@@ -59,53 +50,14 @@ export const DeletedId = Symbol.for('@dxos/echo/Deleted');
 export const ATTR_DELETED = '@deleted';
 
 /**
- * Metadata section.
- */
-export const MetaId = Symbol.for('@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.for('@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.for('@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.for('@dxos/echo/RelationSource');
-
-/**
- * Used to access relation target ref on live ECHO objects.
- * Reading this symbol must return `Live<EchoObject<any>>` or a DXN.
+ * Deletion marker.
  */
-export const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTarget');
+export const ObjectDeletedId = Symbol.for('@dxos/echo/Deleted');
 
 /**
- * Getter to get object version.
+ * Object version accessor symbol.
  */
-export const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/ObjectVersion');
+export const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/Version');
 
 /**
  * Internal runtime representation of an object.
@@ -113,55 +65,62 @@ export const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/ObjectVersi
  */
 export interface InternalObjectProps {
   id: ObjectId;
-  readonly [SelfDXNId]?: DXN;
 
   // Echo supports untyped objects O_O.
   readonly [TypeId]?: DXN;
 
+  //
+  readonly [SelfDXNId]?: DXN;
+
   /**
    * Returns the schema for the object.
    */
   readonly [SchemaId]?: Schema.Schema.AnyNoContext;
-  readonly [EntityKindId]: EntityKind;
-  readonly [DeletedId]?: boolean;
+  readonly [KindId]: EntityKind;
   readonly [MetaId]?: ObjectMeta;
+  readonly [ObjectDeletedId]?: boolean;
+  readonly [ObjectVersionId]?: Version;
   readonly [RelationSourceDXNId]?: DXN;
   readonly [RelationTargetDXNId]?: DXN;
   readonly [RelationSourceId]?: InternalObjectProps;
   readonly [RelationTargetId]?: InternalObjectProps;
-  readonly [ObjectVersionId]?: Version;
 }
 
 /**
- * JSON representation of an object or relation.
+ * Entity metadata.
+ */
+export interface ObjectMetaJSON {
+  keys: ForeignKey[];
+  tags?: string[];
+}
+
+/**
+ * JSON representation of an object or relation metadata.
  */
 export interface ObjectJSON {
   id: string;
-  [ATTR_SELF_DXN]?: DXN.String;
   [ATTR_TYPE]: DXN.String;
+  [ATTR_SELF_DXN]?: 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 {
+/**
+ * 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 || obj[TypeId] instanceof DXN, 'Invalid object model: invalid type');
   invariant(
-    obj[EntityKindId] === EntityKind.Object || obj[EntityKindId] === EntityKind.Relation,
+    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation,
     'Invalid object model: invalid entity kind',
   );
-  if (obj[EntityKindId] === EntityKind.Relation) {
+
+  if (obj[KindId] === 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');

package/src/internal/entities/object.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { invariant } from '@dxos/invariant';
+
+import { type TypeAnnotation, TypeAnnotationId, type TypeMeta, makeTypeJsonSchemaAnnotation } from '../annotations';
+import { EntityKind } from '../types';
+
+import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * Schema for Obj entity types.
+ * Pipeable function to add ECHO object annotations to a schema.
+ */
+export const EchoObjectSchema: {
+  // 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?
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self>(/* self.fields, */ ast, typename, version);
+  };
+};

package/src/internal/entities/relation.ts

@@ -0,0 +1,155 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { raise } from '@dxos/debug';
+import { assertArgument, invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  type TypeMeta,
+  getEntityKind,
+  getSchemaTypename,
+  getTypeIdentifierAnnotation,
+  makeTypeJsonSchemaAnnotation,
+} from '../annotations';
+import { EntityKind } from '../types';
+
+import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * 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.
+ * Reading this symbol must return `Live<EchoObjectSchema<any>>` or a DXN.
+ */
+export const RelationSourceId: unique symbol = Symbol.for('@dxos/echo/RelationSource');
+
+/**
+ * Used to access relation source ref on live ECHO objects.
+ * Reading this symbol must return `Live<EchoObjectSchema<any>>` or a DXN.
+ */
+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.
+ * Reading this symbol must return `Live<EchoObjectSchema<any>>` or a DXN.
+ */
+export const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTarget');
+
+/**
+ * Used to access relation target ref on live ECHO objects.
+ * Reading this symbol must return `Live<EchoObjectSchema<any>>` or a DXN.
+ */
+export const RelationTargetDXNId: unique symbol = Symbol.for('@dxos/echo/RelationTargetDXN');
+
+/**
+ * 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;
+
+export type EchoRelationSchemaOptions<
+  TSource extends Schema.Schema.AnyNoContext,
+  TTarget extends Schema.Schema.AnyNoContext,
+> = TypeMeta & {
+  source: TSource;
+  target: TTarget;
+};
+
+/**
+ * Schema for Relation entity types.
+ */
+export const EchoRelationSchema = <
+  Source extends Schema.Schema.AnyNoContext,
+  Target extends Schema.Schema.AnyNoContext,
+>({
+  source,
+  target,
+  typename,
+  version,
+}: EchoRelationSchemaOptions<Source, Target>) => {
+  assertArgument(Schema.isSchema(source), 'source');
+  assertArgument(Schema.isSchema(target), 'target');
+  const sourceDXN = getDXNForRelationSchemaRef(source);
+  const targetDXN = getDXNForRelationSchemaRef(target);
+  if (getEntityKind(source) !== EntityKind.Object) {
+    raise(new Error('Source schema must be an echo object schema.'));
+  }
+  if (getEntityKind(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,
+        version,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN,
+      } satisfies TypeAnnotation,
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename,
+        version,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self>(/* self.fields, */ ast, typename, version);
+  };
+};
+
+const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): string => {
+  assertArgument(Schema.isSchema(schema), 'schema');
+  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();
+};

package/src/internal/entities/util.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { assertArgument, invariant } from '@dxos/invariant';
+import { DXN, ObjectId } from '@dxos/keys';
+import { assumeType } from '@dxos/util';
+
+import { type InternalObjectProps, SelfDXNId } from './model';
+
+/**
+ * Returns a DXN for an object or schema.
+ *
+ * @internal
+ */
+export const getObjectDXN = (object: any): DXN | undefined => {
+  invariant(!Schema.isSchema(object), 'schema not allowed in this function');
+  assertArgument(typeof object === 'object' && object != null, 'object', 'expected object');
+  assumeType<InternalObjectProps>(object);
+
+  if (object[SelfDXNId]) {
+    invariant(object[SelfDXNId] instanceof DXN, 'Invalid object model: invalid self dxn');
+    return object[SelfDXNId];
+  }
+
+  if (!ObjectId.isValid(object.id)) {
+    throw new TypeError('Object id is not valid.');
+  }
+
+  return DXN.fromLocalObjectId(object.id);
+};

package/src/internal/formats/date.test.ts

@@ -7,7 +7,7 @@ import { describe, expect, test } from 'vitest';
 
 import { log } from '@dxos/log';
 
-import { toJsonSchema } from '../json';
+import { toJsonSchema } from '../json-schema';
 
 import {
   DateOnly,

package/src/internal/formats/date.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.
@@ -102,7 +102,7 @@ export const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Date),
+  FormatAnnotation.set(TypeFormat.Date),
   Schema.annotations({
     title: 'Date',
     description: 'Valid date in ISO format',
@@ -132,7 +132,7 @@ export const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Time),
+  FormatAnnotation.set(TypeFormat.Time),
   Schema.annotations({
     title: 'Time',
     description: 'Valid time in ISO format',
@@ -177,7 +177,7 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.DateTime),
+  FormatAnnotation.set(TypeFormat.DateTime),
   Schema.annotations({
     title: 'DateTime',
     description: 'Valid date and time in ISO format',
@@ -189,7 +189,7 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
  */
 // TODO(burdon): Define duration type.
 export const Duration = Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Duration),
+  FormatAnnotation.set(TypeFormat.Duration),
   Schema.annotations({
     title: 'Duration',
     description: 'Duration in ISO 8601 format',

package/src/internal/formats/format.test.ts

@@ -5,10 +5,10 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { toJsonSchema } from '../json';
+import { toJsonSchema } from '../json-schema';
 
 import { Format } from './format';
-import { FormatEnum, TypeEnum, getTypeEnum } from './types';
+import { TypeEnum, TypeFormat, getTypeEnum } from './types';
 
 describe('formats', () => {
   test('annotations', ({ expect }) => {
@@ -48,7 +48,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Email,
+        format: TypeFormat.Email,
         title: 'Email',
       });
     }
@@ -58,7 +58,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.Number);
       expect(prop).includes({
         type: TypeEnum.Number,
-        format: FormatEnum.Currency,
+        format: TypeFormat.Currency,
         title: 'Currency',
         multipleOf: 0.01,
         currency: 'USD',
@@ -70,7 +70,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Date,
+        format: TypeFormat.Date,
       });
     }
   });