@memberjunction/server 1.0.4 → 1.0.7-next.0

package/src/resolvers/ReportResolver.ts

@@ -1,131 +1,131 @@
-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: number;
-
-  @Field()
-  Success: boolean;
-
-  @Field()
-  Results: string;
-
-  @Field()
-  RowCount: number;
-
-  @Field()
-  ExecutionTime: number;
-
-  @Field()
-  ErrorMessage: string;
-}
-
-@ObjectType()
-export class CreateReportResultType {
-  @Field()
-  ReportID: number;
-
-  @Field()
-  ReportName: string;
-
-  @Field()
-  Success: boolean;
-
-  @Field()
-  ErrorMessage: string;
-}
-
-@Resolver(RunReportResultType)
-export class ReportResolverExtended {
-  @Query(() => RunReportResultType)
-  async GetReportData(@Arg('ReportID', () => Int) ReportID: number, @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', () => Int) ConversationDetailID: number, 
-                                             @Ctx() {dataSource, userPayload}: AppContext): Promise<CreateReportResultType> {
-    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: -1,
-        ReportName: '',
-        Success: false,
-        ErrorMessage: 'Unable to save new report'
-      }
-    }
-  }
-}
+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: number;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  Results: string;
+
+  @Field()
+  RowCount: number;
+
+  @Field()
+  ExecutionTime: number;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@ObjectType()
+export class CreateReportResultType {
+  @Field()
+  ReportID: number;
+
+  @Field()
+  ReportName: string;
+
+  @Field()
+  Success: boolean;
+
+  @Field()
+  ErrorMessage: string;
+}
+
+@Resolver(RunReportResultType)
+export class ReportResolverExtended {
+  @Query(() => RunReportResultType)
+  async GetReportData(@Arg('ReportID', () => Int) ReportID: number, @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', () => Int) ConversationDetailID: number, 
+                                             @Ctx() {dataSource, userPayload}: AppContext): Promise<CreateReportResultType> {
+    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: -1,
+        ReportName: '',
+        Success: false,
+        ErrorMessage: 'Unable to save new report'
+      }
+    }
+  }
+}

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,102 +1,102 @@
-import { Metadata, PrimaryKeyValue } from '@memberjunction/core';
-import { AppContext, Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, PrimaryKeyValueInputType, PrimaryKeyValueOutputType, Query, Resolver } from '@memberjunction/server';
-import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { UserFavoriteEntity } from '@memberjunction/core-entities';
-
-import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated';
-
-//****************************************************************************
-// INPUT TYPE for User Favorite Queries
-//****************************************************************************
-@InputType()
-export class UserFavoriteSearchParams {
-  @Field(() => Int)
-  EntityID: number;
-
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
-
-  @Field(() => Int)
-  UserID: number;
-}
-
-@InputType()
-export class UserFavoriteSetParams {
-  @Field(() => Int)
-  EntityID: number;
-
-  @Field(() => [PrimaryKeyValueInputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
-
-  @Field(() => Int)
-  UserID: number;
-
-  @Field(() => Boolean)
-  IsFavorite: boolean;
-}
-
-@ObjectType()
-export class UserFavoriteResult {
-  @Field(() => Int)
-  EntityID: number;
-
-  @Field(() => [PrimaryKeyValueOutputType])
-  PrimaryKeyValues: PrimaryKeyValue[];
-
-  @Field(() => Int)
-  UserID: number;
-
-  @Field(() => Boolean)
-  IsFavorite: boolean;
-
-  @Field(() => Boolean)
-  Success: boolean;
-}
-
-@Resolver(UserFavorite_)
-export class UserFavoriteResolver extends UserFavoriteResolverBase {
-  @Query(() => [UserFavorite_])
-  async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
-    return await this.findBy(dataSource, 'User Favorites', { UserID });
-  }
-
-  @Query(() => [UserFavorite_])
-  async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { dataSource }: AppContext) {
-    return await this.findBy(dataSource, 'User Favorites', params);
-  }
-
-  @Query(() => UserFavoriteResult)
-  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {}: AppContext) {
-    const md = new Metadata();
-    const e = md.Entities.find((e) => e.ID === params.EntityID);
-    if (e)
-      return {
-        EntityID: params.EntityID,
-        UserID: params.UserID,
-        PrimaryKeyValues: params.PrimaryKeyValues,
-        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValues),
-        Success: true,
-      };
-    else throw new Error(`Entity ID:${params.EntityID} not found`);
-  }
-
-  @Mutation(() => UserFavoriteResult)
-  SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload }: AppContext) {
-    const md = new Metadata();
-    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);
-      return {
-        Success: true,
-        EntityID: params.EntityID,
-        UserID: params.UserID,
-        PrimaryKeyValues: params.PrimaryKeyValues,
-        IsFavorite: params.IsFavorite,
-      };
-    } else throw new Error(`Entity ID:${params.EntityID} not found`);
-  }
- 
-}
-
-export default UserFavoriteResolver;
+import { Metadata, PrimaryKeyValue } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, PrimaryKeyValueInputType, PrimaryKeyValueOutputType, Query, Resolver } from '@memberjunction/server';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserFavoriteEntity } from '@memberjunction/core-entities';
+
+import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated';
+
+//****************************************************************************
+// INPUT TYPE for User Favorite Queries
+//****************************************************************************
+@InputType()
+export class UserFavoriteSearchParams {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => [PrimaryKeyValueInputType])
+  PrimaryKeyValues: PrimaryKeyValue[];
+
+  @Field(() => Int)
+  UserID: number;
+}
+
+@InputType()
+export class UserFavoriteSetParams {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => [PrimaryKeyValueInputType])
+  PrimaryKeyValues: PrimaryKeyValue[];
+
+  @Field(() => Int)
+  UserID: number;
+
+  @Field(() => Boolean)
+  IsFavorite: boolean;
+}
+
+@ObjectType()
+export class UserFavoriteResult {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => [PrimaryKeyValueOutputType])
+  PrimaryKeyValues: PrimaryKeyValue[];
+
+  @Field(() => Int)
+  UserID: number;
+
+  @Field(() => Boolean)
+  IsFavorite: boolean;
+
+  @Field(() => Boolean)
+  Success: boolean;
+}
+
+@Resolver(UserFavorite_)
+export class UserFavoriteResolver extends UserFavoriteResolverBase {
+  @Query(() => [UserFavorite_])
+  async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Favorites', { UserID });
+  }
+
+  @Query(() => [UserFavorite_])
+  async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Favorites', params);
+  }
+
+  @Query(() => UserFavoriteResult)
+  async GetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSearchParams) params: UserFavoriteSearchParams, @Ctx() {}: AppContext) {
+    const md = new Metadata();
+    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    if (e)
+      return {
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        PrimaryKeyValues: params.PrimaryKeyValues,
+        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, params.PrimaryKeyValues),
+        Success: true,
+      };
+    else throw new Error(`Entity ID:${params.EntityID} not found`);
+  }
+
+  @Mutation(() => UserFavoriteResult)
+  SetRecordFavoriteStatus(@Arg('params', () => UserFavoriteSetParams) params: UserFavoriteSetParams, @Ctx() { userPayload }: AppContext) {
+    const md = new Metadata();
+    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);
+      return {
+        Success: true,
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        PrimaryKeyValues: params.PrimaryKeyValues,
+        IsFavorite: params.IsFavorite,
+      };
+    } else throw new Error(`Entity ID:${params.EntityID} not found`);
+  }
+ 
+}
+
+export default UserFavoriteResolver;

