@memberjunction/server 2.23.2 → 2.24.0

package/src/generic/ResolverBase.ts

@@ -27,9 +27,9 @@ import { FieldMapper } from '@memberjunction/graphql-dataprovider';
 import { Subscription } from 'rxjs';
 
 export class ResolverBase {
-  private _emit = process.env.CLOUDEVENTS_HTTP_TRANSPORT ? emitterFor(httpTransport(process.env.CLOUDEVENTS_HTTP_TRANSPORT)) : null;
-  private _cloudeventsHeaders = process.env.CLOUDEVENTS_HTTP_HEADERS ? JSON.parse(process.env.CLOUDEVENTS_HTTP_HEADERS) : {};
-  private _eventSubscription: Subscription | null = null;
+  private static _emit = process.env.CLOUDEVENTS_HTTP_TRANSPORT ? emitterFor(httpTransport(process.env.CLOUDEVENTS_HTTP_TRANSPORT)) : null;
+  private static _cloudeventsHeaders = process.env.CLOUDEVENTS_HTTP_HEADERS ? JSON.parse(process.env.CLOUDEVENTS_HTTP_HEADERS) : {};
+  private static _eventSubscriptions = new Map<string, Subscription>;
 
   protected MapFieldNamesToCodeNames(entityName: string, dataObject: any) {
     // for the given entity name provided, check to see if there are any fields
@@ -245,7 +245,7 @@ export class ResolverBase {
   }
 
   protected async EmitCloudEvent({ component, event, eventCode, args }: MJEvent) {
-    if (this._emit && event === MJEventType.ComponentEvent && eventCode === BaseEntity.BaseEventCode) {
+    if (ResolverBase._emit && event === MJEventType.ComponentEvent && eventCode === BaseEntity.BaseEventCode) {
       const extendedType = args instanceof BaseEntityEvent ? `.${args.type}` : '';
       const type = `MemberJunction.${event}${extendedType}`;
       const source = `${process.env.CLOUDEVENTS_SOURCE ?? 'MemberJunction'}`;
@@ -255,7 +255,7 @@ export class ResolverBase {
       const cloudEvent = new CloudEvent({ type, source, subject, data });
 
       try {
-        const cloudeventTransportResponse = await this._emit(cloudEvent, { headers: this._cloudeventsHeaders });
+        const cloudeventTransportResponse = await ResolverBase._emit(cloudEvent, { headers: ResolverBase._cloudeventsHeaders });
         const cloudeventResponse = JSON.stringify(cloudeventTransportResponse);
         if (/error/i.test(cloudeventResponse)) {
           console.error('CloudEvent ERROR', cloudeventResponse);
@@ -548,27 +548,34 @@ export class ResolverBase {
   }
 
   protected ListenForEntityMessages(entityObject: BaseEntity, pubSub: PubSubEngine, userPayload: UserPayload) {
-    if (!this._eventSubscription) {
+    // The unique key is set up for each entity object via it's primary key to ensure that we only have one listener at most for each unique
+    // entity in the system. This is important because we don't want to have multiple listeners for the same entity as it could
+    // cause issues with multiple messages for the same event.
+    const uniqueKey = entityObject.EntityInfo.Name;
+
+    if (!ResolverBase._eventSubscriptions.has(uniqueKey)) {
       // listen for events from the entityObject in case it is a long running task and we can push messages back to the client via pubSub
-      this._eventSubscription = MJGlobal.Instance.GetEventListener(false).subscribe(async (event) => {
+      const theSub = MJGlobal.Instance.GetEventListener(false).subscribe(async (event: MJEvent) => {
         if (event) {
           await this.EmitCloudEvent(event);
 
-          if (event.component === entityObject && event.args && event.args.message) {
+          if (event.args && event.args instanceof BaseEntityEvent) {
+            const baseEntityEvent = event.args as BaseEntityEvent;
             // message from our entity object, relay it to the client
             pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
               message: JSON.stringify({
                 status: 'OK',
                 type: 'EntityObjectStatusMessage',
-                entityName: entityObject.EntityInfo.Name,
-                primaryKey: entityObject.PrimaryKey,
-                message: event.args.message,
+                entityName: baseEntityEvent.baseEntity.EntityInfo.Name,
+                primaryKey: baseEntityEvent.baseEntity.PrimaryKey,
+                message: event.args.payload,
               }),
               sessionId: userPayload.sessionId,
             });
           }
         }
       });
+      ResolverBase._eventSubscriptions.set(uniqueKey, theSub);
     }
   }
 

package/src/index.ts

@@ -69,7 +69,7 @@ export { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 export * from './generated/generated.js';
 
 import { resolve } from 'node:path';
-import { DataSourceInfo } from './types.js';
+import { DataSourceInfo, raiseEvent } from './types.js';
 
 export type MJServerOptions = {
   onBeforeServe?: () => void | Promise<void>;
@@ -125,8 +125,8 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     console.log('Read-only Data Source has been initialized.');
   }
 
-
   setupComplete$.next(true);
+  raiseEvent('setupComplete', dataSources, null,  this);
 
   /******TEST HARNESS FOR CHANGE DETECTION */
   /******TEST HARNESS FOR CHANGE DETECTION */

package/src/resolvers/AskSkipResolver.ts

@@ -1456,6 +1456,17 @@ export class AskSkipResolver {
       LogError(`Error saving user notification entity for AI message: ${sResult}`, undefined, userNotification.LatestResult);
     }
 
+    // check to see if Skip retrieved additional data on his own outside of the DATA_REQUEST phase/process. It is possible for Skip to call back
+    // to the MJAPI in the instance using the GetData() query in the MJAPI. If Skip did this, we need to save the data context items here.
+    if (apiResponse.newDataItems) {
+      apiResponse.newDataItems.forEach((skipItem) => {
+        const newItem = dataContext.AddDataContextItem();
+        newItem.Type = 'sql';
+        newItem.SQL = skipItem.text;
+        newItem.AdditionalDescription = skipItem.description;
+      });
+    }
+
     // Save the data context items...
     // FOR NOW, we don't want to store the data in the database, we will just load it from the data context when we need it
     // we need a better strategy to persist because the cost of storage and retrieval/parsing is higher than just running the query again in many/most cases

package/src/types.ts

@@ -1,7 +1,10 @@
+import { UserInfo } from '@memberjunction/core';
 import { UserViewEntity } from '@memberjunction/core-entities';
 import { GraphQLSchema } from 'graphql';
 import { PubSubEngine } from 'type-graphql';
 import { DataSource, QueryRunner } from 'typeorm';
+import { getSystemUser } from './auth';
+import { MJEvent, MJEventType, MJGlobal } from '@memberjunction/global';
 
 export type UserPayload = {
   email: string;
@@ -69,3 +72,28 @@ export type RunViewGenericParams = {
   userPayload?: UserPayload;
   pubSub: PubSubEngine;
 };
+
+
+export class MJServerEvent {
+  type: 'setupComplete' | 'requestReceived' | 'requestCompleted' | 'requestFailed';
+  dataSources: DataSourceInfo[];
+  userPayload: UserPayload;
+  systemUser: UserInfo;
+}
+
+export const MJ_SERVER_EVENT_CODE = 'MJ_SERVER_EVENT';
+
+export async function raiseEvent(type: MJServerEvent['type'], dataSources: DataSourceInfo[], userPayload: UserPayload, component?: any) {
+  const event = new MJServerEvent();
+  event.type = type;
+  event.dataSources = dataSources;
+  event.userPayload = userPayload;
+  event.systemUser = await getSystemUser();
+
+  const mje = new MJEvent();
+  mje.args = event;
+  mje.component = component;
+  mje.event = MJEventType.ComponentEvent;
+  mje.eventCode = MJ_SERVER_EVENT_CODE;
+  MJGlobal.Instance.RaiseEvent(mje);
+}