@memberjunction/server 2.1.2 → 2.1.3

package/dist/resolvers/AskSkipResolver.js

@@ -0,0 +1,805 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var AskSkipResolver_1;
+import { Arg, Ctx, Field, Int, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { LogError, LogStatus, Metadata, RunView, CompositeKey } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { DataContext } from '@memberjunction/data-context';
+import { LoadDataContextItemsServer } from '@memberjunction/data-context-server';
+LoadDataContextItemsServer();
+import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver';
+import { ___skipAPIOrgId, ___skipAPIurl, configInfo, mj_core_schema } from '../config';
+import { registerEnumType } from "type-graphql";
+import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
+import { sendPostRequest } from '../util';
+import { GetAIAPIKey } from '@memberjunction/ai';
+import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes';
+var SkipResponsePhase;
+(function (SkipResponsePhase) {
+    SkipResponsePhase["ClarifyingQuestion"] = "clarifying_question";
+    SkipResponsePhase["DataRequest"] = "data_request";
+    SkipResponsePhase["AnalysisComplete"] = "analysis_complete";
+})(SkipResponsePhase || (SkipResponsePhase = {}));
+registerEnumType(SkipResponsePhase, {
+    name: "SkipResponsePhase",
+    description: "The phase of the respons: clarifying_question, data_request, or analysis_complete",
+});
+let AskSkipResultType = class AskSkipResultType {
+    Success;
+    Status;
+    ResponsePhase;
+    Result;
+    ConversationId;
+    UserMessageConversationDetailId;
+    AIMessageConversationDetailId;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AskSkipResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "Status", void 0);
+__decorate([
+    Field(() => SkipResponsePhase),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "ResponsePhase", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "Result", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "ConversationId", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "UserMessageConversationDetailId", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", String)
+], AskSkipResultType.prototype, "AIMessageConversationDetailId", void 0);
+AskSkipResultType = __decorate([
+    ObjectType()
+], AskSkipResultType);
+export { AskSkipResultType };
+let AskSkipResolver = class AskSkipResolver {
+    static { AskSkipResolver_1 = this; }
+    static _defaultNewChatName = 'New Chat';
+    static _maxHistoricalMessages = 20;
+    async ExecuteAskSkipRecordChat(UserQuestion, ConversationId, EntityName, compositeKey, { dataSource, userPayload }, pubSub) {
+        const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+        if (!user)
+            throw new Error(`User ${userPayload.email} not found in UserCache`);
+        const messages = await this.LoadConversationDetailsIntoSkipMessages(dataSource, ConversationId, AskSkipResolver_1._maxHistoricalMessages);
+        const md = new Metadata();
+        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, null);
+        if (!ConversationId || ConversationId.length === 0) {
+            const dci = await md.GetEntityObject('Data Context Items', user);
+            dci.DataContextID = dataContext.ID;
+            dci.Type = 'single_record';
+            dci.EntityID = md.Entities.find((e) => e.Name === EntityName)?.ID;
+            const ck = new CompositeKey();
+            ck.KeyValuePairs = compositeKey.KeyValuePairs;
+            dci.RecordID = ck.Values();
+            let dciSaveResult = await dci.Save();
+            if (!dciSaveResult) {
+                LogError(`Error saving DataContextItemEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, dci.LatestResult);
+            }
+            await dataContext.Load(dataContext.ID, dataSource, false, true, 10, user);
+            await dataContext.SaveItems(user, true);
+            convoEntity.LinkedEntityID = dci.EntityID;
+            convoEntity.LinkedRecordID = ck.Values();
+            convoEntity.DataContextID = dataContext.ID;
+            const convoEntitySaveResult = await convoEntity.Save();
+            if (!convoEntitySaveResult) {
+                LogError(`Error saving ConversationEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, convoEntity.LatestResult);
+            }
+        }
+        const input = this.buildSkipAPIRequest(messages, ConversationId, dataContext, 'chat_with_a_record', false, false);
+        messages.push({
+            content: UserQuestion,
+            role: 'user'
+        });
+        return this.handleSimpleSkipPostRequest(input, convoEntity.ID, convoDetailEntity.ID, true, user);
+    }
+    async handleSimpleSkipPostRequest(input, conversationID = "", UserMessageConversationDetailId = "", createAIMessageConversationDetail = false, user = null) {
+        LogStatus(`   >>> HandleSimpleSkipPostRequest Sending request to Skip API: ${___skipAPIurl}`);
+        const response = await sendPostRequest(___skipAPIurl, input, true, null);
+        if (response && response.length > 0) {
+            const apiResponse = response[response.length - 1].value;
+            const AIMessageConversationDetailID = createAIMessageConversationDetail ? await this.CreateAIMessageConversationDetail(apiResponse, conversationID, user) : "";
+            LogStatus(`  Skip API response: ${apiResponse.responsePhase}`);
+            return {
+                Success: true,
+                Status: 'OK',
+                ResponsePhase: SkipResponsePhase.AnalysisComplete,
+                ConversationId: conversationID,
+                UserMessageConversationDetailId: UserMessageConversationDetailId,
+                AIMessageConversationDetailId: AIMessageConversationDetailID,
+                Result: JSON.stringify(apiResponse)
+            };
+        }
+        else {
+            return {
+                Success: false,
+                Status: 'Error',
+                Result: `Request failed`,
+                ResponsePhase: SkipResponsePhase.AnalysisComplete,
+                ConversationId: conversationID,
+                UserMessageConversationDetailId: UserMessageConversationDetailId,
+                AIMessageConversationDetailId: "",
+            };
+        }
+    }
+    async CreateAIMessageConversationDetail(apiResponse, conversationID, user) {
+        const md = new Metadata();
+        const convoDetailEntityAI = await md.GetEntityObject('Conversation Details', user);
+        convoDetailEntityAI.NewRecord();
+        convoDetailEntityAI.HiddenToUser = false;
+        convoDetailEntityAI.ConversationID = conversationID;
+        const systemMessages = apiResponse.messages.filter((m) => m.role === 'system');
+        const lastSystemMessage = systemMessages[systemMessages.length - 1];
+        convoDetailEntityAI.Message = lastSystemMessage?.content;
+        convoDetailEntityAI.Role = 'AI';
+        if (await convoDetailEntityAI.Save()) {
+            return convoDetailEntityAI.ID;
+        }
+        else {
+            LogError(`Error saving conversation detail entity for AI message: ${lastSystemMessage?.content}`, undefined, convoDetailEntityAI.LatestResult);
+            return "";
+        }
+    }
+    buildSkipAPIRequest(messages, conversationId, dataContext, requestPhase, includeEntities, includeQueries) {
+        const entities = includeEntities ? this.BuildSkipEntities() : [];
+        const queries = includeQueries ? this.BuildSkipQueries() : [];
+        const input = {
+            apiKeys: this.buildSkipAPIKeys(),
+            organizationInfo: configInfo?.askSkip?.organizationInfo,
+            messages: messages,
+            conversationID: conversationId.toString(),
+            dataContext: CopyScalarsAndArrays(dataContext),
+            organizationID: ___skipAPIOrgId,
+            requestPhase: requestPhase,
+            entities: entities,
+            queries: queries
+        };
+        return input;
+    }
+    async ExecuteAskSkipRunScript({ dataSource, userPayload }, pubSub, DataContextId, ScriptText) {
+        const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+        if (!user)
+            throw new Error(`User ${userPayload.email} not found in UserCache`);
+        const dataContext = new DataContext();
+        await dataContext.Load(DataContextId, dataSource, true, false, 0, user);
+        const input = this.buildSkipAPIRequest([], "", dataContext, 'run_existing_script', false, false);
+        return this.handleSimpleSkipPostRequest(input);
+    }
+    buildSkipAPIKeys() {
+        return [
+            {
+                vendorDriverName: 'OpenAILLM',
+                apiKey: GetAIAPIKey('OpenAILLM')
+            },
+            {
+                vendorDriverName: 'AnthropicLLM',
+                apiKey: GetAIAPIKey('AnthropicLLM')
+            },
+            {
+                vendorDriverName: 'GeminiLLM',
+                apiKey: GetAIAPIKey('GeminiLLM')
+            },
+            {
+                vendorDriverName: 'GroqLLM',
+                apiKey: GetAIAPIKey('GroqLLM')
+            },
+            {
+                vendorDriverName: 'MistralLLM',
+                apiKey: GetAIAPIKey('MistralLLM')
+            },
+        ];
+    }
+    async ExecuteAskSkipAnalysisQuery(UserQuestion, ConversationId, { dataSource, userPayload }, pubSub, DataContextId) {
+        const md = new Metadata();
+        const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+        if (!user)
+            throw new Error(`User ${userPayload.email} not found in UserCache`);
+        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId);
+        const messages = await this.LoadConversationDetailsIntoSkipMessages(dataSource, convoEntity.ID, AskSkipResolver_1._maxHistoricalMessages);
+        const input = this.buildSkipAPIRequest(messages, ConversationId, dataContext, 'initial_request', true, true);
+        return this.HandleSkipRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity);
+    }
+    BuildSkipQueries() {
+        const md = new Metadata();
+        return md.Queries.map((q) => {
+            return {
+                id: q.ID,
+                name: q.Name,
+                description: q.Description,
+                category: q.Category,
+                sql: q.SQL,
+                originalSQL: q.OriginalSQL,
+                feedback: q.Feedback,
+                status: q.Status,
+                qualityRank: q.QualityRank,
+                createdAt: q.__mj_CreatedAt,
+                updatedAt: q.__mj_UpdatedAt,
+                categoryID: q.CategoryID,
+                fields: q.Fields.map((f) => {
+                    return {
+                        id: f.ID,
+                        queryID: f.QueryID,
+                        sequence: f.Sequence,
+                        name: f.Name,
+                        description: f.Description,
+                        sqlBaseType: f.SQLBaseType,
+                        sqlFullType: f.SQLFullType,
+                        sourceEntityID: f.SourceEntityID,
+                        sourceEntity: f.SourceEntity,
+                        sourceFieldName: f.SourceFieldName,
+                        isComputed: f.IsComputed,
+                        computationDescription: f.ComputationDescription,
+                        isSummary: f.IsSummary,
+                        summaryDescription: f.SummaryDescription,
+                        createdAt: f.__mj_CreatedAt,
+                        updatedAt: f.__mj_UpdatedAt,
+                    };
+                })
+            };
+        });
+    }
+    BuildSkipEntities() {
+        const md = new Metadata();
+        return md.Entities.filter(e => e.SchemaName !== mj_core_schema).map((e) => {
+            const ret = {
+                id: e.ID,
+                name: e.Name,
+                schemaName: e.SchemaName,
+                baseView: e.BaseView,
+                description: e.Description,
+                fields: e.Fields.map((f) => {
+                    return {
+                        id: f.ID,
+                        entityID: f.EntityID,
+                        sequence: f.Sequence,
+                        name: f.Name,
+                        displayName: f.DisplayName,
+                        category: f.Category,
+                        type: f.Type,
+                        description: f.Description,
+                        isPrimaryKey: f.IsPrimaryKey,
+                        allowsNull: f.AllowsNull,
+                        isUnique: f.IsUnique,
+                        length: f.Length,
+                        precision: f.Precision,
+                        scale: f.Scale,
+                        sqlFullType: f.SQLFullType,
+                        defaultValue: f.DefaultValue,
+                        autoIncrement: f.AutoIncrement,
+                        valueListType: f.ValueListType,
+                        extendedType: f.ExtendedType,
+                        defaultInView: f.DefaultInView,
+                        defaultColumnWidth: f.DefaultColumnWidth,
+                        isVirtual: f.IsVirtual,
+                        isNameField: f.IsNameField,
+                        relatedEntityID: f.RelatedEntityID,
+                        relatedEntityFieldName: f.RelatedEntityFieldName,
+                        relatedEntity: f.RelatedEntity,
+                        relatedEntitySchemaName: f.RelatedEntitySchemaName,
+                        relatedEntityBaseView: f.RelatedEntityBaseView,
+                    };
+                }),
+                relatedEntities: e.RelatedEntities.map((r) => {
+                    return {
+                        entityID: r.EntityID,
+                        relatedEntityID: r.RelatedEntityID,
+                        type: r.Type,
+                        entityKeyField: r.EntityKeyField,
+                        relatedEntityJoinField: r.RelatedEntityJoinField,
+                        joinView: r.JoinView,
+                        joinEntityJoinField: r.JoinEntityJoinField,
+                        joinEntityInverseJoinField: r.JoinEntityInverseJoinField,
+                        entity: r.Entity,
+                        entityBaseView: r.EntityBaseView,
+                        relatedEntity: r.RelatedEntity,
+                        relatedEntityBaseView: r.RelatedEntityBaseView,
+                    };
+                })
+            };
+            return ret;
+        });
+    }
+    async HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId) {
+        const convoEntity = await md.GetEntityObject('Conversations', user);
+        let dataContextEntity;
+        if (!ConversationId || ConversationId.length === 0) {
+            convoEntity.NewRecord();
+            if (user) {
+                convoEntity.UserID = user.ID;
+                convoEntity.Name = AskSkipResolver_1._defaultNewChatName;
+                dataContextEntity = await md.GetEntityObject('Data Contexts', user);
+                if (!DataContextId || DataContextId.length === 0) {
+                    dataContextEntity.NewRecord();
+                    dataContextEntity.UserID = user.ID;
+                    dataContextEntity.Name = 'Data Context for Skip Conversation';
+                    if (!await dataContextEntity.Save()) {
+                        LogError(`Creating a new data context failed`, undefined, dataContextEntity.LatestResult);
+                        throw new Error(`Creating a new data context failed`);
+                    }
+                }
+                else {
+                    const dcLoadResult = await dataContextEntity.Load(DataContextId);
+                    if (!dcLoadResult) {
+                        throw new Error(`Loading DataContextEntity for DataContextId ${DataContextId} failed`);
+                    }
+                }
+                convoEntity.DataContextID = dataContextEntity.ID;
+                if (await convoEntity.Save()) {
+                    ConversationId = convoEntity.ID;
+                    if (!DataContextId || dataContextEntity.ID.length === 0) {
+                        dataContextEntity.Name += ` ${ConversationId}`;
+                        const dciSaveResult = await dataContextEntity.Save();
+                        if (!dciSaveResult) {
+                            LogError(`Error saving DataContextEntity for conversation: ${ConversationId}`, undefined, dataContextEntity.LatestResult);
+                        }
+                    }
+                }
+                else {
+                    LogError(`Creating a new conversation failed`, undefined, convoEntity.LatestResult);
+                    throw new Error(`Creating a new conversation failed`);
+                }
+            }
+            else {
+                throw new Error(`User ${userPayload.email} not found in UserCache`);
+            }
+        }
+        else {
+            await convoEntity.Load(ConversationId);
+            dataContextEntity = await md.GetEntityObject('Data Contexts', user);
+            if (DataContextId && DataContextId.length > 0 && DataContextId !== convoEntity.DataContextID) {
+                if (convoEntity.DataContextID === null) {
+                    convoEntity.DataContextID = DataContextId;
+                    const convoEntitySaveResult = await convoEntity.Save();
+                    if (!convoEntitySaveResult) {
+                        LogError(`Error saving conversation entity for conversation: ${ConversationId}`, undefined, convoEntity.LatestResult);
+                    }
+                }
+                else
+                    console.warn(`AskSkipResolver: DataContextId ${DataContextId} was passed in but it was ignored because it was different than the DataContextID in the conversation ${convoEntity.DataContextID}`);
+            }
+            await dataContextEntity.Load(convoEntity.DataContextID);
+        }
+        const convoDetailEntity = await md.GetEntityObject('Conversation Details', user);
+        convoDetailEntity.NewRecord();
+        convoDetailEntity.ConversationID = ConversationId;
+        convoDetailEntity.Message = UserQuestion;
+        convoDetailEntity.Role = 'User';
+        convoDetailEntity.HiddenToUser = false;
+        convoDetailEntity.Set('Sequence', 1);
+        let convoDetailSaveResult = await convoDetailEntity.Save();
+        if (!convoDetailSaveResult) {
+            LogError(`Error saving conversation detail entity for user message: ${UserQuestion}`, undefined, convoDetailEntity.LatestResult);
+        }
+        const dataContext = MJGlobal.Instance.ClassFactory.CreateInstance(DataContext);
+        await dataContext.Load(dataContextEntity.ID, dataSource, false, false, 0, user);
+        return { dataContext, convoEntity, dataContextEntity, convoDetailEntity };
+    }
+    async LoadConversationDetailsIntoSkipMessages(dataSource, ConversationId, maxHistoricalMessages) {
+        try {
+            const md = new Metadata();
+            const e = md.Entities.find((e) => e.Name === 'Conversation Details');
+            const sql = `SELECT 
+                      ${maxHistoricalMessages ? 'TOP ' + maxHistoricalMessages : ''} ID, Message, Role, __mj_CreatedAt 
+                   FROM 
+                      ${e.SchemaName}.${e.BaseView} 
+                   WHERE 
+                      ConversationID = '${ConversationId}' 
+                   ORDER 
+                      BY __mj_CreatedAt DESC`;
+            const result = await dataSource.query(sql);
+            if (!result)
+                throw new Error(`Error running SQL: ${sql}`);
+            else {
+                const returnData = result.sort((a, b) => {
+                    const aDate = new Date(a.__mj_CreatedAt);
+                    const bDate = new Date(b.__mj_CreatedAt);
+                    return aDate.getTime() - bDate.getTime();
+                });
+                return returnData.map((r) => {
+                    const skipRole = this.MapDBRoleToSkipRole(r.Role);
+                    let outputMessage;
+                    if (skipRole === 'system') {
+                        let detail;
+                        try {
+                            detail = JSON.parse(r.Message);
+                        }
+                        catch (e) {
+                            detail = null;
+                            outputMessage = r.Message;
+                        }
+                        if (detail?.responsePhase === SkipResponsePhase.AnalysisComplete) {
+                            const analysisDetail = detail;
+                            outputMessage = JSON.stringify({
+                                responsePhase: SkipResponsePhase.AnalysisComplete,
+                                techExplanation: analysisDetail.techExplanation,
+                                userExplanation: analysisDetail.userExplanation,
+                                scriptText: analysisDetail.scriptText,
+                                tableDataColumns: analysisDetail.tableDataColumns
+                            });
+                        }
+                        else if (detail?.responsePhase === SkipResponsePhase.ClarifyingQuestion) {
+                            const clarifyingQuestionDetail = detail;
+                            outputMessage = JSON.stringify({
+                                responsePhase: SkipResponsePhase.ClarifyingQuestion,
+                                clarifyingQuestion: clarifyingQuestionDetail.clarifyingQuestion
+                            });
+                        }
+                        else if (detail) {
+                            LogError(`Unknown response phase: ${detail.responsePhase}`);
+                        }
+                    }
+                    const m = {
+                        content: skipRole === 'system' ? outputMessage : r.Message,
+                        role: skipRole,
+                    };
+                    return m;
+                });
+            }
+        }
+        catch (e) {
+            LogError(e);
+            throw e;
+        }
+    }
+    MapDBRoleToSkipRole(role) {
+        switch (role.trim().toLowerCase()) {
+            case 'ai':
+            case 'system':
+            case 'assistant':
+                return 'system';
+            default:
+                return 'user';
+        }
+    }
+    async HandleSkipRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity) {
+        LogStatus(`   >>> HandleSkipRequest: Sending request to Skip API: ${___skipAPIurl}`);
+        const response = await sendPostRequest(___skipAPIurl, input, true, null, (message) => {
+            LogStatus(JSON.stringify(message, null, 4));
+            if (message.type === 'status_update') {
+                pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                    message: JSON.stringify({
+                        type: 'AskSkip',
+                        status: 'OK',
+                        conversationID: ConversationId,
+                        ResponsePhase: message.value.responsePhase,
+                        message: message.value.messages[0].content
+                    }),
+                    sessionId: userPayload.sessionId
+                });
+            }
+        });
+        if (response && response.length > 0) {
+            const apiResponse = response[response.length - 1].value;
+            LogStatus(`  Skip API response: ${apiResponse.responsePhase}`);
+            this.PublishApiResponseUserUpdateMessage(apiResponse, userPayload, ConversationId, pubSub);
+            if (apiResponse.responsePhase === 'data_request') {
+                return await this.HandleDataRequestPhase(input, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity, dataContext, dataContextEntity);
+            }
+            else if (apiResponse.responsePhase === 'clarifying_question') {
+                return await this.HandleClarifyingQuestionPhase(input, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity);
+            }
+            else if (apiResponse.responsePhase === 'analysis_complete') {
+                return await this.HandleAnalysisComplete(input, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity, dataContext, dataContextEntity);
+            }
+            else {
+                throw new Error(`Unknown Skip API response phase: ${apiResponse.responsePhase}`);
+            }
+        }
+        else {
+            pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                message: JSON.stringify({
+                    type: 'AskSkip',
+                    status: 'Error',
+                    conversationID: ConversationId,
+                    message: 'Analysis failed to run, please try again later and if this continues, contact your support desk.',
+                }),
+                sessionId: userPayload.sessionId
+            });
+            return {
+                Success: false,
+                Status: 'Error',
+                Result: `User Question ${UserQuestion} didn't work!`,
+                ResponsePhase: SkipResponsePhase.AnalysisComplete,
+                ConversationId: ConversationId,
+                UserMessageConversationDetailId: "",
+                AIMessageConversationDetailId: "",
+            };
+        }
+    }
+    async PublishApiResponseUserUpdateMessage(apiResponse, userPayload, conversationID, pubSub) {
+        let sUserMessage = '';
+        switch (apiResponse.responsePhase) {
+            case 'data_request':
+                sUserMessage = 'We need to gather some more data, I will do that next and update you soon.';
+                break;
+            case 'analysis_complete':
+                sUserMessage = 'I have completed the analysis, the results will be available momentarily.';
+                break;
+            case 'clarifying_question':
+                break;
+        }
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                type: 'AskSkip',
+                status: 'OK',
+                conversationID,
+                message: sUserMessage,
+            }),
+            sessionId: userPayload.sessionId
+        });
+    }
+    async HandleAnalysisComplete(apiRequest, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity, dataContext, dataContextEntity) {
+        const md = new Metadata();
+        const { AIMessageConversationDetailID } = await this.FinishConversationAndNotifyUser(apiResponse, dataContext, dataContextEntity, md, user, convoEntity, pubSub, userPayload);
+        const response = {
+            Success: true,
+            Status: 'OK',
+            ResponsePhase: SkipResponsePhase.AnalysisComplete,
+            ConversationId: ConversationId,
+            UserMessageConversationDetailId: convoDetailEntity.ID,
+            AIMessageConversationDetailId: AIMessageConversationDetailID,
+            Result: JSON.stringify(apiResponse)
+        };
+        return response;
+    }
+    async HandleClarifyingQuestionPhase(apiRequest, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity) {
+        const md = new Metadata();
+        const convoDetailEntityAI = await md.GetEntityObject('Conversation Details', user);
+        convoDetailEntityAI.NewRecord();
+        convoDetailEntityAI.ConversationID = ConversationId;
+        convoDetailEntityAI.Message = JSON.stringify(apiResponse);
+        convoDetailEntityAI.Role = 'AI';
+        convoDetailEntityAI.HiddenToUser = false;
+        if (await convoDetailEntityAI.Save()) {
+            return {
+                Success: true,
+                Status: 'OK',
+                ResponsePhase: SkipResponsePhase.ClarifyingQuestion,
+                ConversationId: ConversationId,
+                UserMessageConversationDetailId: convoDetailEntity.ID,
+                AIMessageConversationDetailId: convoDetailEntityAI.ID,
+                Result: JSON.stringify(apiResponse)
+            };
+        }
+        else {
+            LogError(`Error saving conversation detail entity for AI message: ${apiResponse.clarifyingQuestion}`, undefined, convoDetailEntityAI.LatestResult);
+            return {
+                Success: false,
+                Status: 'Error',
+                ResponsePhase: SkipResponsePhase.ClarifyingQuestion,
+                ConversationId: ConversationId,
+                UserMessageConversationDetailId: convoDetailEntity.ID,
+                AIMessageConversationDetailId: convoDetailEntityAI.ID,
+                Result: JSON.stringify(apiResponse)
+            };
+        }
+    }
+    async HandleDataRequestPhase(apiRequest, apiResponse, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, convoEntity, convoDetailEntity, dataContext, dataContextEntity) {
+        try {
+            if (!apiResponse.success) {
+                LogError(`Data request/gathering from Skip API failed: ${apiResponse.error}`);
+                return {
+                    Success: false,
+                    Status: `The Skip API Server data gathering phase returned a non-recoverable error. Try again later and Skip might be able to handle this request.\n${apiResponse.error}`,
+                    ResponsePhase: SkipResponsePhase.DataRequest,
+                    ConversationId: ConversationId,
+                    UserMessageConversationDetailId: convoDetailEntity.ID,
+                    AIMessageConversationDetailId: "",
+                    Result: JSON.stringify(apiResponse)
+                };
+            }
+            const _maxDataGatheringRetries = 5;
+            const _dataGatheringFailureHeaderMessage = '***DATA GATHERING FAILURE***';
+            const md = new Metadata();
+            const executionErrors = [];
+            let dataRequest = apiResponse.dataRequest;
+            apiRequest.messages.push({
+                content: `Skip API Requested Data as shown below
+                  ${JSON.stringify(apiResponse.dataRequest)}`,
+                role: 'system'
+            });
+            if (!Array.isArray(dataRequest)) {
+                if (dataRequest) {
+                    dataRequest = [dataRequest];
+                }
+                else {
+                    const errorMessage = `Data request from Skip API is not an array and not a single item.`;
+                    LogError(errorMessage);
+                    executionErrors.push({ dataRequest: apiResponse.dataRequest, errorMessage: errorMessage });
+                    dataRequest = [];
+                }
+            }
+            for (const dr of dataRequest) {
+                try {
+                    const item = dataContext.AddDataContextItem();
+                    switch (dr.type) {
+                        case "sql":
+                            item.Type = 'sql';
+                            item.SQL = dr.text;
+                            item.AdditionalDescription = dr.description;
+                            if (!await item.LoadData(dataSource, false, false, 0, user))
+                                throw new Error(`SQL data request failed: ${item.DataLoadingError}`);
+                            break;
+                        case "stored_query":
+                            const queryName = dr.text;
+                            const query = md.Queries.find((q) => q.Name === queryName);
+                            if (query) {
+                                item.Type = 'query';
+                                item.QueryID = query.ID;
+                                item.RecordName = query.Name;
+                                item.AdditionalDescription = dr.description;
+                                if (!await item.LoadData(dataSource, false, false, 0, user))
+                                    throw new Error(`SQL data request failed: ${item.DataLoadingError}`);
+                            }
+                            else
+                                throw new Error(`Query ${queryName} not found.`);
+                            break;
+                        default:
+                            throw new Error(`Unknown data request type: ${dr.type}`);
+                            break;
+                    }
+                }
+                catch (e) {
+                    LogError(e);
+                    executionErrors.push({ dataRequest: dr, errorMessage: e && e.message ? e.message : e.toString() });
+                }
+            }
+            if (executionErrors.length > 0) {
+                const dataGatheringFailedAttemptCount = apiRequest.messages.filter((m) => m.content.includes(_dataGatheringFailureHeaderMessage)).length + 1;
+                if (dataGatheringFailedAttemptCount > _maxDataGatheringRetries) {
+                    LogStatus(`Execution errors for Skip data request occured, and we have exceeded the max retries${_maxDataGatheringRetries}, sending errors back to the user.`);
+                    return {
+                        Success: false,
+                        Status: 'Error gathering data and we have exceedded the max retries. Try again later and Skip might be able to handle this request.',
+                        ResponsePhase: SkipResponsePhase.DataRequest,
+                        ConversationId: ConversationId,
+                        UserMessageConversationDetailId: convoDetailEntity.ID,
+                        AIMessageConversationDetailId: "",
+                        Result: JSON.stringify(apiResponse)
+                    };
+                }
+                else {
+                    LogStatus(`Execution errors for Skip data request occured, sending those errors back to the Skip API to get new instructions.`);
+                    apiRequest.requestPhase = 'data_gathering_failure';
+                    apiRequest.messages.push({
+                        content: `${_dataGatheringFailureHeaderMessage} #${dataGatheringFailedAttemptCount} of ${_maxDataGatheringRetries} attempts to gather data failed. Errors:
+                      ${JSON.stringify(executionErrors)}
+                    `,
+                        role: 'user'
+                    });
+                }
+            }
+            else {
+                await dataContext.SaveItems(user, false);
+                apiRequest.dataContext = CopyScalarsAndArrays(dataContext);
+                apiRequest.requestPhase = 'data_gathering_response';
+            }
+            return this.HandleSkipRequest(apiRequest, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity);
+        }
+        catch (e) {
+            LogError(e);
+            throw e;
+        }
+    }
+    async FinishConversationAndNotifyUser(apiResponse, dataContext, dataContextEntity, md, user, convoEntity, pubSub, userPayload) {
+        const sTitle = apiResponse.reportTitle;
+        const sResult = JSON.stringify(apiResponse);
+        const convoDetailEntityAI = await md.GetEntityObject('Conversation Details', user);
+        convoDetailEntityAI.NewRecord();
+        convoDetailEntityAI.ConversationID = convoEntity.ID;
+        convoDetailEntityAI.Message = sResult;
+        convoDetailEntityAI.Role = 'AI';
+        convoDetailEntityAI.HiddenToUser = false;
+        convoDetailEntityAI.Set('Sequence', 2);
+        const convoDetailSaveResult = await convoDetailEntityAI.Save();
+        if (!convoDetailSaveResult) {
+            LogError(`Error saving conversation detail entity for AI message: ${sResult}`, undefined, convoDetailEntityAI.LatestResult);
+        }
+        if (convoEntity.Name === AskSkipResolver_1._defaultNewChatName && sTitle && sTitle !== AskSkipResolver_1._defaultNewChatName) {
+            convoEntity.Name = sTitle;
+            const convoEntitySaveResult = await convoEntity.Save();
+            if (!convoEntitySaveResult) {
+                LogError(`Error saving conversation entity for AI message: ${sResult}`, undefined, convoEntity.LatestResult);
+            }
+        }
+        const userNotification = await md.GetEntityObject('User Notifications', user);
+        userNotification.NewRecord();
+        userNotification.UserID = user.ID;
+        userNotification.Title = 'Report Created: ' + sTitle;
+        userNotification.Message = `Good news! Skip finished creating a report for you, click on this notification to jump back into the conversation.`;
+        userNotification.Unread = true;
+        userNotification.ResourceConfiguration = JSON.stringify({
+            type: 'askskip',
+            conversationId: convoEntity.ID,
+        });
+        const userNotificationSaveResult = await userNotification.Save();
+        if (!userNotificationSaveResult) {
+            LogError(`Error saving user notification entity for AI message: ${sResult}`, undefined, userNotification.LatestResult);
+        }
+        dataContext.SaveItems(user, false);
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+            message: JSON.stringify({
+                type: 'UserNotifications',
+                status: 'OK',
+                conversationID: convoEntity.ID,
+                details: {
+                    action: 'create',
+                    recordId: userNotification.ID,
+                }
+            }),
+            sessionId: userPayload.sessionId,
+        });
+        return {
+            AIMessageConversationDetailID: convoDetailEntityAI.ID
+        };
+    }
+    async getViewData(ViewId, user) {
+        const rv = new RunView();
+        const result = await rv.RunView({ ViewID: ViewId, IgnoreMaxRows: true }, user);
+        if (result && result.Success)
+            return result.Results;
+        else
+            throw new Error(`Error running view ${ViewId}`);
+    }
+};
+__decorate([
+    Query(() => AskSkipResultType),
+    __param(0, Arg('UserQuestion', () => String)),
+    __param(1, Arg('ConversationId', () => String)),
+    __param(2, Arg('EntityName', () => String)),
+    __param(3, Arg('CompositeKey', () => CompositeKeyInputType)),
+    __param(4, Ctx()),
+    __param(5, PubSub()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, CompositeKeyInputType, Object, PubSubEngine]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ExecuteAskSkipRecordChat", null);
+__decorate([
+    Query(() => AskSkipResultType),
+    __param(0, Ctx()),
+    __param(1, PubSub()),
+    __param(2, Arg('DataContextId', () => String)),
+    __param(3, Arg('ScriptText', () => String)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, PubSubEngine, String, String]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ExecuteAskSkipRunScript", null);
+__decorate([
+    Query(() => AskSkipResultType),
+    __param(0, Arg('UserQuestion', () => String)),
+    __param(1, Arg('ConversationId', () => String)),
+    __param(2, Ctx()),
+    __param(3, PubSub()),
+    __param(4, Arg('DataContextId', () => String, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, PubSubEngine, String]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ExecuteAskSkipAnalysisQuery", null);
+AskSkipResolver = AskSkipResolver_1 = __decorate([
+    Resolver(AskSkipResultType)
+], AskSkipResolver);
+export { AskSkipResolver };
+export default AskSkipResolver;
+//# sourceMappingURL=AskSkipResolver.js.map