@memberjunction/server 2.112.0 → 2.113.0

package/src/index.ts

@@ -4,7 +4,7 @@ dotenv.config();
 
 import { expressMiddleware } from '@apollo/server/express4';
 import { mergeSchemas } from '@graphql-tools/schema';
-import { Metadata } from '@memberjunction/global';
+import { Metadata } from '@memberjunction/core';
 import { setupSQLServerClient, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { extendConnectionPoolWithQuery } from './util.js';
 import { default as BodyParser } from 'body-parser';
@@ -22,18 +22,7 @@ import { BuildSchemaOptions, buildSchemaSync, GraphQLTimestamp } from 'type-grap
 import sql from 'mssql';
 import { WebSocketServer } from 'ws';
 import buildApolloServer from './apolloServer/index.js';
-import {
-  configInfo,
-  dbDatabase,
-  dbHost,
-  dbPort,
-  dbUsername,
-  graphqlPort,
-  graphqlRootPath,
-  mj_core_schema,
-  websiteRunFromPackage,
-  RESTApiOptions,
-} from './config.js';
+import { configInfo, dbDatabase, dbHost, dbPort, dbUsername, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage, RESTApiOptions } from './config.js';
 import { contextFunction, getUserPayload } from './context.js';
 import { requireSystemUserDirective, publicDirective } from './directives/index.js';
 import createMSSQLConfig from './orm.js';
@@ -41,7 +30,7 @@ import { setupRESTEndpoints } from './rest/setupRESTEndpoints.js';
 
 import { LoadAllCoreActions } from '@memberjunction/core-actions';
 LoadAllCoreActions(); // prevent tree shaking for this dynamic module
-import { LoadApolloAccountsEnrichmentAction, LoadApolloContactsEnrichmentAction } from '@memberjunction/actions-apollo';
+import { LoadApolloAccountsEnrichmentAction, LoadApolloContactsEnrichmentAction } from '@memberjunction/actions-apollo'
 LoadApolloAccountsEnrichmentAction();
 LoadApolloContactsEnrichmentAction();
 
@@ -61,6 +50,7 @@ LoadSchedulingEngine(); // This also loads drivers
 import { LoadAllSchedulingActions } from '@memberjunction/scheduling-actions';
 LoadAllSchedulingActions(); // prevent tree shaking for scheduling actions
 
+
 import { resolve } from 'node:path';
 import { DataSourceInfo, raiseEvent } from './types.js';
 import { LoadAIEngine } from '@memberjunction/aiengine';
@@ -69,6 +59,12 @@ import { LoadAIProviders } from '@memberjunction/ai-provider-bundle';
 LoadAIEngine();
 LoadAIProviders();
 
+// Load Communication Providers
+import { LoadMSGraphProvider } from '@memberjunction/communication-ms-graph';
+import { LoadProvider as LoadSendGridProvider } from '@memberjunction/communication-sendgrid';
+LoadMSGraphProvider();
+LoadSendGridProvider();
+
 import { ExternalChangeDetectorEngine } from '@memberjunction/external-change-detection';
 import { ScheduledJobsService } from './services/ScheduledJobsService.js';
 
@@ -116,6 +112,7 @@ export { GetReadOnlyDataSource, GetReadWriteDataSource, GetReadWriteProvider, Ge
 
 export * from './generated/generated.js';
 
+
 export type MJServerOptions = {
   onBeforeServe?: () => void | Promise<void>;
   restApiOptions?: Partial<RESTApiOptions>; // Options for REST API configuration
@@ -153,10 +150,8 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   const md = new Metadata();
   console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
 
-  const dataSources = [
-    new DataSourceInfo({ dataSource: pool, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername }),
-  ];
-
+  const dataSources = [new DataSourceInfo({dataSource: pool, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername})];
+  
   // Establish a second read-only connection to the database if dbReadOnlyUsername and dbReadOnlyPassword exist
   let readOnlyPool: sql.ConnectionPool | null = null;
   if (configInfo.dbReadOnlyUsername && configInfo.dbReadOnlyPassword) {
@@ -169,21 +164,12 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     await readOnlyPool.connect();
 
     // since we created a read-only pool, add it to the list of data sources
-    dataSources.push(
-      new DataSourceInfo({
-        dataSource: readOnlyPool,
-        type: 'Read-Only',
-        host: dbHost,
-        port: dbPort,
-        database: dbDatabase,
-        userName: configInfo.dbReadOnlyUsername,
-      })
-    );
+    dataSources.push(new DataSourceInfo({dataSource: readOnlyPool, type: 'Read-Only', host: dbHost, port: dbPort, database: dbDatabase, userName: configInfo.dbReadOnlyUsername}));
     console.log('Read-only Connection Pool has been initialized.');
   }
 
   setupComplete$.next(true);
-  raiseEvent('setupComplete', dataSources, null, this);
+  raiseEvent('setupComplete', dataSources, null,  this);
 
   /******TEST HARNESS FOR CHANGE DETECTION */
   /******TEST HARNESS FOR CHANGE DETECTION */
@@ -245,45 +231,41 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
 
   const apolloServer = buildApolloServer({ schema }, { httpServer, serverCleanup });
   await apolloServer.start();
-
+  
   // Fix #8: Add compression for better throughput performance
-  app.use(
-    compression({
-      // Don't compress responses smaller than 1KB
-      threshold: 1024,
-      // Skip compression for images, videos, and other binary files
-      filter: (req, res) => {
-        if (req.headers['content-type']) {
-          const contentType = req.headers['content-type'];
-          if (
-            contentType.includes('image/') ||
+  app.use(compression({
+    // Don't compress responses smaller than 1KB
+    threshold: 1024,
+    // Skip compression for images, videos, and other binary files
+    filter: (req, res) => {
+      if (req.headers['content-type']) {
+        const contentType = req.headers['content-type'];
+        if (contentType.includes('image/') || 
             contentType.includes('video/') ||
             contentType.includes('audio/') ||
-            contentType.includes('application/octet-stream')
-          ) {
-            return false;
-          }
+            contentType.includes('application/octet-stream')) {
+          return false;
         }
-        return compression.filter(req, res);
-      },
-      // High compression level (good balance between CPU and compression ratio)
-      level: 6,
-    })
-  );
+      }
+      return compression.filter(req, res);
+    },
+    // High compression level (good balance between CPU and compression ratio)
+    level: 6
+  }));
 
   app.use(
     graphqlRootPath,
     cors<cors.CorsRequest>(),
     BodyParser.json({ limit: '50mb' }),
     expressMiddleware(apolloServer, {
-      context: contextFunction({
-        setupComplete$,
-        dataSource: extendConnectionPoolWithQuery(pool), // default read-write data source
-        dataSources, // all data source
-      }),
+      context: contextFunction({ 
+                                 setupComplete$, 
+                                 dataSource: extendConnectionPoolWithQuery(pool), // default read-write data source
+                                 dataSources // all data source
+                               }),
     })
   );
-
+  
   // Setup REST API endpoints
   const authMiddleware = async (req, res, next) => {
     try {
@@ -297,7 +279,7 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
       if (!userPayload) {
         return res.status(401).json({ error: 'Invalid token' });
       }
-
+      
       req.user = userPayload;
       next();
     } catch (error) {
@@ -305,19 +287,19 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
       return res.status(401).json({ error: 'Authentication failed' });
     }
   };
-
+  
   // Get REST API configuration from the config file
   const restApiConfig: RESTApiOptions = {
     enabled: configInfo.restApiOptions?.enabled ?? true,
     includeEntities: configInfo.restApiOptions?.includeEntities,
-    excludeEntities: configInfo.restApiOptions?.excludeEntities,
+    excludeEntities: configInfo.restApiOptions?.excludeEntities
   };
-
+  
   // Apply options from server options if provided (these override the config file)
   if (options?.restApiOptions) {
     Object.assign(restApiConfig, options.restApiOptions);
   }
-
+  
   // Get REST API configuration from environment variables if present (env vars override everything)
   if (process.env.MJ_REST_API_ENABLED !== undefined) {
     restApiConfig.enabled = process.env.MJ_REST_API_ENABLED === 'true';
@@ -325,15 +307,15 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
       console.log('REST API is enabled via environment variable');
     }
   }
-
+  
   if (process.env.MJ_REST_API_INCLUDE_ENTITIES) {
-    restApiConfig.includeEntities = process.env.MJ_REST_API_INCLUDE_ENTITIES.split(',').map((e) => e.trim());
+    restApiConfig.includeEntities = process.env.MJ_REST_API_INCLUDE_ENTITIES.split(',').map(e => e.trim());
   }
-
+  
   if (process.env.MJ_REST_API_EXCLUDE_ENTITIES) {
-    restApiConfig.excludeEntities = process.env.MJ_REST_API_EXCLUDE_ENTITIES.split(',').map((e) => e.trim());
+    restApiConfig.excludeEntities = process.env.MJ_REST_API_EXCLUDE_ENTITIES.split(',').map(e => e.trim());
   }
-
+  
   // Set up REST endpoints with the configured options and auth middleware
   setupRESTEndpoints(app, restApiConfig, authMiddleware);
 

package/src/resolvers/ActionResolver.ts

@@ -1,13 +1,13 @@
-import { Resolver, Mutation, Arg, Ctx } from 'type-graphql';
-import { ActionEngineServer } from '@memberjunction/actions';
-import { EntityActionEngineServer } from '@memberjunction/actions';
-import { Metadata, UserInfo, BaseEntity, CompositeKey, KeyValuePair, LogError } from '@memberjunction/global';
-import { ActionParam, ActionResult } from '@memberjunction/actions-base';
-import { Field, InputType, ObjectType } from 'type-graphql';
-import { KeyValuePairInput } from '../generic/KeyValuePairInput.js';
-import { AppContext, ProviderInfo } from '../types.js';
-import { CopyScalarsAndArrays } from '@memberjunction/global';
-import { GetReadOnlyProvider } from '../util.js';
+import { Resolver, Mutation, Arg, Ctx } from "type-graphql";
+import { ActionEngineServer } from "@memberjunction/actions";
+import { EntityActionEngineServer } from "@memberjunction/actions";
+import { Metadata, UserInfo, BaseEntity, CompositeKey, KeyValuePair, LogError } from "@memberjunction/core";
+import { ActionParam, ActionResult } from "@memberjunction/actions-base";
+import { Field, InputType, ObjectType } from "type-graphql";
+import { KeyValuePairInput } from "../generic/KeyValuePairInput.js";
+import { AppContext, ProviderInfo } from "../types.js";
+import { CopyScalarsAndArrays } from "@memberjunction/global";
+import { GetReadOnlyProvider } from "../util.js";
 
 /**
  * Input type for action parameters
@@ -60,7 +60,7 @@ export class RunActionInput {
   @Field(() => Boolean, { nullable: true })
   SkipActionLog?: boolean;
 }
-
+ 
 /**
  * Represents a collection of key-value pairs that make up a composite key
  * Used for both primary keys and foreign keys
@@ -97,7 +97,7 @@ export class EntityActionInput {
    */
   @Field(() => String, { nullable: true })
   EntityName?: string;
-
+  
   /**
    * The ID of the entity
    * Use EntityName instead when possible for better code readability
@@ -179,12 +179,15 @@ export class ActionResolver {
    * @returns The result of running the action
    */
   @Mutation(() => ActionResultOutput)
-  async RunAction(@Arg('input') input: RunActionInput, @Ctx() ctx: AppContext): Promise<ActionResultOutput> {
+  async RunAction(
+    @Arg("input") input: RunActionInput,
+    @Ctx() ctx: AppContext
+  ): Promise<ActionResultOutput> {
     try {
       // Get the user from context
       const user = ctx.userPayload.userRecord;
       if (!user) {
-        throw new Error('User is not authenticated');
+        throw new Error("User is not authenticated");
       }
 
       // Initialize the action engine
@@ -214,7 +217,7 @@ export class ActionResolver {
    * @private
    */
   private findActionById(actionID: string): any {
-    const action = ActionEngineServer.Instance.Actions.find((a) => a.ID === actionID);
+    const action = ActionEngineServer.Instance.Actions.find(a => a.ID === actionID);
     if (!action) {
       throw new Error(`Action with ID ${actionID} not found`);
     }
@@ -232,9 +235,9 @@ export class ActionResolver {
       return [];
     }
 
-    return inputParams.map((p) => {
+    return inputParams.map(p => {
       let value: any = p.Value;
-
+      
       // Try to parse JSON for complex values
       try {
         if (p.Value && (p.Type === 'object' || p.Type === 'array')) {
@@ -245,11 +248,11 @@ export class ActionResolver {
         const error = e as Error;
         LogError(`Failed to parse parameter value as JSON: ${error.message}`);
       }
-
+      
       return {
         Name: p.Name,
         Value: value,
-        Type: 'Input', // Default to Input type since we're sending parameters
+        Type: 'Input' // Default to Input type since we're sending parameters
       };
     });
   }
@@ -263,13 +266,18 @@ export class ActionResolver {
    * @returns The action result
    * @private
    */
-  private async executeAction(action: any, user: UserInfo, params: ActionParam[], skipActionLog?: boolean): Promise<ActionResult> {
+  private async executeAction(
+    action: any, 
+    user: UserInfo, 
+    params: ActionParam[], 
+    skipActionLog?: boolean
+  ): Promise<ActionResult> {
     return await ActionEngineServer.Instance.RunAction({
       Action: action,
       ContextUser: user,
       Params: params,
       SkipActionLog: skipActionLog,
-      Filters: [],
+      Filters: []
     });
   }
 
@@ -280,14 +288,14 @@ export class ActionResolver {
    * @private
    */
   private createActionResult(result: ActionResult): ActionResultOutput {
-    const x = (result.Params || result.RunParams.Params || []).filter(
-      (p) => p.Type.trim().toLowerCase() === 'output' || p.Type.trim().toLowerCase() === 'both'
-    );
+    const x =(result.Params || result.RunParams.Params || [])
+              .filter(p => p.Type.trim().toLowerCase() === 'output' ||
+                           p.Type.trim().toLowerCase() === 'both')     ;
     return {
       Success: result.Success,
       Message: result.Message,
       ResultCode: result.Result?.ResultCode,
-      ResultData: x && x.length > 0 ? JSON.stringify(CopyScalarsAndArrays(x)) : undefined,
+      ResultData: x && x.length > 0 ? JSON.stringify(CopyScalarsAndArrays(x)) : undefined
     };
   }
 
@@ -302,7 +310,7 @@ export class ActionResolver {
     LogError(`Error in RunAction resolver: ${error}`);
     return {
       Success: false,
-      Message: `Error executing action: ${error.message}`,
+      Message: `Error executing action: ${error.message}`
     };
   }
 
@@ -313,11 +321,14 @@ export class ActionResolver {
    * @returns The result of running the entity action
    */
   @Mutation(() => ActionResultOutput)
-  async RunEntityAction(@Arg('input') input: EntityActionInput, @Ctx() ctx: AppContext): Promise<ActionResultOutput> {
+  async RunEntityAction(
+    @Arg("input") input: EntityActionInput,
+    @Ctx() ctx: AppContext
+  ): Promise<ActionResultOutput> {
     try {
       const user = ctx.userPayload.userRecord;
       if (!user) {
-        throw new Error('User is not authenticated');
+        throw new Error("User is not authenticated");
       }
 
       // Initialize the entity action engine
@@ -344,13 +355,13 @@ export class ActionResolver {
       return {
         Success: result.Success,
         Message: result.Message,
-        ResultData: JSON.stringify(result),
+        ResultData: JSON.stringify(result)
       };
     } catch (e) {
       return this.handleError(e);
     }
   }
-
+ 
   /**
    * Gets an entity action by ID
    * @param actionID The ID of the entity action
@@ -359,7 +370,7 @@ export class ActionResolver {
    * @private
    */
   private getEntityAction(actionID: string): any {
-    const entityAction = EntityActionEngineServer.Instance.EntityActions.find((ea) => ea.ID === actionID);
+    const entityAction = EntityActionEngineServer.Instance.EntityActions.find(ea => ea.ID === actionID);
     if (!entityAction) {
       throw new Error(`EntityAction with ID ${actionID} not found`);
     }
@@ -392,23 +403,23 @@ export class ActionResolver {
    */
   private async addEntityObject(providers: Array<ProviderInfo>, params: any, input: EntityActionInput, user: UserInfo): Promise<void> {
     const md = GetReadOnlyProvider(providers);
-
+    
     // Find the entity by ID or name
     let entity;
     if (input.EntityName) {
-      entity = md.Entities.find((e) => e.Name === input.EntityName);
+      entity = md.Entities.find(e => e.Name === input.EntityName);
       if (!entity) {
         throw new Error(`Entity with name ${input.EntityName} not found`);
       }
     } else if (input.EntityID) {
-      entity = md.Entities.find((e) => e.ID === input.EntityID);
+      entity = md.Entities.find(e => e.ID === input.EntityID);
       if (!entity) {
         throw new Error(`Entity with ID ${input.EntityID} not found`);
       }
     }
 
     if (!entity) {
-      throw new Error('Entity information is required');
+      throw new Error("Entity information is required");
     }
 
     // Create a composite key and load the entity object
@@ -427,24 +438,24 @@ export class ActionResolver {
    */
   private createCompositeKey(entity: any, primaryKey: CompositeKeyInput): CompositeKey {
     const compositeKey = new CompositeKey();
-
+    
     for (const kvp of primaryKey.KeyValuePairs) {
       // Convert value based on the field type if necessary
-      const field = entity.Fields.find((f) => f.Name === kvp.Key);
+      const field = entity.Fields.find(f => f.Name === kvp.Key);
       let value: any = kvp.Value;
-
+      
       // If the field is found, try to convert to proper type
       if (field) {
         value = this.convertValueToProperType(value, field);
       }
-
+      
       // Add to composite key
       const kvPair = new KeyValuePair();
       kvPair.FieldName = kvp.Key;
       kvPair.Value = value;
       compositeKey.KeyValuePairs.push(kvPair);
     }
-
+    
     return compositeKey;
   }
 
@@ -484,7 +495,7 @@ export class ActionResolver {
 
     // Add additional parameters if provided
     if (input.Params && input.Params.length > 0) {
-      params.Params = input.Params.map((p) => this.convertParameterValue(p));
+      params.Params = input.Params.map(p => this.convertParameterValue(p));
     }
   }
 
@@ -496,7 +507,7 @@ export class ActionResolver {
    */
   private convertParameterValue(p: ActionParamInput): any {
     let value: any = p.Value;
-
+    
     // Try to parse JSON for complex values
     try {
       if (p.Value && (p.Type === 'object' || p.Type === 'array')) {
@@ -507,11 +518,11 @@ export class ActionResolver {
       const error = e as Error;
       LogError(`Failed to parse parameter value as JSON: ${error.message}`);
     }
-
+    
     return {
       Name: p.Name,
       Value: value,
-      Type: 'Input', // Default to Input type since we're sending parameters
+      Type: 'Input' // Default to Input type since we're sending parameters
     };
   }
 
@@ -526,7 +537,7 @@ export class ActionResolver {
     LogError(`Error in RunEntityAction resolver: ${error}`);
     return {
       Success: false,
-      Message: `Error executing entity action: ${error.message}`,
+      Message: `Error executing entity action: ${error.message}`
     };
   }
-}
+}