@unitn-asa/deliveroo-js-sdk 1.2.1

package/src/client/DjsRestClient.js

@@ -0,0 +1,432 @@
+
+/**
+ * @typedef {import("../types/IOAgent.js").IOAgent} IOAgent
+ * @typedef {import("../types/IOParcel.js").IOParcel} IOParcel
+ * @typedef {import("../types/IOConfig.js").IOConfig} IOConfig
+ */
+
+
+
+/**
+ * @typedef {{
+ *      'agents': () => IOAgent[],
+ *      'agents/:id': () => IOAgent,
+ *      'configs': () => IOConfig,
+ *      'levels': () => IOConfig[],
+ *      'level': () => IOConfig,
+ *      'maps': () => any[],
+ *      'map': () => any,
+ *      'npcs': () => any[],
+ *      'npc': () => any,
+ *      'parcels': () => IOParcel[],
+ *      'parcel': () => IOParcel,
+ * }} IODeliveroojsGETRoutes
+ */
+
+/**
+ * @typedef {{
+ *      'agents': (body: IOAgent) => IOAgent,
+ *      'levels': (body: IOConfig) => IOConfig,
+ *      'maps': (body: any) => IOConfig,
+ *      'npcs': (body: any) => {},
+ *      'parcels': (body: IOParcel) => IOParcel,
+ * }} IODeliveroojsPOSTRoutes
+ */
+
+/**
+ * @typedef {{
+ *      'agents': () => IOAgent[],
+ *      'agents/:id': () => IOAgent,
+ *      'npcs': () => any[],
+ *      'npc': (id: string) => any,
+ *      'parcels': () => IOParcel[],
+ *      'parcel': (id: string) => IOParcel,
+ * }} IODeliveroojsDELETERoutes
+ */
+
+
+
+/**
+ * @class
+ */
+export class DjsRestClient {
+
+
+
+    /** @type {string} */
+    #HOST = 'http://localhost:8080';
+    /** @type {string} */
+    get HOST() { return this.#HOST }
+
+
+
+    /**
+     * Initialize HOST for API calls.
+     * @param {string} HOST
+     */
+    constructor( HOST ) {
+        this.#HOST = HOST;
+        console.log("DjsRestClient (API RESTful Client) initialized with HOST:", this.HOST);
+    }
+
+
+
+    /**
+     * @template { keyof IODeliveroojsGETRoutes } K
+     * @param { K } resource
+     * @param { string } token
+     * @returns {Promise<ReturnType<IODeliveroojsGETRoutes[K][]>>}
+     */
+    async getAll ( resource, token ) {
+
+        return new Promise( (resolve, reject) => {
+
+            const url = this.HOST+'/api/'+resource;
+
+            console.log( 'GET', url );
+
+            fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            
+            .then( JSON.stringify )
+            
+            .then( body => resolve( /** @type {any} */ (body)) )
+            
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error getting config');
+            });
+
+        } );
+    }
+
+
+
+    /**
+     * @template { keyof IODeliveroojsGETRoutes } K
+     * @param { K } resource
+     * @param { string } id
+     * @param { string } token
+     * @returns {Promise<ReturnType<IODeliveroojsGETRoutes[K]>>}
+     */
+    async get ( resource, id, token ) {
+
+        return new Promise( (resolve, reject) => {
+
+            // replace placeholder ':id' with value of id in string resource
+            const url = this.HOST+'/api/'+resource.replace( ':id', id );
+
+            console.log( 'GET', url );
+
+            fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            
+            .then( JSON.stringify )
+            
+            .then( body => resolve( /** @type {any} */ (body)) )
+            
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error getting config');
+            });
+
+        } );
+
+    }
+
+
+
+    /**
+     * @template { keyof IODeliveroojsPOSTRoutes } K
+     * @param { K } resource
+     * @param { string } token
+     * @param { Parameters<IODeliveroojsPOSTRoutes[K]>[0] } body
+     * @returns {Promise<ReturnType<IODeliveroojsPOSTRoutes[K]>>}
+     */
+    async post ( resource, token, body ) {
+
+        return new Promise( (resolve, reject) => {
+
+            const url = this.HOST+'/api/'+resource;
+            
+            console.log( 'POST', url, body );
+
+            fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                },
+                body: JSON.stringify( body )
+            })
+            
+            .then( JSON.stringify )
+            
+            .then( body => resolve( /** @type {any} */ (body)) )
+            
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error getting config');
+            });
+
+        } );
+
+    }
+
+
+
+    async getToken(name, team, password) {
+        return new Promise((resolve, reject) => {
+
+            console.log("Name fetch: ", name + " team fetch: ", team);
+
+            fetch(this.HOST+'/api/tokens', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'name': name,
+                    'team': team,
+                    'password': password
+                }
+            })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                }
+                throw new Error(`Error generating token, Status code: ${response.status}`);
+            })
+            .then(data => {
+                console.log("token ottenuto: " + data.token.slice(-30));
+                resolve(data);
+            })
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('No tokens available at the moment');
+            });
+        });
+    }
+
+
+
+    async getConfig ( token ) {
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/configs', {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            .then( JSON.stringify )
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error getting config');
+            });
+        });
+    }
+
+
+
+    /**
+     * 
+     * @param {string} token 
+     * @param {{}} config 
+     * @returns 
+     */
+    async patchConfig ( token, config ) {
+
+        console.log( "Patching config: ", config );
+
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/configs', {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                },
+                body: JSON.stringify(config)
+            })
+            // parsing response
+            .then( JSON.stringify )
+            // .then( response => {
+            //     console.log("config patched: " + response);
+            //     for ( let [key,value] of Object.entries(response) ) {
+            //         settings[key] = value;
+            //     }
+            //     resolve(settings);
+            // })
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error patching config');
+            });
+        });
+    }
+
+
+
+    /**
+     * @param {string} token
+     * @param {string} id 
+     * @returns 
+     */
+    async deleteAgent ( token, id ) {
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/agents/'+id, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                }
+                throw new Error(`Error deleting agent, Status code: ${response.status}`);
+            })
+            .then(data => {
+                console.log("agent deleted: " + data);
+                resolve(data);
+            })
+            .catch(error => {
+                console.error('An error occurred:', error);
+                reject('Error deleting agent');
+            });
+        });
+    }
+
+
+
+    /**
+     * @param {string} token 
+     * @param {string} id 
+     * @param {{score?:number, penalty?:number}} agent
+     * @returns 
+     */
+    async patchAgent ( token, id, agent ) {
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/agents/'+id, {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                },
+                body: JSON.stringify(agent)
+            })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                }
+                throw new Error(`Error patching agent, Status code: ${response.status}`);
+            })
+            .then(data => {
+                console.log("agent patched: " + data);
+                resolve(data);
+            })
+            .catch(error => {
+                console.warn('An error occurred:', error);
+                reject('Error patching agent');
+            });
+        });
+    }
+
+
+
+    /**
+     * 
+     * @param {string} token
+     * @param {string} id
+     * @returns
+     */
+    async deleteParcel( token, id ) {
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/parcels/'+id, {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                }
+                throw new Error(`Error deleting parcel, Status code: ${response.status}`);
+            })
+            .then(data => {
+                console.log("parcel deleted: " + data);
+                resolve(data);
+            })
+            .catch(error => {
+                console.warn('An error occurred:', error);
+                reject('Error deleting parcel');
+            });
+        });
+    }
+
+
+
+    /**
+     * Delete all parcels from the grid.
+     * @param {*} token 
+     */
+    async deleteAllParcels( token ) {
+        return new Promise((resolve, reject) => {
+            fetch(this.HOST+'/api/parcels', {
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-token': token
+                }
+            })
+            .then(response => {
+                if (response.ok) {
+                    return response.json();
+                }
+                else {
+                    throw new Error(`Error deleting all parcels, Status code: ${response.status}`);
+                }
+            })
+            .then(data => {
+                console.log("all parcels deleted: " + data);
+                resolve(data);
+            })
+            .catch(error => {
+                console.warn('An error occurred:', error);
+                reject('Error deleting all parcels');
+            });
+        });
+    }
+
+
+
+}
+
+
+
+// Example usage:
+// 
+// const api = new DeliveroojsRestClient('http://localhost:8080');
+// api.get('agents', '', 'some-token').then( agents => console.log( agents ) );
+// api.get('agents/:id', 'some-id', 'some-token').then( agent => console.log( agent ) );
+// api.post('agents', 'some-token', {
+//     id: 'agent-123',
+//     name: 'Agent 123',
+//     teamId: 'team-1',
+//     teamName: 'Team 1',
+//     score: 0,
+//     penalty: 0,
+//     x: 0,
+//     y: 0
+// } )
+// .then( agent => console.log( agent ) );

