@memberjunction/server 0.9.90 → 0.9.94

package/src/index.ts

@@ -34,12 +34,40 @@ export * from './directives';
 export * from './entitySubclasses/userViewEntity.server';
 export * from './types';
 
+export * from './generic/PushStatusResolver';
+export * from './generic/ResolverBase';
+export * from './generic/RunViewResolver';
+
+export * from './resolvers/AskSkipResolver';
+export * from './resolvers/ColorResolver';
+export * from './resolvers/DatasetResolver';
+export * from './resolvers/EntityRecordNameResolver';
+//export * from '../../MJAPI/src/resolvers/EntityResolver';
+export * from './resolvers/MergeRecordsResolver';
+export * from './resolvers/ReportResolver';
+
+
+//export * from '../../MJAPI/src/resolvers/UserFavoriteResolver';
+//export * from '../../MJAPI/src/resolvers/UserViewResolver';
+
+import { resolve } from 'node:path';
+
+const localPath = (p: string) => resolve(__dirname, p);
+
 export const serve = async (resolverPaths: Array<string>) => {
+  const localResolverPaths = [
+    'resolvers/**/*Resolver.{js,ts}',
+    'generic/*Resolver.{js,ts}',
+    'generated/generated.{js,ts}'
+  ].map(localPath);
+
+  const combinedResolverPaths = [...resolverPaths, ...localResolverPaths];
+
   const replaceBackslashes = sep === '\\';
-  const paths = resolverPaths.flatMap((path) => globSync(replaceBackslashes ? path.replace(/\\/g, '/') : path));
+  const paths = combinedResolverPaths.flatMap((path) => globSync(replaceBackslashes ? path.replace(/\\/g, '/') : path));
   if (paths.length === 0) {
-    console.warn(`No resolvers found in ${resolverPaths.join(', ')}`);
-    console.log({ resolverPaths, paths, cwd: process.cwd() });
+    console.warn(`No resolvers found in ${combinedResolverPaths.join(', ')}`);
+    console.log({ combinedResolverPaths, paths, cwd: process.cwd() });
   }
 
   const dataSource = new DataSource(orm(paths));

package/src/resolvers/AskSkipResolver.ts

@@ -0,0 +1,237 @@
+import { Arg, Ctx, Field, Int, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { SkipAnalyzeData, SkipExplainQuery } from '@memberjunction/ai';
+import { Metadata } from '@memberjunction/core';
+import { AppContext } from '../types';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import axios from 'axios';
+
+import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver';
+
+@ObjectType()
+export class AskSkipResultType {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String)
+  Status: string; // required
+
+  @Field(() => String)
+  Result: string;
+
+  @Field(() => Int)
+  ConversationId: number;
+
+  @Field(() => Int)
+  UserMessageConversationDetailId: number;
+
+  @Field(() => Int)
+  AIMessageConversationDetailId: number;
+}
+@Resolver(AskSkipResultType)
+export class AskSkipResolver {
+  private static _defaultNewChatName = 'New Chat';
+
+  @Query(() => AskSkipResultType)
+  async ExecuteAskSkipQuery(
+    @Arg('UserQuestion', () => String) UserQuestion: string,
+    @Arg('ConversationId', () => Int) ConversationId: number,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    try {
+      const md = new Metadata();
+      const user = UserCache.Instance.Users.find((u) => u.Email === userPayload.email);
+      if (!user) throw new Error(`User ${userPayload.email} not found in UserCache`);
+
+      const convoEntity = await md.GetEntityObject('Conversations', user);
+      if (!ConversationId || ConversationId <= 0) {
+        // create a new conversation id
+        convoEntity.NewRecord();
+        if (user) {
+          convoEntity.UserID = user.ID;
+          convoEntity.Name = AskSkipResolver._defaultNewChatName;
+          if (await convoEntity.Save()) ConversationId = convoEntity.ID;
+          else throw new Error(`Creating a new conversation failed`);
+        } else throw new Error(`User ${userPayload.email} not found in UserCache`);
+      } else {
+        await convoEntity.Load(ConversationId); // load the existing conversation, will need it later
+      }
+
+      // now, create a conversation detail record for the user message
+      const convoDetailEntity = await md.GetEntityObject('Conversation Details', user);
+      convoDetailEntity.NewRecord();
+      convoDetailEntity.ConversationID = ConversationId;
+      convoDetailEntity.Message = UserQuestion;
+      convoDetailEntity.Role = 'User';
+      convoDetailEntity.Set('Sequence', 1); // using weakly typed here because we're going to get rid of this field soon
+      await convoDetailEntity.Save();
+
+      //const OrganizationId = 2 //HG 8/1/2023 TODO: Pull this from an environment variable
+      const OrganizationId = process.env.BOT_SCHEMA_ORGANIZATION_ID;
+
+      const input = { userInput: UserQuestion, conversationID: ConversationId, organizationID: OrganizationId };
+      //const url = 'https://tasioskipapi.azurewebsites.net/report';
+      const url = process.env.BOT_EXTERNAL_API_URL;
+
+      pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+        message: JSON.stringify({
+          type: 'AskSkip',
+          status: 'OK',
+          message: 'Sure, I can help with that, just give me a second and I will think about the best way to complete your request.',
+        }),
+        sessionId: userPayload.sessionId,
+      });
+
+      const response = await axios({
+        method: 'post',
+        url: process.env.BOT_EXTERNAL_API_URL,
+        data: input,
+      });
+      if (response.status === 200) {
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+          message: JSON.stringify({
+            type: 'AskSkip',
+            status: 'OK',
+            message: 'I created the report structure, now I will get the data for you and analyze the results... Back to ya soon!',
+          }),
+          sessionId: userPayload.sessionId,
+        });
+
+        // it worked, run the SQL and return the results
+        const sql = response.data.params.sql;
+        const [{ result, analysis }, explanation] = await Promise.all([
+          this.getSkipDataAndAnalysis(dataSource, UserQuestion, sql),
+          this.getReportExplanation(UserQuestion, sql),
+        ]);
+
+        const sTitle = response.data.params.reportTitle || response.data.params.chartTitle;
+        const sResult = JSON.stringify({
+          SQLResults: {
+            results: result,
+            sql: sql,
+            columns: response.data.params.columns,
+          },
+          UserMessage: '',
+          ReportExplanation: explanation,
+          Analysis: analysis,
+          ReportTitle: sTitle,
+          DisplayType: response.data.type,
+          DrillDownView: response.data.params.drillDownView,
+          DrillDownBaseViewField: response.data.params.drillDownBaseViewField,
+          DrillDownReportValueField: response.data.params.drillDownReportValueField,
+          ChartOptions: {
+            xAxis: response.data.params.xAxis,
+            xLabel: response.data.params.xLabel,
+            yAxis: response.data.params.yAxis,
+            yLabel: response.data.params.yLabel,
+            color: response.data.params.color,
+            yFormat: response.data.params.yFormat,
+          },
+        });
+
+        // now, create a conversation detail record for the Skip response
+        const convoDetailEntityAI = await md.GetEntityObject('Conversation Details', user);
+        convoDetailEntityAI.NewRecord();
+        convoDetailEntityAI.ConversationID = ConversationId;
+        convoDetailEntityAI.Message = sResult;
+        convoDetailEntityAI.Role = 'AI';
+        convoDetailEntityAI.Set('Sequence', 2); // using weakly typed here because we're going to get rid of this field soon
+        await convoDetailEntityAI.Save();
+
+        // finally update the convo name if it is still the default
+        if (convoEntity.Name === AskSkipResolver._defaultNewChatName) {
+          convoEntity.Name = response.data.params.reportTitle || response.data.params.chartTitle || AskSkipResolver._defaultNewChatName;
+          await convoEntity.Save();
+        }
+
+        // now create a notification for the user
+        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: ConversationId,
+        });
+        await userNotification.Save();
+        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+          message: JSON.stringify({
+            type: 'UserNotifications',
+            status: 'OK',
+            details: {
+              action: 'create',
+              recordId: userNotification.ID,
+            },
+          }),
+          sessionId: userPayload.sessionId,
+        });
+
+        return {
+          Success: true,
+          Status: 'OK',
+          ConversationId: ConversationId,
+          UserMessageConversationDetailId: convoDetailEntity.ID,
+          AIMessageConversationDetailId: convoDetailEntityAI.ID,
+          Result: sResult,
+        };
+      } else return { Success: false, Status: 'Error', Result: `User Question ${UserQuestion} didn't work!` };
+    } catch (error) {
+      console.error(`Error occurred: ${error}`);
+      if (error.response) {
+        // The request was made and the server responded with a status code
+        // that falls out of the range of 2xx
+        console.log(error.response.data);
+        console.log(error.response.status);
+        console.log(error.response.headers);
+      } else if (error.request) {
+        // The request was made but no response was received
+        // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
+        // http.ClientRequest in node.js
+        console.log(error.request);
+      } else {
+        // Something happened in setting up the request that triggered an Error
+        console.log('Error', error.message);
+      }
+      console.log(error.config);
+      return {
+        Success: false,
+        Status: 'Error',
+        Result: `User Question ${UserQuestion} didn't work!`,
+        ConversationId: ConversationId,
+        UserMessageConversationDetailId: 0,
+        AIMessageConversationDetailId: 0,
+      };
+    }
+  }
+
+  protected async getSkipDataAndAnalysis(dataSource: any, userQuestion: string, sql: string): Promise<{ result: any[]; analysis: string }> {
+    const result = await dataSource.query(sql);
+    const stringResult = JSON.stringify(result);
+    // next get average string length of each row in result
+    const maxStringLength = 2000;
+    const avgRowStringLength = stringResult.length / result.length;
+    // next get the subset we actually want to use, either entire result
+    // of if too long, then a subset of the rows from the result
+    let sampleDataJSON = stringResult;
+    if (stringResult.length > maxStringLength) {
+      const rowsToUse = result.length / (maxStringLength / avgRowStringLength);
+      const subsetResult = result.slice(0, rowsToUse);
+      sampleDataJSON = JSON.stringify(subsetResult);
+    }
+    // now get the analysis since we have the sample data
+    const analysis = await this.getAnalysis(userQuestion, sql, sampleDataJSON);
+    return { result, analysis };
+  }
+
+  protected async getAnalysis(userQuestion: string, sql: string, sampleDataJSON: string): Promise<string> {
+    return await SkipAnalyzeData(userQuestion, sql, sampleDataJSON);
+  }
+
+  protected async getReportExplanation(userQuestion: string, sql: string): Promise<string> {
+    return await SkipExplainQuery(userQuestion, sql);
+  }
+}
+
+export default AskSkipResolver;

