package.json

@@ -14,6 +14,7 @@
     "@types/bun": "latest"
   },
   "dependencies": {
+    "env-var": "^7.5.0",
     "gotify": "^1.1.0",
     "ts3-nodejs-library": "^3.4.1",
     "winston": "^3.8.2"

src/app.ts

@@ -1,105 +1,136 @@
 import { Gotify } from "gotify";
-import { QueryProtocol, TeamSpeak, TextMessageTargetMode } from "ts3-nodejs-library"
+import {
+  QueryProtocol,
+  TeamSpeak,
+  TextMessageTargetMode,
+} from "ts3-nodejs-library";
 import { createLogger, transports, format } from "winston";
 
+import {
+  GOTIFY_TITLE,
+  GOTIFY_TOKEN,
+  GOTIFY_URL,
+  LOG_LEVEL,
+  MODE,
+  TS3_HOST,
+  TS3_NICKNAME,
+  TS3_PASSWORD,
+  TS3_QUERY_PORT,
+  TS3_SERVER_PORT,
+  TS3_USERNAME,
+} from "./env";
+import type { Mode } from "./types";
+
 const logger = createLogger({
-    level: process.env.LOG_LEVEL,
+  level: LOG_LEVEL,
   transports: [new transports.Console()],
-    format: format.combine(
+  format: format.combine(format.colorize(), format.timestamp()),
-        format.colorize(),
+});
-        format.timestamp(),
-    ),
-})
 
 const gotify = new Gotify({
-    server: process.env.GOTIFY_URL,
+  server: GOTIFY_URL,
-})
+});
 
 const gotifyConfig = {
-    app: process.env.GOTIFY_TOKEN,
+  app: GOTIFY_TOKEN,
-    title: process.env.GOTIFY_TITLE || "ts3gotify"
+  title: GOTIFY_TITLE,
-}
+};
 
-function getModes() {
+function getModes(): {
-    const modeIsProvided = process.env.MODE != undefined
+  [key in Mode]: boolean;
+} {
+  const modes = MODE.map((mode) => {
+    return { [mode]: true };
+  });
 
-    return {
+  return Object.assign(
-        connect: modeIsProvided ? process.env.MODE?.includes("connect") || false : true,
+    {
-        disconnect: process.env.MODE?.includes("disconnect") || false,
+      connect: false,
-        moved: process.env.MODE?.includes("moved") || false,
+      disconnect: false,
-        message: process.env.MODE?.includes("message") || false
+      moved: false,
-    }
+      message: false,
+    },
+    ...modes
+  );
 }
 
 function sendNotification(message: string) {
-    gotify.send({
+  gotify
+    .send({
       ...gotifyConfig,
       message: message,
-    }).catch((error: Error) => {
-        logger.error(`Error sending message to gotify: ${error.message}`)
     })
+    .catch((error: Error) => {
+      logger.error(`Error sending message to gotify: ${error.message}`);
+    });
 }
 
 function resolveMessageTarget(target: TextMessageTargetMode): string {
   if (target === 1) {
-        return "Client"
+    return "Client";
   } else if (target === 2) {
-        return "Channel"
+    return "Channel";
   } else {
-        return "Server"
+    return "Server";
   }
 }
 
 function handleMessage(message: string) {
-    logger.debug(message)
+  logger.debug(message);
-    sendNotification(message)
+  sendNotification(message);
 }
 
 TeamSpeak.connect({
-    host: process.env.TS3_HOST || "info",
+  host: TS3_HOST,
-    queryport: process.env.TS3_QUERY_PORT || 10011,
+  queryport: TS3_QUERY_PORT,
-    serverport: process.env.TS3_SERVER_PORT || 9987,
+  serverport: TS3_SERVER_PORT,
   protocol: QueryProtocol.RAW,
-    username: process.env.TS3_USERNAME,
+  username: TS3_USERNAME,
-    password: process.env.TS3_PASSWORD,
+  password: TS3_PASSWORD,
-    nickname: process.env.TS3_NICKNAME || "ts3gotify",
+  nickname: TS3_NICKNAME,
 }).then((teamspeak) => {
-    const mode = getModes()
+  const mode = getModes();
 
-    logger.info("connected to TS3")
+  logger.info("connected to TS3");
 
   if (mode.connect) {
     teamspeak.on("clientconnect", (event) => {
-            handleMessage(`${event.client.nickname} connected`)
+      handleMessage(`${event.client.nickname} connected`);
-        })
+    });
   }
 
   if (mode.disconnect) {
     teamspeak.on("clientdisconnect", (event) => {
-            handleMessage(`${event.client?.nickname} disconnected`)
+      handleMessage(`${event.client?.nickname} disconnected`);
-        })
+    });
   }
 
   if (mode.message) {
     teamspeak.on("textmessage", (event) => {
-            handleMessage(`${event.invoker.nickname} wrote ${event.msg} to a ${resolveMessageTarget(event.targetmode)}`)
+      handleMessage(
-        })
+        `${event.invoker.nickname} wrote ${
+          event.msg
+        } to a ${resolveMessageTarget(event.targetmode)}`
+      );
+    });
   }
 
   if (mode.moved) {
     teamspeak.on("clientmoved", (event) => {
-            handleMessage(`${event.client.nickname} got moved to ${event.channel.name}`)
+      handleMessage(
-        })
+        `${event.client.nickname} got moved to ${event.channel.name}`
+      );
+    });
   }
 
   teamspeak.on("close", async () => {
-        logger.debug("disconnected, trying to reconnect...")
+    logger.debug("disconnected, trying to reconnect...");
-        await teamspeak.reconnect(5, 1000)
+    await teamspeak.reconnect(5, 1000);
-        logger.info("reconnected!")
+    logger.info("reconnected!");
-    })
+  });
 
   teamspeak.on("error", (error: Error) => {
-        logger.error(`Error connecting to TS3 server: ${error.message}`)
+    logger.error(`Error connecting to TS3 server: ${error.message}`);
-        process.exit(1)
+    process.exit(1);
-    })
+  });
-})
+});

