@memberjunction/server 2.1.1 → 2.1.3

package/src/resolvers/UserFavoriteResolver.ts

@@ -1,166 +0,0 @@
-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';
-
-//****************************************************************************
-// 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

@@ -1,33 +0,0 @@
-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) {
-    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

@@ -1,64 +0,0 @@
-/* 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', () => 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

@@ -1,40 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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';
-
-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) {
-          console.error(`Error in sendPostRequest while compressing data: ${error && error.message ? error.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) {
-              // Handle JSON parse error for cases of malformed JSON objects
-              console.warn(`Error in postRequest().stream(data) while parsing JSON object: ${e && e.message ? e.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) {
-              // Handle JSON parse error for the last chunk
-              console.warn(`Error in postRequest().stream(end) while parsing JSON object: ${e && e.message ? e.message : e}`);
-            }
-          }
-          resolve(jsonObjects);
-        });
-      });
-  
-      req.on('error', (e) => {
-        console.error(`Error in sendPostRequest().req.on(error): ${e && e.message ? e.message : e}`)
-        reject(e);
-      });
-  
-      req.write(data);
-      req.end();
-    }
-    catch (e) {
-      console.error(`Error in sendPostRequest: ${e && e.message ? e.message : e}`)
-      reject(e);
-    }
-  }
-  );
-}

package/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "ESNext",
-    "target": "ESNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "sourceMap": true,
-    "experimentalDecorators": true,
-    "resolveJsonModule": true,
-    "composite": true,
-    "declarationMap": true,
-    "esModuleInterop": true,
-    "lib": ["es2020", "esnext.asynciterable"],
-    "moduleResolution": "node",
-    "removeComments": true,
-    "noImplicitAny": false,
-    "strictNullChecks": false,
-    "strictFunctionTypes": true,
-    "noImplicitThis": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "allowSyntheticDefaultImports": true,
-    "emitDecoratorMetadata": true,
-    "skipLibCheck": true
-  },
-  "exclude": ["node_modules"],
-  "include": ["./src/**/*.ts"]
-}

package/typedoc.json

@@ -1,4 +0,0 @@
-{
-  "extends": ["../../typedoc.base.json"],
-  "entryPoints": ["src/index.ts"]
-}