@dxos/echo 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

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

@@ -0,0 +1,77 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { toJsonSchema } from '../json-schema';
+
+import { Format } from './format';
+import { TypeEnum, TypeFormat, getTypeEnum } from './types';
+
+describe('formats', () => {
+  test('annotations', ({ expect }) => {
+    const TestSchema = Schema.Struct({
+      name: Schema.String,
+      email: Schema.optional(Format.Email),
+      salary: Schema.optional(Format.Currency({ decimals: 2, code: 'usd' })),
+      website: Schema.optional(Format.URL),
+      birthday: Schema.optional(Format.Date),
+      started: Schema.optional(Format.DateTime),
+      active: Schema.optional(Schema.Boolean),
+    }).pipe(Schema.mutable);
+
+    type TestType = Schema.Schema.Type<typeof TestSchema>;
+
+    const jsonSchema = toJsonSchema(TestSchema);
+
+    const data: TestType = {
+      name: 'Alice',
+      email: 'alice@example.com',
+      birthday: '1999-06-11',
+    };
+
+    const validate = Schema.validateSync(TestSchema);
+    validate(data);
+
+    {
+      const prop = jsonSchema.properties!['active' as const];
+      expect(getTypeEnum(prop)).to.eq(TypeEnum.Boolean);
+      expect(prop).includes({
+        type: TypeEnum.Boolean,
+      });
+    }
+
+    {
+      const prop = jsonSchema.properties!['email' as const];
+      expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
+      expect(prop).includes({
+        type: TypeEnum.String,
+        format: TypeFormat.Email,
+        title: 'Email',
+      });
+    }
+
+    {
+      const prop = jsonSchema.properties!['salary' as const];
+      expect(getTypeEnum(prop)).to.eq(TypeEnum.Number);
+      expect(prop).includes({
+        type: TypeEnum.Number,
+        format: TypeFormat.Currency,
+        title: 'Currency',
+        multipleOf: 0.01,
+        currency: 'USD',
+      });
+    }
+
+    {
+      const prop = jsonSchema.properties!['birthday' as const];
+      expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
+      expect(prop).includes({
+        type: TypeEnum.String,
+        format: TypeFormat.Date,
+      });
+    }
+  });
+});

package/src/internal/formats/format.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import * as Keys from '@dxos/keys';
+
+import * as DateUtil from './date';
+import * as NumberUtil from './number';
+import * as ObjectUtil from './object';
+import * as StringUtil from './string';
+import { TypeFormat as TypeFormat$ } from './types';
+
+// TODO(burdon): Media encoding.
+// - https://json-schema.org/understanding-json-schema/reference/non_json_data
+
+/**
+ * Formats.
+ * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
+ * NOTE: A JSON Schema validator will ignore any format type that it does not understand.
+ */
+// TODO(burdon): Add fields for `examples`, `message`, etc.
+export namespace Format {
+  export import TypeFormat = TypeFormat$;
+
+  // String
+  export const DXN = Keys.DXN.Schema;
+  export const Email = StringUtil.Email;
+  export const Formula = StringUtil.Formula;
+  export const Hostname = StringUtil.Hostname;
+  export const JSON = StringUtil.JSON;
+  export const Markdown = StringUtil.Markdown;
+  export const Regex = StringUtil.Regex;
+  export const URL = StringUtil.URL;
+  export const UUID = Schema.UUID;
+
+  // Numbers
+  // TODO(burdon): BigInt.
+  export const Currency = NumberUtil.Currency;
+  export const Integer = NumberUtil.Integer;
+  export const Percent = NumberUtil.Percent;
+  export const Timestamp = NumberUtil.Timestamp;
+
+  // Dates and times
+  export const Date = DateUtil.DateOnly;
+  export const DateTime = DateUtil.DateTime;
+  export const Duration = DateUtil.Duration;
+  export const Time = DateUtil.TimeOnly;
+
+  // Objects
+  export const GeoPoint = ObjectUtil.GeoPoint;
+  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.
+}

