brackt/app/models/sport.ts

import { eq, sql } from "drizzle-orm";
import { database } from "~/database/context";
import * as schema from "~/database/schema";

export async function countSports(): Promise<number> {
  const db = database();
  const [{ count }] = await db
    .select({ count: sql<number>`count(*)::int` })
    .from(schema.sports);
  return count;
}

export type Sport = typeof schema.sports.$inferSelect;
export type NewSport = typeof schema.sports.$inferInsert;
export type SportType = "team" | "individual";

export type SportWithActiveSeasons = Sport & {
  activeSeasons: Array<{ id: string; name: string; year: number }>;
};

export async function createSport(data: NewSport): Promise<Sport> {
  const db = database();
  const [sport] = await db
    .insert(schema.sports)
    .values(data)
    .returning();
  return sport;
}

export async function findSportById(id: string): Promise<Sport | undefined> {
  const db = database();
  return await db.query.sports.findFirst({
    where: eq(schema.sports.id, id),
  });
}

export async function findSportBySlug(slug: string): Promise<Sport | undefined> {
  const db = database();
  return await db.query.sports.findFirst({
    where: eq(schema.sports.slug, slug),
  });
}

export async function findAllSports(): Promise<Sport[]> {
  const db = database();
  return await db.query.sports.findMany({
    orderBy: (s, { asc }) => [asc(s.name)],
  });
}

export async function findAllSportsWithActiveSeasons(): Promise<SportWithActiveSeasons[]> {
  const db = database();
  const sports = await db.query.sports.findMany({
    orderBy: (s, { asc }) => [asc(s.name)],
    with: {
      sportsSeasons: {
        where: (ss, { or }) =>
          or(
            eq(ss.status, "active"),
            eq(ss.status, "upcoming")
          ),
        orderBy: (ss, { desc }) => [desc(ss.year)],
      },
    },
  });

  return sports.map((sport) => ({
    ...sport,
    activeSeasons: sport.sportsSeasons.map((season) => ({
      id: season.id,
      name: season.name,
      year: season.year,
    })),
  }));
}

export async function findSportsByType(type: SportType): Promise<Sport[]> {
  const db = database();
  return await db.query.sports.findMany({
    where: eq(schema.sports.type, type),
    orderBy: (s, { asc }) => [asc(s.name)],
  });
}

export async function updateSport(
  id: string,
  data: Partial<NewSport>
): Promise<Sport> {
  const db = database();
  const [sport] = await db
    .update(schema.sports)
    .set({ ...data, updatedAt: new Date() })
    .where(eq(schema.sports.id, id))
    .returning();
  return sport;
}

export async function deleteSport(id: string): Promise<void> {
  const db = database();
  await db.delete(schema.sports).where(eq(schema.sports.id, id));
}