Testing things out

package.json

@@ -2,6 +2,9 @@
 	"name": "bracketeer",
 	"version": "0.0.1",
 	"private": true,
+    "prisma": {
+        "seed": "ts-node prisma/seed.ts"
+    },
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -39,6 +42,7 @@
 	},
 	"type": "module",
 	"dependencies": {
+		"@clerk/backend": "^1.13.1",
 		"@prisma/client": "^5.19.0",
 		"clerk-sveltekit": "^0.4.2"
 	}

prisma/migrations/20240914203650_auth/migration.sql

@@ -0,0 +1,24 @@
+-- CreateTable
+CREATE TABLE "UserAuth" (
+    "id" SERIAL NOT NULL,
+    "userId" TEXT NOT NULL,
+    "providerId" INTEGER NOT NULL,
+    "value" TEXT NOT NULL,
+
+    CONSTRAINT "UserAuth_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "AuthProvider" (
+    "id" SERIAL NOT NULL,
+    "name" TEXT NOT NULL,
+    "providerValue" TEXT NOT NULL,
+
+    CONSTRAINT "AuthProvider_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "UserAuth" ADD CONSTRAINT "UserAuth_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "UserAuth" ADD CONSTRAINT "UserAuth_providerId_fkey" FOREIGN KEY ("providerId") REFERENCES "AuthProvider"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/migrations/20240918050122_add_user_email/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - Added the required column `email` to the `User` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "email" TEXT NOT NULL;

prisma/migrations/20240919232548_unique_provider_value/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[providerId,value]` on the table `UserAuth` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- CreateIndex
+CREATE UNIQUE INDEX "UserAuth_providerId_value_key" ON "UserAuth"("providerId", "value");

prisma/migrations/20240919235047_unique_auth_provider_value/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[providerValue]` on the table `AuthProvider` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- CreateIndex
+CREATE UNIQUE INDEX "AuthProvider_providerValue_key" ON "AuthProvider"("providerValue");

prisma/schema.prisma

@@ -2,130 +2,135 @@
 // learn more about it in the docs: https://pris.ly/d/prisma-schema
 
 generator client {
-  provider = "prisma-client-js"
+    provider = "prisma-client-js"
 }
 
 datasource db {
-  provider = "postgresql"
-  url      = env("DATABASE_URL")
+    provider = "postgresql"
+    url      = env("DATABASE_URL")
 }
 
 model User {
-  id                       String       @id @default(uuid(7))
-  name                     String
-  created                  DateTime     @default(now())
-  userRoles                UserRole[]
-  auth UserAuth[]
-  tournamntsAdministrating Tournament[] @relation("admins")
-  tournamentsModerating    Tournament[] @relation("moderators")
-  Tournament               Tournament[]
-  Player                   Player[]
+    id                       String       @id @default(uuid(7))
+    name                     String
+    email                    String
+    created                  DateTime     @default(now())
+    userRoles                UserRole[]
+    auth                     UserAuth[]
+    tournamntsAdministrating Tournament[] @relation("admins")
+    tournamentsModerating    Tournament[] @relation("moderators")
+    Tournament               Tournament[]
+    Player                   Player[]
 }
+
 model UserAuth {
-    id Int @id @default(autoincrement())
-    user User @relation(fields: [userId], references: [id])
-    userId String
-    provider AuthProvider @relation(fields: [providerId], references: [id])
+    id         Int          @id @default(autoincrement())
+    user       User         @relation(fields: [userId], references: [id])
+    userId     String
+    provider   AuthProvider @relation(fields: [providerId], references: [id])
     providerId Int
-    value String
+    value      String
+
+    @@unique(name: "providerIdAuthValue", [providerId, value])
 }
+
 model AuthProvider {
-    id Int @id @default(autoincrement())
-    name String
-    providerValue String
-    userAuth UserAuth[]
+    id            Int        @id @default(autoincrement())
+    name          String
+    providerValue String     @unique
+    userAuth      UserAuth[]
 }
 
 model UserRole {
-  user   User   @relation(fields: [userId], references: [id])
-  userId String
-  role   Role   @relation(fields: [roleId], references: [id])
-  roleId Int
+    user   User   @relation(fields: [userId], references: [id])
+    userId String
+    role   Role   @relation(fields: [roleId], references: [id])
+    roleId Int
 
-  @@id([userId, roleId])
+    @@id([userId, roleId])
 }
 
 model Role {
-  id        Int        @id @default(autoincrement())
-  name      String
-  userRoles UserRole[]
+    id        Int        @id @default(autoincrement())
+    name      String
+    userRoles UserRole[]
 }
 
 model Tournament {
-  id            String   @id @default(uuid(7))
-  name          String
-  slug          String?
-  creator       User     @relation(fields: [creatorUserId], references: [id])
-  creatorUserId String
-  created       DateTime @default(now())
-  admins        User[]   @relation("admins")
-  moderators    User[]   @relation("moderators")
-  events        Event[]
+    id            String   @id @default(uuid(7))
+    name          String
+    slug          String?
+    creator       User     @relation(fields: [creatorUserId], references: [id])
+    creatorUserId String
+    created       DateTime @default(now())
+    admins        User[]   @relation("admins")
+    moderators    User[]   @relation("moderators")
+    events        Event[]
 }
 
 model Event {
-  id           String        @id @default(uuid(7))
-  game         Game          @relation(fields: [gameId], references: [id])
-  gameId       Int
-  entrants     EventPlayer[]
-  title        String
-  phases       Phase[]
-  tournament   Tournament    @relation(fields: [tournamentId], references: [id])
-  tournamentId String
-  created      DateTime      @default(now())
+    id           String        @id @default(uuid(7))
+    game         Game          @relation(fields: [gameId], references: [id])
+    gameId       Int
+    entrants     EventPlayer[]
+    title        String
+    phases       Phase[]
+    tournament   Tournament    @relation(fields: [tournamentId], references: [id])
+    tournamentId String
+    created      DateTime      @default(now())
 }
 
 enum PhaseType {
-  DOUBLE_ELIM
-  SINGLE_ELIM
-  ROUND_ROBIN
+    DOUBLE_ELIM
+    SINGLE_ELIM
+    ROUND_ROBIN
 }
 
 model Phase {
-  id               String    @id @default(uuid(7))
-  name             String
-  type             PhaseType
-  bracketCount     Int
-  phaseWinnerCount Int
-  event            Event     @relation(fields: [eventId], references: [id])
-  eventId          String
-  created          DateTime  @default(now())
-  brackets         Bracket[]
+    id               String    @id @default(uuid(7))
+    name             String
+    type             PhaseType
+    bracketCount     Int
+    phaseWinnerCount Int
+    event            Event     @relation(fields: [eventId], references: [id])
+    eventId          String
+    created          DateTime  @default(now())
+    brackets         Bracket[]
 }
 
 model Bracket {
-  id      Int      @id @default(autoincrement())
-  name    String
-  created DateTime @default(now())
-  Phase   Phase?   @relation(fields: [phaseId], references: [id])
-  phaseId String?
+    id      Int      @id @default(autoincrement())
+    name    String
+    created DateTime @default(now())
+    Phase   Phase?   @relation(fields: [phaseId], references: [id])
+    phaseId String?
 }
 
 model Player {
-  id            Int           @id @default(autoincrement())
-  name          String?
-  user          User?         @relation(fields: [userId], references: [id])
-  userId        String
-  created       DateTime      @default(now())
-  userConfirmed Boolean       @default(false)
-  EventPlayer   EventPlayer[]
+    id            Int           @id @default(autoincrement())
+    name          String?
+    user          User?         @relation(fields: [userId], references: [id])
+    userId        String
+    created       DateTime      @default(now())
+    userConfirmed Boolean       @default(false)
+    EventPlayer   EventPlayer[]
 }
 
 model EventPlayer {
-  event          Event   @relation(fields: [eventId], references: [id])
-  eventId        String
-  player         Player  @relation(fields: [playerId], references: [id])
-  playerId       Int
-  seed           Int
-  manuallySeeded Boolean @default(false)
+    event          Event   @relation(fields: [eventId], references: [id])
+    eventId        String
+    player         Player  @relation(fields: [playerId], references: [id])
+    playerId       Int
+    seed           Int
+    manuallySeeded Boolean @default(false)
 
-  @@id([eventId, playerId])
+    @@id([eventId, playerId])
 }
 
 model Game {
-  id      Int      @id @default(autoincrement())
-  title   String
-  slug    String?
-  created DateTime @default(now())
-  Event   Event[]
+    id      Int      @id @default(autoincrement())
+    title   String
+    slug    String?
+    created DateTime @default(now())
+    Event   Event[]
 }

src/app.d.ts

@@ -1,13 +1,32 @@
 // See https://kit.svelte.dev/docs/types#app
 // for information about these interfaces
+import { User } from '@clerk/backend';
 declare global {
-	namespace App {
-		// interface Error {}
-		// interface Locals {}
-		// interface PageData {}
-		// interface PageState {}
-		// interface Platform {}
-	}
+    namespace App {
+        // interface Error {}
+        interface Locals {
+            session:
+            {
+                prefix: string | undefined,
+                username: string | undefined,
+                userId: string,
+                claims: {
+                    azp: string,
+                    exp: number,
+                    iat: number,
+                    iss: string,
+                    nbf: number,
+                    sid: string,
+                    sub: string
+                }
+            }
+            | undefined,
+            clerkUser: User | undefined
+        }
+        // interface PageData {}
+        // interface PageState {}
+        // interface Platform {}
+    }
 }
 
-export {};
+export { };

src/hooks.server.ts

@@ -3,20 +3,79 @@ import { sequence } from '@sveltejs/kit/hooks'
 import { handleClerk } from 'clerk-sveltekit/server'
 import { CLERK_SECRET_KEY } from '$env/static/private'
 import prisma from '$lib/prisma';
+import { createClerkClient } from '@clerk/backend';
+const getClearkUserObject: Handle = async function({ event, resolve }) {
+    if (event.locals.session?.userId == null) {
+        return await resolve(event);
+    }
+    const clerkClient = createClerkClient({ secretKey: CLERK_SECRET_KEY });
+    event.locals.clerkUser = await clerkClient.users.getUser(event.locals.session.userId);
+    return await resolve(event);
+};
+
+const localUserHandle: Handle = async function({ event, resolve }) {
+    console.debug('Adding or Grabbing new user', event.locals);
+    if (event.locals.session == null || event.locals.clerkUser == null) {
+        return await resolve(event);
+    }
+    let provider = await prisma.authProvider.findUnique({
+        where: {
+            providerValue: event.locals.session!.claims!.iss,
+        }
+    });
+    if (provider == null) {
+        console.debug('Provider does not exist', event.locals.session!.claims.iss);
+        provider = await prisma.authProvider.create({
+            data: {
+                name: event.locals.session!.claims.iss,
+                providerValue: event.locals.session!.claims.iss,
+            }
+        });
+    }
+    const userAuthValue = await prisma.userAuth.findUnique({
+        where: {
+            providerIdAuthValue: {
+                providerId: provider.id,
+                value: event.locals.session?.userId
+            }
+        },
+        include: {
+            user: true,
+        }
+    });
+    let userObject = userAuthValue?.user;
+    if (userAuthValue == null) {
+        //create a user for this identity
+        console.debug(`User doesn't exist, creating`,);
+        userObject = await prisma.user.create({
+            data: {
+                name: event.locals.clerkUser!.username!,
+                email: event.locals.clerkUser!.primaryEmailAddress!.emailAddress,
+                auth: {
+                    create: [
+                        {
+                            value: event.locals.clerkUser.id,
+                            providerId: provider.id
+                        }
+                    ]
+                },
+            },
+        });
+        event.locals.session.username = userObject.name;
+    }
+    console.debug('Found/Created user', userObject);
 
-const newUserHandle: Handle = async function({event, resolve}) {
-    prisma.user.findUnique(
     const result = await resolve(event);
-    console.log(result);
     return result;
 };
 
 export const handle: Handle = sequence(
-	handleClerk(CLERK_SECRET_KEY, {
-		debug: true,
-		protectedPaths: ['/admin'],
-		signInUrl: '/sign-in',
-	}),
-    newUserHandle
+    handleClerk(CLERK_SECRET_KEY, {
+        debug: true,
+        protectedPaths: ['/admin'],
+        signInUrl: '/sign-in',
+    }),
+    getClearkUserObject,
+    localUserHandle
 )
 

src/lib/DTOs/PlayerCellDto.ts

@@ -0,0 +1,12 @@
+export default interface PlayerCellDto {
+    name: string,
+    prefix?: string,
+    character?: string,
+}
+export interface Set {
+
+}
+export class Round {
+    constructor(seededPlayers: Array<PlayerCellDto>) {
+    }
+}

src/lib/components/HeadToHeadCell.svelte

@@ -0,0 +1,31 @@
+<script lang="ts">
+	import type PlayerCellDto from '$lib/DTOs/PlayerCellDto';
+	import PlayerCell from './PlayerCell.svelte';
+
+	interface HeadToHeadCellProps {
+		player1: PlayerCellDto;
+		player2: PlayerCellDto;
+		player1Seed: number;
+		player2Seed: number;
+		setId: string;
+	}
+	let { player1, player2, player1Seed, player2Seed, setId }: HeadToHeadCellProps = $props();
+</script>
+
+<div class="flex flex-col">
+	<div class="text-sm self-center text-zinc-400">
+		╭ Match {setId} ╮
+	</div>
+	<div class="px-1 flex border rounded-t-md border-zinc-600">
+		<div class="flex-1 overflow-hidden">
+			<PlayerCell playerCell={player1} />
+		</div>
+		<div class="text-zinc-400">{player1Seed}</div>
+	</div>
+	<div class="px-1 flex border border-t-0 rounded-b-md border-zinc-600">
+		<div class="flex-1 overflow-hidden">
+			<PlayerCell playerCell={player2} />
+		</div>
+		<div class="text-zinc-400">{player2Seed}</div>
+	</div>
+</div>

src/lib/components/PlayerCell.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+	import type PlayerCellDto from '$lib/DTOs/PlayerCellDto';
+	interface PlayerCellProps {
+		playerCell: PlayerCellDto;
+	}
+	let { playerCell }: PlayerCellProps = $props();
+</script>
+
+{#if playerCell.prefix != null}
+	<span class="text-neutral-400"> {playerCell.prefix} | </span>
+{/if}
+{playerCell.name}
+{#if playerCell.character != null}
+	<img src="" />
+{/if}

src/routes/+page.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
 import type { PageData } from "./$types";
-
 export let data: PageData;
 </script>
 

src/routes/admin/+page.server.ts

@@ -0,0 +1,8 @@
+import prisma from '$lib/prisma';
+import type { PageServerLoad } from './$types';
+
+export const load = (async (event) => {
+    console.log('Checking session for user object', event.locals);
+    return { };
+}) satisfies PageServerLoad;
+

src/routes/playground/cells/+page.server.ts

@@ -0,0 +1,137 @@
+import type { PageServerLoad } from './$types';
+import type PlayerCellDto from '$lib/DTOs/PlayerCellDto';
+
+export const load: PageServerLoad = async ({ params }) => {
+    const playerCells: Array<PlayerCellDto> = [
+        { name: 'Alice' },
+        { name: 'Bob', prefix: 'B', character: 'Knight' },
+        { name: 'Charlie', prefix: 'C' },
+        { name: 'Diana', character: 'Archer' },
+        { name: 'Ethan', prefix: 'E', character: 'Mage' },
+        { name: 'Fiona' }, { name: 'George', prefix: 'G' },
+        { name: 'Hannah', character: 'Warrior' },
+        { name: 'Ian', prefix: 'I', character: 'Rogue' },
+        { name: 'Jasmine' },
+        { name: 'Kevin', prefix: 'K', character: 'Paladin' },
+        { name: 'Laura', character: 'Cleric' },
+        { name: 'Mike', prefix: 'M' },
+        { name: 'Nina', character: 'Druid' },
+        { name: 'Oscar', prefix: 'O', character: 'Sorcerer' },
+        { name: 'Paula' },
+        { name: 'Quentin', prefix: 'Q' },
+        { name: 'Rachel', character: 'Bard' },
+        { name: 'Sam', prefix: 'S', character: 'Monk' },
+        { name: 'Tina' },
+        { name: 'Ulysses', prefix: 'U', character: 'Necromancer' },
+        { name: 'Vera', character: 'Ranger' },
+        { name: 'Walter', prefix: 'W' },
+        { name: 'Xena', character: 'Assassin' },
+        { name: 'Yara', prefix: 'Y', character: 'Summoner' },
+        { name: 'Zack' },
+        { name: 'Amber', prefix: 'Am', character: 'Beastmaster' },
+        { name: 'Blake', character: 'Elementalist' },
+        { name: 'Carmen', prefix: 'Cm', character: 'Guardian' },
+        { name: 'Derek' },
+        { name: 'Elena', prefix: 'El', character: 'Invoker' },
+        { name: 'Frank', character: 'Alchemist' },
+        { name: 'Grace', prefix: 'Gr' },
+        { name: 'Henry', character: 'Tracker' },
+        { name: 'Isla', prefix: 'Is', character: 'Enchanter' },
+        { name: 'Jack' },
+        { name: 'Kara', prefix: 'Kr', character: 'Berserker' },
+        { name: 'Liam', character: 'Shadowcaster' },
+        { name: 'Maya', prefix: 'My' },
+        { name: 'Noah', character: 'Invoker' },
+        { name: 'Olivia', prefix: 'Ol', character: 'Mystic' },
+        { name: 'Peter' },
+        { name: 'Queenie', prefix: 'Qu', character: 'Spellblade' },
+        { name: 'Ryan', character: 'Templar' },
+        { name: 'Sophia', prefix: 'So' },
+        { name: 'Thomas', character: 'Warlord' },
+        { name: 'Uma', prefix: 'Um', character: 'Shadowdancer' },
+        { name: 'Victor' },
+        { name: 'Wendy', prefix: 'We', character: 'Elementalist' },
+        { name: 'Xander', character: 'Runemaster' },
+        { name: 'Yvonne', prefix: 'Yv' },
+        { name: 'Zoe', character: 'Chronomancer' },
+        { name: 'Aaron', prefix: 'Aa', character: 'Battle Mage' },
+        { name: 'Bella' },
+        { name: 'Caleb', prefix: 'Ca', character: 'Guardian' },
+        { name: 'Delilah', character: 'Invoker' },
+        { name: 'Eli', prefix: 'El', character: 'Sorcerer' },
+        { name: 'Faith' },
+        { name: 'Gavin', prefix: 'Ga', character: 'Paladin' },
+        { name: 'Hailey', character: 'Druid' },
+        { name: 'Isaac', prefix: 'Is', character: 'Rogue' },
+        { name: 'Julia' },
+        { name: 'Kyle', prefix: 'Ky', character: 'Warrior' },
+        { name: 'Lily', character: 'Bard' }
+    ];
+
+    const round1Matches: Array<{
+        player1: PlayerCellDto;
+        player2: PlayerCellDto;
+        seed1: number;
+        seed2: number;
+        matchId: string;
+    }> = new Array();
+    const round2Matches: Array<{
+        player1: PlayerCellDto;
+        player2: PlayerCellDto;
+        seed1: number;
+        seed2: number;
+        matchId: string;
+    }> = new Array();
+    const round3Matches: Array<{
+        player1: PlayerCellDto;
+        player2: PlayerCellDto;
+        seed1: number;
+        seed2: number;
+        matchId: string;
+    }> = new Array();
+    const round4Matches: Array<{
+        player1: PlayerCellDto;
+        player2: PlayerCellDto;
+        seed1: number;
+        seed2: number;
+        matchId: string;
+    }> = new Array();
+    for (let i = 0; i < playerCells.length / 2; i++) {
+        round1Matches.push({
+            player1: playerCells[i],
+            player2: playerCells[playerCells.length / 2 + i],
+            seed1: i + 1,
+            seed2: playerCells.length - i,
+            matchId: `A${i + 1}`
+        });
+    }
+    for (let i = 0; i < playerCells.length / 4; i++) {
+        round2Matches.push({
+            player1: playerCells[i],
+            player2: playerCells[playerCells.length / 4 + i],
+            seed1: i + 1,
+            seed2: playerCells.length / 2 - i,
+            matchId: `A${i + 33}`
+        });
+    }
+    for (let i = 0; i < playerCells.length / 8; i++) {
+        round3Matches.push({
+            player1: playerCells[i],
+            player2: playerCells[playerCells.length / 8 + i],
+            seed1: i + 1,
+            seed2: playerCells.length / 4 - i,
+            matchId: `A${i + (round1Matches.length + round2Matches.length)}`
+        });
+    }
+    for (let i = 0; i < playerCells.length / 16; i++) {
+        round4Matches.push({
+            player1: playerCells[i],
+            player2: playerCells[playerCells.length / 16 + i],
+            seed1: i + 1,
+            seed2: playerCells.length / 8 - i,
+            matchId: `A${i + (round1Matches.length + round2Matches.length + round3Matches.length)}`
+        });
+    }
+    return { rounds: [round1Matches, round2Matches, round3Matches, round4Matches] };
+};
+

src/routes/playground/cells/+page.svelte

@@ -0,0 +1,22 @@
+<script lang="ts">
+	import HeadToHeadCell from '$lib/components/HeadToHeadCell.svelte';
+	import type { PageData } from './$types';
+	let { data }: { data: PageData } = $props();
+	console.debug(data);
+</script>
+
+<div class="flex">
+	{#each data.rounds as round}
+		<div class="min-w-36">
+			{#each round as match}
+				<HeadToHeadCell
+					player1={match.player1}
+					player2={match.player2}
+					player1Seed={match.seed1}
+					player2Seed={match.seed2}
+					setId={match.matchId}
+				/>
+			{/each}
+		</div>
+	{/each}
+</div>