ESLint: Auto reformat and fixing some warnings / errors.

server/types/config.ts

@@ -1,11 +1,20 @@
-import {ArrayField, Field, RawJsonField} from "sparkson"
-import {ClientConfig, DurationMilliseconds, isString, toIsNewtype, Url} from "../shared/types";
+import { ArrayField, Field, RawJsonField } from "sparkson";
+import {
+    ClientConfig,
+    DurationMilliseconds,
+    isString,
+    toIsNewtype,
+    Url,
+} from "../shared/types";
 
 export type Username = string & { readonly __tag: unique symbol };
 export const isUsername = toIsNewtype(isString, "" as Username);
 
 export type CleartextPassword = string & { readonly __tag: unique symbol };
-export const isCleartextPassword = toIsNewtype(isString, "" as CleartextPassword);
+export const isCleartextPassword = toIsNewtype(
+    isString,
+    "" as CleartextPassword
+);
 
 export type PasswordHash = string & { readonly __tag: unique symbol };
 export const isPasswordHash = toIsNewtype(isString, "" as PasswordHash);
@@ -13,34 +22,30 @@ export const isPasswordHash = toIsNewtype(isString, "" as PasswordHash);
 export class UsersConfig {
     constructor(
         @Field("user") public username: Username,
-        @Field("passwordHash") public passwordHash: PasswordHash,
-    ) {
-    }
+        @Field("passwordHash") public passwordHash: PasswordHash
+    ) {}
 }
 
 export class LoggingConfig {
     constructor(
         @Field("enabled") public enabled: boolean,
         @Field("debug") public debug: boolean,
-        @Field("profile") public profile: boolean,
-    ) {
-    }
+        @Field("profile") public profile: boolean
+    ) {}
 }
 
 export class InternalConfig {
     constructor(
         @Field("active") public active: boolean,
-        @ArrayField("users", UsersConfig) public users: UsersConfig[],
-    ) {
-    }
+        @ArrayField("users", UsersConfig) public users: UsersConfig[]
+    ) {}
 }
 
 export class SMTPAuthConfig {
     constructor(
         @Field("user") public user: Username,
-        @Field("pass") public pass: CleartextPassword,
-    ) {
-    }
+        @Field("pass") public pass: CleartextPassword
+    ) {}
 }
 
 // For details see: https://nodemailer.com/smtp/
@@ -55,26 +60,24 @@ export class SMTPConfig {
         @Field("opportunisticTLS") public opportunisticTLS?: boolean,
         @Field("name") public name?: string,
         @Field("localAddress") public localAddress?: string,
-        @Field("connectionTimeout") public connectionTimeout?: DurationMilliseconds,
+        @Field("connectionTimeout")
+        public connectionTimeout?: DurationMilliseconds,
         @Field("greetingTimeout") public greetingTimeout?: DurationMilliseconds,
-        @Field("socketTimeout") public socketTimeout?: DurationMilliseconds,
-    ) {
-    }
+        @Field("socketTimeout") public socketTimeout?: DurationMilliseconds
+    ) {}
 }
 
 export class EmailConfig {
     constructor(
         @Field("from") public from: string,
-        @RawJsonField("smtp") public smtp: SMTPConfig,
-    ) {
-    }
+        @RawJsonField("smtp") public smtp: SMTPConfig
+    ) {}
 }
 
 export class ServerMapConfig {
     constructor(
-        @ArrayField("nodesJsonUrl", String) public nodesJsonUrl: Url[],
-    ) {
-    }
+        @ArrayField("nodesJsonUrl", String) public nodesJsonUrl: Url[]
+    ) {}
 }
 
 export class ServerConfig {
@@ -87,15 +90,13 @@ export class ServerConfig {
         @Field("internal") public internal: InternalConfig,
         @Field("email") public email: EmailConfig,
         @Field("map") public map: ServerMapConfig,
-        @Field("rootPath", true, undefined, "/") public rootPath: string,
-    ) {
-    }
+        @Field("rootPath", true, undefined, "/") public rootPath: string
+    ) {}
 }
 
 export class Config {
     constructor(
         @Field("server") public server: ServerConfig,
-        @Field("client") public client: ClientConfig,
-    ) {
-    }
+        @Field("client") public client: ClientConfig
+    ) {}
 }

server/types/database.ts

@@ -1,51 +1,70 @@
-import {ISqlite, Statement} from "sqlite";
+import { ISqlite, Statement } from "sqlite";
 
 export type RunResult = ISqlite.RunResult;
 export type SqlType = ISqlite.SqlType;
 
