initial

src/client/Client.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const EventEmitter = require('events').EventEmitter;
+const MergeDefault = require('../util/MergeDefault');
+const Constants = require('../util/Constants');
+const RESTManager = require('./rest/RestManager');
+const ClientDataStore = require('../structures/DataStore/ClientDataStore');
+const ClientManager = require('./ClientManager');
+const WebSocketManager = require('./websocket/WebSocketManager');
+
+class Client extends EventEmitter{
+
+	constructor(options) {
+		super();
+		this.options = MergeDefault(Constants.DefaultOptions, options);
+		this.rest = new RESTManager(this);
+		this.store = new ClientDataStore(this);
+		this.manager = new ClientManager(this);
+		this.ws = new WebSocketManager(this);
+	}
+
+	login(email, password) {
+		if (password) {
+			// login with email and password
+			return this.rest.methods.LoginEmailPassword(email, password);
+		} else {
+			// login with token
+			return this.rest.methods.LoginToken(email);
+		}
+	}
+
+}
+
+module.exports = Client;

src/client/ClientManager.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const Constants = require('../util/Constants');
+
+class ClientManager {
+
+	constructor(client) {
+		this.client = client;
+		this.heartbeatInterval = null;
+	}
+
+	connectToWebSocket(token, resolve, reject) {
+		this.client.store.token = token;
+		this.client.rest.methods.GetGateway()
+			.then(gateway => {
+				this.client.ws.connect(gateway);
+				this.client.once(Constants.Events.READY, () => resolve(token));
+			})
+			.catch(reject);
+
+		setTimeout(() => reject(Constants.Errors.TOOK_TOO_LONG), 1000 * 15);
+	}
+
+	setupKeepAlive(time) {
+		this.heartbeatInterval = setInterval(() => {
+			this.client.ws.send({
+				op: Constants.OPCodes.HEARTBEAT,
+				d: Date.now(),
+			});
+		}, time);
+	}
+}
+
+module.exports = ClientManager;

src/client/rest/RESTManager.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const request = require('superagent');
+const Constants = require('../../util/Constants');
+const UserAgentManager = require('./UserAgentManager');
+const RESTMethods = require('./RESTMethods');
+
+class RESTManager{
+
+	constructor(client) {
+		this.client = client;
+		this.queue = [];
+		this.userAgentManager = new UserAgentManager(this);
+		this.methods = new RESTMethods(this);
+	}
+
+	makeRequest(method, url, auth, data, file) {
+		/*
+			file is {file, name}
+		 */
+		let apiRequest = request[method](url);
+
+		if (auth) {
+			if (this.client.store.token) {
+				apiRequest.set('authorization', this.client.store.token);
+			} else {
+				throw Constants.Errors.NO_TOKEN;
+			}
+		}
+
+		if (data) {
+			apiRequest.send(data);
+		}
+
+		if (file) {
+			apiRequest.attach('file', file.file, file.name);
+		}
+
+		apiRequest.set('User-Agent', this.userAgentManager.userAgent);
+
+		return new Promise((resolve, reject) => {
+			apiRequest.end((err, res) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(res ? res.body || {} : {});
+				}
+			});
+		});
+	}
+};
+
+module.exports = RESTManager;

src/client/rest/RESTMethods.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const Constants = require('../../util/Constants');
+
+class RESTMethods{
+	constructor(restManager) {
+		this.rest = restManager;
+	}
+
+	LoginEmailPassword(email, password) {
+		return new Promise((resolve, reject) => {
+
+			this.rest.makeRequest('post', Constants.Endpoints.LOGIN, false, { email, password })
+				.then(data => {
+					this.rest.client.manager.connectToWebSocket(data.token, resolve, reject);
+				})
+				.catch(reject);
+
+		});
+	}
+
+	LoginToken(token) {
+		return new Promise((resolve, reject) => {
+			this.rest.client.manager.connectToWebSocket(token, resolve, reject);
+		});
+	}
+
+	GetGateway() {
+		return new Promise((resolve, reject) => {
+			this.rest.makeRequest('get', Constants.Endpoints.GATEWAY, true)
+				.then(res => resolve(res.url))
+				.catch(reject);
+		});
+	}
+}
+
+module.exports = RESTMethods;

