add identity event triggered functions

Author: sw-yx

src/functions-templates/js/hasura-event-triggered/.netlify-function-templates.js

@@ -1,5 +1,5 @@
 module.exports = {
   name: "hasura-event-triggered",
   description:
-    "Serverless function to process a Hasura event and fire off a GraphQL mutation with cleaned text data"
+    "Hasura Cleaning: process a Hasura event and fire off a GraphQL mutation with processed text data"
 };

src/functions-templates/js/identity-signup/.netlify-function-templates.js

@@ -0,0 +1,5 @@
+module.exports = {
+  name: "identity-signup",
+  description:
+    "Identity Signup: Triggered when a new Netlify Identity user confirms. Assigns roles and extra metadata"
+};

src/functions-templates/js/identity-signup/identity-signup.js

@@ -0,0 +1,26 @@
+// note - this function MUST be named `identity-signup` to work
+// we do not yet offer local emulation of this functionality in Netlify Dev
+//
+// more: 
+// https://www.netlify.com/blog/2019/02/21/the-role-of-roles-and-how-to-set-them-in-netlify-identity/
+// https://www.netlify.com/docs/functions/#identity-and-functions
+
+exports.handler = async function(event, context) {
+  const data = JSON.parse(event.body);
+  const { user } = data;
+
+  const responseBody = {
+    app_metadata: {
+      roles: user.email.split("@")[1] === "trust-this-company.com" ? ["editor"] : ["visitor"];,
+      my_user_info: "this is some user info"
+    },
+    user_metadata: {
+      ...user.user_metadata, // append current user metadata
+      custom_data_from_function: "hurray this is some extra metadata"
+    }
+  };
+  return {
+    statusCode: 200,
+    body: JSON.stringify(responseBody)
+  };
+};

src/functions-templates/js/slack-rate-limit/.netlify-function-template.js

@@ -0,0 +1,5 @@
+module.exports = {
+  name: "slack-rate-limit",
+  description:
+    "Slack Rate-limit: post to Slack, at most once an hour, using Neltify Identity metadata"
+};

src/functions-templates/js/slack-rate-limit/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "slack-rate-limit",
+  "version": "1.0.0",
+  "description": "netlify functions:create - post to Slack, at most once an hour, using Neltify Identity metadata",
+  "main": "node-fetch.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "netlify",
+    "serverless",
+    "slack",
+    "js"
+  ],
+  "author": "Netlify",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^2.3.0"
+  }
+}

src/functions-templates/js/slack-rate-limit/slack-rate-limit.js

@@ -0,0 +1,129 @@
+// code walkthrough: https://www.netlify.com/blog/2018/03/29/jamstack-architecture-on-netlify-how-identity-and-functions-work-together/#updating-user-data-with-the-identity-api
+// demo repo: https://github.com/biilmann/testing-slack-tutorial/tree/v3-one-message-an-hour
+// note: requires SLACK_WEBHOOK_URL environment variable
+const slackURL = process.env.SLACK_WEBHOOK_URL;
+const fetch = require("node-fetch");
+
+class IdentityAPI {
+  constructor(apiURL, token) {
+    this.apiURL = apiURL;
+    this.token = token;
+  }
+
+  headers(headers = {}) {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.token}`,
+      ...headers
+    };
+  }
+
+  parseJsonResponse(response) {
+    return response.json().then(json => {
+      if (!response.ok) {
+        return Promise.reject({ status: response.status, json });
+      }
+
+      return json;
+    });
+  }
+
+  request(path, options = {}) {
+    const headers = this.headers(options.headers || {});
+    return fetch(this.apiURL + path, { ...options, headers }).then(response => {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType && contentType.match(/json/)) {
+        return this.parseJsonResponse(response);
+      }
+
+      if (!response.ok) {
+        return response.text().then(data => {
+          return Promise.reject({ stauts: response.status, data });
+        });
+      }
+      return response.text().then(data => {
+        data;
+      });
+    });
+  }
+}
+
+/*
+  Fetch a user from GoTrue via id
+*/
+function fetchUser(identity, id) {
+  const api = new IdentityAPI(identity.url, identity.token);
+  return api.request(`/admin/users/${id}`);
+}
+
+/*
+ Update the app_metadata of a user
+*/
+function updateUser(identity, user, app_metadata) {
+  const api = new IdentityAPI(identity.url, identity.token);
+  const new_app_metadata = { ...user.app_metadata, ...app_metadata };
+
+  return api.request(`/admin/users/${user.id}`, {
+    method: "PUT",
+    body: JSON.stringify({ app_metadata: new_app_metadata })
+  });
+}
+
+const oneHour = 60 * 60 * 1000;
+export function handler(event, context, callback) {
+  if (event.httpMethod !== "POST") {
+    return callback(null, {
+      statusCode: 410,
+      body: "Unsupported Request Method"
+    });
+  }
+
+  const claims = context.clientContext && context.clientContext.user;
+  if (!claims) {
+    return callback(null, {
+      statusCode: 401,
+      body: "You must be signed in to call this function"
+    });
+  }
+
+  fetchUser(context.clientContext.identity, claims.sub).then(user => {
+    const lastMessage = new Date(
+      user.app_metadata.last_message_at || 0
+    ).getTime();
+    const cutOff = new Date().getTime() - oneHour;
+    if (lastMessage > cutOff) {
+      return callback(null, {
+        statusCode: 401,
+        body: "Only one message an hour allowed"
+      });
+    }
+
+    try {
+      const payload = JSON.parse(event.body);
+
+      fetch(slackURL, {
+        method: "POST",
+        body: JSON.stringify({
+          text: payload.text,
+          attachments: [{ text: `From ${user.email}` }]
+        })
+      })
+        .then(() =>
+          updateUser(context.clientContext.identity, user, {
+            last_message_at: new Date().getTime()
+          })
+        )
+        .then(() => {
+          callback(null, { statusCode: 204 });
+        })
+        .catch(err => {
+          callback(null, {
+            statusCode: 500,
+            body: "Internal Server Error: " + e
+          });
+        });
+    } catch (e) {
+      callback(null, { statusCode: 500, body: "Internal Server Error: " + e });
+    }
+  });
+}