@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/internal/{json → JsonSchema}/json-schema.test.ts

@@ -11,22 +11,22 @@ import { type JsonProp, findAnnotation } from '@dxos/effect';
 import { ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { Type } from '../..';
-import { Testing, prepareAstForCompare } from '../../testing';
+import { TestSchema, prepareAstForCompare } from '../../testing';
+import * as Type from '../../Type';
 import {
-  EntityKind,
   FieldLookupAnnotationId,
   GeneratorAnnotation,
   LabelAnnotation,
   PropertyMeta,
   getTypeAnnotation,
   getTypeIdentifierAnnotation,
-} from '../ast';
-import { Email, FormatAnnotation, FormatEnum } from '../formats';
-import { JsonSchemaType, getNormalizedEchoAnnotations, getSchemaProperty, setSchemaProperty } from '../json-schema';
-import { EchoObject } from '../object';
-import { Ref, createSchemaReference, getReferenceAst, getSchemaReference } from '../ref';
-import { StoredSchema } from '../schema';
+} from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { Email, FormatAnnotation, TypeFormat } from '../Format';
+import { JsonSchemaType, getNormalizedEchoAnnotations, getSchemaProperty, setSchemaProperty } from '../JsonSchema';
+import { Ref, createSchemaReference, getReferenceAst, getSchemaReference } from '../Ref';
+import { PersistentSchema } from '../Type';
+import { EntityKind } from '../common/types';
 
 import { toEffectSchema, toJsonSchema } from './json-schema';
 