src/client/rest/UserAgentManager.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Constants = require('../../util/Constants');
+
+class UserAgentManager{
+	constructor(restManager) {
+		this.restManager = restManager;
+		this._userAgent = {
+			url: 'https://github.com/hydrabolt/discord.js',
+			version: Constants.Package.version,
+		};
+	}
+
+	set(info) {
+		this._userAgent.url = info.url || 'https://github.com/hydrabolt/discord.js';
+		this._userAgent.version = info.version || Constants.Package.version;
+	}
+
+	get userAgent() {
+		return `DiscordBot (${this._userAgent.url}, ${this._userAgent.version})`;
+	}
+}
+
+module.exports = UserAgentManager;

src/client/websocket/WebSocketManager.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const WebSocket = require('ws');
+const Constants = require('../../util/Constants');
+const zlib = require('zlib');
+const PacketManager = require('./packets/WebSocketPacketManager');
+
+class WebSocketManager {
+
+	constructor(client) {
+		this.client = client;
+		this.ws = null;
+		this.packetManager = new PacketManager(this);
+		this.emittedReady = false;
+	}
+
+	connect(gateway) {
+		gateway += `/?v=${this.client.options.protocol_version}`;
+		this.ws = new WebSocket(gateway);
+		this.ws.onopen = () => this.EventOpen();
+		this.ws.onclose = () => this.EventClose();
+		this.ws.onmessage = (e) => this.EventMessage(e);
+		this.ws.onerror = (e) => this.EventError(e);
+	}
+
+	send(data) {
+		this.ws.send(JSON.stringify(data));
+	}
+
+	EventOpen() {
+		let payload = this.client.options.ws;
+		payload.token = this.client.store.token;
+
+		this.send({
+			op: Constants.OPCodes.IDENTIFY,
+			d: payload,
+		});
+	}
+
+	EventClose() {
+
+	}
+
+	EventMessage(event) {
+		let packet;
+		try {
+			if (event.binary) {
+				event.data = zlib.inflateSync(event.data).toString();
+			}
+
+			packet = JSON.parse(event.data);
+		} catch (e) {
+			return this.EventError(Constants.Errors.BAD_WS_MESSAGE);
+		}
+
+		this.packetManager.handle(packet);
+	}
+
+	EventError(e) {
+
+	}
+
+	checkIfReady() {
+		if (!this.emittedReady) {
+			let unavailableCount = 0;
+
+			for (let guildID in this.client.store.data.guilds) {
+				unavailableCount += this.client.store.data.guilds[guildID].available ? 0 : 1;
+			}
+
+			if (unavailableCount === 0) {
+				this.client.emit(Constants.Events.READY);
+				this.emittedReady = true;
+			}
+		}
+	}
+}
+
+module.exports = WebSocketManager;

src/client/websocket/packets/WebSocketPacketManager.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const Constants = require('../../../util/Constants');
+
+class WebSocketPacketManager {
+
+	constructor(websocketManager) {
+		this.ws = websocketManager;
+		this.handlers = {};
+
+		this.register(Constants.WSEvents.READY, 'Ready');
+		this.register(Constants.WSEvents.GUILD_CREATE, 'GuildCreate');
+		this.register(Constants.WSEvents.GUILD_DELETE, 'GuildDelete');
+		this.register(Constants.WSEvents.GUILD_UPDATE, 'GuildUpdate');
+		this.register(Constants.WSEvents.GUILD_BAN_ADD, 'GuildBanAdd');
+		this.register(Constants.WSEvents.GUILD_BAN_REMOVE, 'GuildBanRemove');
+		this.register(Constants.WSEvents.GUILD_MEMBER_ADD, 'GuildMemberAdd');
+		this.register(Constants.WSEvents.GUILD_MEMBER_REMOVE, 'GuildMemberRemove');
+		this.register(Constants.WSEvents.GUILD_MEMBER_UPDATE, 'GuildMemberUpdate');
+		this.register(Constants.WSEvents.CHANNEL_CREATE, 'ChannelCreate');
+		this.register(Constants.WSEvents.CHANNEL_DELETE, 'ChannelDelete');
+		this.register(Constants.WSEvents.CHANNEL_UPDATE, 'ChannelUpdate');
+	}
+
+	get client() {
+		return this.ws.client;
+	}
+
+	register(event, handle) {
+		let Handler = require(`./handlers/${handle}`);
+		this.handlers[event] = new Handler(this);
+	}
+
+	handle(packet) {
+		if (this.handlers[packet.t]) {
+			return this.handlers[packet.t].handle(packet);
+		}
+
+		return false;
+	}
+
+}
+
+module.exports = WebSocketPacketManager;