src/env.ts

@@ -0,0 +1,53 @@
+import { from } from "env-var";
+
+import type { LogLevel, Mode } from "./types";
+
+const envVar = from(process.env, {
+  asLogLevel: (value): LogLevel => {
+    const logLevels = ["error", "info", "debug"];
+    if (logLevels.includes(value)) {
+      return value as LogLevel;
+    } else {
+      throw new Error("Invalid log level");
+    }
+  },
+  asTs3GotifyMode: (value): Mode => {
+    const modes = ["connect", "disconnect", "moved", "message"];
+    if (modes.includes(value)) {
+      return value as Mode;
+    } else {
+      throw new Error("Invalid mode");
+    }
+  },
+});
+
+export const LOG_LEVEL = envVar.get("LOG_LEVEL").default("info").asLogLevel();
+
+export const TS3_HOST = envVar.get("TS3_HOST").required().asString();
+export const TS3_QUERY_PORT = envVar
+  .get("TS3_QUERY_PORT")
+  .default(10011)
+  .asPortNumber();
+export const TS3_SERVER_PORT = envVar
+  .get("TS3_SERVER_PORT")
+  .default(9987)
+  .asPortNumber();
+export const TS3_USERNAME = envVar.get("TS3_USERNAME").required().asString();
+export const TS3_PASSWORD = envVar.get("TS3_PASSWORD").required().asString();
+export const TS3_NICKNAME = envVar
+  .get("TS3_NICKNAME")
+  .default("ts3gotify")
+  .asString();
+
+export const GOTIFY_URL = envVar.get("GOTIFY_URL").required().asUrlString();
+export const GOTIFY_TOKEN = envVar.get("GOTIFY_TOKEN").required().asString();
+export const GOTIFY_TITLE = envVar
+  .get("GOTIFY_TITLE")
+  .default("ts3gotify")
+  .asString();
+
+export const MODE = envVar
+  .get("MODE")
+  .default("['connect']")
+  .asJsonArray()
+  .map((value) => value.asTs3GotifyMode());

src/environment.d.ts

@@ -1,19 +0,0 @@
-export { };
-
-declare global {
-    namespace NodeJS {
-        interface ProcessEnv {
-            LOG_LEVEL?: "error" | "info" | "debug"
-            TS3_HOST: string;
-            TS3_QUERY_PORT?: number;
-            TS3_SERVER_PORT?: number;
-            TS3_USERNAME: string;
-            TS3_PASSWORD: string;
-            TS3_NICKNAME?: string;
-            GOTIFY_URL: string;
-            GOTIFY_TOKEN: string;
-            GOTIFY_TITLE?: string;
-            MODE?: Array<"connect" | "disconnect" | "moved" | "message">
-        }
-    }
-}

src/types.ts

@@ -0,0 +1,3 @@
+export type Mode = "connect" | "disconnect" | "moved" | "message";
+
+export type LogLevel = "error" | "info" | "debug";