package/src/resolvers/ColorResolver.ts

@@ -0,0 +1,72 @@
+import {
+  AppContext,
+  Ctx,
+  Field,
+  Int,
+  ObjectType,
+  PubSub,
+  PubSubEngine,
+  Public,
+  Query,
+  Resolver,
+  Root,
+  Subscription,
+} from '@memberjunction/server';
+
+@ObjectType()
+export class Color {
+  @Field(() => Int)
+  @Public()
+  ID: number;
+
+  @Field(() => String)
+  @Public()
+  name: string;
+
+  @Field(() => String)
+  @Public()
+  createdZ: string;
+}
+
+@ObjectType()
+export class ColorNotification {
+  @Public()
+  @Field(() => String, { nullable: true })
+  message?: string;
+
+  @Public()
+  @Field((_type) => Date)
+  date!: Date;
+}
+
+export interface ColorNotificationPayload {
+  message?: string;
+}
+
+@Resolver(Color)
+export class ColorResolver {
+  @Subscription(() => ColorNotification, { topics: 'COLOR' })
+  @Public()
+  colorSubscription(@Root() { message }: ColorNotificationPayload): ColorNotification {
+    return { message, date: new Date() };
+  }
+
+  @Query(() => [Color])
+  @Public()
+  async colors(@Ctx() _ctx: AppContext, @PubSub() pubSub: PubSubEngine) {
+    const createdZ = new Date().toISOString();
+
+    pubSub.publish('COLOR', {
+      message: 'Colors were requested!',
+    });
+
+    return [
+      { ID: 1, name: 'Red', createdZ },
+      { ID: 2, name: 'Orange', createdZ },
+      { ID: 3, name: 'Yellow', createdZ },
+      { ID: 4, name: 'Green', createdZ },
+      { ID: 5, name: 'Blue', createdZ },
+      { ID: 6, name: 'Purple', createdZ },
+    ];
+  }
+}

