galvanic-corrosion/src/config.ts

/* Galvanic Corrosion - Rec Room custom server for communities.
<https://gitea.proxnet.dev/zombieb/galvanic-corrosion>
Copyright (C) 2025  @zombieb (Discord / proxnet Gitea)

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>. */

import Logging from "@proxnet/undead-logging";
import * as fs from "node:fs";
import { PhotonRegionCodeNumber, PhotonRegionCodeString } from "./data/live/types.ts";

const log = new Logging("Config");

type RedisConfiguration = {
    host: string;
    port: number;
    username: string;
    password: string;
    db: number;
};

type WebConfiguration = {
    port: number;
    host: string;
    publichost: string;
    securepublichost: boolean;
}

type WebRootConfiguration = {
    api: WebConfiguration,
    socket: WebConfiguration
};

type PublicConfiguration = {
    serverName: string;
    serverId: string;
    owner: string;
    motd: string;
    levelScale: number;
    maxLevels: number;
    patches: string[];
    photonRegionId: PhotonRegionCodeString | PhotonRegionCodeNumber;
};

type LoggingConfiguration = {
    notfound: boolean;
    debug: boolean;
    network: boolean;
};

type DiscordConfiguration = {
    token: string;
    clientId: string;
    guildId: string;
};

type AuthConfiguration = {
    secret: string;
    /**
     * In Hours
     */
    timeout: number;
};

export type GalvanicConfiguration = {
    redis: RedisConfiguration;
    web: WebRootConfiguration;
    public: PublicConfiguration;
    logging: LoggingConfiguration;
    discord: DiscordConfiguration | null;
    auth: AuthConfiguration;
};

export const defaultConfig: GalvanicConfiguration = {
    redis: {
        host: "127.0.0.1",
        port: 6379,
        username: "",
        password: "",
        db: 0,
    },
    web: {
        api: {
            port: 13370,
            host: "127.0.0.1",
            publichost: "127.0.0.1:13370",
            securepublichost: false,
        },
        socket: {
            port: 13371,
            host: "127.0.0.1",
            publichost: "127.0.0.1:13371",
            securepublichost: false,
        }
    },
    public: {
        serverName: "Galvanic Corrosion",
        serverId: "galvanic-corrosion-default",
        owner: "John Doe",
        motd: "A Galvanic Corrosion server.",
        levelScale: 1,
        maxLevels: 30,
        patches: [],
        photonRegionId: PhotonRegionCodeNumber.us,
    },
    logging: {
        notfound: false,
        debug: false,
        network: false,
    },
    discord: null,
    auth: {
        secret: "CHANGE-ME-PLEASE",
        timeout: 3,
    },
};

/** The current configuration. Read and parsed only during startup. */
let config: GalvanicConfiguration;
try {
    if (!configurationExists()) generateDefaultConfig();
    config = JSON.parse(fs.readFileSync("./config.json").toString());
} catch (err) {
    log.e(`Could not get config: ${err}`);
    Deno.exit(1);
}

/** Does the configuration file exist on the disk? */
export function configurationExists() {
    return fs.existsSync("./config.json");
}

/** Place [or overwrite] the [existing] default configuration in the current directory */
export function generateDefaultConfig() {
    fs.writeFileSync(
        "./config.json",
        JSON.stringify(defaultConfig, undefined, "    "),
    );
}

/** Get current server configuration */
export function getConfig() {
    return config;
}

export const devMode = Deno.args.includes("--dev");

export * as Config from "./config.ts";