feat: Slash Commands (#337)

* feat: add discord interactions worker

* feat(interactions): update CI/CD and terraform to add interactions

* chore: fix lint issues

* chore: fix build & emulation

* fix(interactions): deployment + handler

* chore: remove worker-dist via gitignore

* feat: add /pickable-roles and /pick-role basis

* feat: add pick, remove, and update the general /roleypoly command

* fix: lint missing Member import

packages/worker-utils/api.ts

@@ -0,0 +1,21 @@
+export const respond = (obj: Record<string, any>, init: ResponseInit = {}) =>
+  new Response(JSON.stringify(obj), {
+    ...init,
+    headers: {
+      ...(init.headers || {}),
+      'content-type': 'application/json',
+    },
+  });
+
+export const userAgent =
+  'DiscordBot (https://github.com/roleypoly/roleypoly, git-main) (+https://roleypoly.com)';
+
+export const getQuery = (request: Request): { [x: string]: string } => {
+  const output: { [x: string]: string } = {};
+
+  for (let [key, value] of new URL(request.url).searchParams.entries()) {
+    output[key] = value;
+  }
+
+  return output;
+};

packages/worker-utils/discord.ts

@@ -0,0 +1,38 @@
+import { userAgent } from './api';
+
+export const discordAPIBase = 'https://discordapp.com/api/v9';
+
+export enum AuthType {
+  Bearer = 'Bearer',
+  Bot = 'Bot',
+}
+
+export const discordFetch = async <T>(
+  url: string,
+  auth: string,
+  authType: AuthType = AuthType.Bearer,
+  init?: RequestInit
+): Promise<T | null> => {
+  const response = await fetch(discordAPIBase + url, {
+    ...(init || {}),
+    headers: {
+      ...(init?.headers || {}),
+      authorization: `${AuthType[authType]} ${auth}`,
+      'user-agent': userAgent,
+    },
+  });
+
+  if (response.status >= 400) {
+    console.error('discordFetch failed', {
+      url,
+      authType,
+      payload: await response.text(),
+    });
+  }
+
+  if (response.ok) {
+    return (await response.json()) as T;
+  } else {
+    return null;
+  }
+};

packages/worker-utils/index.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './discord';
+export * from './kv';
+export * from './router';

packages/worker-utils/kv.ts

@@ -0,0 +1,80 @@
+export class WrappedKVNamespace {
+  constructor(private kvNamespace: KVNamespace) {}
+
+  async get<T>(key: string): Promise<T | null> {
+    const data = await this.kvNamespace.get(key, 'text');
+    if (!data) {
+      return null;
+    }
+
+    return JSON.parse(data) as T;
+  }
+
+  async put<T>(key: string, value: T, ttlSeconds?: number) {
+    await this.kvNamespace.put(key, JSON.stringify(value), {
+      expirationTtl: ttlSeconds,
+    });
+  }
+
+  list = this.kvNamespace.list;
+  getWithMetadata = this.kvNamespace.getWithMetadata;
+  delete = this.kvNamespace.delete;
+}
+
+class EmulatedKV implements KVNamespace {
+  constructor() {
+    console.warn('EmulatedKV used. Data will be lost.');
+  }
+
+  private data: Map<string, any> = new Map();
+
+  async get<T>(key: string): Promise<T | null> {
+    if (!this.data.has(key)) {
+      return null;
+    }
+
+    return this.data.get(key);
+  }
+
+  async getWithMetadata<T, Metadata = unknown>(
+    key: string
+  ): KVValueWithMetadata<T, Metadata> {
+    return {
+      value: await this.get<T>(key),
+      metadata: {} as Metadata,
+    };
+  }
+
+  async put(key: string, value: string | ReadableStream<any> | ArrayBuffer | FormData) {
+    this.data.set(key, value);
+  }
+
+  async delete(key: string) {
+    this.data.delete(key);
+  }
+
+  async list(options?: { prefix?: string; limit?: number; cursor?: string }): Promise<{
+    keys: { name: string; expiration?: number; metadata?: unknown }[];
+    list_complete: boolean;
+    cursor: string;
+  }> {
+    let keys: { name: string }[] = [];
+
+    for (let key of this.data.keys()) {
+      if (options?.prefix && !key.startsWith(options.prefix)) {
+        continue;
+      }
+
+      keys.push({ name: key });
+    }
+
+    return {
+      keys,
+      cursor: '0',
+      list_complete: true,
+    };
+  }
+}
+
+export const kvOrLocal = (namespace: KVNamespace | null): KVNamespace =>
+  namespace || new EmulatedKV();

packages/worker-utils/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@roleypoly/worker-utils",
+  "version": "0.1.0",
+  "scripts": {
+    "lint:types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^2.2.2"
+  }
+}

