@memberjunction/server 2.1.1 → 2.1.3

package/src/resolvers/ColorResolver.ts

@@ -1,61 +0,0 @@
-import { AppContext } from '../types';
-import { Ctx, Field, Int, ObjectType, PubSub, PubSubEngine, Query, Resolver, Root, Subscription } from 'type-graphql';
-import { Public } from '../directives';
-
-@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

@@ -1,115 +0,0 @@
-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(() => String)
-  DatasetID: string;
-
-  @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 DatasetResolverExtended {
-  @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(() => String)
-  DatasetID: string;
-
-  @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/EntityCommunicationsResolver.ts

@@ -1,216 +0,0 @@
-import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
-import { AppContext } from '../types';
-import { RunViewByIDInput } from '../generic/RunViewResolver';
-import { Message } from '@memberjunction/communication-types';
-import { EntityCommunicationsEngine } from '@memberjunction/entity-communications-server';
-import { RunViewParams } from '@memberjunction/core';
-import { GraphQLJSONObject } from 'graphql-type-json';
-import { TemplateEngineServer } from '@memberjunction/templates';
-import { EntityCommunicationParams } from '@memberjunction/entity-communications-base';
-
-
-@InputType()
-export class CommunicationProviderMessageType {
-    @Field()
-    ID: number;
-
-    @Field()
-    CommunicationProviderID: number;
-
-    @Field()
-    CommunicationBaseMessageTypeID: number;
-
-    @Field()
-    Name: string;
-
-    @Field()
-    Status: string;
-
-    @Field()
-    AdditionalAttributes: string;
-
-    @Field()
-    _mj_CreatedAt: Date;
-
-    @Field()
-    _mj_UpdatedAt: Date;
-
-    @Field()
-    CommunicationProvider?: string;
-
-    @Field()
-    CommunicationBaseMessageType?: string;
-}
-
-@InputType()
-export class TemplateInputType {
-    @Field()
-    ID: number;
-
-    @Field()
-    Name: string;
-
-    @Field()
-    Description: string;
-
-    @Field({ nullable: true})
-    UserPrompt?: string;
-
-    @Field({ nullable: true})
-    CategoryID?: number;
-
-    @Field()
-    UserID: number;
-
-    @Field({ nullable: true})
-    ActiveAt?: Date;
-
-    @Field({ nullable: true})
-    DisabledAt?: Date;
- 
-    @Field()
-    IsActive: boolean;
-
-    @Field()
-    _mj_CreatedAt: Date;
-
-    @Field()
-    _mj_UpdatedAt: Date;
-
-    @Field({ nullable: true})
-    Category?: string;
-
-    @Field({ nullable: true})
-    User?: string;
-}
-@InputType()
-export class CommunicationMessageInput {
-    /**
-     * The type of message to send 
-     */
-    @Field(() => CommunicationProviderMessageType)
-    public MessageType: CommunicationProviderMessageType;
-
-    /**
-     * The sender of the message, typically an email address but can be anything that is provider-specific for example for a provider that is a social
-     * media provider, it might be a user's social media handle
-     */
-    @Field()
-    public From: string;
-
-    /**
-     * The recipient of the message, typically an email address but can be anything that is provider-specific for example for a provider that is a social 
-     * media provider, it might be a user's social media handle
-     */
-    @Field()
-    public To: string;
-
-    /**
-     * The body of the message, used if BodyTemplate is not provided.
-     */
-    @Field({ nullable: true })
-    public Body?: string;
-    /**
-     * Optional, when provided, Body is ignored and the template is used to render the message. In addition, 
-     * if BodyTemplate is provided it will be used to render the Body and if the template has HTML content it will 
-     * also be used to render the HTMLBody
-     */
-    @Field(() => TemplateInputType, { nullable: true })
-    public BodyTemplate?: TemplateInputType;
-
-    /**
-     * The HTML body of the message 
-     */
-    @Field({ nullable: true })
-    public HTMLBody?: string;
-    /**
-     * Optional, when provided, HTMLBody is ignored and the template is used to render the message. This OVERRIDES
-     * the BodyTemplate's HTML content even if BodyTemplate is provided. This allows for flexibility in that you can
-     * specify a completely different HTMLBodyTemplate and not just relay on the TemplateContent of the BodyTemplate having 
-     * an HTML option.
-     */
-    @Field(() => TemplateInputType, { nullable: true })
-    public HTMLBodyTemplate?: TemplateInputType;
-
-    /**
-     * The subject line for the message, used if SubjectTemplate is not provided and only supported by some providers
-     */
-    @Field({ nullable: true })
-    public Subject?: string;
-    /**
-     * Optional, when provided, Subject is ignored and the template is used to render the message
-     */
-    @Field(() => TemplateInputType, { nullable: true })
-    public SubjectTemplate?: TemplateInputType;
-
-    /**
-     * Optional, any context data that is needed to render the message template
-     */
-    @Field(() => GraphQLJSONObject, { nullable: true })
-    public ContextData?: any;
-}
-
-@ObjectType()
-export class RunEntityCommunicationResultType {
-    @Field()
-    Success: boolean;
-
-    @Field({nullable: true})
-    ErrorMessage?: string;
-
-    /**
-     * Optional, any context data that is needed to render the message template
-     */
-    @Field(() => GraphQLJSONObject, { nullable: true })
-    public Results?: any;
-}
- 
-@Resolver(RunEntityCommunicationResultType)
-export class ReportResolver { 
-  @Query(() => RunEntityCommunicationResultType)
-  async RunEntityCommunicationByViewID( @Arg('entityID', () => String) entityID: string, 
-                                               @Arg('runViewByIDInput', () => RunViewByIDInput) runViewByIDInput: RunViewByIDInput, 
-                                               @Arg('providerName', () => String) providerName: string, 
-                                               @Arg('providerMessageTypeName', () => String) providerMessageTypeName: string, 
-                                               @Arg('message', () => CommunicationMessageInput) message: CommunicationMessageInput, 
-                                               @Arg('previewOnly', () => Boolean) previewOnly: boolean, 
-                                               @Arg('includeProcessedMessages', () => Boolean) includeProcessedMessages: boolean, 
-                                               @Ctx() { userPayload }: AppContext): Promise<RunEntityCommunicationResultType> {
-    try {
-        await EntityCommunicationsEngine.Instance.Config(false, userPayload.userRecord);
-        const newMessage = new Message(message as unknown as Message);
-        await TemplateEngineServer.Instance.Config(false, userPayload.userRecord);
-        // for the templates, replace the values from the input with the objects from the Template Engine we have here
-        if (newMessage.BodyTemplate) {
-            newMessage.BodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.BodyTemplate.Name);
-        }
-        if (newMessage.HTMLBodyTemplate) {
-            newMessage.HTMLBodyTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.HTMLBodyTemplate.Name);
-        }
-        if (newMessage.SubjectTemplate) {
-            newMessage.SubjectTemplate = TemplateEngineServer.Instance.FindTemplate(newMessage.SubjectTemplate.Name);
-        }
-        const params: EntityCommunicationParams = {
-            EntityID: entityID,
-            RunViewParams: <RunViewParams>runViewByIDInput, 
-            ProviderName: providerName, 
-            ProviderMessageTypeName: providerMessageTypeName, 
-            Message: newMessage, 
-            PreviewOnly: previewOnly, 
-            IncludeProcessedMessages: includeProcessedMessages
-        }
-        const result = await EntityCommunicationsEngine.Instance.RunEntityCommunication(params);  
-        return {
-            Success: result.Success,
-            ErrorMessage: result.ErrorMessage,
-            Results: includeProcessedMessages && result.Results ? {Results: result.Results} : undefined
-        };
-    }   
-    catch (e) {
-        return {
-            Success: false,
-            ErrorMessage: e.message
-        }
-    }                   
-  }  
-}

