@memberjunction/server 5.4.1 → 5.5.0

package/src/generic/ResolverBase.ts

@@ -405,9 +405,18 @@ export class ResolverBase {
 
         if (viewInput.ViewName) {
           viewInfo = this.safeFirstArrayElement(await this.findBy(provider, 'MJ: User Views', { Name: viewInput.ViewName }, userPayload.userRecord));
+          // Populate EntityName on the input so callers (e.g. RunViews resolver) can
+          // look up the entity without re-querying the view
+          if (viewInfo && !viewInput.EntityName) {
+            viewInput.EntityName = viewInfo.Entity;
+          }
         } else if (viewInput.ViewID) {
           viewInfo = await provider.GetEntityObject<MJUserViewEntityExtended>('MJ: User Views', contextUser);
           await viewInfo.Load(viewInput.ViewID);
+          // Populate EntityName on the input so callers can look up the entity
+          if (viewInfo && !viewInput.EntityName) {
+            viewInput.EntityName = viewInfo.Entity;
+          }
         } else if (viewInput.EntityName) {
           const entity = md.Entities.find((e) => e.Name === viewInput.EntityName);
           if (!entity) {

package/src/generic/RunViewResolver.ts

@@ -2,6 +2,7 @@ import { Arg, Ctx, Field, InputType, Int, ObjectType, PubSubEngine, Query, Resol
 import { AppContext } from '../types.js';
 import { ResolverBase } from './ResolverBase.js';
 import { LogError, LogStatus, EntityInfo, RunViewWithCacheCheckResult, RunViewsWithCacheCheckResponse, RunViewWithCacheCheckParams, AggregateResult } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadOnlyProvider } from '../util.js';
 import { MJUserViewEntityExtended } from '@memberjunction/core-entities';
@@ -355,8 +356,23 @@ export class RunDynamicViewInput {
 
 @InputType()
 export class RunViewGenericInput {
-  @Field(() => String)
-  EntityName: string;
+  @Field(() => String, {
+    nullable: true,
+    description: 'The ID of a saved User View to run. Provide either ViewID, ViewName, or EntityName.',
+  })
+  ViewID?: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description: 'The name of a saved User View to run. Provide either ViewID, ViewName, or EntityName.',
+  })
+  ViewName?: string;
+
+  @Field(() => String, {
+    nullable: true,
+    description: 'The entity name for a dynamic view. Provide either ViewID, ViewName, or EntityName.',
+  })
+  EntityName?: string;
 
   @Field(() => String, {
     nullable: true,
@@ -653,7 +669,7 @@ export class RunViewResolver extends ResolverBase {
         return null;
 
       const viewInfo = super.safeFirstArrayElement<MJUserViewEntityExtended>(await super.findBy<MJUserViewEntityExtended>(provider, "MJ: User Views", { Name: input.ViewName }, userPayload.userRecord));
-      const entity = provider.Entities.find((e) => e.ID === viewInfo.EntityID);
+      const entity = provider.Entities.find((e) => UUIDsEqual(e.ID, viewInfo.EntityID));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID, entity);
       return {
         Results: returnData,
@@ -684,7 +700,7 @@ export class RunViewResolver extends ResolverBase {
         return null;
 
       const viewInfo = super.safeFirstArrayElement<MJUserViewEntityExtended>(await super.findBy<MJUserViewEntityExtended>(provider, "MJ: User Views", { ID: input.ViewID }, userPayload.userRecord));
-      const entity = provider.Entities.find((e) => e.ID === viewInfo.EntityID);
+      const entity = provider.Entities.find((e) => UUIDsEqual(e.ID, viewInfo.EntityID));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID, entity);
       return {
         Results: returnData,
@@ -747,8 +763,9 @@ export class RunViewResolver extends ResolverBase {
 
       let results: RunViewGenericResult[] = [];
       for (const [index, data] of rawData.entries()) {
-        const entity = provider.Entities.find((e) => e.Name === input[index].EntityName);
-        const returnData: any[] = this.processRawData(data.Results, entity.ID, entity);
+        // EntityName is backfilled by RunViewsGeneric when ViewID/ViewName was used
+        const entity = input[index].EntityName ? provider.Entities.find((e) => e.Name === input[index].EntityName) : null;
+        const returnData: any[] = this.processRawData(data.Results, entity ? entity.ID : null, entity);
 
         results.push({
           Results: returnData,
@@ -838,7 +855,7 @@ export class RunViewResolver extends ResolverBase {
       }
 
       const viewInfo = super.safeFirstArrayElement<MJUserViewEntityExtended>(await super.findBy<MJUserViewEntityExtended>(provider, "MJ: User Views", { ID: input.ViewID }, userPayload.userRecord));
-      const entity = provider.Entities.find((e) => e.ID === viewInfo.EntityID);
+      const entity = provider.Entities.find((e) => UUIDsEqual(e.ID, viewInfo.EntityID));
       const returnData = this.processRawData(rawData.Results, viewInfo.EntityID, entity);
       return {
         Results: returnData,

package/src/index.ts

@@ -4,8 +4,9 @@ dotenv.config({ quiet: true });
 
 import { expressMiddleware } from '@apollo/server/express4';
 import { mergeSchemas } from '@graphql-tools/schema';
-import { Metadata } from '@memberjunction/core';
-import { setupSQLServerClient, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { Metadata, DatabasePlatform, SetProvider, StartupManager as StartupManagerImport } from '@memberjunction/core';
+import { MJGlobal, UUIDsEqual } from '@memberjunction/global';
+import { setupSQLServerClient, SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { extendConnectionPoolWithQuery } from './util.js';
 import { default as BodyParser } from 'body-parser';
 import compression from 'compression'; // Add compression middleware
@@ -39,6 +40,18 @@ import { getSystemUser } from './auth/index.js';
 
 const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
 
+/**
+ * Returns the configured database platform type based on the DB_TYPE environment variable.
+ * Defaults to 'sqlserver' for backward compatibility.
+ */
+export function getDbType(): DatabasePlatform {
+    const dbType = process.env.DB_TYPE?.toLowerCase();
+    if (dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg') {
+        return 'postgresql';
+    }
+    return 'sqlserver';
+}
+
 export { MaxLength } from 'class-validator';
 export * from 'type-graphql';
 export { NewUserBase } from './auth/newUsers.js';
@@ -134,32 +147,145 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     console.log({ combinedResolverPaths, paths, cwd: process.cwd() });
   }
 
-  const pool = new sql.ConnectionPool(createMSSQLConfig());
   const setupComplete$ = new ReplaySubject(1);
-  await pool.connect();
+  const dbType = getDbType();
+  const dataSources: DataSourceInfo[] = [];
+
+  if (dbType === 'postgresql') {
+    // ─── PostgreSQL Path ───────────────────────────────────────────
+    console.log('Database type: PostgreSQL');
+    const pg = await import('pg');
+    const { PostgreSQLDataProvider, PostgreSQLProviderConfigData } = await import('@memberjunction/postgresql-dataprovider');
+
+    const pgHost = process.env.PG_HOST || process.env.DB_HOST || 'localhost';
+    const pgPort = parseInt(process.env.PG_PORT || process.env.DB_PORT || '5432', 10);
+    const pgUser = process.env.PG_USERNAME || process.env.DB_USERNAME || 'postgres';
+    const pgPass = process.env.PG_PASSWORD || process.env.DB_PASSWORD || '';
+    const pgDatabase = process.env.PG_DATABASE || process.env.DB_DATABASE || '';
+
+    const pgPool = new pg.default.Pool({
+      host: pgHost,
+      port: pgPort,
+      user: pgUser,
+      password: pgPass,
+      database: pgDatabase,
+      max: configInfo.databaseSettings.connectionPool?.max ?? 50,
+      min: configInfo.databaseSettings.connectionPool?.min ?? 5,
+      idleTimeoutMillis: configInfo.databaseSettings.connectionPool?.idleTimeoutMillis ?? 30000,
+      connectionTimeoutMillis: configInfo.databaseSettings.connectionPool?.acquireTimeoutMillis ?? 30000,
+    });
 
-  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) {
-    const readOnlyConfig = {
-      ...createMSSQLConfig(),
-      user: configInfo.dbReadOnlyUsername,
-      password: configInfo.dbReadOnlyPassword,
+    // Verify connection
+    const testClient = await pgPool.connect();
+    await testClient.query('SELECT 1');
+    testClient.release();
+    console.log(`PostgreSQL pool connected to ${pgHost}:${pgPort}/${pgDatabase}`);
+
+    // Create a DataSourceInfo with a MSSQL-compatible wrapper around pg.Pool
+    // This allows existing code (types, util, context) to work without changes
+    const mssqlCompatPool = createMSSQLCompatPool(pgPool);
+    dataSources.push(new DataSourceInfo({
+      dataSource: mssqlCompatPool,
+      type: 'Read-Write',
+      host: pgHost,
+      port: pgPort,
+      database: pgDatabase,
+      userName: pgUser,
+    }));
+
+    // Set up the PostgreSQL provider
+    const pgConnectionConfig = {
+      Host: pgHost,
+      Port: pgPort,
+      Database: pgDatabase,
+      User: pgUser,
+      Password: pgPass,
+      MaxConnections: configInfo.databaseSettings.connectionPool?.max ?? 50,
+      MinConnections: configInfo.databaseSettings.connectionPool?.min ?? 5,
+    };
+    const pgConfigData = new PostgreSQLProviderConfigData(
+      pgConnectionConfig,
+      mj_core_schema,
+      cacheRefreshInterval / 1000, // convert ms to seconds
+    );
+    const provider = new PostgreSQLDataProvider();
+    await provider.Config(pgConfigData);
+    SetProvider(provider);
+
+    // Refresh user cache using PostgreSQL
+    await refreshUserCacheFromPG(pgPool, mj_core_schema);
+
+    // Run startup actions
+    const sysUser = UserCache.Instance.GetSystemUser();
+    const backupSysUser = UserCache.Instance.Users.find(u => u.IsActive && u.Type === 'Owner');
+    await StartupManagerImport.Instance.Startup(false, sysUser || backupSysUser, provider);
+
+    // Monkey-patch SQLServerDataProvider.ExecuteSQLWithPool to support PostgreSQL
+    // Generated resolvers call this static method with bracket-quoted SQL.
+    // When the pool is our PG-compat wrapper, translate and execute via pg.Pool.
+    const origExecuteSQLWithPool = SQLServerDataProvider.ExecuteSQLWithPool;
+    SQLServerDataProvider.ExecuteSQLWithPool = async function(
+      pool: sql.ConnectionPool, query: string, parameters?: unknown[], contextUser?: import('@memberjunction/core').UserInfo
+    ): Promise<unknown[]> {
+      const poolAny = pool as unknown as Record<string, unknown>;
+      if (poolAny._pgPool) {
+        const thePgPool = poolAny._pgPool as import('pg').Pool;
+        // Translate SQL Server bracket syntax to PostgreSQL double-quote syntax
+        const pgQuery = translateBracketsToPG(query);
+        const result = await thePgPool.query(pgQuery);
+        return result.rows;
+      }
+      return origExecuteSQLWithPool.call(this, pool, query, parameters, contextUser);
     };
-    readOnlyPool = new sql.ConnectionPool(readOnlyConfig);
-    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}));
-    console.log('Read-only Connection Pool has been initialized.');
+    const md = new Metadata();
+    console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
+  } else {
+    // ─── SQL Server Path (existing behavior) ───────────────────────
+    console.log('Database type: SQL Server');
+    const pool = new sql.ConnectionPool(createMSSQLConfig());
+
+    // Handle connection-level errors from dead/stale connections in the pool.
+    // Without this handler, when Azure drops idle TCP connections, the pool silently
+    // hands out dead connections that throw "Final state" errors on next use.
+    pool.on('error', (err) => {
+      console.error('[ConnectionPool] Pool-level connection error (stale connection evicted):', err.message);
+    });
+
+    await pool.connect();
+
+    dataSources.push(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
+    if (configInfo.dbReadOnlyUsername && configInfo.dbReadOnlyPassword) {
+      const readOnlyConfig = {
+        ...createMSSQLConfig(),
+        user: configInfo.dbReadOnlyUsername,
+        password: configInfo.dbReadOnlyPassword,
+      };
+      const readOnlyPool = new sql.ConnectionPool(readOnlyConfig);
+
+      readOnlyPool.on('error', (err) => {
+        console.error('[ConnectionPool] Read-only pool connection error (stale connection evicted):', err.message);
+      });
+
+      await readOnlyPool.connect();
+
+      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.');
+    }
+
+    const config = new SQLServerProviderConfigData(pool, mj_core_schema, cacheRefreshInterval);
+    await setupSQLServerClient(config);
+    const md = new Metadata();
+    console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
   }
 
-  const config = new SQLServerProviderConfigData(pool, mj_core_schema, cacheRefreshInterval);
-  await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
-  const md = new Metadata();
-  console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
+  // Store queryDialects config in GlobalObjectStore so MJQueryEntityServer can
+  // read it without a circular dependency on MJServer
+  if (configInfo.queryDialects) {
+    MJGlobal.Instance.GetGlobalObjectStore()['queryDialects'] = configInfo.queryDialects;
+  }
 
   // Initialize server telemetry based on config
   const tm = TelemetryManager.Instance;
@@ -375,7 +501,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     expressMiddleware(apolloServer, {
       context: contextFunction({
                                  setupComplete$,
-                                 dataSource: extendConnectionPoolWithQuery(pool), // default read-write data source
+                                 dataSource: extendConnectionPoolWithQuery(dataSources[0].dataSource), // default read-write data source
                                  dataSources // all data source
                                }),
     }) as unknown as express.RequestHandler
@@ -440,3 +566,61 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     // This is critical for server stability when downstream dependencies fail
   });
 };
+
+/**
+ * Creates a MSSQL ConnectionPool-compatible wrapper around a pg.Pool.
+ * This allows existing code that references DataSourceInfo.dataSource (typed as sql.ConnectionPool)
+ * to work with PostgreSQL pools. Only the .query() and .connected properties are used.
+ */
+function createMSSQLCompatPool(pgPool: import('pg').Pool): sql.ConnectionPool {
+  const wrapper = {
+    connected: true,
+    query: async (sqlQuery: string): Promise<{ recordset: Record<string, unknown>[] }> => {
+      const result = await pgPool.query(sqlQuery);
+      return { recordset: result.rows };
+    },
+    request: (): { query: (sql: string) => Promise<{ recordset: Record<string, unknown>[] }> } => ({
+      query: async (sqlQuery: string) => {
+        const result = await pgPool.query(sqlQuery);
+        return { recordset: result.rows };
+      },
+    }),
+    // pg.Pool reference for consumers that need it
+    _pgPool: pgPool,
+  };
+  return wrapper as unknown as sql.ConnectionPool;
+}
+
+/**
+ * Refreshes the UserCache using PostgreSQL queries instead of MSSQL.
+ * This mirrors the logic in UserCache.Refresh() but uses pg.Pool.
+ */
+async function refreshUserCacheFromPG(pgPool: import('pg').Pool, coreSchema: string): Promise<void> {
+  const { UserInfo } = await import('@memberjunction/core');
+  const uResult = await pgPool.query(`SELECT * FROM ${coreSchema}."vwUsers"`);
+  const rResult = await pgPool.query(`SELECT * FROM ${coreSchema}."vwUserRoles"`);
+  const users = uResult.rows;
+  const roles = rResult.rows;
+
+  if (users) {
+    const userInfos = users.map((user: Record<string, unknown>) => {
+      const userWithRoles = {
+        ...user,
+        UserRoles: roles.filter((role: Record<string, unknown>) => UUIDsEqual(role.UserID as string, user.ID as string)),
+      };
+      return new UserInfo(Metadata.Provider, userWithRoles);
+    });
+    // Access the UserCache internals to set users
+    const cache = UserCache.Instance;
+    (cache as unknown as Record<string, unknown>)['_users'] = userInfos;
+  }
+}
+
+/**
+ * Translates SQL Server bracket-quoted identifiers to PostgreSQL double-quoted identifiers.
+ * Converts [schema].[table] to "schema"."table" and handles common T-SQL patterns.
+ */
+function translateBracketsToPG(sql: string): string {
+  // Replace [identifier] with "identifier"
+  return sql.replace(/\[([^\]]+)\]/g, '"$1"');
+}

package/src/resolvers/ActionResolver.ts

@@ -6,7 +6,7 @@ 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 { CopyScalarsAndArrays, UUIDsEqual } from "@memberjunction/global";
 import { GetReadOnlyProvider } from "../util.js";
 import { ResolverBase } from "../generic/ResolverBase.js";
 
@@ -221,7 +221,7 @@ export class ActionResolver extends ResolverBase {
    * @private
    */
   private findActionById(actionID: string): any {
-    const action = ActionEngineServer.Instance.Actions.find(a => a.ID === actionID);
+    const action = ActionEngineServer.Instance.Actions.find(a => UUIDsEqual(a.ID, actionID));
     if (!action) {
       throw new Error(`Action with ID ${actionID} not found`);
     }
@@ -377,7 +377,7 @@ export class ActionResolver extends ResolverBase {
    * @private
    */
   private getEntityAction(actionID: string): any {
-    const entityAction = EntityActionEngineServer.Instance.EntityActions.find(ea => ea.ID === actionID);
+    const entityAction = EntityActionEngineServer.Instance.EntityActions.find(ea => UUIDsEqual(ea.ID, actionID));
     if (!entityAction) {
       throw new Error(`EntityAction with ID ${actionID} not found`);
     }
@@ -419,7 +419,7 @@ export class ActionResolver extends ResolverBase {
         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 => UUIDsEqual(e.ID, input.EntityID));
       if (!entity) {
         throw new Error(`Entity with ID ${input.EntityID} not found`);
       }

package/src/resolvers/ComponentRegistryResolver.ts

@@ -1,5 +1,6 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Mutation, Resolver } from 'type-graphql';
 import { UserInfo, Metadata, LogError, LogStatus } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { MJComponentEntity, MJComponentRegistryEntity, ComponentMetadataEngine } from '@memberjunction/core-entities';
 import { ComponentSpec } from '@memberjunction/interactive-component-types';
@@ -398,7 +399,7 @@ export class ComponentRegistryExtendedResolver {
             await this.componentEngine.Config(false, userInfo);
             
             const registry = this.componentEngine.ComponentRegistries?.find(
-                r => r.ID === registryId
+                r => UUIDsEqual(r.ID, registryId)
             );
             
             return registry || null;
@@ -457,10 +458,10 @@ export class ComponentRegistryExtendedResolver {
      */
     private createClientForRegistry(registry: MJComponentRegistryEntity): ComponentRegistryClient {
         // Check if there's a configuration for this registry
-        const config = configInfo.componentRegistries?.find(r => 
-            r.id === registry.ID || r.name === registry.Name
+        const config = configInfo.componentRegistries?.find(r =>
+            UUIDsEqual(r.id, registry.ID) || r.name === registry.Name
         );
-        
+
         // Get API key from environment or config
         const apiKey = process.env[`REGISTRY_API_KEY_${registry.ID.replace(/-/g, '_').toUpperCase()}`] ||
                       process.env[`REGISTRY_API_KEY_${registry.Name?.replace(/-/g, '_').toUpperCase()}`] ||
@@ -492,8 +493,8 @@ export class ComponentRegistryExtendedResolver {
      */
     private shouldCache(registry: MJComponentRegistryEntity): boolean {
         // Check config for caching settings
-        const config = configInfo.componentRegistries?.find(r => 
-            r.id === registry.ID || r.name === registry.Name
+        const config = configInfo.componentRegistries?.find(r =>
+            UUIDsEqual(r.id, registry.ID) || r.name === registry.Name
         );
         return config?.cache !== false; // Cache by default
     }
@@ -515,7 +516,7 @@ export class ComponentRegistryExtendedResolver {
             const existingComponent = this.componentEngine.Components?.find(
                 c => c.Name === component.name && 
                      c.Namespace === component.namespace &&
-                     c.SourceRegistryID === registryId
+                     UUIDsEqual(c.SourceRegistryID, registryId)
             );
             
             if (existingComponent) {

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,5 @@
 import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions, RunView } from '@memberjunction/core';
+import { NormalizeUUID } from '@memberjunction/global';
 import { MJFileEntity, MJFileStorageProviderEntity, MJFileStorageAccountEntity } from '@memberjunction/core-entities';
 import {
   AppContext,
@@ -748,8 +749,8 @@ export class FileResolver extends FileResolverBase {
 
     // Log any accounts that weren't found
     if (accountEntities.length < input.AccountIDs.length) {
-      const foundIDs = new Set(accountEntities.map((a) => a.ID));
-      const missingIDs = input.AccountIDs.filter((id) => !foundIDs.has(id));
+      const foundIDs = new Set(accountEntities.map((a) => NormalizeUUID(a.ID)));
+      const missingIDs = input.AccountIDs.filter((id) => !foundIDs.has(NormalizeUUID(id)));
       console.warn(`[FileResolver] Accounts not found: ${missingIDs.join(', ')}`);
     }
 

package/src/resolvers/RunAIAgentResolver.ts

@@ -10,7 +10,7 @@ import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
-import { SafeJSONParse } from '@memberjunction/global';
+import { SafeJSONParse, UUIDsEqual } from '@memberjunction/global';
 import { getAttachmentService } from '@memberjunction/aiengine';
 import { NotificationEngine } from '@memberjunction/notifications';
 
@@ -212,7 +212,7 @@ export class RunAIAgentResolver extends ResolverBase {
         await AIEngine.Instance.Config(false, currentUser);
         
         // Find agent in cached collection
-        const agentEntity = AIEngine.Instance.Agents.find((a: MJAIAgentEntityExtended) => a.ID === agentId);
+        const agentEntity = AIEngine.Instance.GetAgentByID(agentId);
         
         if (!agentEntity) {
             throw new Error(`AI Agent with ID ${agentId} not found`);
@@ -676,7 +676,7 @@ export class RunAIAgentResolver extends ResolverBase {
 
             // Get agent info for notification message
             await AIEngine.Instance.Config(false, contextUser);
-            const agent = AIEngine.Instance.Agents.find(a => a.ID === agentRun.AgentID);
+            const agent = AIEngine.Instance.Agents.find(a => UUIDsEqual(a.ID, agentRun.AgentID));
             const agentName = agent?.Name || 'Agent';
 
             // Load conversation detail to get conversation info

package/src/resolvers/SqlLoggingConfigResolver.ts

@@ -9,6 +9,7 @@ import * as fs from 'fs/promises';
 import { loadConfig } from '../config.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadOnlyProvider } from '../util.js';
+import { SqlLoggingOptions as ProviderSqlLoggingOptions } from '@memberjunction/generic-database-provider';
 
 /**
  * Configuration options for SQL logging sessions.
@@ -315,7 +316,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   async sqlLoggingConfig(@Ctx() context: AppContext): Promise<SqlLoggingConfig> {
     await this.checkOwnerAccess(context);
     const config = await loadConfig();
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const activeSessions = provider.GetActiveSqlLoggingSessions();
 
     return {
@@ -370,7 +371,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   @Query(() => [SqlLoggingSession])
   async activeSqlLoggingSessions(@Ctx() context: AppContext): Promise<SqlLoggingSession[]> {
     await this.checkOwnerAccess(context);
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
 
     return sessions.map(session => ({
@@ -435,7 +436,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     }
 
     // Check max active sessions
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const activeSessions = provider.GetActiveSqlLoggingSessions();
     if (activeSessions.length >= (config.sqlLogging.maxActiveSessions ?? 5)) {
       throw new Error(`Maximum number of active SQL logging sessions (${config.sqlLogging.maxActiveSessions}) reached`);
@@ -521,7 +522,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     @Ctx() context: AppContext
   ): Promise<boolean> {
     await this.checkOwnerAccess(context);
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
 
     // Use the public method to get and dispose the session
     const session = provider.GetSqlLoggingSessionById(sessionId);
@@ -564,7 +565,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
   @Mutation(() => Boolean)
   async stopAllSqlLogging(@Ctx() context: AppContext): Promise<boolean> {
     await this.checkOwnerAccess(context);
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     await provider.DisposeAllSqlLoggingSessions();
     return true;
   }
@@ -654,7 +655,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
     }
 
     // Find the session
-    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as SQLServerDataProvider;
+    const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true}) as unknown as SQLServerDataProvider;
     const sessions = provider.GetActiveSqlLoggingSessions();
     const session = sessions.find((s) => s.id === sessionId);
     
@@ -744,7 +745,7 @@ export class SqlLoggingConfigResolver extends ResolverBase {
    * @returns GraphQL-compatible SqlLoggingOptions
    * @private
    */
-  private convertOptionsToGraphQL(options: import('@memberjunction/sqlserver-dataprovider').SqlLoggingOptions): SqlLoggingOptions {
+  private convertOptionsToGraphQL(options: ProviderSqlLoggingOptions): SqlLoggingOptions {
     return {
       formatAsMigration: options.formatAsMigration,
       description: options.description,

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -1,6 +1,7 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
 import { EntityDeleteOptions, EntitySaveOptions, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { MJRoleEntity, MJUserEntity, MJUserRoleEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
@@ -382,7 +383,7 @@ export class SyncRolesAndUsersResolver {
                         const dbRole = dbRoles.find(r => r.Name.trim().toLowerCase() === role.Name.trim().toLowerCase());
                         if (dbRole) {
                             // now we need to make sure there is a user role that matches this user and role
-                            if (!dbUserRoles.find(ur => ur.UserID === dbUser.ID && ur.RoleID === dbRole.ID)) {
+                            if (!dbUserRoles.find(ur => UUIDsEqual(ur.UserID, dbUser.ID) && UUIDsEqual(ur.RoleID, dbRole.ID))) {
                                 // we need to add a user role
                                 const ur = await md.GetEntityObject<MJUserRoleEntity>("MJ: User Roles", u);
                                 ur.UserID = dbUser.ID;
@@ -392,9 +393,9 @@ export class SyncRolesAndUsersResolver {
                         }
                     }
                     // now, we check for DB user roles that are NOT in the user.Roles property as they are no longer part of the user's roles
-                    const thisUserDBRoles = dbUserRoles.filter(ur => ur.UserID === dbUser.ID);
+                    const thisUserDBRoles = dbUserRoles.filter(ur => UUIDsEqual(ur.UserID, dbUser.ID));
                     for (const dbUserRole of thisUserDBRoles) {
-                        const role = user.Roles.find(r => r.Name.trim().toLowerCase() === dbRoles.find(rr => rr.ID === dbUserRole.RoleID)?.Name.trim().toLowerCase());
+                        const role = user.Roles.find(r => r.Name.trim().toLowerCase() === dbRoles.find(rr => UUIDsEqual(rr.ID, dbUserRole.RoleID))?.Name.trim().toLowerCase());
                         if (!role && !this.IsStandardRole(dbUserRole.Role)) {
                             // this user role is no longer in the user's roles, we need to remove it
                             //dbUserRole.TransactionGroup = tg;

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,4 +1,5 @@
 import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import {
   AppContext,
   Arg,
@@ -85,7 +86,7 @@ export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
     const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
 
-    const e = p.Entities.find((e) => e.ID === params.EntityID);
+    const e = p.Entities.find((e) => UUIDsEqual(e.ID, params.EntityID));
     if (e)
       return {
         EntityID: params.EntityID,
@@ -101,8 +102,8 @@ export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
   async SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload, providers }: AppContext) {
     const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
     const pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
-    const e = p.Entities.find((e) => e.ID === params.EntityID);
-    const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);
+    const e = p.Entities.find((e) => UUIDsEqual(e.ID, params.EntityID));
+    const u = UserCache.Users.find((u) => UUIDsEqual(u.ID, userPayload.userRecord.ID));
     if (e) {
       await p.SetRecordFavoriteStatus(params.UserID, e.Name, pk, params.IsFavorite, u);
       return {

package/src/rest/OAuthCallbackHandler.ts

@@ -14,6 +14,7 @@
 
 import express from 'express';
 import { LogError, LogStatus, RunView, UserInfo } from '@memberjunction/core';
+import { UUIDsEqual } from '@memberjunction/global';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { OAuthManager, MCPClientManager } from '@memberjunction/ai-mcp-client';
 import type { MCPServerOAuthConfig } from '@memberjunction/ai-mcp-client';
@@ -201,7 +202,7 @@ export class OAuthCallbackHandler {
             }
 
             // Get the actual user from cache
-            const contextUser = UserCache.Users.find(u => u.ID === authState.userId);
+            const contextUser = UserCache.Users.find(u => UUIDsEqual(u.ID, authState.userId));
             if (!contextUser) {
                 LogError(`[OAuth Callback] User ${authState.userId} not found in cache`);
                 this.redirectToError(res, 'server_error', 'User context not found', authState.frontendReturnUrl);
@@ -289,7 +290,7 @@ export class OAuthCallbackHandler {
             }
 
             // Verify user owns this state
-            if (authState.userId !== contextUser.ID) {
+            if (!UUIDsEqual(authState.userId, contextUser.ID)) {
                 res.status(403).json({
                     success: false,
                     errorCode: 'forbidden',
@@ -491,7 +492,7 @@ export class OAuthCallbackHandler {
             }
 
             // Verify the authenticated user owns this authorization state
-            if (authState.userId !== contextUser.ID) {
+            if (!UUIDsEqual(authState.userId, contextUser.ID)) {
                 LogError(`[OAuth Exchange] User ${contextUser.ID} attempted to exchange code for state owned by ${authState.userId}`);
                 res.status(403).json({
                     success: false,