commit 7d14cf7f13644393247722d0853f83645108cb1c · dunkirk.sh/cachet

+12 -4

src/cache.ts

···

       22
       22
        
        */

     

       23
       23
        
       interface User extends CacheItem {

     

       24
       24
        
         type: "user";

     

       25
       25
       +
         displayName: string;

     

       25
       26
        
         userId: string;

     

       26
       27
        
       }

     

       27
       28
        
       

     
···

       73
       74
        
             CREATE TABLE IF NOT EXISTS users (

     

       74
       75
        
               id TEXT PRIMARY KEY,

     

       75
       76
        
               userId TEXT UNIQUE,

     

       77
       77
       +
               displayName TEXT,

     

       76
       78
        
               imageUrl TEXT,

     

       77
       79
        
               expiration INTEGER

     

       78
       80
        
             )

     
···

       170
       172
        
          * @param expirationHours Optional custom expiration time in hours

     

       171
       173
        
          * @returns boolean indicating success

     

       172
       174
        
          */

     

       173
       173
       -
         async insertUser(userId: string, imageUrl: string, expirationHours?: number) {

     

       175
       175
       +
         async insertUser(

     

       176
       176
       +
           userId: string,

     

       177
       177
       +
           displayName: string,

     

       178
       178
       +
           imageUrl: string,

     

       179
       179
       +
           expirationHours?: number,

     

       180
       180
       +
         ) {

     

       174
       181
        
           const id = crypto.randomUUID();

     

       175
       182
        
           const expiration =

     

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

     

       177
       184
        
       

     

       178
       185
        
           try {

     

       179
       186
        
             this.db.run(

     

       180
       180
       -
               `INSERT INTO users (id, userId, imageUrl, expiration)

     

       181
       181
       -
                  VALUES (?, ?, ?, ?)

     

       187
       187
       +
               `INSERT INTO users (id, userId, displayName, imageUrl, expiration)

     

       188
       188
       +
                  VALUES (?, ?, ?, ?, ?)

     

       182
       189
        
                  ON CONFLICT(userId)

     

       183
       190
        
                  DO UPDATE SET imageUrl = ?, expiration = ?`,

     

       184
       184
       -
               [id, userId, imageUrl, expiration, imageUrl, expiration],

     

       191
       191
       +
               [id, userId, displayName, imageUrl, expiration, imageUrl, expiration],

     

       185
       192
        
             );

     

       186
       193
        
             return true;

     

       187
       194
        
           } catch (error) {

     
···

       306
       313
        
             type: "user",

     

       307
       314
        
             id: result.id,

     

       308
       315
        
             userId: result.userId,

     

       316
       316
       +
             displayName: result.displayName,

     

       309
       317
        
             imageUrl: result.imageUrl,

     

       310
       318
        
             expiration: new Date(result.expiration),

     

       311
       319
        
           };

+10 -1

src/index.ts

···

       202
       202
        
                 });

     

       203
       203
        
               }

     

       204
       204
        
       

     

       205
       205
       -
               await cache.insertUser(slackUser.id, slackUser.profile.image_512);

     

       205
       205
       +
               await cache.insertUser(

     

       206
       206
       +
                 slackUser.id,

     

       207
       207
       +
                 slackUser.profile.display_name_normalized,

     

       208
       208
       +
                 slackUser.profile.image_512,

     

       209
       209
       +
               );

     

       206
       210
        
       

     

       207
       211
        
               return {

     

       208
       212
        
                 id: slackUser.id,

     

       209
       213
        
                 expiration: new Date().toISOString(),

     

       210
       214
        
                 user: slackUser.id,

     

       215
       215
       +
                 displayName: slackUser.profile.display_name_normalized,

     

       211
       216
        
                 image: slackUser.profile.image_512,

     

       212
       217
        
               };

     

       213
       218
        
             }

     
···

       216
       221
        
               id: user.id,

     

       217
       222
        
               expiration: user.expiration.toISOString(),

     

       218
       223
        
               user: user.userId,

     

       224
       224
       +
               displayName: user.displayName,

     

       219
       225
        
               image: user.imageUrl,

     

       220
       226
        
             };

     

       221
       227
        
           },

     
···

       244
       250
        
                 }),

     

       245
       251
        
                 user: t.String({

     

       246
       252
        
                   default: "U12345678",

     

       253
       253
       +
                 }),

     

       254
       254
       +
                 displayName: t.String({

     

       255
       255
       +
                   default: "krn",

     

       247
       256
        
                 }),

     

       248
       257
        
                 image: t.String({

     

       249
       258
        
                   default: