Clean code

functions/src/calendar.ts

@@ -8,7 +8,7 @@ type GCalConfig = {
   privateKeyBase64: string
   clientEmail: string
 }
-export default class Calendar {
+export default class CalendarManager {
   repository: Repository
   gcalConfig: GCalConfig
   gcalBaseURL: string

functions/src/eventHandlers.ts

@@ -1,19 +1,28 @@
 import {Request, Response} from "express";
-import Calendar from './calendar';
-import {projectId, gcal as gcalConfig} from './config'
+import CalendarManager from './calendar';
 import Repository from "./repository";
-// import {CalendarEvent} from "./types";
 import * as cookie from 'cookie'
+import SessionManager, {Session} from "./session";
+import UserManager from "./user";
 
-const calendar = new Calendar({
-  repository: new Repository(projectId),
-  gcalConfig: gcalConfig
-})
+
+let sessionManager, calendarManager
+export type Dependencies = {
+  repository: Repository,
+  userManager: UserManager,
+  sessionManager: SessionManager
+  calendarManager: CalendarManager,
+}
+
+export const setDependencies = (dependencies: Dependencies) => {
+  sessionManager = dependencies.sessionManager
+  calendarManager = dependencies.calendarManager
+}
 
 export const getEvents = async (req: Request, res: Response) => {
   let result
   try {
-    result = await calendar.listEvents()
+    result = await calendarManager.listEvents()
   } catch (e) {
     console.log('Caught error while listing events', e)
     res.status(500)
@@ -25,10 +34,11 @@ export const getEvents = async (req: Request, res: Response) => {
 
 export const postEvent = async (req: Request, res: Response) => {
   // const eventData: CalendarEvent = req.body;
-  let sessionId
+  let sessionHash, session: Session
   try {
-    sessionId = cookie.parse(req.headers.cookie).__session
-    if(!sessionId) {
+    sessionHash = cookie.parse(req.headers.cookie).__session
+    session = await sessionManager.getSession(sessionHash)
+    if (!sessionHash) {
       throw new Error('Session cookie required')
     }
   } catch (e) {
@@ -36,9 +46,9 @@ export const postEvent = async (req: Request, res: Response) => {
     res.send('Authentication required to post an event')
     return
   }
-  console.log('sessionId', sessionId)
+  console.log('sessionId', session.userId)
   res.status(200)
-  res.send(`sessionId: ${sessionId}`)
+  res.send(`sessionId: ${sessionHash}`)
 }
 
 export const events = async (req: Request, res: Response) => {

functions/src/index.ts

@@ -2,15 +2,38 @@ import * as functions from 'firebase-functions';
 import {
   isUserAvailable as isUserAvailableHandler,
   signup as signupHandler,
-  signin as signinHandler
+  signin as signinHandler,
+  setDependencies as setUserHandlerDependencies
 } from './userHandlers'
 
 import {
   events as eventsHandler,
+  setDependencies as setEventsHandlerDependencies
 } from './eventHandlers';
+import {gcal as gcalConfig, projectId} from './config'
+import UserManager from "./user";
+import SessionManager from "./session";
+import Repository from "./repository";
+import Calendar from "./calendar";
+
 
 const IS_FIREBASE = true;
 
+const repository = new Repository(projectId)
+const userManager = new UserManager(repository)
+const sessionManager = new SessionManager(repository)
+const calendarManager = new Calendar({
+  repository,
+  gcalConfig: gcalConfig
+})
+
+setUserHandlerDependencies({
+  repository, userManager, sessionManager
+})
+setEventsHandlerDependencies({
+  repository, userManager, sessionManager, calendarManager
+})
+
 const httpHandler = (func) => {
   let result = func
   if (IS_FIREBASE) {

functions/src/repository.ts

@@ -109,6 +109,25 @@ export default class Repository {
     })
   }
 
+  async getSession(hash: string): Promise<Session> {
+    const query = this.datastore.createQuery('Session')
+      .filter('hash', hash)
+    return new Promise((resolve: (Session) => void, reject) => {
+      this.datastore.runQuery((query), (err, resultSet: Array<Session>) => {
+        if (err) {
+          reject(err)
+        } else if (!resultSet) {
+          resolve(null)
+        } else if (resultSet.length >1) {
+          const message = `Got more than one session with the same hash`
+          reject(message)
+        } else {
+          resolve(resultSet[0])
+        }
+      })
+    })
+  }
+
   async getUser(userKeys: UserKeys, datastore ?: Datastore | DatastoreTransaction): Promise<User> {
     const ds = (datastore || this.datastore)
     let query = ds.createQuery('User')

functions/src/session.ts

@@ -104,5 +104,9 @@ export default class SessionManager {
       return Promise.resolve(null)
     }
   }
+
+  getSession = async(sessionHash: string): Promise<Session> => {
+    return await this.repository.getSession(sessionHash)
+  }
 }
 

functions/src/types.d.ts

@@ -1,12 +1,12 @@
-export interface Session {
-  createdAt: Date
-  ttlMs: number
-  expired: boolean
-  authMethod: string
-  hash: string
-  userAgent: string
-  location: string
-}
+// export interface Session {
+//   createdAt: Date
+//   ttlMs: number
+//   expired: boolean
+//   authMethod: string
+//   hash: string
+//   userAgent: string
+//   location: string
+// }
 
 interface DBEntity {
   id?: string

functions/src/userHandlers.ts

@@ -3,12 +3,20 @@ import UserManager from './user'
 import {Request, Response} from 'express'
 import SessionManager from './session'
 import Repository from './repository'
-import {projectId} from './config'
 import {UserProperties} from "./types"
 
-const repository = new Repository(projectId)
-const userManager = new UserManager(repository)
-const sessionManager = new SessionManager(repository)
+let repository, userManager, sessionManager
+export type Dependencies = {
+  repository: Repository,
+  userManager: UserManager,
+  sessionManager: SessionManager
+}
+
+export const setDependencies = (dependencies) => {
+  repository = dependencies.repository
+  userManager = dependencies.userManager
+  sessionManager = dependencies.sessionManager
+}
 
 export const isUserAvailable = async (req: Request, res: Response) => {
   const params = parse(req.url, true).query