Musare/backend/src/modules/DataModule/plugins/getData.ts

import { PipelineStage, Schema, SchemaTypes } from "mongoose";

export enum FilterType {
	REGEX = "regex",
	CONTAINS = "contains",
	EXACT = "exact",
	DATETIME_BEFORE = "datetimeBefore",
	DATETIME_AFTER = "datetimeAfter",
	NUMBER_LESSER_EQUAL = "numberLesserEqual",
	NUMBER_LESSER = "numberLesser",
	NUMBER_GREATER = "numberGreater",
	NUMBER_GREATER_EQUAL = "numberGreaterEqual",
	NUMBER_EQUAL = "numberEquals",
	BOOLEAN = "boolean",
	SPECIAL = "special"
}

export interface GetData {
	getData(payload: {
		page: number;
		pageSize: number;
		properties: string[];
		sort: Record<string, "ascending" | "descending">;
		queries: {
			data: any;
			filter: {
				property: string;
			};
			filterType: FilterType;
		}[];
		operator: "and" | "or" | "nor";
	}): Promise<{
		data: any[];
		count: number;
	}>;
}

export default function getDataPlugin(schema: Schema) {
	schema.static(
		"getData",
		async function getData(
			payload: Parameters<GetData["getData"]>[0]
		): ReturnType<GetData["getData"]> {
			const { page, pageSize, properties, sort, queries, operator } =
				payload;

			const getData = schema.get("getData");
			if (!getData)
				throw new Error("Schema doesn't have getData defined.");
			const {
				blacklistedProperties,
				specialFilters,
				specialProperties,
				specialQueries
			} = getData;

			const pipeline: PipelineStage[] = [];

			// If a query filter property or sort property is blacklisted, throw error
			if (Array.isArray(blacklistedProperties)) {
				if (
					queries.some(query =>
						blacklistedProperties.some(blacklistedProperty =>
							blacklistedProperty.startsWith(
								query.filter.property
							)
						)
					)
				)
					throw new Error(
						"Unable to filter by blacklisted property."
					);
				if (
					Object.keys(sort).some(property =>
						blacklistedProperties.some(blacklistedProperty =>
							blacklistedProperty.startsWith(property)
						)
					)
				)
					throw new Error("Unable to sort by blacklisted property.");
			}

			// If a filter or property exists for a special property, add some custom pipeline steps
			if (typeof specialProperties === "object")
				Object.entries(specialProperties).forEach(
					([specialProperty, pipelineSteps]) => {
						// Check if a filter with the special property exists
						const filterExists =
							queries
								.map(query => query.filter.property)
								.indexOf(specialProperty) !== -1;

						// Check if a property with the special property exists
						const propertyExists =
							properties.indexOf(specialProperty) !== -1;

						// If no such filter or property exists, skip this function
						if (!filterExists && !propertyExists) return;

						// Add the specified pipeline steps into the pipeline
						pipeline.push(...pipelineSteps);
					}
				);

			// Adds the match stage to aggregation pipeline, which is responsible for filtering
			const filterQueries = queries.flatMap(query => {
				const { data, filter, filterType } = query;
				const { property } = filter;

				const newQuery: any = {};
				switch (filterType) {
					case FilterType.REGEX:
						newQuery[property] = new RegExp(
							`${data.slice(1, data.length - 1)}`,
							"i"
						);
						break;
					case FilterType.CONTAINS:
						newQuery[property] = new RegExp(
							`${data.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")}`,
							"i"
						);
						break;
					case FilterType.EXACT:
						newQuery[property] = data.toString();
						break;
					case FilterType.DATETIME_BEFORE:
						newQuery[property] = { $lte: new Date(data) };
						break;
					case FilterType.DATETIME_AFTER:
						newQuery[property] = { $gte: new Date(data) };
						break;
					case FilterType.NUMBER_LESSER_EQUAL:
						newQuery[property] = { $lte: Number(data) };
						break;
					case FilterType.NUMBER_LESSER:
						newQuery[property] = { $lt: Number(data) };
						break;
					case FilterType.NUMBER_GREATER:
						newQuery[property] = { $gt: Number(data) };
						break;
					case FilterType.NUMBER_GREATER_EQUAL:
						newQuery[property] = { $gte: Number(data) };
						break;
					case FilterType.NUMBER_EQUAL:
						newQuery[property] = { $eq: Number(data) };
						break;
					case FilterType.BOOLEAN:
						newQuery[property] = { $eq: !!data };
						break;
					case FilterType.SPECIAL:
						if (
							typeof specialFilters === "object" &&
							typeof specialFilters[filter.property] ===
								"function"
						) {
							pipeline.push(
								...specialFilters[filter.property](data)
							);
							newQuery[property] = { $eq: true };
						}
						break;
					default:
						throw new Error(`Invalid filter type for "${filter}"`);
				}

				if (
					typeof specialQueries === "object" &&
					typeof specialQueries[filter.property] === "function"
				) {
					return specialQueries[filter.property](newQuery);
				}

				return newQuery;
			});

			const filterQuery: any = {};

			if (filterQueries.length > 0)
				filterQuery[`$${operator}`] = filterQueries;

			pipeline.push({ $match: filterQuery });

			// Adds sort stage to aggregation pipeline if there is at least one column being sorted, responsible for sorting data
			if (Object.keys(sort).length > 0)
				pipeline.push({
					$sort: Object.fromEntries(
						Object.entries(sort).map(([property, direction]) => [
							property,
							direction === "ascending" ? 1 : -1
						])
					)
				});

			// Adds first project stage to aggregation pipeline, responsible for including only the requested properties
			pipeline.push({
				$project: Object.fromEntries(
					properties.map(property => [property, 1])
				)
			});

			// Adds second project stage to aggregation pipeline, responsible for excluding some specific properties
			if (
				Array.isArray(blacklistedProperties) &&
				blacklistedProperties.length > 0
			)
				pipeline.push({
					$project: Object.fromEntries(
						blacklistedProperties.map(property => [property, 0])
					)
				});

			// Adds the facet stage to aggregation pipeline, responsible for returning a total document count, skipping and limitting the documents that will be returned
			pipeline.push({
				$facet: {
					count: [{ $count: "count" }],
					documents: [
						{ $skip: pageSize * (page - 1) },
						{ $limit: pageSize }
					]
				}
			});

			// Executes the aggregation pipeline
			const [result] = await this.aggregate(pipeline).exec();

			if (result.count.length === 0) return { data: [], count: 0 };

			properties.forEach(property => {
				const type = schema.path(property);
				if (type instanceof SchemaTypes.ObjectId) {
					const { ref } = type?.options ?? {};
					if (ref) {
						result.documents = result.documents.map(
							(document: any) => ({
								...document,
								[property]: {
									_name: ref,
									_id: document[property]
								}
							})
						);
					}
				} else if (
					type instanceof SchemaTypes.Array &&
					type.caster instanceof SchemaTypes.ObjectId
				) {
					console.log("Array relation not implemented", property);
				}
			});

			result.documents = result.documents.map((document: any) => ({
				...document,
				// TODO properly support getModelName in TypeScript
				// eslint-disable-next-line
				// @ts-ignore
				_name: schema.statics.getModelName()
			}));

			const { documents: data } = result;
			const { count } = result.count[0];

			return { data, count };
		}
	);
}