@memberjunction/server 3.4.0 → 4.0.0

package/src/index.ts

@@ -1,6 +1,6 @@
 import dotenv from 'dotenv';
 
-dotenv.config();
+dotenv.config({ quiet: true });
 
 import { expressMiddleware } from '@apollo/server/express4';
 import { mergeSchemas } from '@graphql-tools/schema';
@@ -27,45 +27,10 @@ import { contextFunction, getUserPayload } from './context.js';
 import { requireSystemUserDirective, publicDirective } from './directives/index.js';
 import createMSSQLConfig from './orm.js';
 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'
-LoadApolloAccountsEnrichmentAction();
-LoadApolloContactsEnrichmentAction();
-
-import { LoadCoreEntitiesServerSubClasses } from '@memberjunction/core-entities-server';
-LoadCoreEntitiesServerSubClasses(); // prevent tree shaking for this dynamic module
-
-import { LoadAgentManagementActions } from '@memberjunction/ai-agent-manager-actions';
-LoadAgentManagementActions();
-
-// Load agent manager core classes (registers custom agent classes like AgentBuilderAgent, AgentArchitectAgent)
-import { LoadAgentManagerCore } from '@memberjunction/ai-agent-manager';
-LoadAgentManagerCore();
-
-import { LoadSchedulingEngine } from '@memberjunction/scheduling-engine';
-LoadSchedulingEngine(); // This also loads drivers
-
-import { LoadAllSchedulingActions } from '@memberjunction/scheduling-actions';
-LoadAllSchedulingActions(); // prevent tree shaking for scheduling actions
-
-import { GetTypeformResponsesAction } from '@memberjunction/actions-bizapps-formbuilders';
-const x = GetTypeformResponsesAction; // prevent tree shaking for this dynamic module
+import { createOAuthCallbackHandler } from './rest/OAuthCallbackHandler.js';
 
 import { resolve } from 'node:path';
 import { DataSourceInfo, raiseEvent } from './types.js';
-import { LoadAIEngine } from '@memberjunction/aiengine';
-import { LoadAIProviders } from '@memberjunction/ai-provider-bundle';
-// Load AI Engine and all providers to prevent tree shaking
-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';
@@ -300,20 +265,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     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
-                               }),
-    })
-  );
-  
-  // Setup REST API endpoints
+  // Setup REST API endpoints BEFORE GraphQL (since graphqlRootPath may be '/' which catches all routes)
   const authMiddleware = async (req, res, next) => {
     try {
       const sessionIdRaw = req.headers['x-session-id'];
@@ -326,27 +278,58 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       if (!userPayload) {
         return res.status(401).json({ error: 'Invalid token' });
       }
-      
+
+      // Set both req.user (standard Express convention) and req['mjUser'] (MJ REST convention)
+      // Note: userPayload contains { userRecord: UserInfo, email, sessionId }
+      // The mjUser property expects the UserInfo directly (userRecord)
       req.user = userPayload;
+      req['mjUser'] = userPayload.userRecord;
       next();
     } catch (error) {
       console.error('Auth error:', error);
       return res.status(401).json({ error: 'Authentication failed' });
     }
   };
-  
-  // Get REST API configuration from the config file
-  const restApiConfig: RESTApiOptions = {
-    enabled: configInfo.restApiOptions?.enabled ?? true,
+
+  // Build public URL for OAuth callbacks
+  const oauthPublicUrl = configInfo.publicUrl || `${configInfo.baseUrl}:${configInfo.graphqlPort}${configInfo.graphqlRootPath || ''}`;
+  console.log(`[OAuth] publicUrl: ${oauthPublicUrl}`);
+
+  // Set up OAuth callback routes at /oauth (independent of REST API)
+  // These must be registered BEFORE GraphQL middleware since graphqlRootPath may be '/'
+  if (oauthPublicUrl) {
+    const { callbackRouter, authenticatedRouter } = createOAuthCallbackHandler({
+      publicUrl: oauthPublicUrl,
+      // TODO: These should be configurable to point to the MJ Explorer UI
+      successRedirectUrl: `${oauthPublicUrl}/oauth/success`,
+      errorRedirectUrl: `${oauthPublicUrl}/oauth/error`
+    });
+
+    // Create CORS middleware for OAuth routes (needed for cross-origin requests from frontend)
+    const oauthCors = cors<cors.CorsRequest>();
+
+    // OAuth callback is unauthenticated (called by external auth server)
+    app.use('/oauth', oauthCors, callbackRouter);
+    console.log('[OAuth] Callback route registered at /oauth/callback');
+
+    // OAuth status, initiate, and exchange endpoints require authentication
+    // Must also have CORS for frontend requests and JSON body parsing
+    app.use('/oauth', oauthCors, BodyParser.json(), authMiddleware, authenticatedRouter);
+    console.log('[OAuth] Authenticated routes registered at /oauth/status, /oauth/initiate, and /oauth/exchange');
+  }
+
+  // Get REST API configuration
+  const restApiConfig = {
+    enabled: configInfo.restApiOptions?.enabled ?? false,
     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';
@@ -354,18 +337,34 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       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());
   }
-  
+
   if (process.env.MJ_REST_API_EXCLUDE_ENTITIES) {
     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);
 
+  // GraphQL middleware (after REST so /api/v1/* routes are handled first)
+  // Note: Type assertion needed due to @apollo/server bundling older @types/express types
+  // that are incompatible with Express 5.x types (missing 'param' property)
+  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
+                               }),
+    }) as unknown as express.RequestHandler
+  );
+
   // Initialize and start scheduled jobs service if enabled
   let scheduledJobsService: ScheduledJobsService | null = null;
   if (configInfo.scheduledJobs?.enabled) {

package/src/resolvers/InfoResolver.ts

@@ -1,9 +1,13 @@
 import { Field, ObjectType, Int, Query, Resolver, Ctx, Info as RequestInfo } from 'type-graphql';
 import { Public, RequireSystemUser } from '../directives/index.js';
-import packageJson from '../../package.json' with { type: 'json' };
+import { createRequire } from 'node:module';
 import { AppContext } from '../types.js';
 import os from 'node:os';
 
+// Use createRequire to import JSON (compatible with module: es2022)
+const require = createRequire(import.meta.url);
+const packageJson = require('../../package.json') as { version: string };
+
 @ObjectType()
 export class Info {
   @Public()