Rewrite js files to ts and and useful types

.gitignore

@@ -155,4 +155,7 @@ crashlytics-build.properties
 !/stack/node/yarn.lock
 
 # Google
-/secrets
+/secrets
+
+# TypeScript
+dist

.mocharc.yml

@@ -0,0 +1,7 @@
+require:
+  - ts-node/register 
+  - source-map-support/register
+recursive: true
+exit: true
+slow: 500
+timeout: 5000

.nycrc

@@ -1,15 +1,26 @@
 {
+  "extension": [
+    ".ts",
+    ".tsx"
+  ],
   "exclude": [
-    "**/*.apidoc.js",
+    "typings",
     "coverage",
-    "apidoc",
-    "test",
-    "**/*test.js",
-    "index.js"
+    "doc",
+    "dist",
+    "interfaces",
+    "types",
+    "index.ts",
+    "**/*test.ts",
+    ".eslintrc.js"
   ],
   "reporter": [
+    "lcov",
     "text",
     "html"
   ],
-    "all": true
+  "require": [
+    "ts-node/register"
+  ],
+  "all": true
 }

app.js → app.ts

@@ -2,41 +2,50 @@ const express = require('express');
 const bodyParser = require('body-parser');
 const cors = require('cors');
 const helmet = require('helmet');
-const bunyan = require('bunyan');
+import * as bunyan from 'bunyan';
+import { CacheController } from './controller/cache.controller';
+import { TempController } from './controller/temp.controller';
 
 // Controller
-const Cache = require('./controller/cache.controller');
 const Calendar = require('./controller/calendar.controller');
 const Database = require('./controller/database.controller');
 const Heat = require('./controller/heat.controller');
 const Relay = require('./controller/relay.controller');
 const Schedule = require('./controller/schedule.controller');
 const Slave = require('./controller/slave.controller');
-const Temp = require('./controller/temp.controller');
 
 // Routes
 const StatusRoute = require('./routes/v1/status.route');
 
-const EXPRESS_PORT = parseInt(process.env.EXPRESS_PORT, 10) || 3000;
-const IS_MASTER = process.env.TEMPEA_SLAVE !== 'true';
-const SLAVE_ENABLED = process.env.SLAVE_ENABLED === 'true';
+const EXPRESS_PORT: Number = parseInt(process.env.EXPRESS_PORT, 10) || 3000;
+const IS_MASTER: Boolean = process.env.TEMPEA_SLAVE !== 'true';
+const SLAVE_ENABLED: Boolean = process.env.SLAVE_ENABLED === 'true';
 
 module.exports = (loglevel) => {
-  const log = bunyan.createLogger({
+  const log: bunyan = bunyan.createLogger({
     name: 'tempea',
     level: loglevel,
     serializers: bunyan.stdSerializers,
-  });
+  } as bunyan.LoggerOptions);
 
-  let heating = false;
+  let heating: Boolean = false;
   let server;
   let app;
-  const controller = {};
+  const controller = {
+    cache: null,
+    temp: null,
+    calendar: null,
+    database: null,
+    heat: null,
+    relay: null,
+    schedule: null,
+    slave: null,
+  };
 
   const initControllers = async () => {
     log.trace('Initializing general controller');
-    controller.cache = Cache(log.child({ controller: 'cache' }));
-    controller.temp = Temp(log.child({ controller: 'temp' }), controller.cache);
+    controller.cache = new CacheController(log.child({ controller: 'cache' }));
+    controller.temp = new TempController(log.child({ controller: 'temp' }), controller.cache);
     if (IS_MASTER) {
       log.trace('Initializing master controller');
       controller.calendar = Calendar(log.child({ controller: 'calendar' }), controller.cache);

controller/cache.controller.ts

@@ -0,0 +1,127 @@
+import * as bunyan from 'bunyan';
+
+interface Cache {
+  master: {
+    updated?: Number
+    relay?: Number
+    current?: Number
+  },
+  // TODO Use data classes
+  desired: any
+  slave: any,
+  mqtt: any
+}
+
+export class CacheController {
+  private log: bunyan;
+
+  private cache: Cache = {
+    master: {},
+    desired: undefined,
+    slave: undefined,
+    mqtt: undefined
+  }
+
+  constructor(log: bunyan) {
+    this.log = log;
+    this.log.info('Creating cache controller');
+  }
+
+  public async invalidate(): Promise<void> {
+    this.cache = {
+      master: {},
+      desired: undefined,
+      slave: undefined,
+      mqtt: undefined
+    };
+  };
+
+  public async updateRelayState(state: Number): Promise<Boolean> {
+    this.log.trace({ state }, 'Updating relay state');
+    this.cache.master.updated = Date.now();
+    this.cache.master.relay = state;
+    return true;
+  };
+
+  public async getRelayState(): Promise<Number> {
+    this.log.trace('Getting relay state');
+    if (this.cache.master.relay !== undefined) {
+      return this.cache.master.relay;
+    }
+
+    throw Error('No cached value available');
+  };
+
+  public async updateDesiredObject(desired): Promise<Boolean> {
+    const desiredTagged = Object.assign(desired, { updated: Date.now() });
+    this.log.trace({ desiredTagged }, 'Updating desired temperature');
+    this.cache.desired = desiredTagged;
+    return true;
+  };
+
+  public async getDesiredObject(): Promise<any> {
+    this.log.trace('Getting desired temperature');
+    if (this.cache.desired) {
+      return this.cache.desired;
+    }
+
+    throw Error('No cached value available');
+  };
+
+  public async updateCurrentTemperature(current): Promise<Boolean> {
+    this.log.trace({ current }, 'Updating current temperature');
+    this.cache.master.updated = Date.now();
+    this.cache.master.current = current;
+    return true;
+  };
+
+  public async getCurrentTemperature(): Promise<Number> {
+    this.log.trace('Getting current temperature');
+    if (this.cache.master.current) {
+      return this.cache.master.current;
+    }
+
+    throw Error('No cached value available');
+  };
+
+  public async updateSlaveData(data: any): Promise<Boolean> {
+    this.log.trace({ data }, 'Updating slave data');
+    const slaveTagged = Object.assign(data, { updated: Date.now() });
+    this.cache.slave = slaveTagged;
+    return true;
+  };
+
+  public async getSlaveData(): Promise<any> {
+    this.log.trace('Getting slave data');
+    if (this.cache.slave) {
+      return this.cache.slave;
+    }
+
+    throw Error('No cached value available');
+  };
+
+  public async updateMqttData(data: any): Promise<Boolean> {
+    // Do not override updated, already present from influx
+    this.log.trace({ data }, 'Updating mqtt data');
+    this.cache.mqtt = data;
+    return true;
+  };
+
+  public async getMqttData(): Promise<any> {
+    this.log.trace('Getting mqtt data');
+    if (this.cache.mqtt) {
+      return this.cache.mqtt;
+    }
+
+    throw Error('No cached value available');
+  };
+
+  public async getMasterUpdated(): Promise<Number> {
+    this.log.trace('Getting master updated data');
+    if (this.cache.master.updated) {
+      return this.cache.master.updated;
+    }
+
+    throw Error('No cached value available');
+  };
+}

controller/index.ts

@@ -0,0 +1,3 @@
+export { CacheController } from './cache.controller';
+export { TempController } from './temp.controller';
+export { SlaveController } from './slave.controller';