@memberjunction/server 2.1.4 → 2.2.0

package/src/resolvers/UserFavoriteResolver.ts

@@ -0,0 +1,176 @@
+import { Metadata, KeyValuePair, CompositeKey, UserInfo } from '@memberjunction/core';
+import {
+  AppContext,
+  Arg,
+  CompositeKeyInputType,
+  CompositeKeyOutputType,
+  Ctx,
+  Field,
+  InputType,
+  Int,
+  Mutation,
+  ObjectType,
+  Query,
+  Resolver,
+} from '@memberjunction/server';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { UserFavoriteEntity } from '@memberjunction/core-entities';
+
+import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated.js';
+
+//****************************************************************************
+// INPUT TYPE for User Favorite Queries
+//****************************************************************************
+@InputType()
+export class UserFavoriteSearchParams {
+  @Field(() => String)
+  EntityID: string;
+
+  @Field(() => CompositeKeyInputType)
+  CompositeKey: CompositeKeyInputType;
+
+  @Field(() => String)
+  UserID: string;
+}
+
+@InputType()
+export class UserFavoriteSetParams {
+  @Field(() => String)
+  EntityID: string;
+
+  @Field(() => CompositeKeyInputType)
+  CompositeKey: CompositeKeyInputType;
+
+  @Field(() => String)
+  UserID: string;
+
+  @Field(() => Boolean)
+  IsFavorite: boolean;
+}
+
+@ObjectType()
+export class UserFavoriteResult {
+  @Field(() => Int)
+  EntityID: number;
+
+  @Field(() => CompositeKeyOutputType)
+  CompositeKey: CompositeKeyOutputType;
+
+  @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 pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
+
+    const e = md.Entities.find((e) => e.ID === params.EntityID);
+    if (e)
+      return {
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        CompositeKey: pk,
+        IsFavorite: await md.GetRecordFavoriteStatus(params.UserID, e.Name, pk),
+        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 pk = new CompositeKey(params.CompositeKey.KeyValuePairs);
+    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, pk, params.IsFavorite, u);
+      return {
+        Success: true,
+        EntityID: params.EntityID,
+        UserID: params.UserID,
+        CompositeKey: params.CompositeKey,
+        IsFavorite: params.IsFavorite,
+      };
+    } else throw new Error(`Entity ID:${params.EntityID} not found`);
+  }
+
+  private GetTestData() {
+    return [
+      {
+        firstName: 'John',
+        lastName: 'Doe',
+        title: 'Software Engineer II',
+        email: 'amith+john.doe@nagarajan.org',
+        age: 25,
+        address: {
+          street: '123 Main St',
+          city: 'Springfield',
+          state: 'IL',
+          zip: '62701',
+        },
+        recommendedArticles: [
+          {
+            title: 'How to Write Better Code',
+            url: 'https://example.com/article1',
+          },
+          {
+            title: 'The Art of Debugging',
+            url: 'https://example.com/article2',
+          },
+          {
+            title: 'Using Templates Effectively',
+            url: 'https://example.com/article3',
+          },
+        ],
+      },
+      {
+        firstName: 'Jane',
+        lastName: 'Smith',
+        title: 'Executive Vice President of Software Development',
+        email: 'amith+jane.smith@nagarajan.org',
+        age: 30,
+        address: {
+          street: '456 Elm St',
+          city: 'Chicago',
+          state: 'IL',
+          zip: '62702',
+        },
+        recommendedArticles: [
+          {
+            title: 'Exemplifying the Importance of Code Reviews',
+            url: 'https://example.com/article1',
+          },
+          {
+            title: 'AI and Software Development: A New Frontier',
+            url: 'https://example.com/article2',
+          },
+          {
+            title: 'Gardening Tips for Fun Loving Software Developers',
+            url: 'https://example.com/article3',
+          },
+        ],
+      },
+    ];
+  }
+}
+
+export default UserFavoriteResolver;

package/src/resolvers/UserResolver.ts

@@ -0,0 +1,33 @@
+import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
+import { User_, UserResolverBase } from '../generated/generated.js';
+
+@Resolver(User_)
+export class UserResolver extends UserResolverBase {
+  @Query(() => User_)
+  async CurrentUser(@Ctx() { dataSource, userPayload }: AppContext) {
+    const result = await this.UserByEmail(userPayload.email, { dataSource, userPayload });
+    console.log('CurrentUser', result);
+    return result;
+  }
+
+  @Query(() => User_)
+  async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { dataSource }: AppContext) {
+    const retVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { ID }));
+    return this.MapFieldNamesToCodeNames('Users', retVal);
+  }
+
+  @Query(() => User_)
+  async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { dataSource }: AppContext) {
+    const retVal = super.safeFirstArrayElement(await this.findBy(dataSource, 'Users', { EmployeeID }));
+    return this.MapFieldNamesToCodeNames('Users', retVal);
+  }
+
+  @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 this.MapFieldNamesToCodeNames('Users', returnVal);
+  }
+}
+export default UserResolver;

package/src/resolvers/UserViewResolver.ts

@@ -0,0 +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.js';
+import { UserResolver } from './UserResolver.js';
+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', () => String) ID: string, @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;

package/src/types.ts