package/src/internal/formats/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export type { SimpleDate, SimpleDateTime, SimpleTime } from './date';
+export { CurrencyAnnotationId, DecimalPrecision, Currency } from './number';
+export { GeoPoint, GeoLocation } from './object';
+
+export * from './format';
+export * from './select';
+export * from './string';
+export * from './types';

package/src/internal/formats/number.ts

@@ -0,0 +1,89 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { FormatAnnotation, TypeFormat } from './types';
+
+const encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);
+
+const encodeMultiple =
+  <A extends number>(divisor?: number) =>
+  <I, R>(self: Schema.Schema<A, I, R>) =>
+    divisor === undefined || divisor === 0 ? self : self.pipe(Schema.multipleOf(encodeMultipleOf(divisor)));
+
+/**
+ * Convert number of digits to multipleOf annotation.
+ */
+export const DecimalPrecision = Schema.transform(Schema.Number, Schema.Number, {
+  strict: true,
+  encode: (value) => encodeMultipleOf(value),
+  decode: (value) => Math.log10(1 / value),
+}).annotations({
+  title: 'Number of digits',
+});
+
+export const CurrencyAnnotationId = Symbol.for('@dxos/schema/annotation/Currency');
+
+export type CurrencyAnnotation = {
+  decimals?: number;
+  code?: string;
+};
+
+/**
+ * ISO 4217 currency code.
+ */
+export const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>
+  Schema.Number.pipe(
+    encodeMultiple(decimals),
+    FormatAnnotation.set(TypeFormat.Currency),
+    Schema.annotations({
+      title: 'Currency',
+      description: 'Currency value',
+      ...(code ? { [CurrencyAnnotationId]: code.toUpperCase() } : {}),
+    }),
+  );
+
+export type PercentAnnotation = {
+  decimals?: number;
+};
+
+/**
+ * Integer.
+ */
+export const Integer = () =>
+  Schema.Number.pipe(
+    Schema.int(),
+    FormatAnnotation.set(TypeFormat.Integer),
+    Schema.annotations({
+      title: 'Integer',
+      description: 'Integer value',
+    }),
+  );
+
+/**
+ * Percent.
+ */
+// TODO(burdon): Define min/max (e.g., 0, 1).
+export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
+  Schema.Number.pipe(
+    encodeMultiple(decimals),
+    FormatAnnotation.set(TypeFormat.Percent),
+    Schema.annotations({
+      title: 'Percent',
+      description: 'Percentage value',
+    }),
+  );
+
+/**
+ * Unix timestamp.
+ * https://en.wikipedia.org/wiki/Unix_time
+ */
+export const Timestamp = Schema.Number.pipe(
+  FormatAnnotation.set(TypeFormat.Timestamp),
+  Schema.annotations({
+    title: 'Timestamp',
+    description: 'Unix timestamp',
+  }),
+);

