.eslintrc.js

 module.exports = {
   extends: '@loopback/eslint-config',
+  rules: {
+    '@typescript-eslint/no-unused-vars': ['off'],
+    '@typescript-eslint/prefer-nullish-coalescing': ['off'],
+    // Note: you must disable the base rule as it can report incorrect errors
+  },
 };

.gitlab-ci.yml

@@ -75,21 +75,18 @@ yarn:build:
 prettier:
   stage: test
   extends: .nodejs
-  allow_failure: true
   script:
     - yarn run prettier:check
 
 eslint:
   stage: test
   extends: .nodejs
-  allow_failure: true
   script:
     - yarn run eslint
 
 js-test:
   stage: test
   extends: .nodejs
-  allow_failure: true
   script:
     - yarn run test
 

package.json

 {
   "name": "laboite-blog-backend",
-  "version": "1.6.2",
+  "version": "1.6.3-testing.1",
   "license": "EUPL-1.2",
   "description": " API backend for laboite blog service",
   "author": "EOLE/PCLL <team@eole.education> - DINUM",

src/__tests__/acceptance/home-page.acceptance.ts

@@ -3,8 +3,7 @@ import {LaboiteBlogBackendApplication} from '../..';
 import {setupApplication} from './test-helper';
 
 describe('HomePage', () => {
-  let app: LaboiteBlogBackendApplication;
-  let client: Client;
+  let app: LaboiteBlogBackendApplication, client: Client;
 
   before('setupApplication', async () => {
     ({app, client} = await setupApplication());

src/__tests__/acceptance/ping.controller.acceptance.ts

@@ -3,8 +3,7 @@ import {LaboiteBlogBackendApplication} from '../..';
 import {setupApplication} from './test-helper';
 
 describe('PingController', () => {
-  let app: LaboiteBlogBackendApplication;
-  let client: Client;
+  let app: LaboiteBlogBackendApplication, client: Client;
 
   before('setupApplication', async () => {
     ({app, client} = await setupApplication());

src/application.ts

@@ -4,7 +4,7 @@ import {RepositoryMixin} from '@loopback/repository';
 import {RestApplication} from '@loopback/rest';
 import {
   RestExplorerBindings,
-  RestExplorerComponent
+  RestExplorerComponent,
 } from '@loopback/rest-explorer';
 import {ServiceMixin} from '@loopback/service-proxy';
 import path from 'path';

src/controllers/appsettings.controller.ts

 import {
-    Count,
-    CountSchema,
-    Filter,
-    FilterExcludingWhere,
-    repository,
-    Where,
-  } from '@loopback/repository';
-  import {
-    param,
-    get,
-    getModelSchemaRef,
-  } from '@loopback/rest';
-  import {AppSettings} from '../models';
-  import {AppSettingsRepository} from '../repositories';
-  
-  export class AppSettingsController {
-    constructor(
-      @repository(AppSettingsRepository)
-      public appSettingsRepository : AppSettingsRepository,
-    ) {}
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {param, get, getModelSchemaRef} from '@loopback/rest';
+import {AppSettings} from '../models';
+import {AppSettingsRepository} from '../repositories';
 
-    @get('/appsettings', {
-      responses: {
-        '200': {
-          description: 'All appsettings',
-          content: {
-            'application/json': {
-              schema: {
-                type: 'array',
-                items: getModelSchemaRef(AppSettings, {includeRelations: true}),
-              },
+export class AppSettingsController {
+  constructor(
+    @repository(AppSettingsRepository)
+    public appSettingsRepository: AppSettingsRepository,
+  ) {}
+
+  @get('/appsettings', {
+    responses: {
+      '200': {
+        description: 'All appsettings',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(AppSettings, {includeRelations: true}),
             },
           },
         },
       },
-    })
-    async find(
-        @param.filter(AppSettings, {exclude: 'where'}) filter?: FilterExcludingWhere<AppSettings>
-    ): Promise<AppSettings | null> {
-      return this.appSettingsRepository.findOne({ where : { _id: 'settings' } });
-    }
+    },
+  })
+  async find(
+    @param.filter(AppSettings, {exclude: 'where'})
+    filter?: FilterExcludingWhere<AppSettings>,
+  ): Promise<AppSettings | null> {
+    return this.appSettingsRepository.findOne({where: {_id: 'settings'}});
   }
-  
\ No newline at end of file
+}

src/controllers/article-users.controller.ts

-import {
-  repository, Filter,
-} from '@loopback/repository';
-import {
-  param,
-  get,
-  getModelSchemaRef,
-} from '@loopback/rest';
-import {
-  Article,
-  Users,
-} from '../models';
+import {repository, Filter} from '@loopback/repository';
+import {param, get, getModelSchemaRef} from '@loopback/rest';
+import {Article, Users} from '../models';
 import {ArticleRepository} from '../repositories';
 
 export class ArticleUsersController {
   constructor(
     @repository(ArticleRepository)
     public articleRepository: ArticleRepository,
-  ) { }
+  ) {}
 
   @get('/articles/{id}/users', {
     responses: {

src/controllers/articles.controller.ts

@@ -3,11 +3,14 @@ import {
   CountSchema,
   Filter,
   repository,
-  Where
+  Where,
 } from '@loopback/repository';
 import {
   get,
-  getModelSchemaRef, param, requestBody, patch
+  getModelSchemaRef,
+  param,
+  requestBody,
+  patch,
 } from '@loopback/rest';
 import {Article} from '../models';
 import {ArticleRepository} from '../repositories';
@@ -15,7 +18,7 @@ import {ArticleRepository} from '../repositories';
 export class ArticlesController {
   constructor(
     @repository(ArticleRepository)
-    public articleRepository : ArticleRepository,
+    public articleRepository: ArticleRepository,
   ) {}
 
   @get('/articles/count', {
@@ -26,9 +29,7 @@ export class ArticlesController {
       },
     },
   })
-  async count(
-    @param.where(Article) where?: Where<Article>,
-  ): Promise<Count> {
+  async count(@param.where(Article) where?: Where<Article>): Promise<Count> {
     return this.articleRepository.count(where);
   }
 
@@ -65,14 +66,15 @@ export class ArticlesController {
       },
     },
   })
-  async findById(
-    @param.path.string('id') id: string
-  ): Promise<(Article) | null> {
-    return this.articleRepository.findOne({ where : { slug: id }, include: [
-      {
-        relation: 'user',
-      }
-    ]});
+  async findById(@param.path.string('id') id: string): Promise<Article | null> {
+    return this.articleRepository.findOne({
+      where: {slug: id},
+      include: [
+        {
+          relation: 'user',
+        },
+      ],
+    });
   }
 
   @patch('/articles/{id}/read', {
@@ -82,14 +84,15 @@ export class ArticlesController {
       },
     },
   })
-  async updateById(
-    @param.path.string('id') id: string
-  ): Promise<void> {
-    const articles: Article[] = await this.articleRepository.find({ where : { _id: id }, fields: {visits: true} })
-   const concernedArticle = articles[0];
-    if(concernedArticle) {
-      const { visits = 0 } = concernedArticle;
-      await this.articleRepository.updateById(id, { visits: visits + 1 } );
+  async updateById(@param.path.string('id') id: string): Promise<void> {
+    const articles: Article[] = await this.articleRepository.find({
+      where: {_id: id},
+      fields: {visits: true},
+    });
+    const concernedArticle = articles[0];
+    if (concernedArticle) {
+      const {visits = 0} = concernedArticle;
+      await this.articleRepository.updateById(id, {visits: visits + 1});
     }
   }
 }

src/controllers/group.controller.ts

@@ -6,18 +6,14 @@ import {
   repository,
   Where,
 } from '@loopback/repository';
-import {
-  param,
-  get,
-  getModelSchemaRef,
-} from '@loopback/rest';
+import {param, get, getModelSchemaRef} from '@loopback/rest';
 import {Group} from '../models';
 import {GroupRepository} from '../repositories';
 
 export class GroupController {
   constructor(
     @repository(GroupRepository)
-    public groupRepository : GroupRepository,
+    public groupRepository: GroupRepository,
   ) {}
 
   @get('/groups/count', {
@@ -28,9 +24,7 @@ export class GroupController {
       },
     },
   })
-  async count(
-    @param.where(Group) where?: Where<Group>,
-  ): Promise<Count> {
+  async count(@param.where(Group) where?: Where<Group>): Promise<Count> {
     return this.groupRepository.count(where);
   }
 
@@ -49,9 +43,7 @@ export class GroupController {
       },
     },
   })
-  async find(
-    @param.filter(Group) filter?: Filter<Group>,
-  ): Promise<Group[]> {
+  async find(@param.filter(Group) filter?: Filter<Group>): Promise<Group[]> {
     return this.groupRepository.find(filter);
   }
 
@@ -69,8 +61,9 @@ export class GroupController {
   })
   async findById(
     @param.path.string('id') id: string,
-    @param.filter(Group, {exclude: 'where'}) filter?: FilterExcludingWhere<Group>
+    @param.filter(Group, {exclude: 'where'})
+    filter?: FilterExcludingWhere<Group>,
   ): Promise<Group | null> {
-    return this.groupRepository.findOne({ where : { slug: id } }, filter);
+    return this.groupRepository.findOne({where: {slug: id}}, filter);
   }
 }

src/controllers/structure.controller.ts

 import {
-    Count,
-    CountSchema,
-    Filter,
-    FilterExcludingWhere,
-    repository,
-    Where,
-  } from '@loopback/repository';
-  import {
-    param,
-    get,
-    getModelSchemaRef,
-  } from '@loopback/rest';
-  import {Structure} from '../models';
-  import {StructureRepository} from '../repositories';
-  
-  export class StructureController {
-    constructor(
-      @repository(StructureRepository)
-      public structureRepository : StructureRepository,
-    ) {}
-  
-    @get('/structures/count', {
-      responses: {
-        '200': {
-          description: 'Structure model count',
-          content: {'application/json': {schema: CountSchema}},
-        },
+  Count,
+  CountSchema,
+  Filter,
+  FilterExcludingWhere,
+  repository,
+  Where,
+} from '@loopback/repository';
+import {param, get, getModelSchemaRef} from '@loopback/rest';
+import {Structure} from '../models';
+import {StructureRepository} from '../repositories';
+
+export class StructureController {
+  constructor(
+    @repository(StructureRepository)
+    public structureRepository: StructureRepository,
+  ) {}
+
+  @get('/structures/count', {
+    responses: {
+      '200': {
+        description: 'Structure model count',
+        content: {'application/json': {schema: CountSchema}},
       },
-    })
-    async count(
-      @param.where(Structure) where?: Where<Structure>,
-    ): Promise<Count> {
-      return this.structureRepository.count(where);
-    }
-  
-    @get('/structures', {
-      responses: {
-        '200': {
-          description: 'Array of Structure model instances',
-          content: {
-            'application/json': {
-              schema: {
-                type: 'array',
-                items: getModelSchemaRef(Structure, {includeRelations: true}),
-              },
+    },
+  })
+  async count(
+    @param.where(Structure) where?: Where<Structure>,
+  ): Promise<Count> {
+    return this.structureRepository.count(where);
+  }
+
+  @get('/structures', {
+    responses: {
+      '200': {
+        description: 'Array of Structure model instances',
+        content: {
+          'application/json': {
+            schema: {
+              type: 'array',
+              items: getModelSchemaRef(Structure, {includeRelations: true}),
             },
           },
         },
       },
-    })
-    async find(
-      @param.filter(Structure) filter?: Filter<Structure>,
-    ): Promise<Structure[]> {
-      return this.structureRepository.find(filter);
-    }
-  
-    @get('/structures/{id}', {
-      responses: {
-        '200': {
-          description: 'Structure model instance',
-          content: {
-            'application/json': {
-              schema: getModelSchemaRef(Structure, {includeRelations: true}),
-            },
+    },
+  })
+  async find(
+    @param.filter(Structure) filter?: Filter<Structure>,
+  ): Promise<Structure[]> {
+    return this.structureRepository.find(filter);
+  }
+
+  @get('/structures/{id}', {
+    responses: {
+      '200': {
+        description: 'Structure model instance',
+        content: {
+          'application/json': {
+            schema: getModelSchemaRef(Structure, {includeRelations: true}),
           },
         },
       },
-    })
-    async findById(
-      @param.path.string('id') id: string,
-      @param.filter(Structure, {exclude: 'where'}) filter?: FilterExcludingWhere<Structure>
-    ): Promise<Structure | null> {
-      return this.structureRepository.findOne({ where : { _id: id } }, filter);
-    }
+    },
+  })
+  async findById(
+    @param.path.string('id') id: string,
+    @param.filter(Structure, {exclude: 'where'})
+    filter?: FilterExcludingWhere<Structure>,
+  ): Promise<Structure | null> {
+    return this.structureRepository.findOne({where: {_id: id}}, filter);
   }
-  
\ No newline at end of file
+}

src/controllers/tags.controller.ts

-import {
-  Filter,
-  FilterExcludingWhere,
-  repository,
-} from '@loopback/repository';
-import {
-  param,
-  get,
-  getModelSchemaRef,
-} from '@loopback/rest';
+import {Filter, FilterExcludingWhere, repository} from '@loopback/repository';
+import {param, get, getModelSchemaRef} from '@loopback/rest';
 import {Tags} from '../models';
 import {TagsRepository} from '../repositories';
 
 export class TagsControllerController {
   constructor(
     @repository(TagsRepository)
-    public tagsRepository : TagsRepository,
+    public tagsRepository: TagsRepository,
   ) {}
 
   @get('/tags', {
@@ -32,9 +24,7 @@ export class TagsControllerController {
       },
     },
   })
-  async find(
-    @param.filter(Tags) filter?: Filter<Tags>,
-  ): Promise<Tags[]> {
+  async find(@param.filter(Tags) filter?: Filter<Tags>): Promise<Tags[]> {
     return this.tagsRepository.find(filter);
   }
 }

src/controllers/users-article.controller.ts

@@ -15,16 +15,13 @@ import {
   post,
   requestBody,
 } from '@loopback/rest';
-import {
-  Users,
-  Article,
-} from '../models';
+import {Users, Article} from '../models';
 import {UsersRepository} from '../repositories';
 
 export class UsersArticleController {
   constructor(
     @repository(UsersRepository) protected usersRepository: UsersRepository,
-  ) { }
+  ) {}
 
   @get('/users/{id}/articles', {
     responses: {
@@ -44,5 +41,4 @@ export class UsersArticleController {
   ): Promise<Article[]> {
     return this.usersRepository.articles(id).find(filter);
   }
-
 }

src/controllers/users.controller.ts

@@ -4,22 +4,18 @@ import {
   Filter,
   FilterExcludingWhere,
   repository,
-  Where
+  Where,
 } from '@loopback/repository';
-import {
-  get,
-  getModelSchemaRef, param
-} from '@loopback/rest';
+import {get, getModelSchemaRef, param} from '@loopback/rest';
 import {Users} from '../models';
 import {UsersRepository} from '../repositories';
 
 export class UsersController {
   constructor(
     @repository(UsersRepository)
-    public usersRepository : UsersRepository,
+    public usersRepository: UsersRepository,
   ) {}
 
-
   @get('/authors/count', {
     responses: {
       '200': {
@@ -28,9 +24,7 @@ export class UsersController {
       },
     },
   })
-  async count(
-    @param.where(Users) where?: Where<Users>,
-  ): Promise<Count> {
+  async count(@param.where(Users) where?: Where<Users>): Promise<Count> {
     return this.usersRepository.count(where);
   }
 
@@ -49,9 +43,7 @@ export class UsersController {
       },
     },
   })
-  async find(
-    @param.filter(Users) filter?: Filter<Users>,
-  ): Promise<Users[]> {
+  async find(@param.filter(Users) filter?: Filter<Users>): Promise<Users[]> {
     return this.usersRepository.find(filter);
   }
 
@@ -69,7 +61,8 @@ export class UsersController {
   })
   async findById(
     @param.path.string('id') id: string,
-    @param.filter(Users, {exclude: 'where'}) filter?: FilterExcludingWhere<Users>
+    @param.filter(Users, {exclude: 'where'})
+    filter?: FilterExcludingWhere<Users>,
   ): Promise<Users> {
     return this.usersRepository.findById(id, filter);
   }

src/models/settingsType.model.ts

@@ -2,21 +2,21 @@ import {belongsTo, Entity, model, property} from '@loopback/repository';
 
 @model()
 export class SettingsType {
-    @property({
-        type: 'boolean',
-        required: true,
-    })
-    external: boolean
+  @property({
+    type: 'boolean',
+    required: true,
+  })
+  external: boolean;
 
-    @property({
-        type: 'string',
-        required: true,
-    })
-    link: string
-    
-    @property({
-        type: 'string',
-        required: true,
-    })
-    content: string
-}
\ No newline at end of file
+  @property({
+    type: 'string',
+    required: true,
+  })
+  link: string;
+
+  @property({
+    type: 'string',
+    required: true,
+  })
+  content: string;
+}

src/models/structure.model.ts

-import { Entity, model, property } from '@loopback/repository';
+import {Entity, model, property} from '@loopback/repository';
 
 @model({
   settings: {
     strict: true,
     idInjection: false,
-    mongodb: { collection: 'structures' }, // custom names
+    mongodb: {collection: 'structures'}, // custom names
   },
 })
 export class Structure extends Entity {
@@ -21,7 +21,6 @@ export class Structure extends Entity {
   })
   name: string;
 
-
   constructor(data?: Partial<Structure>) {
     super(data);
   }

src/models/tags.model.ts

 import {Entity, model, property} from '@loopback/repository';
 
-
 @model({
   settings: {
     strict: true,
@@ -22,7 +21,6 @@ export class Tags extends Entity {
   })
   name: string;
 
-
   constructor(data?: Partial<Tags>) {
     super(data);
   }

src/repositories/appsettings.repository.ts

@@ -2,17 +2,17 @@ import {DefaultCrudRepository} from '@loopback/repository';
 import {Structure, StructureRelations} from '../models';
 import {DbDataSource} from '../datasources';
 import {inject} from '@loopback/core';
-import { AppSettings, AppSettingsWithRelations } from '../models/appsettings.model';
+import {
+  AppSettings,
+  AppSettingsWithRelations,
+} from '../models/appsettings.model';
 
 export class AppSettingsRepository extends DefaultCrudRepository<
   AppSettings,
   typeof AppSettings.prototype._id,
   AppSettingsWithRelations
 > {
-
-  constructor(
-    @inject('datasources.db') dataSource: DbDataSource,
-  ) {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
     super(AppSettings, dataSource);
   }
 }

src/repositories/article.repository.ts

 import {inject, Getter} from '@loopback/core';
-import {DefaultCrudRepository, repository, BelongsToAccessor} from '@loopback/repository';
+import {
+  DefaultCrudRepository,
+  repository,
+  BelongsToAccessor,
+} from '@loopback/repository';
 import {DbDataSource} from '../datasources';
 import {Article, ArticleRelations, Users} from '../models';
 import {UsersRepository} from './users.repository';
@@ -9,14 +13,15 @@ export class ArticleRepository extends DefaultCrudRepository<
   typeof Article.prototype._id,
   ArticleRelations
 > {
-
   public readonly user: BelongsToAccessor<Users, typeof Article.prototype._id>;
 
   constructor(
-    @inject('datasources.db') dataSource: DbDataSource, @repository.getter('UsersRepository') protected usersRepositoryGetter: Getter<UsersRepository>,
+    @inject('datasources.db') dataSource: DbDataSource,
+    @repository.getter('UsersRepository')
+    protected usersRepositoryGetter: Getter<UsersRepository>,
   ) {
     super(Article, dataSource);
-    this.user = this.createBelongsToAccessorFor('user', usersRepositoryGetter,);
+    this.user = this.createBelongsToAccessorFor('user', usersRepositoryGetter);
     this.registerInclusionResolver('user', this.user.inclusionResolver);
   }
 }

src/repositories/group.repository.ts

@@ -8,10 +8,7 @@ export class GroupRepository extends DefaultCrudRepository<
   typeof Group.prototype._id,
   GroupRelations
 > {
-
-  constructor(
-    @inject('datasources.db') dataSource: DbDataSource,
-  ) {
+  constructor(@inject('datasources.db') dataSource: DbDataSource) {
     super(Group, dataSource);
   }
 }