Get it to store data from grpc calls.

vault/src/app.ts

@@ -1,41 +1,46 @@
 import { Server, ServerCredentials } from '@grpc/grpc-js'
 import { MongoClient } from 'mongodb'
 
-import { initCharacterService } from './character_service'
+import { CharacterService } from './character_service'
 import { DatabaseService } from './database'
 
-const port = 8000
+const port = 8080
+const address = `0.0.0.0:${port}`
 
 const app = new Server()
 
 const client = new MongoClient('mongodb://rushvault:rushvault@mongo:27017/')
 
-initCharacterService(app)
+// initCharacterService(app)
 
-async function testDb() {
-  try {
-    // await client.connect()
-    const database = client.db('test')
-    const potato = database.collection('potato')
+const characterService = new CharacterService(client, "rush-vault")
 
-    await potato.insertOne({ name: 'potato', potato: 'potato' })
-  } finally {
-    await client.close()
-  }
-}
+characterService.addToServer(app)
 
-app.bindAsync('0.0.0.0:8080', ServerCredentials.createInsecure(), async () => {
-  await testDb().catch(console.dir)
+// async function testDb() {
+//   try {
+//     // await client.connect()
+//     const database = client.db('test')
+//     const potato = database.collection('potato')
 
-  let db = new DatabaseService(
-    'mongodb://rushvault:rushvault@mongo:27017/',
-    'rush-vault',
-  )
-  console.log(await db.insertCharacter({
-    playerName: 'badger',
-    characterName: 'potato',
-    characterAlias: ['spud', 'tuber'],
-  }))
+//     await potato.insertOne({ name: 'potato', potato: 'potato' })
+//   } finally {
+//     await client.close()
+//   }
+// }
 
-  console.log('Starting server at 0.0.0.0:8080')
+app.bindAsync(address, ServerCredentials.createInsecure(), () => {
+  // await testDb().catch(console.dir)
+
+  // let db = new DatabaseService(
+  //   'mongodb://rushvault:rushvault@mongo:27017/',
+  //   'rush-vault',
+  // )
+  // console.log(await db.insertCharacter({
+  //   playerName: 'badger',
+  //   characterName: 'potato',
+  //   characterAlias: ['spud', 'tuber'],
+  // }))
+
+  console.log(`Starting server at ${address}`)
 })

vault/src/character_service.ts

@@ -1,6 +1,7 @@
-import { Server } from '@grpc/grpc-js'
+import { Server, ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js'
 import { ReflectionService } from '@grpc/reflection'
 import { loadSync } from '@grpc/proto-loader'
+import { MongoClient, Collection, Db } from 'mongodb'
 
 import {
   Character,
@@ -13,28 +14,66 @@ import {
   ICharacterManager,
 } from './proto/character.grpc-server'
 
-export function initCharacterService(server: Server) {
-  server.addService(characterManagerDefinition, CharacterManagerService)
+export class CharacterService {
+  reflectionService: ReflectionService
+  characterManager: ICharacterManager
 
-  new ReflectionService(loadSync('./src/proto/character.proto')).addToServer(
-    server,
-  )
-}
+  mongoClient: MongoClient
+  db: Db
+  characterCollection: Collection
 
-const CharacterManagerService: ICharacterManager = {
-  createCharacter: (request: CreateCharacterRequest): Character => {
-    return {
+  constructor(mongoClient: MongoClient, dbName: string) {
+    this.reflectionService = new ReflectionService(
+      loadSync('./src/proto/character.proto'),
+    )
+
+    this.characterManager = {
+      createCharacter: this.createCharacterCall.bind(this),
+      getCharacter: this.getCharacterCall.bind(this),
+    }
+
+    this.mongoClient = mongoClient
+    this.db = this.mongoClient.db(dbName)
+    this.characterCollection = this.db.collection('Characters')
+  }
+
+  addToServer(server: Server) {
+    server.addService(characterManagerDefinition, this.characterManager)
+
+    this.reflectionService.addToServer(server)
+  }
+
+  async createCharacterCall(
+    call: ServerUnaryCall<CreateCharacterRequest, Character>,
+    callback: sendUnaryData<Character>,
+  ) {
+
+    let newCharacter = await this.characterCollection
+      .insertOne(call.request.characterData)
+      .then((insertResult) => {
+        console.log(insertResult)
+        return this.characterCollection.findOne({
+          _id: insertResult.insertedId,
+        })
+      })
+
+    console.log(newCharacter)
+
+    callback(null, {
+      playerName: newCharacter.playerName,
+      characterName: newCharacter.characterName,
+      characterAlias: newCharacter.characterAlias,
+    })
+  }
+
+  getCharacterCall(
+    call: ServerUnaryCall<GetCharacterRequest, Character>,
+    callback: sendUnaryData<Character>,
+  ) {
+    callback(null, {
       playerName: 'test player',
       characterName: 'test character',
       characterAlias: ['test alias'],
-    }
-  },
-
-  getCharacter: (request: GetCharacterRequest): Character => {
-    return {
-      playerName: 'test player',
-      characterName: 'test character',
-      characterAlias: ['test alias'],
-    }
-  },
+    })
+  }
 }

vault/src/database.ts

@@ -17,7 +17,9 @@ export class DatabaseService {
       .insertOne(character)
       .then((insertResult) => {
         console.log(insertResult)
-        return this.characterCollection.findOne({ _id: insertResult.insertedId })
+        return this.characterCollection.findOne({
+          _id: insertResult.insertedId,
+        })
       })
       .then((inserted) => {
         return {