@memberjunction/server 5.24.0 → 5.26.0

package/src/resolvers/GeoResolver.ts

@@ -0,0 +1,258 @@
+import { Resolver, Query, Arg, Ctx, ObjectType, Field, InputType, Float, Int } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { RunView, LogError, Metadata, UserInfo } from '@memberjunction/core';
+import { MJCountryEntity, MJStateProvinceEntity } from '@memberjunction/core-entities';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+@ObjectType()
+export class GeoCountryResult {
+    @Field()
+    ID!: string;
+
+    @Field()
+    Name!: string;
+
+    @Field()
+    ISO2!: string;
+
+    @Field()
+    ISO3!: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude!: number | null;
+
+    @Field(() => Float, { nullable: true })
+    Longitude!: number | null;
+}
+
+@ObjectType()
+export class GeoStateProvinceResult {
+    @Field()
+    ID!: string;
+
+    @Field()
+    CountryID!: string;
+
+    @Field()
+    Name!: string;
+
+    @Field()
+    Code!: string;
+
+    @Field()
+    ISO3166_2!: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude!: number | null;
+
+    @Field(() => Float, { nullable: true })
+    Longitude!: number | null;
+}
+
+@ObjectType()
+export class GeoResolveResult {
+    @Field()
+    Success!: boolean;
+
+    @Field({ nullable: true })
+    CountryID?: string;
+
+    @Field({ nullable: true })
+    CountryName?: string;
+
+    @Field({ nullable: true })
+    StateProvinceID?: string;
+
+    @Field({ nullable: true })
+    StateProvinceName?: string;
+
+    @Field(() => Float, { nullable: true })
+    Latitude?: number;
+
+    @Field(() => Float, { nullable: true })
+    Longitude?: number;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Resolver
+// ---------------------------------------------------------------------------
+
+/**
+ * GraphQL resolver for geographic reference data resolution.
+ * Provides country/state text-to-reference matching via the GeoResolver service.
+ * Used by clients that need to resolve free-text location strings to structured
+ * reference data (Country/StateProvince IDs, centroids) without a full geocoding API call.
+ */
+@Resolver()
+export class GeoResolver extends ResolverBase {
+    private _countries: MJCountryEntity[] | null = null;
+    private _states: MJStateProvinceEntity[] | null = null;
+
+    /**
+     * Lazily load all countries into memory (~250 records).
+     */
+    private async GetCountries(contextUser: UserInfo | undefined): Promise<MJCountryEntity[]> {
+        if (this._countries) return this._countries;
+        const rv = new RunView();
+        const result = await rv.RunView<MJCountryEntity>({
+            EntityName: 'MJ: Countries',
+            ResultType: 'entity_object'
+        }, contextUser);
+        if (result.Success) {
+            this._countries = result.Results;
+        }
+        return this._countries ?? [];
+    }
+
+    /**
+     * Lazily load all state/provinces into memory (~5000 records).
+     */
+    private async GetStates(contextUser: UserInfo | undefined): Promise<MJStateProvinceEntity[]> {
+        if (this._states) return this._states;
+        const rv = new RunView();
+        const result = await rv.RunView<MJStateProvinceEntity>({
+            EntityName: 'MJ: State Provinces',
+            ResultType: 'entity_object'
+        }, contextUser);
+        if (result.Success) {
+            this._states = result.Results;
+        }
+        return this._states ?? [];
+    }
+
+    /**
+     * Resolve a free-text country string to a Country reference record.
+     * Matches by Name, ISO2, ISO3, or CommonAliases.
+     */
+    @Query(() => GeoResolveResult)
+    async ResolveCountry(
+        @Arg('input', () => String) input: string,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<GeoResolveResult> {
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+            const countries = await this.GetCountries(user);
+            const normalized = input.trim().toLowerCase();
+
+            // 1. Exact match on Name, ISO2, ISO3
+            const exact = countries.find(c =>
+                c.Name.toLowerCase() === normalized ||
+                c.ISO2.toLowerCase() === normalized ||
+                c.ISO3.toLowerCase() === normalized
+            );
+            if (exact) {
+                return {
+                    Success: true,
+                    CountryID: exact.ID,
+                    CountryName: exact.Name,
+                    Latitude: exact.Latitude ?? undefined,
+                    Longitude: exact.Longitude ?? undefined
+                };
+            }
+
+            // 2. CommonAliases search
+            const aliasMatch = countries.find(c => {
+                if (!c.CommonAliases) return false;
+                try {
+                    const aliases: string[] = JSON.parse(c.CommonAliases);
+                    return aliases.some(a => a.toLowerCase() === normalized);
+                } catch {
+                    return false;
+                }
+            });
+            if (aliasMatch) {
+                return {
+                    Success: true,
+                    CountryID: aliasMatch.ID,
+                    CountryName: aliasMatch.Name,
+                    Latitude: aliasMatch.Latitude ?? undefined,
+                    Longitude: aliasMatch.Longitude ?? undefined
+                };
+            }
+
+            return { Success: false, ErrorMessage: `No country match for "${input}"` };
+        } catch (e: unknown) {
+            const msg = e instanceof Error ? e.message : String(e);
+            LogError(`GeoResolver.ResolveCountry error: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+
+    /**
+     * Resolve a free-text state/province string with country context.
+     * Country context is critical: "CA" = California (US) vs Canada (ISO2).
+     */
+    @Query(() => GeoResolveResult)
+    async ResolveStateProvince(
+        @Arg('stateInput', () => String) stateInput: string,
+        @Arg('countryInput', () => String) countryInput: string,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<GeoResolveResult> {
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+
+            // First resolve country
+            const countryResult = await this.ResolveCountry(countryInput, { userPayload } as AppContext);
+            if (!countryResult.Success || !countryResult.CountryID) {
+                return { Success: false, ErrorMessage: `Could not resolve country "${countryInput}"` };
+            }
+
+            const states = await this.GetStates(user);
+            const countryStates = states.filter(s => s.CountryID === countryResult.CountryID);
+            const normalized = stateInput.trim().toLowerCase();
+
+            // 1. Exact match on Name, Code, ISO3166_2
+            const exact = countryStates.find(s =>
+                s.Name.toLowerCase() === normalized ||
+                s.Code.toLowerCase() === normalized ||
+                s.ISO3166_2.toLowerCase() === normalized
+            );
+            if (exact) {
+                return {
+                    Success: true,
+                    CountryID: countryResult.CountryID,
+                    CountryName: countryResult.CountryName,
+                    StateProvinceID: exact.ID,
+                    StateProvinceName: exact.Name,
+                    Latitude: exact.Latitude ?? undefined,
+                    Longitude: exact.Longitude ?? undefined
+                };
+            }
+
+            // 2. CommonAliases search
+            const aliasMatch = countryStates.find(s => {
+                if (!s.CommonAliases) return false;
+                try {
+                    const aliases: string[] = JSON.parse(s.CommonAliases);
+                    return aliases.some(a => a.toLowerCase() === normalized);
+                } catch {
+                    return false;
+                }
+            });
+            if (aliasMatch) {
+                return {
+                    Success: true,
+                    CountryID: countryResult.CountryID,
+                    CountryName: countryResult.CountryName,
+                    StateProvinceID: aliasMatch.ID,
+                    StateProvinceName: aliasMatch.Name,
+                    Latitude: aliasMatch.Latitude ?? undefined,
+                    Longitude: aliasMatch.Longitude ?? undefined
+                };
+            }
+
+            return { Success: false, ErrorMessage: `No state/province match for "${stateInput}" in ${countryResult.CountryName}` };
+        } catch (e: unknown) {
+            const msg = e instanceof Error ? e.message : String(e);
+            LogError(`GeoResolver.ResolveStateProvince error: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+}

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,17 +1,17 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID, Int } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
-import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
-import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity, MJAIAgentRequestEntity } from '@memberjunction/core-entities';
+import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity, MJConversationDetailArtifactEntity, MJArtifactVersionEntity, MJAIAgentRequestEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
-import { ChatMessage } from '@memberjunction/ai';
+import { ChatMessage, ChatMessageContent } from '@memberjunction/ai';
 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, UUIDsEqual } from '@memberjunction/global';
-import { getAttachmentService } from '@memberjunction/aiengine';
+import { GetAttachmentService } from '@memberjunction/aiengine';
 import { NotificationEngine } from '@memberjunction/notifications';
 
 @ObjectType()
@@ -453,7 +453,7 @@ export class RunAIAgentResolver extends ResolverBase {
 
             if (lastRunId && result.agentRun?.ID) {
                 postExecutionOps.push(
-                    this.syncFeedbackRequestFromConversation(lastRunId, result.agentRun.ID, userMessage, currentUser)
+                    this.syncFeedbackRequestFromConversation(lastRunId, result.agentRun.ID, userMessage, currentUser, p)
                 );
             }
 
@@ -797,10 +797,11 @@ export class RunAIAgentResolver extends ResolverBase {
         lastRunId: string,
         newRunId: string,
         userMessage: string | undefined,
-        contextUser: UserInfo
+        contextUser: UserInfo,
+        provider: IMetadataProvider
     ): Promise<void> {
         try {
-            const rv = new RunView();
+            const rv = RunView.FromMetadataProvider(provider);
             const result = await rv.RunView<MJAIAgentRequestEntity>({
                 EntityName: 'MJ: AI Agent Requests',
                 ExtraFilter: `OriginatingAgentRunID='${lastRunId}' AND Status='Requested'`,
@@ -939,8 +940,7 @@ export class RunAIAgentResolver extends ResolverBase {
             // times: once in loadConversationHistoryWithAttachments (just to get conversationId),
             // once in AgentRunner (same reason), and once in createCompletionNotification. Now we
             // load it a single time and thread conversationId through the call chain.
-            const md = new Metadata();
-            const currentDetail = await md.GetEntityObject<MJConversationDetailEntity>(
+            const currentDetail = await p.GetEntityObject<MJConversationDetailEntity>(
                 'MJ: Conversation Details',
                 currentUser
             );
@@ -953,7 +953,8 @@ export class RunAIAgentResolver extends ResolverBase {
             const messages = await this.loadConversationHistoryWithAttachments(
                 conversationId,
                 currentUser,
-                maxHistoryMessages || 20
+                maxHistoryMessages || 20,
+                p
             );
 
             // Convert to JSON string for the existing executeAIAgent method
@@ -1031,8 +1032,8 @@ export class RunAIAgentResolver extends ResolverBase {
                 throw new Error('Unable to determine current user');
             }
 
-            const md = new Metadata();
-            const request = await md.GetEntityObject<MJAIAgentRequestEntity>(
+            const p = GetReadWriteProvider(providers);
+            const request = await p.GetEntityObject<MJAIAgentRequestEntity>(
                 'MJ: AI Agent Requests',
                 currentUser
             );
@@ -1096,7 +1097,7 @@ export class RunAIAgentResolver extends ResolverBase {
     async ReassignAgentRequest(
         @Arg('requestId') requestId: string,
         @Arg('newUserID') newUserID: string,
-        @Ctx() { userPayload }: AppContext,
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('note', { nullable: true }) note?: string
     ): Promise<AIAgentRunResult> {
         const startTime = Date.now();
@@ -1106,8 +1107,8 @@ export class RunAIAgentResolver extends ResolverBase {
                 throw new Error('Unable to determine current user');
             }
 
-            const md = new Metadata();
-            const request = await md.GetEntityObject<MJAIAgentRequestEntity>(
+            const p = GetReadWriteProvider(providers);
+            const request = await p.GetEntityObject<MJAIAgentRequestEntity>(
                 'MJ: AI Agent Requests',
                 currentUser
             );
@@ -1262,10 +1263,11 @@ export class RunAIAgentResolver extends ResolverBase {
     private async loadConversationHistoryWithAttachments(
         conversationId: string,
         contextUser: UserInfo,
-        maxMessages: number
+        maxMessages: number,
+        provider: IMetadataProvider
     ): Promise<ChatMessage[]> {
-        const rv = new RunView();
-        const attachmentService = getAttachmentService();
+        const rv = RunView.FromMetadataProvider(provider);
+        const attachmentService = GetAttachmentService();
 
         // Load recent conversation details (messages) for this conversation.
         // Only fetch the three fields we actually use — ID for attachment lookups,
@@ -1290,9 +1292,12 @@ export class RunAIAgentResolver extends ResolverBase {
         const messageIds = details.map(d => d.ID);
 
         // Batch load all attachments for these messages
-        const attachmentsByDetailId = await attachmentService.getAttachmentsBatch(messageIds, contextUser);
+        const attachmentsByDetailId = await attachmentService.GetAttachmentsBatch(messageIds, contextUser, provider);
+
+        // Batch load input artifacts for these messages
+        const inputArtifactsByDetailId = await this.loadInputArtifactsBatch(messageIds, contextUser, provider);
 
-        // Build ChatMessage array with attachments
+        // Build ChatMessage array with attachments and input artifacts
         const messages: ChatMessage[] = [];
 
         for (const detail of details) {
@@ -1301,7 +1306,7 @@ export class RunAIAgentResolver extends ResolverBase {
 
             // Get attachment data with content URLs (handles both inline and FileID storage)
             const attachmentDataPromises = attachments.map(att =>
-                attachmentService.getAttachmentData(att, contextUser)
+                attachmentService.GetAttachmentData(att, contextUser, provider)
             );
             const attachmentDataResults = await Promise.all(attachmentDataPromises);
 
@@ -1319,12 +1324,38 @@ export class RunAIAgentResolver extends ResolverBase {
                     content: result.contentUrl
                 }));
 
+            // Get input artifacts for this message and convert to AttachmentData
+            const inputArtifacts = inputArtifactsByDetailId.get(detail.ID) || [];
+            for (const artifactVersion of inputArtifacts) {
+                if (artifactVersion.ContentMode === 'File' && artifactVersion.FileID) {
+                    // File-backed artifact — download content and treat like a document attachment
+                    const fileContent = await this.downloadArtifactFileContent(artifactVersion, contextUser, provider);
+                    if (fileContent) {
+                        validAttachments.push({
+                            type: ConversationUtility.GetAttachmentTypeFromMime(artifactVersion.MimeType || ''),
+                            mimeType: artifactVersion.MimeType || 'application/octet-stream',
+                            fileName: artifactVersion.FileName || artifactVersion.Name || undefined,
+                            sizeBytes: artifactVersion.ContentSizeBytes || undefined,
+                            content: fileContent
+                        });
+                    }
+                } else if (artifactVersion.Content) {
+                    // Text artifact — include content directly as a text attachment
+                    validAttachments.push({
+                        type: 'Document' as AttachmentData['type'],
+                        mimeType: 'text/plain',
+                        fileName: artifactVersion.Name || 'artifact.txt',
+                        content: `[Artifact: ${artifactVersion.Name || 'Untitled'}]\n\n${artifactVersion.Content}`
+                    });
+                }
+            }
+
             // Build message content (with or without attachments)
-            let content: string | ReturnType<typeof ConversationUtility.BuildChatMessageContent>;
+            let content: ChatMessageContent;
 
             if (validAttachments.length > 0) {
                 // Use ConversationUtility to build multimodal content blocks
-                content = ConversationUtility.BuildChatMessageContent(
+                content = await ConversationUtility.BuildChatMessageContent(
                     detail.Message || '',
                     validAttachments
                 );
@@ -1352,4 +1383,87 @@ export class RunAIAgentResolver extends ResolverBase {
         return 'user'; // Default to user
     }
 
+    /**
+     * Batch load input artifact versions for conversation details.
+     * Returns a map of ConversationDetailID -> ArtifactVersion[]
+     */
+    private async loadInputArtifactsBatch(
+        conversationDetailIds: string[],
+        contextUser: UserInfo,
+        provider: IMetadataProvider
+    ): Promise<Map<string, MJArtifactVersionEntity[]>> {
+        const map = new Map<string, MJArtifactVersionEntity[]>();
+        if (conversationDetailIds.length === 0) return map;
+
+        const rv = RunView.FromMetadataProvider(provider);
+        const idList = conversationDetailIds.map(id => `'${id}'`).join(',');
+
+        // Load ConversationDetailArtifact links with Direction='Input'
+        const linksResult = await rv.RunView<MJConversationDetailArtifactEntity>({
+            EntityName: 'MJ: Conversation Detail Artifacts',
+            ExtraFilter: `ConversationDetailID IN (${idList}) AND Direction = 'Input'`,
+            ResultType: 'entity_object'
+        }, contextUser);
+
+        if (!linksResult.Success || !linksResult.Results || linksResult.Results.length === 0) {
+            return map;
+        }
+
+        // Load the referenced artifact versions
+        const versionIds = linksResult.Results.map(l => `'${l.ArtifactVersionID}'`).join(',');
+        const versionsResult = await rv.RunView<MJArtifactVersionEntity>({
+            EntityName: 'MJ: Artifact Versions',
+            ExtraFilter: `ID IN (${versionIds})`,
+            ResultType: 'entity_object'
+        }, contextUser);
+
+        if (!versionsResult.Success || !versionsResult.Results) return map;
+
+        // Build a lookup of version ID -> version entity
+        const versionMap = new Map<string, MJArtifactVersionEntity>();
+        for (const v of versionsResult.Results) {
+            versionMap.set(v.ID, v);
+        }
+
+        // Group by conversation detail ID
+        for (const link of linksResult.Results) {
+            const version = versionMap.get(link.ArtifactVersionID);
+            if (version) {
+                const existing = map.get(link.ConversationDetailID) || [];
+                existing.push(version);
+                map.set(link.ConversationDetailID, existing);
+            }
+        }
+
+        return map;
+    }
+
+    /**
+     * Download file content from an artifact version's FileID.
+     * Returns base64 data URL for extraction pipeline compatibility.
+     * Uses the same downloadFileContent path as ConversationAttachmentService
+     * to avoid Box driver path resolution issues.
+     */
+    private async downloadArtifactFileContent(
+        artifactVersion: MJArtifactVersionEntity,
+        contextUser: UserInfo,
+        provider: IMetadataProvider
+    ): Promise<string | null> {
+        if (!artifactVersion.FileID) return null;
+
+        try {
+            // Use the attachment service's downloadFileContent which uses GetObject directly
+            const attachmentService = GetAttachmentService();
+            const buffer = await attachmentService.DownloadFileContent(artifactVersion.FileID, contextUser, provider);
+            if (!buffer) return null;
+
+            const base64 = buffer.toString('base64');
+            const mimeType = artifactVersion.MimeType || 'application/octet-stream';
+            return `data:${mimeType};base64,${base64}`;
+        } catch (err) {
+            LogError(`Failed to download artifact file ${artifactVersion.FileID}: ${err}`);
+            return null;
+        }
+    }
+
 }