exaroton 1.9.0 → 1.11.1

package/.github/workflows/publish.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: npm install -g npm
       - run: npm ci

package/README.md

@@ -291,6 +291,72 @@ try {
 }
 ```
 
+#### Config files
+Config files are files that contain server configuration and are shown as forms rather than plain text files in the exaroton panel.
+You can get a config file object by using the `getConfig()` method on a file object.
+Whether a file is a config file can be checked using the `isConfigFile` property.
+
+```js
+let file = server.getFile("server.properties");
+let config = file.getConfig();
+```
+
+##### Get config file options
+```js
+let options = await config.getOptions();
+for(let [key, option] of options) {
+    console.log(key, option.getValue());
+}
+```
+
+##### Update config file options
+```js
+let options = await config.getOptions();
+
+options.get("max-players").setValue(26);
+options.get("pvp").setValue(false);
+
+await config.save();
+```
+
+Options of type `select` or `multiselect` have a list of possible values.
+```js
+let options = await config.getOptions();
+console.log(options.get("difficulty").getOptions());
+```
+
+#### Credit pools
+Credit pools allow sharing the costs of a server between multiple users. 
+
+##### List credit pools
+```js
+let pools = await client.getPools();
+console.log(pools);
+```
+
+##### Create a pool object by ID
+```js
+let server = client.pool(id);
+```
+
+##### Get pool information
+```js
+await pool.get();
+console.log(pool.name + ": " + pool.credits);
+```
+
+##### Get pool members
+```js
+let members = await pool.getMembers();
+console.log(members);
+```
+
+##### Get pool servers
+```js
+let servers = await pool.getServers();
+console.log(servers);
+```
+
 ### Websocket API
 The websocket API allows a constant connection to our websocket service to receive 
 events in real time without polling (e.g. trying to get the server status every few seconds).
@@ -372,4 +438,4 @@ You can unsubscribe from one, multiple or all streams using the `server.unsubscr
 server.unsubscribe("console");
 server.unsubscribe(["tick", "heap"]);
 server.unsubscribe(); // this disconnects the websocket connection
-```
+```

package/index.js

@@ -4,5 +4,8 @@ module.exports = {
     Software: require('./src/Server/Software'),
     ServerStatus: require('./src/Server/ServerStatus'),
     Request: require('./src/Request/Request'),
-    Response: require('./src/Response/Response')
-}
+    Response: require('./src/Response/Response'),
+    ConfigOptionType: require('./src/Server/Config/ConfigOptionType'),
+    Pool: require('./src/Billing/Pool/Pool'),
+    PoolMember: require('./src/Billing/Pool/PoolMember')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exaroton",
-  "version": "1.9.0",
+  "version": "1.11.1",
   "description": "exaroton API client",
   "homepage": "https://exaroton.com",
   "main": "index.js",

package/src/Billing/Pool/Pool.js

@@ -0,0 +1,137 @@
+const GetPoolRequest = require("../../Request/Billing/Pool/GetPoolRequest.js");
+const GetPoolMembersRequest = require("../../Request/Billing/Pool/GetPoolMembersRequest.js");
+const GetPoolServersRequest = require("../../Request/Billing/Pool/GetPoolServersRequest.js");
+
+class Pool {
+    /**
+     * @type {Client}
+     * @private
+     */
+    #client;
+
+    /**
+     * Pool ID
+     *
+     * @type {string}
+     */
+    id;
+
+    /**
+     * Pool name
+     *
+     * @type {string}
+     */
+    name;
+
+    /**
+     * Pool credit balance
+     *
+     * @type {number}
+     */
+    credits;
+
+    /**
+     * Pool server count
+     *
+     * @type {number}
+     */
+    servers;
+
+    /**
+     * Pool owner ID
+     *
+     * @type {string}
+     */
+    owner;
+
+    /**
+     * Is pool owner
+     *
+     * @type {boolean}
+     */
+    isOwner;
+
+    /**
+     * Pool member count
+     *
+     * @type {number}
+     */
+    members;
+
+    /**
+     * Share of this pool owned by the current account
+     *
+     * @type {number}
+     */
+    ownShare;
+
+    /**
+     * Credits in this pool owned by the current account
+     *
+     * @type {number}
+     */
+    ownCredits;
+
+    /**
+     * Pool constructor
+     *
+     * @param {Client} client
+     * @param {string} id
+     */
+    constructor(client, id) {
+        this.#client = client;
+        this.id = id;
+    }
+
+    /**
+     * @param {{}} poolObject
+     * @return {this}
+     */
+    setFromObject(poolObject) {
+        this.id = typeof poolObject.id !== "undefined" ? poolObject.id : null;
+        this.name = typeof poolObject.name !== "undefined" ? poolObject.name : null;
+        this.credits = typeof poolObject.credits !== "undefined" ? poolObject.credits : null;
+        this.servers = typeof poolObject.servers !== "undefined" ? poolObject.servers : null;
+        this.owner = typeof poolObject.owner !== "undefined" ? poolObject.owner : null;
+        this.isOwner = typeof poolObject.isOwner !== "undefined" ? poolObject.isOwner : null;
+        this.members = typeof poolObject.members !== "undefined" ? poolObject.members : null;
+        this.ownShare = typeof poolObject.ownShare !== "undefined" ? poolObject.ownShare : null;
+        this.ownCredits = typeof poolObject.ownCredits !== "undefined" ? poolObject.ownCredits : null;
+
+        return this;
+    }
+
+    /**
+     * Get credit pool info
+     *
+     * @return {this}
+     * @throws {RequestError}
+     */
+    async get() {
+        let response = await this.#client.request(new GetPoolRequest(this.id));
+        this.setFromObject(response.getData());
+        return this;
+    }
+
+    /**
+     * Get pool members
+     *
+     * @return {Promise<PoolMember[]>}
+     */
+    async getMembers() {
+        let response = await this.#client.request(new GetPoolMembersRequest(this.id));
+        return response.getData();
+    }
+
+    /**
+     * Get pool servers
+     *
+     * @return {Promise<Server[]>}
+     */
+    async getServers() {
+        let response = await this.#client.request(new GetPoolServersRequest(this.id));
+        return response.getData();
+    }
+}
+
+module.exports = Pool;