package/src/resolvers/DatasetResolver.ts

@@ -0,0 +1,114 @@
+import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+import { LogError, Metadata } from '@memberjunction/core';
+
+@ObjectType()
+export class DatasetResultType {
+  @Field(() => Int)
+  DatasetID: number;
+
+  @Field(() => String)
+  DatasetName: string;
+
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String)
+  Status: string;
+
+  @Field(() => Date)
+  LatestUpdateDate: Date;
+
+  @Field(() => String)
+  Results: string;
+}
+
+@InputType()
+export class DatasetItemFilterTypeGQL {
+  @Field(() => String)
+  ItemCode: string;
+
+  @Field(() => String)
+  Filter: string;
+}
+
+@Resolver(DatasetResultType)
+export class DatasetResolver {
+  @Query(() => DatasetResultType)
+  async GetDatasetByName(
+    @Arg('DatasetName', () => String) DatasetName: string,
+    @Ctx() {}: AppContext,
+    @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
+  ) {
+    try {
+      const md = new Metadata();
+      const result = await md.GetDatasetByName(DatasetName, ItemFilters);
+      if (result) {
+        return {
+          DatasetID: result.DatasetID,
+          DatasetName: result.DatasetName,
+          Success: result.Success,
+          Status: result.Status,
+          LatestUpdateDate: result.LatestUpdateDate,
+          Results: JSON.stringify(result.Results),
+        };
+      } else {
+        throw new Error('Error retrieving Dataset: ' + DatasetName);
+      }
+    } catch (err) {
+      LogError(err);
+      throw new Error('Error retrieving Dataset: ' + DatasetName + '\n\n' + err);
+    }
+  }
+}
+
+@ObjectType()
+export class DatasetStatusResultType {
+  @Field(() => Int)
+  DatasetID: number;
+
+  @Field(() => String)
+  DatasetName: string;
+
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String)
+  Status: string;
+
+  @Field(() => Date)
+  LatestUpdateDate: Date;
+
+  @Field(() => String)
+  EntityUpdateDates: string;
+}
+
+@Resolver(DatasetStatusResultType)
+export class DatasetStatusResolver {
+  @Query(() => DatasetStatusResultType)
+  async GetDatasetStatusByName(
+    @Arg('DatasetName', () => String) DatasetName: string,
+    @Ctx() {}: AppContext,
+    @Arg('ItemFilters', () => [DatasetItemFilterTypeGQL], { nullable: 'itemsAndList' }) ItemFilters?: DatasetItemFilterTypeGQL[]
+  ) {
+    try {
+      const md = new Metadata();
+      const result = await md.GetDatasetStatusByName(DatasetName, ItemFilters);
+      if (result) {
+        return {
+          DatasetID: result.DatasetID,
+          DatasetName: result.DatasetName,
+          Success: result.Success,
+          Status: result.Status,
+          LatestUpdateDate: result.LatestUpdateDate,
+          EntityUpdateDates: JSON.stringify(result.EntityUpdateDates),
+        };
+      } else {
+        throw new Error('Error retrieving Dataset Status: ' + DatasetName);
+      }
+    } catch (err) {
+      LogError(err);
+      throw new Error('Error retrieving Dataset Status: ' + DatasetName + '\n\n' + err);
+    }
+  }
+}