package/src/client/connectUtil.js

@@ -0,0 +1,51 @@
+import { io } from "socket.io-client";
+import { default as argsparser } from "args-parser";
+import { DjsClientSocket } from "./DjsClientSocket.js";
+
+
+
+/**
+ * Takes the following arguments from console:
+ * token or name
+ * e.g:
+ * $ node index.js -token=... -name=marco
+ * $ npm start -- -token=... -name=marco
+ */
+const args = argsparser(process? process?.argv : []);
+
+
+
+/**
+ * @returns { DjsClientSocket }
+ */
+export function connect ( host, token = args['token'], name = args['name'], autoconnect = true ) {
+
+    let opts = {
+        autoConnect: false,
+        withCredentials: false,
+        // extraHeaders: { 'x-token': TOKEN || token }
+        // query: { name: NAME }
+        // path: '/'
+    };
+    if ( token && token != '' )
+        opts.extraHeaders = { 'x-token': token }
+    else if ( name && name != '' )
+        opts.query = { name: name }
+
+    const enhancedClientSocket = DjsClientSocket.enhance( io( host, opts ) );
+    
+    if ( autoconnect )
+        enhancedClientSocket.connect();
+
+    console.log( `Connecting to ${host} as ${ token ? 'token '+ (token).substring(0,5)+'...' : name ? 'name '+name : 'guest' }` );
+
+    return enhancedClientSocket;
+
+}
+
+
+
+// Example usage:
+//
+// const socket = connect( 'http://localhost:8080', 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjczZDZkOSIsIm5hbWUiOiJub21lX21vbHRvX2x1bmdvXzEiLCJ0ZWFtSWQiOiIyNDc0ZDkiLCJ0ZWFtTmFtZSI6Im5vbWVfdGVhbV9tb2x0b19sdW5nbyIsInJvbGUiOiJ1c2VyIiwiaWF0IjoxNzQ4MzUxOTM3fQ.rhEHyAoaQhqVqhEJ5bqyu3UdcvJWK5RLWKJxkBDAX_0', true );
+// socket.emitMove( 'up' );

