feat(repository-json-schema): enhance getJsonSchema to describe navigational properties

Enhance `getJsonSchema` to describe navigational properties

fix #2630

Author: samarpanB

packages/repository-json-schema/src/__tests__/integration/build-schema.integration.ts

@@ -17,6 +17,7 @@ import {
   JsonSchema,
   JSON_SCHEMA_KEY,
   modelToJsonSchema,
+  MODEL_TYPE_KEYS,
 } from '../..';
 import {expectValidJsonSchema} from '../helpers/expect-valid-json-schema';
 
@@ -648,7 +649,7 @@ describe('build-schema', () => {
       };
       MetadataInspector.defineMetadata(
         JSON_SCHEMA_KEY,
-        cachedSchema,
+        {[MODEL_TYPE_KEYS.ModelOnly]: cachedSchema},
         TestModel,
       );
       const jsonSchema = getJsonSchema(TestModel);
@@ -717,5 +718,197 @@ describe('build-schema', () => {
         expect(schema).to.deepEqual(expectedSchemaForCategory);
       });
     });
+
+    it('converts HasMany and BelongsTo relation links', () => {
+      @model()
+      class Product extends Entity {
+        @property({id: true})
+        id: number;
+
+        @belongsTo(() => Category)
+        categoryId: number;
+      }
+
+      @model()
+      class Category extends Entity {
+        @property({id: true})
+        id: number;
+
+        @hasMany(() => Product)
+        products?: Product[];
+      }
+
+      const expectedSchema: JsonSchema = {
+        definitions: {
+          ProductWithRelations: {
+            title: 'ProductWithRelations',
+            properties: {
+              id: {type: 'number'},
+              categoryId: {type: 'number'},
+              category: {$ref: '#/definitions/CategoryWithRelations'},
+            },
+          },
+        },
+        properties: {
+          id: {type: 'number'},
+          products: {
+            type: 'array',
+            items: {$ref: '#/definitions/ProductWithRelations'},
+          },
+        },
+        title: 'CategoryWithRelations',
+      };
+      const jsonSchema = getJsonSchema(Category, {includeRelations: true});
+      expect(jsonSchema).to.deepEqual(expectedSchema);
+    });
+
+    it('converts relation links when no other properties there', () => {
+      @model()
+      class Product extends Entity {
+        @property({id: true})
+        id: number;
+
+        @belongsTo(() => CategoryWithoutProp)
+        categoryId: number;
+      }
+
+      @model()
+      class CategoryWithoutProp extends Entity {
+        @hasMany(() => Product)
+        products?: Product[];
+      }
+      const expectedSchema: JsonSchema = {
+        definitions: {
+          ProductWithRelations: {
+            title: 'ProductWithRelations',
+            properties: {
+              id: {type: 'number'},
+              categoryId: {type: 'number'},
+              category: {
+                $ref: '#/definitions/CategoryWithoutPropWithRelations',
+              },
+            },
+          },
+        },
+        properties: {
+          products: {
+            type: 'array',
+            items: {$ref: '#/definitions/ProductWithRelations'},
+          },
+        },
+        title: 'CategoryWithoutPropWithRelations',
+      };
+
+      // To check for case when there are no other properties than relational
+      const jsonSchemaWithoutProp = getJsonSchema(CategoryWithoutProp, {
+        includeRelations: true,
+      });
+      expect(jsonSchemaWithoutProp).to.deepEqual(expectedSchema);
+    });
+
+    it('gets cached JSON schema with relation links if one exists', () => {
+      @model()
+      class Product extends Entity {
+        @property({id: true})
+        id: number;
+
+        @belongsTo(() => Category)
+        categoryId: number;
+      }
+
+      @model()
+      class Category extends Entity {
+        @property({id: true})
+        id: number;
+
+        @hasMany(() => Product)
+        products?: Product[];
+      }
+
+      const cachedSchema: JsonSchema = {
+        definitions: {
+          ProductWithRelations: {
+            title: 'ProductWithRelations',
+            properties: {
+              id: {type: 'number'},
+              categoryId: {type: 'number'},
+              category: {$ref: '#/definitions/CategoryWithRelations'},
+            },
+          },
+        },
+        properties: {
+          id: {type: 'number'},
+          cachedProp: {type: 'string'},
+          products: {
+            type: 'array',
+            items: {$ref: '#/definitions/ProductWithRelations'},
+          },
+        },
+        title: 'CategoryWithRelations',
+      };
+      MetadataInspector.defineMetadata(
+        JSON_SCHEMA_KEY,
+        {[MODEL_TYPE_KEYS.ModelWithRelations]: cachedSchema},
+        Category,
+      );
+      const jsonSchema = getJsonSchema(Category, {includeRelations: true});
+      expect(jsonSchema).to.eql(cachedSchema);
+    });
+
+    it('updates same cache with new key if one exists for model', () => {
+      @model()
+      class Product extends Entity {
+        @property({id: true})
+        id: number;
+
+        @belongsTo(() => Category)
+        categoryId: number;
+      }
+
+      @model()
+      class Category extends Entity {
+        @property({id: true})
+        id: number;
+
+        @hasMany(() => Product)
+        products?: Product[];
+      }
+
+      const cachedSchema: JsonSchema = {
+        definitions: {
+          ProductWithRelations: {
+            title: 'ProductWithRelations',
+            properties: {
+              id: {type: 'number'},
+              categoryId: {type: 'number'},
+              category: {$ref: '#/definitions/CategoryWithRelations'},
+            },
+          },
+        },
+        properties: {
+          id: {type: 'number'},
+          cachedProp: {type: 'string'},
+          products: {
+            type: 'array',
+            items: {$ref: '#/definitions/ProductWithRelations'},
+          },
+        },
+        title: 'CategoryWithRelations',
+      };
+      MetadataInspector.defineMetadata(
+        JSON_SCHEMA_KEY,
+        {[MODEL_TYPE_KEYS.ModelWithRelations]: cachedSchema},
+        Category,
+      );
+      const jsonSchema = getJsonSchema(Category);
+      // Make sure it's not pulling the withrelations key
+      expect(jsonSchema).to.not.eql(cachedSchema);
+      expect(jsonSchema).to.eql({
+        properties: {
+          id: {type: 'number'},
+        },
+        title: 'Category',
+      });
+    });
   });
 });

packages/repository-json-schema/src/__tests__/unit/build-schema.unit.ts

@@ -3,9 +3,17 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {PropertyDefinition} from '@loopback/repository';
+import {
+  PropertyDefinition,
+  RelationDefinitionBase,
+  RelationType,
+} from '@loopback/repository';
 import {expect} from '@loopback/testlab';
-import {metaToJsonProperty, stringTypeToWrapper} from '../..';
+import {
+  getNavigationalPropertyForRelation,
+  metaToJsonProperty,
+  stringTypeToWrapper,
+} from '../..';
 
 describe('build-schema', () => {
   class CustomType {}
@@ -190,4 +198,20 @@ describe('build-schema', () => {
       });
     });
   });
+
+  describe('getNavigationalPropertyForRelation', () => {
+    it('errors out if targetsMany is undefined', () => {
+      expect(() =>
+        getNavigationalPropertyForRelation(
+          {
+            type: RelationType.hasMany,
+            name: 'Test',
+          } as RelationDefinitionBase,
+          {
+            $ref: `#/definitions/Test`,
+          },
+        ),
+      ).to.throw(/targetsMany attribute missing for Test/);
+    });
+  });
 });