commit 1fc3dddfaac57e3d920a2425801b5bd5fd99abf6 · dunkirk.sh/cachet

+46
README.md
···

       74
       74
        
       

     

       75
       75
        
       The app is honestly super simple. It's pretty much just a cache layer on top of the slack api. When you request a profile picture or emoji it first checks the cache. If the image is in the cache it returns the link to the image. If the image is not in the cache it calls the slack api to get the link to image and then stores that in the cache before returning the image link to you!

     

       76
       76
        
       

     

       77
       77
       +
       There were a few interesting hurdles that made this a bit more confusing though. The first was that slack returns the `emoji.list` endpoint with not just regular emojis but also aliased emojis. The aliased emojis doesn't seem that hard at first untill you realize that someone could alias stock slack emojis. That means that we don't have a url to the image and to make it worse slack doesn't have an offically documented way to get the full list of stock emojis. Thankfully an amazing user ([@impressiver](https://github.com/impressiver)) put this all into a handy [gist](https://gist.github.com/impressiver/87b5b9682d935efba8936898fbfe1919) for everyone to use! It was last updated on 2020-12-22 so it's a bit out of date but slack doesn't seem to be changing their emojis too often so it should be fine for now.

     

       78
       78
       +
       

     

       79
       79
       +
       ```json

     

       80
       80
       +
       {

     

       81
       81
       +
           "ok": true,

     

       82
       82
       +
           "emoji": {

     

       83
       83
       +
               "hackhaj": "https://emoji.slack-edge.com/T0266FRGM/hackshark/0bf4771247471a48.png",

     

       84
       84
       +
               "hackhaj": "alias:hackshark"

     

       85
       85
       +
               "face-grinning": "alias:grinning"

     

       86
       86
       +
           }

     

       87
       87
       +
       }

     

       88
       88
       +
       

     

       89
       89
       +
       {

     

       90
       90
       +
         "grinning": "https://a.slack-edge.com/production-standard-emoji-assets/14.0/google-medium/1f601.png"

     

       91
       91
       +
       }

     

       92
       92
       +
       ```

     

       93
       93
       +
       

     

       94
       94
       +
       The second challenge (technically its not a challenge; more of a side project) was building a custom cache solution based on `Bun:sqlite`. It ended up being far easier than I thought it was going to be and I'm quite happy with how it turned out! It's fully typed which makes it awesome to use and blazing fast due to the native Bun implementation of sqlite. Using it is also dead simple. Just create a new instance of the cache with a db path, a ttl, and a fetch function for the emojis and you're good to go! Inserting and getting data is also super simple and the cache is fully typed!

     

       95
       95
       +
       

     

       96
       96
       +
       ```typescript

     

       97
       97
       +
       const cache = new SlackCache(

     

       98
       98
       +
         process.env.DATABASE_PATH ?? "./data/cachet.db",

     

       99
       99
       +
         24,

     

       100
       100
       +
         async () => {

     

       101
       101
       +
           console.log("Fetching emojis from Slack");

     

       102
       102
       +
         },

     

       103
       103
       +
       );

     

       104
       104
       +
       

     

       105
       105
       +
       await cache.insertUser("U062UG485EE", "https://avatars.slack-edge.com/2024-11-30/8105375749571_53898493372773a01a1f_original.jpg", null);

     

       106
       106
       +
       await cache.insertEmoji("hackshark", "https://emoji.slack-edge.com/T0266FRGM/hackshark/0bf4771247471a48.png");

     

       107
       107
       +
       

     

       108
       108
       +
       const emoji = await cache.getEmoji("hackshark");

     

       109
       109
       +
       const user = await cache.getUser("U062UG485EE");

     

       110
       110
       +
       ```

     

       111
       111
       +
       

     

       112
       112
       +
       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.

     

       113
       113
       +
       

     

       114
       114
       +
       ```typescript

     

       115
       115
       +
       const slack = new Slack(process.env.SLACK_TOKEN, process.env.SLACK_SIGNING_SECRET);

     

       116
       116
       +
       

     

       117
       117
       +
       const user = await slack.getUser("U062UG485EE");

     

       118
       118
       +
       const emojis = await slack.getEmoji();

     

       119
       119
       +
       ```

     

       120
       120
       +
       

     

       121
       121
       +
       #

     

       122
       122
       +
       

     

       77
       123
        
       <p align="center">

     

       78
       124
        
       	<img src="https://raw.githubusercontent.com/taciturnaxolotl/carriage/master/.github/images/line-break.svg" />

     

       79
       125
        
       </p>