Joururi/spellsaurus
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Did the unthinkable and actually achieved Peak ORM

Browse Source
This commit is contained in:
Alexis
2020-06-06 00:17:01 +02:00
parent cabbf68f7a
commit 369d53d509
9 changed files with 381 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

340
routes/spells.js
View File

@@ -8,87 +8,18 @@ let router = express.Router()
const connection = require('../database/connection')
const db = connection.db
// Validations
// Repository
const SpellReposity = require('../repositories/spell-repository');
const Spells = new SpellReposity();
const regexInt = RegExp(/^[1-9]\d*$/)
const regexXSS = RegExp(/<[^>]*script/)
// Bookshelf Models
const bookshelf = require('../database/connection').bookshelf
const Spell = bookshelf.Model.extend({
tableName: 'spell',
schools() {
return this.belongsToMany( School, 'spell_school', 'spell_id', 'school_id' )
},
variables() {
return this.belongsToMany( Variable, 'spell_variable', 'spell_id', 'variable_id' )
},
ingredients() {
return this.belongsToMany( Ingredient, 'spell_ingredient', 'spell_id', 'ingredient_id' )
}
})
const MetaSchool = bookshelf.Model.extend({
tableName: 'meta_school',
schools() {
return this.hasMany( School )
}
})
const School = bookshelf.Model.extend({
tableName: 'school',
spells() {
return this.belongsToMany( Spell, 'spell_school', 'school_id', 'spell_id')
},
meta_school() {
return this.belongsTo( MetaSchool, 'meta_school_id')
}
})
const Ingredient = bookshelf.Model.extend({
tableName: 'ingredient',
spells() {
return this.belongsToMany( Spell, 'spell_ingredient', 'ingredient_id', 'spell_id')
}
})
const Variable = bookshelf.Model.extend({
tableName: 'variable',
spells() {
return this.belongsToMany( Spell, 'spell_variable', 'variable_id', 'spell_id')
}
})
// Model validation
const Validator = require('jsonschema').Validator
const v = new Validator()
const SpellModel = require("../models/SpellValidation")
v.addSchema(SpellModel, "/SpellModel")
// Error handling
const { HttpError } = require('../models/Errors')
// ROUTES
// GET ALL ------------------
const getSpells = () => {
return new Promise((resolve, reject) => {
Spell.forge()
.fetchAll({ withRelated: ['schools.meta_school', 'variables', 'ingredients'] })
.then(v => {
resolve(v.toJSON({ omitPivot: true }))
})
.catch(err => {
console.log(err)
if (err.message == "EmptyResponse") {
reject(new HttpError(404, "No spells matching this id were found"))
} else {
reject(new HttpError(500, err.message))
}
})
})
return Spells.getAll()
.catch(err => {
console.log(err)
throw err
})
}
@@ -111,20 +42,9 @@ router.get('/', async (req, res) => {
// GET ONE ------------------
const getSpell = (id) => {
return new Promise((resolve, reject) => {
Spell.forge()
.where({ 'id' : id })
.fetch({ withRelated: ['schools.meta_school', 'variables', 'ingredients'] })
.then(v => {
resolve(v.toJSON({ omitPivot: true }))
})
.catch(err => {
reject(new HttpError(500, err.message))
})
})
return Spells.getOne(id)
.catch(err => {
console.log(err)
throw err
})
}
@@ -147,144 +67,9 @@ router.get('/:id/', async (req, res) => {
// CREATE ONE ------------------
const addSpell = (s) => {
return new Promise(async (resolve, reject) => {
// Checks if body exists and if the model fits, and throws errors if it doesn't
if (isEmptyObject(s)) {
reject(new HttpError(403, "Error: Spell cannot be nothing !"))
} else if (!v.validate(s, SpellModel).valid) {
reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, SpellModel).errors))
} else if (isXSSAttempt(s.name) || isXSSAttempt(s.description) || isXSSAttempt(s.cost)) {
reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
} else {
Spell.forge({
'name': s.name,
'description': s.description,
'level': s.level,
})
// let query =
// 'INSERT INTO spell (name, description'
// if (s.level !== null) { query += ', level' }
// if (s.charge !== null) { query += ', charge' }
// if (s.cost !== null) { query += ', cost' }
// if (s.is_ritual !== null) { query += ', is_ritual' }
// query += `) VALUES (${db.escape(s.name)}, ${db.escape(s.description)}`
// if (s.level !== null) { query += `, ${s.level}` }
// if (s.charge !== null) { query += `, ${s.charge}` }
// if (s.cost !== null) { query += `, ${db.escape(s.cost)}` }
// if (s.is_ritual !== null) { query += `, ${s.is_ritual}` }
// query += ')'
// db.query(query, async (err, result) => {
// if (err) {
// reject(new HttpError(500, 'Database error'))
// }
// console.log(`Inserted "${s.name}" with ID ${result.insertId}, affecting ${result.affectedRows} row(s)`)
// const new_spell_id = result.insertId
// let addSchoolsData = () => {
// return new Promise((resolve, reject) => {
// if (s.schools !== null) {
// if (s.schools.length > 0) {
// for (let i = 0; i < s.schools.length; i++) {
// if (!regexInt.test(s.schools[i].id)) {
// reject(new HttpError(403, 'Query error - School ID should be an integer !'))
// }
// let insert_schools_query = `INSERT INTO spells_schools (id_spell, id_school) VALUES (${new_spell_id}, ${s.schools[i].id})`
// db.query(insert_schools_query, async (err, result) => {
// if (err) {
// reject(new HttpError(404, 'Database error - No schools matching this ID'))
// } else {
// console.log(`Associated school ID ${s.schools[i].id} to spell ID ${new_spell_id}, affecting ${result.affectedRows} row(s)`)
// resolve()
// }
// })
// }
// } else {
// resolve()
// }
// } else {
// resolve()
// }
// })
// }
// let addVariablesData = () => {
// return new Promise((resolve, reject) => {
// if (s.variables !== null) {
// if (s.variables.length > 0) {
// for (let i = 0; i < s.variables.length; i++) {
// if (!regexInt.test(s.variables[i].id)) {
// reject(new HttpError(403, 'Query error - Variable ID should be an integer !'))
// }
// let insert_variables_query = `INSERT INTO spells_variables (id_spell, id_variable) VALUES (${new_spell_id}, ${s.variables[i].id})`
// db.query(insert_variables_query, async (err, result) => {
// if (err) {
// reject(new HttpError(404, 'Database error - No variables matching this ID'))
// } else {
// console.log(`Associated variable ID ${s.variables[i].id} to spell ID ${new_spell_id}, affecting ${result.affectedRows} row(s)`)
// resolve()
// }
// })
// }
// } else {
// resolve()
// }
// } else {
// resolve()
// }
// })
// }
// let addIngredientsData = () => {
// return new Promise((resolve, reject) => {
// if (s.ingredients !== null) {
// if (s.ingredients.length > 0) {
// for (let i = 0; i < s.ingredients.length; i++) {
// if (!regexInt.test(s.ingredients[i].id)) {
// reject(new HttpError(403, 'Query error - Ingredient ID should be an integer !'))
// }
// let insert_ingredients_query = `INSERT INTO spells_ingredients (id_spell, id_ingredient) VALUES (${new_spell_id}, ${s.ingredients[i].id})`
// db.query(insert_ingredients_query, async (err, result) => {
// if (err) {
// reject(new HttpError(404, 'Database error - No ingredients matching this ID'))
// } else {
// console.log(`Associated ingredient ID ${s.ingredients[i].id} to spell ID ${new_spell_id}, affecting ${result.affectedRows} row(s)`)
// resolve()
// }
// })
// }
// } else {
// resolve()
// }
// } else {
// resolve()
// }
// })
// }
// Promise.all([addSchoolsData(), addVariablesData(), addIngredientsData()])
// .then(() => {
// resolve(getSpell(new_spell_id))
// })
// .catch(err => {
// reject(err)
// })
// })
}
}).catch(err => {
throw err
return Spells.addOne(s)
.catch(err => {
console.log(err)
})
}
router.post('/', async (req, res) => {
@@ -627,107 +412,4 @@ router.param('id', (req, res, next, id) => {
}
})
// SHARED FUNCTIONS ------------------
// Builds the associated infos for a given spell object
const buildSpell = async (spell) => {
// Fetches the spell's schools
let fetchSpellSchoolData = (s) => {
return new Promise((resolve, reject) => {
if (s == null) { reject(new HttpError(404, "Error: No spell matching this ID"))}
let query =
"SELECT school.id, school.name " +
"FROM spells_schools AS sc " +
"INNER JOIN school AS school ON sc.id_school = school.id " +
"WHERE sc.id_spell = " + s.id
db.query(query, (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else {
s.schools = result
resolve(s)
}
})
})
}
// Fetches the spell's variables
let fetchSpellVariablesData = (s) => {
return new Promise((resolve, reject) => {
if (s == null) { reject(new HttpError(404, "Error: No spell matching this ID"))}
let query =
"SELECT variable.id, variable.description " +
"FROM spells_variables AS sv " +
"INNER JOIN variable AS variable ON sv.id_variable = variable.id " +
"WHERE sv.id_spell = " + s.id
db.query(query, (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else {
s.variables = result
resolve(s)
}
})
})
}
// Fetches the spell's ingredients
let fetchSpellIngredientsData = (s) => {
return new Promise((resolve, reject) => {
if (s == null) { reject(new HttpError(404, "Error: No spell matching this ID"))}
let query =
"SELECT ingredient.id, ingredient.name " +
"FROM spells_ingredients AS si " +
"INNER JOIN ingredient AS ingredient ON si.id_ingredient = ingredient.id " +
"WHERE si.id_spell = " + s.id
db.query(query, (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else {
s.ingredients = result
resolve(s)
}
})
})
}
// Builds the spell and returns it
let s = await fetchSpellSchoolData(spell)
.then(s => { return fetchSpellVariablesData(s) })
.then(s => { return fetchSpellIngredientsData(s) })
.catch(err => {
throw err
})
return s
}
// Check if object is null
const isEmptyObject = (obj) => {
if (Object.keys(obj).length === 0 && obj.constructor === Object) {
return true
} else {
return false
}
}
// Check if script injection attempt
const isXSSAttempt = (string) => {
if (regexXSS.test(string)) {
return true
} else {
return false
}
}
module.exports = router

76
routes/users.js
View File

@@ -1,3 +1,5 @@
'use strict'
// Router
const express = require('express')
let router = express.Router()
@@ -6,40 +8,18 @@ let router = express.Router()
const connection = require('../database/connection')
const db = connection.db
// Hashing and passwords
const bcrypt = require('bcrypt')
// Repository
const UserRepository = require('../repositories/user-repository');
const Users = new UserRepository();
// Validations
const regexInt = RegExp(/^[1-9]\d*$/)
const regexXSS = RegExp(/<[^>]*script/)
// Model validation
const Validator = require('jsonschema').Validator
const v = new Validator()
const User = require("../models/UserValidation")
v.addSchema(User, "/UserModel")
// Error handling
const { HttpError } = require('../models/Errors')
// ROUTES
// GET ALL ------------------
const getUsers = () => {
return new Promise((resolve, reject) => {
let query = "SELECT DISTINCT * FROM user"
db.query(query, async (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else if (result.length == 0) {
reject(new HttpError(404, 'No users were found'))
} else {
resolve(result)
}
})
})
return Users.getAll()
.catch(err => {
console.log(err)
throw err
})
}
@@ -62,21 +42,9 @@ router.get('/', async (req, res) => {
// GET ONE ------------------
const getUser = (id) => {
return new Promise((resolve, reject) => {
let query = "SELECT * FROM user WHERE id = " + db.escape(id)
db.query(query, async (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else if (result.length == 0) {
reject(new HttpError(404, 'No User matching this ID'))
} else {
resolve(result)
}
})
})
return Users.getOne(id)
.catch(err => {
console.log(err)
throw err
})
}
@@ -211,33 +179,11 @@ router.param('id', (req, res, next, id) => {
if (regexInt.test(id)) {
next()
} else {
throw new HttpError(403, 'Provided ID must be an integer and not zero')
new Error
}
} catch (err) {
res.status(err.code).send(JSON.stringify(
{
"error": err.message,
})
)
throw new HttpError(403, 'Provided ID must be an integer and not zero')
}
})
// Check if object is null
const isEmptyObject = (obj) => {
if (Object.keys(obj).length === 0 && obj.constructor === Object) {
return true
} else {
return false
}
}
// Check if script injection attempt
const isXSSAttempt = (string) => {
if (regexXSS.test(string)) {
return true
} else {
return false
}
}
module.exports = router