package/src/Billing/Pool/PoolMember.js

@@ -0,0 +1,52 @@
+
+class PoolMember {
+    /**
+     * Pool member account ID
+     *
+     * @type {string}
+     */
+    account;
+
+    /**
+     * Pool member name
+     *
+     * @type {string}
+     */
+    name;
+
+    /**
+     * Pool member share
+     *
+     * @type {number}
+     */
+    share;
+
+    /**
+     * Pool member credits
+     *
+     * @type {number}
+     */
+    credits;
+
+    /**
+     * Is pool owner
+     *
+     * @type {boolean}
+     */
+    isOwner;
+
+    /**
+     * Pool member constructor
+     *
+     * @param {{}} poolMemberObject
+     */
+    constructor(poolMemberObject) {
+        this.account = typeof poolMemberObject.account !== "undefined" ? poolMemberObject.account : null;
+        this.name = typeof poolMemberObject.name !== "undefined" ? poolMemberObject.name : null;
+        this.share = typeof poolMemberObject.share !== "undefined" ? poolMemberObject.share : null;
+        this.credits = typeof poolMemberObject.credits !== "undefined" ? poolMemberObject.credits : null;
+        this.isOwner = typeof poolMemberObject.isOwner !== "undefined" ? poolMemberObject.isOwner : null;
+    }
+}
+
+module.exports = PoolMember;

package/src/Client.js

@@ -6,8 +6,10 @@ const Account = require('./Account/Account');
 const RequestStatusError = require('./Error/RequestStatusError');
 const RequestBodyError = require('./Error/RequestBodyError');
 const GetServersRequest = require('./Request/GetServersRequest');
+const GetPoolsRequest = require('./Request/Billing/Pool/GetPoolsRequest');
 
 const packageConfig = require('../package.json');
+const Pool = require("./Billing/Pool/Pool.js");
 
 class Client {
     /**
@@ -175,6 +177,16 @@ class Client {
         return (await this.request(new GetServersRequest)).getData();
     }
 
+    /**
+     * Get a list of all credit pools
+     *
+     * @return {Promise<Pool[]>}
+     * @throws {RequestError}
+     */
+    async getPools() {
+        return (await this.request(new GetPoolsRequest)).getData();
+    }
+
     /**
      * Get account info for the current account
      *
@@ -194,6 +206,16 @@ class Client {
     server(id) {
         return new Server(this, id);
     }
+
+    /**
+     * Initialize a new pool object
+     *
+     * @param {string} id
+     * @return {Pool}
+     */
+    pool(id) {
+        return new Pool(this, id);
+    }
 }
 
-module.exports = Client;
+module.exports = Client;

package/src/Request/Billing/Pool/GetPoolMembersRequest.js

@@ -0,0 +1,9 @@
+const PoolRequest = require("./PoolRequest.js");
+const PoolMembersResponse = require("../../../Response/PoolMembersResponse.js");
+
+class GetPoolMembersRequest extends PoolRequest {
+    endpoint = "billing/pools/{id}/members";
+    responseClass = PoolMembersResponse;
+}
+
+module.exports = GetPoolMembersRequest;

