.github/ISSUE_TEMPLATE/BUG.md

@@ -1,8 +1,8 @@
 ---
-name: "🐛 Bug Report"
+name: '🐛 Bug Report'
-about: "Report an unexpected problem or unintended behavior."
+about: 'Report an unexpected problem or unintended behavior.'
-title: "[Bug]"
+title: '[Bug]'
-labels: "bug"
+labels: 'bug'
 ---
 
 <!--

.github/ISSUE_TEMPLATE/DOCUMENTATION.md

@@ -1,8 +1,8 @@
 ---
-name: "📜 Documentation"
+name: '📜 Documentation'
-about: "Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...)."
+about: 'Correct spelling errors, improvements or additions to documentation files (README, CONTRIBUTING...).'
-title: "[Documentation]"
+title: '[Documentation]'
-labels: "documentation"
+labels: 'documentation'
 ---
 
 <!-- Please make sure your issue has not already been fixed. -->

.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md

@@ -1,8 +1,8 @@
 ---
-name: "✨ Feature Request"
+name: '✨ Feature Request'
-about: "Suggest a new feature idea."
+about: 'Suggest a new feature idea.'
-title: "[Feature]"
+title: '[Feature]'
-labels: "feature request"
+labels: 'feature request'
 ---
 
 <!-- Please make sure your issue has not already been fixed. -->

.github/ISSUE_TEMPLATE/IMPROVEMENT.md

@@ -1,8 +1,8 @@
 ---
-name: "🔧 Improvement"
+name: '🔧 Improvement'
-about: "Improve structure/format/performance/refactor/tests of the code."
+about: 'Improve structure/format/performance/refactor/tests of the code.'
-title: "[Improvement]"
+title: '[Improvement]'
-labels: "improvement"
+labels: 'improvement'
 ---
 
 <!-- Please make sure your issue has not already been fixed. -->

.github/ISSUE_TEMPLATE/QUESTION.md

@@ -1,8 +1,8 @@
 ---
-name: "🙋 Question"
+name: '🙋 Question'
-about: "Further information is requested."
+about: 'Further information is requested.'
-title: "[Question]"
+title: '[Question]'
-labels: "question"
+labels: 'question'
 ---
 
 ### Question

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: "Build"
+name: 'Build'
 
 on:
   push:
@@ -8,20 +8,20 @@ on:
 
 jobs:
   build:
-    runs-on: "ubuntu-latest"
+    runs-on: 'ubuntu-latest'
     steps:
-      - uses: "actions/checkout@v4.0.0"
+      - uses: 'actions/checkout@v4.0.0'
 
-      - name: "Setup Node.js"
+      - name: 'Setup Node.js'
-        uses: "actions/setup-node@v3.8.1"
+        uses: 'actions/setup-node@v3.8.1'
         with:
-          node-version: "20.x"
+          node-version: '20.x'
-          cache: "npm"
+          cache: 'npm'
 
-      - name: "Install dependencies"
+      - name: 'Install dependencies'
-        run: "npm clean-install"
+        run: 'npm clean-install'
 
-      - name: "Build"
+      - name: 'Build'
-        run: "npm run build"
+        run: 'npm run build'
 
-      - run: "npm run build:typescript"
+      - run: 'npm run build:typescript'

.github/workflows/lint.yml

@@ -1,4 +1,4 @@
-name: "Lint"
+name: 'Lint'
 
 on:
   push:
@@ -8,21 +8,21 @@ on:
 
 jobs:
   lint:
-    runs-on: "ubuntu-latest"
+    runs-on: 'ubuntu-latest'
     steps:
-      - uses: "actions/checkout@v4.0.0"
+      - uses: 'actions/checkout@v4.0.0'
 
-      - name: "Setup Node.js"
+      - name: 'Setup Node.js'
-        uses: "actions/setup-node@v3.8.1"
+        uses: 'actions/setup-node@v3.8.1'
         with:
-          node-version: "20.x"
+          node-version: '20.x'
-          cache: "npm"
+          cache: 'npm'
 
-      - name: "Install dependencies"
+      - name: 'Install dependencies'
-        run: "npm clean-install"
+        run: 'npm clean-install'
 
       - run: 'npm run lint:commit -- --to "${{ github.sha }}"'
-      - run: "npm run lint:editorconfig"
+      - run: 'npm run lint:editorconfig'
-      - run: "npm run lint:markdown"
+      - run: 'npm run lint:markdown'
-      - run: "npm run lint:eslint"
+      - run: 'npm run lint:eslint'
-      - run: "npm run lint:prettier"
+      - run: 'npm run lint:prettier'

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: "Release"
+name: 'Release'
 
 on:
   push:
@@ -6,34 +6,34 @@ on:
 
 jobs:
   release:
-    runs-on: "ubuntu-latest"
+    runs-on: 'ubuntu-latest'
     permissions:
-      contents: "write"
+      contents: 'write'
-      issues: "write"
+      issues: 'write'
-      pull-requests: "write"
+      pull-requests: 'write'
-      id-token: "write"
+      id-token: 'write'
     steps:
-      - uses: "actions/checkout@v4.0.0"
+      - uses: 'actions/checkout@v4.0.0'
 
-      - name: "Setup Node.js"
+      - name: 'Setup Node.js'
-        uses: "actions/setup-node@v3.8.1"
+        uses: 'actions/setup-node@v3.8.1'
         with:
-          node-version: "20.x"
+          node-version: '20.x'
-          cache: "npm"
+          cache: 'npm'
 
-      - name: "Install dependencies"
+      - name: 'Install dependencies'
-        run: "npm clean-install"
+        run: 'npm clean-install'
 
-      - name: "Build Package"
+      - name: 'Build Package'
-        run: "npm run build"
+        run: 'npm run build'
 
-      - run: "npm run build:typescript"
+      - run: 'npm run build:typescript'
 
-      - name: "Verify the integrity of provenance attestations and registry signatures for installed dependencies"
+      - name: 'Verify the integrity of provenance attestations and registry signatures for installed dependencies'
-        run: "npm audit signatures"
+        run: 'npm audit signatures'
 
-      - name: "Release"
+      - name: 'Release'
-        run: "npm run release"
+        run: 'npm run release'
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: "Test"
+name: 'Test'
 
 on:
   push:
@@ -8,21 +8,21 @@ on:
 
 jobs:
   test:
-    runs-on: "ubuntu-latest"
+    runs-on: 'ubuntu-latest'
     steps:
-      - uses: "actions/checkout@v4.0.0"
+      - uses: 'actions/checkout@v4.0.0'
 
-      - name: "Setup Node.js"
+      - name: 'Setup Node.js'
-        uses: "actions/setup-node@v3.8.1"
+        uses: 'actions/setup-node@v3.8.1'
         with:
-          node-version: "20.x"
+          node-version: '20.x'
-          cache: "npm"
+          cache: 'npm'
 
-      - name: "Install dependencies"
+      - name: 'Install dependencies'
-        run: "npm clean-install"
+        run: 'npm clean-install'
 
-      - name: "Build"
+      - name: 'Build'
-        run: "npm run build"
+        run: 'npm run build'
 
-      - name: "Test"
+      - name: 'Test'
-        run: "npm run test"
+        run: 'npm run test'

.prettierrc.json

@@ -1,3 +1,6 @@
 {
-  "semi": false
+  "singleQuote": true,
+  "jsxSingleQuote": true,
+  "semi": false,
+  "trailingComma": "none"
 }

README.md

@@ -4,10 +4,6 @@
   <strong>Authenticate socket.io incoming connections with JWTs.</strong>
 </p>
 
-<p align="center">
-  <strong>⚠️ This project is not maintained anymore, you can still use the code as you wish and fork it to maintain it yourself.</strong>
-</p>
-
 <p align="center">
   <a href="./CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat" /></a>
   <a href="./LICENSE"><img src="https://img.shields.io/badge/licence-MIT-blue.svg" alt="Licence MIT"/></a>
