DB updates, removed all CRUD func's from repositories as prisma's func's are sufficient and reduces boilerplate.

src/repositories/SpriteRepository.ts

@@ -11,33 +11,6 @@ class SpriteRepository {
   async getAll(): Promise<Sprite[]> {
     return prisma.sprite.findMany()
   }
-
-  async create(name: string, origin_x: number, origin_y: number): Promise<Sprite> {
-    return prisma.sprite.create({
-      data: {
-        name,
-        origin_x,
-        origin_y
-      }
-    })
-  }
-
-  async update(id: string, name: string, origin_x: number, origin_y: number): Promise<Sprite> {
-    return prisma.sprite.update({
-      where: { id },
-      data: {
-        name,
-        origin_x,
-        origin_y
-      }
-    })
-  }
-
-  async delete(id: string): Promise<Sprite> {
-    return prisma.sprite.delete({
-      where: { id }
-    })
-  }
 }
 
 export default new SpriteRepository()

src/repositories/TileRepository.ts

@@ -11,37 +11,6 @@ class TileRepository {
   async getAll(): Promise<Tile[]> {
     return prisma.tile.findMany()
   }
-
-  async create(name: string): Promise<Tile> {
-    return prisma.tile.create({
-      data: {
-        name,
-        tags: []
-      }
-    })
-  }
-
-  async update(id: string, name: string, tags: string[]): Promise<Tile> {
-    return prisma.tile.update({
-      where: { id },
-      data: {
-        name,
-        tags
-      }
-    })
-  }
-
-  async delete(id: string): Promise<boolean> {
-    try {
-      await prisma.tile.delete({
-        where: { id }
-      })
-      return true
-    } catch (error) {
-      console.log('Error deleting tile:', error)
-      return false
-    }
-  }
 }
 
 export default new TileRepository()

src/repositories/UserRepository.ts

@@ -26,19 +26,6 @@ class UserRepository {
       throw new Error(`Failed to get user by username: ${error.message}`)
     }
   }
-  async create(username: string, password: string): Promise<User> {
-    try {
-      return await prisma.user.create({
-        data: {
-          username,
-          password
-        }
-      })
-    } catch (error: any) {
-      // Handle error
-      throw new Error(`Failed to create user: ${error.message}`)
-    }
-  }
 }
 
 export default new UserRepository()

src/repositories/ZoneRepository.ts

@@ -1,4 +1,4 @@
-import { Zone, ZoneEventTile, ZoneObject } from '@prisma/client'
+import { Zone } from '@prisma/client'
 import prisma from '../utilities/Prisma' // Import the global Prisma instance
 
 class ZoneRepository {
@@ -44,77 +44,6 @@ class ZoneRepository {
       throw new Error(`Failed to get zone by id: ${error.message}`)
     }
   }
-
-  async create(name: string, width: number, height: number, tiles: string[][]): Promise<Zone> {
-    try {
-      return await prisma.zone.create({
-        data: {
-          name: name,
-          width: width,
-          height: height,
-          tiles: tiles
-        }
-      })
-    } catch (error: any) {
-      // Handle error
-      throw new Error(`Failed to create zone: ${error.message}`)
-    }
-  }
-
-  async update(id: number, name: string, width: number, height: number, tiles: string[][], zoneEventTiles: ZoneEventTile[], zoneObjects: ZoneObject[]): Promise<Zone> {
-    try {
-      return await prisma.zone.update({
-        where: {
-          id: id
-        },
-        data: {
-          name,
-          width,
-          height,
-          tiles,
-          zoneEventTiles: {
-            deleteMany: {
-              zoneId: id // Ensure only event tiles related to the zone are deleted
-            },
-            // Save new zone event tiles
-            create: zoneEventTiles.map((zoneEventTile) => ({
-              type: zoneEventTile.type,
-              position_x: zoneEventTile.position_x,
-              position_y: zoneEventTile.position_y
-            }))
-          },
-          zoneObjects: {
-            deleteMany: {
-              zoneId: id // Ensure only objects related to the zone are deleted
-            },
-            // Save new zone objects
-            create: zoneObjects.map((zoneObject) => ({
-              objectId: zoneObject.objectId,
-              depth: zoneObject.depth,
-              position_x: zoneObject.position_x,
-              position_y: zoneObject.position_y
-            }))
-          }
-        }
-      })
-    } catch (error: any) {
-      // Handle error
-      throw new Error(`Failed to update zone: ${error.message}`)
-    }
-  }
-
-  async delete(id: number): Promise<Zone> {
-    try {
-      return await prisma.zone.delete({
-        where: {
-          id: id
-        }
-      })
-    } catch (error: any) {
-      // Handle error
-      throw new Error(`Failed to delete zone: ${error.message}`)
-    }
-  }
 }
 
 export default new ZoneRepository()