package/src/resolvers/UserResolver.ts

@@ -1,29 +1,29 @@
-import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
-import { User_, UserResolverBase } from '../generated/generated';
-
-@Resolver(User_)
-export class UserResolver extends UserResolverBase {
-  @Query(() => User_)
-  async CurrentUser(@Ctx() { dataSource, userPayload }: AppContext) {
-    return await this.UserByEmail(userPayload.email, { dataSource, userPayload });
-  }
-
-  @Query(() => User_)
-  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource }: AppContext) {
-    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { ID }));
-  }
-
-  @Query(() => User_)
-  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { dataSource }: AppContext) {
-    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { EmployeeID }));
-  }
-
-  @Query(() => User_)
-  async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { dataSource }: AppContext) {
-    // const searchEmail = userEmailMap[Email] ?? Email;
-    const searchEmail = Email;
-    const returnVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { Email: searchEmail }));
-    return returnVal;
-  }
-}
-export default UserResolver;
+import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
+import { User_, UserResolverBase } from '../generated/generated';
+
+@Resolver(User_)
+export class UserResolver extends UserResolverBase {
+  @Query(() => User_)
+  async CurrentUser(@Ctx() { dataSource, userPayload }: AppContext) {
+    return await this.UserByEmail(userPayload.email, { dataSource, userPayload });
+  }
+
+  @Query(() => User_)
+  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource }: AppContext) {
+    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { ID }));
+  }
+
+  @Query(() => User_)
+  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { dataSource }: AppContext) {
+    return super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { EmployeeID }));
+  }
+
+  @Query(() => User_)
+  async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { dataSource }: AppContext) {
+    // const searchEmail = userEmailMap[Email] ?? Email;
+    const searchEmail = Email;
+    const returnVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { Email: searchEmail }));
+    return returnVal;
+  }
+}
+export default UserResolver;

package/src/resolvers/UserViewResolver.ts

