From 1bce9651c383a7fbb9656db6ebd2c87599a85ebb Mon Sep 17 00:00:00 2001
From: Gunnar Omander <gunnar.omander@gmail.com>
Date: Fri, 12 Jan 2024 16:57:12 +0100
Subject: [PATCH] Allow overwriting previously saved wheels

---
 src/lib/components/SaveCloudDialog.svelte    | 116 ++++++++++++++-----
 src/lib/server/FirebaseAdmin.ts              |  30 +++++
 src/lib/stores/WheelStore.ts                 |   2 +-
 src/lib/utils/Api.ts                         |  27 +++++
 src/lib/utils/Schemas.ts                     |  71 +++++++-----
 src/routes/api/wheels/+server.ts             |   4 +-
 src/routes/api/wheels/[path=path]/+server.ts |  65 ++++++++++-
 7 files changed, 254 insertions(+), 61 deletions(-)

diff --git a/src/lib/components/SaveCloudDialog.svelte b/src/lib/components/SaveCloudDialog.svelte
index 54dd6ee..03eba40 100644
--- a/src/lib/components/SaveCloudDialog.svelte
+++ b/src/lib/components/SaveCloudDialog.svelte
@@ -1,10 +1,11 @@
 <script lang="ts">
+  import { onMount } from 'svelte'
   import {
     ProgressRadial, getModalStore, getToastStore
   } from '@skeletonlabs/skeleton'
   import wheelStore from '$lib/stores/WheelStore'
   import { getCurrentUser } from '$lib/utils/Firebase'
-  import { createWheel } from '$lib/utils/Api'
+  import { createWheel, getWheel, updateWheel } from '$lib/utils/Api'
   import { toastDefaults } from '$lib/utils/Toast'
 
   const modalStore = getModalStore()
@@ -12,16 +13,35 @@
 
   let title = $wheelStore.config.title
   let loading = false
+  let saveMode: 'overwrite' | 'new' = 'new'
 
