gerbeur/api/services/follow-service.ts

import {
  APIErrorCode,
  APIException,
  type Dump,
  type FollowStatus,
  type Playlist,
  type User,
} from "../model/interfaces.ts";
import {
  notifyPlaylistOwnerNewFollower,
  notifyUserNewFollower,
} from "./notification-service.ts";
import {
  db,
  DUMP_SELECT_COLUMNS_ALIASED as SELECT_COLS_ALIASED,
  dumpRowToApi,
  isDumpRow,
  isFollowRow,
  isPlaylistRow,
  isUserRow,
  playlistRowToApi,
  userRowToApi,
} from "../model/db.ts";
import { type Page, pageOf } from "../lib/pagination.ts";
import { attachCategoryIds } from "./category-service.ts";

// ── Follow / unfollow a user ──────────────────────────────────────────────────

export function followUser(followerId: string, followedUserId: string): void {
  if (followerId === followedUserId) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      "Cannot follow yourself",
    );
  }
  let isNew = true;
  try {
    db.prepare(
      `INSERT INTO follows (id, follower_id, followed_user_id, created_at)
       VALUES (?, ?, ?, ?);`,
    ).run(
      crypto.randomUUID(),
      followerId,
      followedUserId,
      new Date().toISOString(),
    );
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    if (msg.toLowerCase().includes("unique")) {
      isNew = false;
    } else {
      throw err;
    }
  }
  if (isNew) notifyUserNewFollower(followerId, followedUserId);
}

export function unfollowUser(followerId: string, followedUserId: string): void {
  db.prepare(
    `DELETE FROM follows WHERE follower_id = ? AND followed_user_id = ?;`,
  ).run(followerId, followedUserId);
}

// ── Follow / unfollow a playlist ─────────────────────────────────────────────

export function followPlaylist(followerId: string, playlistId: string): void {
  const row = db.prepare(
    `SELECT id, is_public FROM playlists WHERE id = ?;`,
  ).get(playlistId) as { id: string; is_public: number } | undefined;

  if (!row) {
    throw new APIException(APIErrorCode.NOT_FOUND, 404, "Playlist not found");
  }
  if (!row.is_public) {
    throw new APIException(
      APIErrorCode.UNAUTHORIZED,
      403,
      "Cannot follow a private playlist",
    );
  }

  let isNew = true;
  try {
    db.prepare(
      `INSERT INTO follows (id, follower_id, followed_playlist_id, created_at)
       VALUES (?, ?, ?, ?);`,
    ).run(
      crypto.randomUUID(),
      followerId,
      playlistId,
      new Date().toISOString(),
    );
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    if (msg.toLowerCase().includes("unique")) {
      isNew = false;
    } else {
      throw err;
    }
  }
  if (isNew) notifyPlaylistOwnerNewFollower(followerId, playlistId);
}

export function unfollowPlaylist(followerId: string, playlistId: string): void {
  db.prepare(
    `DELETE FROM follows WHERE follower_id = ? AND followed_playlist_id = ?;`,
  ).run(followerId, playlistId);
}

// ── Follow status ─────────────────────────────────────────────────────────────

export function getFollowStatus(followerId: string): FollowStatus {
  const rawUserRows = db.prepare(
    `SELECT id, follower_id, followed_user_id, followed_playlist_id, created_at
     FROM follows WHERE follower_id = ? AND followed_user_id IS NOT NULL;`,
  ).all(followerId);

  const rawPlaylistRows = db.prepare(
    `SELECT id, follower_id, followed_user_id, followed_playlist_id, created_at
     FROM follows WHERE follower_id = ? AND followed_playlist_id IS NOT NULL;`,
  ).all(followerId);

  if (!rawUserRows.every(isFollowRow) || !rawPlaylistRows.every(isFollowRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed follow data",
    );
  }

  return {
    followedUserIds: rawUserRows.map((r) => r.followed_user_id!),
    followedPlaylistIds: rawPlaylistRows.map((r) => r.followed_playlist_id!),
  };
}

// ── Followed-users feed ───────────────────────────────────────────────────────

