@memberjunction/server 2.1.4 → 2.2.0

package/src/resolvers/FileResolver.ts

@@ -0,0 +1,152 @@
+import { EntityPermissionType, Metadata } from '@memberjunction/core';
+import { FileEntity, FileStorageProviderEntity } from '@memberjunction/core-entities';
+import {
+  AppContext,
+  Arg,
+  Ctx,
+  DeleteOptionsInput,
+  Field,
+  FieldResolver,
+  InputType,
+  Int,
+  Mutation,
+  ObjectType,
+  PubSub,
+  PubSubEngine,
+  Resolver,
+  Root,
+} from '@memberjunction/server';
+import { createDownloadUrl, createUploadUrl, deleteObject, moveObject } from '@memberjunction/storage';
+import { CreateFileInput, FileResolver as FileResolverBase, File_, UpdateFileInput } from '../generated/generated.js';
+import { FieldMapper } from '@memberjunction/graphql-dataprovider';
+
+@InputType()
+export class CreateUploadURLInput {
+  @Field(() => String)
+  FileID: string;
+}
+
+@ObjectType()
+export class CreateFilePayload {
+  @Field(() => File_)
+  File: File_;
+  @Field(() => String)
+  UploadUrl: string;
+  @Field(() => Boolean)
+  NameExists: boolean;
+}
+
+@ObjectType()
+export class FileExt extends File_ {
+  @Field(() => String)
+  DownloadUrl: string;
+}
+
+@Resolver(File_)
+export class FileResolver extends FileResolverBase {
+  @Mutation(() => CreateFilePayload)
+  async CreateFile(
+    @Arg('input', () => CreateFileInput) input: CreateFileInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    const md = new Metadata();
+    const user = this.GetUserFromPayload(userPayload);
+    const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
+    const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
+    fileEntity.CheckPermissions(EntityPermissionType.Create, true);
+
+    // Check to see if there's already an object with that name
+    const [sameName] = await this.findBy(dataSource, 'Files', { Name: input.Name, ProviderID: input.ProviderID });
+    const NameExists = Boolean(sameName);
+
+    const fileRecord = (await super.CreateFile({ ...input, Status: 'Pending' }, { dataSource, userPayload }, pubSub)) as File_;
+
+    // If there's a problem creating the file record, the base resolver will return null
+    if (!fileRecord) {
+      return null;
+    }
+
+    // Create the upload URL and get the record updates (provider key, content type, etc)
+    const { updatedInput, UploadUrl } = await createUploadUrl(providerEntity, fileRecord);
+
+    // Save the file record with the updated input
+    const mapper = new FieldMapper();
+    fileEntity.LoadFromData(mapper.ReverseMapFields({ ...input }));
+    fileEntity.SetMany(mapper.ReverseMapFields({ ...updatedInput }));
+    await fileEntity.Save();
+    const File = mapper.MapFields({ ...fileEntity.GetAll() });
+
+    return { File, UploadUrl, NameExists };
+  }
+
+  @FieldResolver(() => String)
+  async DownloadUrl(@Root() file: File_, @Ctx() { userPayload }: AppContext) {
+    const md = new Metadata();
+    const user = this.GetUserFromPayload(userPayload);
+    const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
+    fileEntity.CheckPermissions(EntityPermissionType.Read, true);
+
+    const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
+    await providerEntity.Load(file.ProviderID);
+
+    const url = await createDownloadUrl(providerEntity, file.ProviderKey ?? file.Name);
+
+    return url;
+  }
+
+  @Mutation(() => File_)
+  async UpdateFile(
+    @Arg('input', () => UpdateFileInput) input: UpdateFileInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    // if the name is changing, rename the target object as well
+    const md = new Metadata();
+    const user = this.GetUserFromPayload(userPayload);
+    const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
+    fileEntity.CheckPermissions(EntityPermissionType.Update, true);
+
+    await fileEntity.Load(input.ID);
+
+    if (fileEntity.Name !== input.Name) {
+      const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
+      await providerEntity.Load(fileEntity.ProviderID);
+
+      const success = await moveObject(providerEntity, fileEntity.Name, input.Name);
+      if (!success) {
+        throw new Error('Error updating object name');
+      }
+    }
+
+    const updatedFile = await super.UpdateFile(input, { dataSource, userPayload }, pubSub);
+    return updatedFile;
+  }
+
+  @Mutation(() => File_)
+  async DeleteFile(
+    @Arg('ID', () => String) ID: string,
+    @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    const md = new Metadata();
+    const userInfo = this.GetUserFromPayload(userPayload);
+
+    const fileEntity = await md.GetEntityObject<FileEntity>('Files', userInfo);
+    await fileEntity.Load(ID);
+    if (!fileEntity) {
+      return null;
+    }
+    fileEntity.CheckPermissions(EntityPermissionType.Delete, true);
+
+    // Only delete the object from the provider if it's actually been uploaded
+    if (fileEntity.Status === 'Uploaded') {
+      const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', userInfo);
+      await providerEntity.Load(fileEntity.ProviderID);
+      await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name);
+    }
+
+    return super.DeleteFile(ID, options, { dataSource, userPayload }, pubSub);
+  }
+}