package/src/client/index.js

@@ -0,0 +1,21 @@
+
+/**
+ * @typedef {import("../types/IOConfig.js").IOConfig} IOConfig
+ * @typedef {import("../types/IOGameOptions.js").IOGameOptions} IOGameOptions
+ * 
+ * @typedef {import("../types/IOClockEvent.js").IOClockEvent} IOClockEvent
+ * 
+ * @typedef {import("../types/IOAgent.js").IOAgent} IOAgent
+ * @typedef {import("../types/IOParcel.js").IOParcel} IOParcel
+ * @typedef {import("../types/IOTile.js").IOTile} IOTile
+ * 
+ * @typedef {import("../types/IOIdentity.js").IOIdentity} IOIdentity
+ * @typedef {import("../types/IOInfo.js").IOInfo} IOInfo
+ * @typedef {import("../types/IOSensing.js").IOSensing} IOSensing
+ * 
+ * @typedef {import("../types/IOSocketEvents.js").IOClientEvents} IOClientEvents
+ * @typedef {import("../types/IOSocketEvents.js").IOServerEvents} IOServerEvents
+ */
+
+export { DjsClientSocket } from './DjsClientSocket.js';
+export { DjsRestClient } from './DjsRestClient.js';

package/src/server/DjsServer.js

@@ -0,0 +1,136 @@
+import { Server } from 'socket.io';
+import { DjsServerSocket } from './DjsServerSocket.js';
+
+/**
+ * @typedef {import("../types/IOAgent.js").IOAgent} IOAgent
+ * @typedef {import("../types/IOParcel.js").IOParcel} IOParcel
+ * @typedef {import("../types/IOTile.js").IOTile} IOTile
+ * @typedef {import("../types/IOConfig.js").IOConfig} IOConfig
+ * @typedef {import("../types/IOInfo.js").IOInfo} IOInfo
+ *
+ * @typedef {import("../types/IOSocketEvents.js").IOSensing} IOSensing
+ * @typedef {import("../types/IOSocketEvents.js").IOClientEvents} IOClientEvents on the client side these are to be emitted with .emit
+ * @typedef {import("../types/IOSocketEvents.js").IOServerEvents} IOServerEvents on the client side these are to be listened with .on
+ */
+
+/**
+ * @class
+ * @extends { Server<IOClientEvents, IOServerEvents> }
+ */
+export class DjsServer extends Server {
+
+    /**
+     * Broadcast config to all connected clients
+     * @param { IOConfig } config
+     */
+    broadcastConfig(config) {
+        this.emit('config', config);
+    }
+
+    /**
+     * Broadcast map to all connected clients
+     * @param { number } width
+     * @param { number } height
+     * @param { IOTile[] } tiles
+     */
+    broadcastMap(width, height, tiles) {
+        this.emit('map', width, height, tiles);
+    }
+
+    /**
+     * Broadcast a tile update to all connected clients
+     * @param { IOTile } tile
+     * @param { IOInfo } info
+     */
+    broadcastTile({ x, y, type }, info) {
+        this.emit('tile', { x, y, type }, info);
+    }
+
+    /**
+     * Broadcast controller status (agent connected/disconnected) to all clients
+     * @param { 'connected' | 'disconnected' } status
+     * @param { Parameters<IOServerEvents['controller']>[1] } agent
+     */
+    broadcastController(status, { id, name, teamId, teamName, score }) {
+        this.emit('controller', status, { id, name, teamId, teamName, score });
+    }
+
+    /**
+     * Broadcast a message to all connected clients
+     * @param { string } fromId
+     * @param { string } fromName
+     * @param { any } msg
+     */
+    broadcastMessage(fromId, fromName, msg) {
+        this.emit('msg', fromId, fromName, msg);
+    }
+
+    /**
+     * Broadcast a log message to all connected clients
+     * @param { 'server' | { socket:string, id:string, name:string } } src - 'server' or client
+     * @param { IOInfo } info
+     * @param { ...any } message
+     */
+    broadcastLog(src, info, ...message) {
+        this.emit('log', src, info, ...message);
+    }
+
+    // /**
+    //  * Get all sockets in a room
+    //  * @param { string } roomName
+    //  * @returns { Promise<import('./DjsServerSocket.js').DjsServerSocket[]> }
+    //  */
+    // async fetchSocketsInRoom(roomName) {
+    //     const sockets = await this.in(roomName).fetchSockets();
+    //     return sockets.forEach(s => DjsServerSocket.enhance(s));
+    // }
+
+    // /**
+    //  * Count sockets in a room
+    //  * @param { string } roomName
+    //  * @returns { Promise<number> }
+    //  */
+    // async countSocketsInRoom(roomName) {
+    //     const sockets = await this.fetchSocketsInRoom(roomName);
+    //     return sockets.length;
+    // }
+
+    // /**
+    //  * Emit to all sockets in a specific room
+    //  * @param { string } roomName
+    //  * @param { string } event
+    //  * @param { ...any } args
+    //  */
+    // emitToRoom(roomName, event, ...args) {
+    //     this.to(roomName).emit(event, ...args);
+    // }
+
+    /**
+     * Enhance a Socket.io Server into a DjsServer
+     * @param { Server } server
+     * @returns { DjsServer }
+     */
+    static enhance(server) {
+        /**
+         * Mixin function to copy methods from a class prototype to an object
+         */
+        function applyMixin(target, MixinClass) {
+            let proto = MixinClass.prototype;
+
+            const descriptors = Object.getOwnPropertyDescriptors(proto);
+            delete descriptors.constructor;
+
+            Object.defineProperties(target, descriptors);
+
+            return target;
+        }
+        applyMixin(server, DjsServer);
+
+        /**
+         * Original server enhanced with DjsServer methods
+         * @type { DjsServer }
+         */
+        // @ts-ignore
+        return server;
+    }
+}