@mdsiha369/adonis-mercure 2.1.2

package/src/define_config.ts

@@ -0,0 +1,18 @@
+import { MercureConfigError } from './errors/config_error.js'
+import type { MercureConfig } from './types/main.js'
+
+const ALLOWED_ALGORITHMS = ['HS256', 'HS384', 'HS512', 'RS256', 'RS384', 'RS512'] as const
+
+export function defineConfig<T extends MercureConfig>(config: T): T {
+  if (!ALLOWED_ALGORITHMS.includes(config.jwt.alg as (typeof ALLOWED_ALGORITHMS)[number])) {
+    throw new MercureConfigError(
+      `Algorithm "${config.jwt.alg}" is not allowed. Use one of: ${ALLOWED_ALGORITHMS.join(', ')}`
+    )
+  }
+
+  if (config.jwt.secret.length < 32) {
+    throw new MercureConfigError('jwt.secret must be at least 32 characters long')
+  }
+
+  return config
+}

package/src/errors/config_error.ts

@@ -0,0 +1,8 @@
+import { MercureError } from './mercure_error.js'
+
+export class MercureConfigError extends MercureError {
+  constructor(message: string) {
+    super(message)
+    this.name = 'MercureConfigError'
+  }
+}

package/src/errors/mercure_error.ts

@@ -0,0 +1,6 @@
+export class MercureError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'MercureError'
+  }
+}

package/src/errors/publish_error.ts

@@ -0,0 +1,14 @@
+import { MercureError } from './mercure_error.js'
+
+export class MercurePublishError extends MercureError {
+  readonly responseBody: string
+
+  constructor(
+    readonly statusCode: number,
+    responseBody: string
+  ) {
+    super(`Mercure hub returned ${statusCode}`)
+    this.name = 'MercurePublishError'
+    this.responseBody = responseBody.slice(0, 200)
+  }
+}

package/src/errors/timeout_error.ts

@@ -0,0 +1,8 @@
+import { MercureError } from './mercure_error.js'
+
+export class MercureTimeoutError extends MercureError {
+  constructor(readonly timeoutMs: number) {
+    super(`Request to Mercure hub timed out after ${timeoutMs}ms`)
+    this.name = 'MercureTimeoutError'
+  }
+}

package/src/fake_mercure.ts

@@ -0,0 +1,74 @@
+import type { MercureContract, SendOptions } from './types/main.js'
+
+export interface SentMessage {
+  topics: string[]
+  data: Record<string, unknown>
+  options: SendOptions
+}
+
+export class FakeMercure implements MercureContract {
+  #sent: SentMessage[] = []
+  #tokens: Array<Record<string, unknown>> = []
+
+  async generate(payload: Record<string, unknown>): Promise<string> {
+    this.#tokens.push(payload)
+    return 'fake-token'
+  }
+
+  async generateSubscribeToken(topics: string[]): Promise<string> {
+    return this.generate({ subscribe: topics })
+  }
+
+  async send(
+    topics: string | string[],
+    data: Record<string, unknown> = {},
+    isPrivateOrOptions: boolean | SendOptions = false
+  ): Promise<Response> {
+    const topicList = Array.isArray(topics) ? topics : [topics]
+    const options: SendOptions =
+      typeof isPrivateOrOptions === 'boolean' ? { private: isPrivateOrOptions } : isPrivateOrOptions
+
+    this.#sent.push({ topics: topicList, data, options })
+    return new Response('1', { status: 200 })
+  }
+
+  async ping(): Promise<boolean> {
+    return true
+  }
+
+  assertSent(topic: string, data?: Record<string, unknown>): void {
+    const match = this.#sent.find((msg) => {
+      if (!msg.topics.includes(topic)) return false
+      if (!data) return true
+      return JSON.stringify(msg.data) === JSON.stringify(data)
+    })
+
+    if (!match) {
+      const found = this.#sent.map((m) => m.topics.join(', ')).join('; ') || 'nothing'
+      throw new Error(`Expected a message on topic "${topic}" but found: [${found}]`)
+    }
+  }
+
+  assertNotSent(topic: string): void {
+    const match = this.#sent.find((msg) => msg.topics.includes(topic))
+    if (match) {
+      throw new Error(`Expected no message on topic "${topic}" but one was found`)
+    }
+  }
+
+  assertNothingSent(): void {
+    if (this.#sent.length > 0) {
+      const topics = this.#sent.map((m) => m.topics.join(', ')).join('; ')
+      throw new Error(`Expected nothing to be sent but found messages on: [${topics}]`)
+    }
+  }
+
+  getSent(): SentMessage[] {
+    return [...this.#sent]
+  }
+
+  clear(): void {
+    this.#sent = []
+    this.#tokens = []
+  }
+}

package/src/mercure.ts