package/src/resolvers/MergeRecordsResolver.ts

@@ -0,0 +1,175 @@
+import { LogError, Metadata, CompositeKey } from '@memberjunction/core';
+import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+import { z } from 'zod';
+
+@ObjectType()
+export class EntityDependencyResult {
+  @Field(() => String)
+  EntityName: string; // required
+
+  @Field(() => String)
+  RelatedEntityName: string; // required
+
+  @Field(() => String)
+  FieldName: string; // required
+}
+
+@Resolver(EntityDependencyResult)
+export class EntityDependencyResolver {
+  @Query(() => [EntityDependencyResult])
+  async GetEntityDependencies(
+    @Arg('entityName', () => String) entityName: string,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    try {
+      const md = new Metadata();
+      return md.GetEntityDependencies(entityName);
+    } catch (err) {
+      LogError(err);
+      const ctx = z.object({ message: z.string() }).catch(null).parse(err)?.message ?? JSON.stringify(err);
+      
+      throw new Error(ctx);
+    }
+  }
+}
+
+@ObjectType()
+export class RecordDependencyResult {
+  @Field(() => String)
+  EntityName: string; // required
+
+  @Field(() => String)
+  RelatedEntityName: string; // required
+
+  @Field(() => String)
+  FieldName: string; // required
+
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKey;
+}
+
+@Resolver(RecordDependencyResult)
+export class RecordDependencyResolver {
+  @Query(() => [RecordDependencyResult])
+  async GetRecordDependencies(
+    @Arg('entityName', () => String) entityName: string,
+    @Arg('CompositeKey', () => CompositeKeyInputType) ckInput: CompositeKeyInputType,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    try {
+      const md = new Metadata();
+      const ck = new CompositeKey(ckInput.KeyValuePairs);
+      const result = await md.GetRecordDependencies(entityName, ck);
+      return result;
+    } catch (e) {
+      LogError(e);
+      throw e;
+    }
+  }
+}
+
+@InputType()
+class FieldMapping {
+  @Field(() => String)
+  FieldName: string;
+
+  @Field(() => String)
+  Value: string;
+}
+
+@ObjectType()
+class FieldMappingOutput {
+  @Field(() => String)
+  FieldName: string;
+
+  @Field(() => String)
+  Value: string;
+}
+
+@InputType()
+export class RecordMergeRequest {
+  @Field(() => String)
+  EntityName: string;
+
+  @Field(() => CompositeKeyInputType)
+  SurvivingRecordCompositeKey: CompositeKey;
+
+  @Field(() => [CompositeKeyInputType])
+  RecordsToMerge: CompositeKey[];
+
+  @Field(() => [FieldMapping], { nullable: true })
+  FieldMap?: FieldMapping[];
+}
+
+@ObjectType()
+export class RecordMergeRequestOutput {
+  @Field(() => String)
+  EntityName: string;
+
+  @Field(() => Int)
+  SurvivingRecordID: number;
+
+  @Field(() => [Int])
+  RecordsToMerge: number[];
+
+  @Field(() => [FieldMappingOutput], { nullable: true })
+  FieldMap?: FieldMappingOutput[];
+}
+
+@ObjectType()
+export class RecordMergeDetailResult {
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKeyOutputType;
+
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => Int, { nullable: true })
+  RecordMergeDeletionLogID?: number;
+
+  @Field(() => String, { nullable: true })
+  Message?: string;
+}
+
+@ObjectType()
+export class RecordMergeResult {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => String, { nullable: true })
+  OverallStatus: string;
+
+  @Field(() => Int, { nullable: true })
+  RecordMergeLogID: number;
+
+  @Field(() => [RecordMergeDetailResult])
+  RecordStatus: RecordMergeDetailResult[];
+
+  @Field(() => RecordMergeRequestOutput)
+  Request: RecordMergeRequestOutput;
+}
+
+@Resolver(RecordMergeResult)
+export class RecordMergeResolver {
+  @Mutation(() => RecordMergeResult)
+  async MergeRecords(
+    @Arg('request', () => RecordMergeRequest) request: RecordMergeRequest,
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @PubSub() pubSub: PubSubEngine
+  ) {
+    try {
+      const md = new Metadata();
+      const result = await md.MergeRecords(request, userPayload.userRecord);
+      return result;
+    } catch (e) {
+      LogError(e);
+      throw e;
+    }
+  }
+}
+
+export default EntityDependencyResolver;

