···

       
7
       
 
       
  },

     

       
8
       
 
       
  "dependencies": {

     

       
9
       
 
       
    "@elysiajs/swagger": "^1.1.6",

     

       
10
       
-
       
    "@types/cron": "^2.4.3",

     

       
11
       
 
       
    "@types/node-cron": "^3.0.11",

     

       
12
       
-
       
    "@types/pg": "^8.11.10",

     

       
13
       
-
       
    "cron": "^3.3.1",

     

       
14
       
 
       
    "elysia": "latest",

     

       
15
       
-
       
    "node-cron": "^3.0.3",

     

       
16
       
-
       
    "pg": "^8.13.1",

     

       
17
       
-
       
    "slack-edge": "^1.3.5"

     

       
18
       
 
       
  },

     

       
19
       
 
       
  "devDependencies": {

     

       
20
       
 
       
    "bun-types": "latest"

     

···

       
7
       
 
       
  },

     

       
8
       
 
       
  "dependencies": {

     

       
9
       
 
       
    "@elysiajs/swagger": "^1.1.6",

     

       
0
       
 
       

     

       
10
       
 
       
    "@types/node-cron": "^3.0.11",

     

       
0
       
 
       

     

       
0
       
 
       

     

       
11
       
 
       
    "elysia": "latest",

     

       
12
       
+
       
    "node-cron": "^3.0.3"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
13
       
 
       
  },

     

       
