commit 9ec87cbc09231c45ab3533c79eba95989a0ea2a9 · dunkirk.sh/cachet

+59

src/cache.ts

···

       216
       216
        
         }

     

       217
       217
        
       

     

       218
       218
        
         /**

     

       219
       219
       +
          * Batch inserts multiple emojis into the cache

     

       220
       220
       +
          * @param emojis Array of {name, imageUrl} objects to insert

     

       221
       221
       +
          * @param expirationHours Optional custom expiration time in hours for all emojis

     

       222
       222
       +
          * @returns boolean indicating if all insertions were successful

     

       223
       223
       +
          */

     

       224
       224
       +
         async batchInsertEmoji(

     

       225
       225
       +
           emojis: Array<{ name: string; imageUrl: string }>,

     

       226
       226
       +
           expirationHours?: number,

     

       227
       227
       +
         ): Promise<boolean> {

     

       228
       228
       +
           try {

     

       229
       229
       +
             const expiration =

     

       230
       230
       +
               Date.now() + (expirationHours || this.defaultExpiration) * 3600000;

     

       231
       231
       +
       

     

       232
       232
       +
             this.db.transaction(() => {

     

       233
       233
       +
               for (const emoji of emojis) {

     

       234
       234
       +
                 const id = crypto.randomUUID();

     

       235
       235
       +
                 this.db.run(

     

       236
       236
       +
                   `INSERT INTO emojis (id, name, imageUrl, expiration)

     

       237
       237
       +
                    VALUES (?, ?, ?, ?)

     

       238
       238
       +
                    ON CONFLICT(name)

     

       239
       239
       +
                    DO UPDATE SET imageUrl = ?, expiration = ?`,

     

       240
       240
       +
                   [

     

       241
       241
       +
                     id,

     

       242
       242
       +
                     emoji.name,

     

       243
       243
       +
                     emoji.imageUrl,

     

       244
       244
       +
                     expiration,

     

       245
       245
       +
                     emoji.imageUrl,

     

       246
       246
       +
                     expiration,

     

       247
       247
       +
                   ],

     

       248
       248
       +
                 );

     

       249
       249
       +
               }

     

       250
       250
       +
             })();

     

       251
       251
       +
       

     

       252
       252
       +
             return true;

     

       253
       253
       +
           } catch (error) {

     

       254
       254
       +
             console.error("Error batch inserting emojis:", error);

     

       255
       255
       +
             return false;

     

       256
       256
       +
           }

     

       257
       257
       +
         }

     

       258
       258
       +
       

     

       259
       259
       +
         /**

     

       260
       260
       +
          * Lists all emoji in the cache

     

       261
       261
       +
          * @returns Array of Emoji objects that haven't expired

     

       262
       262
       +
          */

     

       263
       263
       +
         async listEmoji(): Promise<Emoji[]> {

     

       264
       264
       +
           const results = this.db

     

       265
       265
       +
             .query("SELECT * FROM emojis WHERE expiration > ?")

     

       266
       266
       +
             .all(Date.now()) as Emoji[];

     

       267
       267
       +
       

     

       268
       268
       +
           return results.map((result) => ({

     

       269
       269
       +
             type: "emoji",

     

       270
       270
       +
             id: result.id,

     

       271
       271
       +
             name: result.name,

     

       272
       272
       +
             imageUrl: result.imageUrl,

     

       273
       273
       +
             expiration: new Date(result.expiration),

     

       274
       274
       +
           }));

     

       275
       275
       +
         }

     

       276
       276
       +
       

     

       277
       277
       +
         /**

     

       219
       278
        
          * Retrieves a user from the cache

     

       220
       279
        
          * @param userId Unique identifier of the user

     

       221
       280
        
          * @returns User object if found and not expired, null otherwise

+26

src/index.ts

···

       173
       173
        
           },

     

       174
       174
        
         )

     

       175
       175
        
         .get(

     

       176
       176
       +
           "/emojis",

     

       177
       177
       +
           async () => {

     

       178
       178
       +
             const emojis = await cache.listEmoji();

     

       179
       179
       +
       

     

       180
       180
       +
             return emojis.map((emoji) => ({

     

       181
       181
       +
               id: emoji.id,

     

       182
       182
       +
               expiration: emoji.expiration.toISOString(),

     

       183
       183
       +
               name: emoji.name,

     

       184
       184
       +
               image: emoji.imageUrl,

     

       185
       185
       +
             }));

     

       186
       186
       +
           },

     

       187
       187
       +
           {

     

       188
       188
       +
             tags: ["Slack"],

     

       189
       189
       +
             response: {

     

       190
       190
       +
               200: t.Array(

     

       191
       191
       +
                 t.Object({

     

       192
       192
       +
                   id: t.String(),

     

       193
       193
       +
                   expiration: t.String(),

     

       194
       194
       +
                   name: t.String(),

     

       195
       195
       +
                   image: t.String(),

     

       196
       196
       +
                 }),

     

       197
       197
       +
               ),

     

       198
       198
       +
             },

     

       199
       199
       +
           },

     

       200
       200
       +
         )

     

       201
       201
       +
         .get(

     

       176
       202
        
           "/emojis/:emoji",

     

       177
       203
        
           async ({ params, error }) => {

     

       178
       204
        
             const emoji = await cache.getEmoji(params.emoji);