first commit

server/src/Models/Favourites/Favourites.Adapter.Mongoose.ts

@@ -0,0 +1,89 @@
+import {
+    IFavourite,
+    IFavouriteDocument,
+    IFavouritesAdapter,
+    CreateFavouriteParams,
+    DeleteFavouriteParams,
+    FindFavouritesParams,
+    PaginateFavouritesParams,
+    PaginateFavouritesResults,
+} from "./Favourites.interface";
+import { Schema, model, Model, FilterQuery } from "mongoose";
+
+export class FavouritesAdapterMongoose implements IFavouritesAdapter {
+    schema: Schema;
+    favouritesList: Model<IFavouriteDocument>;
+
+    constructor() {
+        this.schema = new Schema({
+            userId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "User",
+            },
+            serviceId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "Service",
+            },
+            createdAt: { type: Date, default: Date.now, required: true },
+        });
+
+        this.favouritesList = model<IFavouriteDocument>("Favourite", this.schema);
+    }
+
+    public async create(data: Omit<CreateFavouriteParams, "sessionUser">): Promise<IFavourite> {
+        return await this.favouritesList.create(data);
+    }
+
+    public async delete(data: Omit<DeleteFavouriteParams, "sessionUser">): Promise<void> {
+        await this.favouritesList.deleteOne({ _id: data.id });
+    }
+
+    public async find(filters: Omit<FindFavouritesParams, "sessionUser">): Promise<IFavourite[]> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return await this.favouritesList.find(searchCriteria).exec();
+    }
+
+    public async findOne(
+        filters: Omit<FindFavouritesParams, "sessionUser">
+    ): Promise<IFavouriteDocument | null> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return await this.favouritesList.findOne(searchCriteria).exec();
+    }
+
+        private buildSearchCriteria(
+        filters: Omit<FindFavouritesParams, "sessionUser">
+    ): FilterQuery<IFavourite> {
+        const searchCriteria: FilterQuery<IFavourite> = {};
+
+        if (filters.id) searchCriteria._id = filters.id;
+        if (filters.userId) searchCriteria.userId = filters.userId;
+        if (filters.serviceId) searchCriteria.serviceId = filters.serviceId;
+
+        if (filters.startDate && filters.endDate) {
+            searchCriteria.createdAt = {
+                $gte: filters.startDate,
+                $lte: filters.endDate,
+            };
+        }
+
+        return searchCriteria;
+    }
+
+    public async paginate(filters: PaginateFavouritesParams): Promise<PaginateFavouritesResults> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+
+        const count = await this.favouritesList.countDocuments(searchCriteria).exec();
+        const skip = (filters.page - 1) * filters.limit;
+
+        const results = await this.favouritesList
+            .find(searchCriteria)
+            .skip(skip)
+            .limit(filters.limit)
+            .sort({ createdAt: -1 })
+            .exec();
+
+        return { data: results, page: filters.page, pages: Math.ceil(count / filters.limit) };
+    }
+}

server/src/Models/Favourites/Favourites.interface.ts

@@ -0,0 +1,59 @@
+import { Document } from "mongoose";
+
+export interface IFavourite {
+    id?: string;
+    _id?: string;
+    userId: string;
+    serviceId: string;
+    createdAt: Date;
+}
+
+export interface IFavouriteDocument extends Omit<IFavourite, "id" | "_id">, Document {
+    _id: string;
+}
+
+export interface IFavouritesAdapter {
+    create(data: Omit<CreateFavouriteParams, "sessionUser">): Promise<IFavourite>;
+    delete(data: Omit<DeleteFavouriteParams, "sessionUser">): Promise<void>;
+    find(filters: Omit<FindFavouritesParams, "sessionUser">): Promise<IFavourite[]>;
+    findOne(filters: Omit<FindFavouritesParams, "sessionUser">): Promise<IFavouriteDocument | null>;
+    paginate(filters: PaginateFavouritesParams): Promise<PaginateFavouritesResults>;
+}
+
+export type FindFavouritesParams = {
+    id?: string;
+    userId?: string;
+    serviceId?: string;
+    sessionUser: string;
+    startDate?: Date;
+    endDate?: Date;
+};
+
+export type PaginateFavouritesParams = FindFavouritesParams & {
+    page: number;
+    limit: number;
+};
+
+export type PaginateFavouritesResults = {
+    data: IFavourite[];
+    page: number;
+    pages: number;
+};
+
+export type CreateFavouriteParams = {
+    userId: string;
+    serviceId: string;
+    sessionUser: string;
+};
+
+export type DeleteFavouriteParams = {
+    id: string;
+    sessionUser: string;
+};
+
+export interface IFavouritesManager {
+    favourites: IFavouritesAdapter;
+    createFavourite(data: CreateFavouriteParams): Promise<IFavourite>;
+    deleteFavourite(data: DeleteFavouriteParams): Promise<void>;
+    paginate(data: PaginateFavouritesParams): Promise<PaginateFavouritesResults>;
+}

server/src/Models/Favourites/Favourites.ts

@@ -0,0 +1,50 @@
+import { validateSessionUser } from "../../helpers/check";
+import {
+    IFavouritesManager,
+    IFavouritesAdapter,
+    CreateFavouriteParams,
+    DeleteFavouriteParams,
+    IFavourite,
+    PaginateFavouritesParams,
+    PaginateFavouritesResults,
+} from "./Favourites.interface";
+
+export class FavouritesManager implements IFavouritesManager {
+    favourites: IFavouritesAdapter;
+
+    constructor(favouritesAdapter: IFavouritesAdapter) {
+        this.favourites = favouritesAdapter;
+    }
+
+    async createFavourite(data: CreateFavouriteParams): Promise<IFavourite> {
+        await validateSessionUser({
+            sessionUser: data.sessionUser,
+        });
+
+        const favourite = await this.favourites.create(data);
+
+        if (!favourite) {
+            throw new Error("Ha ocurrido un error al crear el favorito");
+        }
+
+        return favourite;
+    }
+
+    async deleteFavourite(data: DeleteFavouriteParams): Promise<void> {
+        await validateSessionUser({
+            sessionUser: data.sessionUser,
+        });
+
+        const favourite = await this.favourites.findOne({ id: data.id });
+
+        if (!favourite) {
+            throw new Error("El favorito que intenta eliminar no existe");
+        }
+
+        await this.favourites.delete(data);
+    }
+
+    async paginate(data: PaginateFavouritesParams): Promise<PaginateFavouritesResults> {
+        return this.favourites.paginate(data);
+    }
+}