@fastify/cookie 11.0.0 → 11.0.2

package/test/signer.test.js

@@ -1,138 +1,125 @@
 'use strict'
 
-const { test } = require('tap')
+const { beforeEach, describe, test } = require('node:test')
 const sinon = require('sinon')
 const crypto = require('node:crypto')
-const { Signer, sign, unsign } = require('../signer')
 
-test('default', t => {
-  t.plan(5)
+const { Signer, sign, unsign } = require('../signer')
 
+describe('default', () => {
   const secret = 'my-secret'
   const signer = Signer(secret)
 
-  t.test('signer.sign should throw if there is no value provided', (t) => {
+  test('signer.sign should throw if there is no value provided', (t) => {
     t.plan(1)
-
-    t.throws(() => signer.sign(undefined), 'Cookie value must be provided as a string.')
-  })
-
-  t.test('signer.sign', (t) => {
-    t.plan(2)
-
-    const input = 'some-value'
-    const result = signer.sign(input)
-
-    t.equal(result, sign(input, secret))
-    t.throws(() => sign(undefined), 'Cookie value must be provided as a string.')
+    t.assert.throws(() => signer.sign(undefined), err => err.message === 'Cookie value must be provided as a string.')
   })
 
-  t.test('sign', (t) => {
+  test('sign', (t) => {
     t.plan(5)
 
     const input = 'some-value'
     const result = signer.sign(input)
 
-    t.equal(result, sign(input, secret))
-    t.equal(result, sign(input, [secret]))
-    t.equal(result, sign(input, Buffer.from(secret)))
-    t.equal(result, sign(input, [Buffer.from(secret)]))
+    t.assert.strictEqual(result, sign(input, secret))
+    t.assert.strictEqual(result, sign(input, [secret]))
+    t.assert.strictEqual(result, sign(input, Buffer.from(secret)))
+    t.assert.strictEqual(result, sign(input, [Buffer.from(secret)]))
 
-    t.throws(() => sign(undefined), 'Cookie value must be provided as a string.')
+    t.assert.throws(() => sign(undefined), err => err.message === 'Secret key must be a string or Buffer.')
   })
 
-  t.test('signer.unsign', (t) => {
+  test('signer.unsign', (t) => {
     t.plan(4)
 
     const input = signer.sign('some-value', secret)
     const result = signer.unsign(input)
 
-    t.equal(result.valid, true)
-    t.equal(result.renew, false)
-    t.equal(result.value, 'some-value')
-    t.throws(() => signer.unsign(undefined), 'Signed cookie string must be provided.')
+    t.assert.strictEqual(result.valid, true)
+    t.assert.strictEqual(result.renew, false)
+    t.assert.strictEqual(result.value, 'some-value')
+    t.assert.throws(() => signer.unsign(undefined), err => err.message === 'Signed cookie string must be provided.')
   })
 
-  t.test('unsign', (t) => {
+  test('unsign', (t) => {
     t.plan(6)
 
     const input = sign('some-value', secret)
     const result = unsign(input, secret)
 
-    t.equal(result.valid, true)
-    t.equal(result.renew, false)
-    t.equal(result.value, 'some-value')
-    t.same(result, unsign(input, [secret]))
-    t.throws(() => unsign(undefined), 'Secret key must be a string or Buffer.')
-    t.throws(() => unsign(undefined, secret), 'Signed cookie string must be provided.')
+    t.assert.strictEqual(result.valid, true)
+    t.assert.strictEqual(result.renew, false)
+    t.assert.strictEqual(result.value, 'some-value')
+    t.assert.deepStrictEqual(result, unsign(input, [secret]))
+    t.assert.throws(() => unsign(undefined), err => err.message === 'Secret key must be a string or Buffer.')
+    t.assert.throws(() => unsign(undefined, secret), err => err.message === 'Signed cookie string must be provided.')
   })
 })
 
-test('key rotation', (t) => {
-  t.plan(3)
+describe('key rotation', () => {
   const secret1 = 'my-secret-1'
   const secret2 = 'my-secret-2'
   const secret3 = 'my-secret-3'
   const signer = Signer([secret1, secret2, secret3])
   const signSpy = sinon.spy(crypto, 'createHmac')
 
-  t.beforeEach(() => {
+  beforeEach(() => {
     signSpy.resetHistory()
   })
 
-  t.test('signer.sign always signs using first key', (t) => {
+  test('signer.sign always signs using first key', (t) => {
     t.plan(1)
 
     const input = 'some-value'
     const result = signer.sign(input)
 
-    t.equal(result, sign(input, secret1))
+    t.assert.strictEqual(result, sign(input, secret1))
   })
 
-  t.test('signer.unsign tries to decode using all keys till it finds', (t) => {
+  test('signer.unsign tries to decode using all keys till it finds', (t) => {
     t.plan(4)
 
     const input = sign('some-value', secret2)
     signSpy.resetHistory()
     const result = signer.unsign(input)
 
-    t.equal(result.valid, true)
-    t.equal(result.renew, true)
-    t.equal(result.value, 'some-value')
-    t.equal(signSpy.callCount, 2) // should have returned early when the right key was found
+    t.assert.strictEqual(result.valid, true)
+    t.assert.strictEqual(result.renew, true)
+    t.assert.strictEqual(result.value, 'some-value')
+    t.assert.strictEqual(signSpy.callCount, 2) // should have returned early when the right key was found
   })
 
-  t.test('signer.unsign failure response', (t) => {
+  test('signer.unsign failure response', (t) => {
     t.plan(4)
 
     const input = sign('some-value', 'invalid-secret')
     signSpy.resetHistory()
     const result = signer.unsign(input)
 
-    t.equal(result.valid, false)
-    t.equal(result.renew, false)
-    t.equal(result.value, null)
-    t.equal(signSpy.callCount, 3) // should have tried all 3
+    t.assert.strictEqual(result.valid, false)
+    t.assert.strictEqual(result.renew, false)
+    t.assert.strictEqual(result.value, null)
+    t.assert.strictEqual(signSpy.callCount, 3) // should have tried all 3
   })
 })
 
-test('Signer', t => {
-  t.plan(2)
-
-  t.test('Signer needs a string or Buffer as secret', (t) => {
+describe('Signer', () => {
+  test('Signer needs a string or Buffer as secret', (t) => {
     t.plan(6)
-    t.throws(() => Signer(1), 'Secret key must be a string or Buffer.')
-    t.throws(() => Signer(undefined), 'Secret key must be a string or Buffer.')
-    t.doesNotThrow(() => Signer('secret'))
-    t.doesNotThrow(() => Signer(['secret']))
-    t.doesNotThrow(() => Signer(Buffer.from('deadbeef76543210', 'hex')))
-    t.doesNotThrow(() => Signer([Buffer.from('deadbeef76543210', 'hex')]))
+
+    t.assert.throws(() => Signer(1), err => err.message === 'Secret key must be a string or Buffer.')
+    t.assert.throws(() => Signer(undefined), err => err.message === 'Secret key must be a string or Buffer.')
+    t.assert.doesNotThrow(() => Signer('secret'))
+    t.assert.doesNotThrow(() => Signer(['secret']))
+    t.assert.doesNotThrow(() => Signer(Buffer.from('deadbeef76543210', 'hex')))
+    t.assert.doesNotThrow(() => Signer([Buffer.from('deadbeef76543210', 'hex')]))
   })
 
-  t.test('Signer handles algorithm properly', (t) => {
+  test('Signer handles algorithm properly', (t) => {
     t.plan(3)
-    t.throws(() => Signer('secret', 'invalid'), 'Algorithm invalid not supported.')
-    t.doesNotThrow(() => Signer('secret', 'sha512'))
-    t.doesNotThrow(() => Signer('secret', 'sha256'))
+
+    t.assert.throws(() => Signer('secret', 'invalid'), err => err.message === 'Algorithm invalid not supported.')
+    t.assert.doesNotThrow(() => Signer('secret', 'sha512'))
+    t.assert.doesNotThrow(() => Signer('secret', 'sha256'))
   })
 })

package/types/plugin.d.ts

@@ -1,8 +1,8 @@
 /// <reference types='node' />
 
-import { FastifyPluginCallback } from "fastify";
+import { FastifyPluginCallback } from 'fastify'
 
-declare module "fastify" {
+declare module 'fastify' {
   interface FastifyInstance extends SignerMethods {
     /**
      * Serialize a cookie name-value pair into a Set-Cookie header string
@@ -42,7 +42,7 @@ declare module "fastify" {
      * Signs the specified cookie using the secret/signer provided.
      * @param value cookie value
      */
-     signCookie(value: string): string;
+    signCookie(value: string): string;
 
     /**
      * Unsigns the specified cookie using the secret/signer provided.
@@ -55,7 +55,7 @@ declare module "fastify" {
     name: string,
     value: string,
     options?: fastifyCookie.CookieSerializeOptions
-  ) => FastifyReply;
+  ) => FastifyReply
 
   interface FastifyReply {
     /**
@@ -96,7 +96,7 @@ declare module "fastify" {
 
 type FastifyCookiePlugin = FastifyPluginCallback<
   NonNullable<fastifyCookie.FastifyCookieOptions>
->;
+>
 
 declare namespace fastifyCookie {
   interface SignerBase {
@@ -106,8 +106,8 @@ declare namespace fastifyCookie {
 
   export class Signer implements SignerBase {
     constructor (secrets: string | Array<string> | Buffer | Array<Buffer>, algorithm?: string)
-    sign: (value: string) => string;
-    unsign: (input: string) => UnsignResult;
+    sign: (value: string) => string
+    unsign: (input: string) => UnsignResult
   }
 
   export interface SerializeOptions {
@@ -143,17 +143,11 @@ declare namespace fastifyCookie {
     decode?: (encodedURIComponent: string) => string;
   }
 
-  type HookType = 'onRequest' | 'preParsing' | 'preValidation' | 'preHandler'  | 'preSerialization';
+  type HookType = 'onRequest' | 'preParsing' | 'preValidation' | 'preHandler' | 'preSerialization'
 
-  export interface FastifyCookieOptions {
-    secret?: string | string[] | Buffer | Buffer[] | Signer;
-    hook?: HookType | false;
-    parseOptions?: fastifyCookie.CookieSerializeOptions;
-  }
-
-  export type Sign = (value: string, secret: string | Buffer, algorithm?: string) => string;
-  export type Unsign = (input: string, secret: string | Buffer, algorithm?: string) => UnsignResult;
-  export type SignerFactory = (secrets: string | string[] | Buffer | Buffer[], algorithm?: string) => SignerBase;
+  export type Sign = (value: string, secret: string | Buffer, algorithm?: string) => string
+  export type Unsign = (input: string, secret: string | Buffer, algorithm?: string) => UnsignResult
+  export type SignerFactory = (secrets: string | string[] | Buffer | Buffer[], algorithm?: string) => SignerBase
 
   export type UnsignResult = {
     valid: true;
@@ -165,9 +159,9 @@ declare namespace fastifyCookie {
     value: null;
   }
 
-  export const signerFactory: SignerFactory;
-  export const sign: Sign;
-  export const unsign: Unsign;
+  export const signerFactory: SignerFactory
+  export const sign: Sign
+  export const unsign: Unsign
 
   export interface FastifyCookie extends FastifyCookiePlugin {
     parse: (cookieHeader: string, opts?: ParseOptions) => { [key: string]: string };
@@ -178,19 +172,20 @@ declare namespace fastifyCookie {
     unsign: Unsign;
   }
 
-  export const fastifyCookie: FastifyCookie;
+  export const fastifyCookie: FastifyCookie
 
   export interface FastifyCookieOptions {
-    secret?: string | string[] | Buffer | Buffer[] | SignerBase;
+    secret?: string | string[] | Buffer | Buffer[] | Signer | SignerBase;
     algorithm?: string;
+    hook?: HookType | false;
     parseOptions?: CookieSerializeOptions;
   }
 
-  export { fastifyCookie as default };
+  export { fastifyCookie as default }
 }
 
-declare function fastifyCookie(
+declare function fastifyCookie (
   ...params: Parameters<FastifyCookiePlugin>
-): ReturnType<FastifyCookiePlugin>;
+): ReturnType<FastifyCookiePlugin>
 
-export = fastifyCookie;
+export = fastifyCookie

package/types/plugin.test-d.ts

@@ -1,67 +1,66 @@
-import cookie from '..';
-import { expectError, expectType } from 'tsd';
-import * as fastifyCookieStar from '..';
-import fastifyCookieCjsImport = require('..');
-import fastifyCookieDefault, { fastifyCookie as fastifyCookieNamed  } from '..';
-import fastify, { FastifyInstance, FastifyReply, setCookieWrapper } from 'fastify';
-
-const fastifyCookieCjs = require('..');
-
-const app: FastifyInstance = fastify();
-app.register(fastifyCookieNamed);
-app.register(fastifyCookieDefault);
-app.register(fastifyCookieCjs);
-app.register(fastifyCookieCjsImport.default);
-app.register(fastifyCookieCjsImport.fastifyCookie);
-app.register(fastifyCookieStar.default);
-app.register(fastifyCookieStar.fastifyCookie);
-
-expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieNamed);
-expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieDefault);
-expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieCjsImport.default);
-expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieCjsImport.fastifyCookie);
-expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieStar.default);
+import { expectError, expectType } from 'tsd'
+import * as fastifyCookieStar from '..'
+import fastifyCookieCjsImport = require('..')
+import cookie, { fastifyCookie as fastifyCookieNamed, Signer } from '..'
+import fastify, { FastifyInstance, FastifyReply, setCookieWrapper } from 'fastify'
+
+const fastifyCookieCjs = require('..')
+
+const app: FastifyInstance = fastify()
+app.register(fastifyCookieNamed)
+app.register(cookie)
+app.register(fastifyCookieCjs)
+app.register(fastifyCookieCjsImport.default)
+app.register(fastifyCookieCjsImport.fastifyCookie)
+app.register(fastifyCookieStar.default)
+app.register(fastifyCookieStar.fastifyCookie)
+
+expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieNamed)
+expectType<fastifyCookieStar.FastifyCookie>(cookie)
+expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieCjsImport.default)
+expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieCjsImport.fastifyCookie)
+expectType<fastifyCookieStar.FastifyCookie>(fastifyCookieStar.default)
 expectType<fastifyCookieStar.FastifyCookie>(
   fastifyCookieStar.fastifyCookie
-);
-expectType<any>(fastifyCookieCjs);
+)
+expectType<any>(fastifyCookieCjs)
 
-expectType<fastifyCookieStar.Sign>(fastifyCookieDefault.sign);
-expectType<fastifyCookieStar.Unsign>(fastifyCookieDefault.unsign);
-expectType<fastifyCookieStar.SignerFactory >(fastifyCookieDefault.signerFactory );
+expectType<fastifyCookieStar.Sign>(cookie.sign)
+expectType<fastifyCookieStar.Unsign>(cookie.unsign)
+expectType<fastifyCookieStar.SignerFactory >(cookie.signerFactory)
 
-expectType<fastifyCookieStar.Sign>(fastifyCookieNamed.sign);
-expectType<fastifyCookieStar.Unsign>(fastifyCookieNamed.unsign);
-expectType<fastifyCookieStar.SignerFactory >(fastifyCookieNamed.signerFactory );
+expectType<fastifyCookieStar.Sign>(fastifyCookieNamed.sign)
+expectType<fastifyCookieStar.Unsign>(fastifyCookieNamed.unsign)
+expectType<fastifyCookieStar.SignerFactory >(fastifyCookieNamed.signerFactory)
 
-const server = fastify();
+const server = fastify()
 
-server.register(cookie);
+server.register(cookie)
 
 server.after((_err) => {
   expectType< string >(
     server.serializeCookie('sessionId', 'aYb4uTIhdBXC')
-  );
+  )
 
   expectType<{ [key: string]: string }>(
     // See https://github.com/fastify/fastify-cookie#manual-cookie-parsing
     server.parseCookie('sessionId=aYb4uTIhdBXC')
-  );
+  )
 
   server.get('/', (request, reply) => {
-    const test = request.cookies.test;
-    expectType<string | undefined>(test);
+    const test = request.cookies.test
+    expectType<string | undefined>(test)
 
-    expectType<setCookieWrapper>(reply.cookie);
-    expectType<setCookieWrapper>(reply.setCookie);
+    expectType<setCookieWrapper>(reply.cookie)
+    expectType<setCookieWrapper>(reply.setCookie)
 
     expectType<FastifyReply>(
       reply
         .setCookie('test', test!, { domain: 'example.com', path: '/' })
         .clearCookie('foo')
         .send({ hello: 'world' })
-    );
-  });
+    )
+  })
 
   expectType<(value: string) => string>(server.signCookie)
   expectType<(value: string) => fastifyCookieStar.UnsignResult>(server.unsignCookie)
@@ -71,100 +70,100 @@ server.after((_err) => {
     expectType<(value: string) => string>(reply.signCookie)
     expectType<(value: string) => fastifyCookieStar.UnsignResult>(request.unsignCookie)
     expectType<(value: string) => fastifyCookieStar.UnsignResult>(reply.unsignCookie)
-  });
-});
+  })
+})
 
-const serverWithHttp2 = fastify({ http2: true });
+const serverWithHttp2 = fastify({ http2: true })
 
-serverWithHttp2.register(cookie);
+serverWithHttp2.register(cookie)
 
 serverWithHttp2.after(() => {
   serverWithHttp2.get('/', (request, reply) => {
-    const test = request.cookies.test;
+    const test = request.cookies.test
     reply
       .setCookie('test', test!, { domain: 'example.com', path: '/' })
       .clearCookie('foo')
-      .send({ hello: 'world' });
-  });
-});
+      .send({ hello: 'world' })
+  })
+})
 
-const testSamesiteOptionsApp = fastify();
+const testSamesiteOptionsApp = fastify()
 
-testSamesiteOptionsApp.register(cookie);
+testSamesiteOptionsApp.register(cookie)
 testSamesiteOptionsApp.after(() => {
   server.get('/test-samesite-option-true', (request, reply) => {
-    const test = request.cookies.test;
-    reply.setCookie('test', test!, { sameSite: true }).send({ hello: 'world' });
-  });
+    const test = request.cookies.test
+    reply.setCookie('test', test!, { sameSite: true }).send({ hello: 'world' })
+  })
   server.get('/test-samesite-option-false', (request, reply) => {
-    const test = request.cookies.test;
-    reply.setCookie('test', test!, { sameSite: false }).send({ hello: 'world' });
-  });
+    const test = request.cookies.test
+    reply.setCookie('test', test!, { sameSite: false }).send({ hello: 'world' })
+  })
   server.get('/test-samesite-option-lax', (request, reply) => {
-    const test = request.cookies.test;
-    reply.setCookie('test', test!, { sameSite: 'lax' }).send({ hello: 'world' });
-  });
+    const test = request.cookies.test
+    reply.setCookie('test', test!, { sameSite: 'lax' }).send({ hello: 'world' })
+  })
   server.get('/test-samesite-option-strict', (request, reply) => {
-    const test = request.cookies.test;
+    const test = request.cookies.test
     reply
       .setCookie('test', test!, { sameSite: 'strict' })
-      .send({ hello: 'world' });
-  });
+      .send({ hello: 'world' })
+  })
   server.get('/test-samesite-option-none', (request, reply) => {
-    const test = request.cookies.test;
+    const test = request.cookies.test
     reply
       .setCookie('test', test!, { sameSite: 'none' })
-      .send({ hello: 'world' });
-  });
-});
+      .send({ hello: 'world' })
+  })
+})
 
-const appWithImplicitHttpSigned = fastify();
+const appWithImplicitHttpSigned = fastify()
 
 appWithImplicitHttpSigned.register(cookie, {
   secret: 'testsecret',
-});
+})
 appWithImplicitHttpSigned.register(cookie, {
   secret: 'testsecret',
   algorithm: 'sha512'
-});
+})
 appWithImplicitHttpSigned.after(() => {
   server.get('/', (request, reply) => {
-    appWithImplicitHttpSigned.unsignCookie(request.cookies.test!);
-    appWithImplicitHttpSigned.unsignCookie('test');
+    appWithImplicitHttpSigned.unsignCookie(request.cookies.test!)
+    appWithImplicitHttpSigned.unsignCookie('test')
 
-    reply.unsignCookie(request.cookies.test!);
-    reply.unsignCookie('test');
+    reply.unsignCookie(request.cookies.test!)
+    reply.unsignCookie('test')
 
-    request.unsignCookie(request.cookies.anotherTest!);
-    request.unsignCookie('anotherTest');
+    request.unsignCookie(request.cookies.anotherTest!)
+    request.unsignCookie('anotherTest')
 
-    reply.send({ hello: 'world' });
-  });
-});
+    reply.send({ hello: 'world' })
+  })
+})
 
-const appWithRotationSecret = fastify();
+const appWithRotationSecret = fastify()
 
 appWithRotationSecret.register(cookie, {
   secret: ['testsecret'],
-});
+})
 appWithRotationSecret.after(() => {
   server.get('/', (request, reply) => {
-    reply.unsignCookie(request.cookies.test!);
-    const unsigned = reply.unsignCookie('test');
+    reply.unsignCookie(request.cookies.test!)
+    const unsigned = reply.unsignCookie('test')
 
-    expectType<boolean>(unsigned.valid);
+    expectType<boolean>(unsigned.valid)
     if (unsigned.valid) {
-      expectType<string>(unsigned.value);
+      expectType<string>(unsigned.value)
     } else {
-      expectType<null>(unsigned.value);
+      expectType<null>(unsigned.value)
     }
-    expectType<boolean>(unsigned.renew);
+    expectType<boolean>(unsigned.renew)
 
-    reply.send({ hello: 'world' });
-  });
-});
+    reply.send({ hello: 'world' })
+  })
+})
 
-const appWithParseOptions = fastify();
+const appWithParseOptions = fastify()
 
 const parseOptions: fastifyCookieStar.CookieSerializeOptions = {
   domain: 'example.com',
@@ -177,26 +176,26 @@ const parseOptions: fastifyCookieStar.CookieSerializeOptions = {
   secure: true,
   signed: true,
   partitioned: false,
-};
-expectType<fastifyCookieStar.CookieSerializeOptions>(parseOptions);
+}
+expectType<fastifyCookieStar.CookieSerializeOptions>(parseOptions)
 
 appWithParseOptions.register(cookie, {
   secret: 'testsecret',
   parseOptions,
-});
+})
 appWithParseOptions.after(() => {
   server.get('/', (request, reply) => {
-    const unsigned = reply.unsignCookie(request.cookies.test!);
+    const unsigned = reply.unsignCookie(request.cookies.test!)
 
-    expectType<boolean>(unsigned.valid);
+    expectType<boolean>(unsigned.valid)
     if (unsigned.valid) {
-      expectType<string>(unsigned.value);
+      expectType<string>(unsigned.value)
     } else {
-      expectType<null>(unsigned.value);
+      expectType<null>(unsigned.value)
     }
-    expectType<boolean>(unsigned.renew);
-  });
-});
+    expectType<boolean>(unsigned.renew)
+  })
+})
 
 const appWithCustomSigner = fastify()
 
@@ -214,36 +213,37 @@ appWithCustomSigner.after(() => {
     reply.unsignCookie(request.cookies.test!)
     const unsigned = reply.unsignCookie('test')
 
-    expectType<boolean>(unsigned.valid);
+    expectType<boolean>(unsigned.valid)
     if (unsigned.valid) {
-      expectType<string>(unsigned.value);
+      expectType<string>(unsigned.value)
     } else {
-      expectType<null>(unsigned.value);
+      expectType<null>(unsigned.value)
     }
-    expectType<boolean>(unsigned.renew);
+    expectType<boolean>(unsigned.renew)
 
     reply.send({ hello: 'world' })
   })
 })
 
-new fastifyCookieStar.Signer('secretString')
-new fastifyCookieStar.Signer(['secretStringInArray'])
-new fastifyCookieStar.Signer(Buffer.from('secretString'))
-new fastifyCookieStar.Signer([Buffer.from('secretStringInArray')])
+expectType<Signer>(new fastifyCookieStar.Signer('secretString'))
+expectType<Signer>(new fastifyCookieStar.Signer(['secretStringInArray']))
+expectType<Signer>(new fastifyCookieStar.Signer(Buffer.from('secretString')))
+expectType<Signer>(new fastifyCookieStar.Signer([Buffer.from('secretStringInArray')]))
+
 const signer = new fastifyCookieStar.Signer(['secretStringInArray'], 'sha256')
 signer.sign('Lorem Ipsum')
 signer.unsign('Lorem Ipsum')
 
-const appWithHook: FastifyInstance = fastify();
+const appWithHook: FastifyInstance = fastify()
 
-appWithHook.register(cookie, { hook: false });
-appWithHook.register(cookie, { hook: 'onRequest' });
-appWithHook.register(cookie, { hook: 'preHandler' });
-appWithHook.register(cookie, { hook: 'preParsing' });
-appWithHook.register(cookie, { hook: 'preSerialization' });
-appWithHook.register(cookie, { hook: 'preValidation' });
-expectError(appWithHook.register(cookie, { hook: true }));
-expectError(appWithHook.register(cookie, { hook: 'false' }));
+appWithHook.register(cookie, { hook: false })
+appWithHook.register(cookie, { hook: 'onRequest' })
+appWithHook.register(cookie, { hook: 'preHandler' })
+appWithHook.register(cookie, { hook: 'preParsing' })
+appWithHook.register(cookie, { hook: 'preSerialization' })
+appWithHook.register(cookie, { hook: 'preValidation' })
+expectError(appWithHook.register(cookie, { hook: true }))
+expectError(appWithHook.register(cookie, { hook: 'false' }))
 
-expectType<(cookieHeader: string, opts?: fastifyCookieStar.ParseOptions) => { [key: string]: string }>(fastifyCookieDefault.parse);
-expectType<(name: string, value: string, opts?: fastifyCookieStar.SerializeOptions) => string>(fastifyCookieDefault.serialize);
+expectType<(cookieHeader: string, opts?: fastifyCookieStar.ParseOptions) => { [key: string]: string }>(cookie.parse)
+expectType<(name: string, value: string, opts?: fastifyCookieStar.SerializeOptions) => string>(cookie.serialize)

package/.taprc

@@ -1,2 +0,0 @@
-files:
-  - test/**/*.test.js