@mdsiha369/adonis-mercure 2.1.2 → 2.2.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright (c) 2024
+Copyright (c) 2024-2026 Michael DAS
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -19,6 +19,7 @@
 
 ## Table of Contents
 
+- [Table of Contents](#table-of-contents)
 - [Requirements](#requirements)
 - [Installation](#installation)
 - [Configuration](#configuration)
@@ -26,11 +27,15 @@
   - [Publish an update](#publish-an-update)
   - [Multiple topics](#multiple-topics)
   - [Private updates](#private-updates)
-  - [SSE options](#sse-options-id-type-retry)
+  - [SSE options (id, type, retry)](#sse-options-id-type-retry)
   - [Generate a subscriber token](#generate-a-subscriber-token)
   - [Health check](#health-check)
 - [Testing](#testing)
 - [API Reference](#api-reference)
+  - [`send(topics, data?, options?)`](#sendtopics-data-options)
+  - [`generateSubscribeToken(topics)`](#generatesubscribetokentopics)
+  - [`generate(payload)`](#generatepayload)
+  - [`ping()`](#ping)
 - [Roadmap](#roadmap)
 - [License](#license)
 
@@ -38,7 +43,7 @@
 
 ## Requirements
 
-- AdonisJS **v6**
+- AdonisJS **v6** or **v7**
 - Node.js **>= 20.6.0**
 - A running [Mercure Hub](https://mercure.rocks/docs/hub/install)
 
@@ -143,14 +148,58 @@ const token = await mercure.generateSubscribeToken(['/orders/42'])
 const token = await mercure.generate({ subscribe: ['/orders/42'] })
 ```
 
-Pass the token to your frontend:
+Tokens do not expire by default. Pass `expiresIn` (in seconds) to limit how long a token stays valid:
 
 ```ts
-const url = new URL('http://localhost:3000/.well-known/mercure')
+const token = await mercure.generateSubscribeToken(['/orders/42'], { expiresIn: 3600 })
+```
+
+Browsers cannot send an `Authorization` header with `EventSource`, so there are two ways to give the token to the hub.
+
+** Option 1: cookie (works with a plain `EventSource`)**
+
+Set the token in a cookie from your AdonisJS app. Use `plainCookie`:
+`response.cookie` signs the value and the hub would reject it.
+
+```ts
+router.get('/orders/:id/subscribe', async ({ params, response }) => {
+  const token = await mercure.generateSubscribeToken([`/orders/${params.id}`])
+
+  response.plainCookie('__Secure-mercure_access_token', token, {
+    httpOnly: true,
+    secure: true,
+    sameSite: 'lax',
+  })
+
+  return { ok: true }
+})
+```
+
+Then, in the browser:
+
+```ts
+const url = new URL('https://hub.example.com/.well-known/mercure')
 url.searchParams.append('topic', '/orders/42')
 
-const eventSource = new EventSource(url.toString(), {
+const eventSource = new EventSource(url, { withCredentials: true })
+```
+
+- The cookie name is the `cookie_name` setting of your hub. Recent hubs default to `__Secure-mercure_access_token`.
+- The app and the hub must share the same registrable domain (for example `app.example.com` and `hub.example.com`). Add `domain: '.example.com'` to the cookie options in that case.
+- The `__Secure-` prefix requires HTTPS. For local HTTP development, configure a cookie name without the prefix in the hub and use `secure: false`.
+
+**Option 2: `Authorization` header**
+
+Use a client that reads the stream with `fetch()`, such as `@microsoft/fetch-event-source`:
+
+```ts
+import { fetchEventSource } from '@microsoft/fetch-event-source'
+
+await fetchEventSource(url.toString(), {
   headers: { Authorization: `Bearer ${token}` },
+  onmessage(event) {
+    console.log(event.data)
+  },
 })
 ```
 
@@ -195,9 +244,15 @@ fake.assertNotSent('/admin/secret')
 // assert nothing was sent at all
 fake.assertNothingSent()
 
+// assert an exact number of messages
+fake.assertSentCount(2)
+
 // inspect all recorded messages
 const messages = fake.getSent()
 
+// inspect the payloads passed to generate() / generateSubscribeToken()
+const tokens = fake.getTokens()
+
 // reset between tests
 fake.clear()
 ```
@@ -226,7 +281,8 @@ Publishes an update to the Mercure Hub.
 | `retry`   | `number`  | Client reconnect delay in milliseconds         |
 
 Throws `MercurePublishError` if the hub returns a non-2xx response.  
-Throws `MercureTimeoutError` if the hub does not respond within the configured timeout.
+Throws `MercureTimeoutError` if the hub does not respond within the configured timeout.  
+Throws `MercureConnectionError` if the hub cannot be reached (connection refused, DNS failure, ...). The original error is available in `error.cause`.
 
 ---
 
@@ -238,6 +294,8 @@ Generates a JWT with `{ subscribe: topics }` for a frontend client.
 const token = await mercure.generateSubscribeToken(['/chat/1', '/notifications/me'])
 ```
 
+Takes an optional last argument `{ expiresIn }` (seconds) that sets the `exp` claim. Without it the token never expires.
+
 ---
 
 ### `generate(payload)`
@@ -248,11 +306,13 @@ Low-level JWT generation. Wraps `payload` under the `mercure` claim.
 const token = await mercure.generate({ subscribe: ['/chat/1'], publish: ['/chat/1'] })
 ```
 
+Takes an optional last argument `{ expiresIn }` (seconds) that sets the `exp` claim. Without it the token never expires.
+
 ---
 
 ### `ping()`
 
-Returns `true` if the hub is reachable, `false` on network error or timeout.
+Returns `true` if the hub answers, including with a 4xx status. Returns `false` if the hub answers with a 5xx status, if the request fails, or if it times out.
 
 ---
 

package/build/index.d.ts

@@ -7,3 +7,6 @@ export { MercureError } from './src/errors/mercure_error.js';
 export { MercurePublishError } from './src/errors/publish_error.js';
 export { MercureConfigError } from './src/errors/config_error.js';
 export { MercureTimeoutError } from './src/errors/timeout_error.js';
+export { MercureConnectionError } from './src/errors/connection_error.js';
+export type { JwtAlgorithm, MercureConfig, MercureContract, SendOptions, TokenOptions, } from './src/types/main.js';
+export type { SentMessage } from './src/fake_mercure.js';

package/build/index.js

@@ -12,3 +12,4 @@ export { MercureError } from './src/errors/mercure_error.js';
 export { MercurePublishError } from './src/errors/publish_error.js';
 export { MercureConfigError } from './src/errors/config_error.js';
 export { MercureTimeoutError } from './src/errors/timeout_error.js';
+export { MercureConnectionError } from './src/errors/connection_error.js';

package/build/src/define_config.js

@@ -1,9 +1,31 @@
 import { MercureConfigError } from './errors/config_error.js';
-const ALLOWED_ALGORITHMS = ['HS256', 'HS384', 'HS512', 'RS256', 'RS384', 'RS512'];
+const ALLOWED_ALGORITHMS = [
+    'HS256',
+    'HS384',
+    'HS512',
+    'RS256',
+    'RS384',
+    'RS512',
+];
+function isHttpUrl(value) {
+    try {
+        const { protocol } = new URL(value);
+        return protocol === 'http:' || protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
 export function defineConfig(config) {
     if (!ALLOWED_ALGORITHMS.includes(config.jwt.alg)) {
         throw new MercureConfigError(`Algorithm "${config.jwt.alg}" is not allowed. Use one of: ${ALLOWED_ALGORITHMS.join(', ')}`);
     }
+    if (!isHttpUrl(config.endpoint)) {
+        throw new MercureConfigError('endpoint must be a valid http(s) URL');
+    }
+    if (!config.adminToken) {
+        throw new MercureConfigError('adminToken must not be empty');
+    }
     if (config.jwt.secret.length < 32) {
         throw new MercureConfigError('jwt.secret must be at least 32 characters long');
     }

package/build/src/errors/connection_error.d.ts

@@ -0,0 +1,4 @@
+import { MercureError } from './mercure_error.js';
+export declare class MercureConnectionError extends MercureError {
+    constructor(cause: unknown);
+}

package/build/src/errors/connection_error.js

@@ -0,0 +1,14 @@
+import { MercureError } from './mercure_error.js';
+export class MercureConnectionError extends MercureError {
+    constructor(cause) {
+        super(`Could not reach the Mercure hub: ${describe(cause)}`, { cause });
+        this.name = 'MercureConnectionError';
+    }
+}
+// fetch() throws a generic "fetch failed" and hides the real reason in `cause.code`
+function describe(error) {
+    const code = error?.cause?.code;
+    if (code)
+        return code;
+    return error instanceof Error ? error.message : String(error);
+}

package/build/src/errors/mercure_error.d.ts

@@ -1,3 +1,3 @@
 export declare class MercureError extends Error {
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
 }

package/build/src/errors/mercure_error.js

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

package/build/src/fake_mercure.d.ts

@@ -1,4 +1,4 @@
-import type { MercureContract, SendOptions } from './types/main.js';
+import type { MercureContract, SendOptions, TokenOptions } from './types/main.js';
 export interface SentMessage {
     topics: string[];
     data: Record<string, unknown>;
@@ -6,13 +6,15 @@ export interface SentMessage {
 }
 export declare class FakeMercure implements MercureContract {
     #private;
-    generate(payload: Record<string, unknown>): Promise<string>;
-    generateSubscribeToken(topics: string[]): Promise<string>;
+    generate(payload: Record<string, unknown>, _options?: TokenOptions): Promise<string>;
+    generateSubscribeToken(topics: string[], options?: TokenOptions): Promise<string>;
     send(topics: string | string[], data?: Record<string, unknown>, isPrivateOrOptions?: boolean | SendOptions): Promise<Response>;
     ping(): Promise<boolean>;
     assertSent(topic: string, data?: Record<string, unknown>): void;
     assertNotSent(topic: string): void;
+    assertSentCount(expected: number): void;
     assertNothingSent(): void;
     getSent(): SentMessage[];
+    getTokens(): Array<Record<string, unknown>>;
     clear(): void;
 }

package/build/src/fake_mercure.js

@@ -1,12 +1,18 @@
+import { isDeepStrictEqual } from 'node:util';
+// Compare what the hub would receive
+function isSameData(a, b) {
+    return isDeepStrictEqual(JSON.parse(JSON.stringify(a)), JSON.parse(JSON.stringify(b)));
+}
 export class FakeMercure {
     #sent = [];
     #tokens = [];
-    async generate(payload) {
+    // options (expiresIn) are accepted to match the contract but have no effect here
+    async generate(payload, _options) {
         this.#tokens.push(payload);
         return 'fake-token';
     }
-    async generateSubscribeToken(topics) {
-        return this.generate({ subscribe: topics });
+    async generateSubscribeToken(topics, options) {
+        return this.generate({ subscribe: topics }, options);
     }
     async send(topics, data = {}, isPrivateOrOptions = false) {
         const topicList = Array.isArray(topics) ? topics : [topics];
@@ -23,7 +29,7 @@ export class FakeMercure {
                 return false;
             if (!data)
                 return true;
-            return JSON.stringify(msg.data) === JSON.stringify(data);
+            return isSameData(msg.data, data);
         });
         if (!match) {
             const found = this.#sent.map((m) => m.topics.join(', ')).join('; ') || 'nothing';
@@ -36,6 +42,11 @@ export class FakeMercure {
             throw new Error(`Expected no message on topic "${topic}" but one was found`);
         }
     }
+    assertSentCount(expected) {
+        if (this.#sent.length !== expected) {
+            throw new Error(`Expected ${expected} message(s) to be sent but found ${this.#sent.length}`);
+        }
+    }
     assertNothingSent() {
         if (this.#sent.length > 0) {
             const topics = this.#sent.map((m) => m.topics.join(', ')).join('; ');
@@ -45,6 +56,9 @@ export class FakeMercure {
     getSent() {
         return [...this.#sent];
     }
+    getTokens() {
+        return [...this.#tokens];
+    }
     clear() {
         this.#sent = [];
         this.#tokens = [];

package/build/src/mercure.d.ts

@@ -1,9 +1,9 @@
-import type { MercureConfig, MercureContract, SendOptions } from './types/main.js';
+import type { MercureConfig, MercureContract, SendOptions, TokenOptions } from './types/main.js';
 export declare class Mercure implements MercureContract {
     #private;
     constructor(config: MercureConfig);
-    generate(payload: Record<string, unknown>): Promise<string>;
-    generateSubscribeToken(topics: string[]): Promise<string>;
+    generate(payload: Record<string, unknown>, options?: TokenOptions): Promise<string>;
+    generateSubscribeToken(topics: string[], options?: TokenOptions): Promise<string>;
     send(topics: string | string[], data?: Record<string, unknown>, isPrivateOrOptions?: boolean | SendOptions): Promise<Response>;
     ping(): Promise<boolean>;
 }

package/build/src/mercure.js

@@ -10,11 +10,11 @@ export class Mercure {
         this.#tokenGenerator = new TokenGenerator(config);
         this.#publisher = new Publisher(config);
     }
-    generate(payload) {
-        return this.#tokenGenerator.generate(payload);
+    generate(payload, options) {
+        return this.#tokenGenerator.generate(payload, options);
     }
-    generateSubscribeToken(topics) {
-        return this.#tokenGenerator.generateSubscribeToken(topics);
+    generateSubscribeToken(topics, options) {
+        return this.#tokenGenerator.generateSubscribeToken(topics, options);
     }
     send(topics, data = {}, isPrivateOrOptions = false) {
         const options = typeof isPrivateOrOptions === 'boolean' ? { private: isPrivateOrOptions } : isPrivateOrOptions;
@@ -25,11 +25,12 @@ export class Mercure {
         const controller = timeout > 0 ? new AbortController() : null;
         const timer = controller ? setTimeout(() => controller.abort(), timeout) : null;
         try {
-            await fetch(this.#config.endpoint, {
+            const response = await fetch(this.#config.endpoint, {
                 method: 'HEAD',
                 signal: controller?.signal,
             });
-            return true;
+            // 4xx still means the hub answered
+            return response.status < 500;
         }
         catch {
             return false;

package/build/src/publisher.js

@@ -1,3 +1,5 @@
+import { MercureConnectionError } from './errors/connection_error.js';
+import { MercureError } from './errors/mercure_error.js';
 import { MercurePublishError } from './errors/publish_error.js';
 import { MercureTimeoutError } from './errors/timeout_error.js';
 const DEFAULT_TIMEOUT = 5000;
@@ -41,10 +43,12 @@ export class Publisher {
             return response;
         }
         catch (err) {
+            if (err instanceof MercureError)
+                throw err;
             if (err?.name === 'AbortError') {
                 throw new MercureTimeoutError(timeout);
             }
-            throw err;
+            throw new MercureConnectionError(err);
         }
         finally {
             if (timer)

package/build/src/token_generator.d.ts

@@ -1,7 +1,7 @@
-import type { MercureConfig } from './types/main.js';
+import type { MercureConfig, TokenOptions } from './types/main.js';
 export declare class TokenGenerator {
     #private;
     constructor(config: MercureConfig);
-    generate(payload: Record<string, unknown>): Promise<string>;
-    generateSubscribeToken(topics: string[]): Promise<string>;
+    generate(payload: Record<string, unknown>, options?: TokenOptions): Promise<string>;
+    generateSubscribeToken(topics: string[], options?: TokenOptions): Promise<string>;
 }

package/build/src/token_generator.js

@@ -1,14 +1,22 @@
 import jws from 'jws';
+import { MercureError } from './errors/mercure_error.js';
 export class TokenGenerator {
     #config;
     constructor(config) {
         this.#config = config;
     }
-    generate(payload) {
+    async generate(payload, options = {}) {
+        const claims = { mercure: payload };
+        if (options.expiresIn !== undefined) {
+            if (!Number.isInteger(options.expiresIn) || options.expiresIn <= 0) {
+                throw new MercureError('expiresIn must be a positive integer (seconds)');
+            }
+            claims.exp = Math.floor(Date.now() / 1000) + options.expiresIn;
+        }
         return new Promise((resolve, reject) => {
             jws
                 .createSign({
-                payload: { mercure: payload },
+                payload: claims,
                 secret: this.#config.jwt.secret,
                 header: { alg: this.#config.jwt.alg },
             })
@@ -16,9 +24,8 @@ export class TokenGenerator {
                 .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) {
-        return this.generate({ subscribe: topics });
+    // wildcard topic grants access to all private events, don't pass user input directly
+    generateSubscribeToken(topics, options) {
+        return this.generate({ subscribe: topics }, options);
     }
 }

package/build/src/types/main.d.ts

@@ -1,15 +1,19 @@
-import type { Algorithm } from 'jws';
+export type JwtAlgorithm = 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512';
 export interface MercureConfig {
     endpoint: string;
     adminToken: string;
     jwt: {
-        alg: Algorithm;
+        alg: JwtAlgorithm;
         secret: string;
     };
     http?: {
         timeout?: number;
     };
 }
+export interface TokenOptions {
+    /** Token lifetime in seconds. No `exp` claim is set when omitted */
+    expiresIn?: number;
+}
 export interface SendOptions {
     private?: boolean;
     id?: string;
@@ -17,8 +21,8 @@ export interface SendOptions {
     retry?: number;
 }
 export interface MercureContract {
-    generate(payload: Record<string, unknown>): Promise<string>;
-    generateSubscribeToken(topics: string[]): Promise<string>;
+    generate(payload: Record<string, unknown>, options?: TokenOptions): Promise<string>;
+    generateSubscribeToken(topics: string[], options?: TokenOptions): Promise<string>;
     send(topics: string | string[], data?: Record<string, unknown>, options?: boolean | SendOptions): Promise<Response>;
     ping(): Promise<boolean>;
 }

package/package.json

@@ -1,17 +1,13 @@
 {
   "name": "@mdsiha369/adonis-mercure",
   "description": "Mercure Hub integration for AdonisJS v6 — publish real-time updates via Server-Sent Events (SSE)",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "engines": {
     "node": ">=20.6.0"
   },
   "main": "./build/index.js",
   "type": "module",
   "files": [
-    "src",
-    "providers",
-    "index.ts",
-    "configure.ts",
     "build"
   ],
   "exports": {
@@ -30,7 +26,7 @@
     "pretest": "npm run lint",
     "test": "c8 npm run quick:test",
     "prebuild": "npm run lint && npm run clean",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "postbuild": "npm run copy:templates",
     "release": "np",
     "version": "npm run build",
@@ -60,14 +56,14 @@
     "jws": "^4.0.0"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^6.2.0"
+    "@adonisjs/core": "^6.2.0 || ^7.0.0"
   },
   "author": "Michael DAŞ",
   "license": "MIT",
   "homepage": "https://github.com/mdsiha/adonis-mercure#readme",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/mdsiha/adonis-mercure.git"
+    "url": "git+https://github.com/mdsiha/adonis-mercure.git"
   },
   "bugs": {
     "url": "https://github.com/mdsiha/adonis-mercure/issues"

package/build/bin/test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/bin/test.js

@@ -1,8 +0,0 @@
-import { assert } from '@japa/assert';
-import { configure, processCLIArgs, run } from '@japa/runner';
-processCLIArgs(process.argv.splice(2));
-configure({
-    files: ['tests/**/*.spec.ts'],
-    plugins: [assert()],
-});
-run();

package/build/tests/fake_mercure.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tests/fake_mercure.spec.js

@@ -1,76 +0,0 @@
-import { test } from '@japa/runner';
-import { FakeMercure } from '../src/fake_mercure.js';
-test.group('FakeMercure', () => {
-    test('records sent messages', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/orders/1', { status: 'shipped' });
-        const sent = fake.getSent();
-        assert.lengthOf(sent, 1);
-        assert.deepEqual(sent[0].topics, ['/orders/1']);
-        assert.deepEqual(sent[0].data, { status: 'shipped' });
-    });
-    test('assertSent passes when topic matches', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', { foo: 'bar' });
-        assert.doesNotThrow(() => fake.assertSent('/topic'));
-    });
-    test('assertSent passes when topic and data match', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', { foo: 'bar' });
-        assert.doesNotThrow(() => fake.assertSent('/topic', { foo: 'bar' }));
-    });
-    test('assertSent throws when topic was not sent', ({ assert }) => {
-        const fake = new FakeMercure();
-        assert.throws(() => fake.assertSent('/missing'));
-    });
-    test('assertSent throws when data does not match', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', { foo: 'bar' });
-        assert.throws(() => fake.assertSent('/topic', { foo: 'wrong' }));
-    });
-    test('assertNotSent passes when topic was never sent', ({ assert }) => {
-        const fake = new FakeMercure();
-        assert.doesNotThrow(() => fake.assertNotSent('/topic'));
-    });
-    test('assertNotSent throws when topic was sent', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', {});
-        assert.throws(() => fake.assertNotSent('/topic'));
-    });
-    test('assertNothingSent passes on fresh instance', ({ assert }) => {
-        const fake = new FakeMercure();
-        assert.doesNotThrow(() => fake.assertNothingSent());
-    });
-    test('assertNothingSent throws after a send', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', {});
-        assert.throws(() => fake.assertNothingSent());
-    });
-    test('clear resets all recorded messages', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', {});
-        fake.clear();
-        assert.lengthOf(fake.getSent(), 0);
-        assert.doesNotThrow(() => fake.assertNothingSent());
-    });
-    test('handles boolean true as private option', async ({ assert }) => {
-        const fake = new FakeMercure();
-        await fake.send('/topic', {}, true);
-        const sent = fake.getSent();
-        assert.isTrue(sent[0].options.private);
-    });
-    test('ping always returns true', async ({ assert }) => {
-        const fake = new FakeMercure();
-        assert.isTrue(await fake.ping());
-    });
-    test('generate stores the payload and returns fake-token', async ({ assert }) => {
-        const fake = new FakeMercure();
-        const token = await fake.generate({ subscribe: ['/chat/1'] });
-        assert.equal(token, 'fake-token');
-    });
-    test('generateSubscribeToken returns fake-token', async ({ assert }) => {
-        const fake = new FakeMercure();
-        const token = await fake.generateSubscribeToken(['/orders/42']);
-        assert.equal(token, 'fake-token');
-    });
-});

package/build/tests/mercure.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tests/mercure.spec.js

@@ -1,84 +0,0 @@
-import { test } from '@japa/runner';
-import { Mercure } from '../src/mercure.js';
-const config = {
-    endpoint: 'http://localhost:3000/.well-known/mercure',
-    adminToken: 'test-admin-token',
-    jwt: { alg: 'HS256', secret: 'test-secret-long-enough-for-tests-ok' },
-};
-test.group('Mercure', (group) => {
-    let originalFetch;
-    group.each.setup(() => {
-        originalFetch = globalThis.fetch;
-    });
-    group.each.teardown(() => {
-        globalThis.fetch = originalFetch;
-    });
-    test('generate returns a signed JWT string', async ({ assert }) => {
-        const mercure = new Mercure(config);
-        const token = await mercure.generate({ subscribe: ['/chat/1'] });
-        assert.isString(token);
-        assert.equal(token.split('.').length, 3);
-    });
-    test('generateSubscribeToken returns JWT with subscribe claim', async ({ assert }) => {
-        const mercure = new Mercure(config);
-        const token = await mercure.generateSubscribeToken(['/orders/42']);
-        const raw = token.split('.')[1];
-        const payload = JSON.parse(Buffer.from(raw, 'base64url').toString());
-        assert.deepEqual(payload.mercure.subscribe, ['/orders/42']);
-    });
-    test('send publishes topic and data to the hub', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Mercure(config).send('/topic', { msg: 'hello' });
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('topic'), '/topic');
-        assert.deepEqual(JSON.parse(body.get('data')), { msg: 'hello' });
-    });
-    test('send converts boolean true to private=on', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Mercure(config).send('/topic', {}, true);
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('private'), 'on');
-    });
-    test('send accepts a SendOptions object', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Mercure(config).send('/topic', {}, { private: true, id: 'evt-1', type: 'order.shipped' });
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('private'), 'on');
-        assert.equal(body.get('id'), 'evt-1');
-        assert.equal(body.get('type'), 'order.shipped');
-    });
-    test('ping returns true when hub responds', async ({ assert }) => {
-        globalThis.fetch = async () => new Response('', { status: 200 });
-        assert.isTrue(await new Mercure(config).ping());
-    });
-    test('ping returns true even on hub 4xx response', async ({ assert }) => {
-        globalThis.fetch = async () => new Response('', { status: 401 });
-        assert.isTrue(await new Mercure(config).ping());
-    });
-    test('ping returns false on network error', async ({ assert }) => {
-        globalThis.fetch = async () => {
-            throw new Error('Network error');
-        };
-        assert.isFalse(await new Mercure(config).ping());
-    });
-    test('ping returns false on timeout', async ({ assert }) => {
-        globalThis.fetch = async () => {
-            const err = new Error('The operation was aborted');
-            err.name = 'AbortError';
-            throw err;
-        };
-        assert.isFalse(await new Mercure(config).ping());
-    });
-});

package/build/tests/publisher.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tests/publisher.spec.js

@@ -1,101 +0,0 @@
-import { test } from '@japa/runner';
-import { Publisher } from '../src/publisher.js';
-import { MercurePublishError } from '../src/errors/publish_error.js';
-import { MercureTimeoutError } from '../src/errors/timeout_error.js';
-const config = {
-    endpoint: 'http://localhost:3000/.well-known/mercure',
-    adminToken: 'test-token',
-    jwt: { alg: 'HS256', secret: 'test-secret' },
-};
-test.group('Publisher', (group) => {
-    let originalFetch;
-    group.each.setup(() => {
-        originalFetch = globalThis.fetch;
-    });
-    group.each.teardown(() => {
-        globalThis.fetch = originalFetch;
-    });
-    test('posts to the configured endpoint', async ({ assert }) => {
-        let capturedUrl = '';
-        globalThis.fetch = async (url, _init) => {
-            capturedUrl = url;
-            return new Response('1', { status: 200 });
-        };
-        const publisher = new Publisher(config);
-        await publisher.publish('test-topic', { hello: 'world' });
-        assert.equal(capturedUrl, config.endpoint);
-    });
-    test('sends topic and data in the body', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        const publisher = new Publisher(config);
-        await publisher.publish('my-topic', { msg: 'hello' });
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('topic'), 'my-topic');
-        assert.deepEqual(JSON.parse(body.get('data')), { msg: 'hello' });
-    });
-    test('appends private=on when option is set', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Publisher(config).publish('topic', {}, { private: true });
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('private'), 'on');
-    });
-    test('appends id, type, retry when provided', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Publisher(config).publish('topic', {}, { id: 'msg-1', type: 'order.created', retry: 5000 });
-        const body = new URLSearchParams(capturedBody);
-        assert.equal(body.get('id'), 'msg-1');
-        assert.equal(body.get('type'), 'order.created');
-        assert.equal(body.get('retry'), '5000');
-    });
-    test('throws MercurePublishError on non-2xx response', async ({ assert }) => {
-        globalThis.fetch = async () => new Response('Unauthorized', { status: 401 });
-        let caught;
-        try {
-            await new Publisher(config).publish('topic', {});
-        }
-        catch (err) {
-            caught = err;
-        }
-        assert.instanceOf(caught, MercurePublishError);
-        assert.equal(caught.statusCode, 401);
-    });
-    test('throws MercureTimeoutError when request times out', async ({ assert }) => {
-        globalThis.fetch = async () => {
-            const err = new Error('The operation was aborted');
-            err.name = 'AbortError';
-            throw err;
-        };
-        let caught;
-        try {
-            await new Publisher(config).publish('topic', {});
-        }
-        catch (err) {
-            caught = err;
-        }
-        assert.instanceOf(caught, MercureTimeoutError);
-        assert.equal(caught.timeoutMs, 5000);
-    });
-    test('handles multiple topics', async ({ assert }) => {
-        let capturedBody = '';
-        globalThis.fetch = async (_url, init) => {
-            capturedBody = init.body;
-            return new Response('1', { status: 200 });
-        };
-        await new Publisher(config).publish(['/a', '/b'], {});
-        // URLSearchParams.getAll handles repeated keys
-        const body = new URLSearchParams(capturedBody);
-        assert.deepEqual(body.getAll('topic'), ['/a', '/b']);
-    });
-});

package/build/tests/token_generator.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tests/token_generator.spec.js

@@ -1,29 +0,0 @@
-import { test } from '@japa/runner';
-import { TokenGenerator } from '../src/token_generator.js';
-const config = {
-    endpoint: 'http://localhost:3000/.well-known/mercure',
-    adminToken: 'test-token',
-    jwt: { alg: 'HS256', secret: 'test-secret' },
-};
-test.group('TokenGenerator', () => {
-    test('generate returns a JWT string', async ({ assert }) => {
-        const generator = new TokenGenerator(config);
-        const token = await generator.generate({ subscribe: ['*'] });
-        assert.isString(token);
-        assert.equal(token.split('.').length, 3);
-    });
-    test('generated token contains the mercure claim', async ({ assert }) => {
-        const generator = new TokenGenerator(config);
-        const token = await generator.generate({ subscribe: ['/chat/1'] });
-        const raw = token.split('.')[1];
-        const payload = JSON.parse(Buffer.from(raw, 'base64url').toString());
-        assert.deepEqual(payload.mercure.subscribe, ['/chat/1']);
-    });
-    test('generateSubscribeToken wraps topics in subscribe field', async ({ assert }) => {
-        const generator = new TokenGenerator(config);
-        const token = await generator.generateSubscribeToken(['/orders/42']);
-        const raw = token.split('.')[1];
-        const payload = JSON.parse(Buffer.from(raw, 'base64url').toString());
-        assert.deepEqual(payload.mercure.subscribe, ['/orders/42']);
-    });
-});

package/configure.ts

@@ -1,41 +0,0 @@
-/*
-|--------------------------------------------------------------------------
-| Configure hook
-|--------------------------------------------------------------------------
-|
-| The configure hook is called when someone runs "node ace configure <package>"
-| command. You are free to perform any operations inside this function to
-| configure the package.
-|
-| To make things easier, you have access to the underlying "ConfigureCommand"
-| instance and you can use codemods to modify the source files.
-|
-*/
-
-import ConfigureCommand from '@adonisjs/core/commands/configure'
-import { stubsRoot } from './stubs/main.js'
-
-export async function configure(_command: ConfigureCommand) {
-  const codemods = await _command.createCodemods()
-
-  await codemods.makeUsingStub(stubsRoot, 'config/mercure.stub', {})
-
-  await codemods.defineEnvVariables({
-    MERCURE_ENDPOINT: 'http://localhost:3000/.well-known/mercure',
-    MERCURE_ADMIN_JWT: '',
-    MERCURE_JWT_SECRET: '',
-  })
-
-  await codemods.defineEnvValidations({
-    variables: {
-      MERCURE_ENDPOINT: `Env.schema.string({ format: 'url' })`,
-      MERCURE_ADMIN_JWT: `Env.schema.string()`,
-      MERCURE_JWT_SECRET: `Env.schema.string()`,
-    },
-    leadingComment: 'Mercure configuration',
-  })
-
-  await codemods.updateRcFile((rcFile) => {
-    rcFile.addProvider('@mdsiha369/adonis-mercure/mercure_provider')
-  })
-}

package/index.ts

@@ -1,14 +0,0 @@
-/*
-|--------------------------------------------------------------------------
-| Package entrypoint
-|--------------------------------------------------------------------------
-*/
-export { configure } from './configure.js'
-export { Mercure } from './src/mercure.js'
-export { FakeMercure } from './src/fake_mercure.js'
-export { defineConfig } from './src/define_config.js'
-export { stubsRoot } from './stubs/main.js'
-export { MercureError } from './src/errors/mercure_error.js'
-export { MercurePublishError } from './src/errors/publish_error.js'
-export { MercureConfigError } from './src/errors/config_error.js'
-export { MercureTimeoutError } from './src/errors/timeout_error.js'

package/providers/mercure_provider.ts

@@ -1,23 +0,0 @@
-import '../src/types/extended.js'
-import { Mercure } from '../src/mercure.js'
-import { MercureConfigError } from '../src/errors/config_error.js'
-import type { ApplicationService } from '@adonisjs/core/types'
-import type { MercureConfig } from '../src/types/main.js'
-
-export default class MercureProvider {
-  constructor(protected app: ApplicationService) {}
-
-  async boot() {
-    this.app.container.singleton('mercure', async () => {
-      const config = this.app.config.get<MercureConfig | undefined>('mercure')
-
-      if (!config?.endpoint || !config?.adminToken || !config?.jwt?.secret) {
-        throw new MercureConfigError(
-          'Missing or incomplete Mercure config. Run "node ace configure @mdsiha369/adonis-mercure"'
-        )
-      }
-
-      return new Mercure(config)
-    })
-  }
-}

package/src/define_config.ts

@@ -1,18 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/src/errors/publish_error.ts

@@ -1,14 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

package/src/types/main.ts

@@ -1,31 +0,0 @@
-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>
-}