Ngrok in docker, type checking

docker-compose.yml

@@ -1,6 +1,14 @@
 version: "3.8"
 
 services:
+  ngrok:
+    image: wernight/ngrok:latest
+    ports:
+      - 4040:4040
+    environment:
+      NGROK_PROTOCOL: http
+      NGROK_PORT: server:3000
+      NGROK_AUTH: ${NGROK_AUTH}
 
   # access through `psql -h localhost -p 5432 -d filesync -U user`, password is 'pass'
   # to be able to build after the initializing the db, you may need to run `sudo chown -R $USER db_data/`
@@ -19,6 +27,7 @@ services:
       dockerfile: Dockerfile
     depends_on:
       - database
+      - ngrok
     env_file: ./.env
     volumes: 
       - ./src/build:/ffs/

environment.d.ts

@@ -7,6 +7,10 @@ declare global {
         PORT_SERVER: number;
         PORT_DB: number;
         WEBHOOK_TOKEN: string;
+        POSTGRES_USER: string;
+        POSTGRES_DB: string;
+        POSTGRES_PASSWORD: string;
+        HOOK_CALLBACK_HOSTNAME: string;
       }
     }
   }

package.json

@@ -8,7 +8,7 @@
     "start:ngrok": "ngrok http 3000",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "npm run open:page && npm run build:docker",
