@memberjunction/server 2.20.2 → 2.21.0

package/src/resolvers/GetDataResolver.ts

@@ -0,0 +1,245 @@
+import { Arg, Ctx, Field, InputType, ObjectType, Query } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { v4 as uuidv4 } from 'uuid';
+ 
+@InputType() 
+export class GetDataInputType {
+    @Field(() => String)
+    Token: string;
+
+    @Field(() => [String])
+    Queries: string[];
+}
+  
+  
+@ObjectType()
+export class GetDataOutputType {
+    @Field(() => Boolean)
+    Success: boolean;
+
+    @Field(() => String)
+    ErrorMessage: string;
+
+    @Field(() => String)
+    SQL: string;
+
+    /**
+     * Each query's results will be converted to JSON and returned as a string
+     */
+    @Field(() => [String])
+    Results: string[];
+}
+ 
+@ObjectType()
+export class SimpleEntityResultType {
+    @Field(() => Boolean)
+    Success: boolean;
+
+    @Field(() => String)
+    ErrorMessage: string;
+
+    @Field(() => [SimpleEntityOutputType])
+    Results: SimpleEntityOutputType[];
+}
+
+@ObjectType()
+export class SimpleEntityOutputType {
+    @Field(() => String)
+    ID: string;
+
+    @Field(() => String)
+    Name: string;
+
+    @Field(() => String)
+    Description: string;
+
+    @Field(() => String)
+    SchemaName: string;
+
+    @Field(() => String)
+    BaseView: string;
+
+    @Field(() => String)
+    BaseTable: string;
+
+    @Field(() => String)
+    CodeName: string;
+
+    @Field(() => String)
+    ClassName: string;
+
+    @Field(() => [SimpleEntityFieldOutputType])
+    Fields: SimpleEntityFieldOutputType[];
+}
+
+@ObjectType()
+export class SimpleEntityFieldOutputType {
+    @Field(() => String)
+    ID: string;
+
+    @Field(() => String)
+    Name: string;
+
+    @Field(() => String)
+    Description: string;
+
+    @Field(() => String)
+    Type: string;
+
+    @Field(() => Boolean)
+    AllowsNull: boolean;
+
+    @Field(() => Number)
+    MaxLength: number;
+}
+
+
+export class GetDataResolver {
+    /**
+     * This mutation will sync the specified items with the existing system. Items will be processed in order and the results of each operation will be returned in the Results array within the return value.
+     * @param items - an array of ActionItemInputType objects that specify the action to be taken on the specified entity with the specified primary key and the JSON representation of the field values. 
+     * @param token - the short-lived access token that is required to perform this operation.
+     */
+    @RequireSystemUser()
+    @Query(() => GetDataOutputType)
+    async GetData(
+    @Arg('input', () => GetDataInputType) input: GetDataInputType,
+    @Ctx() context: AppContext
+    ) {
+        try { 
+            LogStatus(`GetDataResolver.GetData() ---- IMPORTANT - temporarily using the same connection as rest of the server, we need to separately create a READ ONLY CONNECTION and pass that in 
+                       the AppContext so we can use that special connection here to ensure we are using a lower privileged connection for this operation to prevent mutation from being possible.`);
+            LogStatus(`${JSON.stringify(input)}`);
+
+            // validate the token
+            if (!isTokenValid(input.Token)) {
+                throw new Error(`Token ${input.Token} is not valid or has expired`);
+            }
+
+            // iterate through the items 
+            let success: boolean = true;
+            const promises = input.Queries.map((q) => {
+                return context.dataSource.query(q);
+            });
+            const results = await Promise.all(promises); // run all the queries in parallel
+
+            // record the use of the token
+            recordTokenUse(input.Token, {request: input, results: results});
+
+            return { Success: success, Results: results.map((r) => JSON.stringify(r)) };
+        } 
+        catch (err) {
+            LogError(err);
+            return { Success: false, ErrorMessage: typeof err === 'string' ? err : (err as any).message, Results: [] };
+        }
+    }
+
+    @RequireSystemUser()
+    @Query(() => SimpleEntityResultType)
+    async GetAllEntities(
+    @Ctx() context: AppContext
+    ) {
+        try { 
+            const md = new Metadata();
+            const result = md.Entities.map((e) => {
+                return { 
+                    ID: e.ID, 
+                    Name: e.Name,
+                    Description: e.Description, 
+                    SchemaName: e.SchemaName,
+                    BaseView: e.BaseView,
+                    BaseTable: e.BaseTable,
+                    CodeName: e.CodeName,
+                    ClassName: e.ClassName,
+                    Fields: e.Fields.map((f) => {
+                        return { 
+                            ID: f.ID, 
+                            Name: f.Name, 
+                            Description: f.Description, 
+                            Type: f.Type,
+                            AllowsNull: f.AllowsNull,
+                            MaxLength: f.MaxLength,
+                        };
+                    })
+                }
+            });
+            return { Success: true, Results: result };
+        } 
+        catch (err) {
+            LogError(err);
+            return { Success: false, ErrorMessage: typeof err === 'string' ? err : (err as any).message, Results: [] };
+        }
+    }
+
+
+}
+ 
+
+export class TokenUseLog {
+    Token: string;
+    UsedAt: Date;
+    UsePayload: any;
+}
+/**
+ * Used to track all active access tokens that are requested by anyone within the server to be able to send to external services that can
+ * in turn call back to the GetDataResolver to get data from the server. This is an extra security layer to ensure that tokens are short 
+ * lived compared to the system level API key which rotates but less frequently.
+ */
+export class GetDataAccessToken {
+    Token: string;
+    ExpiresAt: Date;
+    RequstedAt: Date;
+    /**
+     * Can be used to store any payload to identify who requested the creation of the token, for example Skip might use this to put in a conversation ID to know which conversation a request is coming back for.
+     */
+    RequestorPayload: any;
+    TokenUses: TokenUseLog[];
+}
+const __accessTokens: GetDataAccessToken[] = [];
+const __defaultTokenLifeSpan = 1000 * 60 * 5; // 5 minutes  
+export function registerAccessToken(token?: string, lifeSpan: number = __defaultTokenLifeSpan, requestorPayload?: any): GetDataAccessToken {
+    const tokenToUse = token || uuidv4();
+
+    if (tokenExists(tokenToUse)) {
+        // should never happen if we used the uuidv4() function but could happen if someone tries to use a custom token
+        throw new Error(`Token ${tokenToUse} already exists`);
+    }
+
+    const newToken = new GetDataAccessToken();
+    newToken.Token = tokenToUse;
+    newToken.ExpiresAt = new Date(new Date().getTime() + lifeSpan);
+    newToken.RequstedAt = new Date();
+    newToken.RequestorPayload = requestorPayload;
+    __accessTokens.push(newToken);
+    return newToken;
+}
+export function deleteAccessToken(token: string) {
+    const index = __accessTokens.findIndex((t) => t.Token === token);
+    if (index >= 0) {
+        __accessTokens.splice(index, 1);
+    }
+    else {
+        throw new Error(`Token ${token} does not exist`);
+    }
+}
+export function tokenExists(token: string) {
+    return __accessTokens.find((t) => t.Token === token) !== undefined;
+}
+export function isTokenValid(token: string) {
+    const t = __accessTokens.find((t) => t.Token === token);
+    if (t) {
+        return t.ExpiresAt > new Date();
+    }
+    return false;
+} 
+export function recordTokenUse(token: string, usePayload: any) {
+    const t = __accessTokens.find((t) => t.Token === token);
+    if (t) {
+        t.TokenUses.push({ Token: token, UsedAt: new Date(), UsePayload: usePayload });
+    }
+    else {
+        throw new Error(`Token ${token} does not exist`);
+    }
+}

