@memberjunction/server 2.1.5 → 2.2.1

package/src/resolvers/ColorResolver.ts

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

@@ -0,0 +1,115 @@
+import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+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

@@ -0,0 +1,221 @@
+import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { RunViewByIDInput } from '../generic/RunViewResolver.js';
+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';
+import { z } from 'zod';
+
+@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) {
+      const { message } = z
+        .object({ message: z.string() })
+        .catch({ message: JSON.stringify(e) })
+        .parse(e);
+      return {
+        Success: false,
+        ErrorMessage: message,
+      };
+    }
+  }
+}

package/src/resolvers/EntityRecordNameResolver.ts

@@ -0,0 +1,75 @@
+import { Metadata, CompositeKey } from '@memberjunction/core';
+import { Arg, Ctx, Field, InputType, ObjectType, Query, Resolver } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+
+@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

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

@@ -0,0 +1,69 @@
+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.js';
+import { FileCategoryResolver as FileCategoryResolverBase, FileCategory_ } from '../generated/generated.js';
+
+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;
+  }
+}