dev: run prettier in precommit, style: run prettier again

Author: aster-void

.github/workflows/static.yml

@@ -20,7 +20,7 @@ jobs:
       - run: bun install --frozen-lockfile
       - run: bun check
       - run: biome lint .
-      - run: biome format .
+      - run: bun prettier --check .
   nix-checks:
     name: Nix checks
     runs-on: ubuntu-latest

.helix/languages.toml

@@ -1,6 +1,3 @@
-# [language-server]
-# deno = { command = "deno", args = ["lsp"] }
-
 [[language]]
 name = "nix"
 formatter.command = "alejandra"
@@ -26,17 +23,9 @@ language-servers = [
 
 [[language]]
 name = "svelte"
-formatter = { command = "biome", args = [
-  "format",
-  "--stdin-file-path",
-  "a.svelte",
-] }
+formatter = { command = "prettier", args = ["--parser=svelte"] }
 language-servers = ["tailwindcss-ls", "svelteserver"]
 
 [[language]]
 name = "typescript"
-formatter = { command = "biome", args = [
-  "format",
-  "--stdin-file-path",
-  "a.ts",
-] }
+formatter = { command = "prettier", args = ["--parser=typescript"] }

biome.jsonc

@@ -10,7 +10,7 @@
     "ignore": [],
   },
   "formatter": {
-    "enabled": true, // HTML-ish support when?
+    "enabled": false, // HTML-ish support when?
     "lineWidth": 120,
     "indentStyle": "space",
     "indentWidth": 2,

lefthook.yml

@@ -29,10 +29,10 @@ pre-commit:
       run: cd service; bun run cf-typegen
       stage_fixed: true
     # JS
-    biome-fmt:
+    prettier:
       tags: js style
-      glob: "*.{js,ts,svelte,html,md}"
-      run: biome format {staged_files} --fix
+      glob: "*.{js,ts,svelte,json,jsonc,yaml,html,md}"
+      run: bun prettier {staged_files} --write
       stage_fixed: true
     biome-lint:
       tags: js lint

service/features/auth/index.ts

@@ -28,7 +28,10 @@ type AuthInfo = {
   info: NoAuth;
 };
 
-export async function signup(c: Context, auth: AuthInfo): Promise<SelectAccount> {
+export async function signup(
+  c: Context,
+  auth: AuthInfo,
+): Promise<SelectAccount> {
   const browser_id = await getBrowserID(c);
   const prev = await _findAccount(c, auth);
   if (prev) {
@@ -45,36 +48,63 @@ export async function signup(c: Context, auth: AuthInfo): Promise<SelectAccount>
       })
       .returning()
   )[0];
-  if (!account) throw new HTTPException(500, { message: "Failed to create account" });
+  if (!account)
+    throw new HTTPException(500, { message: "Failed to create account" });
   return account;
 }
 
 // TODO: implement authentication
