s

lib/api.ts

@@ -1,7 +1,6 @@
 "use server";
 
 import { eq, inArray, not, sql } from "drizzle-orm";
-import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
 import { revalidatePath } from "next/cache";
 import { redirect } from "next/navigation";
 import { apiAuthCheck } from "./auth";
@@ -139,42 +138,58 @@ export async function random() {
   else throw "ไม่พบผู้ลงทะเบียนที่ยังไม่ตรวจสอบ";
 }
 
-export async function reorder(
+/*export async function reorder(
   table: PgTable & { id: PgColumn; order: PgColumn },
-  id: string,
-  position: number,
+  target: string | { id: string; order: number },
+  data: Partial<{ id: string; order: number }>,
 ) {
-  await db
-    .update(table)
-    .set({
-      order: sql`
-      (
-        SELECT (prev_order + next_order) / 2
-        FROM (
-          SELECT "order",
-                 lag("order") OVER (ORDER BY "order") AS prev_order,
-                 lead("order") OVER (ORDER BY "order") AS next_order,
-                 row_number() OVER (ORDER BY "order") AS rn
-          FROM ${table}
-        ) sub
-        WHERE rn = ${position}
-      )
-    `,
-    })
-    .where(eq(table.id, id));
-}
+  return await db.transaction(async (tx) => {
+    const [item] =
+      typeof target === "string"
+        ? ((await tx.select().from(table).where(eq(table.id, target))) as {
+            id: string;
+            order: number;
+          }[])
+        : [target];
 
-export async function untangle(
-  table: PgTable & { id: PgColumn; order: PgColumn },
-) {
-  await db.execute(sql`
-    WITH ordered AS (
-      SELECT id, row_number() OVER (ORDER BY "order") * 10 AS new_order
-      FROM ${table}
-    )
-    UPDATE ${table} t
-    SET "order" = o.new_order
-    FROM ordered o
-    WHERE t.id = o.id;
-  `);
-}
+    if (!item) throw new Error("Item not found");
+
+    const newOrder = data.order;
+    if (newOrder != null && newOrder !== item.order) {
+      // Moving up
+      if (newOrder < item.order) {
+        await tx
+          .update(table)
+          .set({ order: sql`${table.order} + 1` })
+          .where(
+            and(
+              eq(table.list, item.list),
+              gte(table.order, newOrder),
+              lt(table.order, item.order),
+            ),
+          );
+      }
+      // Moving down
+      else {
+        await tx
+          .update(tierlistStates)
+          .set({ order: sql`${tierlistStates.order} - 1` })
+          .where(
+            and(
+              eq(tierlistStates.list, item.list),
+              lte(tierlistStates.order, newOrder),
+              gt(tierlistStates.order, item.order),
+            ),
+          );
+      }
+    }
+
+    // Finally, move the item itself
+    await tx
+      .update(tierlistStates)
+      .set(data)
+      .where(eq(tierlistStates.id, item.id));
+
+    return { ...item, ...data };
+  });
+}*/

lib/db/schema.ts

@@ -3,7 +3,7 @@ import {
   boolean,
   date,
   integer,
-  numeric,
+  jsonb,
   pgEnum,
   pgSchema,
   pgTable,
@@ -44,15 +44,18 @@ export const characters = pgTable("characters", {
   name: text().unique().notNull(), // Qiqi
   version: text()
     .notNull()
-    .references(() => versions.id), // Li-A
+    .references(() => versions.id, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    }), // Li-A
   stars: integer().notNull().$type<4 | 5>(),
   vision: element().notNull(),
   image: text()
     .notNull()
-    .references(() => cdn.id),
+    .references(() => cdn.id, { onDelete: "cascade", onUpdate: "cascade" }),
   weapon: text().notNull(),
   amber: text().notNull(), // Amber character ID
-  order: numeric().notNull(),
+  order: integer().notNull(),
 });
 
 export const versions = pgTable("versions", {
@@ -79,7 +82,10 @@ export const submissions = artifact.table("submissions", {
   comment: text().notNull(),
   char: text()
     .notNull()
-    .references(() => characters.name),
+    .references(() => characters.name, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    }),
   queue: serial(),
   checked: boolean().notNull().default(false),
 });
@@ -98,30 +104,44 @@ export const tierlist = pgSchema("tierlist");
 export const tierlistTypes = tierlist.table("types", {
   id: text().primaryKey().$defaultFn(uuidv7),
   name: text().notNull(),
-  image: text().references(() => cdn.id),
-  order: numeric().notNull(),
+  image: text().references(() => cdn.id, {
+    onDelete: "cascade",
+    onUpdate: "cascade",
+  }),
+  order: integer().notNull(),
 });
 
 export const tierlistTiers = tierlist.table("tiers", {
   id: text().primaryKey().$defaultFn(uuidv7),
   name: text().notNull(),
-  badges: text().references(()=>tierlistBadges.id).array(),
-  image: text().references(() => cdn.id),
-  order: numeric().notNull(),
+  badges: text()
+    .references(() => tierlistBadges.id)
+    .array(),
+  image: text().references(() => cdn.id, {
+    onDelete: "cascade",
+    onUpdate: "cascade",
+  }),
+  order: integer().notNull(),
 });
 
 export const tierlistColumns = tierlist.table("columns", {
   id: text().primaryKey().$defaultFn(uuidv7),
   name: text().notNull(),
-  image: text().references(() => cdn.id),
-  order: numeric().notNull(),
+  image: text().references(() => cdn.id, {
+    onDelete: "cascade",
+    onUpdate: "cascade",
+  }),
+  order: integer().notNull(),
 });
 
 export const tierlistBadges = tierlist.table("badges", {
   id: text().primaryKey().$defaultFn(uuidv7),
   name: text().notNull(),
-  image: text().references(() => cdn.id),
-  order: numeric().notNull(),
+  image: text().references(() => cdn.id, {
+    onDelete: "cascade",
+    onUpdate: "cascade",
+  }),
+  order: integer().notNull(),
 });
 
 export const tierlistVersions = tierlist.table("versions", {
@@ -130,32 +150,43 @@ export const tierlistVersions = tierlist.table("versions", {
   hidden: boolean().notNull().default(false),
   type: text()
     .notNull()
-    .references(() => tierlistTypes.id),
-  image: text().references(() => cdn.id),
-  from: text().notNull().references(()=>versions.id),
-  order: numeric().notNull(),
+    .references(() => tierlistTypes.id, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    }),
+  image: text().references(() => cdn.id, {
+    onDelete: "cascade",
+    onUpdate: "cascade",
+  }),
+  from: text()
+    .notNull()
+    .references(() => versions.id),
+  order: integer().notNull(),
+  states: jsonb().notNull().$type<{ [x: string]: string[] }>().default({}),
 });
 
 export const tierlistStates = tierlist.table("states", {
   uuid: text().primaryKey().$defaultFn(uuidv7),
   char: text()
     .notNull()
-    .references(() => characters.id),
+    .references(() => characters.id, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    }),
   list: text()
     .notNull()
-    .references(() => tierlistVersions.id),
-  tier: text()
-    .notNull()
-    .references(() => tierlistTiers.id),
-  column: text()
-    .notNull()
-    .references(() => tierlistColumns.id),
+    .references(() => tierlistVersions.id, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    }),
   comment: text().notNull().default(""),
   badges: text()
-    .references(() => tierlistBadges.id)
+    .references(() => tierlistBadges.id, {
+      onDelete: "cascade",
+      onUpdate: "cascade",
+    })
     .array(4)
     .default([]),
-  order: numeric().notNull(),
 });
 
 //#endregion