@mdsiha369/adonis-mercure 2.1.2

package/build/src/publisher.js

@@ -0,0 +1,54 @@
+import { MercurePublishError } from './errors/publish_error.js';
+import { MercureTimeoutError } from './errors/timeout_error.js';
+const DEFAULT_TIMEOUT = 5000;
+export class Publisher {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    async publish(topics, data = {}, options = {}) {
+        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?.name === 'AbortError') {
+                throw new MercureTimeoutError(timeout);
+            }
+            throw err;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+}

package/build/src/token_generator.d.ts

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

package/build/src/token_generator.js

@@ -0,0 +1,24 @@
+import jws from 'jws';
+export class TokenGenerator {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    generate(payload) {
+        return new Promise((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) {
+        return this.generate({ subscribe: topics });
+    }
+}

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

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

package/build/src/types/extended.js

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

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

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

package/build/src/types/main.js

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

package/build/stubs/config/mercure.stub

@@ -0,0 +1,15 @@
+{{{
+  exports({ to: app.configPath('mercure.ts') })
+}}}
+import env from '#start/env'
+import { defineConfig } from '@mdsiha369/adonis-mercure'
+
+export default defineConfig({
+  endpoint: env.get('MERCURE_ENDPOINT'),
+  adminToken: env.get('MERCURE_ADMIN_JWT'),
+
+  jwt: {
+    alg: 'HS256',
+    secret: env.get('MERCURE_JWT_SECRET'),
+  },
+})

package/build/stubs/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export declare const stubsRoot: string;

package/build/stubs/main.js

@@ -0,0 +1,7 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export const stubsRoot = dirname(fileURLToPath(import.meta.url));

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

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

package/build/tests/fake_mercure.spec.js

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

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

package/build/tests/mercure.spec.js

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

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

package/build/tests/publisher.spec.js

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

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

package/build/tests/token_generator.spec.js

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

@@ -0,0 +1,41 @@
+/*
+|--------------------------------------------------------------------------
+| 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

@@ -0,0 +1,14 @@
+/*
+|--------------------------------------------------------------------------
+| 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/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "@mdsiha369/adonis-mercure",
+  "description": "Mercure Hub integration for AdonisJS v6 — publish real-time updates via Server-Sent Events (SSE)",
+  "version": "2.1.2",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "main": "./build/index.js",
+  "type": "module",
+  "files": [
+    "src",
+    "providers",
+    "index.ts",
+    "configure.ts",
+    "build"
+  ],
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types/main.js",
+    "./services/main": "./build/services/mercure.js",
+    "./mercure_provider": "./build/providers/mercure_provider.js"
+  },
+  "scripts": {
+    "clean": "del-cli build",
+    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext=.ts",
+    "format": "prettier --write .",
+    "quick:test": "node --import=./tsnode.esm.js --enable-source-maps bin/test.ts",
+    "pretest": "npm run lint",
+    "test": "c8 npm run quick:test",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "tsc",
+    "postbuild": "npm run copy:templates",
+    "release": "np",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^7.7.0",
+    "@adonisjs/core": "^6.12.1",
+    "@adonisjs/eslint-config": "^1.3.0",
+    "@adonisjs/prettier-config": "^1.3.0",
+    "@adonisjs/tsconfig": "^1.3.0",
+    "@japa/assert": "^3.0.0",
+    "@japa/runner": "^3.1.4",
+    "@swc/core": "^1.7.10",
+    "@types/jws": "^3.2.10",
+    "@types/node": "^22.2.0",
+    "c8": "^10.1.2",
+    "copyfiles": "^2.4.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.57.0",
+    "np": "^10.0.7",
+    "prettier": "^3.3.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "jws": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@adonisjs/core": "^6.2.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"
+  },
+  "bugs": {
+    "url": "https://github.com/mdsiha/adonis-mercure/issues"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonisjs-package",
+    "mercure",
+    "sse",
+    "server-sent-events",
+    "realtime",
+    "real-time",
+    "typescript",
+    "jwt",
+    "push-notifications",
+    "nodejs"
+  ],
+  "types": "./build/index.d.ts",
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/package"
+  },
+  "prettier": "@adonisjs/prettier-config",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "latest",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
+  "directories": {
+    "test": "tests"
+  }
+}

package/providers/mercure_provider.ts

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