chore: expose authorize method from manager

Author: RomainLanz

src/stream_manager.ts

@@ -9,7 +9,10 @@ import { Stream } from './stream.js'
 import { Storage } from './storage.js'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 
-type AccessCallback = <T>(context: T, params?: any) => Promise<boolean> | boolean
+export type AccessCallback<T extends unknown, U extends Record<string, string>> = (
+  context: T,
+  params: U
+) => Promise<boolean> | boolean
 
 interface OnConnectParams<T> {
   uid: string
@@ -59,7 +62,7 @@ export interface UnsubscribeParams<T> {
 export class StreamManager {
   #storage: Storage
 
-  #securedChannels = new Map<string, AccessCallback>()
+  #securedChannels = new Map<string, AccessCallback<any, any>>()
 
   constructor() {
     this.#storage = new Storage()
@@ -108,7 +111,10 @@ export class StreamManager {
     return true
   }
 
-  authorize(channel: string, callback: AccessCallback) {
+  authorize<T extends unknown, U extends Record<string, string>>(
+    channel: string,
+    callback: AccessCallback<T, U>
+  ) {
     this.#storage.secure(channel)
     this.#securedChannels.set(channel, callback)
   }

src/transmit.ts

@@ -5,15 +5,20 @@
  * @copyright Boring Node
  */
 
+import { clearInterval } from 'node:timers'
 import Emittery from 'emittery'
 import { Bus } from '@boringnode/bus'
 import string from '@poppinss/utils/string'
 import { StreamManager } from './stream_manager.js'
 import { TransportMessageType } from './transport_message_type.js'
 import type { Transport } from '@boringnode/bus/types/main'
 import type { Broadcastable, TransmitConfig } from './types/main.js'
-import type { CreateStreamParams, SubscribeParams, UnsubscribeParams } from './stream_manager.js'
-import { clearInterval } from 'node:timers'
+import type {
+  AccessCallback,
+  CreateStreamParams,
+  SubscribeParams,
+  UnsubscribeParams,
+} from './stream_manager.js'
 
 export interface TransmitLifecycleHooks<T> {
   connect: { uid: string; context: T }
@@ -126,6 +131,13 @@ export class Transmit {
     })
   }
 
+  authorize<T extends unknown, U extends Record<string, string>>(
+    channel: string,
+    callback: AccessCallback<T, U>
+  ) {
+    this.#manager.authorize(channel, callback)
+  }
+
   subscribe<T>(params: Omit<SubscribeParams<T>, 'onSubscribe'>) {
     return this.#manager.subscribe<T>({
       ...params,

tests/transmit.spec.ts

@@ -22,6 +22,91 @@ test.group('Transmit', () => {
     assert.instanceOf(transmit.getManager(), StreamManager)
   })
 
+  test('should call the authorization callback', async ({ assert }) => {
+    const transmit = new Transmit({
+      transport: null,
+    })
+
+    const uid = randomUUID()
+    let authorized = false
+
+    transmit.authorize('channel1', () => {
+      authorized = true
+      return true
+    })
+
+    await transmit.subscribe({ channel: 'channel1', uid })
+
+    assert.isTrue(authorized)
+  })
+
+  test('should call the authorization callback with the context', async ({ assert }) => {
+    assert.plan(1)
+
+    const transmit = new Transmit({
+      transport: null,
+    })
+
+    const uid = randomUUID()
+
+    transmit.authorize('channel1', (context) => {
+      assert.equal(context, 'foo')
+      return true
+    })
+
+    await transmit.subscribe({ channel: 'channel1', uid, context: 'foo' })
+  })
+
+  test('should authorize the subscription', async ({ assert }) => {
+    const transmit = new Transmit({
+      transport: null,
+    })
+
+    const uid = randomUUID()
+
+    transmit.authorize('channel1', () => {
+      return true
+    })
+
+    const authorized = await transmit.subscribe({ channel: 'channel1', uid })
+
+    assert.isTrue(authorized)
+  })
+
+  test('should not authorize the subscription', async ({ assert }) => {
+    const transmit = new Transmit({
+      transport: null,
+    })
+
+    const uid = randomUUID()
+
+    transmit.authorize('channel1', () => {
+      return false
+    })
+
+    const authorized = await transmit.subscribe({ channel: 'channel1', uid })
+
+    assert.isFalse(authorized)
+  })
+
+  test('should authorize with channel params', async ({ assert }) => {
+    const transmit = new Transmit({
+      transport: null,
+    })
+
+    const uid = randomUUID()
+
+    transmit.authorize<any, { id: string }>('channel/:id', (_context, params) => {
+      return params.id === '1'
+    })
+
+    const authorized = await transmit.subscribe({ channel: 'channel/1', uid })
+    const refused = await transmit.subscribe({ channel: 'channel/2', uid })
+
+    assert.isTrue(authorized)
+    assert.isFalse(refused)
+  })
+
   test('should emit an connect event', async ({ assert }, done) => {
     assert.plan(2)