package/src/resolvers/EntityRecordNameResolver.ts

@@ -0,0 +1,73 @@
+import { Metadata } from '@memberjunction/core';
+import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types';
+
+@InputType()
+export class EntityRecordNameInput {
+  @Field(() => String)
+  EntityName: string;
+
+  @Field(() => String)
+  RecordID: string;
+}
+
+@ObjectType()
+export class EntityRecordNameResult {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String)
+  Status: string;
+
+  @Field(() => String)
+  RecordID: string;
+
+  @Field(() => String)
+  EntityName: string;
+
+  @Field(() => String, { nullable: true })
+  RecordName?: string;
+}
+
+@Resolver(EntityRecordNameResult)
+export class EntityRecordNameResolver {
+  @Query(() => EntityRecordNameResult)
+  async GetEntityRecordName(
+    @Arg('EntityName', () => String) EntityName: string,
+    @Arg('RecordID', () => String) RecordID: string,
+    @Ctx() {}: AppContext
+  ): Promise<EntityRecordNameResult> {
+    const md = new Metadata();
+    return await this.InnerGetEntityRecordName(md, EntityName, RecordID);
+  }
+
+  @Query(() => [EntityRecordNameResult])
+  async GetEntityRecordNames(
+    @Arg('info', () => [EntityRecordNameInput]) info: EntityRecordNameInput[],
+    @Ctx() {}: AppContext
+  ): Promise<EntityRecordNameResult[]> {
+    const result: EntityRecordNameResult[] = [];
+    const md = new Metadata();
+    for (const i of info) {
+      result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.RecordID));
+    }
+    return result;
+  }
+
+  async InnerGetEntityRecordName(md: Metadata, EntityName: string, RecordID: string): Promise<EntityRecordNameResult> {
+    const e = md.Entities.find((e) => e.Name === EntityName);
+    if (e) {
+      const recordName = await md.GetEntityRecordName(e.Name, RecordID);
+      if (recordName) return { Success: true, Status: 'OK', RecordID: RecordID, RecordName: recordName, EntityName: EntityName };
+      else
+        return {
+          Success: false,
+          Status: `Name for record, or record ${RecordID} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
+          RecordID: RecordID,
+          EntityName: EntityName,
+        };
+    } else return { Success: false, Status: `Entity ${EntityName} not found`, RecordID: RecordID, EntityName: EntityName };
+  }
+}
+
+export default EntityRecordNameResolver;

package/src/resolvers/EntityResolver.ts

@@ -0,0 +1,34 @@
+import { EntityPermissionType } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Query, Resolver } from '@memberjunction/server';
+import { Entity_, EntityResolverBase } from '../generated/generated';
+
+@Resolver(Entity_)
+export class EntityResolver extends EntityResolverBase {
+  @Query(() => [Entity_])
+  EntitiesBySchemas(
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @Arg('IncludeSchemas', () => [String], { nullable: true }) IncludeSchemas?: string[],
+    @Arg('ExcludeSchemas', () => [String], { nullable: true }) ExcludeSchemas?: string[]
+  ) {
+    this.CheckUserReadPermissions('Entities', userPayload);
+    const rlsWhere = this.getRowLevelSecurityWhereClause('Entities', userPayload, EntityPermissionType.Read, ' WHERE');
+    const includeSchemaSQL =
+      IncludeSchemas && IncludeSchemas.length > 0 ? `SchemaName IN (${IncludeSchemas.map((s) => `'${s}'`).join(',')})` : '';
+    const excludeSchemaSQL =
+      ExcludeSchemas && ExcludeSchemas.length > 0 ? `SchemaName NOT IN (${ExcludeSchemas.map((s) => `'${s}'`).join(',')})` : '';
+    let schemaSQL = '';
+    if (includeSchemaSQL) schemaSQL = includeSchemaSQL;
+    if (excludeSchemaSQL) {
+      if (schemaSQL) schemaSQL = `${schemaSQL} AND ${excludeSchemaSQL}`;
+      else schemaSQL = excludeSchemaSQL;
+    }
+    let totalWhere = '';
+    if (schemaSQL) totalWhere = ` WHERE ${schemaSQL}`;
+    if (rlsWhere) {
+      if (totalWhere) totalWhere = `${totalWhere} AND ${rlsWhere}`;
+      else totalWhere = ` WHERE ${rlsWhere}`;
+    }
+    const sSQL = `SELECT * FROM [${this.MJCoreSchema}].vwEntities${totalWhere}`;
+    return dataSource.query(sSQL);
+  }
+}