@@ -1,64 +1,64 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Metadata } from '@memberjunction/core';
-import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
-import { DataSource } from 'typeorm';
-import { UserView_, UserViewResolverBase } from '../generated/generated';
-import { UserResolver } from './UserResolver';
-import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
-
-@Resolver(UserView_)
-export class UserViewResolver extends UserViewResolverBase {
-  @Query(() => [UserView_])
-  async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
-    return await this.findBy(dataSource, 'User Views', { UserID });
-  }
-
-  @Query(() => [UserView_])
-  async DefaultViewByUserAndEntity(
-    @Arg('UserID', () => Int) UserID: number,
-    @Arg('EntityID', () => Int) EntityID: number,
-    @Ctx() { dataSource }: AppContext
-  ) {
-    return await this.findBy(dataSource, 'User Views', { UserID, EntityID, IsDefault: true });
-  }
-
-  @Query(() => [UserView_])
-  async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    return await this.findBy(dataSource, 'User Views', {
-      UserID: await this.getCurrentUserID(dataSource, userPayload),
-      EntityID,
-      IsDefault: true,
-    });
-  }
-
-  protected async getCurrentUserID(dataSource: DataSource, userPayload: UserPayload): Promise<number> {
-    const userResolver = new UserResolver();
-    const user = await userResolver.UserByEmail(userPayload.email, { dataSource, userPayload });
-    return user.ID;
-  }
-
-  @Query(() => [UserView_])
-  async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
-    return this.findBy(dataSource, 'User Views', { UserID: await this.getCurrentUserID(dataSource, userPayload), EntityID });
-  }
-
-  @Query(() => [UserView_])
-  async UpdateWhereClause(@Arg('ID', () => Int) ID: number, @Ctx() { userPayload }: AppContext) {
-    // in this query we want to update the uesrView record in the DB with a new where clause
-    // this should normally not be a factor but we have this exposed in the GraphQL API so that
-    // a dev can force the update if desired from the client. The normal path is just to update
-    // filter state which in turn will be used to update the where clause in the entity sub-class.
-    const md = new Metadata();
-    const u = this.GetUserFromPayload(userPayload);
-    const viewEntity = <UserViewEntityExtended>await md.GetEntityObject('User Views', u);
-    await viewEntity.Load(ID);
-    viewEntity.UpdateWhereClause();
-    if (await viewEntity.Save()) {
-      return viewEntity.GetAll();
-    } else {
-      throw new Error('Failed to update where clause');
-    }
-  }
-}
-
-export default UserViewResolver;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Metadata } from '@memberjunction/core';
+import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
+import { DataSource } from 'typeorm';
+import { UserView_, UserViewResolverBase } from '../generated/generated';
+import { UserResolver } from './UserResolver';
+import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
+
+@Resolver(UserView_)
+export class UserViewResolver extends UserViewResolverBase {
+  @Query(() => [UserView_])
+  async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { dataSource }: AppContext) {
+    return await this.findBy(dataSource, 'User Views', { UserID });
+  }
+
+  @Query(() => [UserView_])
+  async DefaultViewByUserAndEntity(
+    @Arg('UserID', () => Int) UserID: number,
+    @Arg('EntityID', () => Int) EntityID: number,
+    @Ctx() { dataSource }: AppContext
+  ) {
+    return await this.findBy(dataSource, 'User Views', { UserID, EntityID, IsDefault: true });
+  }
+
+  @Query(() => [UserView_])
+  async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
+    return await this.findBy(dataSource, 'User Views', {
+      UserID: await this.getCurrentUserID(dataSource, userPayload),
+      EntityID,
+      IsDefault: true,
+    });
+  }
+
+  protected async getCurrentUserID(dataSource: DataSource, userPayload: UserPayload): Promise<number> {
+    const userResolver = new UserResolver();
+    const user = await userResolver.UserByEmail(userPayload.email, { dataSource, userPayload });
+    return user.ID;
+  }
+
+  @Query(() => [UserView_])
+  async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() { dataSource, userPayload }: AppContext) {
+    return this.findBy(dataSource, 'User Views', { UserID: await this.getCurrentUserID(dataSource, userPayload), EntityID });
+  }
+
+  @Query(() => [UserView_])
+  async UpdateWhereClause(@Arg('ID', () => Int) ID: number, @Ctx() { userPayload }: AppContext) {
+    // in this query we want to update the uesrView record in the DB with a new where clause
+    // this should normally not be a factor but we have this exposed in the GraphQL API so that
+    // a dev can force the update if desired from the client. The normal path is just to update
+    // filter state which in turn will be used to update the where clause in the entity sub-class.
+    const md = new Metadata();
+    const u = this.GetUserFromPayload(userPayload);
+    const viewEntity = <UserViewEntityExtended>await md.GetEntityObject('User Views', u);
+    await viewEntity.Load(ID);
+    viewEntity.UpdateWhereClause();
+    if (await viewEntity.Save()) {
+      return viewEntity.GetAll();
+    } else {
+      throw new Error('Failed to update where clause');
+    }
+  }
+}
+
+export default UserViewResolver;