@@ -0,0 +1,40 @@
+import { UserViewEntity } from '@memberjunction/core-entities';
+import { GraphQLSchema } from 'graphql';
+import { PubSubEngine } from 'type-graphql';
+import { DataSource, QueryRunner } from 'typeorm';
+
+export type UserPayload = {
+  email: string;
+  userRecord: any;
+  sessionId: string;
+};
+
+export type AppContext = {
+  dataSource: DataSource;
+  userPayload: UserPayload;
+  queryRunner?: QueryRunner;
+};
+
+export type DirectiveBuilder = {
+  typeDefs: string;
+  transformer: (schema: GraphQLSchema) => GraphQLSchema;
+};
+
+export type RunViewGenericParams = {
+  viewInfo: UserViewEntity;
+  dataSource: DataSource;
+  extraFilter: string;
+  orderBy: string;
+  userSearchString: string;
+  excludeUserViewRunID?: string;
+  overrideExcludeFilter?: string;
+  saveViewResults?: boolean;
+  fields?: string[];
+  ignoreMaxRows?: boolean;
+  excludeDataFromAllPriorViewRuns?: boolean;
+  forceAuditLog?: boolean;
+  auditLogDescription?: string;
+  resultType?: string;
+  userPayload?: UserPayload;
+  pubSub: PubSubEngine
+}

package/src/util.ts

@@ -0,0 +1,112 @@
+import { request as httpRequest } from 'http';
+import { request as httpsRequest } from 'https';
+import { gzip as gzipCallback, createGunzip } from 'zlib';
+import { promisify } from 'util';
+import { URL } from 'url';
+import { z } from 'zod';
+
+const gzip = promisify(gzipCallback);
+
+type StreamCallback = (jsonObject: any) => void;
+
+/**
+ * Utility function to handle HTTP/HTTPS requests with optional compression, custom headers, and streaming response callback for JSON objects.
+ * This function accumulates data chunks and parses complete JSON objects, assuming newline-delimited JSON in the stream.
+ * 
+ * @param {string} url - The URL to which the request is sent.
+ * @param {any} payload - The payload to be sent with the request.
+ * @param {boolean} useCompression - Flag to determine if payload compression should be used.
+ * @param {Record<string, string> | null} headers - Custom headers for the request. Can be null.
+ * @param {StreamCallback} [streamCallback] - Optional callback for handling streaming JSON objects.
+ * @returns {Promise<any[]>} - A promise that resolves to an array of all JSON objects received during the streaming process.
+ */
+export async function sendPostRequest(url: string, payload: any, useCompression: boolean, headers: Record<string, string> | null, streamCallback?: StreamCallback): Promise<any[]> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const { protocol, hostname, port, pathname } = new URL(url);
+      let data;
+      if (useCompression) {
+        try {
+          data = await gzip(Buffer.from(JSON.stringify(payload)));
+          headers = headers || {}; // Ensure headers is an object
+          headers['Content-Encoding'] = 'gzip';
+        } catch (error) {
+          const err = z.object({ message: z.string() }).safeParse(error);
+          console.error(`Error in sendPostRequest while compressing data: ${err.success ? err.data.message : error}`);
+          return reject(error);
+        }
+      } else {
+        data = Buffer.from(JSON.stringify(payload));
+      }
+  
+      const options = {
+        hostname,
+        port: port || (protocol === 'https:' ? 443 : 80),
+        path: pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...headers
+        }
+      };
+  
+      const request = protocol === 'https:' ? httpsRequest : httpRequest;
+      const jsonObjects: any[] = [];
+      let buffer = '';
+  
+      const req = request(options, (res) => {
+        const gunzip = createGunzip();
+        const stream = res.headers['content-encoding'] === 'gzip' ? res.pipe(gunzip) : res;
+  
+        stream.on('data', (chunk) => {
+          buffer += chunk;
+          let boundary;
+          while ((boundary = buffer.indexOf('\n')) !== -1) {
+            const jsonString = buffer.substring(0, boundary);
+            buffer = buffer.substring(boundary + 1);
+            try {
+              const jsonObject = JSON.parse(jsonString);
+              jsonObjects.push(jsonObject);
+              streamCallback?.(jsonObject);
+            } catch (e) {
+              const err = z.object({ message: z.string() }).safeParse(e);
+              // Handle JSON parse error for cases of malformed JSON objects
+              console.warn(`Error in postRequest().stream(data) while parsing JSON object: ${err.success ? err.data.message : e}`);
+            }
+          }
+        });
+  
+        stream.on('end', () => {
+          // Attempt to parse any remaining data in buffer in case it's a complete JSON object
+          if (buffer.trim()) {
+            try {
+              const jsonObject = JSON.parse(buffer.trim());
+              jsonObjects.push(jsonObject);
+              streamCallback?.(jsonObject);
+            } catch (e) {
+              const err = z.object({ message: z.string() }).safeParse(e);
+              // Handle JSON parse error for the last chunk
+              console.warn(`Error in postRequest().stream(end) while parsing JSON object: ${err.success ? err.data.message : e}`);
+            }
+          }
+          resolve(jsonObjects);
+        });
+      });
+  
+      req.on('error', (e) => {
+        const err = z.object({ message: z.string() }).safeParse(e);
+        console.error(`Error in sendPostRequest().req.on(error): ${err.success ? err.data.message : e}`);
+        reject(e);
+      });
+  
+      req.write(data);
+      req.end();
+    }
+    catch (e) {
+      const err = z.object({ message: z.string() }).safeParse(e);
+      console.error(`Error in sendPostRequest: ${err.success ? err.data.message : e}`)
+      reject(e);
+    }
+  }
+  );
+}