fix: remove repeated code from controller in case of same table hasManyThrough relation

Signed-off-by: Muhammad Aaqil <[email protected]>

Author: aaqilniz

packages/cli/generators/relation/templates/controller-relation-template-has-many-through.ts.ejs

@@ -15,8 +15,8 @@ import {
   post,
   requestBody,
 } from '@loopback/rest';
-import {
-<%= sourceModelClassName %>,
+import {<%if (sourceModelClassName != targetModelClassName) { %>
+<%= sourceModelClassName %>,<% } %>
 <%= throughModelClassName %>,
 <%= targetModelClassName %>,
 } from '../models';

packages/cli/snapshots/integration/generators/relation.has-many-through.integration.snapshots.js

@@ -701,3 +701,203 @@ export class DoctorRepository extends DefaultCrudRepository<
 }
 
 `;
+
+
+exports[`lb4 relation HasManyThrough generates model relation with same table answers {"relationType":"hasManyThrough","sourceModel":"User","destinationModel":"User","throughModel":"Friend"} controller file has been created with hasManyThrough relation with same table 1`] = `
+import {
+  Count,
+  CountSchema,
+  Filter,
+  repository,
+  Where,
+} from '@loopback/repository';
+  import {
+  del,
+  get,
+  getModelSchemaRef,
+  getWhereSchemaFor,
+  param,
+  patch,
+  post,
+  requestBody,
+} from '@loopback/rest';
+import {
+Friend,
+User,
+} from '../models';
+import {UserRepository} from '../repositories';
+
+export class UserUserController {
+  constructor(
+    @repository(UserRepository) protected userRepository: UserRepository,
+  ) { }
+
+  @get('/users/{id}/users', {
+    responses: {
+      '200': {
+        description: 'Array of User has many User through Friend',
+        content: {
+          'application/json': {
+            schema: {type: 'array', items: getModelSchemaRef(User)},
+          },
+        },
+      },
+    },
+  })
+  async find(
+    @param.path.number('id') id: number,
+    @param.query.object('filter') filter?: Filter<User>,
+  ): Promise<User[]> {
+    return this.userRepository.users(id).find(filter);
+  }
+
+  @post('/users/{id}/users', {
+    responses: {
+      '200': {
+        description: 'create a User model instance',
+        content: {'application/json': {schema: getModelSchemaRef(User)}},
+      },
+    },
+  })
+  async create(
+    @param.path.number('id') id: typeof User.prototype.id,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(User, {
+            title: 'NewUserInUser',
+            exclude: ['id'],
+          }),
+        },
+      },
+    }) user: Omit<User, 'id'>,
+  ): Promise<User> {
+    return this.userRepository.users(id).create(user);
+  }
+
+  @patch('/users/{id}/users', {
+    responses: {
+      '200': {
+        description: 'User.User PATCH success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async patch(
+    @param.path.number('id') id: number,
+    @requestBody({
+      content: {
+        'application/json': {
+          schema: getModelSchemaRef(User, {partial: true}),
+        },
+      },
+    })
+    user: Partial<User>,
+    @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
+  ): Promise<Count> {
+    return this.userRepository.users(id).patch(user, where);
+  }
+
+  @del('/users/{id}/users', {
+    responses: {
+      '200': {
+        description: 'User.User DELETE success count',
+        content: {'application/json': {schema: CountSchema}},
+      },
+    },
+  })
+  async delete(
+    @param.path.number('id') id: number,
+    @param.query.object('where', getWhereSchemaFor(User)) where?: Where<User>,
+  ): Promise<Count> {
+    return this.userRepository.users(id).delete(where);
+  }
+}
+
+`;
+
+
+exports[`lb4 relation HasManyThrough generates model relation with same table answers {"relationType":"hasManyThrough","sourceModel":"User","destinationModel":"User","throughModel":"Friend"} has correct default foreign keys 1`] = `
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class Friend extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    default: 0,
+  })
+  id?: number;
+
+  @property({
+    type: 'number',
+  })
+  userId?: number;
+
+  @property({
+    type: 'number',
+  })
+  friendId?: number;
+
+  constructor(data?: Partial<Friend>) {
+    super(data);
+  }
+}
+
+`;
+
+
+exports[`lb4 relation HasManyThrough generates model relation with same table answers {"relationType":"hasManyThrough","sourceModel":"User","destinationModel":"User","throughModel":"Friend"} has correct imports and relation name users 1`] = `
+import {Entity, model, property, hasMany} from '@loopback/repository';
+import {Friend} from './friend.model';
+
+@model()
+export class User extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    default: 0,
+  })
+  id?: number;
+
+  @property({
+    type: 'string',
+  })
+  email?: string;
+
+  @hasMany(() => User, {through: {model: () => Friend}})
+  users: User[];
+
+  constructor(data?: Partial<User>) {
+    super(data);
+  }
+}
+
+`;
+
+
+exports[`lb4 relation HasManyThrough generates model relation with same table answers {"relationType":"hasManyThrough","sourceModel":"User","destinationModel":"User","throughModel":"Friend"} has correct imports and relation name users 2`] = `
+import {inject, Getter} from '@loopback/core';
+import {DefaultCrudRepository, repository, HasManyThroughRepositoryFactory} from '@loopback/repository';
+import {DbDataSource} from '../datasources';
+import {User, Friend} from '../models';
+import {FriendRepository} from './friend.repository';
+
+export class UserRepository extends DefaultCrudRepository<
+  User,
+  typeof User.prototype.id
+> {
+
+  public readonly users: HasManyThroughRepositoryFactory<User, typeof User.prototype.id,
+          Friend,
+          typeof User.prototype.id
+        >;
+
+  constructor(@inject('datasources.db') dataSource: DbDataSource, @repository.getter('FriendRepository') protected friendRepositoryGetter: Getter<FriendRepository>, @repository.getter('UserRepository') protected userRepositoryGetter: Getter<UserRepository>,) {
+    super(User, dataSource);
+    this.users = this.createHasManyThroughRepositoryFactoryFor('users', userRepositoryGetter, friendRepositoryGetter,);
+    this.registerInclusionResolver('users', this.users.inclusionResolver);
+  }
+}
+
+`;

packages/cli/test/fixtures/relation/controllers/user-user.controller.ts

@@ -0,0 +1 @@
+export class UserUserController {}

packages/cli/test/fixtures/relation/index.js

@@ -162,6 +162,26 @@ const SourceEntries = {
     file: 'employee.controller.ts',
     content: readSourceFile('./controllers/employee.controller.ts'),
   },
+  UserModel: {
+    path: MODEL_APP_PATH,
+    file: 'user.model.ts',
+    content: readSourceFile('./models/user.model.ts'),
+  },
+  FriendModel: {
+    path: MODEL_APP_PATH,
+    file: 'friend.model.ts',
+    content: readSourceFile('./models/friend.model.ts'),
+  },
+  UserRepository: {
+    path: REPOSITORY_APP_PATH,
+    file: 'user.repository.ts',
+    content: readSourceFile('./repositories/user.repository.ts'),
+  },
+  FriendRepository: {
+    path: REPOSITORY_APP_PATH,
+    file: 'friend.repository.ts',
+    content: readSourceFile('./repositories/friend.repository.ts'),
+  },
 };
 exports.SourceEntries = SourceEntries;
 
@@ -226,6 +246,10 @@ exports.SANDBOX_FILES = [
   SourceEntries.DoctorPatientController,
   SourceEntries.EmployeeModel,
   SourceEntries.EmployeeController,
+  SourceEntries.UserModel,
+  SourceEntries.FriendModel,
+  SourceEntries.UserRepository,
+  SourceEntries.FriendRepository,
 ];
 
 exports.SANDBOX_FILES2 = [

packages/cli/test/fixtures/relation/models/friend.model.ts

@@ -0,0 +1,25 @@
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class Friend extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    default: 0,
+  })
+  id?: number;
+
+  @property({
+    type: 'number',
+  })
+  userId?: number;
+
+  @property({
+    type: 'number',
+  })
+  friendId?: number;
+
+  constructor(data?: Partial<Friend>) {
+    super(data);
+  }
+}

packages/cli/test/fixtures/relation/models/user.model.ts

@@ -0,0 +1,20 @@
+import {Entity, model, property} from '@loopback/repository';
+
+@model()
+export class User extends Entity {
+  @property({
+    type: 'number',
+    id: true,
+    default: 0,
+  })
+  id?: number;
+
+  @property({
+    type: 'string',
+  })
+  email?: string;
+
+  constructor(data?: Partial<User>) {
+    super(data);
+  }
+}

packages/cli/test/fixtures/relation/repositories/friend.repository.ts

@@ -0,0 +1,13 @@
+import {inject} from '@loopback/core';
+import {DefaultCrudRepository} from '@loopback/repository';
+import {DbDataSource} from '../datasources';
+import {Friend} from '../models';
+
+export class FriendRepository extends DefaultCrudRepository<
+  Friend,
+  typeof Friend.prototype.id
+> {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
+    super(Friend, dataSource);
+  }
+}

packages/cli/test/fixtures/relation/repositories/user.repository.ts

@@ -0,0 +1,13 @@
+import {inject} from '@loopback/core';
+import {DefaultCrudRepository} from '@loopback/repository';
+import {DbDataSource} from '../datasources';
+import {User} from '../models';
+
+export class UserRepository extends DefaultCrudRepository<
+  User,
+  typeof User.prototype.id
+> {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
+    super(User, dataSource);
+  }
+}