package/src/resolvers/EntityRecordNameResolver.ts

@@ -1,78 +0,0 @@
-import { Metadata, CompositeKey } from '@memberjunction/core';
-import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
-import { AppContext } from '../types';
-import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes';
-
-@InputType()
-export class EntityRecordNameInput {
-  @Field(() => String)
-  EntityName: string;
-
-  @Field(() => CompositeKeyInputType)
-  CompositeKey: CompositeKey;
-}
-
-@ObjectType()
-export class EntityRecordNameResult {
-  @Field(() => Boolean)
-  Success: boolean;
-
-  @Field(() => String)
-  Status: string;
-
-  @Field(() => CompositeKeyOutputType)
-  CompositeKey: CompositeKey;
-
-  @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('CompositeKey', () => CompositeKeyInputType) primaryKey: CompositeKey,
-    @Ctx() {userPayload}: AppContext
-  ): Promise<EntityRecordNameResult> {
-    const md = new Metadata();
-    return await this.InnerGetEntityRecordName(md, EntityName, primaryKey);
-  }
-
-  @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.CompositeKey));
-    }
-    return result;
-  }
-
-  async InnerGetEntityRecordName(md: Metadata, EntityName: string, primaryKey: CompositeKeyInputType): Promise<EntityRecordNameResult> {
-    const pk = new CompositeKey(primaryKey.KeyValuePairs);
-    const e = md.Entities.find((e) => e.Name === EntityName);
-    if (e) {
-      const recordName = await md.GetEntityRecordName(e.Name, pk);
-      if (recordName) 
-        return { Success: true, Status: 'OK', CompositeKey: pk, RecordName: recordName, EntityName };
-      else
-        return {
-          Success: false,
-          Status: `Name for record, or record ${pk.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: pk,
-          EntityName
-        };
-    } 
-    else 
-      return { Success: false, Status: `Entity ${EntityName} not found`, CompositeKey: pk, EntityName };
-  }
-}
-
-export default EntityRecordNameResolver;

package/src/resolvers/EntityResolver.ts

@@ -1,37 +0,0 @@
-import { EntityPermissionType } from '@memberjunction/core';
-import { AppContext } from '../types';
-import { Arg, Ctx, Query, Resolver, InputType, Field } from 'type-graphql';
-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);
-  }
-}

package/src/resolvers/FileCategoryResolver.ts

@@ -1,62 +0,0 @@
-import { CompositeKey, EntityPermissionType, Metadata, RunView } from '@memberjunction/core';
-import { FileCategoryEntity, FileEntity } from '@memberjunction/core-entities';
-import { AppContext, Arg, Ctx, DeleteOptionsInput, Int, Mutation } from '@memberjunction/server';
-import { mj_core_schema } from '../config';
-import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated';
-
-export class FileResolver extends FileCategoryResolverBase {
-  @Mutation(() => FileCategory_)
-  async DeleteFileCategory(@Arg('ID', () => String) ID: string, @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput, @Ctx() { dataSource, userPayload }: AppContext) {
-    const key = new CompositeKey();
-    key.LoadFromSingleKeyValuePair('ID', ID);
-    if (!(await this.BeforeDelete(dataSource, key))) {
-      return null;
-    }
-
-    const md = new Metadata();
-    const user = this.GetUserFromPayload(userPayload);
-    const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
-    const fileCategoryEntity = await md.GetEntityObject<FileCategoryEntity>('File Categories', user);
-
-    fileEntity.CheckPermissions(EntityPermissionType.Update, true);
-    fileCategoryEntity.CheckPermissions(EntityPermissionType.Delete, true);
-
-    await fileCategoryEntity.Load(ID);
-    const returnValue = fileCategoryEntity.GetAll();
-
-    // Any files using the deleted category fall back to its parent
-    await dataSource.transaction(async () => {
-      // SHOULD USE BaseEntity for each of these records to ensure object model
-      // is used everywhere - new code below. The below is SLOWER than a single
-      // Update statement, but it ensures that the object model is used everywhere
-      // in case there are sub-classes and business logic/etc for the updates
-      // the direct SQL would bypass that logic.
-
-      // const sSQL = `UPDATE [${mj_core_schema}].[File] 
-      //                 SET [CategoryID]=${fileCategoryEntity.ParentID}
-      //                 WHERE [CategoryID]=${fileCategoryEntity.ID}`;
-
-      // await dataSource.query(sSQL);
-      const rv = new RunView();
-      const filesResult = await rv.RunView({
-        EntityName: 'Files',
-        ExtraFilter: `CategoryID='${fileCategoryEntity.ID}'`,
-        ResultType: 'entity_object'
-      }, user);
-      if (filesResult) {
-        // iterate through each of the files in filesResult.Results
-        // and update the CategoryID to fileCategoryEntity.ParentID
-        for (const file of filesResult.Results) {
-          const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
-          await fileEntity.Load(file.ID);
-          fileEntity.CategoryID = fileCategoryEntity.ParentID;
-          await fileEntity.Save();
-        }
-      }
-      await fileCategoryEntity.Delete();
-    });
-
-    await this.AfterDelete(dataSource, key); // fire event
-    return returnValue;
-  }
-}