@@ -46,24 +42,24 @@ npm install --save @thream/socketio-jwt
 ### Server side
 
 ```ts
-import { Server } from "socket.io"
+import { Server } from 'socket.io'
-import { authorize } from "@thream/socketio-jwt"
+import { authorize } from '@thream/socketio-jwt'
 
 const io = new Server(9000)
 io.use(
   authorize({
-    secret: "your secret or public key",
+    secret: 'your secret or public key'
-  }),
+  })
 )
 
-io.on("connection", async (socket) => {
+io.on('connection', async (socket) => {
   // jwt payload of the connected client
   console.log(socket.decodedToken)
   const clients = await io.sockets.allSockets()
   if (clients != null) {
     for (const clientId of clients) {
       const client = io.sockets.sockets.get(clientId)
-      client?.emit("messages", { message: "Success!" })
+      client?.emit('messages', { message: 'Success!' })
       // we can access the jwt payload of each connected client
       console.log(client?.decodedToken)
     }
@@ -74,12 +70,12 @@ io.on("connection", async (socket) => {
 ### Server side with `jwks-rsa` (example)
 
 ```ts
-import jwksClient from "jwks-rsa"
+import jwksClient from 'jwks-rsa'
-import { Server } from "socket.io"
+import { Server } from 'socket.io'
-import { authorize } from "@thream/socketio-jwt"
+import { authorize } from '@thream/socketio-jwt'
 
 const client = jwksClient({
-  jwksUri: "https://sandrino.auth0.com/.well-known/jwks.json",
+  jwksUri: 'https://sandrino.auth0.com/.well-known/jwks.json'
 })
 
 const io = new Server(9000)
@@ -88,11 +84,11 @@ io.use(
     secret: async (decodedToken) => {
       const key = await client.getSigningKeyAsync(decodedToken.header.kid)
       return key.getPublicKey()
-    },
+    }
-  }),
+  })
 )
 
