@dxos/echo 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

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

@@ -11,21 +11,22 @@ import { type JsonProp, findAnnotation } from '@dxos/effect';
 import { ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
+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, TypedObject } from '../object';
 import { Ref, createSchemaReference, getReferenceAst, getSchemaReference } from '../ref';
-import { StoredSchema } from '../schema';
-import { Testing, prepareAstForCompare } from '../testing';
+import { PersistentSchema } from '../schema';
+import { EntityKind } from '../types';
 
 import { toEffectSchema, toJsonSchema } from './json-schema';
 
@@ -33,10 +34,12 @@ const EXAMPLE_NAMESPACE = '@example';
 
 describe('effect-to-json', () => {
   test('type annotation', () => {
-    class Test extends TypedObject({
-      typename: 'example.com/type/Test',
-      version: '0.1.0',
-    })({ name: Schema.String }) {}
+    const Test = Schema.Struct({ name: Schema.String }).pipe(
+      Type.Obj({
+        typename: 'example.com/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).version).toEqual('0.1.0');
@@ -44,23 +47,35 @@ describe('effect-to-json', () => {
 
   test('property meta annotation', () => {
     const meta = { maxLength: 0 };
-    class Test extends TypedObject({
-      typename: 'example.com/type/Test',
-      version: '0.1.0',
-    })({
+    const Test = Schema.Struct({
       name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Test',
+        version: '0.1.0',
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     expect(getNormalizedEchoAnnotations(jsonSchema.properties!.name!)!.meta![EXAMPLE_NAMESPACE]).to.deep.eq(meta);
   });
 
   test('reference annotation', () => {
-    class Nested extends TypedObject({ typename: 'example.com/type/TestNested', version: '0.1.0' })({
+    const Nested = Schema.Struct({
       name: Schema.String,
-    }) {}
-    class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/TestNested',
+        version: '0.1.0',
+      }),
+    );
+    const Test = Schema.Struct({
       name: Ref(Nested),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Test',
+        version: '0.1.0',
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     // log.info('schema', { jsonSchema });
     const nested = jsonSchema.properties!.name;
@@ -70,12 +85,22 @@ describe('effect-to-json', () => {
   // TODO(ZaymonFC): @dmaretskyi we still need to fix this.
   // TODO(dmaretskyi): Remove FieldLookupAnnotationId.
   test.skip('reference annotation with lookup property', () => {
-    class Nested extends TypedObject({ typename: 'example.com/type/TestNested', version: '0.1.0' })({
+    const Nested = Schema.Struct({
       name: Schema.String,
-    }) {}
-    class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/TestNested',
+        version: '0.1.0',
+      }),
+    );
+    const Test = Schema.Struct({
       name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Test',
+        version: '0.1.0',
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     const effectSchema = toEffectSchema(jsonSchema);
 
@@ -84,24 +109,44 @@ describe('effect-to-json', () => {
   });
 
   test('array of references', () => {
-    class Nested extends TypedObject({ typename: 'example.com/type/TestNested', version: '0.1.0' })({
+    const Nested = Schema.Struct({
       name: Schema.String,
-    }) {}
-    class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/TestNested',
+        version: '0.1.0',
+      }),
+    );
+    const Test = Schema.Struct({
       name: Schema.Array(Ref(Nested)),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Test',
+        version: '0.1.0',
+      }),
+    );
 
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation((jsonSchema.properties!.name as any).items);
   });
 
   test('optional references', () => {
-    class Nested extends TypedObject({ typename: 'example.com/type/TestNested', version: '0.1.0' })({
+    const Nested = Schema.Struct({
       name: Schema.String,
-    }) {}
-    class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })({
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/TestNested',
+        version: '0.1.0',
+      }),
+    );
+    const Test = Schema.Struct({
       name: Schema.optional(Ref(Nested)),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Test',
+        version: '0.1.0',
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation(jsonSchema.properties!.name);
   });
@@ -114,19 +159,25 @@ describe('effect-to-json', () => {
   });
 
   test('annotations', () => {
-    class TestSchema extends TypedObject({ typename: 'example.com/type/Contact', version: '0.1.0' })({
+    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',
       }),
-    }) {}
-    const jsonSchema = toJsonSchema(TestSchema);
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Person',
+        version: '0.1.0',
+      }),
+    );
+
+    const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).to.deep.eq({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:example.com/type/Contact',
+      $id: 'dxn:type:example.com/type/Person',
 
       entityKind: EntityKind.Object,
-      typename: 'example.com/type/Contact',
+      typename: 'example.com/type/Person',
       version: '0.1.0',
 
       type: 'object',
@@ -147,37 +198,47 @@ describe('effect-to-json', () => {
   });
 
   test('handles suspend -- Contact schema serialization', () => {
-    const schema = toJsonSchema(Testing.Contact);
+    const schema = toJsonSchema(TestSchema.Person);
     expect(Object.keys(schema.properties!)).toEqual([
       'id',
       'name',
       'username',
       'email',
-      'phoneNumbers',
       'tasks',
+      'employer',
       'address',
     ]);
   });
 
   test('reference property by ref', () => {
-    class Organization extends TypedObject({ typename: 'example.com/type/Organization', version: '0.1.0' })({
+    const Organization = Schema.Struct({
       field: Schema.String,
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Organization',
+        version: '0.1.0',
+      }),
+    );
 
-    class Contact extends TypedObject({ typename: 'example.com/type/Contact', version: '0.1.0' })({
+    const Contact = Schema.Struct({
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Person',
+        version: '0.1.0',
+      }),
+    );
 
     // log.info('Contact', { ast: Contact.ast });
 
     const jsonSchema = toJsonSchema(Contact);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:example.com/type/Contact',
+      $id: 'dxn:type:example.com/type/Person',
 
       entityKind: EntityKind.Object,
-      typename: 'example.com/type/Contact',
+      typename: 'example.com/type/Person',
       version: '0.1.0',
 
       type: 'object',
@@ -212,14 +273,24 @@ describe('effect-to-json', () => {
   });
 
   test('add reference property', () => {
-    class Organization extends TypedObject({ typename: 'example.com/type/Organization', version: '0.1.0' })({
+    const Organization = Schema.Struct({
       field: Schema.String,
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Organization',
+        version: '0.1.0',
+      }),
+    );
 
-    class Contact extends TypedObject({ typename: 'example.com/type/Contact', version: '0.1.0' })({
+    const Contact = Schema.Struct({
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }) {}
+    }).pipe(
+      Type.Obj({
+        typename: 'example.com/type/Person',
+        version: '0.1.0',
+      }),
+    );
 
     const jsonSchema = toJsonSchema(Contact);
     setSchemaProperty(jsonSchema, 'organization' as JsonProp, createSchemaReference(Organization.typename));
@@ -227,8 +298,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.
@@ -251,7 +322,7 @@ describe('effect-to-json', () => {
 
   test('reference with title annotation', () => {
     const schema = Schema.Struct({
-      contact: Ref(Testing.Contact).annotations({ title: 'Custom Title' }),
+      contact: Ref(TestSchema.Person).annotations({ title: 'Custom Title' }),
     });
 
     // log.info('schema before', { ast: schema.ast });
@@ -274,33 +345,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: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?
-        $ref: 'dxn:type:example.com/type/Contact',
+        $ref: 'dxn:type:example.com/type/Person',
       },
       relationTarget: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:example.com/type/Contact',
+        $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,
     });
   });
@@ -310,7 +384,7 @@ describe('effect-to-json', () => {
       id: ObjectId,
       name: Schema.String,
     }).pipe(
-      EchoObject({
+      EchoObjectSchema({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -417,26 +491,35 @@ describe('json-to-effect', () => {
 
   for (const partial of [false, true]) {
     test(`deserialized equals original ${partial ? 'with partial' : ''}`, () => {
-      class Organization extends TypedObject({ typename: 'example.com/type/Organization', version: '0.1.0' })({
+      const Organization = Schema.Struct({
         field: Schema.String,
-      }) {}
-
-      class Test extends TypedObject({ typename: 'example.com/type/Test', version: '0.1.0' })(
-        {
-          string: Schema.String,
-          number: Schema.Number.pipe(PropertyMeta(EXAMPLE_NAMESPACE, { is_date: true })),
-          boolean: Schema.Boolean,
-          array: Schema.Array(Schema.String),
-          twoDArray: Schema.Array(Schema.Array(Schema.String)),
-          record: Schema.Record({ key: Schema.String, value: Schema.Number }),
-          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)),
-          null: Schema.Null,
-        },
-        partial ? { partial } : {},
-      ) {}
+      }).pipe(
+        Type.Obj({
+          typename: 'example.com/type/Organization',
+          version: '0.1.0',
+        }),
+      );
+
+      const fields = {
+        string: Schema.String,
+        number: Schema.Number.pipe(PropertyMeta(EXAMPLE_NAMESPACE, { is_date: true })),
+        boolean: Schema.Boolean,
+        array: Schema.Array(Schema.String),
+        twoDArray: Schema.Array(Schema.Array(Schema.String)),
+        record: Schema.Record({ key: Schema.String, value: Schema.Number }),
+        object: Schema.Struct({ id: Schema.String, field: Ref(Organization) }),
+        echoObject: Ref(Organization),
+        echoObjectArray: Schema.Array(Ref(Organization)),
+        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',
+          version: '0.1.0',
+        }),
+      );
 
       const jsonSchema = toJsonSchema(Test);
       // log.info('schema', { jsonSchema });
@@ -499,8 +582,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));
   });
 
@@ -515,7 +598,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));
@@ -618,10 +701,8 @@ describe('json-to-effect', () => {
   });
 
   test('schema with optional referece', () => {
-    const TestSchema = Schema.Struct({
-      contact: Schema.optional(Ref(Testing.Contact)),
-    });
-    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#",
@@ -632,7 +713,7 @@ describe('json-to-effect', () => {
             "$ref": "/schemas/echo/ref",
             "reference": {
               "schema": {
-                "$ref": "dxn:type:example.com/type/Contact",
+                "$ref": "dxn:type:example.com/type/Person",
               },
               "schemaVersion": "0.1.0",
             },
@@ -647,13 +728,65 @@ 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(EchoObjectSchema({ typename: 'example.com/type/Person', version: '0.1.0' }));
+    const input = Schema.Struct({
+      contact: Contact,
+    });
+    const jsonSchema = toJsonSchema(input);
+    expect(jsonSchema).toMatchInlineSnapshot(`
+      {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "additionalProperties": false,
+        "properties": {
+          "contact": {
+            "$id": "dxn:type:example.com/type/Person",
+            "additionalProperties": false,
+            "entityKind": "object",
+            "properties": {
+              "id": {
+                "type": "string",
+              },
+              "name": {
+                "type": "string",
+              },
+            },
+            "propertyOrder": [
+              "name",
+              "id",
+            ],
+            "required": [
+              "name",
+              "id",
+            ],
+            "type": "object",
+            "typename": "example.com/type/Person",
+            "version": "0.1.0",
+          },
+        },
+        "propertyOrder": [
+          "contact",
+        ],
+        "required": [
+          "contact",
+        ],
+        "type": "object",
+      }
+    `);
+
+    const effectSchema = toEffectSchema(jsonSchema);
+    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(input.ast));
   });
 });
 
 describe('reference', () => {
   test('reference annotation', () => {
-    const schema = Ref(Testing.Contact);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $id: '/schemas/echo/ref',
@@ -661,7 +794,7 @@ describe('reference', () => {
       $schema: 'http://json-schema.org/draft-07/schema#',
       reference: {
         schema: {
-          $ref: 'dxn:type:example.com/type/Contact',
+          $ref: 'dxn:type:example.com/type/Person',
         },
         schemaVersion: '0.1.0',
       },
@@ -669,7 +802,7 @@ describe('reference', () => {
   });
 
   test('title annotation', () => {
-    const schema = Ref(Testing.Contact).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#',
@@ -679,7 +812,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:example.com/type/Contact',
+              $ref: 'dxn:type:example.com/type/Person',
             },
             schemaVersion: '0.1.0',
           },
@@ -690,7 +823,7 @@ describe('reference', () => {
   });
 
   test('description annotation', () => {
-    const schema = Ref(Testing.Contact).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#',
@@ -700,7 +833,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:example.com/type/Contact',
+              $ref: 'dxn:type:example.com/type/Person',
             },
             schemaVersion: '0.1.0',
           },
@@ -714,13 +847,13 @@ describe('reference', () => {
   });
 
   test('serialize and deserialize', () => {
-    const schema = Ref(Testing.Contact);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     const deserializedSchema = toEffectSchema(jsonSchema);
     const refAst = getReferenceAst(deserializedSchema.ast);
     expect(refAst).toEqual({
-      typename: Testing.Contact.typename,
-      version: Testing.Contact.version,
+      typename: TestSchema.Person.typename,
+      version: TestSchema.Person.version,
     });
   });
 });