-export {Statement};
+export { Statement };
 
 export interface TypedDatabase {
     /**
      * @see Database.on
      */
-    on(event: string, listener: any): Promise<void>;
+    on(event: string, listener: unknown): Promise<void>;
 
     /**
      * @see Database.run
      */
-    run(sql: SqlType, ...params: any[]): Promise<RunResult>;
+    run(sql: SqlType, ...params: unknown[]): Promise<RunResult>;
 
     /**
      * @see Database.get
      */
-    get<T>(sql: SqlType, ...params: any[]): Promise<T | undefined>;
+    get<T>(sql: SqlType, ...params: unknown[]): Promise<T | undefined>;
 
     /**
      * @see Database.each
      */
-    each<T>(sql: SqlType, callback: (err: any, row: T) => void): Promise<number>;
+    each<T>(
+        sql: SqlType,
+        callback: (err: unknown, row: T) => void
+    ): Promise<number>;
 
-    each<T>(sql: SqlType, param1: any, callback: (err: any, row: T) => void): Promise<number>;
+    each<T>(
+        sql: SqlType,
+        param1: unknown,
+        callback: (err: unknown, row: T) => void
+    ): Promise<number>;
 
-    each<T>(sql: SqlType, param1: any, param2: any, callback: (err: any, row: T) => void): Promise<number>;
+    each<T>(
+        sql: SqlType,
+        param1: unknown,
+        param2: unknown,
+        callback: (err: unknown, row: T) => void
+    ): Promise<number>;
 
-    each<T>(sql: SqlType, param1: any, param2: any, param3: any, callback: (err: any, row: T) => void): Promise<number>;
+    each<T>(
+        sql: SqlType,
+        param1: unknown,
+        param2: unknown,
+        param3: unknown,
+        callback: (err: unknown, row: T) => void
+    ): Promise<number>;
 
-    each<T>(sql: SqlType, ...params: any[]): Promise<number>;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    each<T>(sql: SqlType, ...params: unknown[]): Promise<number>;
 
     /**
      * @see Database.all
      */
-    all<T = never>(sql: SqlType, ...params: any[]): Promise<T[]>;
+    all<T = never>(sql: SqlType, ...params: unknown[]): Promise<T[]>;
 
     /**
      * @see Database.exec
      */
-    exec(sql: SqlType, ...params: any[]): Promise<void>;
+    exec(sql: SqlType, ...params: unknown[]): Promise<void>;
 
     /**
      * @see Database.prepare
      */
-    prepare(sql: SqlType, ...params: any[]): Promise<Statement>;
+    prepare(sql: SqlType, ...params: unknown[]): Promise<Statement>;
 }

server/types/index.ts

@@ -23,10 +23,10 @@ export * from "./logger";
 export * from "../shared/types";
 
 export type NodeStateData = {
-    site?: Site,
-    domain?: Domain,
-    state: OnlineState,
-}
+    site?: Site;
+    domain?: Domain;
+    state: OnlineState;
+};
 
 export function toCreateOrUpdateNode(node: StoredNode): CreateOrUpdateNode {
     return {
@@ -37,7 +37,7 @@ export function toCreateOrUpdateNode(node: StoredNode): CreateOrUpdateNode {
         key: node.key,
         mac: node.mac,
         monitoring: node.monitoringState !== MonitoringState.DISABLED,
-    }
+    };
 }
 
 export function toNodeResponse(node: StoredNode): NodeResponse {
@@ -53,17 +53,20 @@ export function toNodeResponse(node: StoredNode): NodeResponse {
         monitoringConfirmed: node.monitoringState === MonitoringState.ACTIVE,
         monitoringState: node.monitoringState,
         modifiedAt: node.modifiedAt,
-    }
+    };
 }
 
 export function toNodeTokenResponse(node: StoredNode): NodeTokenResponse {
     return {
         token: node.token,
         node: toNodeResponse(node),
-    }
+    };
 }
 
-export function toDomainSpecificNodeResponse(node: StoredNode, nodeStateData: NodeStateData): DomainSpecificNodeResponse {
+export function toDomainSpecificNodeResponse(
+    node: StoredNode,
+    nodeStateData: NodeStateData
+): DomainSpecificNodeResponse {
     return {
         token: node.token,
         nickname: node.nickname,
@@ -79,7 +82,7 @@ export function toDomainSpecificNodeResponse(node: StoredNode, nodeStateData: No
         site: nodeStateData.site,
         domain: nodeStateData.domain,
         onlineState: nodeStateData.state,
-    }
+    };
 }
 
 export function toMonitoringResponse(node: StoredNode): MonitoringResponse {
@@ -93,7 +96,7 @@ export function toMonitoringResponse(node: StoredNode): MonitoringResponse {
 }
 
 export type NodeSecrets = {
-    monitoringToken?: MonitoringToken,
+    monitoringToken?: MonitoringToken;
 };
 
 export type MailId = number & { readonly __tag: unique symbol };
@@ -118,4 +121,4 @@ export type Mail = {
     recipient: EmailAddress;
     data: MailData;
     failures: number;
-}
+};

server/types/logger.ts

@@ -1,7 +1,13 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'profile';
-export const LogLevels: LogLevel[] = ['debug', 'info', 'warn', 'error', 'profile'];
+export type LogLevel = "debug" | "info" | "warn" | "error" | "profile";
+export const LogLevels: LogLevel[] = [
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "profile",
+];
 
-export function isLogLevel(arg: any): arg is LogLevel {
+export function isLogLevel(arg: unknown): arg is LogLevel {
     if (typeof arg !== "string") {
         return false;
     }
@@ -14,12 +20,12 @@ export function isLogLevel(arg: any): arg is LogLevel {
 }
 
 export interface TaggedLogger {
-    log(level: LogLevel, ...args: any[]): void;
-    debug(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-    profile(...args: any[]): void;
+    log(level: LogLevel, ...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    profile(...args: unknown[]): void;
 }
 
 export interface Logger {