-    "build:docker": "node src/ngrok_script.js && tsc --build && docker-compose up --build --remove-orphans",
+    "build:docker": "tsc --build && docker-compose up --build --remove-orphans",
     "open:page": "opener http://localhost:3000/auth"
   },
   "repository": {

src/config.ts

@@ -2,54 +2,60 @@
  * Configures constants used in the other parts of this app
  */
 
-import { AuthClientThreeLegged } from 'forge-apis';
-import * as dotenv from 'dotenv';
-dotenv.config({path: '../.env'});
+import * as ForgeSDK from "forge-apis";
+import * as dotenv from "dotenv";
+dotenv.config({ path: "../.env" });
 
-export const ForgeAuthClient = AuthClientThreeLegged;
-
-export const scopes: any = ['bucket:create', 'bucket:read', 'data:read', 'data:create', 'data:write'];
+// export const ForgeAuthClient = ForgeSDK.AuthClientThreeLegged;
 
+export const scopes: ForgeSDK.Scope[] = [
+    "bucket:create",
+    "bucket:read",
+    "data:read",
+    "data:create",
+    "data:write",
+];
 
 // TODO: add production environment variables
 
-export const authClient = new ForgeAuthClient(
-  process.env.FORGE_CLIENT_ID,
-  process.env.FORGE_CLIENT_SECRET,
-  process.env.FORGE_CALLBACK_URL,
-  scopes,
-  true
+export const authClient = new ForgeSDK.AuthClientThreeLegged(
+    process.env.FORGE_CLIENT_ID,
+    process.env.FORGE_CLIENT_SECRET,
+    process.env.FORGE_CALLBACK_URL,
+    scopes,
+    true
 );
 
-export const projectID = "a.YnVzaW5lc3M6cHVyZHVlMjY5NiMyMDIxMTExNTQ2Njg0NTI1MQ";
+export const projectID: string =
+    "a.YnVzaW5lc3M6cHVyZHVlMjY5NiMyMDIxMTExNTQ2Njg0NTI1MQ";
 
 // The local fields are only for internal/container use, host paths are specified in the environment
 export const folderMap: any = {
-  gantry: {
-    fusionID: "urn:adsk.wipprod:fs.folder:co.IxiedfeBTOGg6NSIGQhXxQ",
-    local: "/Gantry"
-  },
-  lathe: {
-    fusionID: "urn:adsk.wipprod:fs.folder:co.FDWCeyBGQX2rv8xSNWo5lg",
-    local: "/Lathe"
-  },
-  mill: {
-    fusionID: "urn:adsk.wipprod:fs.folder:co.nEihcpHUSW-ZsVzU-__1iw",
-    local: "/Mill"
-  },
-  waterjet: {
-    fusionID: "urn:adsk.wipprod:fs.folder:co.vJLXAKGbQQayeljr-nwztQ",
-    local: "/Waterjet"
-  }
+    gantry: {
+        fusionID: "urn:adsk.wipprod:fs.folder:co.IxiedfeBTOGg6NSIGQhXxQ",
+        local: "/Gantry",
+    },
+    lathe: {
+        fusionID: "urn:adsk.wipprod:fs.folder:co.FDWCeyBGQX2rv8xSNWo5lg",
+        local: "/Lathe",
+    },
+    mill: {
+        fusionID: "urn:adsk.wipprod:fs.folder:co.nEihcpHUSW-ZsVzU-__1iw",
+        local: "/Mill",
+    },
+    waterjet: {
+        fusionID: "urn:adsk.wipprod:fs.folder:co.vJLXAKGbQQayeljr-nwztQ",
+        local: "/Waterjet",
+    },
 };
 
 // dictionary for looking up local directory path based on folder ID
 export const folderIDtoLocal: any = {
-  "urn:adsk.wipprod:fs.folder:co.IxiedfeBTOGg6NSIGQhXxQ" : "/Gantry",
-  "urn:adsk.wipprod:fs.folder:co.FDWCeyBGQX2rv8xSNWo5lg": "/Lathe",
-  "urn:adsk.wipprod:fs.folder:co.nEihcpHUSW-ZsVzU-__1iw": "/Mill",
-  "urn:adsk.wipprod:fs.folder:co.vJLXAKGbQQayeljr-nwztQ": "/Waterjet"
-}
+    "urn:adsk.wipprod:fs.folder:co.IxiedfeBTOGg6NSIGQhXxQ": "/Gantry",
+    "urn:adsk.wipprod:fs.folder:co.FDWCeyBGQX2rv8xSNWo5lg": "/Lathe",
+    "urn:adsk.wipprod:fs.folder:co.nEihcpHUSW-ZsVzU-__1iw": "/Mill",
+    "urn:adsk.wipprod:fs.folder:co.vJLXAKGbQQayeljr-nwztQ": "/Waterjet",
+};
 
 export const port = process.env.PORT_SERVER;
 export const forgeClientId = process.env.FORGE_CLIENT_ID;
@@ -60,4 +66,4 @@ export const webhookToken = process.env.WEBHOOK_TOKEN;
 export const postgresUser = process.env.POSTGRES_USER;
 export const postgresPassword = process.env.POSTGRES_PASSWORD;
 export const postgresPort = process.env.PORT_DB;
-export const postgresDB = process.env.POSTGRES_DB;
+export const postgresDB = process.env.POSTGRES_DB;

src/db.ts

@@ -1,108 +1,119 @@
-import { Client, Query } from 'ts-postgres';
-import { createPool } from 'generic-pool';
-import * as config from './config';
+import { Client, Query, DatabaseError } from "ts-postgres";
+import { createPool } from "generic-pool";
+import * as config from "./config";
 
-const pool = createPool({
-  create: async () => {
-    return new Promise<Client>((resolve, reject) => {
-
-      const client = new Client({
-        'host': 'database', // name of docker container, not 'localhost'
-        'port': config.postgresPort,
-        'user': config.postgresUser,
-        'password': config.postgresPassword,
-        'database': config.postgresDB
-      });
-
-      client.connect()
-      .then(() => {
-        console.log("successfully connected to db")
-        resolve(client);
-      }).catch((err: any) => {
-        console.log()
-        console.log(err)
-        reject(err);
-      });
-    });
-  },
-  destroy: async (client: Client) => {
-    return client.end()
-  },
-  validate: (client: Client) => {
-    return Promise.resolve(!client.closed);
-  }
-}, {
-  testOnBorrow: true,
-  max: 10
-})
+const pool = createPool(
+    {
+        create: async () => {
+            return new Promise<Client>((resolve, reject) => {
+                const client = new Client({
+                    host: "database", // name of docker container, not 'localhost'
+                    port: config.postgresPort,
+                    user: config.postgresUser,
+                    password: config.postgresPassword,
+                    database: config.postgresDB,
+                });
+
+                client
+                    .connect()
+                    .then(() => {
+                        console.log("successfully connected to db");
+                        resolve(client);
+                    })
+                    .catch((err: DatabaseError) => {
+                        console.log(err);
+                        reject(err);
+                    });
+            });
+        },
+        destroy: async (client: Client) => {
+            return client.end();
+        },
+        validate: (client: Client) => {
+            return Promise.resolve(!client.closed);
+        },
+    },
+    {
+        testOnBorrow: true,
+        max: 10,
+    }
+);
 
 const executeQuery = (query: Query) => {
-  console.log('executing query');
-
-  const res = pool.acquire();
+    console.log("executing query");
 
-  return res.then(async (client: Client) => {
-    console.log('aquired client from pool')
-    const result = await client.execute(query);
-    pool.release(client).then(() => {
-      console.log("client released back into pool")
-    });
-    return result;
-  }).catch((err: any) => {
-    console.log(err);
-  })
-}
+    const res = pool.acquire();
+
+    return res
+        .then(async (client: Client) => {
+            console.log("aquired client from pool");
+            const result = await client.execute(query);
+            pool.release(client).then(() => {
+                console.log("client released back into pool");
+            });
+            return result;
+        })
+        .catch((err: DatabaseError) => {
+            console.log(err);
+        });
+};
 
 export const shutdown = () => {
-  pool.drain()
-  .then(() => {
-    return pool.clear();
-  });
-}
+    pool.drain().then(() => {
+        return pool.clear();
+    });
+};
 
 export const insert = (table: string, params: any) => {
+    let fileName = params.fileName;
+    let folderName = params.folderName;
+    let fusionID = null;
+    let username = null;
+    let size = null;
+    let version = null;
 
-  let fileName = params.fileName;
-  let folderName = params.folderName;
-  let fusionID = null;
-  let username = null;
-  let size = null;
-  let version = null;
+    if (params.hasOwnProperty("fusionID")) {
+        fusionID = params.fusionID;
+    }
+    if (params.hasOwnProperty("username")) {
+        username = params.username;
+    }
+    if (params.hasOwnProperty("size")) {
+        size = params.size;
+    }
+    if (params.hasOwnProperty("version")) {
+        version = params.version;
+    }
 
-  if (params.hasOwnProperty('fusionID')) {fusionID = params.fusionID}
-  if (params.hasOwnProperty('username')) {username = params.username}
-  if (params.hasOwnProperty('size')) {size = params.size}
-  if (params.hasOwnProperty('version')) {version = params.version}
-
-  let query: Query;
+    let query: Query;
 
-  console.log("params: ", params);
+    console.log("params: ", params);
 
-  switch(table) {
-    case 'fusion':
-      query = new Query (
-        "INSERT INTO fusion (fusion_id, folder_name, file_name, username, size, version)" +
-        "VALUES ($1, $2, $3, $4, $5, $6)",
-        [fusionID, folderName, fileName, username, size, version]
-      );
-      break;
-    case 'local':
-      query = new Query (
-        "INSERT INTO local (file_name, folder_name, fusion_id)" +
-        "VALUES ($1, $2, $3)",
-        [fileName, folderName, fusionID]
-      );
-      break;
-    case 'archive':
-      query = new Query (
-        "INSERT INTO archive (fusion_id, folder_name, file_name, username, size, version)" +
-        "VALUES ($1, $2, $3, $4, $5, $6)",
-        [fusionID, folderName, fileName, username, size, version]
-      );
-      break;
-    default:
-      throw new Error("Invalid table/params");
-  }
+    switch (table) {
+        case "fusion":
+            query = new Query(
+                "INSERT INTO fusion (fusion_id, folder_name, file_name, username, size, version)" +
+                    "VALUES ($1, $2, $3, $4, $5, $6)",
+                [fusionID, folderName, fileName, username, size, version]
+            );
+            break;
+        case "local":
+            query = new Query(
+                "INSERT INTO local (file_name, folder_name, fusion_id)" +
+                    "VALUES ($1, $2, $3)",
+                [fileName, folderName, fusionID]
+            );
+            break;
+        case "archive":
+            query = new Query(
+                "INSERT INTO archive (fusion_id, folder_name, file_name, username, size, version)" +
+                    "VALUES ($1, $2, $3, $4, $5, $6)",
+                [fusionID, folderName, fileName, username, size, version]
+            );
+            break;
+        default:
+            throw new Error("Invalid table/params");
+    }
 
-  return executeQuery(query);
-}
+    return executeQuery(query);
+};