201 extend mongolib

README.md

@@ -24,7 +24,6 @@ Note: We have disabled HADOLINT for now as we are getting an error: `qemu: uncau
 [![Maintainability](https://api.codeclimate.com/v1/badges/52d516c2ad7c262adb37/maintainability)](https://codeclimate.com/github/RnDAO/tc-dbComm/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/52d516c2ad7c262adb37/test_coverage)](https://codeclimate.com/github/RnDAO/tc-dbComm/test_coverage)
 
-
 ### Tests
 
 The CI Pipeline uses the `test` target from the Dockerfile to run the tests. You can run it locally with the following command:
@@ -35,7 +34,6 @@ docker compose -f docker-compose.test.yml up --exit-code-from app --build
 
 Note: This will create a /coverage folder where you can review the coverage details.
 
-
 ### User interface
 
 ```ts
@@ -87,6 +85,7 @@ Module {
     }
 }
 ```
+
 ### Heatmap interface
 
 ```ts
@@ -140,7 +139,6 @@ Channel {
 }
 ```
 
-
 ### Role interface
 
 ```ts
@@ -212,4 +210,4 @@ Token {
     expires: Date,
     blacklisted?: boolean
 }
-```
+```

src/service/connection.ts → src/connection.ts

@@ -1,14 +1,10 @@
-import mongoose, { type Connection } from 'mongoose';
+import mongoose, { Connection } from 'mongoose';
 
-/**
- * Manages the MongoDB connection using Mongoose.
- * Implements the singleton pattern to ensure a single connection throughout the application.
- */
 export default class MongoConnectionManager {
   private static instance: MongoConnectionManager;
   private mongoConnection: Connection | null = null;
 
-  // Private constructor to prevent direct instantiation
+  // Private constructorto prevent direct instantiation
   private constructor() {}
 
   public static getInstance(): MongoConnectionManager {

src/service/databaseManager.ts → src/databaseManager.ts

@@ -1,22 +1,15 @@
-import mongoose, { type Connection } from 'mongoose';
+import { Snowflake } from 'discord.js';
+import mongoose, { Connection } from 'mongoose';
+
+import { IChannel, IGuildMember, IHeatMap, IMemberActivity, IRawInfo, IRole } from './interfaces';
 import {
+  channelSchema,
+  guildMemberSchema,
   heatMapSchema,
-  rawInfoSchema,
   MemberActivitySchema,
-  guildMemberSchema,
-  channelSchema,
+  rawInfoSchema,
   roleSchema,
-} from '../models/schemas';
-import {
-  type IHeatMap,
-  type IRawInfo,
-  type IMemberActivity,
-  type IGuildMember,
-  type IChannel,
-  type IRole,
-} from '../interfaces';
-
-import { type Snowflake } from 'discord.js';
+} from './models/schemas';
 
 export default class DatabaseManager {
   private static instance: DatabaseManager;

src/index.ts

@@ -1,5 +1,7 @@
 export * from './models';
 export * from './models/schemas';
 export * from './interfaces';
-export * from './service';
 export * from './config/enums';
+export * from './databaseManager';
+export * from './connection';
+export * from './repositories';

src/repositories/announcement.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IAnnouncement } from '../interfaces';
+import Announcement from '../models/Announcement.model';
+
+export class AnnouncementRepository extends BaseRepository<IAnnouncement> {
+  constructor(model: Model<IAnnouncement> = Announcement) {
+    super(model);
+  }
+}
+
+export const announcementRepository = new AnnouncementRepository();
+export default announcementRepository;

src/repositories/base.repository.ts

@@ -0,0 +1,58 @@
+// src/db/repositories/base.repository.ts
+import { FilterQuery, LeanDocument, Model, PopulateOptions, ProjectionType, QueryOptions, UpdateQuery } from 'mongoose';
+
+export interface PaginateOptions {
+  page?: number;
+  limit?: number;
+  sortBy?: string;
+  populate?: string | PopulateOptions | Array<string | PopulateOptions>;
+}
+
+export class BaseRepository<T> {
+  constructor(private readonly model: Model<T>) {}
+
+  async create(doc: Partial<T>): Promise<T> {
+    return await this.model.create(doc);
+  }
+
+  async createMany(docs: Array<Partial<T>>): Promise<T[]> {
+    return await this.model.insertMany(docs);
+  }
+
+  async findById(id: string, projection?: ProjectionType<T>, options?: QueryOptions): Promise<T | null> {
+    return await this.model.findById(id, projection, options);
+  }
+
+  async find(filter: FilterQuery<T>, projection?: ProjectionType<T>, options?: QueryOptions): Promise<T[]> {
+    return await this.model.find(filter, projection, options);
+  }
+
+  async updateOne(
+    filter: FilterQuery<T>,
+    update: UpdateQuery<T>,
+    options?: QueryOptions,
+  ): Promise<{ acknowledged: boolean; modifiedCount: number; upsertedId: unknown }> {
+    return await this.model.updateOne(filter, update, options);
+  }
+
+  async deleteOne(filter: FilterQuery<T>): Promise<{ deletedCount?: number }> {
+    return await this.model.deleteOne(filter);
+  }
+
+  async deleteMany(filter: FilterQuery<T>): Promise<{ deletedCount?: number }> {
+    return await this.model.deleteMany(filter);
+  }
+
+  async paginate(
+    filter: FilterQuery<T>,
+    options: PaginateOptions,
+  ): Promise<{
+    results: Array<LeanDocument<T>>;
+    page: number;
+    limit: number;
+    totalPages: number;
+    totalResults: number;
+  }> {
+    return (this.model as any).paginate(filter, options);
+  }
+}

src/repositories/channel.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IChannel } from '../interfaces';
+import Channel from '../models/Channel.model';
+
+export class ChannelRepository extends BaseRepository<IChannel> {
+  constructor(model: Model<IChannel> = Channel) {
+    super(model);
+  }
+}
+
+export const channelRepository = new ChannelRepository();
+export default channelRepository;

