Adds Hooks API

Adds Parse.Hooks.js in src/cloud-code/Parse.Hooks.js
Moves Cloud code related functions in src/cloud-code

src/cloud-code/Parse.Cloud.js

@@ -0,0 +1,51 @@
+var Parse = require("parse/node");
+var triggers = require("../triggers");
+
+function validateClassNameForTriggers(className) {
+  const restrictedClassNames = [ '_Session' ];
+  if (restrictedClassNames.indexOf(className) != -1) {
+    throw `Triggers are not supported for ${className} class.`;
+  }
+  return className;
+}
+
+function getClassName(parseClass) {
+  if (parseClass && parseClass.className) {
+    return validateClassNameForTriggers(parseClass.className);
+  }
+  return validateClassNameForTriggers(parseClass);
+}
+
+var ParseCloud = {};
+ParseCloud.define = function(functionName, handler, validationHandler) {
+  triggers.addFunction(functionName, handler, validationHandler, Parse.applicationId);
+};
+
+ParseCloud.beforeSave = function(parseClass, handler) {
+  var className = getClassName(parseClass);
+  triggers.addTrigger('beforeSave', className, handler, Parse.applicationId);
+};
+
+ParseCloud.beforeDelete = function(parseClass, handler) {
+  var className = getClassName(parseClass);
+  triggers.addTrigger('beforeDelete', className, handler, Parse.applicationId);
+};
+
+ParseCloud.afterSave = function(parseClass, handler) {
+  var className = getClassName(parseClass);
+  triggers.addTrigger('afterSave', className, handler, Parse.applicationId);
+};
+
+ParseCloud.afterDelete = function(parseClass, handler) {
+  var className = getClassName(parseClass);
+  triggers.addTrigger('afterDelete', className, handler, Parse.applicationId);
+};
+  
+ParseCloud._removeHook = function(category, name, type, applicationId) {
+  applicationId = applicationId || Parse.applicationId;
+  triggers._unregister(applicationId, category, name, type);
+};
+
+ParseCloud.httpRequest = require("./httpRequest");
+
+module.exports = ParseCloud;

src/cloud-code/Parse.Hooks.js

@@ -0,0 +1,132 @@
+var request = require("request");
+const send = function(method, path, body) {
+  
+  var Parse = require("parse/node").Parse;
+
+  var options = {
+      method: method,
+      url: Parse.serverURL + path,
+      headers: {
+        'X-Parse-Application-Id': Parse.applicationId,
+        'X-Parse-Master-Key': Parse.masterKey,
+        'Content-Type': 'application/json'
+      },
+  };
+  
+  if (body) {
+    if (typeof body == "object") {
+      options.body = JSON.stringify(body);
+    } else {
+      options.body = body;
+    }
+  }
+  
+  var promise = new Parse.Promise();
+  request(options, function(err, response, body){
+      if (err) {
+          promise.reject(err);
+          return;
+      }
+      body = JSON.parse(body);
+      if (body.error) {
+        promise.reject(body);
+      } else {
+        promise.resolve(body);
+      }
+    });
+    return promise;
+}
+
+var Hooks = {};
+
+Hooks.getFunctions = function() {
+  return Hooks.get("functions");
+}
+
+Hooks.getTriggers = function() {
+  return Hooks.get("triggers");
+}
+
+Hooks.getFunction = function(name) {
+  return Hooks.get("functions", name);
+}
+
+Hooks.getTrigger = function(className, triggerName) {
+  return Hooks.get("triggers", className, triggerName);
+}
+
+Hooks.get = function(type, functionName, triggerName) {
+  var url = "/hooks/"+type;
+  if(functionName) {
+    url += "/"+functionName;
+    if (triggerName) {
+      url += "/"+triggerName;
+    }
+  }
+  return send("GET", url);
+}
+
+Hooks.createFunction = function(functionName, url) {
+  return Hooks.create({functionName: functionName, url: url});
+}
+
+Hooks.createTrigger = function(className, triggerName, url) {
+  return Hooks.create({className: className, triggerName: triggerName, url: url});
+}
+
+Hooks.create = function(hook) {
+  var url;
+  if (hook.functionName && hook.url) {
+      url = "/hooks/functions";
+  } else if (hook.className && hook.triggerName && hook.url) {
+      url = "/hooks/triggers";
+  } else {
+    return Promise.reject({error: 'invalid hook declaration', code: 143});
+  }
+  return send("POST", url, hook);
+}
+
+Hooks.updateFunction = function(functionName, url) {
+  return Hooks.update({functionName: functionName, url: url});
+}
+
+Hooks.updateTrigger = function(className, triggerName, url) {
+  return Hooks.update({className: className, triggerName: triggerName, url: url});
+}
+
+
+Hooks.update = function(hook) {
+  var url;
+  if (hook.functionName && hook.url) {
+      url = "/hooks/functions/"+hook.functionName;
+      delete hook.functionName;
+  } else if (hook.className && hook.triggerName && hook.url) {
+      url = "/hooks/triggers/"+hook.className+"/"+hook.triggerName;
+      delete hook.className;
+      delete hook.triggerName;
+  }
+  return send("PUT", url, hook);
+}
+
+Hooks.deleteFunction = function(functionName) {
+  return Hooks.delete({functionName: functionName});
+}
+
+Hooks.deleteTrigger = function(className, triggerName) {
+  return Hooks.delete({className: className, triggerName: triggerName});
+}
+
+Hooks.delete = function(hook) {
+  var url;
+  if (hook.functionName) {
+      url = "/hooks/functions/"+hook.functionName;
+      delete hook.functionName;
+  } else if (hook.className && hook.triggerName) {
+      url = "/hooks/triggers/"+hook.className+"/"+hook.triggerName;
+      delete hook.className;
+      delete hook.triggerName;
+  }
+  return send("PUT", url, '{ "__op": "Delete" }');
+}
+
+module.exports = Hooks