export function getFollowedUsersDumpFeed(
  followerId: string,
  page: number,
  limit: number,
  categoryId?: string,
): Page<Dump> {
  const offset = (page - 1) * limit;

  // Optional category filter: join the membership table and constrain to it.
  const catJoin = categoryId
    ? "INNER JOIN dump_categories dc ON dc.dump_id = d.id AND dc.category_id = ?"
    : "";
  const catParams = categoryId ? [categoryId] : [];

  const rawRows = db.prepare(
    `SELECT ${SELECT_COLS_ALIASED}
     FROM dumps d
     INNER JOIN follows f ON f.followed_user_id = d.user_id
     ${catJoin}
     WHERE f.follower_id = ?
       AND d.is_private = 0
     ORDER BY d.created_at DESC
     LIMIT ? OFFSET ?;`,
  ).all(...catParams, followerId, limit + 1, offset);

  const userFeedRows = rawRows as Parameters<typeof isDumpRow>[0][];
  if (!userFeedRows.every(isDumpRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed dump data",
    );
  }
  const items = userFeedRows.map(dumpRowToApi);
  attachCategoryIds(items);
  return pageOf(items, limit);
}

// ── Followed-playlists dump feed ──────────────────────────────────────────────

export function getFollowedPlaylistsDumpFeed(
  followerId: string,
  page: number,
  limit: number,
  categoryId?: string,
): Page<Dump> {
  const offset = (page - 1) * limit;

  const catJoin = categoryId
    ? "INNER JOIN dump_categories dc ON dc.dump_id = d.id AND dc.category_id = ?"
    : "";
  const catParams = categoryId ? [categoryId] : [];

  const rawRows = db.prepare(
    `SELECT ${SELECT_COLS_ALIASED}
     FROM dumps d
     INNER JOIN playlist_dumps pd ON pd.dump_id = d.id
     INNER JOIN playlists p ON p.id = pd.playlist_id
     INNER JOIN follows f ON f.followed_playlist_id = p.id
     ${catJoin}
     WHERE f.follower_id = ?
       AND p.is_public = 1
       AND d.is_private = 0
     GROUP BY d.id
     ORDER BY MAX(pd.added_at) DESC
     LIMIT ? OFFSET ?;`,
  ).all(...catParams, followerId, limit + 1, offset);

  if (!rawRows.every(isDumpRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed dump data",
    );
  }
  const items = rawRows.map(dumpRowToApi);
  attachCategoryIds(items);
  return pageOf(items, limit);
}

// ── Followed playlists (as playlist objects) ──────────────────────────────────

export function getFollowedPlaylistsByUser(
  userId: string,
  page: number,
  limit: number,
): Page<Playlist> {
  const offset = (page - 1) * limit;

  const rawRows = db.prepare(
    `SELECT p.*, u.username as owner_username,
       (SELECT COUNT(*) FROM playlist_dumps pd WHERE pd.playlist_id = p.id) as dump_count
     FROM playlists p
     LEFT JOIN users u ON u.id = p.user_id
     INNER JOIN follows f ON f.followed_playlist_id = p.id
     WHERE f.follower_id = ?
       AND p.is_public = 1
     ORDER BY f.created_at DESC
     LIMIT ? OFFSET ?;`,
  ).all(userId, limit + 1, offset);

  if (!rawRows.every(isPlaylistRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed playlist data",
    );
  }
  return pageOf(rawRows.map(playlistRowToApi), limit);
}

// ── Followed users (as user objects) ─────────────────────────────────────────

export function getFollowedUsersByUser(
  userId: string,
  page: number,
  limit: number,
): Page<User> {
  const offset = (page - 1) * limit;

  const rawRows = db.prepare(
    `SELECT u.id, u.username, u.password_hash, u.role, u.created_at, u.updated_at,
            u.avatar_mime, u.description, u.invited_by, u.email,
            i.username as invited_by_username
     FROM users u
     LEFT JOIN users i ON i.id = u.invited_by
     INNER JOIN follows f ON f.followed_user_id = u.id
     WHERE f.follower_id = ?
     ORDER BY f.created_at DESC
     LIMIT ? OFFSET ?;`,
  ).all(userId, limit + 1, offset);

  if (!rawRows.every(isUserRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed user data",
    );
  }

  return pageOf(rawRows.map(userRowToApi), limit);
}