-io.on("connection", async (socket) => {
+io.on('connection', async (socket) => {
   // jwt payload of the connected client
   console.log(socket.decodedToken)
   // You can do the same things of the previous example there...
@@ -102,21 +98,21 @@ io.on("connection", async (socket) => {
 ### Server side with `onAuthentication` (example)
 
 ```ts
-import { Server } from "socket.io"
+import { Server } from 'socket.io'
-import { authorize } from "@thream/socketio-jwt"
+import { authorize } from '@thream/socketio-jwt'
 
 const io = new Server(9000)
 io.use(
   authorize({
-    secret: "your secret or public key",
+    secret: 'your secret or public key',
     onAuthentication: async (decodedToken) => {
       // return the object that you want to add to the user property
       // or throw an error if the token is unauthorized
-    },
+    }
-  }),
+  })
 )
 
-io.on("connection", async (socket) => {
+io.on('connection', async (socket) => {
   // jwt payload of the connected client
   console.log(socket.decodedToken)
   // You can do the same things of the previous example there...
@@ -134,23 +130,23 @@ io.on("connection", async (socket) => {
 ### Client side
 
 ```ts
-import { io } from "socket.io-client"
+import { io } from 'socket.io-client'
-import { isUnauthorizedError } from "@thream/socketio-jwt/build/UnauthorizedError.js"
+import { isUnauthorizedError } from '@thream/socketio-jwt/build/UnauthorizedError.js'
 
 // Require Bearer Token
-const socket = io("http://localhost:9000", {
+const socket = io('http://localhost:9000', {
-  auth: { token: `Bearer ${yourJWT}` },
+  auth: { token: `Bearer ${yourJWT}` }
 })
 
 // Handling token expiration
-socket.on("connect_error", (error) => {
+socket.on('connect_error', (error) => {
   if (isUnauthorizedError(error)) {
-    console.log("User token has expired")
+    console.log('User token has expired')
   }
 })
 
 // Listening to events
-socket.on("messages", (data) => {
+socket.on('messages', (data) => {
   console.log(data)
 })
 ```

package.json

@@ -58,34 +58,34 @@
     "jsonwebtoken": "9.0.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "18.0.0",
+    "@commitlint/cli": "17.7.1",
-    "@commitlint/config-conventional": "18.0.0",
+    "@commitlint/config-conventional": "17.7.0",
     "@swc/cli": "0.1.62",
-    "@swc/core": "1.3.94",
+    "@swc/core": "1.3.85",
     "@tsconfig/strictest": "2.0.2",
-    "@types/jsonwebtoken": "9.0.4",
+    "@types/jsonwebtoken": "9.0.3",
-    "@types/node": "20.8.7",
+    "@types/node": "20.6.2",
-    "@typescript-eslint/eslint-plugin": "6.9.0",
+    "@typescript-eslint/eslint-plugin": "6.7.2",
-    "@typescript-eslint/parser": "6.9.0",
+    "@typescript-eslint/parser": "6.7.2",
-    "axios": "1.5.1",
+    "axios": "1.5.0",
     "cross-env": "7.0.3",
     "editorconfig-checker": "5.1.1",
-    "eslint": "8.52.0",
+    "eslint": "8.49.0",
-    "eslint-config-conventions": "12.0.0",
+    "eslint-config-conventions": "11.0.1",
     "eslint-config-prettier": "9.0.0",
-    "eslint-plugin-import": "2.29.0",
+    "eslint-plugin-import": "2.28.1",
-    "eslint-plugin-prettier": "5.0.1",
+    "eslint-plugin-prettier": "5.0.0",
     "eslint-plugin-promise": "6.1.1",
     "eslint-plugin-unicorn": "48.0.1",
-    "fastify": "4.24.3",
+    "fastify": "4.23.2",
     "husky": "8.0.3",
-    "lint-staged": "15.0.2",
+    "lint-staged": "14.0.1",
     "markdownlint-cli2": "0.10.0",
     "markdownlint-rule-relative-links": "2.1.0",
     "pinst": "3.0.0",
     "prettier": "3.0.3",
-    "rimraf": "5.0.5",
+    "rimraf": "5.0.1",
-    "semantic-release": "22.0.5",
+    "semantic-release": "22.0.0",
     "socket.io": "4.7.2",
     "socket.io-client": "4.7.2",
     "typescript": "5.2.2"

src/UnauthorizedError.ts

@@ -1,30 +1,30 @@
 export class UnauthorizedError extends Error {
   public inner: { message: string }
-  public data: { message: string; code: string; type: "UnauthorizedError" }
+  public data: { message: string; code: string; type: 'UnauthorizedError' }
 
   constructor(code: string, error: { message: string }) {
     super(error.message)
-    this.name = "UnauthorizedError"
+    this.name = 'UnauthorizedError'
     this.inner = error
     this.data = {
       message: this.message,
       code,
-      type: "UnauthorizedError",
+      type: 'UnauthorizedError'
     }
     Object.setPrototypeOf(this, UnauthorizedError.prototype)
   }
 }
 
 export const isUnauthorizedError = (
-  error: unknown,
+  error: unknown
 ): error is UnauthorizedError => {
   return (
-    typeof error === "object" &&
+    typeof error === 'object' &&
     error != null &&
-    "data" in error &&
+    'data' in error &&
-    typeof error.data === "object" &&
+    typeof error.data === 'object' &&
     error.data != null &&
-    "type" in error.data &&
+    'type' in error.data &&
-    error.data.type === "UnauthorizedError"
+    error.data.type === 'UnauthorizedError'
   )
 }

src/__test__/authorize.test.ts

@@ -1,39 +1,39 @@
-import test from "node:test"
+import test from 'node:test'
-import assert from "node:assert/strict"
+import assert from 'node:assert/strict'
 
-import axios from "axios"
+import axios from 'axios'
-import type { Socket } from "socket.io-client"
+import type { Socket } from 'socket.io-client'
-import { io } from "socket.io-client"
+import { io } from 'socket.io-client'
 
-import { isUnauthorizedError } from "../UnauthorizedError.js"
+import { isUnauthorizedError } from '../UnauthorizedError.js'
-import type { Profile } from "./fixture/index.js"
+import type { Profile } from './fixture/index.js'
 import {
   API_URL,
   fixtureStart,
   fixtureStop,
   getSocket,
-  basicProfile,
+  basicProfile
-} from "./fixture/index.js"
+} from './fixture/index.js'
 
 export const api = axios.create({
   baseURL: API_URL,
   headers: {
-    "Content-Type": "application/json",
+    'Content-Type': 'application/json'
-  },
+  }
 })
 
 const secretCallback = async (): Promise<string> => {
-  return "somesecret"
+  return 'somesecret'
 }
 
-await test("authorize", async (t) => {
+await test('authorize', async (t) => {
-  await t.test("with secret as string in options", async (t) => {
+  await t.test('with secret as string in options', async (t) => {
-    let token = ""
+    let token = ''
     let socket: Socket | null = null
 
     t.beforeEach(async () => {
       await fixtureStart()
-      const response = await api.post("/login", {})
+      const response = await api.post('/login', {})
       token = response.data.token
     })
 
@@ -42,87 +42,87 @@ await test("authorize", async (t) => {
       await fixtureStop()
     })
 
-    await t.test("should emit error with no token provided", () => {
+    await t.test('should emit error with no token provided', () => {
       socket = io(API_URL)
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
-          assert.strictEqual(error.data.message, "no token provided")
+          assert.strictEqual(error.data.message, 'no token provided')
-          assert.strictEqual(error.data.code, "credentials_required")
+          assert.strictEqual(error.data.code, 'credentials_required')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with bad token format", () => {
+    await t.test('should emit error with bad token format', () => {
       socket = io(API_URL, {
-        auth: { token: "testing" },
+        auth: { token: 'testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Format is Authorization: Bearer [token]",
+            'Format is Authorization: Bearer [token]'
           )
-          assert.strictEqual(error.data.code, "credentials_bad_format")
+          assert.strictEqual(error.data.code, 'credentials_bad_format')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with unauthorized handshake", () => {
+    await t.test('should emit error with unauthorized handshake', () => {
       socket = io(API_URL, {
-        auth: { token: "Bearer testing" },
+        auth: { token: 'Bearer testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Unauthorized: Token is missing or invalid Bearer",
+            'Unauthorized: Token is missing or invalid Bearer'
           )
-          assert.strictEqual(error.data.code, "invalid_token")
+          assert.strictEqual(error.data.code, 'invalid_token')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should connect the user", () => {
+    await t.test('should connect the user', () => {
       socket = io(API_URL, {
-        auth: { token: `Bearer ${token}` },
+        auth: { token: `Bearer ${token}` }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
         assert.ok(true)
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.fail(error.message)
       })
     })
   })
 
-  await t.test("with secret as callback in options", async (t) => {
+  await t.test('with secret as callback in options', async (t) => {
-    let token = ""
+    let token = ''
     let socket: Socket | null = null
 
     t.beforeEach(async () => {
       await fixtureStart({ secret: secretCallback })
-      const response = await api.post("/login", {})
+      const response = await api.post('/login', {})
       token = response.data.token
     })
 
@@ -131,83 +131,83 @@ await test("authorize", async (t) => {
       await fixtureStop()
     })
 
-    await t.test("should emit error with no token provided", () => {
+    await t.test('should emit error with no token provided', () => {
       socket = io(API_URL)
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
-          assert.strictEqual(error.data.message, "no token provided")
+          assert.strictEqual(error.data.message, 'no token provided')
-          assert.strictEqual(error.data.code, "credentials_required")
+          assert.strictEqual(error.data.code, 'credentials_required')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with bad token format", () => {
+    await t.test('should emit error with bad token format', () => {
       socket = io(API_URL, {
-        auth: { token: "testing" },
+        auth: { token: 'testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Format is Authorization: Bearer [token]",
+            'Format is Authorization: Bearer [token]'
           )
-          assert.strictEqual(error.data.code, "credentials_bad_format")
+          assert.strictEqual(error.data.code, 'credentials_bad_format')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with unauthorized handshake", () => {
+    await t.test('should emit error with unauthorized handshake', () => {
       socket = io(API_URL, {
-        auth: { token: "Bearer testing" },
+        auth: { token: 'Bearer testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Unauthorized: Token is missing or invalid Bearer",
+            'Unauthorized: Token is missing or invalid Bearer'
           )
-          assert.strictEqual(error.data.code, "invalid_token")
+          assert.strictEqual(error.data.code, 'invalid_token')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should connect the user", () => {
+    await t.test('should connect the user', () => {
       socket = io(API_URL, {
-        auth: { token: `Bearer ${token}` },
+        auth: { token: `Bearer ${token}` }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
         assert.ok(true)
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.fail(error.message)
       })
     })
   })
 
-  await t.test("with onAuthentication callback in options", async (t) => {
+  await t.test('with onAuthentication callback in options', async (t) => {
-    let token = ""
+    let token = ''
-    let wrongToken = ""
+    let wrongToken = ''
     let socket: Socket | null = null
 
     t.beforeEach(async () => {
@@ -215,16 +215,16 @@ await test("authorize", async (t) => {
         secret: secretCallback,
         onAuthentication: (decodedToken: Profile) => {
           if (!decodedToken.checkField) {
-            throw new Error("Check Field validation failed")
+            throw new Error('Check Field validation failed')
           }
           return {
-            email: decodedToken.email,
+            email: decodedToken.email
           }
-        },
+        }
       })
-      const response = await api.post("/login", {})
+      const response = await api.post('/login', {})
       token = response.data.token
-      const responseWrong = await api.post("/login-wrong", {})
+      const responseWrong = await api.post('/login-wrong', {})
       wrongToken = responseWrong.data.token
     })
 
@@ -233,107 +233,107 @@ await test("authorize", async (t) => {
       await fixtureStop()
     })
 
-    await t.test("should emit error with no token provided", () => {
+    await t.test('should emit error with no token provided', () => {
       socket = io(API_URL)
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
-          assert.strictEqual(error.data.message, "no token provided")
+          assert.strictEqual(error.data.message, 'no token provided')
-          assert.strictEqual(error.data.code, "credentials_required")
+          assert.strictEqual(error.data.code, 'credentials_required')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with bad token format", () => {
+    await t.test('should emit error with bad token format', () => {
       socket = io(API_URL, {
-        auth: { token: "testing" },
+        auth: { token: 'testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Format is Authorization: Bearer [token]",
+            'Format is Authorization: Bearer [token]'
           )
-          assert.strictEqual(error.data.code, "credentials_bad_format")
+          assert.strictEqual(error.data.code, 'credentials_bad_format')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should emit error with unauthorized handshake", () => {
+    await t.test('should emit error with unauthorized handshake', () => {
       socket = io(API_URL, {
-        auth: { token: "Bearer testing" },
+        auth: { token: 'Bearer testing' }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.strictEqual(isUnauthorizedError(error), true)
         if (isUnauthorizedError(error)) {
           assert.strictEqual(
             error.data.message,
-            "Unauthorized: Token is missing or invalid Bearer",
+            'Unauthorized: Token is missing or invalid Bearer'
           )
-          assert.strictEqual(error.data.code, "invalid_token")
+          assert.strictEqual(error.data.code, 'invalid_token')
           assert.ok(true)
         } else {
-          assert.fail("should be unauthorized error")
+          assert.fail('should be unauthorized error')
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
 
-    await t.test("should connect the user", () => {
+    await t.test('should connect the user', () => {
       socket = io(API_URL, {
-        auth: { token: `Bearer ${token}` },
+        auth: { token: `Bearer ${token}` }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
         assert.ok(true)
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.fail(error.message)
       })
     })
 
-    await t.test("should contains user properties", () => {
+    await t.test('should contains user properties', () => {
       const socketServer = getSocket()
-      socketServer?.on("connection", (client: any) => {
+      socketServer?.on('connection', (client: any) => {
         assert.strictEqual(client.user.email, basicProfile.email)
         assert.ok(true)
       })
       socket = io(API_URL, {
-        auth: { token: `Bearer ${token}` },
+        auth: { token: `Bearer ${token}` }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         assert.fail(error.message)
       })
     })
 
-    await t.test("should emit error when user validation fails", () => {
+    await t.test('should emit error when user validation fails', () => {
       socket = io(API_URL, {
-        auth: { token: `Bearer ${wrongToken}` },
+        auth: { token: `Bearer ${wrongToken}` }
       })
-      socket.on("connect_error", async (error) => {
+      socket.on('connect_error', async (error) => {
         try {
-          assert.strictEqual(error.message, "Check Field validation failed")
+          assert.strictEqual(error.message, 'Check Field validation failed')
           assert.ok(true)
         } catch {
           assert.fail(error.message)
         }
       })
-      socket.on("connect", async () => {
+      socket.on('connect', async () => {
-        assert.fail("should not connect")
+        assert.fail('should not connect')
       })
     })
   })

src/__test__/fixture/index.ts

@@ -1,16 +1,16 @@
-import jwt from "jsonwebtoken"
+import jwt from 'jsonwebtoken'
-import { Server as SocketIoServer } from "socket.io"
+import { Server as SocketIoServer } from 'socket.io'
-import type { FastifyInstance } from "fastify"
+import type { FastifyInstance } from 'fastify'
-import fastify from "fastify"
+import fastify from 'fastify'
 
-import type { AuthorizeOptions } from "../../index.js"
+import type { AuthorizeOptions } from '../../index.js'
-import { authorize } from "../../index.js"
+import { authorize } from '../../index.js'
 
 interface FastifyIo {
   instance: SocketIoServer
 }
 
-declare module "fastify" {
+declare module 'fastify' {
   export interface FastifyInstance {
     io: FastifyIo
   }
@@ -28,49 +28,49 @@ export interface Profile extends BasicProfile {
 export const PORT = 9000
 export const API_URL = `http://localhost:${PORT}`
 export const basicProfile: BasicProfile = {
-  email: "john@doe.com",
+  email: 'john@doe.com',
-  id: 123,
+  id: 123
 }
 
 let application: FastifyInstance | null = null
 
 export const fixtureStart = async (
-  options: AuthorizeOptions = { secret: "super secret" },
+  options: AuthorizeOptions = { secret: 'super secret' }
 ): Promise<void> => {
   const profile: Profile = { ...basicProfile, checkField: true }
-  let keySecret = ""
+  let keySecret = ''
-  if (typeof options.secret === "string") {
+  if (typeof options.secret === 'string') {
     keySecret = options.secret
   } else {
     keySecret = await options.secret({
-      header: { alg: "HS256" },
+      header: { alg: 'HS256' },
-      payload: profile,
+      payload: profile
     })
   }
   application = fastify()
-  application.post("/login", async (_request, reply) => {
+  application.post('/login', async (_request, reply) => {
     const token = jwt.sign(profile, keySecret, {
-      expiresIn: 60 * 60 * 5,
+      expiresIn: 60 * 60 * 5
     })
     reply.statusCode = 201
     return { token }
   })
-  application.post("/login-wrong", async (_request, reply) => {
+  application.post('/login-wrong', async (_request, reply) => {
     profile.checkField = false
     const token = jwt.sign(profile, keySecret, {
-      expiresIn: 60 * 60 * 5,
+      expiresIn: 60 * 60 * 5
     })
     reply.statusCode = 201
     return { token }
   })
   const instance = new SocketIoServer(application.server)
   instance.use(authorize(options))
-  application.decorate("io", { instance })
+  application.decorate('io', { instance })
-  application.addHook("onClose", (fastify) => {
+  application.addHook('onClose', (fastify) => {
     fastify.io.instance.close()
   })
   await application.listen({
-    port: PORT,
+    port: PORT
   })
 }
 

src/authorize.ts

@@ -1,10 +1,10 @@
-import type { Algorithm } from "jsonwebtoken"
+import type { Algorithm } from 'jsonwebtoken'
-import jwt from "jsonwebtoken"
+import jwt from 'jsonwebtoken'
-import type { Socket } from "socket.io"
+import type { Socket } from 'socket.io'
 
-import { UnauthorizedError } from "./UnauthorizedError.js"
+import { UnauthorizedError } from './UnauthorizedError.js'
 
-declare module "socket.io" {
+declare module 'socket.io' {
   interface Socket extends ExtendedSocket {}
 }
 
@@ -16,7 +16,7 @@ interface ExtendedSocket {
 
 type SocketIOMiddleware = (
   socket: Socket,
-  next: (error?: UnauthorizedError) => void,
+  next: (error?: UnauthorizedError) => void
 ) => void
 
 interface CompleteDecodedToken {
@@ -28,7 +28,7 @@ interface CompleteDecodedToken {
 }
 
 type SecretCallback = (
-  decodedToken: CompleteDecodedToken,
+  decodedToken: CompleteDecodedToken
 ) => Promise<string> | string
 
 export interface AuthorizeOptions {
@@ -38,32 +38,32 @@ export interface AuthorizeOptions {
 }
 
 export const authorize = (options: AuthorizeOptions): SocketIOMiddleware => {
-  const { secret, algorithms = ["HS256"], onAuthentication } = options
+  const { secret, algorithms = ['HS256'], onAuthentication } = options
   return async (socket, next) => {
     let encodedToken: string | null = null
     const { token } = socket.handshake.auth
     if (token != null) {
-      const tokenSplitted = token.split(" ")
+      const tokenSplitted = token.split(' ')
-      if (tokenSplitted.length !== 2 || tokenSplitted[0] !== "Bearer") {
+      if (tokenSplitted.length !== 2 || tokenSplitted[0] !== 'Bearer') {
         return next(
-          new UnauthorizedError("credentials_bad_format", {
+          new UnauthorizedError('credentials_bad_format', {
-            message: "Format is Authorization: Bearer [token]",
+            message: 'Format is Authorization: Bearer [token]'
-          }),
+          })
         )
       }
       encodedToken = tokenSplitted[1]
     }
     if (encodedToken == null) {
       return next(
-        new UnauthorizedError("credentials_required", {
+        new UnauthorizedError('credentials_required', {
-          message: "no token provided",
+          message: 'no token provided'
-        }),
+        })
       )
     }
     socket.encodedToken = encodedToken
     let keySecret: string | null = null
     let decodedToken: any = null
-    if (typeof secret === "string") {
+    if (typeof secret === 'string') {
       keySecret = secret
     } else {
       const completeDecodedToken = jwt.decode(encodedToken, { complete: true })
@@ -73,9 +73,9 @@ export const authorize = (options: AuthorizeOptions): SocketIOMiddleware => {
       decodedToken = jwt.verify(encodedToken, keySecret, { algorithms })
     } catch {
       return next(
-        new UnauthorizedError("invalid_token", {
+        new UnauthorizedError('invalid_token', {
-          message: "Unauthorized: Token is missing or invalid Bearer",
+          message: 'Unauthorized: Token is missing or invalid Bearer'
-        }),
+        })
       )
     }
     socket.decodedToken = decodedToken

src/index.ts

@@ -1,2 +1,2 @@
-export * from "./authorize.js"
+export * from './authorize.js'
-export * from "./UnauthorizedError.js"
+export * from './UnauthorizedError.js'