package/src/internal/formats/object.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { clamp } from '@dxos/util';
+
+import { FormatAnnotation, TypeFormat } from './types';
+
+/**
+ * GeoJSON Format
+ * https://datatracker.ietf.org/doc/html/rfc7946
+ * https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1
+ * https://en.wikipedia.org/wiki/Geographic_coordinate_system
+ * https://geojson.org
+ * {
+ *   "type": "Point",
+ *   "coordinates": [0, 51.47] // [longitude, latitude]
+ * }
+ * Note: optional third element for altitude.
+ */
+export const GeoPoint = Schema.Tuple(
+  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.000001)),
+  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.000001)),
+  Schema.optionalElement(Schema.Number).annotations({
+    title: 'Height ASL (m)',
+  }),
+).pipe(
+  FormatAnnotation.set(TypeFormat.GeoPoint),
+  Schema.annotations({
+    title: 'GeoPoint',
+    description: 'GeoJSON Position',
+  }),
+);
+
+export type GeoPoint = Schema.Schema.Type<typeof GeoPoint>;
+
+export type GeoLocation = {
+  longitude: number;
+  latitude: number;
+  height?: number;
+};
+
+/**
+ * Geolocation utilities for working with GeoPoint format.
+ */
+export namespace GeoLocation {
+  /**
+   * Convert latitude and longitude to GeoPoint (GeoJSON format [longitude, latitude, height?]).
+   * Clamps values to valid ranges: latitude [-90, 90], longitude [-180, 180].
+   */
+  export const toGeoPoint = ({ longitude, latitude, height }: GeoLocation): GeoPoint => {
+    // TODO(ZaymonFC): Use schema validation instead of doing this manually.
+    const clampedLongitude = clamp(longitude, -180, 180);
+    const clampedLatitude = clamp(latitude, -90, 90);
+    return height !== undefined ? [clampedLongitude, clampedLatitude, height] : [clampedLongitude, clampedLatitude];
+  };
+
+  /**
+   * Extract latitude and longitude from GeoPoint (GeoJSON format [longitude, latitude, height?]).
+   */
+  export const fromGeoPoint = (geoPoint: GeoPoint | undefined): GeoLocation => {
+    if (!geoPoint) {
+      return { longitude: 0, latitude: 0 };
+    }
+
+    const result: GeoLocation = {
+      longitude: geoPoint[0],
+      latitude: geoPoint[1],
+    };
+
+    // Add height if defined.
+    if (geoPoint[2] !== undefined) {
+      result.height = geoPoint[2];
+    }
+
+    return result;
+  };
+}

package/src/internal/formats/select.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+/**
+ * Schema for a single select option. Used to define choices in a {single|multi}-select field.
+ */
+export const SelectOption = Schema.Struct({
+  /** Stable identifier for the option. */
+  id: Schema.NonEmptyString,
+  title: Schema.String,
+  /** Color palette used for visual styling. */
+  color: Schema.String,
+}).pipe(Schema.mutable);
+
+export type SelectOption = Schema.Schema.Type<typeof SelectOption>;

