catch missed additions for db separation, add in tokenizers

backend/src/app.ts

@@ -1,6 +1,8 @@
 import express from 'express'
 import { json } from 'body-parser'
+import { Sequelize } from 'sequelize'
 import { database, Character, Game, Pick, App } from './db'
+import { lexr, orderByLexr, parseOrderByString } from './tokenizer'
 
 const app = express()
 const jsonParser = json()
@@ -34,16 +36,17 @@ app.get('/api/game/:gameId', async (req, res) => {
 })
 
 app.post('/api/game', jsonParser, async (req, res) => {
+  console.log(req.body)
+
   const page = req.body.page || 0
-  const orderBy = req.body.orderBy || 'id'
+  const orderBy = req.body.orderBy ? parseOrderByString(req.body.orderBy) : ['id']
   const count = req.body.count || 10
   const filter = req.body.filter || ''
 
-  console.log(filter)
-
   const gameData = await Game.findAll({
     offset: page * count,
-    limit: count
+    limit: count,
+    order: orderBy
   })
   const pageCount = Math.ceil((await Character.count()) / count)
 

backend/src/db.ts

@@ -0,0 +1,77 @@
+import { Sequelize, Model, DataTypes } from 'sequelize'
+
+const databasePath = './testdb.db'
+
+export const database = new Sequelize({
+  dialect: 'sqlite',
+  storage: databasePath
+})
+
+export const Character = database.define(
+  'Characters',
+  {
+    id: { type: DataTypes.INTEGER, primaryKey: true },
+    characterName: { type: DataTypes.TEXT },
+    playerName: { type: DataTypes.TEXT },
+    role: { type: DataTypes.TEXT },
+    creationDate: { type: DataTypes.INTEGER },
+    status: { type: DataTypes.TEXT }
+  },
+  { timestamps: false }
+)
+
+export const Game = database.define(
+  'Games',
+  {
+    id: { type: DataTypes.INTEGER, primaryKey: true },
+    title: { type: DataTypes.TEXT },
+    status: { type: DataTypes.TEXT },
+    fix: { type: DataTypes.BOOLEAN },
+    postdate: { type: DataTypes.INTEGER },
+    gamemaster: { type: DataTypes.TEXT },
+    payoutEB: { type: DataTypes.INTEGER },
+    payoutIP: { type: DataTypes.INTEGER },
+    payputLoot: { type: DataTypes.INTEGER }
+  },
+  { timestamps: false }
+)
+
+export const Pick = database.define(
+  'Picks',
+  {
+    gameId: { type: DataTypes.INTEGER, primaryKey: true },
+    gameTitle: { type: DataTypes.TEXT },
+    characterId: { type: DataTypes.INTEGER, primaryKey: true },
+    characterName: { type: DataTypes.TEXT }
+  },
+  { timestamps: false }
+)
+
+export const App = database.define(
+  'Apps',
+  {
+    gameId: { type: DataTypes.INTEGER, primaryKey: true },
+    gameTitle: { type: DataTypes.TEXT },
+    characterId: { type: DataTypes.INTEGER, primaryKey: true },
+    characterName: { type: DataTypes.TEXT }
+  },
+  { timestamps: false }
+)
+
+// Bind characters to applications and picks
+Character.hasMany(App, { foreignKey: 'characterId', as: 'appliedCharacter' })
+App.belongsTo(Character, { foreignKey: 'characterId', as: 'appliedCharacter' })
+Character.hasMany(Pick, { foreignKey: 'characterId', as: 'pickedCharacter' })
+Pick.belongsTo(Character, { foreignKey: 'characterId', as: 'pickedCharacter' })
+
+// Bind games to applications and picks
+Game.hasMany(App, { foreignKey: 'gameId', as: 'gameApplications' })
+App.belongsTo(Game, { foreignKey: 'gameId', as: 'gameApplications' })
+Game.hasMany(Pick, { foreignKey: 'gameId', as: 'gamePicks' })
+Pick.belongsTo(Game, { foreignKey: 'gameId', as: 'gamePicks' })
+
+// Bind picked characters to games.
+Game.belongsToMany(Character, { through: 'Apps', as: 'characterAppliedForGame' })
+Character.belongsToMany(Game, { through: 'Apps', as: 'characterAppliedForGame' })
+Game.belongsToMany(Character, { through: 'Picks', as: 'characterPickedForGame' })
+Character.belongsToMany(Game, { through: 'Picks', as: 'characterPickedForGame' })

backend/src/tokenizer.ts

@@ -0,0 +1,49 @@
+import Tokenizr from 'tokenizr'
+
+export const lexr = new Tokenizr()
+
+lexr.rule(/[AND|OR]/, (ctx, m) => {
+  ctx.accept('conjunction', m[0])
+})
+
+export const orderByLexr = new Tokenizr()
+
+orderByLexr.rule(/,/, (ctx, m) => {
+  ctx.accept('spacer')
+})
+
+orderByLexr.rule(/ASC|DESC/, (ctx, m) => {
+  ctx.accept('direction', m[0])
+})
+
+orderByLexr.rule(/[a-zA-Z]+/, (ctx, m) => {
+  ctx.accept('column', m[0])
+})
+
+orderByLexr.rule(/\s/, (ctx, m) => {
+  ctx.ignore()
+})
+
+export function parseOrderByString(orderBy: string) {
+  const output = []
+  let holding = []
+  orderByLexr
+    .input(orderBy)
+    .tokens()
+    .forEach((token) => {
+      switch (token.type) {
+        case 'spacer':
+          output.push(holding)
+          holding = []
+          break
+        case 'column':
+        case 'direction':
+          holding.push(token.value)
+          break
+      }
+    })
+  if (holding) {
+    output.push(holding)
+  }
+  return output
+}