epicenter-libs 3.33.0 → 3.34.1

package/dist/test/adapters/cometd.js

@@ -1,514 +0,0 @@
-import _defineProperty from '../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
-import { isBrowser } from '../utils/helpers.js';
-import EpicenterError from '../utils/error.js';
-import Fault from '../utils/fault.js';
-import config from '../utils/config.js';
-import identification from '../utils/identification.js';
-import errorManager from '../utils/error-manager.js';
-import 'cross-fetch';
-import { get } from './project.js';
-
-const AUTH_TOKEN_KEY = 'com.forio.epicenter.token';
-const MAX_RETRIES = 3;
-const IDLE = 'idle';
-const FAILED = 'failed';
-const CONNECTED = 'connected';
-const SUCCEEDED = 'succeeded';
-const CONNECTING = 'connecting';
-const HANDSHAKING = 'handshaking';
-const DISCONNECTED = 'disconnected';
-const FORBIDDEN = 403;
-const CONNECT_META_CHANNEL = '/meta/connect';
-const DISCONNECT_META_CHANNEL = '/meta/disconnect';
-const HANDSHAKE_META_CHANNEL = '/meta/handshake';
-const COMETD_RECONNECTED = 'COMETD_RECONNECTED';
-const DEFAULT_CHANNEL_PROTOCOL = 'cometd';
-// error messages that indicate session invalidation as
-// described in cometd documentation and oumuamua source code:
-// https://docs.cometd.org/current/reference/#_javascript_disconnect
-// https://github.com/zenbones/SmallMind/blob/main/bayeux/oumuamua/server/spi/src/main/java/org/smallmind/bayeux/oumuamua/server/spi/MetaProcessingException.java
-
-const SESSION_INVALIDATION_ERRORS = ['402', 'session_unknown', 'invalid client id', 'missing client id', 'session has been disconnected', 'invalid session type', 'handshake_denied', 'handshake_failed'];
-function isSessionInvalidationError(errorMessage) {
-  const lowerError = errorMessage.toLowerCase();
-  return SESSION_INVALIDATION_ERRORS.some(pattern => {
-    return lowerError.includes(pattern);
-  });
-}
-function isIllegalStateError(error) {
-  return error instanceof Error && error.message.toLowerCase().includes('illegal state');
-}
-function shouldRehandshake(reply) {
-  var _reply$advice, _reply$error;
-  const advice = (_reply$advice = reply.advice) === null || _reply$advice === void 0 ? void 0 : _reply$advice.reconnect;
-  if (advice === 'handshake') {
-    return true;
-  }
-  const errorMessage = (_reply$error = reply.error) !== null && _reply$error !== void 0 ? _reply$error : '';
-  return isSessionInvalidationError(errorMessage);
-}
-let cometdInstance;
-class CometdAdapter {
-  constructor() {
-    _defineProperty(this, "url", '');
-    _defineProperty(this, "initialization", undefined);
-    _defineProperty(this, "handshakePromise", undefined);
-    _defineProperty(this, "subscriptions", new Map());
-    _defineProperty(this, "isConnected", false);
-    _defineProperty(this, "handshakeState", IDLE);
-    _defineProperty(this, "pendingOperations", []);
-    _defineProperty(this, "processingQueue", false);
-  }
-  get cometd() {
-    if (!cometdInstance) {
-      throw new EpicenterError('Tried to get non-existent cometd');
-    }
-    return cometdInstance;
-  }
-  set cometd(instance) {
-    cometdInstance = instance;
-  }
-  async startup(options = {
-    logLevel: 'warn'
-  }) {
-    var _project$channelProto;
-    const project = await get();
-    if (!project.channelEnabled) throw new EpicenterError('Push Channels are not enabled on this project');
-    const channelProtocol = ((_project$channelProto = project.channelProtocol) === null || _project$channelProto === void 0 ? void 0 : _project$channelProto.toLowerCase()) || DEFAULT_CHANNEL_PROTOCOL;
-    const {
-      CometD
-    } = await import('../node_modules/cometd/cometd.js');
-    const {
-      AckExtension
-    } = await import('../node_modules/cometd/cometd.js');
-    const {
-      ReloadExtension
-    } = await import('../node_modules/cometd/cometd.js');
-    this.cometd = new CometD();
-    const {
-      apiProtocol,
-      apiHost,
-      apiVersion,
-      accountShortName,
-      projectShortName
-    } = config;
-    const accountProject = accountShortName && projectShortName ? `/${accountShortName}/${projectShortName}` : '/epicenter/manager';
-    this.url = `${apiProtocol}://${apiHost}/push/v${apiVersion}${accountProject}/${channelProtocol}`;
-    this.cometd.registerExtension('ack', new AckExtension());
-    if (isBrowser()) {
-      this.cometd.registerExtension('reload', new ReloadExtension());
-      window.onunload = () => {
-        if (this.cometd.getStatus() === CONNECTED) {
-          if (this.cometd.reload) this.cometd.reload();
-          const transport = this.cometd.getTransport();
-          if (transport) transport.abort();
-        }
-      };
-    }
-    this.cometd.configure({
-      url: this.url,
-      logLevel: options.logLevel
-    });
-    return true;
-  }
-  listenToMetaChannels() {
-    this.cometd.addListener(HANDSHAKE_META_CHANNEL, message => {
-      if (message.successful) {
-        this.handshakeState = SUCCEEDED;
-        this.processPendingOperations();
-      } else {
-        this.handshakeState = FAILED;
-        this.handleHandshakeFailure(message);
-      }
-    });
-    const connectListener = new Promise((resolve, reject) => {
-      this.cometd.addListener(CONNECT_META_CHANNEL, message => {
-        if (this.cometd.isDisconnected()) {
-          return;
-        }
-        const wasConnected = this.isConnected;
-        this.isConnected = message.successful || false;
-        if (!wasConnected && this.isConnected) {
-          const error = new Fault({
-            status: undefined,
-            message: 'Reconnected to CometD',
-            information: {
-              code: COMETD_RECONNECTED
-            }
-          });
-          const retry = () => Promise.resolve();
-          try {
-            const result = errorManager.handle(error, retry);
-            resolve(result);
-          } catch (e) {
-            reject(e);
-          }
-          this.processPendingOperations();
-        } else if (wasConnected && !this.isConnected) {
-          this.handshakeState = IDLE;
-        }
-      });
-    });
-    const disconnectListener = new Promise(resolve => {
-      this.cometd.addListener(DISCONNECT_META_CHANNEL, message => {
-        if (message.successful) {
-          this.isConnected = false;
-          this.handshakeState = IDLE;
-        }
-        resolve(message);
-      });
-    });
-    return Promise.all([connectListener, disconnectListener]);
-  }
-  handleHandshakeFailure(message) {
-    if (shouldRehandshake(message)) {
-      this.handshakeState = IDLE;
-      this.handshakePromise = undefined;
-    }
-  }
-  async processPendingOperations() {
-    if (this.processingQueue || this.pendingOperations.length === 0) return;
-    this.processingQueue = true;
-    const operations = [...this.pendingOperations];
-    this.pendingOperations = [];
-    try {
-      await Promise.all(operations.map(op => op().catch(console.error)));
-    } finally {
-      this.processingQueue = false;
-    }
-  }
-  async init(options) {
-    if (!this.initialization) {
-      this.initialization = this.startup(options);
-    }
-    return this.initialization;
-  }
-
-  // Connects to CometD server
-  async handshake(options = {}) {
-    await this.init();
-
-    // Prevent concurrent handshake attempts
-    if (this.handshakePromise && this.handshakeState === HANDSHAKING) {
-      return this.handshakePromise;
-    }
-    const currentStatus = this.cometd.getStatus();
-
-    // If already connected and handshake succeeded, return immediately
-    if (currentStatus === CONNECTED && this.handshakeState === SUCCEEDED) {
-      return Promise.resolve();
-    }
-
-    // If CometD is connecting or handshaking, don't call handshake again - just wait
-    if (currentStatus === CONNECTING || currentStatus === HANDSHAKING) {
-      if (this.handshakePromise) {
-        return this.handshakePromise;
-      }
-      // Return a rejected promise to indicate we can't handshake right now
-      return Promise.reject(new Error('CometD is already connecting, please wait'));
-    }
-
-    // Only proceed if disconnected
-    if (currentStatus !== DISCONNECTED) {
-      return Promise.resolve();
-    }
-    this.handshakeState = HANDSHAKING;
-    const {
-      session
-    } = identification;
-    let handshakeProps = {};
-    if (session) {
-      handshakeProps = {
-        ext: {
-          [AUTH_TOKEN_KEY]: session.token,
-          ack: true
-        }
-      };
-    }
-    this.cometd.websocketEnabled = true;
-    this.handshakePromise = new Promise((resolve, reject) => {
-      this.cometd.handshake(handshakeProps, handshakeReply => {
-        var _handshakeReply$error;
-        if (handshakeReply.successful) {
-          this.handshakeState = SUCCEEDED;
-          this.listenToMetaChannels();
-          resolve(undefined);
-          return;
-        }
-        this.handshakeState = FAILED;
-        if (shouldRehandshake(handshakeReply)) {
-          this.handshakeState = IDLE;
-          this.handshakePromise = undefined;
-        }
-        const errorMessage = (_handshakeReply$error = handshakeReply.error) !== null && _handshakeReply$error !== void 0 ? _handshakeReply$error : '';
-        const error = new Fault({
-          status: errorMessage.includes('403') ? FORBIDDEN : undefined,
-          message: errorMessage,
-          information: {
-            code: 'COMETD_ERROR',
-            ...handshakeReply
-          }
-        });
-        if (options.inert) {
-          reject(error);
-          return;
-        }
-        const retry = () => this.handshake({
-          inert: true
-        });
-        try {
-          const result = errorManager.handle(error, retry);
-          resolve(result);
-        } catch (e) {
-          reject(e);
-        }
-      });
-    });
-    return this.handshakePromise;
-  }
-  async disconnect() {
-    if (!this.initialization) return Promise.resolve();
-    await this.init();
-    await this.empty();
-    if (this.cometd.getStatus() !== CONNECTED) return Promise.resolve();
-    return new Promise((resolve, reject) => this.cometd.disconnect(disconnectReply => {
-      var _disconnectReply$erro;
-      if (disconnectReply.successful) {
-        resolve(undefined);
-        return;
-      }
-      const errorMessage = (_disconnectReply$erro = disconnectReply.error) !== null && _disconnectReply$erro !== void 0 ? _disconnectReply$erro : '';
-      if (isSessionInvalidationError(errorMessage)) {
-        resolve(undefined);
-        return;
-      }
-      reject(new EpicenterError('Unable to disconnect from CometD server'));
-    }));
-  }
-  async add(channel, update, options = {}) {
-    var _this$cometd;
-    await this.init();
-    const currentStatus = (_this$cometd = this.cometd) === null || _this$cometd === void 0 ? void 0 : _this$cometd.getStatus();
-    if (currentStatus !== CONNECTED) {
-      try {
-        await this.handshake();
-      } catch (error) {
-        var _errorObj$message;
-        const errorObj = error;
-        if (errorObj !== null && errorObj !== void 0 && (_errorObj$message = errorObj.message) !== null && _errorObj$message !== void 0 && _errorObj$message.includes('already connecting')) {
-          var _this$cometd2;
-          // Wait a moment and try again
-          const retryDelay = 500;
-          await new Promise(resolve => setTimeout(resolve, retryDelay));
-          if (((_this$cometd2 = this.cometd) === null || _this$cometd2 === void 0 ? void 0 : _this$cometd2.getStatus()) === CONNECTED) ;
-        }
-        throw error;
-      }
-    }
-    const {
-      session
-    } = identification;
-    const subscriptionProps = !session ? {} : {
-      ext: {
-        [AUTH_TOKEN_KEY]: session.token
-      }
-    };
-    const handleCometdUpdate = message => {
-      // TODO -- figure out why there's ambiguity here and try to remove it
-      let data = message.data;
-      if (typeof data === 'string') {
-        try {
-          data = JSON.parse(data);
-        } catch (_error) {
-          // If parsing fails, use raw string
-        }
-      }
-      return update(data);
-    };
-    return new Promise((resolve, reject) => {
-      let subscription;
-      try {
-        subscription = this.cometd.subscribe(channel.path, handleCometdUpdate, subscriptionProps, subscribeReply => {
-          var _subscribeReply$error;
-          if (subscribeReply.successful) {
-            this.subscriptions.set(channel.path, subscription);
-            resolve(subscription);
-            return;
-          }
-          if (shouldRehandshake(subscribeReply)) {
-            this.handshakeState = IDLE;
-            this.handshakePromise = undefined;
-          }
-          const errorMessage = (_subscribeReply$error = subscribeReply.error) !== null && _subscribeReply$error !== void 0 ? _subscribeReply$error : '';
-          const error = new Fault({
-            status: errorMessage.includes('403') ? FORBIDDEN : undefined,
-            message: errorMessage,
-            information: {
-              code: 'COMETD_ERROR',
-              ...subscribeReply
-            }
-          });
-          if (options.inert) {
-            reject(error);
-            return;
-          }
-          const retry = async () => {
-            if (shouldRehandshake(subscribeReply)) {
-              await this.handshake({
-                inert: true
-              });
-            }
-            return this.add(channel, update, {
-              inert: true
-            });
-          };
-          try {
-            const result = errorManager.handle(error, retry);
-            resolve(result);
-          } catch (e) {
-            reject(e);
-          }
-        });
-      } catch (error) {
-        var _options$_retryCount;
-        const retryCount = (_options$_retryCount = options._retryCount) !== null && _options$_retryCount !== void 0 ? _options$_retryCount : 0;
-        if (isIllegalStateError(error) && retryCount < MAX_RETRIES) {
-          this.handshakeState = IDLE;
-          this.handshakePromise = undefined;
-          this.handshake().then(() => this.add(channel, update, {
-            ...options,
-            _retryCount: retryCount + 1
-          })).then(resolve).catch(reject);
-          return;
-        }
-        reject(error);
-      }
-    });
-  }
-  async publish(channel, content, options = {}) {
-    await this.init();
-    if (this.cometd.getStatus() !== CONNECTED) {
-      await this.handshake();
-    }
-    const {
-      session
-    } = identification;
-    const publishProps = {
-      ext: session ? {
-        [AUTH_TOKEN_KEY]: session.token
-      } : undefined
-    };
-    return new Promise((resolve, reject) => {
-      try {
-        this.cometd.publish(channel.path, content, publishProps, publishReply => {
-          var _publishReply$error;
-          if (publishReply.successful) {
-            resolve(publishReply);
-            return;
-          }
-          if (shouldRehandshake(publishReply)) {
-            this.handshakeState = IDLE;
-            this.handshakePromise = undefined;
-          }
-          const errorMessage = (_publishReply$error = publishReply.error) !== null && _publishReply$error !== void 0 ? _publishReply$error : '';
-          const error = new Fault({
-            status: errorMessage.includes('403') ? FORBIDDEN : undefined,
-            message: errorMessage,
-            information: {
-              code: 'COMETD_ERROR',
-              ...publishReply
-            }
-          });
-          if (options.inert) {
-            reject(error);
-            return;
-          }
-          const retry = async () => {
-            if (shouldRehandshake(publishReply)) {
-              await this.handshake({
-                inert: true
-              });
-            }
-            return this.publish(channel, content, {
-              inert: true
-            });
-          };
-          try {
-            const result = errorManager.handle(error, retry);
-            resolve(result);
-          } catch (e) {
-            reject(e);
-          }
-        });
-      } catch (error) {
-        var _options$_retryCount2;
-        const retryCount = (_options$_retryCount2 = options._retryCount) !== null && _options$_retryCount2 !== void 0 ? _options$_retryCount2 : 0;
-        if (isIllegalStateError(error) && retryCount < MAX_RETRIES) {
-          this.handshakeState = IDLE;
-          this.handshakePromise = undefined;
-          this.handshake().then(() => this.publish(channel, content, {
-            ...options,
-            _retryCount: retryCount + 1
-          })).then(resolve).catch(reject);
-          return;
-        }
-        reject(error);
-      }
-    });
-  }
-  async remove(subscription) {
-    await this.init();
-
-    // Find the subscription by iterating through the map
-    let channelPath;
-    for (const [path, sub] of this.subscriptions.entries()) {
-      if (sub === subscription) {
-        channelPath = path;
-        break;
-      }
-    }
-    if (channelPath) {
-      this.subscriptions.delete(channelPath);
-      if (this.cometd.getStatus() === DISCONNECTED) return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-      try {
-        this.cometd.unsubscribe(subscription, unsubscribeReply => {
-          var _unsubscribeReply$err;
-          if (unsubscribeReply.successful) {
-            resolve(unsubscribeReply);
-            return;
-          }
-          const errorMessage = (_unsubscribeReply$err = unsubscribeReply.error) !== null && _unsubscribeReply$err !== void 0 ? _unsubscribeReply$err : '';
-          if (isSessionInvalidationError(errorMessage)) {
-            resolve(unsubscribeReply);
-            return;
-          }
-          const error = new Fault({
-            status: undefined,
-            message: errorMessage,
-            information: {
-              code: 'COMETD_ERROR',
-              ...unsubscribeReply
-            }
-          });
-          reject(error);
-        });
-      } catch (error) {
-        if (isIllegalStateError(error)) {
-          resolve(undefined);
-          return;
-        }
-        reject(error);
-      }
-    });
-  }
-  async empty() {
-    await this.init();
-    this.cometd.clearSubscriptions();
-    this.subscriptions.clear();
-  }
-}
-const cometdAdapter = new CometdAdapter();
-
-export { cometdAdapter as default };