src/repositories/community.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { ICommunity } from '../interfaces';
+import Community from '../models/Community.model';
+
+export class CommunityRepository extends BaseRepository<ICommunity> {
+  constructor(model: Model<ICommunity> = Community) {
+    super(model);
+  }
+}
+
+export const communityRepository = new CommunityRepository();
+export default communityRepository;

src/repositories/guildMember.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IGuildMember } from '../interfaces';
+import GuildMember from '../models/GuildMember.model';
+
+export class GuildMemberRepository extends BaseRepository<IGuildMember> {
+  constructor(model: Model<IGuildMember> = GuildMember) {
+    super(model);
+  }
+}
+
+export const guildMemberRepository = new GuildMemberRepository();
+export default guildMemberRepository;

src/repositories/heatMap.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IHeatMap } from '../interfaces';
+import HeatMap from '../models/HeatMap.model';
+
+export class HeatMapRepository extends BaseRepository<IHeatMap> {
+  constructor(model: Model<IHeatMap> = HeatMap) {
+    super(model);
+  }
+}
+
+export const heatMapRepository = new HeatMapRepository();
+export default heatMapRepository;

src/repositories/index.ts

@@ -0,0 +1,29 @@
+import { BaseRepository } from './base.repository';
+import userRepository from './user.repository';
+import tokenRepository from './token.repository';
+import heatMapRepository from './heatMap.repository';
+import rawInfoRepository from './rawInfo.repository';
+import memberActivityRepository from './memberActivity.repository';
+import guildMemberRepository from './guildMember.repository';
+import channelRepository from './channel.repository';
+import roleRepository from './role.repository';
+import communityRepository from './community.repository';
+import platformRepository from './platform.repository';
+import announcementRepository from './announcement.repository';
+import moduleRepository from './module.repository';
+
+export {
+  BaseRepository,
+  userRepository,
+  tokenRepository,
+  heatMapRepository,
+  rawInfoRepository,
+  memberActivityRepository,
+  guildMemberRepository,
+  channelRepository,
+  roleRepository,
+  communityRepository,
+  platformRepository,
+  announcementRepository,
+  moduleRepository,
+};

src/repositories/memberActivity.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IMemberActivity } from '../interfaces';
+import MemberActivity from '../models/memberActivity.model';
+
+export class MemberActivityRepository extends BaseRepository<IMemberActivity> {
+  constructor(model: Model<IMemberActivity> = MemberActivity) {
+    super(model);
+  }
+}
+
+export const memberActivityRepository = new MemberActivityRepository();
+export default memberActivityRepository;

src/repositories/module.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IModule } from '../interfaces';
+import Module from '../models/Module.model';
+
+export class ModuleRepository extends BaseRepository<IModule> {
+  constructor(model: Model<IModule> = Module) {
+    super(model);
+  }
+}
+
+export const moduleRepository = new ModuleRepository();
+export default moduleRepository;

src/repositories/platform.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IPlatform } from '../interfaces';
+import Platform from '../models/Platfrom.model';
+
+export class PlatformRepository extends BaseRepository<IPlatform> {
+  constructor(model: Model<IPlatform> = Platform) {
+    super(model);
+  }
+}
+
+export const platformRepository = new PlatformRepository();
+export default platformRepository;

src/repositories/rawInfo.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IRawInfo } from '../interfaces';
+import RawInfo from '../models/RawInfo.model';
+
+export class RawInfoRepository extends BaseRepository<IRawInfo> {
+  constructor(model: Model<IRawInfo> = RawInfo) {
+    super(model);
+  }
+}
+
+export const rawInfoRepository = new RawInfoRepository();
+export default rawInfoRepository;

src/repositories/role.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IRole } from '../interfaces';
+import Role from '../models/Role.model';
+
+export class RoleRepository extends BaseRepository<IRole> {
+  constructor(model: Model<IRole> = Role) {
+    super(model);
+  }
+}
+
+export const roleRepository = new RoleRepository();
+export default roleRepository;

src/repositories/token.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IToken } from '../interfaces';
+import Token from '../models/Token.model';
+
+export class TokenRepository extends BaseRepository<IToken> {
+  constructor(model: Model<IToken> = Token) {
+    super(model);
+  }
+}
+
+export const tokenRepository = new TokenRepository();
+export default tokenRepository;

src/repositories/user.repository.ts

@@ -0,0 +1,13 @@
+import { Model } from 'mongoose';
+import { BaseRepository } from './base.repository';
+import { IUser } from '../interfaces';
+import User from '../models/User.model';
+
+export class UserRepository extends BaseRepository<IUser> {
+  constructor(model: Model<IUser> = User) {
+    super(model);
+  }
+}
+
+export const userRepository = new UserRepository();
+export default userRepository;