14
       
 
       
  "devDependencies": {

     

       
15
       
 
       
    "bun-types": "latest"

     

···

       
1
       
 
       
import { Elysia, t } from "elysia";

     

       
2
       
 
       
import { swagger } from "@elysiajs/swagger";

     

       
3
       
 
       
import { version } from "../package.json";

     

       
4
       
-
       
import { SlackApp } from "slack-edge";

     

       
5
       
 
       
import { SlackCache } from "./cache";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
6
       
 
       


     

       
7
       
-
       
if (!process.env.SLACK_BOT_TOKEN || !process.env.SLACK_SIGNING_SECRET) {

     

       
8
       
-
       
  const missingEnvVars = [

     

       
9
       
-
       
    !process.env.SLACK_BOT_TOKEN && "SLACK_BOT_TOKEN",

     

       
10
       
-
       
    !process.env.SLACK_SIGNING_SECRET && "SLACK_SIGNING_SECRET",

     

       
11
       
-
       
  ].filter(Boolean);

     

       
12
       
-
       


     

       
13
       
-
       
  throw new Error(

     

       
14
       
-
       
    `Missing required environment variables: ${missingEnvVars.join(", ")}`,

     

       
15
       
-
       
  );

     

       
16
       
-
       
}

     

       
17
       
-
       


     

       
18
       
-
       
const slackApp = new SlackApp({

     

       
19
       
-
       
  env: {

     

       
20
       
-
       
    SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN,

     

       
21
       
-
       
    SLACK_SIGNING_SECRET: process.env.SLACK_SIGNING_SECRET,

     

       
22
       
-
       
    SLACK_LOGGING_LEVEL: "INFO",

     

       
23
       
-
       
  },

     

       
24
       
-
       
  startLazyListenerAfterAck: true,

     

       
25
       
-
       
});

     

       
26
       
 
       


     

       
27
       
 
       
const cache = new SlackCache(process.env.DATABASE_PATH ?? "./data/cachet.db");

     

       
28
       
 
       


     
···

       
76
       
 
       
  .get(

     

       
77
       
 
       
    "/health",

     

       
78
       
 
       
    async ({ error }) => {

     

       
79
       
-
       
      const slackConnection = await slackApp.client.auth.test();

     

       
80
       
 
       


     

       
81
       
 
       
      const databaseConnection = await cache.healthCheck();

     

       
82
       
 
       


     

       
83
       
-
       
      if (!slackConnection.ok || !databaseConnection)

     

       
84
       
 
       
        return error(500, {

     

       
85
       
 
       
          http: false,

     

       
86
       
-
       
          slack: slackConnection.ok,

     

       
87
       
 
       
          database: databaseConnection,

     

       
88
       
 
       
        });

     

       
89
       
 
       


     
···

       
122
       
 
       


     

       
123
       
 
       
      // if not found then check slack first

     

       
124
       
 
       
      if (!user) {

     

       
125
       
-
       
        const slackUser = await slackApp.client.users.info({

     

       
126
       
-
       
          user: params.user,

     

       
127
       
-
       
        });

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
128
       
 
       


     

       
129
       
-
       
        if (!slackUser.ok) return error(404, { message: "User not found" });

     

       
130
       
-
       


     

       
131
       
-
       
        if (!slackUser.user?.profile?.image_original || !slackUser.user.id)

     

       
132
       
-
       
          return error(404, { message: "User data malformed" });

     

       
133
       
 
       


     

       
134
       
-
       
        await cache.insertUser(

     

       
135
       
-
       
          slackUser.user.id,

     

       
136
       
-
       
          slackUser.user?.profile?.image_original,

     

       
137
       
-
       
        );

     

       
138
       
 
       


     

       
139
       
 
       
        return {

     

       
140
       
-
       
          id: slackUser.user.id,

     

       
141
       
 
       
          expiration: new Date().toISOString(),

     

       
142
       
-
       
          user: slackUser.user.id,

     

       
143
       
-
       
          image: slackUser.user.profile.image_original,

     

       
144
       
 
       
        };

     

       
145
       
 
       
      }

     

       
146
       
 
       


     
···

       
158
       
 
       
      }),

     

       
159
       
 
       
      response: {

     

       
160
       
 
       
        404: t.Object({

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
161
       
 
       
          message: t.String(),

     

       
162
       
 
       
        }),

     

       
163
       
 
       
        200: t.Object({

     

···

       
1
       
 
       
import { Elysia, t } from "elysia";

     

       
2
       
 
       
import { swagger } from "@elysiajs/swagger";

     

       
3
       
 
       
import { version } from "../package.json";

     

       
0
       
 
       

     

       
4
       
 
       
import { SlackCache } from "./cache";

     

       
5
       
+
       
import { SlackWrapper } from "./slackWrapper";

     

       
6
       
+
       
import type { SlackUser } from "./slack";

     

       
7
       
 
       


     

       
8
       
+
       
const slackApp = new SlackWrapper();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
 
       
const cache = new SlackCache(process.env.DATABASE_PATH ?? "./data/cachet.db");

     

       
11
       
 
       


     
···

       
59
       
 
       
  .get(

     

       
60
       
 
       
    "/health",

     

       
61
       
 
       
    async ({ error }) => {

     

       
62
       
+
       
      const slackConnection = await slackApp.testAuth();

     

       
63
       
 
       


     

       
64
       
 
       
      const databaseConnection = await cache.healthCheck();

     

       
65
       
 
       


     

       
66
       
+
       
      if (!slackConnection || !databaseConnection)

     

       
67
       
 
       
        return error(500, {

     

       
68
       
 
       
          http: false,

     

       
69
       
+
       
          slack: slackConnection,

     

       
70
       
 
       
          database: databaseConnection,

     

       
71
       
 
       
        });

     

       
72
       
 
       


     
···

       
105
       
 
       


     

       
106
       
 
       
      // if not found then check slack first

     

       
107
       
 
       
      if (!user) {

     

       
108
       
+
       
        let slackUser: SlackUser;

     

       
109
       
+
       
        try {

     

       
110
       
+
       
          slackUser = await slackApp.getUserInfo(params.user);

     

       
111
       
+
       
        } catch (e) {

     

       
112
       
+
       
          if (e instanceof Error && e.message === "user_not_found")

     

       
113
       
+
       
            return error(404, { message: "User not found" });

     

       
114
       
 
       


     

       
115
       
+
       
          return error(500, {

     

       
116
       
+
       
            message: `Error fetching user from Slack: ${e}`,

     

       
117
       
+
       
          });

     

       
118
       
+
       
        }

     

       
119
       
 
       


     

       
120
       
+
       
        await cache.insertUser(slackUser.id, slackUser.profile.image_original);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
121
       
 
       


     

       
122
       
 
       
        return {

     

       
123
       
+
       
          id: slackUser.id,

     

       
124
       
 
       
          expiration: new Date().toISOString(),

     

       
125
       
+
       
          user: slackUser.id,

     

       
126
       
+
       
          image: slackUser.profile.image_original,

     

       
127
       
 
       
        };

     

       
128
       
 
       
      }

     

       
129
       
 
       


     
···

       
141
       
 
       
      }),

     

       
142
       
 
       
      response: {

     

       
143
       
 
       
        404: t.Object({

     

       
144
       
+
       
          message: t.String(),

     

       
145
       
+
       
        }),

     

       
146
       
+
       
        500: t.Object({

     

       
147
       
 
       
          message: t.String(),

     

       
148
       
 
       
        }),

     

       
149
       
 
       
        200: t.Object({