-  const user = getCurrentUser()
-  if (!user) {
-    modalStore.close()
-    modalStore.trigger({
-      type: 'component',
-      component: 'loginDialog',
-      meta: { next: 'saveCloudDialog' }
-    })
-  }
+  onMount(async () => {
+    const user = getCurrentUser()
+    if (!user) {
+      modalStore.close()
+      modalStore.trigger({
+        type: 'component',
+        component: 'loginDialog',
+        meta: { next: 'saveCloudDialog' }
+      })
+      return
+    }
+    if ($wheelStore.path) {
+      loading = true
+      try {
+        const response = await getWheel($wheelStore.path, user.uid)
+        if (!response.success) {
+          wheelStore.setPath(null)
+          return
+        }
+        saveMode = 'overwrite'
+      } catch (error) {
+        wheelStore.setPath(null)
+      } finally {
+        loading = false
+      }
+    }
+  })
 
   const save = async () => {
     if (loading) return
@@ -30,19 +50,34 @@
       if (!title) {
         throw new Error('Title is required')
       }
+      const user = getCurrentUser()
       if (!user) {
         throw new Error('User is not logged in')
       }
-      const response = await createWheel({
-        wheel: {
-          config: { ...$wheelStore.config, title },
-          entries: $wheelStore.entries
-        },
-        visibility: 'private',
-        uid: user.uid
-      }, user.uid)
-      if (!response.success) {
-        throw new Error('Failed to save wheel')
+      if (saveMode === 'new') {
+        const response = await createWheel({
+          wheel: {
+            config: { ...$wheelStore.config, title },
+            entries: $wheelStore.entries
+          },
+          visibility: 'private',
+          uid: user.uid
+        }, user.uid)
+        if (!response.success) {
+          throw new Error('Failed to save wheel')
+        }
+      }
+      if (saveMode === 'overwrite' && $wheelStore.path) {
+        const response = await updateWheel($wheelStore.path, {
+          wheel: {
+            config: { ...$wheelStore.config, title },
+            entries: $wheelStore.entries
+          },
+          uid: user.uid
+        }, user.uid)
+        if (!response.success) {
+          throw new Error('Failed to save wheel')
+        }
       }
       modalStore.close()
       toastStore.trigger({
@@ -63,14 +98,10 @@
     }
   }
 
-  // TODO: If the wheel has been saved previously, present the user with a
-  // choice to overwrite the existing wheel or create a new wheel. This can be
-  // done by writing the path to the wheel store when saving or opening a wheel
-  // and checking if the path exists when opening the save cloud dialog. The
-  // user should be shown as much metadata about the wheel as possible, such as
-  // the title, number of entries, and date created. Additionally, there should
-  // be a thumbnail of the wheel, the same one that would be shown in the open
-  // cloud dialog.
+  // TODO: When wheelStore has a path, the user should be shown as much metadata
+  // about the wheel as possible, such as the title, number of entries, and date
+  // created. Additionally, there should be a thumbnail of the wheel, the same
+  // one that would be shown in the open cloud dialog.
 </script>
 
 {#if $modalStore[0]}
@@ -84,9 +115,36 @@
       on:submit|preventDefault={save}
       class="flex flex-col gap-4"
     >
+      {#if $wheelStore.path}
+        <div class="flex flex-col gap-2">
+          <label class="flex items-center gap-2">
+            <input
+              type="radio"
+              name="saveMode"
+              value="overwrite"
+              bind:group={saveMode}
+              class="radio"
+            />
+            <span>
+              Overwrite "{$wheelStore.config.title}" ({$wheelStore.path})
+            </span>
+          </label>
+          <label class="flex items-center gap-2">
+            <input
+              type="radio"
+              name="saveMode"
+              value="new"
+              bind:group={saveMode}
+              checked
+              class="radio"
+            />
+            <span>Save a new wheel</span>
+          </label>
+        </div>
+      {/if}
+
       <label class="label">
         <span class="required">Title</span>
-
         <input
           type="text"
           maxlength="50"
diff --git a/src/lib/server/FirebaseAdmin.ts b/src/lib/server/FirebaseAdmin.ts
index 4c07924..555964a 100644
--- a/src/lib/server/FirebaseAdmin.ts
+++ b/src/lib/server/FirebaseAdmin.ts
@@ -83,6 +83,36 @@ export const saveWheel = async (
   return path
 }
 
+export const updateWheel = async (
+  path: string,
+  wheel: Partial<Omit<ApiWheel, 'path'>>,
+  uid: string,
+  visibility?: WheelVisibility
+) => {
+  const wheelMetaDoc = db.doc(`wheel-meta/${path}`)
+  const wheelMetaSnap = await wheelMetaDoc.get()
+  if (!wheelMetaSnap.exists) {
+    return null
+  }
+  const wheelMeta = wheelMetaSnap.data() as ApiWheelMeta
+  if (wheelMeta.uid !== uid) {
+    return null
+  }
+  const newWheelMeta: Partial<ApiWheelMeta> = {
+    updated: Date.now()
+  }
+  if (wheel.config && wheel.config.title !== wheelMeta.title) {
+    newWheelMeta.title = wheel.config.title
+  }
+  if (visibility) {
+    newWheelMeta.visibility = visibility
+  }
+  await wheelMetaDoc.update(newWheelMeta)
+  const wheelDoc = db.doc(`wheels/${path}`)
+  await wheelDoc.update({ ...wheel } satisfies Partial<ApiWheel>)
+  return wheelMeta.path
+}
+
 const getNewWheelPath = async () => {
   let path: string
   let snap: FirebaseFirestore.DocumentSnapshot<FirebaseFirestore.DocumentData>
diff --git a/src/lib/stores/WheelStore.ts b/src/lib/stores/WheelStore.ts
index a93bb67..43bdf44 100644
--- a/src/lib/stores/WheelStore.ts
+++ b/src/lib/stores/WheelStore.ts
@@ -34,7 +34,7 @@ const createWheelStore = (state: WheelStoreData) => {
     })
   }
 
-  const setPath = (path: string) => {
+  const setPath = (path: string | null) => {
     update(state => {
       state.path = path
       return state
diff --git a/src/lib/utils/Api.ts b/src/lib/utils/Api.ts
index cb11cdb..65842b9 100644
--- a/src/lib/utils/Api.ts
+++ b/src/lib/utils/Api.ts
@@ -25,6 +25,31 @@ export const createWheel = async (
   return await response.json() as ApiResponse<{ path: string }>
 }
 
+export const updateWheel = async (
+  path: string,
+  data: UpdateWheelData,
+  uid?: string | null,
+  apiKey?: string | null,
+  fetch = window.fetch
+) => {
+  const headers: HeadersInit = { 'Content-Type': 'application/json' }
+  if (uid) {
+    headers.authorization = uid
+  }
+  if (apiKey) {
+    headers['x-api-key'] = apiKey
+  }
+  const response = await fetch(
+    `/api/wheels/${path}`,
+    {
+      method: 'PUT',
+      headers,
+      body: JSON.stringify(data)
+    }
+  )
+  return await response.json() as ApiResponse<{ path: string }>
+}
+
 export const getWheel = async (
   path: string,
   uid?: string | null,
@@ -97,3 +122,5 @@ export interface CreateWheelData {
   visibility: WheelVisibility
   uid: string
 }
+
+export type UpdateWheelData = Partial<CreateWheelData> & { uid: string }
diff --git a/src/lib/utils/Schemas.ts b/src/lib/utils/Schemas.ts
index 69c193a..801794d 100644
--- a/src/lib/utils/Schemas.ts
+++ b/src/lib/utils/Schemas.ts
@@ -4,36 +4,53 @@ import { wheelTypes, hubSizeKeys, defaultColors } from '$lib/utils/WheelConfig'
 import { confettiTypes } from '$lib/utils/ConfettiLauncher'
 import { wheelVisibilities } from '$lib/utils/Api'
 
-export const wheelSchema = z.object({
+const wheelConfigSchema = z.object({
+  type: z.optional(z.enum(wheelTypes)).default('color'),
+  title: z.string().min(1).max(50).trim(),
+  description: z.optional(z.string().max(200).trim()).default(''),
+  spinTime: z.optional(z.number().min(1).max(60)).default(10),
+  indefiniteSpin: z.optional(z.boolean()).default(false),
+  colors: z.optional(
+    z.array(z.string().trim().length(7).startsWith('#'))
+  ).default(defaultColors),
+  confetti: z.optional(z.enum(confettiTypes)).default('off'),
+  displayWinnerDialog: z.optional(z.boolean()).default(true),
+  winnerMessage: z.optional(z.string().max(50).trim()).default(''),
+  hubSize: z.optional(z.enum(hubSizeKeys)).default('S'),
+  duringSpinSound: z.optional(z.string().max(100).trim()).default(''),
+  duringSpinSoundVolume: z.optional(z.number().min(0).max(1)).default(0),
+  afterSpinSound: z.optional(z.string().max(100).trim()).default(''),
+  afterSpinSoundVolume: z.optional(z.number().min(0).max(1)).default(0),
+  image: z.optional(z.string().trim()).default('')
+})
+
+const entrySchema = z.object({
+  text: z.string(),
+  id: z.optional(z.string().trim().length(8)).default(getNewEntryId())
+})
+
+const entriesSchema = z.array(entrySchema)
+
+export const uidValidator = z.string().trim().min(20).max(40)
+
+export const createWheelSchema = z.object({
   wheel: z.object({
-    config: z.object({
-      type: z.optional(z.enum(wheelTypes)).default('color'),
-      title: z.string().min(1).max(50).trim(),
-      description: z.optional(z.string().max(200).trim()).default(''),
-      spinTime: z.optional(z.number().min(1).max(60)).default(10),
-      indefiniteSpin: z.optional(z.boolean()).default(false),
-      colors: z.optional(
-        z.array(z.string().trim().length(7).startsWith('#'))
-      ).default(defaultColors),
-      confetti: z.optional(z.enum(confettiTypes)).default('off'),
-      displayWinnerDialog: z.optional(z.boolean()).default(true),
-      winnerMessage: z.optional(z.string().max(50).trim()).default(''),
-      hubSize: z.optional(z.enum(hubSizeKeys)).default('S'),
-      duringSpinSound: z.optional(z.string().max(100).trim()).default(''),
-      duringSpinSoundVolume: z.optional(z.number().min(0).max(1)).default(0),
-      afterSpinSound: z.optional(z.string().max(100).trim()).default(''),
-      afterSpinSoundVolume: z.optional(z.number().min(0).max(1)).default(0),
-      image: z.optional(z.string().trim()).default('')
-    }),
-    entries: z.array(
-      z.object({
-        text: z.string(),
-        id: z.optional(z.string().trim().length(8)).default(getNewEntryId())
-      })
-    )
+    config: wheelConfigSchema,
+    entries: entriesSchema
   }),
   visibility: z.enum(wheelVisibilities),
-  uid: z.string().trim().min(20).max(40)
+  uid: uidValidator
+})
+
+export const updateWheelSchema = z.object({
+  wheel: z.optional(
+    z.object({
+      config: z.optional(wheelConfigSchema),
+      entries: z.optional(entriesSchema)
+    })
+  ).default({}),
+  visibility: z.optional(z.enum(wheelVisibilities)),
+  uid: uidValidator
 })
 
 export const emailValidator = z.string().email()
diff --git a/src/routes/api/wheels/+server.ts b/src/routes/api/wheels/+server.ts
index 35e1dd1..0ed7c13 100644
--- a/src/routes/api/wheels/+server.ts
+++ b/src/routes/api/wheels/+server.ts
@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { SVELTE_WHEEL_API_KEY } from '$env/static/private'
 import { getUserWheelsMeta, saveWheel } from '$lib/server/FirebaseAdmin'
-import { wheelSchema } from '$lib/utils/Schemas'
+import { createWheelSchema } from '$lib/utils/Schemas'
 import type { ApiError, ApiSuccess, ApiWheelMeta } from '$lib/utils/Api'
 
 export const GET = async ({ request }) => {
@@ -52,7 +52,7 @@ export const POST = async ({ request }) => {
   }
   try {
     const body = await request.json()
-    const data = wheelSchema.parse(body)
+    const data = createWheelSchema.parse(body)
     const path = await saveWheel(data.wheel, data.uid, data.visibility)
     return new Response(
       JSON.stringify({
diff --git a/src/routes/api/wheels/[path=path]/+server.ts b/src/routes/api/wheels/[path=path]/+server.ts
index 16504f0..db26445 100644
--- a/src/routes/api/wheels/[path=path]/+server.ts
+++ b/src/routes/api/wheels/[path=path]/+server.ts
@@ -1,5 +1,7 @@
+import { z } from 'zod'
 import { SVELTE_WHEEL_API_KEY } from '$env/static/private'
-import { getWheel } from '$lib/server/FirebaseAdmin'
+import { getWheel, updateWheel } from '$lib/server/FirebaseAdmin'
+import { updateWheelSchema } from '$lib/utils/Schemas'
 import type { ApiError, ApiSuccess, ApiWheel } from '$lib/utils/Api'
 
 export const GET = async ({ request, params }) => {
@@ -40,7 +42,66 @@ export const GET = async ({ request, params }) => {
     return new Response(
       JSON.stringify({
         success: false,
-        error : { message: `Error when fetching wheel "${params.path}"` }
+        error : { message: `Error fetching wheel "${params.path}"` }
+      } satisfies ApiError),
+      { status: 500 }
+    )
+  }
+}
+
+export const PUT = async ({ request, params }) => {
+  const uid = request.headers.get('authorization')
+  const apiKey = request.headers.get('x-api-key')
+  if (
+    (!uid && !apiKey) ||
+    (apiKey && apiKey !== SVELTE_WHEEL_API_KEY)
+  ) {
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error : { message: 'Unauthorized' }
+      } satisfies ApiError),
+      { status: 401 }
+    )
+  }
+  try {
+    const body = await request.json()
+    const { wheel, uid, visibility } = updateWheelSchema.parse(body)
+    const path = await updateWheel(params.path, wheel, uid, visibility)
+    if (!path) {
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error : { message: `Wheel "${params.path}" not found` }
+        } satisfies ApiError),
+        { status: 404 }
+      )
+    }
+    return new Response(
+      JSON.stringify({
+        success: true,
+        data: { path }
+      } satisfies ApiSuccess<{ path: string }>),
+      { status: 200 }
+    )
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: {
+            message: 'Invalid wheel',
+            errors: error.flatten().fieldErrors
+          }
+        } satisfies ApiError),
+        { status: 400 }
+      )
+    }
+    console.error(error)
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error : { message: `Error updating wheel "${params.path}"` }
       } satisfies ApiError),
       { status: 500 }
     )