packages/worker-utils/router.ts

@@ -0,0 +1,111 @@
+export type Handler = (request: Request) => Promise<Response> | Response;
+
+type RoutingTree = {
+  [method: string]: {
+    [path: string]: Handler;
+  };
+};
+
+type Fallbacks = {
+  root: Handler;
+  404: Handler;
+  500: Handler;
+};
+
+export class Router {
+  private routingTree: RoutingTree = {};
+  private fallbacks: Fallbacks = {
+    root: this.respondToRoot,
+    404: this.notFound,
+    500: this.serverError,
+  };
+
+  private corsOrigins: string[] = [];
+
+  addCORSOrigins(origins: string[]) {
+    this.corsOrigins = [...this.corsOrigins, ...origins];
+  }
+
+  addFallback(which: keyof Fallbacks, handler: Handler) {
+    this.fallbacks[which] = handler;
+  }
+
+  add(method: string, rootPath: string, handler: Handler) {
+    const lowerMethod = method.toLowerCase();
+
+    if (!this.routingTree[lowerMethod]) {
+      this.routingTree[lowerMethod] = {};
+    }
+
+    this.routingTree[lowerMethod][rootPath] = handler;
+  }
+
+  async handle(request: Request): Promise<Response> {
+    const response = await this.processRequest(request);
+    this.injectCORSHeaders(request, response.headers);
+    return response;
+  }
+
+  private async processRequest(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === '/' || url.pathname === '') {
+      return this.fallbacks.root(request);
+    }
+    const lowerMethod = request.method.toLowerCase();
+    const rootPath = url.pathname.split('/')[1];
+    const handler = this.routingTree[lowerMethod]?.[rootPath];
+
+    if (handler) {
+      try {
+        const response = await handler(request);
+        return response;
+      } catch (e) {
+        console.error(e);
+        return this.fallbacks[500](request);
+      }
+    }
+
+    if (lowerMethod === 'options') {
+      return new Response(null, {});
+    }
+
+    return this.fallbacks[404](request);
+  }
+
+  private respondToRoot(): Response {
+    return new Response('Hi there!');
+  }
+
+  private notFound(): Response {
+    return new Response(JSON.stringify({ error: 'not_found' }), {
+      status: 404,
+    });
+  }
+
+  private serverError(): Response {
+    return new Response(JSON.stringify({ error: 'internal_server_error' }), {
+      status: 500,
+    });
+  }
+
+  private injectCORSHeaders(request: Request, headers: Headers) {
+    headers.set('access-control-allow-methods', '*');
+    headers.set('access-control-allow-headers', '*');
+
+    if (this.corsOrigins.length === 0) {
+      headers.set('access-control-allow-origin', '*');
+      return;
+    }
+
+    const originHeader = request.headers.get('origin');
+    if (!originHeader) {
+      return;
+    }
+
+    const originHostname = new URL(originHeader).hostname;
+    if (this.corsOrigins.includes(originHostname)) {
+      headers.set('access-control-allow-origin', originHostname);
+    }
+  }
+}

packages/worker-utils/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "lib": ["esnext", "webworker", "ES2020.BigInt", "ES2020.Promise"],
+    "types": ["@cloudflare/workers-types"],
+    "target": "ES2019"
+  },
+  "include": [
+    "./*.ts",
+    "./**/*.ts",
+    "../../node_modules/@cloudflare/workers-types/index.d.ts"
+  ],
+  "exclude": ["./**/*.spec.ts", "./dist/**"],
+  "extends": "../../tsconfig.json"
+}