add tests and fix

Author: paula-stacho

src/schema-convertors/internalToMongoDB.ts

@@ -64,6 +64,10 @@ async function parseType(type: SchemaType, signal?: AbortSignal): Promise<MongoD
   return schema;
 }
 
+function isSimpleTypesOnly(types: MongoDBJSONSchema[]): types is { bsonType: string }[] {
+  return types.every(definition => !!definition.bsonType && Object.keys(definition).length === 1);
+}
+
 async function parseTypes(types: SchemaType[], signal?: AbortSignal): Promise<MongoDBJSONSchema> {
   await allowAbort(signal);
   const definedTypes = types.filter(type => type.bsonType.toLowerCase() !== 'undefined');
@@ -72,13 +76,13 @@ async function parseTypes(types: SchemaType[], signal?: AbortSignal): Promise<Mo
     return parseType(definedTypes[0], signal);
   }
   const parsedTypes = await Promise.all(definedTypes.map(type => parseType(type, signal)));
-  if (definedTypes.some(type => ['Document', 'Array'].includes(type.bsonType))) {
+  if (isSimpleTypesOnly(parsedTypes)) {
     return {
-      anyOf: parsedTypes
+      bsonType: parsedTypes.map(({ bsonType }) => bsonType)
     };
   }
   return {
-    bsonType: definedTypes.map((type) => convertInternalType(type.bsonType))
+    anyOf: parsedTypes
   };
 }
 

src/schema-convertors/internalToStandard.test.ts

@@ -3,7 +3,7 @@ import internalSchemaToStandard, { RELAXED_EJSON_DEFINITIONS } from './internalT
 
 describe('internalSchemaToStandard', async function() {
   describe('Converts: ', async function() {
-    it.only('all the types', async function() {
+    it('all the types', async function() {
       const internal = {
         count: 1,
         fields: [
@@ -893,7 +893,6 @@ describe('internalSchemaToStandard', async function() {
         ]
       };
       const standard = await internalSchemaToStandard(internal);
-      console.log(JSON.stringify(standard));
       assert.deepStrictEqual(standard, {
         type: 'object',
         required: [],
@@ -986,7 +985,8 @@ describe('internalSchemaToStandard', async function() {
               key: {
                 type: 'string'
               }
-            }
+            },
+            required: []
           },
           objectId: {
             $ref: '#/$defs/ObjectId'
@@ -1525,7 +1525,7 @@ describe('internalSchemaToStandard', async function() {
         });
       });
 
-      it('complex mixed type', async function() {
+      it('complex mixed type (with array and object)', async function() {
         const internal = {
           count: 2,
           fields: [
@@ -1657,6 +1657,72 @@ describe('internalSchemaToStandard', async function() {
           }
         });
       });
+
+      it('complex mixed type (with $refs)', async function() {
+        const internal = {
+          count: 2,
+          fields: [
+            {
+              name: 'mixedType',
+              path: [
+                'mixedType'
+              ],
+              count: 2,
+              type: [
+                'String',
+                'ObjectId'
+              ],
+              probability: 1,
+              hasDuplicates: false,
+              types: [
+                {
+                  name: 'String',
+                  path: [
+                    'mixedType'
+                  ],
+                  count: 1,
+                  probability: 0.3333333333333333,
+                  unique: 1,
+                  hasDuplicates: false,
+                  values: [
+                    'abc'
+                  ],
+                  bsonType: 'String'
+                },
+                {
+                  name: 'ObjectId',
+                  path: [
+                    'objectId'
+                  ],
+                  count: 1,
+                  probability: 0.8,
+                  unique: 1,
+                  hasDuplicates: false,
+                  values: [
+                    '642d766c7300158b1f22e975'
+                  ],
+                  bsonType: 'ObjectId'
+                }
+              ]
+            }
+          ]
+        };
+        const standard = await internalSchemaToStandard(internal);
+        assert.deepStrictEqual(standard, {
+          type: 'object',
+          required: ['mixedType'],
+          $defs: RELAXED_EJSON_DEFINITIONS,
+          properties: {
+            mixedType: {
+              anyOf: [{
+                type: 'string'
+              }, {
+                $ref: '#/$defs/ObjectId'
+              }]
+            }
+          }
+        });
+      });
     });
 
     it('can be aborted', async function() {

src/schema-convertors/internalToStandard.ts

@@ -241,7 +241,7 @@ export const RELAXED_EJSON_DEFINITIONS = Object.freeze({
 });
 
 const convertInternalType = (internalType: string) => {
-  const type = InternalTypeToStandardTypeMap[internalType];
+  const type = { ...InternalTypeToStandardTypeMap[internalType] };
   if (!type) throw new Error(`Encountered unknown type: ${internalType}`);
   return type;
 };
@@ -272,8 +272,8 @@ async function parseType(type: SchemaType, signal?: AbortSignal): Promise<Standa
   return schema;
 }
 
-function isSimpleTypesOnly(types: StandardTypeDefinition[]): types is { type: JSONSchema4TypeName }[] {
-  return types.every(definition => !definition.$ref);
+function isSimpleTypesOnly(types: StandardJSONSchema[]): types is { type: JSONSchema4TypeName }[] {
+  return types.every(definition => !!definition.type && Object.keys(definition).length === 1);
 }
 
 async function parseTypes(types: SchemaType[], signal?: AbortSignal): Promise<StandardJSONSchema> {
@@ -284,19 +284,13 @@ async function parseTypes(types: SchemaType[], signal?: AbortSignal): Promise<St
     return parseType(definedTypes[0], signal);
   }
   const parsedTypes = await Promise.all(definedTypes.map(type => parseType(type, signal)));
-  if (definedTypes.some(type => ['Document', 'Array'].includes(type.bsonType))) {
+  if (isSimpleTypesOnly(parsedTypes)) {
     return {
-      anyOf: parsedTypes
-    };
-  }
-  const convertedTypes = definedTypes.map((type) => convertInternalType(type.bsonType));
-  if (isSimpleTypesOnly(convertedTypes)) {
-    return {
-      type: convertedTypes.map(({ type }) => type)
+      type: parsedTypes.map(({ type }) => type)
     };
   }
   return {
-    anyOf: convertedTypes
+    anyOf: parsedTypes
   };
 }