package/src/Request/Billing/Pool/GetPoolRequest.js

@@ -0,0 +1,7 @@
+const PoolRequest = require("./PoolRequest.js");
+
+class GetPoolRequest extends PoolRequest {
+    endpoint = "billing/pools/{id}";
+}
+
+module.exports = GetPoolRequest;

package/src/Request/Billing/Pool/GetPoolServersRequest.js

@@ -0,0 +1,9 @@
+const PoolRequest = require("./PoolRequest.js");
+const ServersResponse = require("../../../Response/ServersResponse.js");
+
+class GetPoolServersRequest extends PoolRequest {
+    endpoint = "billing/pools/{id}/servers";
+    responseClass = ServersResponse;
+}
+
+module.exports = GetPoolServersRequest;

package/src/Request/Billing/Pool/GetPoolsRequest.js

@@ -0,0 +1,9 @@
+const Request = require('../../Request');
+const PoolsResponse = require("../../../Response/PoolsResponse.js");
+
+class GetPoolsRequest extends Request {
+    endpoint = "billing/pools";
+    responseClass = PoolsResponse;
+}
+
+module.exports = GetPoolsRequest;

package/src/Request/Billing/Pool/PoolRequest.js

@@ -0,0 +1,15 @@
+const Request = require('../../Request.js');
+
+class PoolRequest extends Request {
+    /**
+     * Pool request constructor
+     *
+     * @param {string} id
+     */
+    constructor(id) {
+        super();
+        this.setParameter("id", id);
+    }
+}
+
+module.exports = PoolRequest;

package/src/Request/Server/Files/Config/GetConfigFileOptionsRequest.js

@@ -0,0 +1,7 @@
+const FileRequest = require("../FileRequest");
+
+class GetConfigFileOptionsRequest extends FileRequest {
+    endpoint = "servers/{id}/files/config/{path}";
+}
+
+module.exports = GetConfigFileOptionsRequest;

package/src/Request/Server/Files/Config/UpdateConfigFileOptionsRequest.js

@@ -0,0 +1,21 @@
+const FileRequest = require("../FileRequest");
+
+class UpdateConfigFileOptionsRequest extends FileRequest {
+    endpoint = "servers/{id}/files/config/{path}";
+    method = "POST";
+
+    /**
+     * UpdateConfigFileOptionsRequest constructor
+     *
+     * @param {string} id
+     * @param {string} path
+     * @param {Object.<string, string|number|boolean|string[]>} options
+     */
+    constructor(id, path, options) {
+        super(id, path);
+
+        this.data = options;
+    }
+}
+
+module.exports = UpdateConfigFileOptionsRequest;

package/src/Response/ArrayResponse.js

@@ -0,0 +1,44 @@
+const Response = require('./Response');
+
+/**
+ * @abstract
+ */
+class ArrayResponse extends Response {
+    /**
+     * @type {*[]}
+     */
+    items = [];
+
+    /**
+     * @inheritDoc
+     */
+    setBody(body) {
+        super.setBody(body);
+
+        if (!Array.isArray(body.data)) {
+            return;
+        }
+
+        for (let object of body.data) {
+            this.items.push(this.handleItem(object));
+        }
+    }
+
+    /**
+     * @param {*} item
+     * @return {*}
+     * @abstract
+     */
+    handleItem(item) {
+
+    }
+
+    /**
+     * @inheritDoc
+     */
+    getData() {
+        return this.items;
+    }
+}
+
+module.exports = ArrayResponse;

package/src/Response/PlayerListsResponse.js

@@ -1,32 +1,12 @@
 const PlayerList = require('../Server/PlayerList');
