commit 9304bfcae386ac6dfedecea75e525b42b5b219f8 · dunkirk.sh/cachet

+17 -1

README.md

···

       66
       66
        
       

     

       67
       67
        
       ### Usage

     

       68
       68
        
       

     

       69
       69
       -
       The api is pretty simple. You can get a profile picture by calling `GET /profile/:id` where `:id` is the slack user id. You can get an emoji by calling `GET /emoji/:name` where `:name` is the name of the emoji. You can also get a list of all emojis by calling `GET /emojis`. (WIP - subject to rapid change)

     

       69
       69
       +
       The api is pretty simple. You can get a profile picture by calling `GET /profile/:id` where `:id` is the slack user id. You can get an emoji by calling `GET /emoji/:name` where `:name` is the name of the emoji. You can also get a list of all emojis by calling `GET /emojis`. 

     

       70
       70
       +
       

     

       71
       71
       +
       Additionally, you can manually purge a specific user's cache with `POST /users/:user/purge` (requires authentication with a bearer token).

     

       70
       72
        
       

     

       71
       73
        
       There are also complete swagger docs available at [`/swagger`](https://cachet.dunkirk.sh/swagger)! They are dynamically generated from the code so they should always be up to date! (The types force me to keep them up to date ^_^)

     

       72
       74
        
       

     
···

       109
       111
        
       

     

       110
       112
        
       const emoji = await cache.getEmoji("hackshark");

     

       111
       113
        
       const user = await cache.getUser("U062UG485EE");

     

       114
       114
       +
       

     

       115
       115
       +
       // You can also purge the cache for a specific user

     

       116
       116
       +
       const purgeResult = await cache.purgeUserCache("U062UG485EE");

     

       117
       117
       +
       console.log(`Cache purged: ${purgeResult}`); // true if user was in cache and purged

     

       112
       118
        
       ```

     

       113
       119
        
       

     

       114
       120
        
       The final bit was at this point a bit of a ridiculous one. I didn't like how heavyweight the `bolt` or `slack-edge` packages were so I rolled my own slack api wrapper. It's again fully typed and designed to be as lightweight as possible.

     
···

       118
       124
        
       

     

       119
       125
        
       const user = await slack.getUser("U062UG485EE");

     

       120
       126
        
       const emojis = await slack.getEmoji();

     

       127
       127
       +
       

     

       128
       128
       +
       // Manually purge a specific user's cache using the API endpoint

     

       129
       129
       +
       const response = await fetch("https://cachet.example.com/users/U062UG485EE/purge", {

     

       130
       130
       +
         method: "POST",

     

       131
       131
       +
         headers: {

     

       132
       132
       +
           "Authorization": `Bearer ${process.env.BEARER_TOKEN}`

     

       133
       133
       +
         }

     

       134
       134
       +
       });

     

       135
       135
       +
       const result = await response.json();

     

       136
       136
       +
       // { message: "User cache purged", userId: "U062UG485EE", success: true }

     

       121
       137
        
       ```

     

       122
       138
        
       

     

       123
       139
        
       <p align="center">

+18 -3

src/cache.ts

···

       115
       115
        
           });

     

       116
       116
        
         }

     

       117
       117
        
       

     

       118
       118
       -
         /*

     

       118
       118
       +
         /**

     

       119
       119
        
          * Purges expired items from the cache

     

       120
       120
        
          * @returns int indicating number of items purged

     

       121
       121
        
          */

     
