homeio

1import "server-only";
2
3import { eq, sql } from "drizzle-orm";
4import { db } from "@/lib/server/db/drizzle";
5import { filesTrashEntries } from "@/lib/server/db/schema";
6
7export type TrashEntryRecord = {
8  id: string;
9  trashPath: string;
10  originalPath: string;
11  deletedAt: Date;
12};
13
14export type UpsertTrashEntryInput = {
15  id: string;
16  trashPath: string;
17  originalPath: string;
18  deletedAt?: Date;
19};
20
21let ensureTrashEntriesTablePromise: Promise<void> | null = null;
22
23async function ensureTrashEntriesTable() {
24  if (!ensureTrashEntriesTablePromise) {
25    ensureTrashEntriesTablePromise = (async () => {
26      await db.execute(sql`
27        CREATE TABLE IF NOT EXISTS files_trash_entries (
28          id text PRIMARY KEY,
29          trash_path text NOT NULL,
30          original_path text NOT NULL,
31          deleted_at timestamptz NOT NULL DEFAULT NOW()
32        )
33      `);
34      await db.execute(sql`
35        CREATE UNIQUE INDEX IF NOT EXISTS files_trash_entries_trash_path_idx
36        ON files_trash_entries (trash_path)
37      `);
38      await db.execute(sql`
39        CREATE INDEX IF NOT EXISTS files_trash_entries_deleted_at_idx
40        ON files_trash_entries (deleted_at DESC)
41      `);
42    })().catch((error) => {
43      ensureTrashEntriesTablePromise = null;
44      throw error;
45    });
46  }
47
48  await ensureTrashEntriesTablePromise;
49}
50
51function toRecord(row: {
52  id: string;
53  trashPath: string;
54  originalPath: string;
55  deletedAt: Date;
56}): TrashEntryRecord {
57  return {
58    id: row.id,
59    trashPath: row.trashPath,
60    originalPath: row.originalPath,
61    deletedAt: row.deletedAt,
62  };
63}
64
65export async function upsertTrashEntryInDb(input: UpsertTrashEntryInput) {
66  await ensureTrashEntriesTable();
67
68  const deletedAt = input.deletedAt ?? new Date();
69
70  const rows = await db
71    .insert(filesTrashEntries)
72    .values({
73      id: input.id,
74      trashPath: input.trashPath,
75      originalPath: input.originalPath,
76      deletedAt,
77    })
78    .onConflictDoUpdate({
79      target: filesTrashEntries.trashPath,
80      set: {
81        originalPath: input.originalPath,
82        deletedAt,
83      },
84    })
85    .returning({
86      id: filesTrashEntries.id,
87      trashPath: filesTrashEntries.trashPath,
88      originalPath: filesTrashEntries.originalPath,
89      deletedAt: filesTrashEntries.deletedAt,
90    });
91
92  if (!rows[0]) {
93    throw new Error("Failed to upsert trash entry");
94  }
95
96  return toRecord(rows[0]);
97}
98
99export async function getTrashEntryFromDb(trashPath: string) {
100  await ensureTrashEntriesTable();
101
102  const rows = await db
103    .select({
104      id: filesTrashEntries.id,
105      trashPath: filesTrashEntries.trashPath,
106      originalPath: filesTrashEntries.originalPath,
107      deletedAt: filesTrashEntries.deletedAt,
108    })
109    .from(filesTrashEntries)
110    .where(eq(filesTrashEntries.trashPath, trashPath))
111    .limit(1);
112
113  return rows[0] ? toRecord(rows[0]) : null;
114}
115
116export async function deleteTrashEntryFromDb(trashPath: string) {
117  await ensureTrashEntriesTable();
118
119  const rows = await db
120    .delete(filesTrashEntries)
121    .where(eq(filesTrashEntries.trashPath, trashPath))
122    .returning({
123      id: filesTrashEntries.id,
124      trashPath: filesTrashEntries.trashPath,
125      originalPath: filesTrashEntries.originalPath,
126      deletedAt: filesTrashEntries.deletedAt,
127    });
128
129  return rows[0] ? toRecord(rows[0]) : null;
130}
131
132export async function listTrashEntriesFromDb() {
133  await ensureTrashEntriesTable();
134
135  const rows = await db
136    .select({
137      id: filesTrashEntries.id,
138      trashPath: filesTrashEntries.trashPath,
139      originalPath: filesTrashEntries.originalPath,
140      deletedAt: filesTrashEntries.deletedAt,
141    })
142    .from(filesTrashEntries);
143
144  return rows.map(toRecord);
145}
146
147export async function deleteAllTrashEntriesFromDb() {
148  await ensureTrashEntriesTable();
149
150  const rows = await db
151    .delete(filesTrashEntries)
152    .returning({
153      id: filesTrashEntries.id,
154      trashPath: filesTrashEntries.trashPath,
155      originalPath: filesTrashEntries.originalPath,
156      deletedAt: filesTrashEntries.deletedAt,
157    });
158
159  return rows.map(toRecord);
160}
161