@@ -0,0 +1,54 @@
+import { TokenGenerator } from './token_generator.js'
+import { Publisher } from './publisher.js'
+import type { MercureConfig, MercureContract, SendOptions } from './types/main.js'
+
+const DEFAULT_TIMEOUT = 5000
+
+export class Mercure implements MercureContract {
+  #config: MercureConfig
+  #tokenGenerator: TokenGenerator
+  #publisher: Publisher
+
+  constructor(config: MercureConfig) {
+    this.#config = config
+    this.#tokenGenerator = new TokenGenerator(config)
+    this.#publisher = new Publisher(config)
+  }
+
+  generate(payload: Record<string, unknown>): Promise<string> {
+    return this.#tokenGenerator.generate(payload)
+  }
+
+  generateSubscribeToken(topics: string[]): Promise<string> {
+    return this.#tokenGenerator.generateSubscribeToken(topics)
+  }
+
+  send(
+    topics: string | string[],
+    data: Record<string, unknown> = {},
+    isPrivateOrOptions: boolean | SendOptions = false
+  ): Promise<Response> {
+    const options: SendOptions =
+      typeof isPrivateOrOptions === 'boolean' ? { private: isPrivateOrOptions } : isPrivateOrOptions
+
+    return this.#publisher.publish(topics, data, options)
+  }
+
+  async ping(): Promise<boolean> {
+    const timeout = this.#config.http?.timeout ?? DEFAULT_TIMEOUT
+    const controller = timeout > 0 ? new AbortController() : null
+    const timer = controller ? setTimeout(() => controller.abort(), timeout) : null
+
+    try {
+      await fetch(this.#config.endpoint, {
+        method: 'HEAD',
+        signal: controller?.signal,
+      })
+      return true
+    } catch {
+      return false
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+}

package/src/publisher.ts

@@ -0,0 +1,62 @@
+import { MercurePublishError } from './errors/publish_error.js'
+import { MercureTimeoutError } from './errors/timeout_error.js'
+import type { MercureConfig, SendOptions } from './types/main.js'
+
+const DEFAULT_TIMEOUT = 5000
+
+export class Publisher {
+  #config: MercureConfig
+
+  constructor(config: MercureConfig) {
+    this.#config = config
+  }
+
+  async publish(
+    topics: string | string[],
+    data: Record<string, unknown> = {},
+    options: SendOptions = {}
+  ): Promise<Response> {
+    const topicList = Array.isArray(topics) ? topics : [topics]
+    const form = new URLSearchParams()
+
+    for (const topic of topicList) {
+      form.append('topic', topic)
+    }
+    form.append('data', JSON.stringify(data))
+
+    if (options.private) form.append('private', 'on')
+    if (options.id) form.append('id', options.id)
+    if (options.type) form.append('type', options.type)
+    if (options.retry !== undefined) form.append('retry', String(options.retry))
+
+    const timeout = this.#config.http?.timeout ?? DEFAULT_TIMEOUT
+    const controller = timeout > 0 ? new AbortController() : null
+    const timer = controller ? setTimeout(() => controller.abort(), timeout) : null
+
+    try {
+      const response = await fetch(this.#config.endpoint, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.#config.adminToken}`,
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: form.toString(),
+        signal: controller?.signal,
+      })
+
+      if (!response.ok) {
+        const body = await response.text()
+        throw new MercurePublishError(response.status, body)
+      }
+
+      return response
+    } catch (err) {
+      if ((err as Error)?.name === 'AbortError') {
+        throw new MercureTimeoutError(timeout)
+      }
+      throw err
+    } finally {
+      if (timer) clearTimeout(timer)
+    }
+  }
+}

package/src/token_generator.ts

@@ -0,0 +1,29 @@
+import jws from 'jws'
+import type { MercureConfig } from './types/main.js'
+
+export class TokenGenerator {
+  #config: MercureConfig
+
+  constructor(config: MercureConfig) {
+    this.#config = config
+  }
+
+  generate(payload: Record<string, unknown>): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      jws
+        .createSign({
+          payload: { mercure: payload },
+          secret: this.#config.jwt.secret,
+          header: { alg: this.#config.jwt.alg },
+        })
+        .on('error', reject)
+        .on('done', resolve)
+    })
+  }
+
+  // WARNING: never pass user-controlled topics directly — a wildcard topic ('*')
+  // would grant the token holder access to all private events.
+  generateSubscribeToken(topics: string[]): Promise<string> {
+    return this.generate({ subscribe: topics })
+  }
+}

package/src/types/extended.ts

@@ -0,0 +1,7 @@
+import { Mercure } from '../mercure.js'
+
+declare module '@adonisjs/core/types' {
+  export interface ContainerBindings {
+    mercure: Mercure
+  }
+}

package/src/types/main.ts

@@ -0,0 +1,31 @@
+import type { Algorithm } from 'jws'
+
+export interface MercureConfig {
+  endpoint: string
+  adminToken: string
+  jwt: {
+    alg: Algorithm
+    secret: string
+  }
+  http?: {
+    timeout?: number
+  }
+}
+
+export interface SendOptions {
+  private?: boolean
+  id?: string
+  type?: string
+  retry?: number
+}
+
+export interface MercureContract {
+  generate(payload: Record<string, unknown>): Promise<string>
+  generateSubscribeToken(topics: string[]): Promise<string>
+  send(
+    topics: string | string[],
+    data?: Record<string, unknown>,
+    options?: boolean | SendOptions
+  ): Promise<Response>
+  ping(): Promise<boolean>
+}