@memberjunction/server 2.22.2 → 2.23.0

package/src/resolvers/FileResolver.ts

@@ -47,20 +47,20 @@ export class FileResolver extends FileResolverBase {
   @Mutation(() => CreateFilePayload)
   async CreateFile(
     @Arg('input', () => CreateFileInput) input: CreateFileInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
     const md = new Metadata();
-    const user = this.GetUserFromPayload(userPayload);
+    const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
     const providerEntity = await md.GetEntityObject<FileStorageProviderEntity>('File Storage Providers', user);
     fileEntity.CheckPermissions(EntityPermissionType.Create, true);
 
     // Check to see if there's already an object with that name
-    const [sameName] = await this.findBy(dataSource, 'Files', { Name: input.Name, ProviderID: input.ProviderID });
+    const [sameName] = await this.findBy(context.dataSource, 'Files', { Name: input.Name, ProviderID: input.ProviderID });
     const NameExists = Boolean(sameName);
 
-    const fileRecord = (await super.CreateFile({ ...input, Status: 'Pending' }, { dataSource, userPayload }, pubSub)) as File_;
+    const fileRecord = (await super.CreateFile({ ...input, Status: 'Pending' }, context, pubSub)) as File_;
 
     // If there's a problem creating the file record, the base resolver will return null
     if (!fileRecord) {
@@ -98,12 +98,12 @@ export class FileResolver extends FileResolverBase {
   @Mutation(() => File_)
   async UpdateFile(
     @Arg('input', () => UpdateFileInput) input: UpdateFileInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
     // if the name is changing, rename the target object as well
     const md = new Metadata();
-    const user = this.GetUserFromPayload(userPayload);
+    const user = this.GetUserFromPayload(context.userPayload);
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Update, true);
 
@@ -119,7 +119,7 @@ export class FileResolver extends FileResolverBase {
       }
     }
 
-    const updatedFile = await super.UpdateFile(input, { dataSource, userPayload }, pubSub);
+    const updatedFile = await super.UpdateFile(input, context, pubSub);
     return updatedFile;
   }
 
@@ -127,11 +127,11 @@ export class FileResolver extends FileResolverBase {
   async DeleteFile(
     @Arg('ID', () => String) ID: string,
     @Arg('options___', () => DeleteOptionsInput) options: DeleteOptionsInput,
-    @Ctx() { dataSource, userPayload }: AppContext,
+    @Ctx() context: AppContext,
     @PubSub() pubSub: PubSubEngine
   ) {
     const md = new Metadata();
-    const userInfo = this.GetUserFromPayload(userPayload);
+    const userInfo = this.GetUserFromPayload(context.userPayload);
 
     const fileEntity = await md.GetEntityObject<FileEntity>('Files', userInfo);
     await fileEntity.Load(ID);
@@ -147,6 +147,6 @@ export class FileResolver extends FileResolverBase {
       await deleteObject(providerEntity, fileEntity.ProviderKey ?? fileEntity.Name);
     }
 
-    return super.DeleteFile(ID, options, { dataSource, userPayload }, pubSub);
+    return super.DeleteFile(ID, options, context, pubSub);
   }
 }

package/src/resolvers/GetDataResolver.ts

@@ -3,6 +3,7 @@ import { AppContext } from '../types.js';
 import { LogError, LogStatus, Metadata } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { v4 as uuidv4 } from 'uuid';
+import { GetReadOnlyDataSource } from '../util.js';
  
 @InputType() 
 export class GetDataInputType {
@@ -98,7 +99,7 @@ export class SimpleEntityFieldOutputType {
 
 export class GetDataResolver {
     /**
-     * This mutation will sync the specified items with the existing system. Items will be processed in order and the results of each operation will be returned in the Results array within the return value.
+     * This query will sync the specified items with the existing system. Items will be processed in order and the results of each operation will be returned in the Results array within the return value.
      * @param items - an array of ActionItemInputType objects that specify the action to be taken on the specified entity with the specified primary key and the JSON representation of the field values. 
      * @param token - the short-lived access token that is required to perform this operation.
      */
@@ -118,12 +119,18 @@ export class GetDataResolver {
                 throw new Error(`Token ${input.Token} is not valid or has expired`);
             }
 
+            // Use the read-only connection for executing queries
+            const readOnlyDataSource = GetReadOnlyDataSource(context.dataSources, {allowFallbackToReadWrite: false})
+            if (!readOnlyDataSource) {
+                throw new Error('Read-only data source not found');
+            }
+
             // Execute all queries in parallel, but execute each individual query in its own try catch block so that if one fails, the others can still be processed
             // and also so that we can capture the error message for each query and return it
             const results = await Promise.allSettled(
                 input.Queries.map(async (query) => {
                     try {
-                        const result = await context.dataSource.query(query);
+                        const result = await readOnlyDataSource.query(query);
                         return { result, error: null };
                     } catch (err) {
                         return { result: null, error: err };
@@ -258,4 +265,4 @@ export function recordTokenUse(token: string, usePayload: any) {
     else {
         throw new Error(`Token ${token} does not exist`);
     }
-}
+}

package/src/resolvers/SyncDataResolver.ts

@@ -266,6 +266,15 @@ export class SyncDataResolver {
                 result.ErrorMessage = 'Failed to load the item, it is possible the record with the specified primary key does not exist';
             }
             else {
+                // pass back the full record as it was JUST BEFORE the delete, often quite useful on the other end
+                result.RecordJSON = await altKeyResult.GetDataObjectJSON({
+                    includeRelatedEntityData: false,
+                    excludeFields: [],
+                    omitEmptyStrings: false,
+                    relatedEntityList: [],
+                    omitNullValues: false,
+                    oldValues: false
+                });
                 if (await altKeyResult.Delete()) {
                     result.Success = true;
                 }
@@ -275,6 +284,15 @@ export class SyncDataResolver {
             }
         }
         else if (await entityObject.InnerLoad(pk)) {
+            // pass back the full record as it was JUST BEFORE the delete, often quite useful on the other end
+            result.RecordJSON = await entityObject.GetDataObjectJSON({
+                includeRelatedEntityData: false,
+                excludeFields: [],
+                omitEmptyStrings: false,
+                relatedEntityList: [],
+                omitNullValues: false,
+                oldValues: false
+            });
             if (await entityObject.Delete()) {
                 result.Success = true;
             }
@@ -297,6 +315,15 @@ export class SyncDataResolver {
         if (await entityObject.Save()) {
             result.Success = true;
             result.PrimaryKey = new CompositeKey(entityObject.PrimaryKeys.map((pk) => ({FieldName: pk.Name, Value: pk.Value})));
+            // pass back the full record AFTER the sync, that's often quite useful on the other end
+            result.RecordJSON = await entityObject.GetDataObjectJSON({
+                includeRelatedEntityData: false,
+                excludeFields: [],
+                omitEmptyStrings: false,
+                relatedEntityList: [],
+                omitNullValues: false,
+                oldValues: false
+            });
         }
         else {
             result.ErrorMessage = 'Failed to create the item :' + entityObject.LatestResult.Message;
@@ -328,6 +355,18 @@ export class SyncDataResolver {
         entityObject.SetMany(fieldValues);
         if (await entityObject.Save()) {
             result.Success = true;
+            if (!result.PrimaryKey || result.PrimaryKey.KeyValuePairs.length === 0) {
+                result.PrimaryKey = new CompositeKey(entityObject.PrimaryKeys.map((pk) => ({FieldName: pk.Name, Value: pk.Value})));
+            }
+            // pass back the full record AFTER the sync, that's often quite useful on the other end
+            result.RecordJSON = await entityObject.GetDataObjectJSON({
+                includeRelatedEntityData: false,
+                excludeFields: [],
+                omitEmptyStrings: false,
+                relatedEntityList: [],
+                omitNullValues: false,
+                oldValues: false
+            });
         }
         else {
             result.ErrorMessage = 'Failed to update the item :' + entityObject.LatestResult.Message;

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -398,4 +398,4 @@ export class SyncRolesAndUsersResolver {
         }
     }
 }
- 
+ 

package/src/resolvers/UserResolver.ts

@@ -4,8 +4,8 @@ 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 });
+  async CurrentUser(@Ctx() context: AppContext) {
+    const result = await this.UserByEmail(context.userPayload.email, context);
     console.log('CurrentUser', result);
     return result;
   }

package/src/resolvers/UserViewResolver.ts

@@ -23,23 +23,23 @@ export class UserViewResolver extends UserViewResolverBase {
   }
 
   @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),
+  async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
+    return await this.findBy(context.dataSource, 'User Views', {
+      UserID: await this.getCurrentUserID(context),
       EntityID,
       IsDefault: true,
     });
   }
 
-  protected async getCurrentUserID(dataSource: DataSource, userPayload: UserPayload): Promise<number> {
+  protected async getCurrentUserID(context: AppContext): Promise<number> {
     const userResolver = new UserResolver();
-    const user = await userResolver.UserByEmail(userPayload.email, { dataSource, userPayload });
+    const user = await userResolver.UserByEmail(context.userPayload.email, context);
     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 });
+  async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
+    return this.findBy(context.dataSource, 'User Views', { UserID: await this.getCurrentUserID(context), EntityID });
   }
 
   @Query(() => [UserView_])

package/src/types.ts

@@ -11,10 +11,39 @@ export type UserPayload = {
   apiKey?: string;
 };
 
+/**
+ * AppContext is the context object that is passed to all resolvers.
+ */
 export type AppContext = {
+  /**
+   * The default and backwards compatible data source.
+   */
   dataSource: DataSource;
   userPayload: UserPayload;
   queryRunner?: QueryRunner;
+  /**
+   * Array of data sources that have additional information about their intended use e.g. Admin, Read-Write, Read-Only.
+   */
+  dataSources: DataSourceInfo[];
+};
+
+export class DataSourceInfo  {
+  dataSource: DataSource;
+  host: string;
+  port: number;
+  instance?: string;
+  database: string;
+  userName: string;
+  type: "Admin" | "Read-Write" | "Read-Only" | "Other";
+
+  constructor(init: {dataSource: DataSource, type: "Admin" | "Read-Write" | "Read-Only" | "Other", host: string, port: number, database: string, userName: string} ) {
+    this.dataSource = init.dataSource;
+    this.host = init.host;
+    this.port = init.port;
+    this.database = init.database;
+    this.userName = init.userName;
+    this.type = init.type;
+  }
 };
 
 export type DirectiveBuilder = {

package/src/util.ts

@@ -4,6 +4,8 @@ import { gzip as gzipCallback, createGunzip } from 'zlib';
 import { promisify } from 'util';
 import { URL } from 'url';
 import { z } from 'zod';
+import { DataSourceInfo } from './types';
+import { DataSource } from 'typeorm';
 
 const gzip = promisify(gzipCallback);
 
@@ -110,3 +112,39 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
   }
   );
 }
+
+
+  /**
+   * Returns the read-only data source if it exists, otherwise returns the read-write data source if options is not provided or if options.allowFallbackToReadWrite is true.
+   * @param dataSources 
+   * @param options 
+   * @returns 
+   */
+  export function GetReadOnlyDataSource(dataSources: DataSourceInfo[], options?: {allowFallbackToReadWrite: boolean}): DataSource {
+    const readOnlyDataSource = dataSources.find((ds) => ds.type === 'Read-Only');
+    if (readOnlyDataSource) {
+      return readOnlyDataSource.dataSource;
+    } 
+    else if (!options || options.allowFallbackToReadWrite) {
+      // default behavior for backward compatibility prior to MJ 2.22.3 where we introduced this functionality was to have a single
+      // connection, so for back-compatability, if we don't have a read-only data source, we'll fall back to the read-write data source
+      const readWriteDataSource = dataSources.find((ds) => ds.type === 'Read-Write');
+      if (readWriteDataSource) {
+        return readWriteDataSource.dataSource;
+      }
+    }
+    throw new Error('No suitable data source found');
+  }
+
+  /**
+   * Returns the read-write data source if it exists, otherwise throws an error.
+   * @param dataSources 
+   * @returns 
+   */
+  export function GetReadWriteDataSource(dataSources: DataSourceInfo[]): DataSource {
+    const readWriteDataSource = dataSources.find((ds) => ds.type === 'Read-Write');
+    if (readWriteDataSource) {
+      return readWriteDataSource.dataSource;
+    }
+    throw new Error('No suitable read-write data source found');
+  }