gerbeur/api/model/db.ts

import { DatabaseSync, type SQLOutputValue } from "node:sqlite";
import {
  type Comment,
  Dump,
  type Notification,
  type NotificationType,
  type Playlist,
  type RichContent,
  type User,
} from "./interfaces.ts";
import { makeSlug } from "../lib/slugify.ts";

export const db = new DatabaseSync("api/sql/gerbeur.db");
db.exec("PRAGMA foreign_keys = ON;");

// Add columns to existing tables if missing (idempotent migrations)
for (
  const [table, col, def] of [
    ["dumps", "updated_at", "TEXT"],
    ["users", "updated_at", "TEXT"],
    ["playlists", "updated_at", "TEXT"],
    ["comments", "updated_at", "TEXT"],
    ["dumps", "slug", "TEXT"],
    ["playlists", "slug", "TEXT"],
  ] as [string, string, string][]
) {
  const cols = db.prepare(`PRAGMA table_info(${table})`).all() as {
    name: string;
  }[];
  if (!cols.some((c) => c.name === col)) {
    db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def};`);
  }
}

// Backfill slugs for any records created before this migration
for (const table of ["dumps", "playlists"] as const) {
  const rows = db.prepare(
    `SELECT id, title FROM ${table} WHERE slug IS NULL;`,
  ).all() as { id: string; title: string }[];
  const update = db.prepare(`UPDATE ${table} SET slug = ? WHERE id = ?;`);
  for (const row of rows) {
    update.run(makeSlug(row.title, row.id), row.id);
  }
}

// Purge expired unused invites on startup
db.prepare(
  `DELETE FROM invites WHERE used_at IS NULL AND created_at < datetime('now', '-7 days');`,
).run();

/**
 * Database Row Types
 */

export interface DumpRow {
  id: string;
  kind: string;
  title: string;
  comment: string | null;
  user_id: string;
  created_at: string;
  updated_at: string | null;
  slug: string | null;
  url: string | null;
  rich_content: string | null;
  file_name: string | null;
  file_mime: string | null;
  file_size: number | null;
  vote_count: number;
  comment_count: number;
  is_private: number;
  [key: string]: SQLOutputValue; // Index signature
}

export interface UserRow {
  id: string;
  username: string;
  password_hash: string;
  is_admin: number;
  created_at: string;
  updated_at: string | null;
  avatar_mime: string | null;
  invited_by: string | null;
  // Present only when joined: LEFT JOIN users i ON i.id = u.invited_by
  invited_by_username: string | null;
  [key: string]: SQLOutputValue; // Index signature
}

/**
 * Type Guards
 */

export function isDumpRow(obj: Record<string, SQLOutputValue>): obj is DumpRow {
  return !!obj &&
    typeof obj === "object" &&
    "id" in obj && typeof obj.id === "string" &&
    "kind" in obj && typeof obj.kind === "string" &&
    "title" in obj && typeof obj.title === "string" &&
    "comment" in obj &&
    (typeof obj.comment === "string" || obj.comment === null) &&
    "user_id" in obj && typeof obj.user_id === "string" &&
    "created_at" in obj && typeof obj.created_at === "string" &&
    "url" in obj && (typeof obj.url === "string" || obj.url === null) &&
    "rich_content" in obj &&
    (typeof obj.rich_content === "string" || obj.rich_content === null) &&
    "file_name" in obj &&
    (typeof obj.file_name === "string" || obj.file_name === null) &&
    "file_mime" in obj &&
    (typeof obj.file_mime === "string" || obj.file_mime === null) &&
    "file_size" in obj &&
    (typeof obj.file_size === "number" || obj.file_size === null) &&
    "vote_count" in obj && typeof obj.vote_count === "number" &&
    "is_private" in obj && typeof obj.is_private === "number";
}

export function isUserRow(obj: Record<string, SQLOutputValue>): obj is UserRow {
  return !!obj &&
    typeof obj === "object" &&
    "id" in obj && typeof obj.id === "string" &&
    "username" in obj && typeof obj.username === "string" &&
    "password_hash" in obj && typeof obj.password_hash === "string" &&
    "is_admin" in obj && typeof obj.is_admin === "number" &&
    "created_at" in obj && typeof obj.created_at === "string" &&
    "avatar_mime" in obj &&
    (typeof obj.avatar_mime === "string" || obj.avatar_mime === null);
}

/**
 * Conversion Helpers
 */

export function dumpRowToApi(row: DumpRow): Dump {
  return {
    id: row.id,
    kind: row.kind as "url" | "file",
    title: row.title,
    slug: row.slug ?? undefined,
    comment: row.comment ?? undefined,
    userId: row.user_id,
    createdAt: new Date(row.created_at),
    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
    url: row.url ?? undefined,
    richContent: row.rich_content
      ? (JSON.parse(row.rich_content) as RichContent)
      : undefined,
    fileName: row.file_name ?? undefined,
    fileMime: row.file_mime ?? undefined,
    fileSize: row.file_size ?? undefined,
    voteCount: row.vote_count,
    commentCount: row.comment_count,
    isPrivate: Boolean(row.is_private),
  };
}

export function dumpApiToRow(dump: Dump): DumpRow {
  return {
    id: dump.id,
    kind: dump.kind,
    title: dump.title,
    slug: dump.slug ?? null,
    comment: dump.comment ?? null,
    user_id: dump.userId,
    created_at: dump.createdAt.toISOString(),
    updated_at: dump.updatedAt?.toISOString() ?? null,
    url: dump.url ?? null,
    rich_content: dump.richContent ? JSON.stringify(dump.richContent) : null,
    file_name: dump.fileName ?? null,
    file_mime: dump.fileMime ?? null,
    file_size: dump.fileSize ?? null,
    vote_count: dump.voteCount,
    comment_count: dump.commentCount,
    is_private: dump.isPrivate ? 1 : 0,
  };
}

export function userRowToApi(row: UserRow): User {
  return {
    id: row.id,
    username: row.username,
    passwordHash: row.password_hash,
    isAdmin: Boolean(row.is_admin),
    createdAt: new Date(row.created_at),
    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
    avatarMime: row.avatar_mime ?? undefined,
    invitedByUsername: typeof row.invited_by_username === "string"
      ? row.invited_by_username
      : undefined,
  };
}

export function userApiToRow(user: User): UserRow {
  return {
    id: user.id,
    username: user.username,
    password_hash: user.passwordHash,
    is_admin: user.isAdmin ? 1 : 0,
    created_at: user.createdAt.toISOString(),
    updated_at: user.updatedAt?.toISOString() ?? null,
    avatar_mime: user.avatarMime ?? null,
    invited_by: null,
    invited_by_username: null,
  };
}

export interface CommentRow {
  id: string;
  dump_id: string;
  user_id: string;
  parent_id: string | null;
  body: string;
  created_at: string;
  updated_at: string | null;
  deleted: number;
  author_username: string;
  author_avatar_mime: string | null;
  [key: string]: SQLOutputValue;
}

export function isCommentRow(
  obj: Record<string, SQLOutputValue>,
): obj is CommentRow {
  return !!obj && typeof obj === "object" &&
    typeof obj.id === "string" &&
    typeof obj.dump_id === "string" &&
    typeof obj.user_id === "string" &&
    (typeof obj.parent_id === "string" || obj.parent_id === null) &&
    typeof obj.body === "string" &&
    typeof obj.created_at === "string" &&
    typeof obj.deleted === "number" &&
    typeof obj.author_username === "string" &&
    (typeof obj.author_avatar_mime === "string" ||
      obj.author_avatar_mime === null);
}

export function commentRowToApi(row: CommentRow): Comment {
  return {
    id: row.id,
    dumpId: row.dump_id,
    userId: row.user_id,
    parentId: row.parent_id ?? undefined,
    body: row.body,
    createdAt: new Date(row.created_at),
    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
    deleted: Boolean(row.deleted),
    authorUsername: row.author_username,
    authorAvatarMime: row.author_avatar_mime ?? undefined,
  };
}

export interface PlaylistRow {
  id: string;
  user_id: string;
  title: string;
  slug: string | null;
  description: string | null;
  is_public: number;
  created_at: string;
  updated_at: string | null;
  image_mime: string | null;
  [key: string]: SQLOutputValue;
}

export function isPlaylistRow(
  obj: Record<string, SQLOutputValue>,
): obj is PlaylistRow {
  return !!obj && typeof obj.id === "string" &&
    typeof obj.user_id === "string" &&
    typeof obj.title === "string" &&
    typeof obj.is_public === "number" &&
    typeof obj.created_at === "string";
}

export function playlistRowToApi(row: PlaylistRow): Playlist {
  return {
    id: row.id,
    userId: row.user_id,
    title: row.title,
    slug: row.slug ?? undefined,
    description: row.description ?? undefined,
    isPublic: Boolean(row.is_public),
    createdAt: new Date(row.created_at),
    updatedAt: row.updated_at ? new Date(row.updated_at) : undefined,
    imageMime: row.image_mime ?? undefined,
    dumpCount: typeof row.dump_count === "number" ? row.dump_count : undefined,
    ownerUsername: typeof row.owner_username === "string"
      ? row.owner_username
      : undefined,
  };
}

export interface FollowRow {
  id: string;
  follower_id: string;
  followed_user_id: string | null;
  followed_playlist_id: string | null;
  created_at: string;
  [key: string]: SQLOutputValue;
}

export function isFollowRow(
  obj: Record<string, SQLOutputValue>,
): obj is FollowRow {
  return !!obj &&
    typeof obj.id === "string" &&
    typeof obj.follower_id === "string" &&
    typeof obj.created_at === "string" &&
    (obj.followed_user_id === null ||
      typeof obj.followed_user_id === "string") &&
    (obj.followed_playlist_id === null ||
      typeof obj.followed_playlist_id === "string");
}

// ── Notifications ─────────────────────────────────────────────────────────────

export interface NotificationRow {
  id: string;
  user_id: string;
  type: string;
  data: string;
  read: number;
  created_at: string;
  source_key: string | null;
  [key: string]: SQLOutputValue;
}

export function isNotificationRow(
  obj: Record<string, SQLOutputValue>,
): obj is NotificationRow {
  return !!obj && typeof obj === "object" &&
    typeof obj.id === "string" &&
    typeof obj.user_id === "string" &&
    typeof obj.type === "string" &&
    typeof obj.data === "string" &&
    typeof obj.read === "number" &&
    typeof obj.created_at === "string";
}

export function notificationRowToApi(row: NotificationRow): Notification {
  return {
    id: row.id,
    userId: row.user_id,
    type: row.type as NotificationType,
    data: JSON.parse(row.data),
    read: Boolean(row.read),
    createdAt: new Date(row.created_at),
  };
}

// ── Invites ───────────────────────────────────────────────────────────────────

export interface InviteRow {
  token: string;
  inviter_id: string;
  used_at: string | null;
  created_at: string;
  [key: string]: SQLOutputValue;
}

export function isInviteRow(
  obj: Record<string, SQLOutputValue>,
): obj is InviteRow {
  return !!obj && typeof obj === "object" &&
    typeof obj.token === "string" &&
    typeof obj.inviter_id === "string" &&
    typeof obj.created_at === "string" &&
    (obj.used_at === null || typeof obj.used_at === "string");
}