@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.ef1bc66f44

package/src/internal/formats/string.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';
 
 /**
  * Email address (RFC 5321)
@@ -13,7 +13,7 @@ import { FormatAnnotation, FormatEnum } from './types';
  */
 export const Email = Schema.String.pipe(
   Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/),
-  FormatAnnotation.set(FormatEnum.Email),
+  FormatAnnotation.set(TypeFormat.Email),
   Schema.annotations({
     title: 'Email',
     description: 'Email address',
@@ -24,25 +24,25 @@ export const Email = Schema.String.pipe(
  *
  */
 // TODO(burdon): Implement.
-export const Formula = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Formula));
+export const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Hostname = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Hostname));
+export const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const JSON = Schema.String.pipe(FormatAnnotation.set(FormatEnum.JSON));
+export const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markdown));
+export const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
 
 /**
  * Regex
@@ -50,14 +50,19 @@ export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markd
  * https://ecma-international.org/publications-and-standards/standards/ecma-262
  */
 // TODO(burdon): Implement.
-export const Regex = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Regex));
+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(FormatEnum.URL),
+  FormatAnnotation.set(TypeFormat.URL),
   Schema.annotations({
     title: 'URL',
     description: 'URL',
@@ -69,7 +74,7 @@ export const URL = Schema.String.pipe(
  * https://datatracker.ietf.org/doc/html/rfc4122
  */
 export const UUID = Schema.UUID.pipe(
-  FormatAnnotation.set(FormatEnum.UUID),
+  FormatAnnotation.set(TypeFormat.UUID),
   Schema.annotations({
     [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],
   }),

package/src/internal/formats/types.ts

@@ -7,7 +7,7 @@ import type * as JSONSchema from 'effect/JSONSchema';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { createAnnotationHelper } from '../ast';
+import { createAnnotationHelper } from '../annotations';
 import { type JsonSchemaType } from '../json-schema';
 
 // TODO(burdon): Rename PropertyType.
@@ -53,14 +53,20 @@ export const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {
  */
 export const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');
 
-export const FormatAnnotation = createAnnotationHelper<FormatEnum>(FormatAnnotationId);
+export const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);
 
-export const getFormatAnnotation = (node: SchemaAST.AST): FormatEnum | undefined =>
-  Function.pipe(SchemaAST.getAnnotation<FormatEnum>(FormatAnnotationId)(node), Option.getOrUndefined);
+/** @deprecated */
+export const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);
 
-// TODO(burdon): Rename to FormatType and change to discriminated union.
-export enum FormatEnum {
+// TODO(burdon): Rename Format; Change to discriminated union?
+export enum TypeFormat {
   None = 'none',
+
+  //
+  // Scalar
+  //
+
   String = 'string',
   Number = 'number',
   Boolean = 'boolean',
@@ -79,6 +85,7 @@ export enum FormatEnum {
   Markdown = 'markdown',
   Regex = 'regex',
   SingleSelect = 'single-select',
+  Text = 'text',
   MultiSelect = 'multi-select',
   URL = 'url',
   UUID = 'uuid',
@@ -108,60 +115,61 @@ export enum FormatEnum {
   GeoPoint = 'lnglat',
 }
 
-export const FormatEnums = Object.values(FormatEnum).sort();
+export const FormatEnums = Object.values(TypeFormat).sort();
 
 export const PropertyKind = {
   type: TypeEnum,
-  format: FormatEnum,
+  format: TypeFormat,
 };
 
 /**
  * Default formats
  */
-export const typeToFormat: Partial<Record<TypeEnum, FormatEnum>> = {
-  [TypeEnum.String]: FormatEnum.String,
-  [TypeEnum.Number]: FormatEnum.Number,
-  [TypeEnum.Boolean]: FormatEnum.Boolean,
+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<FormatEnum, TypeEnum> = {
-  [FormatEnum.None]: undefined as any,
-  [FormatEnum.String]: TypeEnum.String,
-  [FormatEnum.Number]: TypeEnum.Number,
-  [FormatEnum.Boolean]: TypeEnum.Boolean,
-  [FormatEnum.Ref]: TypeEnum.Ref,
+export const formatToType: Record<TypeFormat, TypeEnum> = {
+  [TypeFormat.None]: TypeEnum.String,
+  [TypeFormat.String]: TypeEnum.String,
+  [TypeFormat.Number]: TypeEnum.Number,
+  [TypeFormat.Boolean]: TypeEnum.Boolean,
+  [TypeFormat.Ref]: TypeEnum.Ref,
 
   // Strings
-  [FormatEnum.DID]: TypeEnum.String,
-  [FormatEnum.DXN]: TypeEnum.String,
-  [FormatEnum.Email]: TypeEnum.String,
-  [FormatEnum.Formula]: TypeEnum.String,
-  [FormatEnum.Hostname]: TypeEnum.String,
-  [FormatEnum.JSON]: TypeEnum.String,
-  [FormatEnum.Markdown]: TypeEnum.String,
-  [FormatEnum.Regex]: TypeEnum.String,
-  [FormatEnum.URL]: TypeEnum.String,
-  [FormatEnum.UUID]: TypeEnum.String,
-  [FormatEnum.SingleSelect]: TypeEnum.String,
-  [FormatEnum.MultiSelect]: TypeEnum.Object,
+  [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
-  [FormatEnum.Date]: TypeEnum.String,
-  [FormatEnum.DateTime]: TypeEnum.String,
-  [FormatEnum.Duration]: TypeEnum.String,
-  [FormatEnum.Time]: TypeEnum.String,
+  [TypeFormat.Date]: TypeEnum.String,
+  [TypeFormat.DateTime]: TypeEnum.String,
+  [TypeFormat.Duration]: TypeEnum.String,
+  [TypeFormat.Time]: TypeEnum.String,
 
   // Numbers
-  [FormatEnum.Currency]: TypeEnum.Number,
-  [FormatEnum.Integer]: TypeEnum.Number,
-  [FormatEnum.Percent]: TypeEnum.Number,
-  [FormatEnum.Timestamp]: TypeEnum.Number,
+  [TypeFormat.Currency]: TypeEnum.Number,
+  [TypeFormat.Integer]: TypeEnum.Number,
+  [TypeFormat.Percent]: TypeEnum.Number,
+  [TypeFormat.Timestamp]: TypeEnum.Number,
 
   // Objects
-  [FormatEnum.GeoPoint]: TypeEnum.Array,
+  [TypeFormat.GeoPoint]: TypeEnum.Array,
 };
 
 /**
@@ -169,7 +177,10 @@ export const formatToType: Record<FormatEnum, TypeEnum> = {
  */
 export const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');
 
-export const getOptionsAnnotation = (node: SchemaAST.AST): OptionsAnnotationType[] | undefined =>
-  Function.pipe(SchemaAST.getAnnotation<OptionsAnnotationType[]>(OptionsAnnotationId)(node), Option.getOrUndefined);
+// TODO(wittjosiah): Reconcile with `SelectOption`.
+export type Options = string | number;
+export const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);
 
-export type OptionsAnnotationType = string | number;
+/** @deprecated */
+export const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);

package/src/internal/index.ts

@@ -2,21 +2,38 @@
 // Copyright 2024 DXOS.org
 //
 
-export { JsonPath, splitJsonPath, JsonProp } from '@dxos/effect';
+// TODO(burdon): Import directly (not part of ECHO API).
+export { JsonPath, JsonProp, getValue, splitJsonPath } from '@dxos/effect';
 
-// TODO(dmaretskyi): Remove.
-export { ObjectId } from '@dxos/keys';
-export { ForeignKey } from '@dxos/echo-protocol';
-
-export * from './ast';
+export * from './annotations';
+export * from './api';
+export * from './entities';
 export * from './formats';
-export * from './json';
 export * from './json-schema';
-export * from './object';
-export * from './types';
-export { defineHiddenProperty } from '@dxos/live-object';
 export * from './ref';
-export * from './projection';
+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';
-// TODO(dmaretskyi): Remove
-export { live } from './proxy/reactive-object';
+
+// 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 → json-schema}/annotations.ts

@@ -4,7 +4,7 @@
 
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../ast';
+import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../annotations';
 import { CurrencyAnnotationId, FormatAnnotationId } from '../formats';
 import { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../json-schema';
 

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

@@ -2,5 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './annotations';
 export * from './json-schema-normalize';
 export * from './json-schema-type';
+export * from './json-schema';

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

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+import type * as Types from 'effect/Types';
+
 import { JsonSchemaFields, type JsonSchemaType } from './json-schema-type';
 
 /**
@@ -9,12 +11,12 @@ import { JsonSchemaFields, type JsonSchemaType } from './json-schema-type';
  * Note: the input type does not necessarily match the {@link JsonSchemaType} type.
  */
 export const normalizeSchema = (schema: JsonSchemaType): JsonSchemaType => {
-  const copy = structuredClone(schema);
+  const copy = structuredClone(schema) as Types.DeepMutable<JsonSchemaType>;
   go(copy);
   return copy;
 };
 
-const go = (schema: JsonSchemaType) => {
+const go = (schema: Types.DeepMutable<JsonSchemaType>) => {
   if (typeof schema !== 'object' || schema === null) {
     return;
   }

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

@@ -6,8 +6,9 @@ import * as Schema from 'effect/Schema';
 
 import { JsonPath, type JsonProp } from '@dxos/effect';
 
-import { EntityKindSchema } from '../ast';
-import { FormatAnnotation, FormatEnum } from '../formats';
+import { FormatAnnotation, TypeFormat } from '../formats';
+import { type Mutable } from '../proxy';
+import { EntityKindSchema } from '../types';
 
 //
 // JSON Schema
@@ -18,7 +19,7 @@ const SimpleTypes = Schema.Literal('array', 'boolean', 'integer', 'null', 'numbe
 
 const NonNegativeInteger = Schema.Number.pipe(Schema.greaterThanOrEqualTo(0));
 
-const StringArray = Schema.Array(Schema.String).pipe(Schema.mutable);
+const StringArray = Schema.Array(Schema.String);
 
 const JsonSchemaOrBoolean = Schema.Union(
   Schema.suspend(() => JsonSchemaType),
@@ -48,13 +49,13 @@ export const JsonSchemaEchoAnnotations = Schema.Struct({
     Schema.Record({
       key: Schema.String,
       value: Schema.Any,
-    }).pipe(Schema.mutable),
+    }),
   ),
 
   /**
    * @deprecated
    */
-  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe
+  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe.
   type: Schema.optional(
     Schema.Struct({
       typename: Schema.String,
@@ -62,7 +63,7 @@ export const JsonSchemaEchoAnnotations = Schema.Struct({
 
       // Not used.
       schemaId: Schema.optional(Schema.String),
-    }).pipe(Schema.mutable),
+    }),
   ),
 
   /**
@@ -72,9 +73,9 @@ export const JsonSchemaEchoAnnotations = Schema.Struct({
     Schema.Record({
       key: Schema.String,
       value: Schema.Any,
-    }).pipe(Schema.mutable),
+    }),
   ),
-}).pipe(Schema.mutable);
+});
 export type JsonSchemaEchoAnnotations = Schema.Schema.Type<typeof JsonSchemaEchoAnnotations>;
 
 /**
@@ -206,7 +207,7 @@ const _JsonSchemaType = Schema.Struct({
   /**
    * Regex pattern for strings.
    */
-  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(FormatEnum.Regex))),
+  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex))),
 
   /**
    * Serialized from {@link FormatAnnotationId}.
@@ -257,23 +258,21 @@ const _JsonSchemaType = Schema.Struct({
     Schema.Record({
       key: Schema.String,
       value: Schema.suspend(() => JsonSchemaType),
-    }).pipe(Schema.mutable),
+    }),
   ),
   patternProperties: Schema.optional(
     Schema.Record({
       key: Schema.String,
       value: Schema.suspend(() => JsonSchemaType),
-    }).pipe(Schema.mutable),
+    }),
   ),
   propertyNames: Schema.optional(Schema.suspend(() => JsonSchemaType)),
 
   definitions: Schema.optional(
-    Schema.mutable(
-      Schema.Record({
-        key: Schema.String,
-        value: Schema.suspend(() => JsonSchemaType),
-      }),
-    ),
+    Schema.Record({
+      key: Schema.String,
+      value: Schema.suspend(() => JsonSchemaType),
+    }),
   ),
   dependencies: Schema.optional(
     Schema.Record({
@@ -296,12 +295,10 @@ const _JsonSchemaType = Schema.Struct({
   oneOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),
   not: Schema.optional(Schema.suspend(() => JsonSchemaType)),
   $defs: Schema.optional(
-    Schema.mutable(
-      Schema.Record({
-        key: Schema.String,
-        value: Schema.suspend(() => JsonSchemaType),
-      }),
-    ),
+    Schema.Record({
+      key: Schema.String,
+      value: Schema.suspend(() => JsonSchemaType),
+    }),
   ),
 
   //
@@ -311,25 +308,23 @@ const _JsonSchemaType = Schema.Struct({
   currency: Schema.optional(Schema.String),
 
   reference: Schema.optional(
-    Schema.mutable(
-      Schema.Struct({
-        schema: Schema.suspend(() => JsonSchemaType),
-        schemaVersion: Schema.optional(Schema.String),
-        schemaObject: Schema.optional(Schema.String),
-      }),
-    ),
+    Schema.Struct({
+      schema: Schema.suspend(() => JsonSchemaType),
+      schemaVersion: Schema.optional(Schema.String),
+      schemaObject: Schema.optional(Schema.String),
+    }),
   ),
 
   /**
    * ECHO-specific annotations.
    */
   // TODO(dmaretskyi): Since we are adding a lot of new extensions to the JSON Schema, it is safer to namespace them here.
-  annotations: Schema.optional(Schema.mutable(JsonSchemaEchoAnnotations)),
+  annotations: Schema.optional(JsonSchemaEchoAnnotations),
 
   /**
    * @deprecated Use `annotations` instead.
    */
-  echo: Schema.optional(Schema.mutable(JsonSchemaEchoAnnotations)),
+  echo: Schema.optional(JsonSchemaEchoAnnotations),
 }).annotations({ identifier: 'jsonSchema', description: 'JSON Schema' });
 
 export const JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
@@ -337,9 +332,10 @@ export const JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
 /**
  * https://json-schema.org/draft-07/schema
  */
-export interface JsonSchemaType extends Schema.Schema.Type<Schema.mutable<typeof _JsonSchemaType>> {}
+// TODO(burdon): Reconcile with @effect/Schema/JSONSchema
+export interface JsonSchemaType extends Schema.Schema.Type<typeof _JsonSchemaType> {}
 
-export const JsonSchemaType: Schema.Schema<JsonSchemaType> = _JsonSchemaType.pipe(Schema.mutable);
+export const JsonSchemaType: Schema.Schema<JsonSchemaType> = _JsonSchemaType;
 
 // TODO(burdon): Factor out JSON schema utils.
 
@@ -348,7 +344,11 @@ export const getSchemaProperty = (schema: JsonSchemaType, property: JsonProp): J
 };
 
 // TODO(burdon): Properties should be ordered.
-export const setSchemaProperty = (schema: JsonSchemaType, property: JsonProp, value: JsonSchemaType) => {
+export const setSchemaProperty = (
+  schema: Mutable<JsonSchemaType>,
+  property: JsonProp,
+  value: Mutable<JsonSchemaType>,
+) => {
   schema.properties ??= {};
   schema.properties[property] = value;
   return schema;