package/src/resolvers/PotentialDuplicateRecordResolver.ts

@@ -0,0 +1,91 @@
+import { Arg, Ctx, Field, Float, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import {
+  PotentialDuplicateRequest,
+  PotentialDuplicateResponse,
+  PotentialDuplicate,
+  Metadata,
+  CompositeKey,
+  PotentialDuplicateResult,
+} from '@memberjunction/core';
+import { AppContext } from '../types.js';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+
+//load the default vectorDB and embedding model
+import { LoadMistralEmbedding } from '@memberjunction/ai-mistral';
+import { LoadPineconeVectorDB } from '@memberjunction/ai-vectors-pinecone';
+import { CompositeKeyInputType, CompositeKeyOutputType, KeyValuePairOutputType } from '../generic/KeyInputOutputTypes.js';
+LoadMistralEmbedding();
+LoadPineconeVectorDB();
+
+@InputType()
+export class PotentialDuplicateRequestType extends PotentialDuplicateRequest {
+  @Field(() => String)
+  declare EntityID: string;
+
+  @Field(() => [CompositeKeyInputType])
+  declare RecordIDs: CompositeKey[];
+
+  @Field(() => String, { nullable: true })
+  declare EntityDocumentID: string;
+
+  @Field(() => Int, { nullable: true })
+  declare ProbabilityScore: number;
+
+  @Field(() => String)
+  declare ListID: string;
+}
+
+@ObjectType()
+export class PotentialDuplicateType extends PotentialDuplicate {
+  @Field(() => Float)
+  declare ProbabilityScore: number;
+
+  @Field(() => [KeyValuePairOutputType])
+  declare KeyValuePairs: KeyValuePairOutputType[];
+}
+
+@ObjectType()
+export class PotentialDuplicateResultType extends PotentialDuplicateResult {
+  @Field(() => String, { nullable: true })
+  declare EntityID: string;
+
+  @Field(() => [PotentialDuplicateType])
+  declare Duplicates: PotentialDuplicateType[];
+
+  @Field(() => CompositeKeyOutputType)
+  RecordPrimaryKeys: CompositeKey;
+
+  @Field(() => [String])
+  declare DuplicateRunDetailMatchRecordIDs: string[];
+}
+
+@ObjectType()
+export class PotentialDuplicateResponseType extends PotentialDuplicateResponse {
+  @Field(() => String)
+  declare Status: 'Inprogress' | 'Success' | 'Error';
+
+  @Field(() => String, { nullable: true })
+  declare ErrorMessage?: string;
+
+  @Field(() => [PotentialDuplicateResultType])
+  declare PotentialDuplicateResult: PotentialDuplicateResult[];
+}
+
+@Resolver(PotentialDuplicateResponseType)
+export class DuplicateRecordResolver {
+  @Query(() => PotentialDuplicateResponseType)
+  async GetRecordDuplicates(
+    @Ctx() { dataSource, userPayload }: AppContext,
+    @Arg('params') params: PotentialDuplicateRequestType
+  ): Promise<PotentialDuplicateResponseType> {
+    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 result = await md.GetRecordDuplicates(params, user);
+    return result;
+  }
+}

package/src/resolvers/QueryResolver.ts

@@ -0,0 +1,42 @@
+// Queries are MemberJunction primitive operations that are used to retrieve data from the server from any stored query
+import { RunQuery } from '@memberjunction/core';
+import { Arg, Ctx, Field, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+
+@ObjectType()
+export class RunQueryResultType {
+  @Field()
+  QueryID: string;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  Results: string;
+
+  @Field()
+  RowCount: number;
+
+  @Field()
+  ExecutionTime: number;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@Resolver(RunQueryResultType)
+export class ReportResolver {
+  @Query(() => RunQueryResultType)
+  async GetQueryData(@Arg('QueryID', () => String) QueryID: string, @Ctx() {}: AppContext): Promise<RunQueryResultType> {
+    const runQuery = new RunQuery();
+    const result = await runQuery.RunQuery({ QueryID: QueryID });
+    return {
+      QueryID: QueryID,
+      Success: result.Success,
+      Results: JSON.stringify(result.Results),
+      RowCount: result.RowCount,
+      ExecutionTime: result.ExecutionTime,
+      ErrorMessage: result.ErrorMessage,
+    };
+  }
+}

package/src/resolvers/ReportResolver.ts

@@ -0,0 +1,144 @@
+import { Metadata, RunReport } from '@memberjunction/core';
+import { Arg, Ctx, Field, Int, Mutation, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { ConversationDetailEntity, ReportEntity } from '@memberjunction/core-entities';
+import { SkipAPIAnalysisCompleteResponse } from '@memberjunction/skip-types';
+import { DataContext } from '@memberjunction/data-context';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { z } from 'zod';
+
+@ObjectType()
+export class RunReportResultType {
+  @Field()
+  ReportID: string;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  Results: string;
+
+  @Field()
+  RowCount: number;
+
+  @Field()
+  ExecutionTime: number;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@ObjectType()
+export class CreateReportResultType {
+  @Field()
+  ReportID: string;
+
+  @Field()
+  ReportName: string;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@Resolver(RunReportResultType)
+export class ReportResolverExtended {
+  @Query(() => RunReportResultType)
+  async GetReportData(@Arg('ReportID', () => String) ReportID: string, @Ctx() {}: AppContext): Promise<RunReportResultType> {
+    const runReport = new RunReport();
+    const result = await runReport.RunReport({ ReportID: ReportID });
+    return {
+      ReportID: ReportID,
+      Success: result.Success,
+      Results: JSON.stringify(result.Results),
+      RowCount: result.RowCount,
+      ExecutionTime: result.ExecutionTime,
+      ErrorMessage: result.ErrorMessage,
+    };
+  }
+
+  /**
+   * This mutation will create a new report from a conversation detail ID
+   */
+  @Mutation(() => CreateReportResultType)
+  async CreateReportFromConversationDetailID(
+    @Arg('ConversationDetailID', () => String) ConversationDetailID: string,
+    @Ctx() { dataSource, userPayload }: AppContext
+  ): Promise<CreateReportResultType> {
+    try {
+      const md = new Metadata();
+
+      const u = UserCache.Users.find((u) => u.Email?.trim().toLowerCase() === userPayload?.email?.trim().toLowerCase());
+      if (!u) throw new Error('Unable to find user');
+
+      const cde = md.Entities.find((e) => e.Name === 'Conversation Details');
+      if (!cde) throw new Error('Unable to find Conversation Details Entity metadata');
+
+      const cd = md.Entities.find((e) => e.Name === 'Conversations');
+      if (!cd) throw new Error('Unable to find Conversations Entity metadata');
+
+      const sql = `SELECT
+                      cd.Message, cd.ConversationID, c.DataContextID
+                   FROM
+                      ${cde.SchemaName}.${cde.BaseView} cd
+                   INNER JOIN
+                      ${cd.SchemaName}.${cd.BaseView} c
+                   ON
+                      cd.ConversationID = c.ID
+                   WHERE
+                      cd.ID=${ConversationDetailID}`;
+
+      const result = await dataSource.query(sql);
+      if (!result || result.length === 0) throw new Error('Unable to retrieve converation details');
+      const skipData = <SkipAPIAnalysisCompleteResponse>JSON.parse(result[0].Message);
+
+      const report = await md.GetEntityObject<ReportEntity>('Reports', u);
+      report.NewRecord();
+      report.Name = skipData.reportTitle ? skipData.reportTitle : 'Untitled Report';
+      report.Description = skipData.userExplanation ? skipData.userExplanation : '';
+      report.ConversationID = result[0].ConversationID;
+      report.ConversationDetailID = ConversationDetailID;
+
+      const dc: DataContext = new DataContext();
+      await dc.LoadMetadata(result[0].DataContextID, u);
+      const newDataContext = await DataContext.Clone(dc, false, u);
+      if (!newDataContext) throw new Error('Error cloning data context');
+      report.DataContextID = newDataContext.ID;
+
+      // next, strip out the messags from the SkipData object to put them into our Report Configuration as we dont need to store that information as we have a
+      // link back to the conversation and conversation detail
+      const newSkipData: SkipAPIAnalysisCompleteResponse = JSON.parse(JSON.stringify(skipData));
+      newSkipData.messages = [];
+      report.Configuration = JSON.stringify(newSkipData);
+
+      report.SharingScope = 'None';
+      report.UserID = u.ID;
+
+      if (await report.Save()) {
+        return {
+          ReportID: report.ID,
+          ReportName: report.Name,
+          Success: true,
+          ErrorMessage: '',
+        };
+      } else {
+        return {
+          ReportID: '',
+          ReportName: '',
+          Success: false,
+          ErrorMessage: 'Unable to save new report',
+        };
+      }
+    } catch (ex) {
+      const err = z.object({ message: z.string() }).safeParse(ex);
+      return {
+        ReportID: '',
+        ReportName: '',
+        Success: false,
+        ErrorMessage: 'Unable to create new report: ' + err.success ? err.data.message : String(ex),
+      };
+    }
+  }
+}