@elderbyte/ngx-starter 14.11.0 → 14.11.1

package/src/lib/features/event-source/elder-event-source.service.ts

@@ -0,0 +1,71 @@
+import {Injectable, NgZone} from '@angular/core';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {ReactiveEventSource} from './reactive-event-source';
+
+/**
+ * Angular reactive EventSource integration
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ElderEventSourceService {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger('ElderEventSourceService');
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private zone: NgZone
+  ) { }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Creates an reactive, automatic reconnecting event source.
+   *
+   * @param eventSourceUrl The url to the event source
+   * @param eventSourceInitDict Additional configuration to use when connecting. (optional)
+   */
+  public reactiveEventSource<T = any>(eventSourceUrl: string,
+                                      eventSourceInitDict?: EventSourceInit
+  ): ReactiveEventSource<T> {
+    return ReactiveEventSource.staticUrl(
+      this.zone,
+      eventSourceUrl,
+      eventSourceInitDict,
+    );
+  }
+
+  /**
+   * Creates an reactive, automatic reconnecting event source. Each time the event source
+   * reconnects, the url provider is invoked.
+   *
+   * @param eventSourceUrlProvider The url provider of the event source
+   * @param eventSourceInitDict Additional configuration to use when connecting. (optional)
+   */
+  public reactiveEventSourceDynamic<T = any>(
+    eventSourceUrlProvider: () => string,
+    eventSourceInitDict?: EventSourceInit
+  ): ReactiveEventSource<T> {
+    return ReactiveEventSource.dynamicUrl(
+      this.zone,
+      eventSourceUrlProvider,
+      eventSourceInitDict,
+    );
+  }
+
+}

package/src/lib/features/event-source/public_api.ts

@@ -0,0 +1,3 @@
+export * from './reactive-event-source';
+export * from './elder-event-source.service';
+

package/src/lib/features/event-source/reactive-event-source.ts

