mastodon.js

// mastodon javascript lib
// by @kirschn@pleasehug.me 2017
// no fucking copyright
// do whatever you want with it
// but please don't hurt it (and keep this header)


var MastodonAPI = function (config) {
	var apiBase = config.instance + "/api/v1/";

	function checkArgs(args) {
		var checkedArgs;
		if (typeof args[1] === "function") {
			checkedArgs = {
				data: {},
				callback: args[1]
			};
		} else {
			checkedArgs = {
				data: args[1],
				callback: args[2]
			};
		}

		return checkedArgs;
	}

	function addAuthorizationHeader(headers, token) {
		if (token) {
			headers.Authorization = "Bearer " + token;
		}

		return headers;
	}

	function onAjaxSuccess(url, op, callback, logData) {
		return function (data, textStatus, xhr) {
			console.log("Successful " + op + " API request to " + url,
				", status: " + textStatus,
				", HTTP status: " + xhr.status,
				", data: " + (logData ? JSON.stringify(data) : "<skipped>"));

			if (typeof callback !== "undefined") {
				callback(data, textStatus);
			}
		};
	}

	function onAjaxError(url, op) {
		return function (xhr, textStatus, errorThrown) {
			console.error("Failed " + op + " API request to " + url,
				", status: " + textStatus,
				", error: " + errorThrown,
				", HTTP status: " + xhr.status,
				", response JSON: " + JSON.stringify(xhr.responseJSON));
		};
	}

	return {
		setConfig: function (key, value) {
			// modify initial config afterwards
			config[key] = value;
		},
		getConfig: function (key) {
			// get config key
			return config[key];
		},
		get: function (endpoint) {
			// for GET API calls
			// can be called with two or three parameters
			// endpoint, callback
			// or
			// endpoint, queryData, callback
			// where queryData is an object { paramname1: "paramvalue1", paramname2: paramvalue2 }

			var args = checkArgs(arguments);
			var queryData = args.data;
			var callback = args.callback;
			var url = apiBase + endpoint;

			// ajax function
			return $.ajax({
				url: url,
				type: "GET",
				data: queryData,
				headers: addAuthorizationHeader({}, config.api_user_token),
				success: onAjaxSuccess(url, "GET", callback, false),
				error: onAjaxError(url, "GET")
			});
		},
		post: function (endpoint) {
			// for POST API calls
			var args = checkArgs(arguments);
			var postData = args.data;
			var callback = args.callback;
			var url = apiBase + endpoint;

			return $.ajax({
				url: url,
				type: "POST",
				data: postData,
				headers: addAuthorizationHeader({}, config.api_user_token),
				success: onAjaxSuccess(url, "POST", callback, false),
				error: onAjaxError(url, "POST")
			});
		},
		postMedia: function (endpoint) {
			// for POST API calls
			var args = checkArgs(arguments);
			var postData = args.data;
			var callback = args.callback;
			var url = apiBase + endpoint;

			return $.ajax({
				url: url,
				type: "POST",
				data: postData,
				contentType: false,
				processData: false,
				headers: addAuthorizationHeader({}, config.api_user_token),
				success: onAjaxSuccess(url, "POST MEDIA", callback, false),
				error: onAjaxError(url, "POST MEDIA")
			});
		},
		delete: function (endpoint, callback) {
			// for DELETE API calls.
			var url = apiBase + endpoint;
			return $.ajax({
				url: url,
				type: "DELETE",
				headers: addAuthorizationHeader({}, config.api_user_token),
				success: onAjaxSuccess(url, "DELETE", callback, false),
				error: onAjaxError(url, "DELETE")
			});
		},
		stream: function (streamType, onData) {
			// Event Stream Support
			// websocket streaming is undocumented. i had to reverse engineer the fucking web client.
			// streamType is either
			// user for your local home TL and notifications
			// public for your federated TL
			// public:local for your home TL
			// hashtag&tag=fuckdonaldtrump for the stream of #fuckdonaldtrump
			// callback gets called whenever new data ist recieved
			// callback { event: (eventtype), payload: {mastodon object as described in the api docs} }
			// eventtype could be notification (=notification) or update (= new toot in TL)
			var es = new WebSocket("wss://" + apiBase.substr(8) +
				"streaming?access_token=" + config.api_user_token + "&stream=" + streamType);
			var listener = function (event) {
				console.log("Got Data from Stream " + streamType);
				event = JSON.parse(event.data);
				event.payload = JSON.parse(event.payload);
				onData(event);
			};
			es.onmessage = listener;
		},
		registerApplication: function (client_name, redirect_uri, scopes, website, callback) {
			// register a new application

			// OAuth Auth flow:
			// First register the application
			// 2) get a access code from a user (using the link, generation function below!)
			// 3) insert the data you got from the application and the code from the user into
			// getAccessTokenFromAuthCode. Note: scopes has to be an array, every time!
			// For example ["read", "write"]

			// determine which parameters we got
			if (website === null) {
				website = "";
			}
			// build scope array to string for the api request
			if (typeof scopes !== "string") {
				scopes = scopes.join(" ");
			}
			var url = apiBase + "apps";
			return $.ajax({
				url: url,
				type: "POST",
				data: {
					client_name: client_name,
					redirect_uris: redirect_uri,
					scopes: scopes,
					website: website
				},
				success: onAjaxSuccess(url, "REGISTER", callback, true),
				error: onAjaxError(url, "REGISTER")
			});
		},
		generateAuthLink: function (client_id, redirect_uri, responseType, scopes) {
			return config.instance + "/oauth/authorize?client_id=" + client_id + "&redirect_uri=" + redirect_uri +
				"&response_type=" + responseType + "&scope=" + scopes.join("+");
		},
		getAccessTokenFromAuthCode: function (client_id, client_secret, redirect_uri, code, callback) {
			var url = config.instance + "/oauth/token";
			return $.ajax({
				url: url,
				type: "POST",
				data: {
					client_id: client_id,
					client_secret: client_secret,
					redirect_uri: redirect_uri,
					grant_type: "authorization_code",
					code: code
				},
				success: onAjaxSuccess(url, "TOKEN", callback, true),
				error: onAjaxError(url, "TOKEN")
			});
		}
	};
};

// node.js
if (typeof module !== "undefined") {
	module.exports = MastodonAPI;
}