package/src/internal/formats/string.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { FormatAnnotation, TypeFormat } from './types';
+
+/**
+ * Email address (RFC 5321)
+ * https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2
+ */
+export const Email = Schema.String.pipe(
+  Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/),
+  FormatAnnotation.set(TypeFormat.Email),
+  Schema.annotations({
+    title: 'Email',
+    description: 'Email address',
+  }),
+);
+
+/**
+ *
+ */
+// TODO(burdon): Implement.
+export const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));
+
+/**
+ *
+ */
+// TODO(burdon): Implement.
+export const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
+
+/**
+ *
+ */
+// TODO(burdon): Implement.
+export const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
+
+/**
+ *
+ */
+// TODO(burdon): Implement.
+export const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
+
+/**
+ * Regex
+ * https://json-schema.org/understanding-json-schema/reference/regular_expressions
+ * https://ecma-international.org/publications-and-standards/standards/ecma-262
+ */
+// TODO(burdon): Implement.
+export const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));
+
+/**
+ * Multi-line text.
+ */
+export const Text = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Text));
+
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3
+ */
+export const URL = Schema.String.pipe(
+  Schema.pattern(/^(\w+?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i),
+  FormatAnnotation.set(TypeFormat.URL),
+  Schema.annotations({
+    title: 'URL',
+    description: 'URL',
+  }),
+);
+
+/**
+ * UUID (RFC 4122)
+ * https://datatracker.ietf.org/doc/html/rfc4122
+ */
+export const UUID = Schema.UUID.pipe(
+  FormatAnnotation.set(TypeFormat.UUID),
+  Schema.annotations({
+    [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],
+  }),
+);

package/src/internal/formats/types.ts

@@ -0,0 +1,186 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import type * as JSONSchema from 'effect/JSONSchema';
+import * as Option from 'effect/Option';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { createAnnotationHelper } from '../annotations';
+import { type JsonSchemaType } from '../json-schema';
+
+// TODO(burdon): Rename PropertyType.
+export type ScalarType =
+  | JSONSchema.JsonSchema7Object
+  | JSONSchema.JsonSchema7String
+  | JSONSchema.JsonSchema7Number
+  | JSONSchema.JsonSchema7Boolean
+  | JSONSchema.JsonSchema7Ref;
+
+// TODO(burdon): Rename ValueType and change to disciminated union.
+// export type ValueType = 'array' | 'object' | 'string' | 'number' | 'boolean' | 'ref';
+export enum TypeEnum {
+  Array = 'array', // TODO(burdon): Remove?
+  Object = 'object',
+  String = 'string',
+  Number = 'number',
+  Boolean = 'boolean',
+  Ref = 'ref',
+}
+
+// TODO(burdon): Ref?
+export const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {
+  switch (property.type) {
+    case 'array':
+      return TypeEnum.Array;
+    case 'object':
+      return TypeEnum.Object;
+    case 'string':
+      return TypeEnum.String;
+    case 'number':
+      return TypeEnum.Number;
+    case 'boolean':
+      return TypeEnum.Boolean;
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * https://json-schema.org/understanding-json-schema/reference/schema
+ * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
+ */
+export const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');
+
+export const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);
+
+/** @deprecated */
+export const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);
+
+// TODO(burdon): Rename Format; Change to discriminated union?
+export enum TypeFormat {
+  None = 'none',
+
+  //
+  // Scalar
+  //
+
+  String = 'string',
+  Number = 'number',
+  Boolean = 'boolean',
+  Ref = 'ref',
+
+  //
+  // { type: 'string' }
+  //
+
+  DID = 'did', // Users, etc.
+  DXN = 'dxn',
+  Email = 'email',
+  Formula = 'formula', // Spreadsheet formula.
+  Hostname = 'hostname',
+  JSON = 'json',
+  Markdown = 'markdown',
+  Regex = 'regex',
+  SingleSelect = 'single-select',
+  Text = 'text',
+  MultiSelect = 'multi-select',
+  URL = 'url',
+  UUID = 'uuid',
+
+  //
+  // { type: 'number' }
+  //
+
+  Currency = 'currency',
+  Integer = 'integer',
+  Percent = 'percent',
+  Timestamp = 'timestamp',
+
+  //
+  // { type: 'date' }
+  //
+
+  DateTime = 'date-time',
+  Date = 'date',
+  Time = 'time',
+  Duration = 'duration',
+
+  //
+  // { type: 'object' }
+  //
+
+  GeoPoint = 'lnglat',
+}
+
+export const FormatEnums = Object.values(TypeFormat).sort();
+
+export const PropertyKind = {
+  type: TypeEnum,
+  format: TypeFormat,
+};
+
+/**
+ * Default formats
+ */
+export const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {
+  [TypeEnum.String]: TypeFormat.String,
+  [TypeEnum.Number]: TypeFormat.Number,
+  [TypeEnum.Boolean]: TypeFormat.Boolean,
+};
+
+/**
+ * Map of format to type.
+ */
+export const formatToType: Record<TypeFormat, TypeEnum> = {
+  [TypeFormat.None]: undefined as any,
+  [TypeFormat.String]: TypeEnum.String,
+  [TypeFormat.Number]: TypeEnum.Number,
+  [TypeFormat.Boolean]: TypeEnum.Boolean,
+  [TypeFormat.Ref]: TypeEnum.Ref,
+
+  // Strings
+  [TypeFormat.DID]: TypeEnum.String,
+  [TypeFormat.DXN]: TypeEnum.String,
+  [TypeFormat.Email]: TypeEnum.String,
+  [TypeFormat.Formula]: TypeEnum.String,
+  [TypeFormat.Hostname]: TypeEnum.String,
+  [TypeFormat.JSON]: TypeEnum.String,
+  [TypeFormat.Markdown]: TypeEnum.String,
+  [TypeFormat.Regex]: TypeEnum.String,
+  [TypeFormat.URL]: TypeEnum.String,
+  [TypeFormat.UUID]: TypeEnum.String,
+  [TypeFormat.SingleSelect]: TypeEnum.String,
+  [TypeFormat.Text]: TypeEnum.String,
+  [TypeFormat.MultiSelect]: TypeEnum.Object,
+
+  // Dates
+  [TypeFormat.Date]: TypeEnum.String,
+  [TypeFormat.DateTime]: TypeEnum.String,
+  [TypeFormat.Duration]: TypeEnum.String,
+  [TypeFormat.Time]: TypeEnum.String,
+
+  // Numbers
+  [TypeFormat.Currency]: TypeEnum.Number,
+  [TypeFormat.Integer]: TypeEnum.Number,
+  [TypeFormat.Percent]: TypeEnum.Number,
+  [TypeFormat.Timestamp]: TypeEnum.Number,
+
+  // Objects
+  [TypeFormat.GeoPoint]: TypeEnum.Array,
+};
+
+/**
+ * Allowed value options for select.
+ */
+export const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');
+
+// TODO(wittjosiah): Reconcile with `SelectOption`.
+export type Options = string | number;
+export const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);
+
+/** @deprecated */
+export const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);