package/src/resolvers/SyncDataResolver.ts

@@ -0,0 +1,337 @@
+import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { BaseEntity, CompositeKey, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { RequireSystemUser } from '../directives/RequireSystemUser.js';
+import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+
+
+
+/**
+ * This type defines the possible list of actions that can be taken in syncing data: Create, Update, CreateOrUpdate, Delete, or DeleteWithFilter
+ * DeleteWithFilter is where you specify a valid SQL expression that can be used in a where clause to get a list of records in a given entity to delete
+ * this can be used to ensure cleaning out data from a subset of a given table.
+ */
+export enum SyncDataActionType {
+    Create = "Create",
+    Update = "Update",
+    CreateOrUpdate = "CreateOrUpdate",
+    Delete = "Delete",
+    DeleteWithFilter = "DeleteWithFilter"
+  }
+  
+  registerEnumType(SyncDataActionType, {
+    name: "SyncDataActionType", // GraphQL Enum Name
+    description: "Specifies the type of action to be taken in syncing, Create, Update, CreateOrUpdate, Delete" // Description,
+  });
+  
+
+  @InputType() 
+  export class ActionItemInputType {
+      @Field(() => String)
+      EntityName!: string;
+  
+      @Field(() => CompositeKeyInputType, {nullable: true})
+      PrimaryKey?: CompositeKeyInputType;
+  
+      @Field(() => CompositeKeyInputType, {nullable: true})
+      AlternateKey?: CompositeKeyInputType;
+  
+      @Field(() => SyncDataActionType) 
+      Type!: SyncDataActionType;
+  
+      /**
+       * This field is a JSON representation of the field values of the entity to be created or updated. It is used for all ActionTypes except for 
+       */
+      @Field(() => String, {nullable: true})
+      RecordJSON?: string;
+  
+      /**
+       * This field is only provided when the Action Type is DeleteWithFilter. It is a valid SQL expression that can be used in a where clause to get a list of records in a given entity to delete
+       */
+      @Field(() => String, {nullable: true})
+      DeleteFilter?: string;
+  }
+  
+  
+@ObjectType()
+export class ActionItemOutputType {
+    @Field(() => Boolean)
+    Success: boolean;
+
+    @Field(() => String)
+    ErrorMessage: string;
+
+    @Field(() => String)
+    EntityName!: string;
+
+    @Field(() => CompositeKeyOutputType, {nullable: true})
+    PrimaryKey?: CompositeKeyOutputType;
+
+    @Field(() => CompositeKeyOutputType, {nullable: true})
+    AlternateKey?: CompositeKeyOutputType;
+
+    @Field(() => SyncDataActionType) 
+    Type!: SyncDataActionType;
+
+    /**
+     * This field is a JSON representation of the field values of the entity to be created or updated. It is used for all ActionTypes except for 
+     */
+    @Field(() => String, {nullable: true})
+    RecordJSON?: string;
+
+    /**
+     * This field is only provided when the Action Type is DeleteWithFilter. It is a valid SQL expression that can be used in a where clause to get a list of records in a given entity to delete
+     */
+    @Field(() => String, {nullable: true})
+    DeleteFilter?: string;
+}
+
+@ObjectType()
+export class SyncDataResultType {
+  @Field(() => Boolean)
+  Success: boolean;
+
+  @Field(() => [ActionItemOutputType])
+  Results: ActionItemOutputType[] = [];
+}
+
+export class SyncDataResolver {
+    /**
+     * This mutation will sync the specified items with the existing system. Items will be processed in order and the results of each operation will be returned in the Results array within the return value.
+     * @param items - an array of ActionItemInputType objects that specify the action to be taken on the specified entity with the specified primary key and the JSON representation of the field values. 
+     */
+    @RequireSystemUser()
+    @Mutation(() => SyncDataResultType)
+    async SyncData(
+    @Arg('items', () => [ActionItemInputType] ) items: ActionItemInputType[],
+    @Ctx() context: AppContext
+    ) {
+        try { 
+            // iterate through the items 
+            const md = new Metadata();
+            const results: ActionItemOutputType[] = [];
+            for (const item of items) {
+                results.push(await this.SyncSingleItem(item, context, md)); 
+            }
+
+            const overallSuccess = !results.some((r) => !r.Success); // if any element in the array of results has a Success value of false, then the overall success is false
+            return { Success: overallSuccess, Results: results };
+        } 
+        catch (err) {
+            LogError(err);
+            throw new Error('SyncDataResolver::SyncData --- Error Syncing Data\n\n' + err);
+        }
+    }
+
+    protected async SyncSingleItem(item: ActionItemInputType, context: AppContext, md: Metadata): Promise<ActionItemOutputType> {
+        const result = new ActionItemOutputType();
+        result.AlternateKey = item.AlternateKey;
+        result.PrimaryKey = item.PrimaryKey;
+        result.DeleteFilter = item.DeleteFilter;
+        result.EntityName = item.EntityName;
+        result.RecordJSON = item.RecordJSON;
+        result.Type = item.Type;
+        result.Success = false;
+        result.ErrorMessage = '';
+        try {
+            const e = md.Entities.find((e) => e.Name === item.EntityName);
+            if (e) {
+                const pk = item.PrimaryKey ? new CompositeKey(item.PrimaryKey.KeyValuePairs) : null;
+                const ak = item.AlternateKey ? new CompositeKey(item.AlternateKey.KeyValuePairs) : null;
+                const entityObject = item.Type === SyncDataActionType.DeleteWithFilter ? null : await md.GetEntityObject(e.Name, context.userPayload.userRecord);
+                const fieldValues = item.RecordJSON ? JSON.parse(item.RecordJSON) : {};
+                switch (item.Type) {
+                    case SyncDataActionType.Create:
+                        await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+                        break;
+                    case SyncDataActionType.Update:
+                        await this.SyncSingleItemUpdate(entityObject, pk, ak, fieldValues, result);
+                        break;
+                    case SyncDataActionType.CreateOrUpdate:
+                        // in this case we attempt to load the item first, if it is not possible to load the item, then we create it
+                        await this.SyncSingleItemCreateOrUpdate(entityObject, pk, ak, fieldValues, result);
+                        break;
+                    case SyncDataActionType.Delete:
+                        await this.SyncSingleItemDelete(entityObject, pk, ak, result);
+                        break;
+                    case SyncDataActionType.DeleteWithFilter:
+                        await this.SyncSingleItemDeleteWithFilter(item.EntityName, item.DeleteFilter, result, context.userPayload.userRecord);
+                        break;
+                    default:
+                        throw new Error('Invalid SyncDataActionType');
+                }
+            } else {
+                throw new Error('Entity not found');
+            }
+        } 
+        catch (err) {
+            result.ErrorMessage = typeof err === 'string' ? err : (err as any).message;
+            LogError(err);
+        }
+        finally {
+            return result;
+        }
+    }
+
+
+    protected async SyncSingleItemDeleteWithFilter(entityName: string, filter: string, result: ActionItemOutputType, user: UserInfo) {
+        try {
+            // here we will iterate through the result of a RunView on the entityname/filter and delete each matching record
+            let overallSuccess: boolean = true;
+            let combinedErrorMessage: string = "";
+            const rv = new RunView();
+            const data = await rv.RunView<BaseEntity>({
+                EntityName: entityName,
+                ExtraFilter: filter,
+                ResultType: 'entity_object'
+            }, user);
+            if (data && data.Success) {
+                for (const entityObject of data.Results) {
+                    if (!await entityObject.Delete()) {
+                        overallSuccess = false;
+                        combinedErrorMessage += 'Failed to delete the item :' + entityObject.LatestResult.Message + '\n';
+                    }
+                }
+                result.Success = overallSuccess
+                if (!overallSuccess) {
+                    result.ErrorMessage = combinedErrorMessage
+                }
+            }
+            else {
+                result.Success = false;
+                result.ErrorMessage = 'Failed to run the view to get the list of items to delete for entity: ' + entityName + ' with filter: ' + filter + '\n';
+            }
+        }
+        catch (e) {
+            result.ErrorMessage = typeof e === 'string' ? e : (e as any).message;
+        }
+    }
+
+    protected async LoadFromAlternateKey(entityName: string, alternateKey: CompositeKey, user: UserInfo): Promise<BaseEntity> {
+        try {
+            // no primary key provided, attempt to look up the primary key based on the 
+            const rv = new RunView();
+            const md = new Metadata();
+            const entity = md.EntityByName(entityName);
+            const r = await rv.RunView<BaseEntity>({
+                EntityName: entityName,
+                ExtraFilter: alternateKey.KeyValuePairs.map((kvp) => {
+                    const fieldInfo = entity.Fields.find((f) => f.Name === kvp.FieldName);
+                    const quotes = fieldInfo.NeedsQuotes ? "'" : '';
+                    return `${kvp.FieldName} = ${quotes}${kvp.Value}${quotes}`;
+                }).join(' AND '),
+                ResultType: 'entity_object'
+            }, user);
+            if (r && r.Success && r.Results.length === 1) {
+                return r.Results[0];
+            }
+            else {
+                //LogError (`Failed to load the item with alternate key: ${alternateKey.KeyValuePairs.map((kvp) => `${kvp.FieldName} = ${kvp.Value}`).join(' AND ')}. Result: ${r.Success} and ${r.Results?.length} items returned`);
+                return null;
+            }
+        }
+        catch (e) {
+            LogError(e);
+            return null;
+        }
+    }
+
+    protected async SyncSingleItemCreateOrUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType) {
+        if (!pk || pk.KeyValuePairs.length === 0) {
+            // no primary key try to load from alt key
+            const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
+            if (!altKeyResult) {
+                // no record found, create a new one
+                await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+            }
+            else {
+                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result);
+            }
+        }
+        else {
+            // have a primary key do the usual load
+            if (await entityObject.InnerLoad(pk)) {
+                await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result);
+            }
+            else {
+                await this.SyncSingleItemCreate(entityObject, fieldValues, result);
+            }    
+        }
+    }
+
+    protected async SyncSingleItemDelete(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, result: ActionItemOutputType) {
+        if (!pk || pk.KeyValuePairs.length === 0) {
+            const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
+            if (!altKeyResult) {
+                result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified primary key does not exist';
+            }
+            else {
+                if (await altKeyResult.Delete()) {
+                    result.Success = true;
+                }
+                else {
+                    result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.Message;
+                }
+            }
+        }
+        else if (await entityObject.InnerLoad(pk)) {
+            if (await entityObject.Delete()) {
+                result.Success = true;
+            }
+            else {
+                result.ErrorMessage = 'Failed to delete the item :' + entityObject.LatestResult.Message;
+            }
+        }
+        else {
+            result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified primary key does not exist';
+        }
+    }
+
+    protected async SyncSingleItemCreate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType) {
+        // make sure we strip out the primary key from fieldValues before we pass it in because otherwise it will appear to be an existing record to the BaseEntity
+        const noPKValues = {...fieldValues};
+        entityObject.EntityInfo.PrimaryKeys.forEach((pk) => {
+            delete noPKValues[pk.Name];
+        });
+        entityObject.SetMany(noPKValues);
+        if (await entityObject.Save()) {
+            result.Success = true;
+            result.PrimaryKey = new CompositeKey(entityObject.PrimaryKeys.map((pk) => ({FieldName: pk.Name, Value: pk.Value})));
+        }
+        else {
+            result.ErrorMessage = 'Failed to create the item :' + entityObject.LatestResult.Message;
+        }
+    }
+
+    protected async SyncSingleItemUpdate(entityObject: BaseEntity, pk: CompositeKey, ak: CompositeKey, fieldValues: any, result: ActionItemOutputType) {
+        if (!pk || pk.KeyValuePairs.length === 0) {
+            // no pk, attempt to load by alt key
+            const altKeyResult = await this.LoadFromAlternateKey(entityObject.EntityInfo.Name, ak, entityObject.ContextCurrentUser);
+            if (!altKeyResult) {
+                // no record found, create a new one
+                result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified alternate key does not exist';
+            }
+            else {
+                await this.InnerSyncSingleItemUpdate(altKeyResult, fieldValues, result);
+            }
+        }
+        else if (await entityObject.InnerLoad(pk)) {
+            await this.InnerSyncSingleItemUpdate(entityObject, fieldValues, result);
+        }
+        else {
+            // failed to load the item
+            result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified primary key does not exist';
+        }
+    }
+
+    protected async InnerSyncSingleItemUpdate(entityObject: BaseEntity, fieldValues: any, result: ActionItemOutputType) {
+        entityObject.SetMany(fieldValues);
+        if (await entityObject.Save()) {
+            result.Success = true;
+        }
+        else {
+            result.ErrorMessage = 'Failed to update the item :' + entityObject.LatestResult.Message;
+        }
+    }
+}
+ 

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -1,6 +1,6 @@
-import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, Query, Resolver, registerEnumType } from 'type-graphql';
+import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, Metadata, RunView, TransactionGroupBase, UserInfo } from '@memberjunction/core';
+import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { RoleEntity, UserEntity, UserRoleEntity } from '@memberjunction/core-entities';