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

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 './projection';
-// TODO(dmaretskyi): Remove
-export { live } from './proxy/reactive-object';
 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 → 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;

package/src/internal/{json → json-schema}/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';
+} from '../annotations';
+import { EchoObjectSchema } from '../entities';
+import { Email, FormatAnnotation, TypeFormat } 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';
+import { PersistentSchema } from '../schema';
+import { EntityKind } from '../types';
 
 import { toEffectSchema, toJsonSchema } from './json-schema';
 
@@ -35,7 +35,7 @@ const EXAMPLE_NAMESPACE = '@example';
 describe('effect-to-json', () => {
   test('type annotation', () => {
     const Test = Schema.Struct({ name: Schema.String }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -50,7 +50,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -63,7 +63,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -71,7 +71,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Ref(Nested),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -88,7 +88,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -96,7 +96,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -112,7 +112,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -120,7 +120,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.Array(Ref(Nested)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -134,7 +134,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -142,7 +142,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.optional(Ref(Nested)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -159,18 +159,19 @@ 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({
+      Type.object({
         typename: 'example.com/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',
@@ -197,15 +198,25 @@ 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({
+      Type.object({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -215,7 +226,7 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Person',
         version: '0.1.0',
       }),
@@ -267,7 +278,7 @@ describe('effect-to-json', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -277,7 +288,7 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/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,13 +347,13 @@ 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:example.com/type/EmployedBy',
       $schema: 'http://json-schema.org/draft-07/schema#',
       entityKind: 'relation',
-      typename: 'example.com/type/HasManager',
+      typename: 'example.com/type/EmployedBy',
       version: '0.1.0',
       relationSource: {
         // TODO(dmaretskyi): Should those point to specific schema version?
@@ -350,19 +361,22 @@ describe('effect-to-json', () => {
       },
       relationTarget: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:example.com/type/Person',
+        $ref: 'dxn:type:example.com/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,7 +386,7 @@ describe('effect-to-json', () => {
       id: ObjectId,
       name: Schema.String,
     }).pipe(
-      EchoObject({
+      EchoObjectSchema({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -482,7 +496,7 @@ describe('json-to-effect', () => {
       const Organization = Schema.Struct({
         field: Schema.String,
       }).pipe(
-        Type.Obj({
+        Type.object({
           typename: 'example.com/type/Organization',
           version: '0.1.0',
         }),
@@ -498,12 +512,12 @@ 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({
+        Type.object({
           typename: 'example.com/type/Test',
           version: '0.1.0',
         }),
@@ -570,8 +584,8 @@ describe('json-to-effect', () => {
   });
 
   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#",
@@ -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: 'example.com/type/Person', version: '0.1.0' }));
     const input = Schema.Struct({
       contact: Contact,
     });
@@ -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',
@@ -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#',
@@ -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#',
@@ -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,
     });
   });
 });