Epicnabbo-Catalogus-Updated-Daily/src/lib/admin-list.ts

import { redirect } from "next/navigation";
import { calcPagination, parseListParams } from "./admin-helpers";
import { canAccess, getAdminContext, type PermissionSet } from "./permissions";
import { prisma } from "./prisma";

// biome-ignore lint/suspicious/noExplicitAny: explicitly chosen here, see surrounding code
type PrismaModel = any;

interface AdminListConfig<TRow> {
  /** Permission slug required to view this page */
  permission: string;
  /** Prisma model name (e.g. 'user', 'ban', 'room') */
  model: string;
  /** Search field paths for OR filter. Use dot notation for nested relations (e.g. 'owner.username') */
  searchFields: string[];
  /** Default sort when no sort param provided. Default: { id: 'desc' } */
  defaultSort?: Record<string, "asc" | "desc">;
  /** Default items per page. Default: 20 */
  defaultPerPage?: number;
  /** Prisma include clause for relations */
  include?: Record<string, unknown>;
  /** Prisma select clause (mutually exclusive with include) */
  select?: Record<string, unknown>;
  /** Fixed WHERE conditions merged with search (e.g. { online: '1' }) */
  baseWhere?: Record<string, unknown>;
  /**
   * Map URL ?filter_* params to Prisma WHERE conditions. Each entry receives
   * the raw string value from the URL and returns the WHERE fragment to merge.
   * Returning null/undefined drops the filter.
   *
   * @example
   * filterMap: {
   *   filter_rank: (v) => ({ rank: { gte: Number(v) } }),
   *   filter_online: (v) => ({ online: v }),
   * }
   */
  filterMap?: Record<string, (value: string) => Record<string, unknown> | null | undefined>;
  /** Transform raw Prisma row to the shape needed by the table component */
  mapRow?: (row: PrismaModel) => TRow;
}

interface AdminListResult<TRow> {
  rows: TRow[];
  total: number;
  page: number;
  perPage: number;
  lastPage: number;
  locale: string;
  permissions: PermissionSet;
  rank: number;
}

/**
 * Build a nested Prisma WHERE condition from a dot-notation field path.
 * e.g. 'owner.username' => { owner: { username: { contains: search } } }
 * e.g. 'username' => { username: { contains: search } }
 */
function buildFieldCondition(fieldPath: string, search: string): Record<string, unknown> {
  const parts = fieldPath.split(".");
  if (parts.length === 1) {
    return { [parts[0]]: { contains: search } };
  }
  // Build nested object from right to left
  let result: Record<string, unknown> = { [parts[parts.length - 1]]: { contains: search } };
  for (let i = parts.length - 2; i >= 0; i--) {
    result = { [parts[i]]: result };
  }
  return result;
}

/**
 * Generic admin list data fetcher.
 * Centralizes the common pattern: auth check, param parsing, WHERE/orderBy construction,
 * Prisma query with pagination, and row mapping.
 */
export async function fetchAdminList<TRow = PrismaModel>(
  config: AdminListConfig<TRow>,
  paramsPromise: Promise<{ locale: string }>,
  searchParamsPromise: Promise<Record<string, string>>,
): Promise<AdminListResult<TRow>> {
  const { locale } = await paramsPromise;
  const { session, permissions } = await getAdminContext();

  if (!canAccess(permissions, config.permission, session.user.rank)) {
    redirect("/admin");
  }

  const rawParams = await searchParamsPromise;
  const sp = new URLSearchParams(rawParams);
  const parsed = parseListParams(sp);
  const perPage = config.defaultPerPage ? Number(rawParams.perPage) || config.defaultPerPage : parsed.perPage;
  const { search, page, sort, order } = parsed;

  // Build WHERE clause
  const searchWhere =
    search && config.searchFields.length > 0
      ? { OR: config.searchFields.map((field) => buildFieldCondition(field, search)) }
      : {};

  // Apply URL filter_* params via filterMap
  const filterWhere: Record<string, unknown> = {};
  if (config.filterMap) {
    for (const [paramKey, build] of Object.entries(config.filterMap)) {
      const value = rawParams[paramKey];
      if (!value) continue;
      const fragment = build(value);
      if (fragment) Object.assign(filterWhere, fragment);
    }
  }

  const where = {
    ...(config.baseWhere ?? {}),
    ...filterWhere,
    ...searchWhere,
  };

  // Build orderBy
  const orderBy = sort ? { [sort]: order } : (config.defaultSort ?? { id: "desc" as const });

  // Access Prisma model dynamically
  const delegate = (prisma as PrismaModel)[config.model];

  const queryArgs: PrismaModel = {
    where,
    orderBy,
    skip: (page - 1) * perPage,
    take: perPage,
  };

  if (config.include) queryArgs.include = config.include;
  if (config.select) queryArgs.select = config.select;

  const [rawRows, total] = await Promise.all([delegate.findMany(queryArgs), delegate.count({ where })]);

  const pagination = calcPagination(total, page, perPage);
  const rows = config.mapRow ? rawRows.map(config.mapRow) : rawRows;

  return {
    rows,
    ...pagination,
    locale,
    permissions,
    rank: session.user.rank,
  };
}