@@ -0,0 +1,252 @@
+import {Observable, Subject, Subscription} from 'rxjs';
+import {NgZone} from '@angular/core';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {map} from 'rxjs/operators';
+
+/**
+ * This class provides a reactive wrapper around an event source.
+ *
+ * It supports event type filtering out of the box and manages the registrations.
+ *
+ * Additionally, it also handles reconnects since the default reconect handling by browsers
+ * is not working in a lot of cases (5xx errors etc).
+ *
+ */
+export class ReactiveEventSource<T = any> {
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger('ReactiveEventSource');
+
+  private readonly eventTopics = new Map<string, Subject<MessageEvent>>();
+
+  private currentSource: EventSource;
+  private currentListeners = new Set<string>();
+
+  private _closed: boolean;
+
+  private _unsubscribeSub: Subscription;
+
+  /***************************************************************************
+   *                                                                         *
+   * Static Builder                                                          *
+   *                                                                         *
+   **************************************************************************/
+
+  public static staticUrl<T>(
+    zone: NgZone,
+    eventSourceUrl: string,
+    eventSourceInitDict?: EventSourceInit
+  ): ReactiveEventSource<T> {
+
+    if (!eventSourceUrl) {
+      throw new Error('You must provide a event source url!');
+    }
+    return new ReactiveEventSource(zone, () => eventSourceUrl, eventSourceInitDict);
+  }
+
+  public static dynamicUrl<T>(
+    zone: NgZone,
+    eventSourceUrlProvider: () => string,
+    eventSourceInitDict?: EventSourceInit
+  ): ReactiveEventSource<T> {
+    return new ReactiveEventSource(zone, eventSourceUrlProvider, eventSourceInitDict);
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  private constructor(
+    private readonly zone: NgZone,
+    private eventSourceUrlProvider: () => string,
+    private eventSourceInitDict?: EventSourceInit
+  ) {
+    if (!eventSourceUrlProvider) {
+      throw new Error('You must provide a event source url provider!');
+    }
+    this.open();
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Properties                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  public get closed(): boolean {
+    return this._closed;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Public API                                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Open the event source.
+   *
+   * Note: The connection is opened automatically upon object creation.
+   * This method should only be used if this reactive-event-source has
+   * been closed explicitly.
+   */
+  public open(): void {
+    this._closed = false;
+    this.reconnect();
+  }
+
+  /**
+   * Get an event stream for the given event type.
+   * @param eventType The event type. Defaults to 'message'.
+   */
+  public events(eventType: string = 'message'): Observable<MessageEvent> {
+    if (!this.eventTopics.has(eventType)) {
+      this.eventTopics.set(eventType, new Subject<MessageEvent>());
+      this.ensureRegistrations();
+    }
+    const eventSubj = this.eventTopics.get(eventType);
+    return eventSubj.asObservable();
+  }
+
+  /**
+   * Get an event stream of messages parsed from json.
+   * (event.data must be in json format)
+   *
+   * @param eventType The event type. Defaults to 'message'.
+   */
+  public eventsJson(eventType: string = 'message'): Observable<T> {
+    return this.events(eventType).pipe(
+      map(event => JSON.parse(event.data))
+    );
+  }
+
+  /**
+   * Close this event source. It wont reconnect.
+   */
+  public close(): void {
+    this._closed = true;
+    this.closeCurrent();
+    this.logger.debug('Closing the event-source.');
+  }
+
+  /**
+   * Keeps this reactive event source open until the given observable emits an event.
+   * @param unsubscribe
+   */
+  public openUntil(unsubscribe: Observable<any>): this {
+    this.cleanUpOpenUntil();
+    this._unsubscribeSub = unsubscribe
+      .subscribe(
+        () => this.close()
+      );
+    return this;
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Private methods                                                         *
+   *                                                                         *
+   **************************************************************************/
+
+  private cleanUpOpenUntil(): void {
+    if (this._unsubscribeSub) {
+      this._unsubscribeSub.unsubscribe();
+      this._unsubscribeSub = null;
+    }
+  }
+
+  /**
+   * Reconnects this event source, unless closed is true;
+   */
+  private reconnect(): void {
+
+    if (this._closed) { return; }
+
+    this.closeCurrent();
+
+    const eventSourceUrl = this.eventSourceUrlProvider();
+
+    try {
+      this.currentSource = new EventSource(eventSourceUrl, this.eventSourceInitDict);
+
+      this.ensureRegistrations();
+
+      this.currentSource.onopen = (event) => {
+        this.logger.debug('EventSource connection opened to: ' + eventSourceUrl +
+          ', state: ' + this.readyStateAsString(this.currentSource), event);
+      };
+
+      this.currentSource.onerror = (error) => {
+
+        this.logger.trace('There was an SSE error, current state: ' + this.readyStateAsString(this.currentSource), error);
+
+        if (!this.closed) {
+          // There was an error - try reconnecting
+          this.logger.debug('Attempting to reconnect event-source at' + eventSourceUrl + '...');
+          setTimeout(() => this.reconnect(), 3000); // Delay the reconnect
+        } else {
+          this.logger.debug('There was an error in the sse connection (closed).', error);
+        }
+      };
+
+    } catch (err) {
+      this.logger.error('Failed to create EventSource for ' + eventSourceUrl, err);
+      setTimeout(() => this.reconnect(), 3000); // Delay the reconnect
+    }
+  }
+
+  private ensureRegistrations(): void {
+    if (this.currentSource) {
+      this.eventTopics.forEach((subject, type) => {
+
+        if (!this.currentListeners.has(type)) {
+          this.currentSource.addEventListener(
+            type,
+            msg => subject.next(msg as MessageEvent),
+            false
+          );
+          this.currentListeners.add(type);
+          this.logger.debug('Listening to event type: ' + type);
+        }
+      });
+    }
+  }
+
+  /**
+   * Close the current event source
+   */
+  private closeCurrent(): void {
+
+    this.currentListeners.clear();
+
+    if (!this.currentClosed) {
+      // Close Event Source if not already closed.
+      this.logger.debug('Closing the event-source.');
+      this.currentSource.close();
+      this.currentSource = null;
+    }
+  }
+
+  private get currentClosed(): boolean {
+    return !this.currentSource || this.currentSource.readyState === this.currentSource.CLOSED;
+  }
+
+  private readyStateAsString(source: EventSource): string {
+    if (source.readyState === source.OPEN) {
+      return 'OPEN';
+    } else if (source.readyState === source.CLOSED) {
+      return 'CLOSED';
+    } else if (source.readyState === source.CONNECTING) {
+      return 'CONNECTING';
+    } else {
+      return 'UNKNOWN';
+    }
+  }
+}

package/src/lib/features/kafent/access-token-provider.ts

@@ -0,0 +1,21 @@
+import {WebSessionStorage} from '@elderbyte/ngx-simple-webstorage';
+import {Injectable} from '@angular/core';
+
+
+export abstract class KafentTokenProvider {
+  abstract getAccessToken(): string;
+}
+
+@Injectable()
+export class KafentTokenProviderSessionStorage extends KafentTokenProvider {
+
+  constructor(
+    private readonly sessionStorage: WebSessionStorage
+  ) {
+    super();
+  }
+
+  public getAccessToken(): string {
+    return this.sessionStorage.getItem('access_token');
+  }
+}

package/src/lib/features/kafent/kafent-config.ts

@@ -0,0 +1,42 @@
+import {Injectable} from '@angular/core';
+
+
+export enum KafentEventTransport {
+
+
+  /**
+   * Use Server-Sent Events, with auto reconnect as transport layer
+   */
+  SSE = 'sse',
+
+  /**
+   * Effectively dont use Kafent integration as transport is disabled.
+   */
+  DISABLED = 'disabled'
+
+}
+
+/**
+ * Kafent Client Configuration
+ */
+@Injectable()
+export class KafentConfig {
+
+  /**
+   * The url to the kavent event api
+   */
+  public kafentUrl: string;
+
+  /**
+   * The token query param.
+   * (If not provided, defaults to access_token)
+   */
+  public tokenParam?: string;
+
+  /**
+   * Specify the transport.
+   * If omitted, defaults to KafentEventTransport.SSE.
+   */
+  public transport?: KafentEventTransport;
+
+}

package/src/lib/features/kafent/kafent-event-stream.ts

@@ -0,0 +1,48 @@
+import {KafentLiveEventRequest} from './kafent-live-event-request';
+import {NEVER, Observable} from 'rxjs';
+import {KafentEvent} from './kafent-event';
+import {KafentEventTransport} from './kafent-config';
+import {Injectable} from '@angular/core';
+
+export abstract class KafentEventStream {
+
+  /**
+   * The transport layer of this event stream implementation
+   */
+  public readonly transport: KafentEventTransport;
+
+
+  constructor(
+    transport: KafentEventTransport
+  ) {
+    this.transport = transport;
+  }
+
+
+  /**
+   * Get Kafent events from the given topic-request.
+   *
+   * This event stream is infinite and will never complete on its own.
+   * Therefore, ensure you unsubscribe from this observable to
+   * ensure resources are cleaned up properly.
+   *
+   * @param request
+   */
+  public abstract getLiveEventsWith(request: KafentLiveEventRequest): Observable<KafentEvent>;
+
+}
+
+@Injectable()
+export class KafentEventStreamDisabled extends KafentEventStream {
+
+  constructor() {
+    super(KafentEventTransport.DISABLED);
+  }
+
+  public getLiveEventsWith(request: KafentLiveEventRequest): Observable<KafentEvent> {
+    // We use NEVER as dummy, which means it will never emit any item and also never complete.
+    // This fits the overall api contract as Kafent Event Streams always infinite by nature.
+    return NEVER;
+  }
+
+}

package/src/lib/features/kafent/kafent-event.service.ts

@@ -0,0 +1,128 @@
+import {KafentEvent} from './kafent-event';
+import {map} from 'rxjs/operators';
+import {Observable} from 'rxjs';
+import {KafentLiveEventRequest} from './kafent-live-event-request';
+import {Inject, Injectable} from '@angular/core';
+import {LoggerFactory} from '@elderbyte/ts-logger';
+import {KafentConfig, KafentEventTransport} from './kafent-config';
+import {KafentTokenProvider} from './access-token-provider';
+import {KafentEventStream} from './kafent-event-stream';
+
+/**
+ * Provides Kafent events over a simple API.
+ *
+ * Technically this is the Kafent Public API Facade, hides
+ * transport and other technical optimisations from consumers.
+ */
+@Injectable()
+export class KafentEventService {
+
+
+  /***************************************************************************
+   *                                                                         *
+   * Fields                                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  private readonly logger = LoggerFactory.getLogger('KafentEventService');
+  private readonly authTokenParam: string;
+
+  private readonly transport: KafentEventTransport;
+  private readonly kafentEventStream: KafentEventStream;
+
+  /***************************************************************************
+   *                                                                         *
+   * Constructor                                                             *
+   *                                                                         *
+   **************************************************************************/
+
+  constructor(
+    private readonly config: KafentConfig,
+    private readonly tokenProvider: KafentTokenProvider,
+    @Inject(KafentEventStream) private eventStreams: KafentEventStream[]
+  ) {
+    this.authTokenParam = this.config.tokenParam || 'access_token';
+    this.transport = config.transport || KafentEventTransport.SSE;
+
+    this.logger.info('Initializing Kafent with transport: ' + this.transport + ' and auth-token param: ' + this.authTokenParam);
+
+    this.kafentEventStream = eventStreams
+      .find(es => es.transport === this.transport);
+
+    if (this.kafentEventStream == null) {
+      throw new Error('Could not find an event-stream implementation supporting transport ' + this.transport + '. ' +
+        'Available implementations (' + eventStreams.length + ') [' + eventStreams + ']');
+    }
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Live Events Public API                                                  *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   * Get Kafent events from the given topic request.
+   *
+   * Ensure you unsubscribe from this observable to
+   * ensure resources are cleaned up properly.
+   *
+   * @param request
+   */
+  public getLiveEventsWith(request: KafentLiveEventRequest): Observable<KafentEvent> {
+    return this.kafentEventStream.getLiveEventsWith(request);
+  }
+
+  /**
+   * Get all events of the given topics
+   * @param topic
+   */
+  public getLiveEvents(topic: string): Observable<KafentEvent> {
+    return this.getLiveEventsWith({
+      topic: topic
+    });
+  }
+
+  public getLiveEventValues<T>(topic: string): Observable<T> {
+    return this.getLiveEvents(topic).pipe(
+      map(e => e.value)
+    );
+  }
+
+  /***************************************************************************
+   *                                                                         *
+   * Consumer Events Public API                                              *
+   *                                                                         *
+   **************************************************************************/
+
+  // TODO
+
+  /***************************************************************************
+   *                                                                         *
+   * Legacy Public API                                                       *
+   *                                                                         *
+   **************************************************************************/
+
+  /**
+   *  @deprecated
+   */
+  public getEventsWith(request: KafentLiveEventRequest): Observable<KafentEvent> {
+    return this.getLiveEventsWith(request);
+  }
+
+  /**
+   * @deprecated
+   */
+  public getEvents(topic: string): Observable<KafentEvent> {
+    return this.getLiveEvents(topic);
+  }
+
+  /**
+   * @deprecated
+   */
+  public getEventValues<T>(topic: string): Observable<T> {
+    return this.getLiveEventValues(topic);
+  }
+
+}
+

package/src/lib/features/kafent/kafent-event.ts

@@ -0,0 +1,14 @@
+
+export class KafentEvent<T = any> {
+
+  /**
+   * The event key. Usually the id of the entity.
+   */
+  public key: string;
+
+  /**
+   * The event value.
+   * Null might indicate deletion (tombstone)
+   */
+  public value: T;
+}

package/src/lib/features/kafent/kafent-live-event-request.ts

@@ -0,0 +1,75 @@
+
+export interface KafentEventFilter {
+
+  /**
+   * String prefix filter expression.
+   */
+  keyPrefix?: string;
+
+  /**
+   * The composite key prefix parts.
+   *
+   * key: 'cmp/order1/1234'
+   *
+   * keyParts: ['cmp', 'order1'] (would match the above)
+   */
+  keyParts?: string[];
+
+  /**
+   * Server side filters to apply to the event json data:
+   * i.e.:
+   *
+   * filters: {
+   *    'group': 'interesting'
+   *    'foo.bar.id': '221',
+   * }
+   *
+   * Nested objects are supported with dot syntax.
+   *
+   * Only events which match all filters will be passed to the client.
+   */
+  filters?: { [key: string]: string };
+
+}
+
+
+export interface KafentEventRequestBase {
+  filter?: KafentEventFilter;
+}
+
+
+export interface KafentLiveEventRequest extends KafentEventRequestBase {
+
+  /**
+   * The topic
+   */
+  topic: string;
+
+}
+
+export interface KafentConsumerEventRequest extends KafentEventRequestBase {
+
+  /**
+   * The client Id
+   */
+  clientId: string;
+
+  /**
+   * The consumer group
+   */
+  consumerGroup: string;
+
+  /**
+   * The topic
+   */
+  topics: string[];
+
+}
+
+
+/**
+ * @deprecated Please switch to the KafentLiveEventRequest interface.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface KafentEventRequest extends KafentLiveEventRequest { }
+