···

       136
       136
        
           return result.changes + result2.changes;

     

       137
       137
        
         }

     

       138
       138
        
       

     

       139
       139
       -
         /*

     

       139
       139
       +
         /**

     

       140
       140
       +
          * Purges cache for a specific user

     

       141
       141
       +
          * @param userId The Slack user ID to purge from cache

     

       142
       142
       +
          * @returns boolean indicating if any user was purged

     

       143
       143
       +
          */

     

       144
       144
       +
         async purgeUserCache(userId: string): Promise<boolean> {

     

       145
       145
       +
           try {

     

       146
       146
       +
             const result = this.db.run("DELETE FROM users WHERE userId = ?", [userId]);

     

       147
       147
       +
             return result.changes > 0;

     

       148
       148
       +
           } catch (error) {

     

       149
       149
       +
             console.error("Error purging user cache:", error);

     

       150
       150
       +
             return false;

     

       151
       151
       +
           }

     

       152
       152
       +
         }

     

       153
       153
       +
       

     

       154
       154
       +
         /**

     

       140
       155
        
          * Purges all items from the cache

     

       141
       141
       -
          * @returns int indicating number of items purged

     

       156
       156
       +
          * @returns Object containing purge results

     

       142
       157
        
          */

     

       143
       158
        
         async purgeAll(): Promise<{

     

       144
       159
        
           message: string;

+50

src/index.ts

···

       95
       95
        
           }),

     

       96
       96
        
         )

     

       97
       97
        
         .use(

     

       98
       98
       +
           cron({

     

       99
       99
       +
             name: "purgeSpecificUserCache",

     

       100
       100
       +
             pattern: "5 * * * *", // Run at 5 minutes after each hour

     

       101
       101
       +
             async run() {

     

       102
       102
       +
               const userId = "U062UG485EE";

     

       103
       103
       +
               console.log(`Purging cache for user ${userId}`);

     

       104
       104
       +
               const result = await cache.purgeUserCache(userId);

     

       105
       105
       +
               console.log(

     

       106
       106
       +
                 `Cache purge for user ${userId}: ${result ? "successful" : "no cache entry found"}`,

     

       107
       107
       +
               );

     

       108
       108
       +
             },

     

       109
       109
       +
           }),

     

       110
       110
       +
         )

     

       111
       111
       +
         .use(

     

       98
       112
        
           swagger({

     

       99
       113
        
             exclude: ["/", "favicon.ico"],

     

       100
       114
        
             documentation: {

     
···

       489
       503
        
                 message: t.String(),

     

       490
       504
        
                 users: t.Number(),

     

       491
       505
        
                 emojis: t.Number(),

     

       506
       506
       +
               }),

     

       507
       507
       +
               401: t.String({ default: "Unauthorized" }),

     

       508
       508
       +
             },

     

       509
       509
       +
           },

     

       510
       510
       +
         )

     

       511
       511
       +
         .post(

     

       512
       512
       +
           "/users/:user/purge",

     

       513
       513
       +
           async ({ headers, params, set }) => {

     

       514
       514
       +
             if (headers.authorization !== `Bearer ${process.env.BEARER_TOKEN}`) {

     

       515
       515
       +
               set.status = 401;

     

       516
       516
       +
               return "Unauthorized";

     

       517
       517
       +
             }

     

       518
       518
       +
       

     

       519
       519
       +
             const success = await cache.purgeUserCache(params.user);

     

       520
       520
       +
       

     

       521
       521
       +
             return {

     

       522
       522
       +
               message: success ? "User cache purged" : "User not found in cache",

     

       523
       523
       +
               userId: params.user,

     

       524
       524
       +
               success,

     

       525
       525
       +
             };

     

       526
       526
       +
           },

     

       527
       527
       +
           {

     

       528
       528
       +
             tags: ["The Cache!"],

     

       529
       529
       +
             headers: t.Object({

     

       530
       530
       +
               authorization: t.String({

     

       531
       531
       +
                 default: "Bearer <token>",

     

       532
       532
       +
               }),

     

       533
       533
       +
             }),

     

       534
       534
       +
             params: t.Object({

     

       535
       535
       +
               user: t.String(),

     

       536
       536
       +
             }),

     

       537
       537
       +
             response: {

     

       538
       538
       +
               200: t.Object({

     

       539
       539
       +
                 message: t.String(),

     

       540
       540
       +
                 userId: t.String(),

     

       541
       541
       +
                 success: t.Boolean(),

     

       492
       542
        
               }),

     

       493
       543
        
               401: t.String({ default: "Unauthorized" }),

     

       494
       544
        
             },