@dxos/echo 0.8.4-main.b97322e → 0.8.4-main.c4373fc

package/src/Type.ts

@@ -2,15 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
-import { type Simplify } from 'effect/Schema';
+import type * as EffectSchema from 'effect/Schema';
 
 import { type EncodedReference } from '@dxos/echo-protocol';
-import * as EchoSchema from '@dxos/echo-schema';
-import { type ToMutable } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import type * as Keys from '@dxos/keys';
 
+import { type ToMutable } from './internal';
+import * as EchoSchema from './internal';
 import type * as RelationModule from './Relation';
 
 //
@@ -39,7 +38,7 @@ export type Schema = EchoSchema.EchoSchema;
 /**
  * Returns all properties of an object or relation except for the id and kind.
  */
-export type Properties<T> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
+export type Properties<T = any> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
 
 //
 // Obj
@@ -55,45 +54,47 @@ interface ObjJsonProps {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface obj<Self extends Schema.Schema.Any>
+export interface obj<Self extends EffectSchema.Schema.Any>
   extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+    EffectSchema.AnnotableClass<
       obj<Self>,
-      OfKind<EchoSchema.EntityKind.Object> & ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<ObjJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+      OfKind<EchoSchema.EntityKind.Object> & ToMutable<EffectSchema.Schema.Type<Self>>,
+      EffectSchema.Simplify<ObjJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,
+      EffectSchema.Schema.Context<Self>
     > {}
 
 /**
  * Object schema.
  */
 export const Obj: {
-  (opts: EchoSchema.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => obj<Self>;
+  (opts: EchoSchema.TypeMeta): <Self extends EffectSchema.Schema.Any>(self: Self) => obj<Self>;
 } = EchoSchema.EchoObject as any;
 
 /**
  * Object schema type definitions.
  */
-export namespace Obj {
+export declare namespace Obj {
   /**
    * Type that represents an arbitrary schema type of an object.
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = Schema.Schema.AnyNoContext;
+  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).
+  export type Any = EffectSchema.Schema.AnyNoContext;
 }
 
 //
 // Expando
 //
 
+// TODO(burdon): We're using Expando in many places as a base type.
 export interface Expando extends OfKind<EchoSchema.EntityKind.Object> {
   [key: string]: any;
 }
 
-type ExpandoEncoded = Simplify<ObjJsonProps & { [key: string]: any }>;
+type ExpandoEncoded = EffectSchema.Simplify<ObjJsonProps & { [key: string]: any }>;
 
-export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
+export const Expando: EffectSchema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
 
 //
 // Relation
@@ -112,17 +113,17 @@ interface RelationJsonProps {
  * See Effect's note on interface types.
  */
 export interface relation<
-  Self extends Schema.Schema.Any,
-  SourceSchema extends Schema.Schema.Any,
-  TargetSchema extends Schema.Schema.Any,
+  Self extends EffectSchema.Schema.Any,
+  SourceSchema extends EffectSchema.Schema.Any,
+  TargetSchema extends EffectSchema.Schema.Any,
 > extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+    EffectSchema.AnnotableClass<
       relation<Self, SourceSchema, TargetSchema>,
       OfKind<EchoSchema.EntityKind.Relation> &
-        Relation.Endpoints<Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>> &
-        ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<RelationJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+        Relation.Endpoints<EffectSchema.Schema.Type<SourceSchema>, EffectSchema.Schema.Type<TargetSchema>> &
+        ToMutable<EffectSchema.Schema.Type<Self>>,
+      EffectSchema.Simplify<RelationJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,
+      EffectSchema.Schema.Context<Self>
     > {}
 
 /**
@@ -130,9 +131,9 @@ export interface relation<
  */
 // TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.
 export const Relation: {
-  <Source extends Schema.Schema.AnyNoContext, Target extends Schema.Schema.AnyNoContext>(
+  <Source extends EffectSchema.Schema.AnyNoContext, Target extends EffectSchema.Schema.AnyNoContext>(
     opts: EchoSchema.EchoRelationOptions<Source, Target>,
-  ): <Self extends Schema.Schema.Any>(self: Self) => relation<Self, Source, Target>;
+  ): <Self extends EffectSchema.Schema.Any>(self: Self) => relation<Self, Source, Target>;
 } = EchoSchema.EchoRelation as any;
 
 /**
@@ -144,7 +145,7 @@ export namespace Relation {
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = Schema.Schema.AnyNoContext;
+  export type Any = EffectSchema.Schema.AnyNoContext;
 
   /**
    * Get relation source type.
@@ -172,15 +173,15 @@ export namespace Relation {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface ref<TargetSchema extends Schema.Schema.Any>
-  extends EchoSchema.Ref$<Schema.Schema.Type<TargetSchema>> {}
+export interface ref<TargetSchema extends EffectSchema.Schema.Any>
+  extends EchoSchema.Ref$<EffectSchema.Schema.Type<TargetSchema>> {}
 
 /**
  * Ref schema.
  */
 export const Ref: <S extends Obj.Any>(schema: S) => ref<S> = EchoSchema.Ref;
 
-export interface Ref<T> extends Schema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}
+export interface Ref<T> extends EffectSchema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}
 
 // TODO(buurdon): Move to Ref?
 export namespace Ref {
@@ -188,7 +189,7 @@ export namespace Ref {
    * Type that represents an arbitrary schema type of a reference.
    * NOTE: This is not an instance type.
    */
-  export type Any = Schema.Schema<EchoSchema.Ref<any>, EncodedReference>;
+  export type Any = EffectSchema.Schema<EchoSchema.Ref<any>, EncodedReference>;
 }
 
 /**
@@ -241,4 +242,4 @@ export const getMeta = (schema: Obj.Any | Relation.Any): Meta | undefined => {
 // TODO(dmaretskyi): Remove re-exports.
 export { SpaceId, ObjectId, DXN } from '@dxos/keys';
 
-export { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from '@dxos/echo-schema';
+export { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from './internal';

package/src/errors.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+import { type DXN } from '@dxos/keys';
+
+export class SchemaNotFoundError extends BaseError.extend('SCHEMA_NOT_FOUND', 'Schema not found') {
+  constructor(schema: string, options?: BaseErrorOptions) {
+    super({ context: { schema }, ...options });
+  }
+}
+
+export class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND', 'Object not found') {
+  constructor(dxn: DXN, options?: BaseErrorOptions) {
+    super({ context: { dxn }, ...options });
+  }
+}

package/src/index.ts

@@ -2,12 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './errors';
+export * from './query';
+
 export * as Key from './Key';
 export * as Obj from './Obj';
 export * as Ref from './Ref';
 export * as Relation from './Relation';
 export * as Type from './Type';
 
+export { QueryAST } from '@dxos/echo-protocol';
 export { DXN } from '@dxos/keys';
-export { Filter, Query } from './query';
 export { type Live } from '@dxos/live-object';

package/src/internal/ast/annotation-helper.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+export interface AnnotationHelper<T> {
+  get: (schema: Schema.Schema.Any) => Option.Option<T>;
+  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;
+}
+
+export const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    set:
+      (value) =>
+      <S extends Schema.Schema.Any>(schema: S) =>
+        schema.annotations({ [id]: value }) as S,
+  };
+};

package/src/internal/ast/annotations.test.ts

@@ -0,0 +1,98 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { EchoObject, getLabel } from '../object';
+
+import { LabelAnnotation, SchemaVersion, Typename } from './annotations';
+
+// TODO(dmaretskyi): Use one of the testing schemas.
+const TestObject = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  fallbackName: Schema.optional(Schema.String),
+  other: Schema.String,
+}).pipe(LabelAnnotation.set(['name', 'fallbackName']));
+
+const a: Schema.Struct<typeof TestObject.fields> = TestObject;
+console.log(a);
+
+type TestObject = Schema.Schema.Type<typeof TestObject>;
+
+const TestEchoSchema = TestObject.pipe(
+  EchoObject({
+    typename: 'dxos.org/type/Test',
+    version: '0.1.0',
+  }),
+);
+type TestEchoSchema = Schema.Schema.Type<typeof TestEchoSchema>;
+
+describe('annotations', () => {
+  describe('Typename', () => {
+    test('should validate typename', ({ expect }) => {
+      // Valid.
+      expect(Typename.make('dxos.org/type/foo')).to.exist;
+      expect(Typename.make('dxos.org/type/foo-bar')).to.exist;
+      expect(Typename.make('dxos.org/type/foo_bar')).to.exist;
+
+      // Invalid.
+      expect(() => Typename.make('dxn:dxos.org')).to.throw();
+      expect(() => Typename.make('2dxos.org')).to.throw();
+      expect(() => Typename.make('dxos org')).to.throw();
+    });
+
+    test('should validate version', ({ expect }) => {
+      // Valid.
+      expect(SchemaVersion.make('0.1.0')).to.exist;
+
+      // Invalid.
+      expect(() => SchemaVersion.make('0.1.x')).to.throw();
+      expect(() => SchemaVersion.make('0.1.0-alpha')).to.throw();
+    });
+  });
+
+  describe('getLabel', () => {
+    test('should return first available label value', ({ expect }) => {
+      const obj: TestObject = {
+        name: 'Primary Name',
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toEqual('Primary Name');
+    });
+
+    test('should fallback to second path if first is undefined', ({ expect }) => {
+      const obj: TestObject = {
+        name: undefined,
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toEqual('Fallback Name');
+    });
+
+    test('should return undefined if no label paths resolve', ({ expect }) => {
+      const obj: TestObject = {
+        name: undefined,
+        fallbackName: undefined,
+        other: 'Other',
+      };
+
+      expect(getLabel(TestObject, obj)).toBeUndefined();
+    });
+
+    test('should return label from echo object', ({ expect }) => {
+      const obj: TestEchoSchema = {
+        id: 'test',
+        name: 'Primary Name',
+        fallbackName: 'Fallback Name',
+        other: 'Other',
+      };
+
+      expect(getLabel(TestEchoSchema, obj)).toEqual('Primary Name');
+    });
+  });
+});

package/src/internal/ast/annotations.ts

@@ -0,0 +1,212 @@
+//
+// 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 { assertArgument } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+import { type Primitive } from '@dxos/util';
+
+import { createAnnotationHelper } from './annotation-helper';
+import { EntityKind } from './entity-kind';
+
+/**
+ * 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];
+};
+
+/**
+ * ECHO identifier (for a stored schema).
+ * Must be a `dxn: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);
+
+/**
+ * ECHO type.
+ */
+export const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');
+
+// TODO(burdon): Create echo-schema Format types.
+// TODO(burdon): Reconcile with "short" DXN.
+export const Typename = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/));
+export const SchemaVersion = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/));
+
+/**
+ * Payload stored under {@link TypeAnnotationId}.
+ */
+// TODO(dmaretskyi): Rename getTypeAnnotation to represent commonality between objects and relations (e.g. `entity`).
+export const TypeAnnotation = Schema.Struct({
+  kind: Schema.Enums(EntityKind),
+  typename: Typename,
+  version: SchemaVersion,
+
+  /**
+   * 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> {}
+
+export type TypeMeta = Pick<TypeAnnotation, 'typename' | 'version'>;
+
+/**
+ * @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;
+
+/**
+ * @deprecated Use {@link Type.getTypename} instead.
+ * @returns Schema typename (without dxn: prefix or version number).
+ */
+export const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;
+
+/**
+ * @deprecated Use {@link Type.getVersion} instead.
+ * @returns Schema version in semver format.
+ */
+export const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;
+
+/**
+ * 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;
+};
+
+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),
+  );
+
+/**
+ * Schema reference.
+ */
+export const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');
+
+export type ReferenceAnnotationValue = TypeAnnotation;
+
+export const getReferenceAnnotation = (schema: Schema.Schema.AnyNoContext) =>
+  Function.pipe(
+    SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(schema.ast),
+    Option.getOrElse(() => undefined),
+  );
+
+/**
+ * SchemaMeta.
+ */
+export const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');
+
+export type SchemaMeta = TypeMeta & { id: string };
+
+/**
+ * Identifies a schema as a view.
+ */
+export const ViewAnnotationId = Symbol.for('@dxos/schema/annotation/View');
+export const ViewAnnotation = createAnnotationHelper<boolean>(ViewAnnotationId);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * @returns DXN of the schema.
+ *
+ * For non-stored schema returns `dxn:type:`.
+ * For stored schema returns `dxn:echo:`.
+ * @deprecated Use `Type.getDXN`.
+ */
+export const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {
+  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');
+
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+
+  // TODO(dmaretskyi): Add support for dynamic schema.
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return undefined;
+  }
+
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};

package/src/internal/ast/entity-kind.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+/**
+ * Kinds of entities stored in ECHO: objects and relations.
+ */
+export enum EntityKind {
+  Object = 'object',
+  Relation = 'relation',
+}
+
+export const EntityKindSchema = Schema.Enums(EntityKind);

package/src/internal/ast/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './annotations';
+export * from './annotation-helper';
+export * from './types';
+export * from './entity-kind';

package/src/internal/ast/types.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { PropertyMeta } from './annotations';
+
+/**
+ * @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);

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

@@ -0,0 +1,56 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, expect, test } from 'vitest';
+
+import { log } from '@dxos/log';
+
+import { toJsonSchema } from '../json';
+
+import {
+  DateOnly,
+  DateTime,
+  type SimpleDate,
+  type SimpleDateTime,
+  type SimpleTime,
+  TimeOnly,
+  toSimpleDate,
+  toSimpleTime,
+} from './date';
+
+describe.skip('date', () => {
+  test('basic', () => {
+    const date = new Date('2024-12-31T23:59:59Z');
+    expect(toSimpleDate(date)).to.deep.eq({ year: 2024, month: 12, day: 31 });
+    expect(toSimpleTime(date)).to.deep.eq({ hours: 23, minutes: 59, seconds: 59 });
+  });
+
+  test('Date', ({ expect }) => {
+    const jsonSchema = toJsonSchema(DateOnly);
+    log('schema', { jsonSchema });
+    const v1: SimpleDate = { year: 1999, month: 12, day: 31 };
+    const str = Schema.encodeUnknownSync(DateOnly)(v1);
+    const v2 = Schema.decodeUnknownSync(DateOnly)(str);
+    expect(v1).to.deep.eq(v2);
+  });
+
+  test('Time', ({ expect }) => {
+    const jsonSchema = toJsonSchema(TimeOnly);
+    log('schema', { jsonSchema });
+    const v1: SimpleTime = { hours: 23, minutes: 59, seconds: 59 };
+    const str = Schema.encodeUnknownSync(TimeOnly)(v1);
+    const v2 = Schema.decodeUnknownSync(TimeOnly)(str);
+    expect(v1).to.deep.eq(v2);
+  });
+
+  test('DateTime', ({ expect }) => {
+    const jsonSchema = toJsonSchema(DateTime);
+    log('schema', { jsonSchema });
+    const v1: SimpleDateTime = { year: 1999, month: 12, day: 31, hours: 23, minutes: 59, seconds: 59 };
+    const str = Schema.encodeUnknownSync(DateTime)(v1);
+    const v2 = Schema.decodeUnknownSync(DateTime)(str);
+    expect(v1).to.deep.eq(v2);
+  });
+});