noxious/server
6
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NPM update, removed CRUD functions from object repository, added prettier

Browse Source
This commit is contained in:
Dennis Postma
2024-07-22 01:36:05 +02:00
parent 792abdfaf6
commit 6131a8455a
51 changed files with 1450 additions and 1460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
src/repositories/CharacterRepository.ts
View File

@ -1,125 +1,125 @@
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import {Character} from '@prisma/client';
import prisma from '../utilities/Prisma' // Import the global Prisma instance
import { Character } from '@prisma/client'
class CharacterRepository {
async getByUserId(userId: number): Promise<Character[] | null> {
try {
return await prisma.character.findMany({
where: {
userId,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by user ID: ${error.message}`);
async getByUserId(userId: number): Promise<Character[] | null> {
try {
return await prisma.character.findMany({
where: {
userId
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by user ID: ${error.message}`)
}
}
async getByUserAndId(userId: number, characterId: number): Promise<Character | null> {
try {
return await prisma.character.findFirst({
where: {
userId,
id: characterId,
},
include: {
zone: true
}
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by user ID and character ID: ${error.message}`);
async getByUserAndId(userId: number, characterId: number): Promise<Character | null> {
try {
return await prisma.character.findFirst({
where: {
userId,
id: characterId
},
include: {
zone: true
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by user ID and character ID: ${error.message}`)
}
}
async getById(id: number): Promise<Character | null> {
try {
return await prisma.character.findUnique({
where: {
id,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by ID: ${error.message}`);
async getById(id: number): Promise<Character | null> {
try {
return await prisma.character.findUnique({
where: {
id
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by ID: ${error.message}`)
}
}
async create(userId: number, name: string, role: 'player'): Promise<Character | null> {
try {
return await prisma.character.create({
data: {
userId,
name,
role,
position_x: 0, // @TODO Set default registration values in the database
position_y: 0, // @TODO Set default registration values in the database
rotation: 0, // @TODO Set default registration values in the database
zoneId: 1, // @TODO Set default registration values in the database
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to create character: ${error.message}`);
async create(userId: number, name: string, role: 'player'): Promise<Character | null> {
try {
return await prisma.character.create({
data: {
userId,
name,
role,
position_x: 0, // @TODO Set default registration values in the database
position_y: 0, // @TODO Set default registration values in the database
rotation: 0, // @TODO Set default registration values in the database
zoneId: 1 // @TODO Set default registration values in the database
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to create character: ${error.message}`)
}
}
async updatePosition(id:number, position_x: number, position_y: number): Promise<Character | null> {
try {
return await prisma.character.update({
where: {
id: id,
},
data: {
position_x,
position_y,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to update character: ${error.message}`);
async updatePosition(id: number, position_x: number, position_y: number): Promise<Character | null> {
try {
return await prisma.character.update({
where: {
id: id
},
data: {
position_x,
position_y
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to update character: ${error.message}`)
}
}
async delete(id: number): Promise<Character | null> {
try {
return await prisma.character.delete({
where: {
id,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to delete character: ${error.message}`);
async delete(id: number): Promise<Character | null> {
try {
return await prisma.character.delete({
where: {
id
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to delete character: ${error.message}`)
}
}
async deleteByUserIdAndId(userId: number, characterId: number): Promise<Character | null> {
try {
return await prisma.character.delete({
where: {
userId,
id: characterId,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to delete character by user ID and character ID: ${error.message}`);
async deleteByUserIdAndId(userId: number, characterId: number): Promise<Character | null> {
try {
return await prisma.character.delete({
where: {
userId,
id: characterId
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to delete character by user ID and character ID: ${error.message}`)
}
}
async getByName(name: string): Promise<Character | null> {
try {
return await prisma.character.findFirst({
where: {
name,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by name: ${error.message}`);
async getByName(name: string): Promise<Character | null> {
try {
return await prisma.character.findFirst({
where: {
name
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to get character by name: ${error.message}`)
}
}
}
export default new CharacterRepository;
export default new CharacterRepository()

48
src/repositories/ObjectRepository.ts
View File

@ -1,44 +1,16 @@
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import prisma from '../utilities/Prisma' // Import the global Prisma instance
import { Object } from '@prisma/client'
class ObjectRepository {
async getById(id: string): Promise<Object | null> {
return prisma.object.findUnique({
where: { id },
});
}
async getById(id: string): Promise<Object | null> {
return prisma.object.findUnique({
where: { id }
})
}
async getAll(): Promise<Object[]> {
return prisma.object.findMany();
}
async create(name: string, origin_x: number, origin_y: number): Promise<Object> {
return prisma.object.create({
data: {
name,
origin_x,
origin_y
},
});
}
async update(id: string, name: string, tags: string[], origin_x: number, origin_y: number): Promise<Object> {
return prisma.object.update({
where: { id },
data: {
name,
tags,
origin_x,
origin_y
},
});
}
async delete(id: string): Promise<Object> {
return prisma.object.delete({
where: { id },
});
}
async getAll(): Promise<Object[]> {
return prisma.object.findMany()
}
}
export default new ObjectRepository();
export default new ObjectRepository()

68
src/repositories/SpriteRepository.ts
View File

@ -1,43 +1,43 @@
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import prisma from '../utilities/Prisma' // Import the global Prisma instance
import { Sprite } from '@prisma/client'
class SpriteRepository {
async getById(id: string): Promise<Sprite | null> {
return prisma.sprite.findUnique({
where: { id },
});
}
async getById(id: string): Promise<Sprite | null> {
return prisma.sprite.findUnique({
where: { id }
})
}
async getAll(): Promise<Sprite[]> {
return prisma.sprite.findMany();
}
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 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 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 },
});
}
async delete(id: string): Promise<Sprite> {
return prisma.sprite.delete({
where: { id }
})
}
}
export default new SpriteRepository();
export default new SpriteRepository()

74
src/repositories/TileRepository.ts
View File

@ -1,47 +1,47 @@
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import prisma from '../utilities/Prisma' // Import the global Prisma instance
import { Tile } from '@prisma/client'
class TileRepository {
async getById(id: string): Promise<Tile | null> {
return prisma.tile.findUnique({
where: { id },
});
}
async getById(id: string): Promise<Tile | null> {
return prisma.tile.findUnique({
where: { id }
})
}
async getAll(): Promise<Tile[]> {
return prisma.tile.findMany();
}
async getAll(): Promise<Tile[]> {
return prisma.tile.findMany()
}
async create(name: string): Promise<Tile> {
return prisma.tile.create({
data: {
name,
tags: []
},
});
}
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 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;
}
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();
export default new TileRepository()

68
src/repositories/UserRepository.ts
View File

@ -1,44 +1,44 @@
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import { User } from '@prisma/client';
import prisma from '../utilities/Prisma' // Import the global Prisma instance
import { User } from '@prisma/client'
class UserRepository {
async getById(id: number): Promise<User | null> {
try {
return await prisma.user.findUnique({
where: {
id,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get user by ID: ${error.message}`);
async getById(id: number): Promise<User | null> {
try {
return await prisma.user.findUnique({
where: {
id
}
})
} catch (error: any) {
// Handle error
throw new Error(`Failed to get user by ID: ${error.message}`)
}
async getByUsername(username: string): Promise<User | null> {
try {
return await prisma.user.findUnique({
where: {
username,
},
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get user by username: ${error.message}`);
}
async getByUsername(username: string): Promise<User | null> {
try {
return await prisma.user.findUnique({
where: {
username
}
})
} catch (error: any) {
// Handle error
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}`);
}
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;
export default new UserRepository()

200
src/repositories/ZoneRepository.ts
View File

@ -1,120 +1,120 @@
import { Zone, ZoneEventTile, ZoneObject } from '@prisma/client'
import prisma from '../utilities/Prisma'; // Import the global Prisma instance
import prisma from '../utilities/Prisma' // Import the global Prisma instance
class ZoneRepository {
async getFirst(): Promise<Zone | null> {
try {
return await prisma.zone.findFirst();
} catch (error: any) {
// Handle error
throw new Error(`Failed to get first zone: ${error.message}`);
}
async getFirst(): Promise<Zone | null> {
try {
return await prisma.zone.findFirst()
} catch (error: any) {
// Handle error
throw new Error(`Failed to get first zone: ${error.message}`)
}
}
async getAll(): Promise<Zone[]> {
try {
return await prisma.zone.findMany();
} catch (error: any) {
// Handle error
throw new Error(`Failed to get all zone: ${error.message}`);
}
async getAll(): Promise<Zone[]> {
try {
return await prisma.zone.findMany()
} catch (error: any) {
// Handle error
throw new Error(`Failed to get all zone: ${error.message}`)
}
}
async getById(id: number): Promise<Zone | null> {
try {
return await prisma.zone.findUnique({
where: {
id: id
},
include: {
zoneEventTiles: {
include: {
zone: true
}
},
zoneObjects: {
include: {
object: true
}
}
}
});
} catch (error: any) {
// Handle error
throw new Error(`Failed to get zone by id: ${error.message}`);
async getById(id: number): Promise<Zone | null> {
try {
return await prisma.zone.findUnique({
where: {
id: id
},
include: {
zoneEventTiles: {
include: {
zone: true
}
},
zoneObjects: {
include: {
object: true
}
}
}
})
} catch (error: any) {
// Handle error
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 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 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}`);
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;
export default new ZoneRepository()