src/client/websocket/packets/handlers/AbstractHandler.js

@@ -0,0 +1,14 @@
+'use strict';
+
+class AbstractHandler {
+
+	constructor(packetManager) {
+		this.packetManager = packetManager;
+	}
+
+	handle(packet) {
+
+	}
+}
+
+module.exports = AbstractHandler;

src/client/websocket/packets/handlers/ChannelCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const DMChannel = Structure('DMChannel');
+
+const Constants = require('../../../../util/Constants');
+
+class ChannelCreateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.NewChannel(data);
+
+	}
+
+};
+
+module.exports = ChannelCreateHandler;

src/client/websocket/packets/handlers/ChannelDelete.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const ServerChannel = Structure('ServerChannel');
+
+const Constants = require('../../../../util/Constants');
+
+class ChannelDeleteHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.get('channels', data.id);
+
+		if (channel) {
+			client.store.KillChannel(channel);
+		}
+	}
+
+};
+
+module.exports = ChannelDeleteHandler;

src/client/websocket/packets/handlers/ChannelUpdate.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const ServerChannel = Structure('ServerChannel');
+
+const Constants = require('../../../../util/Constants');
+const CloneObject = require('../../../../util/CloneObject');
+
+class ChannelUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.get('channels', data.id);
+
+		if (channel) {
+			client.store.UpdateChannel(channel, data);
+		}
+
+	}
+
+};
+
+module.exports = ChannelUpdateHandler;

src/client/websocket/packets/handlers/GuildBanAdd.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildBanAddHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			client.emit(Constants.Events.GUILD_BAN_ADD, guild, user);
+		}
+	}
+
+};
+
+module.exports = GuildBanAddHandler;

src/client/websocket/packets/handlers/GuildBanRemove.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildBanRemoveHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			client.emit(Constants.Events.GUILD_BAN_REMOVE, guild, user);
+		}
+	}
+
+};
+
+module.exports = GuildBanRemoveHandler;

src/client/websocket/packets/handlers/GuildCreate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildCreateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			if (!guild.available && !data.unavailable) {
+				// a newly available guild
+				guild.setup(data);
+				this.packetManager.ws.checkIfReady();
+			}
+		} else {
+			// a new guild
+			client.store.NewGuild(data);
+		}
+
+	}
+
+};
+
+module.exports = GuildCreateHandler;

src/client/websocket/packets/handlers/GuildDelete.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildDeleteHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			if (guild.available && data.unavailable) {
+				// guild is unavailable
+				guild.available = false;
+				client.emit(Constants.Events.GUILD_UNAVAILABLE, guild);
+			} else {
+				// delete guild
+				client.store.KillGuild(guild);
+			}
+		} else {
+			// it's not there! :(
+			client.emit('warn', 'guild deleted but not cached in first place. missed packet?');
+		}
+
+	}
+
+};
+
+module.exports = GuildDeleteHandler;

src/client/websocket/packets/handlers/GuildMemberAdd.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberAddHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+
+		if (guild) {
+			guild._addMember(data);
+		}
+	}
+
+};
+
+module.exports = GuildMemberAddHandler;

src/client/websocket/packets/handlers/GuildMemberRemove.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberRemoveHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			guild._removeMember(user);
+		}
+	}
+
+};
+
+module.exports = GuildMemberRemoveHandler;

src/client/websocket/packets/handlers/GuildMemberUpdate.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild) {
+			guild._updateMember(user, data);
+		}
+	}
+
+};
+
+module.exports = GuildMemberUpdateHandler;

src/client/websocket/packets/handlers/GuildUpdate.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+const CloneObject = require('../../../../util/CloneObject');
+
+class GuildUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			client.store.UpdateGuild(guild, data);
+		}
+
+	}
+
+};
+
+module.exports = GuildUpdateHandler;

src/client/websocket/packets/handlers/Ready.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const DMChannel = Structure('DMChannel');
+
+class ReadyHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		client.manager.setupKeepAlive(data.heartbeat_interval);
+
+		client.store.user = client.store.add('users', new ClientUser(client, data.user));
+
+		for (let guild of data.guilds) {
+			client.store.NewGuild(guild);
+		}
+
+		for (let privateDM of data.private_channels) {
+			client.store.NewChannel(privateDM);
+		}
+
+	}
+
+};
+
+module.exports = ReadyHandler;