-const Response = require('./Response');
-
-class PlayerListsResponse extends Response {
-    /**
-     * @type {PlayerList[]}
-     */
-    lists = [];
-
-    /**
-     * @inheritDoc
-     */
-    setBody(body) {
-        super.setBody(body);
-
-        if (!Array.isArray(body.data)) {
-            return;
-        }
-
-        for (let playerListName of body.data) {
-            this.lists.push(new PlayerList(playerListName).setClient(this.request.client));
-        }
-    }
+const ArrayResponse = require("./ArrayResponse.js");
 
+class PlayerListsResponse extends ArrayResponse {
     /**
      * @inheritDoc
      */
-    getData() {
-        return this.lists;
+    handleItem(item) {
+        return new PlayerList(item).setClient(this.request.client);
     }
 }
-module.exports = PlayerListsResponse;
+module.exports = PlayerListsResponse;

package/src/Response/PoolMembersResponse.js

@@ -0,0 +1,13 @@
+const ArrayResponse = require("./ArrayResponse.js");
+const PoolMember = require("../Billing/Pool/PoolMember.js");
+
+class PoolMembersResponse extends ArrayResponse {
+    /**
+     * @inheritDoc
+     */
+    handleItem(item) {
+        return new PoolMember(item);
+    }
+}
+
+module.exports = PoolMembersResponse;

package/src/Response/PoolsResponse.js

@@ -0,0 +1,13 @@
+const Pool = require('../Billing/Pool/Pool.js');
+const ArrayResponse = require("./ArrayResponse.js");
+
+class PoolsResponse extends ArrayResponse {
+    /**
+     * @inheritDoc
+     */
+    handleItem(item) {
+        return new Pool(this.request.client, item.id).setFromObject(item);
+    }
+}
+
+module.exports = PoolsResponse;

package/src/Response/ServersResponse.js

@@ -1,33 +1,13 @@
-const Response = require('./Response');
 const Server = require('../Server/Server');
+const ArrayResponse = require("./ArrayResponse.js");
 
-class ServersResponse extends Response {
-    /**
-     * @type {Server[]}
-     */
-    servers = [];
-
-    /**
-     * @inheritDoc
-     */
-    setBody(body) {
-        super.setBody(body);
-
-        if (!Array.isArray(body.data)) {
-            return;
-        }
-
-        for (let serverObject of body.data) {
-            this.servers.push(new Server(this.request.client, serverObject.id).setFromObject(serverObject));
-        }
-    }
-
+class ServersResponse extends ArrayResponse {
     /**
      * @inheritDoc
      */
-    getData() {
-        return this.servers;
+    handleItem(item) {
+        return new Server(this.request.client, item.id).setFromObject(item);
     }
 }
 
-module.exports = ServersResponse;
+module.exports = ServersResponse;

package/src/Server/Config/Config.js

@@ -0,0 +1,115 @@
+const GetConfigFileOptionsRequest = require("../../Request/Server/Files/Config/GetConfigFileOptionsRequest");
+const UpdateConfigFileOptionsRequest = require("../../Request/Server/Files/Config/UpdateConfigFileOptionsRequest");
+const ConfigOption = require("./ConfigOption");
+
+class Config {
+    /**
+     * @type {File}
+     */
+    #file;
+
+    /**
+     * @type {null|Map<string, ConfigOption>}
+     */
+    #options = null;
+
+    /**
+     * @type {null|Map<string, ConfigOptionValue>}
+     */
+    #originalValues = null;
+
+    /**
+     * @param {File} file
+     */
+    constructor(file) {
+        this.#file = file;
+    }
+
+    /**
+     * @param {Object} object
+     * @return {this}
+     */
+    applyData(object) {
+        this.#options = new Map();
+        this.#originalValues = new Map();
+
+        if (!Array.isArray(object)) {
+            return this;
+        }
+
+        for (const option of object) {
+            if (typeof option !== "object") {
+                continue;
+            }
+
+            let {key, label, type, value, options} = option;
+            if (typeof key !== "string" || typeof label !== "string" || typeof type !== "string" || options && !Array.isArray(options)) {
+                continue;
+            }
+
+            this.#options.set(key, new ConfigOption(key, label, type, value, options));
+            this.#originalValues.set(key, value);
+        }
+        return this;
+    }
+
+    /**
+     * @return {Promise<this>}
+     */
+    async #loadOptions() {
+        const response = await this.#file.getClient().request(new GetConfigFileOptionsRequest(this.#file.getServer().id, this.#file.path));
+        this.applyData(response.getData());
+        return this;
+    }
+
+    /**
+     * @param {boolean} update
+     * @return {Promise<Map<string, ConfigOption>>}
+     */
+    async getOptions(update = false) {
+        if (update || this.#options === null) {
+            await this.#loadOptions();
+        }
+        return this.#options;
+    }
+
+    /**
+     * @param {string} key
+     * @return {Promise<ConfigOption|null>}
+     */
+    async getOption(key) {
+        const options = await this.getOptions();
+        return options.get(key) ?? null;
+    }
+
+    /**
+     * Save all changes made to this config file
+     *
+     * @return {Promise<Response|null>} null if no changes were made
+     */
+    async save() {
+        let updated = false;
+        let changed = {};
+        for (let [key, option] of this.#options) {
+            if (option.getValue() !== this.#originalValues.get(key)) {
+                updated = true;
+                changed[key] = option.getValue();
+            }
+        }
+
+        if (!updated) {
+            return null;
+        }
+
+        let response = await this.#file.getClient().request(
+            new UpdateConfigFileOptionsRequest(this.#file.getServer().id, this.#file.path, changed));
+
+        for (let [key, value] of Object.entries(changed)) {
+            this.#originalValues.set(key, value);
+        }
+
+        return response;
+    }
+}
+
+module.exports = Config;

package/src/Server/Config/ConfigOption.js

@@ -0,0 +1,103 @@
+/**
+ * @typedef {string|number|boolean|string[]} ConfigOptionValue
+ */
+
+class ConfigOption {
+    /**
+     * Key of this config option
+     *
+     * @type {string}
+     */
+    #key;
+
+    /**
+     * Label of this config option
+     *
+     * @type {string}
+     */
+    #label;
+
+    /**
+     * Option type
+     *
+     * @type {string}
+     */
+    #type;
+
+    /**
+     * Current option value
+     *
+     * @type {ConfigOptionValue}
+     */
+    #value;
+
+    /**
+     * Available options for select/multiselect
+     *
+     * @type {string[]|null}
+     */
+    #options;
+
+    /**
+     * ConfigOption constructor
+     *
+     * @param {string} key
+     * @param {string} label
+     * @param {string} type
+     * @param {ConfigOptionValue} value
+     * @param {string[]|null} options
+     */
+    constructor(key, label, type, value, options = null) {
+        this.#key = key;
+        this.#label = label;
+        this.#type = type;
+        this.#value = value;
+        this.#options = options;
+    }
+
+    /**
+     * @return {string}
+     */
+    getKey() {
+        return this.#key;
+    }
+
+    /**
+     * @return {string}
+     */
+    getLabel() {
+        return this.#label;
+    }
+
+    /**
+     * @return {string}
+     */
+    getType() {
+        return this.#type;
+    }
+
+    /**
+     * @return {ConfigOptionValue}
+     */
+    getValue() {
+        return this.#value;
+    }
+
+    /**
+     * @param {ConfigOptionValue} value
+     * @return {ConfigOption}
+     */
+    setValue(value) {
+        this.#value = value;
+        return this;
+    }
+
+    /**
+     * @return {string[]|null}
+     */
+    getOptions() {
+        return this.#options;
+    }
+}
+
+module.exports = ConfigOption;

package/src/Server/Config/ConfigOptionType.js

@@ -0,0 +1,13 @@
+/**
+ * @enum {string}
+ */
+class ConfigOptionType {
+    static STRING = "string";
+    static INTEGER = "number";
+    static FLOAT = "float";
+    static BOOLEAN = "boolean";
+    static MULTI_SELECT = "multiselect";
+    static SELECT = "select";
+}
+
+module.exports = ConfigOptionType;

package/src/Server/File.js

@@ -3,6 +3,7 @@ const GetFileDataRequest = require("../Request/Server/Files/GetFileDataRequest")
 const PutFileDataRequest = require("../Request/Server/Files/PutFileDataRequest");
 const DeleteFileDataRequest = require("../Request/Server/Files/DeleteFileDataRequest");
 const CreateDirectoryRequest = require("../Request/Server/Files/CreateDirectoryRequest");
+const Config = require("./Config/Config");
 
 class File {
     /**
@@ -60,15 +61,20 @@ class File {
     children = null;
 
     /**
-     * @type {{Server}}
+     * @type {Server}
      */
     #server;
 
     /**
-     * @type {{Client}}
+     * @type {Client}
      */
     #client;
 
+    /**
+     * @type {Config|null}
+     */
+    #config = null;
+
     /**
      * @param {string|null} path
      */
@@ -113,7 +119,7 @@ class File {
     /**
      * Set the server
      *
-     * @param server
+     * @param {Server} server
      * @returns {this}
      */
     setServer(server) {
@@ -129,7 +135,7 @@ class File {
     /**
      * Set the API client
      *
-     * @param client
+     * @param {Client} client
      * @returns {this}
      */
     setClient(client) {
@@ -142,6 +148,20 @@ class File {
         return this;
     }
 
+    /**
+     * @return {Client}
+     */
+    getClient() {
+        return this.#client;
+    }
+
+    /**
+     * @return {Server}
+     */
+    getServer() {
+        return this.#server;
+    }
+
     /**
      * Get file information from the API
      *
@@ -251,6 +271,19 @@ class File {
 
         return this.children;
     }
+
+    /**
+     * Get Config object for this file
+     * Only available if the file is a config file
+     *
+     * @return {Config}
+     */
+    getConfig() {
+        if (this.#config === null) {
+            this.#config = new Config(this);
+        }
+        return this.#config;
+    }
 }
 
-module.exports = File;
+module.exports = File;