src/cloud-code/httpRequest.js

@@ -0,0 +1,64 @@
+var request = require("request"),
+  Parse = require('parse/node').Parse;
+
+var encodeBody = function(body, headers = {}) {
+  if (typeof body !== 'object') {
+    return body;
+  }
+  var contentTypeKeys = Object.keys(headers).filter((key) => {
+    return key.match(/content-type/i) != null;
+  });
+
+  if (contentTypeKeys.length == 1) {
+    var contentType = contentTypeKeys[0];
+    if (headers[contentType].match(/application\/json/i)) {
+      body = JSON.stringify(body);
+    } else if(headers[contentType].match(/application\/x-www-form-urlencoded/i)) {
+      body = Object.keys(body).map(function(key){
+        return `${key}=${encodeURIComponent(body[key])}`
+      }).join("&");
+    }
+  }
+  return body;
+}
+
+module.exports = function(options) {
+  var promise = new Parse.Promise();
+  var callbacks = {
+    success: options.success,
+    error: options.error
+  };
+  delete options.success;
+  delete options.error;
+  delete options.uri; // not supported
+  options.body = encodeBody(options.body, options.headers);
+  // set follow redirects to false by default
+  options.followRedirect = options.followRedirects == true;
+  
+  request(options, (error, response, body) => {
+    var httpResponse = {};
+    httpResponse.status = response.statusCode;
+    httpResponse.headers = response.headers;
+    httpResponse.buffer = new Buffer(response.body);
+    httpResponse.cookies = response.headers["set-cookie"];
+    httpResponse.text = response.body;
+    try {
+      httpResponse.data = JSON.parse(response.body);
+    } catch (e) {}
+    // Consider <200 && >= 400 as errors 
+    if (error || httpResponse.status <200 || httpResponse.status >=400) {
+      if (callbacks.error) {
+        callbacks.error(httpResponse);
+      }
+      return promise.reject(httpResponse);
+    } else {
+      if (callbacks.success) {
+        callbacks.success(httpResponse);
+      }
+      return promise.resolve(httpResponse);
+    }
+  });
+  return promise;
+};
+
+module.exports.encodeBody = encodeBody;