package/src/internal/index.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// TODO(burdon): Import directly (not part of ECHO API).
+export { JsonPath, JsonProp, getValue, setValue, splitJsonPath } from '@dxos/effect';
+
+export * from './annotations';
+export * from './entities';
+export * from './formats';
+export * from './json-schema';
+export * from './ref';
+export * from './types';
+
+// TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).
+export * from './object';
+export * from './proxy';
+export * from './schema';
+
+// export {
+//   createObject,
+//   createQueueDXN,
+//   isDeleted,
+//   objectFromJSON,
+//   objectToJSON,
+//   setRefResolverOnData,
+//   SchemaValidator,
+//   TypedObject,
+// } from './object';
+// export { makeObject } from './proxy';
+// export {
+//   type BaseSchema,
+//   EchoSchema,
+//   ImmutableSchema,
+//   RuntimeSchemaRegistry,
+//   PersistentSchema,
+//   isMutable,
+// } from './schema';

package/src/internal/json-schema/annotations.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../annotations';
+import { CurrencyAnnotationId, FormatAnnotationId } from '../formats';
+import { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../json-schema';
+
+//
+// This file configures annotations for JSON encoding/decoding.
+//
+
+// Go on the root level.
+type RootJsonSchemaProperty = keyof JsonSchemaType;
+
+// Go on the namespaced `annotations` property.
+type NamespacedJsonSchemaProperty = keyof JsonSchemaEchoAnnotations;
+
+/**
+ * List of annotations for JSON encoding/decoding.
+ * Omits default effect-schema annotations since they are encoded with default serializer.
+ */
+// TODO(burdon): Reconcile with `EchoAnnotations`.
+export const CustomAnnotations: Partial<Record<RootJsonSchemaProperty, symbol>> = {
+  format: FormatAnnotationId,
+  currency: CurrencyAnnotationId,
+};
+
+/**
+ * List of annotations for JSON decoding only.
+ * Includes default effect annotations.
+ */
+export const DecodedAnnotations: Partial<Record<RootJsonSchemaProperty, symbol>> = {
+  title: SchemaAST.TitleAnnotationId,
+  description: SchemaAST.DescriptionAnnotationId,
+};
+
+/**
+ * Annotations that go into ECHO namespace in json-schema.
+ */
+// TODO(dmaretskyi): Consider removing ECHO namespace and putting them at the top level.
+// TODO(dmaretskyi): Move to format.ts when circular imports are solved
+export const EchoAnnotations: Partial<Record<NamespacedJsonSchemaProperty, symbol>> = {
+  // TODO(dmaretskyi): `FieldLookupAnnotationId` might go here, but lets remove it entirely and use LabelAnnotation instead.
+  meta: PropertyMetaAnnotationId,
+  generator: GeneratorAnnotationId,
+  labelProp: LabelAnnotationId,
+};