@adonisjs/transmit-client 0.1.5 → 0.2.0

package/build/transmit.js

@@ -0,0 +1,434 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/subscription_status.ts
+var SubscriptionStatus = {
+  Pending: 0,
+  Created: 1,
+  Deleted: 2
+};
+
+// src/transmit_status.ts
+var TransmitStatus = {
+  Initializing: "initializing",
+  Connecting: "connecting",
+  Connected: "connected",
+  Disconnected: "disconnected",
+  Reconnecting: "reconnecting"
+};
+
+// src/subscription.ts
+var _httpClient, _hooks, _channel, _getEventSourceStatus, _handlers, _status;
+var Subscription = class {
+  constructor(options) {
+    /**
+     * HTTP client instance.
+     */
+    __privateAdd(this, _httpClient, void 0);
+    /**
+     * Hook instance.
+     */
+    __privateAdd(this, _hooks, void 0);
+    /**
+     * Channel name.
+     */
+    __privateAdd(this, _channel, void 0);
+    /**
+     * Event source status getter.
+     */
+    __privateAdd(this, _getEventSourceStatus, void 0);
+    /**
+     * Registered message handlers.
+     */
+    __privateAdd(this, _handlers, /* @__PURE__ */ new Set());
+    /**
+     * Current status of the subscription.
+     */
+    __privateAdd(this, _status, SubscriptionStatus.Pending);
+    __privateSet(this, _channel, options.channel);
+    __privateSet(this, _httpClient, options.httpClient);
+    __privateSet(this, _hooks, options.hooks);
+    __privateSet(this, _getEventSourceStatus, options.getEventSourceStatus);
+  }
+  /**
+   * Returns if the subscription is created or not.
+   */
+  get isCreated() {
+    return __privateGet(this, _status) === SubscriptionStatus.Created;
+  }
+  /**
+   * Returns if the subscription is deleted or not.
+   */
+  get isDeleted() {
+    return __privateGet(this, _status) === SubscriptionStatus.Deleted;
+  }
+  /**
+   * Returns the number of registered handlers.
+   */
+  get handlerCount() {
+    return __privateGet(this, _handlers).size;
+  }
+  /**
+   * Run all registered handlers for the subscription.
+   */
+  $runHandler(message) {
+    for (const handler of __privateGet(this, _handlers)) {
+      handler(message);
+    }
+  }
+  async create() {
+    if (this.isCreated) {
+      return;
+    }
+    if (__privateGet(this, _getEventSourceStatus).call(this) !== TransmitStatus.Connected) {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(this.create());
+        }, 100);
+      });
+    }
+    const request = __privateGet(this, _httpClient).createRequest("/__transmit/subscribe", {
+      channel: __privateGet(this, _channel)
+    });
+    __privateGet(this, _hooks)?.beforeSubscribe(request);
+    try {
+      const response = await __privateGet(this, _httpClient).send(request);
+      void response.text();
+      if (!response.ok) {
+        __privateGet(this, _hooks)?.onSubscribeFailed(response);
+        return;
+      }
+      __privateSet(this, _status, SubscriptionStatus.Created);
+      __privateGet(this, _hooks)?.onSubscription(__privateGet(this, _channel));
+    } catch (error) {
+    }
+  }
+  async delete() {
+    if (this.isDeleted || !this.isCreated) {
+      return;
+    }
+    const request = __privateGet(this, _httpClient).createRequest("/__transmit/unsubscribe", {
+      channel: __privateGet(this, _channel)
+    });
+    __privateGet(this, _hooks)?.beforeUnsubscribe(request);
+    try {
+      const response = await __privateGet(this, _httpClient).send(request);
+      void response.text();
+      if (!response.ok) {
+        return;
+      }
+      __privateSet(this, _status, SubscriptionStatus.Deleted);
+      __privateGet(this, _hooks)?.onUnsubscription(__privateGet(this, _channel));
+    } catch (error) {
+    }
+  }
+  onMessage(handler) {
+    __privateGet(this, _handlers).add(handler);
+    return () => {
+      __privateGet(this, _handlers).delete(handler);
+    };
+  }
+  onMessageOnce(handler) {
+    const deleteHandler = this.onMessage((message) => {
+      handler(message);
+      deleteHandler();
+    });
+  }
+};
+_httpClient = new WeakMap();
+_hooks = new WeakMap();
+_channel = new WeakMap();
+_getEventSourceStatus = new WeakMap();
+_handlers = new WeakMap();
+_status = new WeakMap();
+
+// src/http_client.ts
+var _options, _retrieveXsrfToken, retrieveXsrfToken_fn;
+var HttpClient = class {
+  constructor(options) {
+    __privateAdd(this, _retrieveXsrfToken);
+    __privateAdd(this, _options, void 0);
+    __privateSet(this, _options, options);
+  }
+  send(request) {
+    return fetch(request);
+  }
+  createRequest(path, body) {
+    return new Request(`${__privateGet(this, _options).baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-XSRF-TOKEN": __privateMethod(this, _retrieveXsrfToken, retrieveXsrfToken_fn).call(this) ?? ""
+      },
+      body: JSON.stringify({ uid: __privateGet(this, _options).uid, ...body }),
+      credentials: "include"
+    });
+  }
+};
+_options = new WeakMap();
+_retrieveXsrfToken = new WeakSet();
+retrieveXsrfToken_fn = function() {
+  if (typeof document === "undefined")
+    return null;
+  const match = document.cookie.match(new RegExp("(^|;\\s*)(XSRF-TOKEN)=([^;]*)"));
+  return match ? decodeURIComponent(match[3]) : null;
+};
+
+// src/hook_event.ts
+var HookEvent = {
+  BeforeSubscribe: "beforeSubscribe",
+  BeforeUnsubscribe: "beforeUnsubscribe",
+  OnReconnectAttempt: "onReconnectAttempt",
+  OnReconnectFailed: "onReconnectFailed",
+  OnSubscribeFailed: "onSubscribeFailed",
+  OnSubscription: "onSubscription",
+  OnUnsubscription: "onUnsubscription"
+};
+
+// src/hook.ts
+var _handlers2;
+var Hook = class {
+  constructor() {
+    __privateAdd(this, _handlers2, /* @__PURE__ */ new Map());
+  }
+  register(event, handler) {
+    if (!__privateGet(this, _handlers2).has(event)) {
+      __privateGet(this, _handlers2).set(event, /* @__PURE__ */ new Set());
+    }
+    __privateGet(this, _handlers2).get(event)?.add(handler);
+    return this;
+  }
+  beforeSubscribe(request) {
+    __privateGet(this, _handlers2).get(HookEvent.BeforeSubscribe)?.forEach((handler) => handler(request));
+    return this;
+  }
+  beforeUnsubscribe(request) {
+    __privateGet(this, _handlers2).get(HookEvent.BeforeUnsubscribe)?.forEach((handler) => handler(request));
+    return this;
+  }
+  onReconnectAttempt(attempt) {
+    __privateGet(this, _handlers2).get(HookEvent.OnReconnectAttempt)?.forEach((handler) => handler(attempt));
+    return this;
+  }
+  onReconnectFailed() {
+    __privateGet(this, _handlers2).get(HookEvent.OnReconnectFailed)?.forEach((handler) => handler());
+    return this;
+  }
+  onSubscribeFailed(response) {
+    __privateGet(this, _handlers2).get(HookEvent.OnSubscribeFailed)?.forEach((handler) => handler(response));
+    return this;
+  }
+  onSubscription(channel) {
+    __privateGet(this, _handlers2).get(HookEvent.OnSubscription)?.forEach((handler) => handler(channel));
+    return this;
+  }
+  onUnsubscription(channel) {
+    __privateGet(this, _handlers2).get(HookEvent.OnUnsubscription)?.forEach((handler) => handler(channel));
+    return this;
+  }
+};
+_handlers2 = new WeakMap();
+
+// src/transmit.ts
+var _uid, _options2, _subscriptions, _httpClient2, _hooks2, _status2, _eventSource, _eventTarget, _reconnectAttempts, _changeStatus, changeStatus_fn, _connect, connect_fn, _onMessage, onMessage_fn, _onError, onError_fn;
+var Transmit = class {
+  constructor(options) {
+    __privateAdd(this, _changeStatus);
+    __privateAdd(this, _connect);
+    __privateAdd(this, _onMessage);
+    __privateAdd(this, _onError);
+    /**
+     * Unique identifier for this client.
+     */
+    __privateAdd(this, _uid, void 0);
+    /**
+     * Options for this client.
+     */
+    __privateAdd(this, _options2, void 0);
+    /**
+     * Registered subscriptions.
+     */
+    __privateAdd(this, _subscriptions, /* @__PURE__ */ new Map());
+    /**
+     * HTTP client instance.
+     */
+    __privateAdd(this, _httpClient2, void 0);
+    /**
+     * Hook instance.
+     */
+    __privateAdd(this, _hooks2, void 0);
+    /**
+     * Current status of the client.
+     */
+    __privateAdd(this, _status2, TransmitStatus.Initializing);
+    /**
+     * EventSource instance.
+     */
+    __privateAdd(this, _eventSource, void 0);
+    /**
+     * EventTarget instance.
+     */
+    __privateAdd(this, _eventTarget, void 0);
+    /**
+     * Number of reconnect attempts.
+     */
+    __privateAdd(this, _reconnectAttempts, 0);
+    if (typeof options.uidGenerator === "undefined") {
+      options.uidGenerator = () => crypto.randomUUID();
+    }
+    if (typeof options.eventSourceFactory === "undefined") {
+      options.eventSourceFactory = (...args) => new EventSource(...args);
+    }
+    if (typeof options.eventTargetFactory === "undefined") {
+      options.eventTargetFactory = () => new EventTarget();
+    }
+    if (typeof options.maxReconnectAttempts === "undefined") {
+      options.maxReconnectAttempts = 5;
+    }
+    __privateSet(this, _uid, options.uidGenerator());
+    __privateSet(this, _eventTarget, options.eventTargetFactory());
+    __privateSet(this, _hooks2, new Hook());
+    __privateSet(this, _httpClient2, new HttpClient({
+      baseUrl: options.baseUrl,
+      uid: __privateGet(this, _uid)
+    }));
+    if (options.beforeSubscribe) {
+      __privateGet(this, _hooks2).register(HookEvent.BeforeSubscribe, options.beforeSubscribe);
+    }
+    if (options.beforeUnsubscribe) {
+      __privateGet(this, _hooks2).register(HookEvent.BeforeUnsubscribe, options.beforeUnsubscribe);
+    }
+    if (options.onReconnectAttempt) {
+      __privateGet(this, _hooks2).register(HookEvent.OnReconnectAttempt, options.onReconnectAttempt);
+    }
+    if (options.onReconnectFailed) {
+      __privateGet(this, _hooks2).register(HookEvent.OnReconnectFailed, options.onReconnectFailed);
+    }
+    if (options.onSubscribeFailed) {
+      __privateGet(this, _hooks2).register(HookEvent.OnSubscribeFailed, options.onSubscribeFailed);
+    }
+    if (options.onSubscription) {
+      __privateGet(this, _hooks2).register(HookEvent.OnSubscription, options.onSubscription);
+    }
+    if (options.onUnsubscription) {
+      __privateGet(this, _hooks2).register(HookEvent.OnUnsubscription, options.onUnsubscription);
+    }
+    __privateSet(this, _options2, options);
+    __privateMethod(this, _connect, connect_fn).call(this);
+  }
+  /**
+   * Returns the unique identifier of the client.
+   */
+  get uid() {
+    return __privateGet(this, _uid);
+  }
+  subscription(channel) {
+    const subscription = new Subscription({
+      channel,
+      httpClient: __privateGet(this, _httpClient2),
+      hooks: __privateGet(this, _hooks2),
+      getEventSourceStatus: () => __privateGet(this, _status2)
+    });
+    if (__privateGet(this, _subscriptions).has(channel)) {
+      return __privateGet(this, _subscriptions).get(channel);
+    }
+    __privateGet(this, _subscriptions).set(channel, subscription);
+    return subscription;
+  }
+  on(event, callback) {
+    __privateGet(this, _eventTarget)?.addEventListener(event, callback);
+  }
+  close() {
+    __privateGet(this, _eventSource)?.close();
+  }
+};
+_uid = new WeakMap();
+_options2 = new WeakMap();
+_subscriptions = new WeakMap();
+_httpClient2 = new WeakMap();
+_hooks2 = new WeakMap();
+_status2 = new WeakMap();
+_eventSource = new WeakMap();
+_eventTarget = new WeakMap();
+_reconnectAttempts = new WeakMap();
+_changeStatus = new WeakSet();
+changeStatus_fn = function(status) {
+  __privateSet(this, _status2, status);
+  __privateGet(this, _eventTarget)?.dispatchEvent(new CustomEvent(status));
+};
+_connect = new WeakSet();
+connect_fn = function() {
+  __privateMethod(this, _changeStatus, changeStatus_fn).call(this, TransmitStatus.Connecting);
+  const url = new URL(`${__privateGet(this, _options2).baseUrl}/__transmit/events`);
+  url.searchParams.append("uid", __privateGet(this, _uid));
+  __privateSet(this, _eventSource, __privateGet(this, _options2).eventSourceFactory(url, {
+    withCredentials: true
+  }));
+  __privateGet(this, _eventSource).addEventListener("message", __privateMethod(this, _onMessage, onMessage_fn).bind(this));
+  __privateGet(this, _eventSource).addEventListener("error", __privateMethod(this, _onError, onError_fn).bind(this));
+  __privateGet(this, _eventSource).addEventListener("open", () => {
+    __privateMethod(this, _changeStatus, changeStatus_fn).call(this, TransmitStatus.Connected);
+    __privateSet(this, _reconnectAttempts, 0);
+    for (const subscription of __privateGet(this, _subscriptions).values()) {
+      void subscription.create();
+    }
+  });
+};
+_onMessage = new WeakSet();
+onMessage_fn = function(event) {
+  const data = JSON.parse(event.data);
+  const subscription = __privateGet(this, _subscriptions).get(data.channel);
+  if (typeof subscription === "undefined") {
+    return;
+  }
+  try {
+    subscription.$runHandler(data.payload);
+  } catch (error) {
+    console.log(error);
+  }
+};
+_onError = new WeakSet();
+onError_fn = function() {
+  if (__privateGet(this, _status2) !== TransmitStatus.Reconnecting) {
+    __privateMethod(this, _changeStatus, changeStatus_fn).call(this, TransmitStatus.Disconnected);
+  }
+  __privateMethod(this, _changeStatus, changeStatus_fn).call(this, TransmitStatus.Reconnecting);
+  __privateGet(this, _hooks2).onReconnectAttempt(__privateGet(this, _reconnectAttempts) + 1);
+  if (__privateGet(this, _options2).maxReconnectAttempts && __privateGet(this, _reconnectAttempts) >= __privateGet(this, _options2).maxReconnectAttempts) {
+    __privateGet(this, _eventSource).close();
+    __privateGet(this, _hooks2).onReconnectFailed();
+    return;
+  }
+  __privateWrapper(this, _reconnectAttempts)._++;
+};
+export {
+  Transmit
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/transmit-client",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "A client for the native Server-Sent-Event module of AdonisJS.",
   "keywords": [
     "client",
@@ -15,34 +15,33 @@
   "author": "Romain Lanz <romain.lanz@pm.me>",
   "type": "module",
   "source": "src/transmit.ts",
-  "exports": {
-    "types": "./build/transmit.d.ts",
-    "require": "./build/transmit.cjs",
-    "default": "./build/transmit.modern.js"
-  },
   "main": "./build/transmit.js",
-  "module": "./build/transmit.module.js",
-  "unpkg": "./build/transmit.umd.js",
+  "types": "./build/transmit.d.ts",
   "scripts": {
     "clean": "del-cli build",
     "typecheck": "tsc --noEmit",
     "lint": "eslint . --ext=.ts",
     "format": "prettier --write .",
-    "pretest": "npm run lint",
-    "build": "microbundle",
-    "dev": "microbundle watch",
-    "release": "np",
+    "build": "tsup",
+    "release": "npx release-it",
     "version": "npm run build",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "c8 node --loader ts-node/esm --enable-source-maps bin/test.ts"
   },
   "devDependencies": {
     "@adonisjs/eslint-config": "^1.1.7",
     "@adonisjs/prettier-config": "^1.1.7",
+    "@adonisjs/tsconfig": "^1.3.0",
+    "@japa/assert": "^2.0.0-2",
+    "@japa/runner": "^3.0.0-9",
+    "@swc/core": "^1.4.11",
+    "c8": "^9.1.0",
     "del-cli": "^5.0.0",
     "eslint": "^8.44.0",
-    "microbundle": "^0.15.1",
-    "np": "^8.0.4",
     "prettier": "^3.0.0",
+    "release-it": "^17.1.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.2",
     "typescript": "^5.1.6"
   },
   "files": [
@@ -60,10 +59,27 @@
     "access": "public",
     "tag": "latest"
   },
-  "np": {
-    "message": "chore(release): %s",
-    "tag": "latest",
-    "branch": "main",
-    "anyBranch": false
+  "tsup": {
+    "dts": true,
+    "clean": true,
+    "format": "esm",
+    "sourceMap": true,
+    "target": "es2020",
+    "outDir": "build",
+    "entry": [
+      "src/transmit.ts"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore(release): ${version}",
+      "tagAnnotation": "v${version}",
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true,
+      "releaseName": "v${version}",
+      "web": true
+    }
   }
 }

package/src/hook.ts

@@ -0,0 +1,66 @@
+/*
+ * @adonisjs/transmit-client
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HookEvent } from './hook_event.js'
+
+export class Hook {
+  #handlers = new Map<HookEvent, Set<(...args: any[]) => void>>()
+
+  register(event: HookEvent, handler: (...args: any[]) => void) {
+    if (!this.#handlers.has(event)) {
+      this.#handlers.set(event, new Set())
+    }
+
+    this.#handlers.get(event)?.add(handler)
+
+    return this
+  }
+
+  beforeSubscribe(request: Request) {
+    this.#handlers.get(HookEvent.BeforeSubscribe)?.forEach((handler) => handler(request))
+
+    return this
+  }
+
+  beforeUnsubscribe(request: Request) {
+    this.#handlers.get(HookEvent.BeforeUnsubscribe)?.forEach((handler) => handler(request))
+
+    return this
+  }
+
+  onReconnectAttempt(attempt: number) {
+    this.#handlers.get(HookEvent.OnReconnectAttempt)?.forEach((handler) => handler(attempt))
+
+    return this
+  }
+
+  onReconnectFailed() {
+    this.#handlers.get(HookEvent.OnReconnectFailed)?.forEach((handler) => handler())
+
+    return this
+  }
+
+  onSubscribeFailed(response: Response) {
+    this.#handlers.get(HookEvent.OnSubscribeFailed)?.forEach((handler) => handler(response))
+
+    return this
+  }
+
+  onSubscription(channel: string) {
+    this.#handlers.get(HookEvent.OnSubscription)?.forEach((handler) => handler(channel))
+
+    return this
+  }
+
+  onUnsubscription(channel: string) {
+    this.#handlers.get(HookEvent.OnUnsubscription)?.forEach((handler) => handler(channel))
+
+    return this
+  }
+}

package/src/hook_event.ts

@@ -0,0 +1,20 @@
+/*
+ * @adonisjs/transmit-client
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export const HookEvent = {
+  BeforeSubscribe: 'beforeSubscribe',
+  BeforeUnsubscribe: 'beforeUnsubscribe',
+  OnReconnectAttempt: 'onReconnectAttempt',
+  OnReconnectFailed: 'onReconnectFailed',
+  OnSubscribeFailed: 'onSubscribeFailed',
+  OnSubscription: 'onSubscription',
+  OnUnsubscription: 'onUnsubscription',
+} as const
+
+export type HookEvent = (typeof HookEvent)[keyof typeof HookEvent]

package/src/http_client.ts

@@ -0,0 +1,46 @@
+/*
+ * @adonisjs/transmit-client
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+interface HttpClientOptions {
+  baseUrl: string
+  uid: string
+}
+
+export class HttpClient {
+  #options: HttpClientOptions
+
+  constructor(options: HttpClientOptions) {
+    this.#options = options
+  }
+
+  send(request: Request) {
+    return fetch(request)
+  }
+
+  createRequest(path: string, body: Record<string, unknown>) {
+    return new Request(`${this.#options.baseUrl}${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-XSRF-TOKEN': this.#retrieveXsrfToken() ?? '',
+      },
+      body: JSON.stringify({ uid: this.#options.uid, ...body }),
+      credentials: 'include',
+    })
+  }
+
+  #retrieveXsrfToken() {
+    //? This is a browser-only feature
+    if (typeof document === 'undefined') return null
+
+    const match = document.cookie.match(new RegExp('(^|;\\s*)(XSRF-TOKEN)=([^;]*)'))
+
+    return match ? decodeURIComponent(match[3]) : null
+  }
+}