@memberjunction/server 2.1.2 → 2.1.3

package/src/resolvers/FileResolver.ts

@@ -1,147 +0,0 @@
-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';
-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(updatedInput);
-    await fileEntity.Save();
-    const File = 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

@@ -1,182 +0,0 @@
-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';
-import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes';
-
-@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);
-            throw new Error(err.message);
-        }
-    }
- 
-}
-
-
-@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

@@ -1,91 +0,0 @@
-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';
-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';
-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

@@ -1,42 +0,0 @@
-// 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';
-
-@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

@@ -1,147 +0,0 @@
-import { Metadata, RunReport } from '@memberjunction/core';
-import { Arg, Ctx, Field, Int, Mutation, ObjectType, Query, Resolver } from 'type-graphql';
-import { AppContext } from '../types';
-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';
-
-@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) {
-      return {
-        ReportID: "",
-        ReportName: '',
-        Success: false,
-        ErrorMessage: 'Unable to create new report: ' + ex.message
-      }
-    }
-  }
-}