@@ -35,13 +35,13 @@ const EXAMPLE_NAMESPACE = '@example';
 describe('effect-to-json', () => {
   test('type annotation', () => {
     const Test = Schema.Struct({ name: Schema.String }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
     const jsonSchema = toJsonSchema(Test);
-    expect((jsonSchema as any).$id).toEqual('dxn:type:example.com/type/Test');
+    expect((jsonSchema as any).$id).toEqual('dxn:type:com.example.type.test');
     expect((jsonSchema as any).version).toEqual('0.1.0');
   });
 
@@ -50,8 +50,8 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -63,16 +63,16 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/TestNested',
+      Type.object({
+        typename: 'com.example.type.testNested',
         version: '0.1.0',
       }),
     );
     const Test = Schema.Struct({
       name: Ref(Nested),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -88,16 +88,16 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/TestNested',
+      Type.object({
+        typename: 'com.example.type.testNested',
         version: '0.1.0',
       }),
     );
     const Test = Schema.Struct({
       name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -112,16 +112,16 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/TestNested',
+      Type.object({
+        typename: 'com.example.type.testNested',
         version: '0.1.0',
       }),
     );
     const Test = Schema.Struct({
       name: Schema.Array(Ref(Nested)),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -134,16 +134,16 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/TestNested',
+      Type.object({
+        typename: 'com.example.type.testNested',
         version: '0.1.0',
       }),
     );
     const Test = Schema.Struct({
       name: Schema.optional(Ref(Nested)),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Test',
+      Type.object({
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -159,24 +159,25 @@ describe('effect-to-json', () => {
   });
 
   test('annotations', () => {
-    const TestSchema = Schema.Struct({
+    const TempSchema = Schema.Struct({
       name: Schema.String.annotations({ description: 'Person name', title: 'Name' }),
-      email: Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email)).annotations({
+      email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)).annotations({
         description: 'Email address',
       }),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Person',
+      Type.object({
+        typename: 'com.example.type.person',
         version: '0.1.0',
       }),
     );
-    const jsonSchema = toJsonSchema(TestSchema);
+
+    const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).to.deep.eq({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:example.com/type/Person',
+      $id: 'dxn:type:com.example.type.person',
 
       entityKind: EntityKind.Object,
-      typename: 'example.com/type/Person',
+      typename: 'com.example.type.person',
       version: '0.1.0',
 
       type: 'object',
@@ -197,16 +198,26 @@ describe('effect-to-json', () => {
   });
 
   test('handles suspend -- Contact schema serialization', () => {
-    const schema = toJsonSchema(Testing.Person);
-    expect(Object.keys(schema.properties!)).toEqual(['id', 'name', 'username', 'email', 'tasks', 'address']);
+    const schema = toJsonSchema(TestSchema.Person);
+    expect(Object.keys(schema.properties!)).toEqual([
+      'id',
+      'name',
+      'username',
+      'email',
+      'age',
+      'tasks',
+      'employer',
+      'address',
+      'fields',
+    ]);
   });
 
   test('reference property by ref', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Organization',
+      Type.object({
+        typename: 'com.example.type.organization',
         version: '0.1.0',
       }),
     );
@@ -215,8 +226,8 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Person',
+      Type.object({
+        typename: 'com.example.type.person',
         version: '0.1.0',
       }),
     );
@@ -226,10 +237,10 @@ describe('effect-to-json', () => {
     const jsonSchema = toJsonSchema(Contact);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:example.com/type/Person',
+      $id: 'dxn:type:com.example.type.person',
 
       entityKind: EntityKind.Object,
-      typename: 'example.com/type/Person',
+      typename: 'com.example.type.person',
       version: '0.1.0',
 
       type: 'object',
@@ -249,7 +260,7 @@ describe('effect-to-json', () => {
               $ref: '/schemas/echo/ref',
               reference: {
                 schema: {
-                  $ref: 'dxn:type:example.com/type/Organization',
+                  $ref: 'dxn:type:com.example.type.organization',
                 },
                 schemaVersion: '0.1.0',
               },
@@ -267,8 +278,8 @@ describe('effect-to-json', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Organization',
+      Type.object({
+        typename: 'com.example.type.organization',
         version: '0.1.0',
       }),
     );
@@ -277,8 +288,8 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
-        typename: 'example.com/type/Person',
+      Type.object({
+        typename: 'com.example.type.person',
         version: '0.1.0',
       }),
     );
@@ -289,8 +300,8 @@ describe('effect-to-json', () => {
     expect(typename).to.eq(Organization.typename);
   });
 
-  test('serialize circular schema (StoredSchema)', () => {
-    const jsonSchema = toJsonSchema(StoredSchema);
+  test('serialize circular schema (PersistentSchema)', () => {
+    const jsonSchema = toJsonSchema(PersistentSchema);
     expect(Object.keys(jsonSchema.properties!).length).toBeGreaterThan(0);
 
     // TODO(dmaretskyi): Currently unable to deserialize.
@@ -313,7 +324,7 @@ describe('effect-to-json', () => {
 
   test('reference with title annotation', () => {
     const schema = Schema.Struct({
-      contact: Ref(Testing.Person).annotations({ title: 'Custom Title' }),
+      contact: Ref(TestSchema.Person).annotations({ title: 'Custom Title' }),
     });
 
     // log.info('schema before', { ast: schema.ast });
@@ -336,33 +347,36 @@ describe('effect-to-json', () => {
   });
 
   test('relation schema', () => {
-    const schema = Testing.HasManager;
+    const schema = TestSchema.EmployedBy;
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
-      $id: 'dxn:type:example.com/type/HasManager',
+      $id: 'dxn:type:com.example.type.employed-by',
       $schema: 'http://json-schema.org/draft-07/schema#',
       entityKind: 'relation',
-      typename: 'example.com/type/HasManager',
+      typename: 'com.example.type.employed-by',
       version: '0.1.0',
       relationSource: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:example.com/type/Person',
+        $ref: 'dxn:type:com.example.type.person',
       },
       relationTarget: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:example.com/type/Person',
+        $ref: 'dxn:type:com.example.type.organization',
       },
       type: 'object',
       properties: {
         id: {
           type: 'string',
         },
+        role: {
+          type: 'string',
+        },
         since: {
           type: 'string',
         },
       },
-      propertyOrder: ['since', 'id'],
-      required: ['id'],
+      propertyOrder: ['role', 'since', 'id'],
+      required: ['role', 'id'],
       additionalProperties: false,
     });
   });
@@ -372,8 +386,8 @@ describe('effect-to-json', () => {
       id: ObjectId,
       name: Schema.String,
     }).pipe(
-      EchoObject({
-        typename: 'example.com/type/Organization',
+      EchoObjectSchema({
+        typename: 'com.example.type.organization',
         version: '0.1.0',
       }),
       LabelAnnotation.set(['name']),
@@ -381,9 +395,9 @@ describe('effect-to-json', () => {
 
     const jsonSchema = toJsonSchema(Organization);
     expect(jsonSchema).toEqual({
-      $id: 'dxn:type:example.com/type/Organization',
+      $id: 'dxn:type:com.example.type.organization',
       $schema: 'http://json-schema.org/draft-07/schema#',
-      typename: 'example.com/type/Organization',
+      typename: 'com.example.type.organization',
       version: '0.1.0',
       entityKind: 'object',
       type: 'object',
@@ -454,7 +468,7 @@ describe('effect-to-json', () => {
   const expectReferenceAnnotation = (object: JsonSchemaType) => {
     expect(object.reference).to.deep.eq({
       schema: {
-        $ref: 'dxn:type:example.com/type/TestNested',
+        $ref: 'dxn:type:com.example.type.testNested',
       },
       schemaVersion: '0.1.0',
     });
@@ -482,8 +496,8 @@ describe('json-to-effect', () => {
       const Organization = Schema.Struct({
         field: Schema.String,
       }).pipe(
-        Type.Obj({
-          typename: 'example.com/type/Organization',
+        Type.object({
+          typename: 'com.example.type.organization',
           version: '0.1.0',
         }),
       );
@@ -498,13 +512,13 @@ describe('json-to-effect', () => {
         object: Schema.Struct({ id: Schema.String, field: Ref(Organization) }),
         echoObject: Ref(Organization),
         echoObjectArray: Schema.Array(Ref(Organization)),
-        email: Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email)),
+        email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)),
         null: Schema.Null,
       } as const;
 
       const Test = (partial ? Schema.partial(Schema.Struct(fields)) : Schema.Struct(fields)).pipe(
-        Type.Obj({
-          typename: 'example.com/type/Test',
+        Type.object({
+          typename: 'com.example.type.test',
           version: '0.1.0',
         }),
       );
@@ -531,13 +545,13 @@ describe('json-to-effect', () => {
 
   test('legacy schema with dxn:type $id gets decoded', () => {
     const jsonSchema: JsonSchemaType = {
-      $id: 'dxn:type:example.com/type/Project',
+      $id: 'dxn:type:com.example.type.project',
       $schema: 'http://json-schema.org/draft-07/schema#',
       additionalProperties: false,
       echo: {
         type: {
           schemaId: '01JERV1HQCQZDQ4NVCJ42QB38F',
-          typename: 'example.com/type/Project',
+          typename: 'com.example.type.project',
           version: '0.1.0',
         },
       },
@@ -563,15 +577,15 @@ describe('json-to-effect', () => {
     const schema = toEffectSchema(jsonSchema);
     expect(getTypeAnnotation(schema)).to.deep.eq({
       kind: EntityKind.Object,
-      typename: 'example.com/type/Project',
+      typename: 'com.example.type.project',
       version: '0.1.0',
     });
     expect(getTypeIdentifierAnnotation(schema)).to.deep.eq('dxn:echo:@:01JERV1HQCQZDQ4NVCJ42QB38F');
   });
 
   test('symbol annotations get compared', () => {
-    const schema1 = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email));
-    const schema2 = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Currency));
+    const schema1 = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email));
+    const schema2 = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Currency));
     expect(prepareAstForCompare(schema1.ast)).not.to.deep.eq(prepareAstForCompare(schema2.ast));
   });
 
@@ -586,7 +600,7 @@ describe('json-to-effect', () => {
   });
 
   test('relation schema roundtrip', () => {
-    const schema = Testing.HasManager;
+    const schema = TestSchema.HasManager;
     const jsonSchema = toJsonSchema(schema);
     const effectSchema = toEffectSchema(jsonSchema);
     expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(schema.ast));
@@ -689,10 +703,8 @@ describe('json-to-effect', () => {
   });
 
   test('schema with optional referece', () => {
-    const TestSchema = Schema.Struct({
-      contact: Schema.optional(Ref(Testing.Person)),
-    });
-    const jsonSchema = toJsonSchema(TestSchema);
+    const TempSchema = Schema.Struct({ contact: Schema.optional(Ref(TestSchema.Person)) });
+    const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "$schema": "http://json-schema.org/draft-07/schema#",
@@ -703,7 +715,7 @@ describe('json-to-effect', () => {
             "$ref": "/schemas/echo/ref",
             "reference": {
               "schema": {
-                "$ref": "dxn:type:example.com/type/Person",
+                "$ref": "dxn:type:com.example.type.person",
               },
               "schemaVersion": "0.1.0",
             },
@@ -718,13 +730,13 @@ describe('json-to-effect', () => {
     `);
 
     const effectSchema = toEffectSchema(jsonSchema);
-    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(TestSchema.ast));
+    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(TempSchema.ast));
   });
 
   test('object nested inside another struct', () => {
     const Contact = Schema.Struct({
       name: Schema.String,
-    }).pipe(EchoObject({ typename: 'example.com/type/Person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema({ typename: 'com.example.type.person', version: '0.1.0' }));
     const input = Schema.Struct({
       contact: Contact,
     });
@@ -735,7 +747,7 @@ describe('json-to-effect', () => {
         "additionalProperties": false,
         "properties": {
           "contact": {
-            "$id": "dxn:type:example.com/type/Person",
+            "$id": "dxn:type:com.example.type.person",
             "additionalProperties": false,
             "entityKind": "object",
             "properties": {
@@ -755,7 +767,7 @@ describe('json-to-effect', () => {
               "id",
             ],
             "type": "object",
-            "typename": "example.com/type/Person",
+            "typename": "com.example.type.person",
             "version": "0.1.0",
           },
         },
@@ -776,7 +788,7 @@ describe('json-to-effect', () => {
 
 describe('reference', () => {
   test('reference annotation', () => {
-    const schema = Ref(Testing.Person);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $id: '/schemas/echo/ref',
@@ -784,7 +796,7 @@ describe('reference', () => {
       $schema: 'http://json-schema.org/draft-07/schema#',
       reference: {
         schema: {
-          $ref: 'dxn:type:example.com/type/Person',
+          $ref: 'dxn:type:com.example.type.person',
         },
         schemaVersion: '0.1.0',
       },
@@ -792,7 +804,7 @@ describe('reference', () => {
   });
 
   test('title annotation', () => {
-    const schema = Ref(Testing.Person).annotations({ title: 'My custom title' });
+    const schema = Ref(TestSchema.Person).annotations({ title: 'My custom title' });
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
@@ -802,7 +814,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:example.com/type/Person',
+              $ref: 'dxn:type:com.example.type.person',
             },
             schemaVersion: '0.1.0',
           },
@@ -813,7 +825,7 @@ describe('reference', () => {
   });
 
   test('description annotation', () => {
-    const schema = Ref(Testing.Person).annotations({ description: 'My custom description' });
+    const schema = Ref(TestSchema.Person).annotations({ description: 'My custom description' });
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
@@ -823,7 +835,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:example.com/type/Person',
+              $ref: 'dxn:type:com.example.type.person',
             },
             schemaVersion: '0.1.0',
           },
@@ -837,13 +849,13 @@ describe('reference', () => {
   });
 
   test('serialize and deserialize', () => {
-    const schema = Ref(Testing.Person);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     const deserializedSchema = toEffectSchema(jsonSchema);
     const refAst = getReferenceAst(deserializedSchema.ast);
     expect(refAst).toEqual({
-      typename: Testing.Person.typename,
-      version: Testing.Person.version,
+      typename: TestSchema.Person.typename,
+      version: TestSchema.Person.version,
     });
   });
 });

package/src/internal/{json → JsonSchema}/json-schema.ts

@@ -17,19 +17,23 @@ import { DXN, ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { clearUndefined, orderKeys, removeProperties } from '@dxos/util';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../ast';
-import { EntityKind, EntityKindSchema } from '../ast';
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  TypeIdentifierAnnotationId,
+  makeTypeJsonSchemaAnnotation,
+} from '../Annotation';
+import { type JsonSchemaReferenceInfo, createEchoReferenceSchema } from '../Ref';
+import { ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION, EntityKind, EntityKindSchema } from '../common/types';
+
+import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
 import {
   ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
   ECHO_ANNOTATIONS_NS_KEY,
   type JsonSchemaEchoAnnotations,
   type JsonSchemaType,
   getNormalizedEchoAnnotations,
-} from '../json-schema';
-import { Expando, makeTypeJsonSchemaAnnotation } from '../object';
-import { type JsonSchemaReferenceInfo, Ref, createEchoReferenceSchema } from '../ref';
-
-import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
+} from './json-schema-type';
 
 // TODO(burdon): Are these values stored (can they be changed?)
 export enum PropType {
@@ -71,9 +75,16 @@ export type JsonSchemaOptions = {
 
 /**
  * Convert effect schema to JSON Schema.
+ * NOTE: This handles custom annotations.
  * @param schema
  */
-export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptions = {}): JsonSchemaType => {
+// TODO(burdon): Reconcile with possibly extending @effect/Schema/JSONSchema
+//  We add additional propertyOrder (but the object properties ARE ordered); and type "string" for literals.
+// TODO(wittjosiah): This is mutable because its a pojo, perhaps should be left as readonly at type level though?
+export const toJsonSchema = (
+  schema: Schema.Schema.All,
+  options: JsonSchemaOptions = {},
+): Types.DeepMutable<JsonSchemaType> => {
   assertArgument(Schema.isSchema(schema), 'schema');
   let jsonSchema = _toJsonSchemaAST(schema.ast);
   if (options.strict) {
@@ -96,11 +107,11 @@ export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptio
   return jsonSchema;
 };
 
-const _toJsonSchemaAST = (ast: SchemaAST.AST): JsonSchemaType => {
+const _toJsonSchemaAST = (ast: SchemaAST.AST): Types.DeepMutable<JsonSchemaType> => {
   const withRefinements = withEchoRefinements(ast, '#');
   const jsonSchema = JSONSchema.fromAST(withRefinements, {
     definitions: {},
-  }) as JsonSchemaType;
+  }) as Types.DeepMutable<JsonSchemaType>;
 
   return normalizeJsonSchema(jsonSchema);
 };
@@ -319,7 +330,7 @@ const objectToEffectSchema = (root: JsonSchemaType, defs: JsonSchemaType['$defs'
   }
 
   if (immutableIdField) {
-    schema = Schema.extend(Schema.mutable(schema), Schema.Struct({ id: immutableIdField }));
+    schema = Schema.extend(schema, Schema.Struct({ id: immutableIdField }));
   }
 
   const annotations = jsonSchemaFieldsToAnnotations(root);
@@ -344,8 +355,10 @@ const anyToEffectSchema = (root: JSONSchema.JsonSchema7Any): Schema.Schema.AnyNo
 // TODO(dmaretskyi): Types.
 const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
   if (!('reference' in root)) {
-    return Ref(Expando);
+    // Fallback to generic object ref when no reference info is provided.
+    return createEchoReferenceSchema(undefined, ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION);
   }
+
   const reference: JsonSchemaReferenceInfo = root.reference;
   if (typeof reference !== 'object') {
     throw new Error('Invalid reference field in ref schema');
@@ -368,7 +381,7 @@ const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
 const annotations_toJsonSchemaFields = (annotations: SchemaAST.Annotations): Record<symbol, any> => {
   const schemaFields: Record<string, any> = {};
 
-  const echoAnnotations: JsonSchemaEchoAnnotations = {};
+  const echoAnnotations: Types.Mutable<JsonSchemaEchoAnnotations> = {};
   for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
     if (annotations[annotationId] != null) {
       echoAnnotations[key as keyof JsonSchemaEchoAnnotations] = annotations[annotationId] as any;
@@ -452,11 +465,13 @@ const jsonSchemaFieldsToAnnotations = (schema: JsonSchemaType): SchemaAST.Annota
     }
   }
 
-  annotations[TypeIdentifierAnnotationId] = decodeTypeIdentifierAnnotation(schema);
+  const typeIdentifier = decodeTypeIdentifierAnnotation(schema);
+  annotations[TypeIdentifierAnnotationId] = typeIdentifier;
   const typeAnnotation = decodeTypeAnnotation(schema);
   if (typeAnnotation) {
     annotations[TypeAnnotationId] = typeAnnotation;
     annotations[SchemaAST.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
+      identifier: typeIdentifier,
       kind: typeAnnotation.kind,
       typename: typeAnnotation.typename,
       version: typeAnnotation.version,
@@ -486,7 +501,7 @@ const addJsonSchemaFields = (ast: SchemaAST.AST, schema: JsonSchemaType): Schema
  * Fixes field order.
  * Sets `$schema` prop.
  */
-const normalizeJsonSchema = (jsonSchema: JsonSchemaType): JsonSchemaType => {
+const normalizeJsonSchema = (jsonSchema: Types.DeepMutable<JsonSchemaType>): Types.DeepMutable<JsonSchemaType> => {
   if (jsonSchema.properties && 'id' in jsonSchema.properties) {
     jsonSchema.properties = orderKeys(jsonSchema.properties, ['id']); // Put id first.
   }