feat: 🎸 improve yar vals and flash typings

lib/index.d.ts

@@ -1,6 +1,12 @@
 import { Id, PolicyOptions } from '@hapi/catbox';
 import { CachePolicyOptions, Plugin, Request, ResponseToolkit, Server, ServerOptionsCache } from '@hapi/hapi';
 
+export interface YarValues {}
+export interface YarFlashes {}
+
+type YarValKeys = keyof YarValues;
+type YarFlashKeys = keyof YarFlashes;
+
 declare namespace yar {
     interface YarOptions {
         /**
@@ -109,20 +115,20 @@ declare namespace yar {
         /**
          * - assigns a value (string, object, etc) to a given key which will persist across requests. Returns the value.
          */
-        set<T>(key: string, value: T): T;
+        set<T extends YarValKeys>(key: T, value: YarValues[T]): T;
         /**
          *  assigns values to multiple keys using each 'keysObject' top-level property. Returns the keysObject.
          */
-        set<T extends { [key: string]: any }>(keysObject: T): T;
+        set<T extends YarValues>(keysObject: Partial<T>): T;
 
         /**
          * retrieve value using a key. If 'clear' is 'true', key is cleared on return.
          */
-        get(key: string, clear?: boolean): any;
+        get <T extends YarValKeys>(key: T, clear?: boolean): YarValues[T];
         /**
          * clears key.
          */
-        clear(key: string): void;
+        clear <T extends YarValKeys>(key: T): void;
         /**
          * Manually notify the session of changes (when using get()
          * and changing the content of the returned reference directly without calling set()).
@@ -136,7 +142,7 @@ declare namespace yar {
          * 'isOverride' used to indicate that the message provided should replace
          * any existing value instead of being appended to it (defaults to false).
          */
-        flash(type?: string, message?: any, isOverride?: boolean): any[];
+        flash <T extends YarFlashKeys>(type?: T, message?: YarFlashes[T], isOverride?: boolean): any[];
 
         /**
          * if set to 'true', enables lazy mode.
@@ -160,7 +166,9 @@ declare namespace yar {
         revoke(id: Id): Promise<void>;
     }
 }
+
 declare const yar: Plugin<yar.YarOptions>;
+
 export = yar;
 
 declare module '@hapi/hapi' {

test/types/index.ts

@@ -1,6 +1,29 @@
+import { types } from '@hapi/lab';
 import { Request, Server } from '@hapi/hapi';
 import * as yar from '../..';
 
+declare module '../..' {
+
+    interface YarValues {
+
+        test1: string;
+        test2: {
+            a: true;
+            b: string;
+        },
+
+        example: {
+            key: string;
+        };
+    }
+
+    interface YarFlashes {
+
+        success: { title: string; message: string; };
+        error: { title: string; message: string; };
+    }
+}
+
 async function boot() {
     const server = new Server();
     await server.register({
@@ -28,4 +51,43 @@ async function boot() {
             };
         },
     });
+
+    server.route({
+
+        path: '/test',
+        method: 'post',
+        handler(request: Request) {
+
+
+            types.expect.error(request.yar.set('abc123', true));
+            request.yar.set('test1', '123');
+            request.yar.set('test2', {
+                a: true,
+                b: '123',
+            });
+
+            types.expect.error(request.yar.set('test1', 123))
+            types.expect.error(request.yar.set('test2', 123))
+
+            request.yar.set({
+                test1: '123',
+            });
+
+            request.yar.flash('error', { title: 'Error', message: 'This is an error' });
+            request.yar.flash('success', { title: 'Success', message: 'This is a success' });
+
+            types.expect.error(
+                request.yar.flash('test', { title: 'Success', message: 'This is a success' })
+            )
+
+            types.expect.error(
+                request.yar.flash('success', 'message')
+            );
+
+
+            return {
+                id: request.yar.id,
+            };
+        },
+    });
 }