{backend, test}: change backend files and backend tests to typescript (…

…#204)

* refactor backend file structure, add typescript config file

* remove compiled files

* remove extra file

* fresh yarn lock

* fix test, readme

* update package.json script

* change js to ts in backend, begin fixes

* finish refactoring/cleaning up backend ts files

* fix tests

* upgrade tsconfig target to es6, moduleResolution to node

* fix docker run error

* empty commit

* debugging sequelize error

* remove babel, change common/lumen.js to use commonjs, other fixes

* fix convertFields method

* unneeded allowJS in tsconfig

* use correct types instead of any in lumens.d.ts

* add LedgerSql type

* use _:any for unused params

backend/app.ts

@@ -1,6 +1,7 @@
-require("babel-register")({
-  presets: ["es2015"],
-});
+// need to manually import regeneratorRuntime for babel w/ async
+// https://github.com/babel/babel/issues/9849#issuecomment-487040428
+// require("regenerator-runtime/runtime");
+import "regenerator-runtime/runtime";
 
 // Run backend with interval cache updates.
 const { updateLumensCache } = require("./routes");

backend/ledgers.js → backend/ledgers.ts

@@ -1,11 +1,24 @@
 import stellarSdk from "stellar-sdk";
-import moment from "moment";
-import _ from "lodash";
-import * as postgres from "./postgres.js";
+import { map, pick } from "lodash";
+import { QueryTypes } from "sequelize";
+import { Response } from "express";
+import * as postgres from "./postgres";
 
-let cachedData;
+interface Ledger {
+  date: string;
+  transaction_count: number;
+  operation_count: number;
+}
+
+interface LedgerSql {
+  date: string;
+  transaction_count: string;
+  operation_count: string;
+}
 
-export const handler = function(req, res) {
+let cachedData: Array<Ledger>;
+
+export const handler = function(_: any, res: Response) {
   res.send(cachedData);
 };
 
@@ -20,20 +33,19 @@ function updateResults() {
     order by 1 desc`;
 
   postgres.sequelize
-    .query(query, { type: postgres.sequelize.QueryTypes.SELECT })
-    .then((results) => (cachedData = _.each(results, convertFields)));
+    .query(query, { type: QueryTypes.SELECT })
+    .then((results: Array<LedgerSql>) => {
+      cachedData = map(results, convertFields);
+    });
 }
 
-function convertFields(ledger) {
-  // String to int fields
-  const fields = ["transaction_count", "operation_count"];
-  for (let field of fields) {
-    ledger[field] = parseInt(ledger[field]);
-  }
-
-  // Remove year from date
-  ledger["date"] = ledger["date"].substring(5);
-  return ledger;
+function convertFields(ledger: LedgerSql): Ledger {
+  return {
+    // Remove year from date
+    date: ledger["date"].substring(5),
+    transaction_count: parseInt(ledger.transaction_count),
+    operation_count: parseInt(ledger.operation_count),
+  };
 }
 
 // Wait for schema sync
@@ -44,7 +56,7 @@ postgres.sequelize.addHook("afterBulkSync", () => {
   if (process.env.UPDATE_DATA == "true") {
     // Stream ledgers - get last paging_token/
     postgres.LedgerStats.findOne({ order: [["sequence", "DESC"]] }).then(
-      (lastLedger) => {
+      (lastLedger: postgres.LedgerStats) => {
         let pagingToken;
         if (!lastLedger) {
           pagingToken = "now";
@@ -58,8 +70,9 @@ postgres.sequelize.addHook("afterBulkSync", () => {
           .cursor(pagingToken)
           .limit(200)
           .stream({
-            onmessage: (ledger) => {
-              let newLedger = _.pick(ledger, [
+            // TODO - use type any until https://github.com/stellar/js-stellar-sdk/issues/731 resolved
+            onmessage: (ledger: any) => {
+              let newLedger: any = pick(ledger, [
                 "sequence",
                 "closed_at",
                 "paging_token",

backend/lumens.js → backend/lumens.ts

@@ -1,9 +1,21 @@
 import * as commonLumens from "../common/lumens.js";
-import BigNumber from "bignumber.js";
+import { Response } from "express";
 
-export let cachedData;
+interface CachedData {
+  updatedAt: Date;
+  totalCoins: string;
+  availableCoins: string;
+  programs: {
+    directDevelopment: string;
+    ecosystemSupport: string;
+    useCaseInvestment: string;
+    userAcquisition: string;
+  };
+}
+
+export let cachedData: CachedData;
 
-export const v1Handler = function(req, res) {
+export const v1Handler = function(_: any, res: Response) {
   res.send(cachedData);
 };
 

backend/postgres.ts

@@ -0,0 +1,59 @@
+import { Sequelize, Model, DataTypes } from "sequelize";
+
+export const sequelize = new Sequelize(
+  process.env.DEV
+    ? "postgres://localhost/dashboard?sslmode=disable"
+    : process.env.POSTGRES_URL || "",
+  process.env.DEV
+    ? {}
+    : {
+        dialect: "postgres",
+        dialectOptions: {
+          ssl: {
+            require: true,
+            rejectUnauthorized: false,
+          },
+        },
+      },
+);
+
+export class LedgerStats extends Model {
+  public sequence!: number;
+  public closed_at!: Date;
+  public paging_token!: string;
+  public transaction_count!: number;
+  public operation_count!: number;
+}
+
+LedgerStats.init(
+  {
+    sequence: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true,
+    },
+    closed_at: {
+      type: DataTypes.DATE,
+      allowNull: false,
+    },
+    paging_token: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    transaction_count: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    operation_count: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+  },
+  {
+    tableName: "ledger_stats",
+    sequelize,
+  },
+);
+
+// Create schema if doesn't exist
+sequelize.sync({ hooks: true });

backend/routes.js → backend/routes.ts

@@ -2,9 +2,9 @@ import express from "express";
 import proxy from "express-http-proxy";
 import logger from "morgan";
 
-import * as lumens from "./lumens.js";
-import * as lumensV2V3 from "./v2v3/lumens.js";
-import * as ledgers from "./ledgers.js";
+import * as lumens from "./lumens";
+import * as lumensV2V3 from "./v2v3/lumens";
+import * as ledgers from "./ledgers";
 
 export var app = express();
 app.set("port", process.env.PORT || 5000);
@@ -16,7 +16,7 @@ if (process.env.DEV) {
   app.use(
     "/",
     proxy("localhost:3000", {
-      filter: function(req, res) {
+      filter: function(req, _) {
         return (
           req.path == "/" ||
           req.path.indexOf(".js") >= 0 ||

backend/v2v3/lumens.js → backend/v2v3/lumens.ts

@@ -1,42 +1,80 @@
 import * as commonLumens from "../../common/lumens.js";
 import BigNumber from "bignumber.js";
+import { Response } from "express";
 
 const LUMEN_SUPPLY_METRICS_URL =
   "https://www.stellar.org/developers/guides/lumen-supply-metrics.html";
 
 // v2:
-export let lumensDataV2;
+interface LumensDataV2 {
+  updatedAt: Date;
+  originalSupply: string;
+  inflationLumens: string;
+  burnedLumens: string;
+  totalSupply: string;
+  upgradeReserve: string;
+  feePool: string;
+  sdfMandate: string;
+  circulatingSupply: string;
+  _details: string;
+}
+
+export let lumensDataV2: LumensDataV2;
 
 /* For CoinMarketCap */
-let totalSupplyData;
-let circulatingSupplyData;
+let totalSupplyData: number;
+let circulatingSupplyData: number;
 
-export const v2Handler = function(req, res) {
+export const v2Handler = function(_: any, res: Response) {
   res.send(lumensDataV2);
 };
-export const v2TotalSupplyHandler = function(req, res) {
+export const v2TotalSupplyHandler = function(_: any, res: Response) {
   res.json(totalSupplyData);
 };
-export const v2CirculatingSupplyHandler = function(req, res) {
+export const v2CirculatingSupplyHandler = function(_: any, res: Response) {
   res.json(circulatingSupplyData);
 };
 
 // v3:
-export let lumensDataV3;
-export let totalSupplyCheckResponse;
+interface LumensDataV3 {
+  updatedAt: Date;
+  originalSupply: string;
+  inflationLumens: string;
+  burnedLumens: string;
+  totalSupply: BigNumber;
+  upgradeReserve: string;
+  feePool: string;
+  sdfMandate: string;
+  circulatingSupply: BigNumber;
+  _details: string;
+}
+export let lumensDataV3: LumensDataV3;
+
+interface TotalSupplyCheckResponse {
+  updatedAt: Date;
+  totalSupply: BigNumber;
+  inflationLumens: string;
+  burnedLumens: string;
+  totalSupplySum: BigNumber;
+  upgradeReserve: string;
+  feePool: string;
+  sdfMandate: string;
+  circulatingSupply: BigNumber;
+}
+export let totalSupplyCheckResponse: TotalSupplyCheckResponse;
 
-export const v3Handler = function(req, res) {
+export const v3Handler = function(_: any, res: Response) {
   res.send(lumensDataV3);
 };
-export const totalSupplyCheckHandler = function(req, res) {
+export const totalSupplyCheckHandler = function(_: any, res: Response) {
   res.json(totalSupplyCheckResponse);
 };
 
 /* For CoinMarketCap */
-export const v3TotalSupplyHandler = function(req, res) {
+export const v3TotalSupplyHandler = function(_: any, res: Response) {
   res.json(totalSupplyCheckResponse.totalSupplySum);
 };
-export const v3CirculatingSupplyHandler = function(req, res) {
+export const v3CirculatingSupplyHandler = function(_: any, res: Response) {
   res.json(totalSupplyCheckResponse.circulatingSupply);
 };
 
@@ -75,8 +113,8 @@ export function updateApiLumens() {
       };
 
       /* For CoinMarketCap */
-      totalSupplyData = totalSupply * 1;
-      circulatingSupplyData = circulatingSupply * 1;
+      totalSupplyData = Number(totalSupply);
+      circulatingSupplyData = Number(circulatingSupply);
 
       console.log("/api/v2/lumens data saved!");
 

common/lumens.d.ts

@@ -0,0 +1,15 @@
+export var ORIGINAL_SUPPLY_AMOUNT: string;
+export function getLumenBalance(horizonURL: string, accountId: string): string;
+export function totalLumens(horizonURL: string): string;
+export function inflationLumens(): Promise<BigNumber>;
+export function feePool(): string;
+export function burnedLumens(): string;
+export function directDevelopmentAll(): Promise<string>;
+export function distributionEcosystemSupport(): Promise<string>;
+export function distributionUseCaseInvestment(): Promise<string>;
+export function distributionUserAcquisition(): Promise<string>;
+export function getUpgradeReserve(): string;
+export function sdfAccounts(): Promise<BigNumber>;
+export function totalSupply(): Promise<BigNumber>;
+export function noncirculatingSupply(): Promise<BigNumber>;
+export function circulatingSupply(): Promise<BigNumber>;