-export async function login(c: Context, auth: AuthInfo): Promise<SelectAccount> {
+export async function login(
+  c: Context,
+  auth: AuthInfo,
+): Promise<SelectAccount> {
   const acc = await _findAccount(c, auth);
   if (acc) {
-    setSignedCookie(c, cookie_identifier__browser_id, acc.browser_id, GET_COOKIE_SIGN(c), cookieOptions);
+    setSignedCookie(
+      c,
+      cookie_identifier__browser_id,
+      acc.browser_id,
+      GET_COOKIE_SIGN(c),
+      cookieOptions,
+    );
     return acc;
   }
   throw new HTTPException(404, { message: "account not found" });
 }
 
 // creates new one if necessary.
 export async function getBrowserID(c: Context): Promise<string> {
-  const cookie = await getSignedCookie(c, GET_COOKIE_SIGN(c), cookie_identifier__browser_id);
+  const cookie = await getSignedCookie(
+    c,
+    GET_COOKIE_SIGN(c),
+    cookie_identifier__browser_id,
+  );
   if (cookie) {
     return cookie;
   }
   const browser_id = crypto.randomUUID();
-  await setSignedCookie(c, cookie_identifier__browser_id, browser_id, GET_COOKIE_SIGN(c), cookieOptions);
+  await setSignedCookie(
+    c,
+    cookie_identifier__browser_id,
+    browser_id,
+    GET_COOKIE_SIGN(c),
+    cookieOptions,
+  );
   return browser_id;
 }
 
 // TODO: implement authentication
-async function _findAccount(c: Context, auth: AuthInfo): Promise<SelectAccount | undefined> {
+async function _findAccount(
+  c: Context,
+  auth: AuthInfo,
+): Promise<SelectAccount | undefined> {
   switch (auth.kind) {
     case "none": {
-      const accountsResult = await db(c).select().from(accounts).where(eq(accounts.name, auth.info.name)).limit(1);
+      const accountsResult = await db(c)
+        .select()
+        .from(accounts)
+        .where(eq(accounts.name, auth.info.name))
+        .limit(1);
       return accountsResult[0]; // findUnique をしたかった
     }
     default:

service/lib.ts

@@ -2,10 +2,20 @@ import type { Context } from "hono";
 import { env as _env } from "hono/adapter";
 import { panic } from "share/lib.ts";
 
-export function env(ctx: Context, name: string, options: { fallback?: string } = {}) {
-  return _env(ctx)?.[name] ?? options.fallback ?? panic(`env var "${name}" not found in environment!`);
+export function env(
+  ctx: Context,
+  name: string,
+  options: { fallback?: string } = {},
+) {
+  return (
+    _env(ctx)?.[name] ??
+    options.fallback ??
+    panic(`env var "${name}" not found in environment!`)
+  );
 }
 
 export function process_env(name: string) {
-  return process.env[name] ?? panic(`env var "${name}" not found in environment!`);
+  return (
+    process.env[name] ?? panic(`env var "${name}" not found in environment!`)
+  );
 }

service/routes/projects/index.ts

@@ -2,7 +2,13 @@ import { and, eq, exists } from "drizzle-orm";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { db } from "service/db/client.ts";
-import { matches, participants, projects, ratings, roles } from "service/db/schema.ts";
+import {
+  matches,
+  participants,
+  projects,
+  ratings,
+  roles,
+} from "service/db/schema.ts";
 import { getBrowserID } from "service/features/auth/index.ts";
 import type { HonoOptions } from "service/types.ts";
 import { json, param } from "service/validator/hono.ts";
@@ -42,7 +48,11 @@ const route = new Hono<HonoOptions>()
     async (c) => {
       const browser_id = await getBrowserID(c);
       const projectId = c.req.valid("param").projectId;
-      const project_resp = db(c).select().from(projects).where(eq(projects.id, projectId)).execute();
+      const project_resp = db(c)
+        .select()
+        .from(projects)
+        .where(eq(projects.id, projectId))
+        .execute();
       const project = project_resp.then((it) => {
         const project = it[0];
         if (!project) {
@@ -108,7 +118,8 @@ const route = new Hono<HonoOptions>()
         ])
         .returning()
     )[0];
-    if (!project_resp) throw new HTTPException(500, { message: "failed to create project" });
+    if (!project_resp)
+      throw new HTTPException(500, { message: "failed to create project" });
     await db(c)
       .insert(participants)
       .values([
@@ -138,23 +149,32 @@ const route = new Hono<HonoOptions>()
       roles: roles_resp,
     });
   })
-  .delete("/:projectId", param({ projectId: v.pipe(v.string(), v.uuid()) }), async (c) => {
-    const browser_id = await getBrowserID(c);
-    const { projectId: project_id } = c.req.valid("param");
-    const d = db(c);
-    await d.delete(projects).where(
-      and(
-        eq(projects.id, project_id),
-        exists(
-          d
-            .select()
-            .from(participants)
-            .where(and(eq(participants.browser_id, browser_id), eq(participants.is_admin, 1))),
+  .delete(
+    "/:projectId",
+    param({ projectId: v.pipe(v.string(), v.uuid()) }),
+    async (c) => {
+      const browser_id = await getBrowserID(c);
+      const { projectId: project_id } = c.req.valid("param");
+      const d = db(c);
+      await d.delete(projects).where(
+        and(
+          eq(projects.id, project_id),
+          exists(
+            d
+              .select()
+              .from(participants)
+              .where(
+                and(
+                  eq(participants.browser_id, browser_id),
+                  eq(participants.is_admin, 1),
+                ),
+              ),
+          ),
         ),
-      ),
-    );
-    return c.json({ ok: true }, 200);
-  })
+      );
+      return c.json({ ok: true }, 200);
+    },
+  )
 
   .put("/:projectId/finalize", param({ projectId: v.string() }), async (c) => {
     const browser_id = await getBrowserID(c);
@@ -165,7 +185,10 @@ const route = new Hono<HonoOptions>()
     const participant_resp = await db(c)
       .select()
       .from(participants)
-      .where(eq(participants.browser_id, browser_id) && eq(participants.project_id, c.req.param("projectId")));
+      .where(
+        eq(participants.browser_id, browser_id) &&
+          eq(participants.project_id, c.req.param("projectId")),
+      );
     if (participant_resp[0]?.is_admin !== 1) {
       return c.json({ message: "Unauthorized" }, 401);
     }
@@ -183,7 +206,10 @@ const route = new Hono<HonoOptions>()
       .where(eq(ratings.project_id, projectId))
       .orderBy(ratings.participant_id, ratings.role_id);
 
-    const ratingsByParticipant = Map.groupBy(participantsData, (item) => item.participant_id);
+    const ratingsByParticipant = Map.groupBy(
+      participantsData,
+      (item) => item.participant_id,
+    );
 
     const ratingsArray: number[][] = []; // TODO: 型付けをマシにする
     const participantIndexIdMap: string[] = [];
@@ -193,13 +219,21 @@ const route = new Hono<HonoOptions>()
       participantIndexIdMap.push(r[0]?.participant_id ?? "-");
     });
 
-    const roleConstraints = await db(c).select().from(roles).where(eq(roles.project_id, projectId)).orderBy(roles.id);
+    const roleConstraints = await db(c)
+      .select()
+      .from(roles)
+      .where(eq(roles.project_id, projectId))
+      .orderBy(roles.id);
     const minMaxConstraints = roleConstraints.map((role) => ({
       min: role.min,
       max: role.max,
     }));
 
-    const result = assignRoles(ratingsArray, at(ratingsArray, 0).length, minMaxConstraints);
+    const result = assignRoles(
+      ratingsArray,
+      at(ratingsArray, 0).length,
+      minMaxConstraints,
+    );
 
     await db(c)
       .insert(matches)

service/routes/projects/preferences.ts

@@ -86,12 +86,20 @@ const route = new Hono<HonoOptions>()
           .set({
             name: body.participantName,
           })
-          .where(and(eq(participants.browser_id, browser_id), eq(participants.is_admin, 0)))
+          .where(
+            and(
+              eq(participants.browser_id, browser_id),
+              eq(participants.is_admin, 0),
+            ),
+          )
           .returning({ id: participants.id })
       )[0];
-      if (!participant) throw new HTTPException(500, { message: "failed to find participant" });
+      if (!participant)
+        throw new HTTPException(500, { message: "failed to find participant" });
 
-      await db(c).delete(ratings).where(eq(ratings.participant_id, participant.id));
+      await db(c)
+        .delete(ratings)
+        .where(eq(ratings.participant_id, participant.id));
       await db(c)
         .insert(ratings)
         .values(

service/validator/hono.ts

@@ -1,5 +1,10 @@
 import { vValidator } from "@hono/valibot-validator";
-import { type BaseIssue, type BaseSchema, type ObjectEntries, object } from "valibot";
+import {
+  type BaseIssue,
+  type BaseSchema,
+  type ObjectEntries,
+  object,
+} from "valibot";
 
 export function param<T extends ObjectEntries>(values: T) {
   return vValidator("param", object(values));
@@ -9,6 +14,8 @@ export function query<T extends ObjectEntries>(values: T) {
   return vValidator("param", object(values));
 }
 
-export function json<T extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(schema: T) {
+export function json<
+  T extends BaseSchema<unknown, unknown, BaseIssue<unknown>>,
+>(schema: T) {
   return vValidator("json", schema);
 }

share/lib.ts

@@ -16,6 +16,7 @@ export function assert(cond: boolean, message?: string) {
 }
 export function at<T>(list: T[], idx: number): T {
   const elem = list[idx];
-  if (elem === undefined) throw new Error(`elemAt: item not found at index ${idx} in list`);
+  if (elem === undefined)
+    throw new Error(`elemAt: item not found at index ${idx} in list`);
   return elem;
 }

share/logic/min-flow.ts

@@ -24,7 +24,9 @@ export function assignRoles(
     sumMax += minMaxConstraints[j]?.max ?? 0;
   }
   if (sumMin > P) {
-    throw new Error("割当可能な participant 数が制約を満たしません（sum(min) > participants.length）");
+    throw new Error(
+      "割当可能な participant 数が制約を満たしません（sum(min) > participants.length）",
+    );
   }
 
   // 拡張用配列：dummy role を追加するかどうか
@@ -55,7 +57,11 @@ export function assignRoles(
   // distribution: dist[0..M_ext-1] で、各 extended role j に割り当てる参加者数
   // 条件: extendedConstraints[j].min <= d[j] <= extendedConstraints[j].max,  ∑ d[j] = P
   const distributions: number[][] = [];
-  function enumerateDistribution(index: number, current: number[], remaining: number) {
+  function enumerateDistribution(
+    index: number,
+    current: number[],
+    remaining: number,
+  ) {
     if (index === M_ext) {
       if (remaining === 0) {
         distributions.push(current.slice());
@@ -129,7 +135,10 @@ export function assignRoles(
   const result: { participant: number; role: number }[] = [];
   for (let i = 0; i < P; i++) {
     // const assignedRole = bestMatching.roleForColumn[bestMatching.assignment[i]];
-    const assignedRole = at(bestMatching.roleForColumn, at(bestMatching.assignment, i));
+    const assignedRole = at(
+      bestMatching.roleForColumn,
+      at(bestMatching.assignment, i),
+    );
     // dummy roleの場合は -1 として返す（必要に応じて処理してください）
     result.push({ participant: i, role: assignedRole < M ? assignedRole : -1 });
   }