HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/modules/metrics/services/MetricService.ts

import { Prisma } from "@toolctrl/db/prisma-browser";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { db } from "~/utils/db.server";
import { adminGetAllTenantsIdsAndNames } from "~/utils/db/tenants.db.server";
import { adminGetAllUsersNames } from "~/utils/db/users.db.server";
import { getFiltersFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";

const FILTER_OPTION_LIMIT = 200;

async function getGroupBys() {
  const allEnvs = [
    { name: "shared.environments.production", value: "production" },
    { name: "shared.environments.staging", value: "staging" },
    { name: "shared.environments.development", value: "development" },
  ];
  const allTypes = [
    { name: "admin.metrics.types.loader", value: "loader" },
    { name: "admin.metrics.types.action", value: "action" },
  ];
  const [allRoutes, allUrls, allFunctions] = await Promise.all([
    db.metricLog.groupBy({
      by: ["route"],
      _count: { route: true },
      orderBy: { _count: { route: "desc" } },
      take: FILTER_OPTION_LIMIT,
    }),
    db.metricLog.groupBy({
      by: ["url"],
      _count: { url: true },
      orderBy: { _count: { url: "desc" } },
      take: FILTER_OPTION_LIMIT,
    }),
    db.metricLog.groupBy({
      by: ["function"],
      _count: { function: true },
      orderBy: { _count: { function: "desc" } },
      take: FILTER_OPTION_LIMIT,
    }),
  ]);

  return {
    allEnvs,
    allTypes,
    allRoutes,
    allUrls,
    allFunctions,
  };
}
async function getFilterableProperties() {
  const [{ allEnvs, allTypes, allRoutes, allUrls, allFunctions }, tenants, users] = await Promise.all([
    getGroupBys(),
    adminGetAllTenantsIdsAndNames(),
    adminGetAllUsersNames(),
  ]);
  const filterableProperties: FilterablePropertyDto[] = [
    { name: "env", title: "admin.metrics.columns.env", options: allEnvs },
    { name: "type", title: "admin.metrics.columns.type", options: allTypes },
    { name: "route", title: "admin.metrics.columns.route", options: allRoutes.map((item) => ({ name: `${item.route} (${item._count.route})`, value: item.route })) },
    { name: "url", title: "admin.metrics.columns.url", options: allUrls.map((item) => ({ name: `${item.url} (${item._count.url})`, value: item.url })) },
    {
      name: "function",
      title: "admin.metrics.columns.function",
      options: allFunctions.map((item) => ({ name: `${item.function} (${item._count.function})`, value: item.function })),
    },
    {
      name: "tenantId",
      title: "models.tenant.object",
      options: [
        { value: "null", name: "{null}" },
        ...tenants.map((item) => {
          return {
            value: item.id,
            name: item.name,
          };
        }),
      ],
    },
    {
      name: "userId",
      title: "models.user.object",
      options: [
        { value: "null", name: "{null}" },
        ...users.map((item) => {
          return {
            value: item.id,
            name: item.email,
          };
        }),
      ],
    },
  ];
  return filterableProperties;
}
async function getFilters({ request }: { request: Request }) {
  const filterableProperties = await getFilterableProperties();
  // const searchParams = new URL(request.url).searchParams;
  // const current = getPaginationFromCurrentUrl(searchParams);
  const filters = getFiltersFromCurrentUrl(request, filterableProperties);
  const q = filters.query || "";

  const AND_filters: Prisma.MetricLogWhereInput[] = [];
  filterableProperties.forEach((filter) => {
    const value = filters.properties.find((f) => f.name === filter.name)?.value;
    if (value) {
      AND_filters.push({
        [filter.name]: value === "null" ? null : value,
      });
    }
  });

  const OR_filters: Prisma.MetricLogWhereInput[] = [];
  if (q) {
    OR_filters.push(
      { env: { contains: q, mode: "insensitive" } },
      { type: { contains: q, mode: "insensitive" } },
      { route: { contains: q, mode: "insensitive" } },
      { url: { contains: q, mode: "insensitive" } },
      { function: { contains: q, mode: "insensitive" } }
    );
  }

  const whereFilters: Prisma.MetricLogWhereInput = {};
  if (OR_filters.length > 0) {
    whereFilters.OR = OR_filters;
  }
  if (AND_filters.length > 0) {
    whereFilters.AND = AND_filters;
  }

  return { filterableProperties, whereFilters };
}
export default {
  getFilters,
};