@fastify/cookie 11.0.1 → 11.1.0

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 → index.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/index.tst.ts

@@ -0,0 +1,290 @@
+import { expect } from 'tstyche'
+import * as fastifyCookieStar from '..'
+import fastifyCookieCjsImport = require('..')
+import cookie, { fastifyCookie as fastifyCookieNamed, Signer } from '..'
+import fastify, {
+  type FastifyInstance,
+  type FastifyReply,
+  type 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)
+
+expect(fastifyCookieNamed).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(cookie).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(
+  fastifyCookieCjsImport.default
+).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(
+  fastifyCookieCjsImport.fastifyCookie
+).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(fastifyCookieStar.default).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(
+  fastifyCookieStar.fastifyCookie
+).type.toBe<fastifyCookieStar.FastifyCookie>()
+expect(fastifyCookieCjs).type.toBe<any>()
+
+expect(cookie.sign).type.toBe<fastifyCookieStar.Sign>()
+expect(cookie.unsign).type.toBe<fastifyCookieStar.Unsign>()
+expect(cookie.signerFactory).type.toBe<fastifyCookieStar.SignerFactory>()
+
+expect(fastifyCookieNamed.sign).type.toBe<fastifyCookieStar.Sign>()
+expect(fastifyCookieNamed.unsign).type.toBe<fastifyCookieStar.Unsign>()
+expect(
+  fastifyCookieNamed.signerFactory
+).type.toBe<fastifyCookieStar.SignerFactory>()
+
+const server = fastify()
+
+server.register(cookie)
+
+server.after((_err) => {
+  expect(
+    server.serializeCookie('sessionId', 'aYb4uTIhdBXC')
+  ).type.toBe<string>()
+
+  expect(server.parseCookie('sessionId=aYb4uTIhdBXC')).type.toBe<{
+    [key: string]: string;
+  }>()
+
+  server.get('/', (request, reply) => {
+    const test = request.cookies.test
+    expect(test).type.toBe<string | undefined>()
+
+    expect(reply.cookie).type.toBe<setCookieWrapper>()
+    expect(reply.setCookie).type.toBe<setCookieWrapper>()
+
+    expect(
+      reply
+        .setCookie('test', test!, { domain: 'example.com', path: '/' })
+        .clearCookie('foo')
+        .send({ hello: 'world' })
+    ).type.toBe<FastifyReply>()
+  })
+
+  expect(server.signCookie).type.toBe<(value: string) => string>()
+  expect(server.unsignCookie).type.toBe<
+    (value: string) => fastifyCookieStar.UnsignResult
+  >()
+
+  server.get('/', (request, reply) => {
+    expect(request.signCookie).type.toBe<(value: string) => string>()
+    expect(reply.signCookie).type.toBe<(value: string) => string>()
+    expect(request.unsignCookie).type.toBe<
+      (value: string) => fastifyCookieStar.UnsignResult
+    >()
+    expect(reply.unsignCookie).type.toBe<
+      (value: string) => fastifyCookieStar.UnsignResult
+    >()
+  })
+})
+
+const serverWithHttp2 = fastify({ http2: true })
+
+serverWithHttp2.register(cookie)
+
+serverWithHttp2.after(() => {
+  serverWithHttp2.get('/', (request, reply) => {
+    const test = request.cookies.test
+    reply
+      .setCookie('test', test!, { domain: 'example.com', path: '/' })
+      .clearCookie('foo')
+      .send({ hello: 'world' })
+  })
+})
+
+const testSamesiteOptionsApp = fastify()
+
+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' })
+  })
+  server.get('/test-samesite-option-false', (request, reply) => {
+    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' })
+  })
+  server.get('/test-samesite-option-strict', (request, reply) => {
+    const test = request.cookies.test
+    reply
+      .setCookie('test', test!, { sameSite: 'strict' })
+      .send({ hello: 'world' })
+  })
+  server.get('/test-samesite-option-none', (request, reply) => {
+    const test = request.cookies.test
+    reply
+      .setCookie('test', test!, { sameSite: 'none' })
+      .send({ hello: 'world' })
+  })
+})
+
+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')
+
+    reply.unsignCookie(request.cookies.test!)
+    reply.unsignCookie('test')
+
+    request.unsignCookie(request.cookies.anotherTest!)
+    request.unsignCookie('anotherTest')
+
+    reply.send({ hello: 'world' })
+  })
+})
+
+const appWithRotationSecret = fastify()
+
+appWithRotationSecret.register(cookie, {
+  secret: ['testsecret']
+})
+appWithRotationSecret.after(() => {
+  server.get('/', (request, reply) => {
+    reply.unsignCookie(request.cookies.test!)
+    const unsigned = reply.unsignCookie('test')
+
+    expect(unsigned.valid).type.toBe<boolean>()
+    if (unsigned.valid) {
+      expect(unsigned.value).type.toBe<string>()
+    } else {
+      expect(unsigned.value).type.toBe<null>()
+    }
+    expect(unsigned.renew).type.toBe<boolean>()
+
+    reply.send({ hello: 'world' })
+  })
+})
+
+const appWithParseOptions = fastify()
+
+const parseOptions: fastifyCookieStar.CookieSerializeOptions = {
+  domain: 'example.com',
+  encode: (value: string) => value,
+  expires: new Date(),
+  httpOnly: true,
+  maxAge: 3600,
+  path: '/',
+  sameSite: 'lax',
+  secure: true,
+  signed: true,
+  partitioned: false
+}
+expect(parseOptions).type.toBe<fastifyCookieStar.CookieSerializeOptions>()
+
+appWithParseOptions.register(cookie, {
+  secret: 'testsecret',
+  parseOptions
+})
+appWithParseOptions.after(() => {
+  server.get('/', (request, reply) => {
+    const unsigned = reply.unsignCookie(request.cookies.test!)
+
+    expect(unsigned.valid).type.toBe<boolean>()
+    if (unsigned.valid) {
+      expect(unsigned.value).type.toBe<string>()
+    } else {
+      expect(unsigned.value).type.toBe<null>()
+    }
+    expect(unsigned.renew).type.toBe<boolean>()
+  })
+})
+
+const appWithCustomSigner = fastify()
+
+appWithCustomSigner.register(cookie, {
+  secret: {
+    sign: (x) => x + '.signed',
+    unsign: (x) => {
+      if (x.endsWith('.signed')) {
+        return { renew: false, valid: true, value: x.slice(0, -7) }
+      }
+      return { renew: false, valid: false, value: null }
+    }
+  }
+})
+appWithCustomSigner.after(() => {
+  server.get('/', (request, reply) => {
+    reply.unsignCookie(request.cookies.test!)
+    const unsigned = reply.unsignCookie('test')
+
+    expect(unsigned.valid).type.toBe<boolean>()
+    if (unsigned.valid) {
+      expect(unsigned.value).type.toBe<string>()
+    } else {
+      expect(unsigned.value).type.toBe<null>()
+    }
+    expect(unsigned.renew).type.toBe<boolean>()
+
+    reply.send({ hello: 'world' })
+  })
+})
+
+expect(new fastifyCookieStar.Signer('secretString')).type.toBe<Signer>()
+expect(
+  new fastifyCookieStar.Signer(['secretStringInArray'])
+).type.toBe<Signer>()
+expect(
+  new fastifyCookieStar.Signer(Buffer.from('secretString'))
+).type.toBe<Signer>()
+expect(
+  new fastifyCookieStar.Signer([Buffer.from('secretStringInArray')])
+).type.toBe<Signer>()
+
+const signer = new fastifyCookieStar.Signer(['secretStringInArray'], 'sha256')
+signer.sign('Lorem Ipsum')
+signer.unsign('Lorem Ipsum')
+
+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' })
+
+expect(appWithHook.register)
+  .type.not.toBeCallableWith(cookie, { hook: true })
+expect(appWithHook.register)
+  .type.not.toBeCallableWith(cookie, { hook: 'false' })
+
+expect(cookie.parse).type.toBe<
+  (
+    cookieHeader: string,
+    opts?: fastifyCookieStar.ParseOptions
+  ) => { [key: string]: string }
+>()
+expect(cookie.serialize).type.toBe<
+  (
+    name: string,
+    value: string,
+    opts?: fastifyCookieStar.SerializeOptions
+  ) => string
+>()

package/.github/stale.yml

@@ -1,21 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - "discussion"
-  - "feature request"
-  - "bug"
-  - "help wanted"
-  - "plugin suggestion"
-  - "good first issue"
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false

package/.taprc

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