@memberjunction/server 1.2.1 → 1.3.0

package/src/resolvers/AskSkipResolver.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, Field, Int, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
-import { LogError, LogStatus, Metadata, PrimaryKeyValue, RunView, UserInfo } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, KeyValuePair, RunView, UserInfo, CompositeKey } from '@memberjunction/core';
 import { AppContext, UserPayload } from '../types';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { DataContext } from '@memberjunction/data-context'
@@ -18,7 +18,8 @@ import { registerEnumType } from "type-graphql";
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
 import { sendPostRequest } from '../util';
 import { GetAIAPIKey } from '@memberjunction/ai';
-import { PrimaryKeyValueInputType } from './MergeRecordsResolver';
+import { KeyValuePairInputType } from './MergeRecordsResolver';
+import { CompositeKeyInputType } from './PotentialDuplicateRecordResolver';
 
 
 enum SkipResponsePhase {
@@ -73,7 +74,7 @@ export class AskSkipResolver {
   async ExecuteAskSkipRecordChat(@Arg('UserQuestion', () => String) UserQuestion: string,
                                  @Arg('ConversationId', () => Int) ConversationId: number,
                                  @Arg('EntityName', () => String) EntityName: string,
-                                 @Arg('PrimaryKeys', () => [PrimaryKeyValueInputType]) PrimaryKeys: PrimaryKeyValueInputType[],
+                                 @Arg('CompositeKey', () => CompositeKeyInputType) CompositeKey: CompositeKeyInputType,
                                  @Ctx() { dataSource, userPayload }: AppContext,
                                  @PubSub() pubSub: PubSubEngine) {
     // In this function we're simply going to call the Skip API and pass along the message from the user
@@ -96,15 +97,15 @@ export class AskSkipResolver {
       dci.DataContextID = dataContext.ID;
       dci.Type = 'single_record';
       dci.EntityID = md.Entities.find((e) => e.Name === EntityName)?.ID;
-      dci.RecordID = PrimaryKeys.map((pk) => pk.Value).join(',');
+      dci.RecordID = CompositeKey.Values();
       await dci.Save();
   
       await dataContext.Load(dataContext.ID, dataSource, false, true, 10, user); // load again because we added a new data context item  
-      await dataContext.SaveItems(); // persist
+      await dataContext.SaveItems(user, true); // persist the data becuase the deep loading above with related data is expensive
 
       // also, in the situation for a new convo, we need to update the Conversation ID to have a LinkedEntity and LinkedRecord
       convoEntity.LinkedEntityID = dci.EntityID;
-      convoEntity.LinkedRecordID = PrimaryKeys.map((pk) => pk.Value).join(',');
+      convoEntity.LinkedRecordID = CompositeKey.Values();
       convoEntity.DataContextID = dataContext.ID;
       await convoEntity.Save();
     } 

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,15 +1,15 @@
-import { Metadata, PrimaryKeyValue } from '@memberjunction/core';
+import { Metadata, CompositeKey } from '@memberjunction/core';
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types';
-import { PrimaryKeyValueInputType, PrimaryKeyValueOutputType } from './MergeRecordsResolver';
+import { CompositeKeyInputType, CompositeKeyOutputType } from './PotentialDuplicateRecordResolver';
 
 @InputType()
 export class EntityRecordNameInput {
   @Field(() => String)
   EntityName: string;
 
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
+  @Field(() => CompositeKeyInputType)
+  CompositeKey: CompositeKey;
 }
 
 @ObjectType()
@@ -20,8 +20,8 @@ export class EntityRecordNameResult {
   @Field(() => String)
   Status: string;
 
-  @Field(() => [PrimaryKeyValueOutputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKey;
 
   @Field(() => String)
   EntityName: string;
@@ -35,11 +35,11 @@ export class EntityRecordNameResolver {
   @Query(() => EntityRecordNameResult)
   async GetEntityRecordName(
     @Arg('EntityName', () => String) EntityName: string,
-    @Arg('PrimaryKeyValues', () => [PrimaryKeyValueInputType]) PrimaryKeyValues: PrimaryKeyValue[],
+    @Arg('CompositeKey', () => CompositeKeyInputType) CompositeKey: CompositeKey,
     @Ctx() {}: AppContext
   ): Promise<EntityRecordNameResult> {
     const md = new Metadata();
-    return await this.InnerGetEntityRecordName(md, EntityName, PrimaryKeyValues);
+    return await this.InnerGetEntityRecordName(md, EntityName, CompositeKey);
   }
 
   @Query(() => [EntityRecordNameResult])
@@ -50,27 +50,27 @@ export class EntityRecordNameResolver {
     const result: EntityRecordNameResult[] = [];
     const md = new Metadata();
     for (const i of info) {
-      result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.PrimaryKeyValues));
+      result.push(await this.InnerGetEntityRecordName(md, i.EntityName, i.CompositeKey));
     }
     return result;
   }
 
-  async InnerGetEntityRecordName(md: Metadata, EntityName: string, primaryKeyValues: PrimaryKeyValue[]): Promise<EntityRecordNameResult> {
+  async InnerGetEntityRecordName(md: Metadata, EntityName: string, CompositeKey: CompositeKey): Promise<EntityRecordNameResult> {
     const e = md.Entities.find((e) => e.Name === EntityName);
     if (e) {
-      const recordName = await md.GetEntityRecordName(e.Name, primaryKeyValues);
+      const recordName = await md.GetEntityRecordName(e.Name, CompositeKey);
       if (recordName) 
-        return { Success: true, Status: 'OK', PrimaryKeyValues: primaryKeyValues, RecordName: recordName, EntityName: EntityName };
+        return { Success: true, Status: 'OK', CompositeKey, RecordName: recordName, EntityName };
       else
         return {
           Success: false,
-          Status: `Name for record, or record ${primaryKeyValues.map(pkv => pkv.FieldName + ':' + pkv.Value).join(',')} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
-          PrimaryKeyValues: primaryKeyValues,
-          EntityName: EntityName,
+          Status: `Name for record, or record ${CompositeKey.ToString()} itself not found, could be an access issue if user doesn't have Row Level Access (RLS) if RLS is enabled for this entity`,
+          CompositeKey,
+          EntityName
         };
     } 
     else 
-      return { Success: false, Status: `Entity ${EntityName} not found`, PrimaryKeyValues: primaryKeyValues, EntityName: EntityName };
+      return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey, EntityName };
   }
 }
 

package/src/resolvers/FileResolver.ts

@@ -15,8 +15,8 @@ import {
   Resolver,
   Root,
 } from '@memberjunction/server';
-import { createDownloadUrl, createUploadUrl, deleteObject } from '@memberjunction/storage';
-import { CreateFileInput, FileResolver as FileResolverBase, File_ } from '../generated/generated';
+import { createDownloadUrl, createUploadUrl, deleteObject, moveObject } from '@memberjunction/storage';
+import { CreateFileInput, FileResolver as FileResolverBase, File_, UpdateFileInput } from '../generated/generated';
 
 @InputType()
 export class CreateUploadURLInput {
@@ -30,6 +30,8 @@ export class CreateFilePayload {
   File: File_;
   @Field(() => String)
   UploadUrl: string;
+  @Field(() => Boolean)
+  NameExists: boolean;
 }
 
 @ObjectType()
@@ -52,6 +54,10 @@ export class FileResolver extends FileResolverBase {
     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
@@ -68,7 +74,7 @@ export class FileResolver extends FileResolverBase {
     await fileEntity.Save();
     const File = fileEntity.GetAll();
 
-    return { File, UploadUrl };
+    return { File, UploadUrl, NameExists };
   }
 
   @FieldResolver(() => String)
@@ -81,11 +87,39 @@ export class FileResolver extends FileResolverBase {
     const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
     await providerEntity.Load(file.ProviderID);
 
-    const url = await createDownloadUrl(providerEntity, file.ProviderKey ?? file.ID);
+    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', () => Int) ID: number, @Ctx() { dataSource, userPayload }: AppContext, @PubSub() pubSub: PubSubEngine) {
     const md = new Metadata();
@@ -102,7 +136,7 @@ export class FileResolver extends FileResolverBase {
     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.ID);
+      await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name);
     }
 
     return super.DeleteFile(ID, { dataSource, userPayload }, pubSub);

package/src/resolvers/MergeRecordsResolver.ts

@@ -1,6 +1,7 @@
-import { LogError, Metadata, PrimaryKeyValue } from '@memberjunction/core';
+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 './PotentialDuplicateRecordResolver';
 
 @ObjectType()
 export class EntityDependencyResult {
@@ -36,7 +37,7 @@ export class EntityDependencyResolver {
 
 
 @InputType()
-export class PrimaryKeyValueInputType {
+export class KeyValuePairInputType {
   @Field(() => String)
   FieldName: string;
 
@@ -45,7 +46,7 @@ export class PrimaryKeyValueInputType {
 }
 
 @ObjectType()
-export class PrimaryKeyValueOutputType {
+export class KeyValuePairOutputType {
   @Field(() => String)
   FieldName: string;
 
@@ -65,8 +66,8 @@ export class RecordDependencyResult {
   @Field(() => String)
   FieldName: string; // required
 
-  @Field(() => String)
-  PrimaryKeyValue: string;
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKey;
 }
 
  
@@ -77,13 +78,13 @@ export class RecordDependencyResolver {
     @Query(() => [RecordDependencyResult])
     async GetRecordDependencies(
       @Arg('entityName', () => String) entityName: string,
-      @Arg('primaryKeyValues', () => [PrimaryKeyValueInputType]) primaryKeyValues: PrimaryKeyValue[],
+      @Arg('CompositeKey', () => CompositeKeyInputType) CompositeKey: CompositeKey,
       @Ctx() { dataSource, userPayload }: AppContext,
       @PubSub() pubSub: PubSubEngine
     ) {
         try {
             const md = new Metadata();
-            const result = await md.GetRecordDependencies(entityName, primaryKeyValues)    
+            const result = await md.GetRecordDependencies(entityName, CompositeKey); 
             return result;
         }
         catch (e) {
@@ -116,11 +117,11 @@ export class RecordMergeRequest {
     @Field(() => String)
     EntityName: string;
 
-    @Field(() => [PrimaryKeyValueInputType])
-    SurvivingRecordPrimaryKeyValues: PrimaryKeyValue[];
+    @Field(() => CompositeKeyInputType)
+    SurvivingRecordCompositeKey: CompositeKey;
 
-    @Field(() => [[PrimaryKeyValueInputType]])
-    RecordsToMerge: PrimaryKeyValue[][];
+    @Field(() => [CompositeKeyInputType])
+    RecordsToMerge: CompositeKey[];
 
     @Field(() => [FieldMapping], { nullable: true })
     FieldMap?: FieldMapping[];
@@ -144,8 +145,8 @@ export class RecordMergeRequestOutput {
 
 @ObjectType()
 export class RecordMergeDetailResult {
-    @Field(() => [PrimaryKeyValueOutputType])
-    PrimaryKeyValues: PrimaryKeyValue[];
+    @Field(() => CompositeKeyOutputType)
+    CompositeKey: CompositeKeyOutputType;
 
     @Field(() => Boolean)
     Success: boolean; 

package/src/resolvers/PotentialDuplicateRecordResolver.ts

@@ -1,26 +1,43 @@
 import { Arg, Ctx, Field, Float, InputType, Int, ObjectType, Query, Resolver } from "type-graphql";
-import { PotentialDuplicateRequest, PotentialDuplicateResponse, PotentialDuplicate, Metadata, PrimaryKeyValue, LogError } from '@memberjunction/core';
-import {PrimaryKeyValueInputType, PrimaryKeyValueOutputType} from './MergeRecordsResolver'
+import { PotentialDuplicateRequest, PotentialDuplicateResponse, PotentialDuplicate, Metadata, KeyValuePair, LogError, CompositeKey, PotentialDuplicateResult } from '@memberjunction/core';
+import {KeyValuePairInputType, KeyValuePairOutputType} from './MergeRecordsResolver'
 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';
+LoadMistralEmbedding();
+LoadPineconeVectorDB();
+
 @InputType()
 export class PotentialDuplicateRequestType extends PotentialDuplicateRequest {
   @Field(() => Int)
-  EntityDocumentID: number;
+  EntityID: number;
 
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValueInputType[];
+  @Field(() => [CompositeKeyInputType])
+  RecordIDs: CompositeKey[];
 
   @Field(() => Int, { nullable: true })
-  EntitiyID: number;
-
-  @Field(() => String, { nullable: true })
-  EntityName: string;
+  EntityDocumentID: number;
 
   @Field(() => Int, { nullable: true })
   ProbabilityScore: number;
+  
+  @Field(() => Int)
+  ListID: number;
+}
+
+@InputType()
+export class CompositeKeyInputType extends CompositeKey {
+  @Field(() => [KeyValuePairInputType])
+  KeyValuePairs: KeyValuePair[];
+}
 
+@ObjectType()
+export class CompositeKeyOutputType extends CompositeKey {
+  @Field(() => [KeyValuePairOutputType])
+  KeyValuePairs: KeyValuePair[];
 }
 
 @ObjectType()
@@ -28,18 +45,36 @@ export class PotentialDuplicateType extends PotentialDuplicate {
   @Field(() => Float)
   ProbabilityScore: number;
 
-  @Field(() => [PrimaryKeyValueOutputType])
-  PrimaryKeyValues: PrimaryKeyValueOutputType[];
+  @Field(() => [KeyValuePairOutputType])
+  KeyValuePairs: KeyValuePairOutputType[];
 }
 
 @ObjectType()
-export class PotentialDuplicateResponseType extends PotentialDuplicateResponse{
-
-  @Field(() => Int)
+export class PotentialDuplicateResultType extends PotentialDuplicateResult {
+  @Field(() => Int, { nullable: true })
   EntityID: number;
 
   @Field(() => [PotentialDuplicateType])
   Duplicates: PotentialDuplicateType[];
+
+  @Field(() => CompositeKeyOutputType)
+  RecordPrimaryKeys: CompositeKey;
+
+  @Field(() => [Int])
+  DuplicateRunDetailMatchRecordIDs: number[];
+}
+
+@ObjectType()
+export class PotentialDuplicateResponseType extends PotentialDuplicateResponse{
+
+  @Field(() => String)
+  Status: 'Inprogress' | 'Success' | 'Error';
+
+  @Field(() => String, { nullable: true })
+  ErrorMessage?: string;
+
+  @Field(() => [PotentialDuplicateResultType])
+  PotentialDuplicateResult: PotentialDuplicateResult[]
 }
 
 @Resolver(PotentialDuplicateResponseType)

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,9 +1,10 @@
-import { Metadata, PrimaryKeyValue } from '@memberjunction/core';
-import { AppContext, Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, PrimaryKeyValueInputType, PrimaryKeyValueOutputType, Query, Resolver } from '@memberjunction/server';
+import { Metadata, KeyValuePair, CompositeKey } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, KeyValuePairInputType, KeyValuePairOutputType, Query, Resolver } from '@memberjunction/server';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { UserFavoriteEntity } from '@memberjunction/core-entities';
 
 import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated';
+import { CompositeKeyInputType, CompositeKeyOutputType } from './PotentialDuplicateRecordResolver';
 
 //****************************************************************************
 // INPUT TYPE for User Favorite Queries
@@ -13,8 +14,8 @@ export class UserFavoriteSearchParams {
   @Field(() => Int)
   EntityID: number;
 
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
+  @Field(() => CompositeKeyInputType)
+  CompositeKey: CompositeKey;
 
   @Field(() => Int)
   UserID: number;
@@ -25,8 +26,8 @@ export class UserFavoriteSetParams {
   @Field(() => Int)
   EntityID: number;
 
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
+  @Field(() => CompositeKeyInputType)
+  CompositeKey: CompositeKey;
 
   @Field(() => Int)
   UserID: number;
@@ -40,8 +41,8 @@ export class UserFavoriteResult {
   @Field(() => Int)
   EntityID: number;
 
-  @Field(() => [PrimaryKeyValueOutputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKey;
 
   @Field(() => Int)
   UserID: number;
@@ -73,8 +74,8 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
       return {
         EntityID: params.EntityID,
         UserID: params.UserID,
-        PrimaryKeyValues: params.PrimaryKeyValues,
-        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValues),
+        CompositeKey: params.CompositeKey,
+        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, params.CompositeKey),
         Success: true,
       };
     else throw new Error(`Entity ID:${params.EntityID} not found`);
@@ -86,12 +87,12 @@ export class UserFavoriteResolver extends UserFavoriteResolverBase {
     const e = md.Entities.find((e) => e.ID === params.EntityID);
     const u = UserCache.Users.find((u) => u.ID === userPayload.userRecord.ID);
     if (e) {
-      md.SetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValues, params.IsFavorite, u);
+      md.SetRecordFavoriteStatus(params.UserID, e.Name, params.CompositeKey, params.IsFavorite, u);
       return {
         Success: true,
         EntityID: params.EntityID,
         UserID: params.UserID,
-        PrimaryKeyValues: params.PrimaryKeyValues,
+        CompositeKey: params.CompositeKey,
         IsFavorite: params.IsFavorite,
       };
     } else throw new Error(`Entity ID:${params.EntityID} not found`);