@leogps/file-uploader 2.0.3 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leogps/file-uploader",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Facilitates file uploader server.",
   "main": "src/index.ts",
   "repository": {
@@ -12,7 +12,7 @@
   },
   "scripts": {
     "clean": "rimraf dist file-uploader.tar.gz",
-    "precompile": "eslint -c .eslintrc.js --fix --ext .ts src src-client",
+    "precompile": "eslint -c .eslintrc.js --fix --ext .ts src src-client && node scripts/inject-version.js",
     "compile-server": "./node_modules/webpack-cli/bin/cli.js --config webpack.config.js",
     "compile-client-dev": "./node_modules/webpack-cli/bin/cli.js --config webpack-client.dev.js",
     "compile-client-prod": "./node_modules/webpack-cli/bin/cli.js --config webpack-client.prod.js",
@@ -105,10 +105,13 @@
     "rimraf": "^6.1.2",
     "sass": "^1.94.2",
     "sass-loader": "^13.3.3",
+    "source-map-support": "^0.5.21",
     "style-loader": "^3.3.1",
     "targz": "^1.0.1",
     "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.2",
     "tsc-watch": "^5.0.3",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.9.3",
     "webpack": "^5.74.0",
     "webpack-cli": "^6.0.1",

package/scripts/inject-version.js

@@ -0,0 +1,23 @@
+const fs = require('fs');
+const path = require('path');
+const pkg = require('../package.json');
+
+const filePath = path.join(__dirname, '../src/globals.ts');
+
+let content = fs.readFileSync(filePath, 'utf8');
+
+const versionBlockRegex = /\/\/ version:start[\s\S]*?\/\/ version:end/;
+
+const newBlock = `// version:start
+export const APP_VERSION = '${pkg.version}';
+// version:end`;
+
+if (!versionBlockRegex.test(content)) {
+    throw new Error('Version block markers not found in globals.ts');
+}
+
+content = content.replace(versionBlockRegex, newBlock);
+
+fs.writeFileSync(filePath, content, 'utf8');
+
+console.log(`APP_VERSION updated to ${pkg.version}`);

package/src/globals.ts

@@ -1,42 +1,70 @@
 import { Progress } from './model/progress';
 import { ProgressWriter } from './service/progress_writer';
 import _ from "lodash";
+import os from "os";
+import path from "path";
 
-let uploadChunkSize = 512 * 1024;
-let maxParallelChunkUploads = 10;
-let uploadsDir: string;
-let enableCompression = true;
-let serverPort = 8082;
-let maxFileSize = 100 * 1024 * 1024 * 1024; // 100Gb
+// version:start
+export const APP_VERSION = '2.0.4';
+// version:end
 
-export const progresses: Progress[] = [];
-export const uploadsProgressMap: Map<string, Progress> = new Map();
-let progressWriter: ProgressWriter;
-export const throttleWaitTimeInMillis = 250;
+export interface ServerConfig {
+    readonly uploadsDir: string;
+    readonly uploadChunkSize: number;
+    readonly maxParallelFileUploads: number;
+    readonly maxParallelChunkUploads: number;
+    readonly enableCompression: boolean;
+    readonly serverPort: number;
+    readonly maxFileSize: number;
+    readonly throttleWaitTimeInMillis: number;
+    readonly progressWriter?: ProgressWriter;
+    readonly version: string;
+}
+export type ServerConfigJson = Omit<ServerConfig, "progressWriter">;
 
-export const setUploadsDir = (dir: string) => { uploadsDir = dir; };
-export const getUploadsDir = () => uploadsDir;
+export const DEFAULT_SERVER_CONFIG: ServerConfig = Object.freeze({
+    uploadsDir: `${os.homedir()}${path.sep}uploads/`,
+    uploadChunkSize: 512 * 1024,
+    maxParallelFileUploads: 3,
+    maxParallelChunkUploads: 10,
+    enableCompression: true,
+    serverPort: 8082,
+    maxFileSize: 100 * 1024 * 1024 * 1024, // 100GB
+    throttleWaitTimeInMillis: 250,
+    version: APP_VERSION
+});
 
-export const setUploadChunkSize = (size: number) => { uploadChunkSize = size; };
-export const getUploadChunkSize = () => uploadChunkSize;
+const currentConfig: ServerConfig = { ...DEFAULT_SERVER_CONFIG };
 
-export const setMaxParallelChunkUploads = (count: number) => { maxParallelChunkUploads = count; };
-export const getMaxParallelChunkUploads = () => maxParallelChunkUploads;
+export const getServerConfig = (): ServerConfig => currentConfig;
 
-export const setEnableCompression = (enable: boolean) => { enableCompression = enable; };
-export const getEnableCompression = () => enableCompression;
-
-export const setServerPort = (port: number) => { serverPort = port; };
-export const getServerPort = () => serverPort;
+export const updateServerConfig = (overrides: Partial<ServerConfig>) => {
+    Object.assign(currentConfig, overrides);
+    return currentConfig;
+};
 
-export const setMaxFileSize = (size: number) => { maxFileSize = size; };
-export const getMaxFileSize = () => maxFileSize;
+export const progresses: Progress[] = [];
+export const uploadsProgressMap: Map<string, Progress> = new Map();
 
-export const setProgressWriter = (writer: ProgressWriter) => {
-    progressWriter = writer;
+export const getProgressWriter = (): ProgressWriter => {
+    const writer = getServerConfig().progressWriter;
+    if (!writer) {
+        throw new Error('ProgressWriter not configured');
+    }
+    return writer;
 };
-export const getProgressWriter = (): ProgressWriter => progressWriter;
 
-export const throttledBroadcaster = _.throttle(() => {
-    getProgressWriter().writeProgress(progresses);
-}, throttleWaitTimeInMillis);
+export let throttledBroadcaster: _.DebouncedFunc<() => void> =
+    _.throttle(() => {
+        // noop.
+    }, 0);
+export const createThrottledBroadcaster = (): void => {
+    throttledBroadcaster?.cancel?.();
+
+    throttledBroadcaster = _.throttle(
+        () => {
+            getProgressWriter().writeProgress(progresses);
+        },
+        getServerConfig().throttleWaitTimeInMillis
+    )
+};

package/src/index.ts

@@ -6,83 +6,97 @@ import {router as uploadChunkRouter} from "./routes/uploadChunk";
 import {router as uploadCompleteRouter} from "./routes/uploadComplete";
 import {router as uploadStatusRouter} from "./routes/uploadStatus";
 import {router as uploadRouter} from "./routes/upload";
+import {router as configRouter} from "./routes/config";
 import {ProgressWriter} from "./service/progress_writer";
 import * as socketio from "socket.io";
 import yargs from "yargs";
 import {hideBin} from "yargs/helpers";
-import * as os from 'os';
+
 import {
-  getEnableCompression, getMaxFileSize,
-  getMaxParallelChunkUploads, getServerPort, getUploadChunkSize,
-  progresses, setEnableCompression, setMaxFileSize,
-  setMaxParallelChunkUploads, setProgressWriter, setServerPort, setUploadChunkSize, setUploadsDir, throttledBroadcaster
+  createThrottledBroadcaster,
+  getServerConfig, progresses, throttledBroadcaster, updateServerConfig,
 } from "./globals";
 import prettyBytes from "pretty-bytes";
+import path from "path";
 
-const homedir = os.homedir();
-let uploadsDir = homedir + "/uploads/"
+const serverConfig = getServerConfig();
+console.log(`🚀file-uploader ${serverConfig.version}\n`);
 const argv: any = yargs(hideBin(process.argv))
   .option('upload-location', {
     alias: 'l',
     type: 'string',
     description: 'upload location',
-    default: uploadsDir
+    default: serverConfig.uploadsDir,
   })
   .option('port', {
     alias: 'p',
     type: 'number',
-    default: getServerPort(),
+    default: serverConfig.serverPort,
     description: 'server port'
   })
   .option('chunk-size', {
     alias: 's',
     type: 'number',
     description: 'chunk size in bytes',
-    default: 512 * 1024
+    default: serverConfig.uploadChunkSize,
+    defaultDescription: prettyBytes(serverConfig.uploadChunkSize, {binary: true}),
+  })
+  .option('parallel-file-uploads', {
+    alias: 'N',
+    type: 'number',
+    description: 'number of simultaneous parallel file uploads',
+    default: serverConfig.maxParallelFileUploads
   })
-  .option('parallel-uploads', {
+  .option('parallel-chunk-uploads', {
     alias: 'n',
     type: 'number',
     description: 'number of simultaneous parallel chunk uploads (per file)',
-    default: 10
+    default: serverConfig.maxParallelChunkUploads
   })
   .option('enable-compression', {
     alias: 'c',
     type: 'boolean',
     description: 'enable gzip compression (server to client responses)',
-    default: true
+    default: serverConfig.enableCompression
   })
   .option('max-file-size', {
     alias: 'm',
     type: 'number',
     description: 'maximum file size in bytes',
-    default: getMaxFileSize()
+    default: serverConfig.maxFileSize,
+    defaultDescription: prettyBytes(serverConfig.maxFileSize, {binary: true}),
   })
   .help()
   .argv
 
 const uploadLocationArg = argv["upload-location"]
+let uploadsDir: string = serverConfig.uploadsDir
 if (uploadLocationArg) {
   uploadsDir = uploadLocationArg.endsWith('/') ? uploadLocationArg: uploadLocationArg + '/'
 }
-setUploadsDir(uploadsDir)
-setUploadChunkSize(argv["chunk-size"])
-setMaxParallelChunkUploads(argv["parallel-uploads"])
-setEnableCompression(argv["enable-compression"])
-setServerPort(argv.port)
-setMaxFileSize(argv["max-file-size"])
-const port = getServerPort()
-
-console.log(`Upload location: ${uploadsDir}`)
-console.log(`Max Parallel uploads per file: ${getMaxParallelChunkUploads()}`)
-console.log(`Parallel upload chunk size: ${prettyBytes(getUploadChunkSize())}`)
-console.log(`Compression: ${getEnableCompression() ? "Enabled" : "Disabled"}`)
-console.log(`Server port: ${port}`)
+updateServerConfig({
+  uploadsDir,
+  uploadChunkSize: argv["chunk-size"],
+  maxParallelFileUploads: argv["parallel-file-uploads"],
+  maxParallelChunkUploads: argv["parallel-chunk-uploads"],
+  enableCompression: argv["enable-compression"],
+  serverPort: argv.port,
+  maxFileSize: argv["max-file-size"],
+})
+console.log(`Upload location: ${serverConfig.uploadsDir}`)
+console.log(`Max Parallel file uploads: ${serverConfig.maxParallelFileUploads}`)
+console.log(`Max Parallel uploads per file: ${serverConfig.maxParallelChunkUploads}`)
+console.log(`Parallel upload chunk size: ${prettyBytes(serverConfig.uploadChunkSize, {binary: true})}`)
+console.log(`Compression: ${serverConfig.enableCompression ? "Enabled" : "Disabled"}`)
+console.log(`Server port: ${serverConfig.serverPort}`)
+console.log(`\n`)
 
+console.info("Starting application server...")
 const app: Express = express();
 const httpServer: Server = createServer(app)
 const io: socketio.Server = new socketio.Server(httpServer);
-if (getEnableCompression()) {
+if (serverConfig.enableCompression) {
+  console.debug("enabling compression...")
   app.use(
       compression({
         threshold: 10 * 1024,
@@ -90,8 +104,10 @@ if (getEnableCompression()) {
       })
   )
 }
-
-setProgressWriter(new ProgressWriter(io));
+updateServerConfig({
+  progressWriter: new ProgressWriter(io)
+})
+createThrottledBroadcaster();
 
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
@@ -100,10 +116,20 @@ app.use('/upload/chunk', uploadChunkRouter);
 app.use('/upload/complete', uploadCompleteRouter);
 app.use('/upload/status', uploadStatusRouter);
 app.use('/upload', uploadRouter);
+app.use('/config', configRouter);
+
+const isDev = process.env.NODE_ENV !== 'production';
+
+const clientDir = isDev
+    ? path.resolve(__dirname, "../dist/client")  // dev: server in src/, client in dist/
+    : path.resolve(__dirname, "client");        // prod: server in dist/, client in dist/client
 
 app.get('/', (_, res) => {
-  res.sendFile(__dirname + '/client/index.html');
+  res.sendFile(path.join(clientDir, 'index.html'));
 });
+app.use('/', [
+  express.static(clientDir)
+]);
 
 app.get('/progresses', (_: Request, res: Response) => {
   console.log("Progresses requested...");
@@ -124,10 +150,6 @@ io.on('connection', (socket: socketio.Socket) => {
   });
 });
 
-app.use('/', [
-  express.static(__dirname + '/client/')
-]);
-
-httpServer.listen(port, () => {
-  console.log('Server listening on ' + port + ' ...');
+httpServer.listen(serverConfig.serverPort, () => {
+  console.log('Server listening on ' + serverConfig.serverPort + ' ...');
 });

package/src/routes/config.ts

@@ -0,0 +1,15 @@
+import { Router, Request, Response } from 'express';
+import {getServerConfig, ServerConfig, ServerConfigJson} from "../globals";
+
+const serverConfig = getServerConfig();
+export const router = Router();
+
+router.get('/', (_: Request, res: Response) => {
+    console.log("GET /config");
+    const toServerConfigJson = (config: ServerConfig): ServerConfigJson => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { progressWriter, ...json } = config;
+        return json;
+    };
+    res.json(toServerConfigJson(serverConfig));
+})

package/src/routes/upload.ts

@@ -2,11 +2,9 @@ import { Router } from 'express';
 import formidable, { File } from "formidable";
 import { v4 as uuidv4 } from 'uuid';
 import {
-    getMaxFileSize,
-    getUploadsDir,
-    progresses,
+    getServerConfig,
+    progresses, ServerConfig,
     throttledBroadcaster,
-    throttleWaitTimeInMillis,
     uploadsProgressMap
 } from "../globals";
 import {FileTransferProgress, Progress, UploadStatus} from "../model/progress";
@@ -14,11 +12,12 @@ import _ from "lodash";
 import prettyBytes from "pretty-bytes";
 import mv from "mv";
 
+const serverConfig: ServerConfig = getServerConfig();
 export const router = Router();
 
 router.post('/', (req: any, res: any) => {
-    const maxFileSize = getMaxFileSize();
-    const uploadsDir = getUploadsDir();
+    const maxFileSize = serverConfig.maxFileSize;
+    const uploadsDir = serverConfig.uploadsDir;
     // parse a file upload
     const form = formidable({
         multiples: true,
@@ -47,7 +46,7 @@ router.post('/', (req: any, res: any) => {
             console.warn("Progress not found in the map for uuid: " + uuid);
             return;
         }
-    }, throttleWaitTimeInMillis, {
+    }, serverConfig.throttleWaitTimeInMillis, {
         leading: true
     });
 

package/src/routes/uploadChunk.ts

@@ -5,11 +5,11 @@ import path from "path";
 import crypto from "crypto";
 import {
     uploadsProgressMap,
-    getUploadsDir,
-    throttledBroadcaster
+    throttledBroadcaster, getServerConfig
 } from "../globals";
 import { FileTransferProgress } from "../model/progress";
 
+const serverConfig = getServerConfig();
 export const router = Router();
 
 router.post("/", (req: Request, res: Response) => {
@@ -30,7 +30,7 @@ router.post("/", (req: Request, res: Response) => {
 
         const progress = uploadsProgressMap.get(fileId)! as FileTransferProgress;
 
-        const uploadDir = getUploadsDir();
+        const uploadDir = serverConfig.uploadsDir;
         await fs.mkdir(uploadDir, { recursive: true });
 
         const form = formidable({

package/src/routes/uploadInit.ts

@@ -2,14 +2,13 @@ import { Router, Request, Response } from 'express';
 import { v4 as uuidv4 } from 'uuid';
 import {
     uploadsProgressMap,
-    progresses,
-    getUploadsDir,
-    getUploadChunkSize, getMaxParallelChunkUploads
+    progresses, getServerConfig
 } from '../globals';
 import { FileTransferProgress } from '../model/progress';
 import path from "path";
 import fs from "fs";
 
+const serverConfig = getServerConfig();
 export const router = Router();
 
 /**
@@ -34,7 +33,7 @@ router.post('/', (req: Request, res: Response) => {
         return res.status(400).json({ msg: 'Missing or invalid fileName/fileSize' });
     }
 
-    const finalPath = path.join(getUploadsDir(), fileName);
+    const finalPath = path.join(serverConfig.uploadsDir, fileName);
     let progress: FileTransferProgress;
     let fileId: string;
 
@@ -53,7 +52,7 @@ router.post('/', (req: Request, res: Response) => {
             progress = new FileTransferProgress(fileId, Date.now());
             progress.fileName = fileName;
             progress.bytesExpected = fileSize;
-            progress.chunkSize = getUploadChunkSize();
+            progress.chunkSize = serverConfig.uploadChunkSize;
             progress.totalChunks = Math.ceil(fileSize / progress.chunkSize);
             progress.bytesReceived = fs.statSync(finalPath).size; // resume
             progress.resetUploadedChunks();
@@ -68,7 +67,7 @@ router.post('/', (req: Request, res: Response) => {
         progress = new FileTransferProgress(fileId, Date.now());
         progress.fileName = fileName;
         progress.bytesExpected = fileSize;
-        progress.chunkSize = getUploadChunkSize();
+        progress.chunkSize = serverConfig.uploadChunkSize;
         progress.totalChunks = Math.ceil(fileSize / progress.chunkSize);
         progress.resetUploadedChunks();
         uploadsProgressMap.set(fileId, progress);
@@ -82,7 +81,7 @@ router.post('/', (req: Request, res: Response) => {
         fileId,
         chunkSize: progress.chunkSize,
         totalChunks: progress.totalChunks,
-        maxParallel: getMaxParallelChunkUploads(),
+        maxParallelChunkUploads: serverConfig.maxParallelChunkUploads,
         bytesReceived: progress.bytesReceived || 0 // client can skip uploaded chunks
     });
 });

package/src-client/entrypoint.ts

@@ -3,6 +3,7 @@ import "jquery-blockui/jquery.blockUI.js";
 import "./style.scss";
 import Toastify from "toastify-js";
 import {computeSHA1} from "./sha1";
+import {ServerConfigJson} from "../src/globals";
 
 const MAX_COMPLETE_CHECK_RETRIES = 20;
 const COMPLETE_CHECK_RETRY_DELAY_MS = 1000;
@@ -15,6 +16,28 @@ jQuery(() => {
     pageEventRegistrar.registerEvents();
 });
 
+const asyncPool = async <T>(
+    poolLimit: number,
+    array: T[],
+    iteratorFn: (item: T) => Promise<void>
+): Promise<void> => {
+    const executing = new Set<Promise<void>>();
+
+    for (const item of array) {
+        const p = Promise.resolve().then(() => iteratorFn(item));
+        executing.add(p);
+
+        const clean = () => executing.delete(p);
+        p.then(clean).catch(clean);
+
+        if (executing.size >= poolLimit) {
+            await Promise.race(executing);
+        }
+    }
+
+    await Promise.all(executing);
+};
+
 class PageEventRegistrar {
     public registerEvents(): void {
         this.registerThemeSelectionEventHandler();
@@ -95,37 +118,42 @@ class PageEventRegistrar {
                     return;
                 }
 
-                const disableChunked = (jQuery("#disableChunkedUpload").prop("checked") === true);
-
                 // Block form before uploading
                 $uploadForm.block({
                     message: '<h1 class="upload-block-modal p-2 m-0">Uploading...</h1>'
                 });
 
-                try {
-                    // Upload all files sequentially
-                    for (const file of Array.from(files)) {
-                        if (disableChunked) {
-                            await this.uploadFileNonChunked(file);
-                        } else {
-                            await this.uploadFile(file);
-                        }
+                const disableChunked = (jQuery("#disableChunkedUpload").prop("checked") === true);
+                console.log("disableChunked?", disableChunked);
+
+                const serverConfigResponse = await this.retrieveConfig();
+                const errorMessage = serverConfigResponse.error
+                if (errorMessage) {
+                    let errorText = errorMessage;
+                    const errorObject = serverConfigResponse.errorObject;
+                    const errorObjectMessage = errorObject instanceof Error ? errorObject.message : String(errorObject);
+                    if (serverConfigResponse.errorObject) {
+                        errorText = `${errorText}. ${errorObjectMessage}`;
                     }
-                } finally {
-                    // Unblock and reset form after all files finish
-                    $uploadForm.trigger("reset");
-
-                    const $fileDiv = jQuery("#file-div");
-                    const $fileNameDiv = $fileDiv.find("#file-name");
-                    const $fileInput = jQuery("form#uploadForm input[name='file']");
-                    this.onFilesChange($fileNameDiv, $fileInput);
-
-                    $uploadForm.unblock();
+                    console.error(errorText);
+                    Toastify({
+                        text: errorText,
+                        duration: -1,
+                        close: true,
+                        style: { background: "linear-gradient(to right, #F39454, #FF6600)" }
+                    }).showToast();
                 }
+                const serverConfigJson = serverConfigResponse.response;
+                await this.doUpload(files, {
+                    $uploadForm,
+                    serverConfig: serverConfigJson,
+                    disableChunkedUpload: disableChunked,
+                });
             })().catch(err => {
+                const message = err instanceof Error ? err.message : String(err);
                 console.error("Error during upload:", err);
                 Toastify({
-                    text: `Upload error: ${err}`,
+                    text: `Upload failed: ${message}`,
                     duration: -1,
                     close: true,
                     style: { background: "linear-gradient(to right, #F39454, #FF6600)" }
@@ -134,6 +162,53 @@ class PageEventRegistrar {
         });
     }
 
+    private async doUpload(files: FileList, {
+        disableChunkedUpload = false,
+        serverConfig,
+        $uploadForm,
+    }: {
+        disableChunkedUpload: boolean,
+        serverConfig?: ServerConfigJson,
+        $uploadForm: JQuery<HTMLElement>
+    }):Promise<void> {
+        try {
+            let maxParallelFileUploads = 1;
+            if (serverConfig != null) {
+                maxParallelFileUploads = serverConfig.maxParallelFileUploads;
+            }
+            console.log(`Max parallel file uploads: ${maxParallelFileUploads}`);
+            await asyncPool(
+                maxParallelFileUploads,
+                Array.from(files),
+                async (file) => {
+                    if (disableChunkedUpload) {
+                        await this.uploadFileNonChunked(file);
+                    } else {
+                        await this.uploadFile(file);
+                    }
+                }
+            ).catch(err => {
+                console.error("Error during upload:", err);
+                Toastify({
+                    text: `Upload failed: ${err}`,
+                    duration: -1,
+                    close: true,
+                    style: { background: "linear-gradient(to right, #F39454, #FF6600)" }
+                }).showToast();
+            });
+        } finally {
+            // Unblock and reset form after all files finish
+            $uploadForm.trigger("reset");
+
+            const $fileDiv = jQuery("#file-div");
+            const $fileNameDiv = $fileDiv.find("#file-name");
+            const $fileInput = jQuery("form#uploadForm input[name='file']");
+            this.onFilesChange($fileNameDiv, $fileInput);
+
+            $uploadForm.unblock();
+        }
+    }
+
     private async uploadFileNonChunked(file: File): Promise<void> {
         const formData = new FormData();
         // Server-side uses formidable({ multiples: true }) so using the same field name is fine
@@ -175,7 +250,7 @@ class PageEventRegistrar {
             const initData = await initResp.json();
             const fileId: string = initData.fileId;
             const chunkSize: number = initData.chunkSize;
-            const maxParallel: number = initData.maxParallel || 3;
+            const maxParallelChunkUploads: number = initData.maxParallelChunkUploads || 3;
             const totalChunks: number = Math.ceil(file.size / chunkSize);
 
             // Active upload pool
@@ -226,7 +301,7 @@ class PageEventRegistrar {
                 pool.push(taskPromise);
 
                 // If pool is full, wait for at least one to finish
-                if (pool.length >= maxParallel) {
+                if (pool.length >= maxParallelChunkUploads) {
                     await Promise.race(pool).catch((err) => {
                         console.warn(`Pool full, but one task failed, err: ${err}`);
                     }); // don't block other tasks
@@ -306,4 +381,33 @@ class PageEventRegistrar {
             }
         }
     }
+
+    private async retrieveConfig(): Promise<ResponseOrError<ServerConfigJson>> {
+        try {
+            const response = await fetch(`/config`)
+            if (response.ok) {
+                const serverConfigJson = await response.json();
+                return {
+                    response: serverConfigJson as ServerConfigJson
+                };
+            }
+            return {
+                "error": `Could not retrieve config: ${response.status}`
+            };
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`Could not retrieve config: ${errorMessage}`);
+            return {
+                error: `Failed to retrieve config: ${errorMessage}`,
+                errorObject: error,
+            };
+        }
+
+    }
+}
+
+interface ResponseOrError<T> {
+    response?: T;
+    error?: string,
+    errorObject?: any
 }