@memberjunction/server 2.22.2 → 2.23.1

package/src/context.ts

@@ -8,8 +8,9 @@ import { DataSource } from 'typeorm';
 import { getSigningKeys, getSystemUser, validationOptions, verifyUserRecord } from './auth/index.js';
 import { authCache } from './cache.js';
 import { userEmailMap, apiKey } from './config.js';
-import { UserPayload } from './types.js';
+import { DataSourceInfo, UserPayload } from './types.js';
 import { TokenExpiredError } from './auth/index.js';
+import { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
 
 const verifyAsync = async (issuer: string, options: jwt.VerifyOptions, token: string): Promise<jwt.JwtPayload> =>
   new Promise((resolve, reject) => {
@@ -29,15 +30,18 @@ const verifyAsync = async (issuer: string, options: jwt.VerifyOptions, token: st
 export const getUserPayload = async (
   bearerToken: string,
   sessionId = 'default',
-  dataSource: DataSource,
+  dataSources: DataSourceInfo[],
   requestDomain?: string,
   requestApiKey?: string
 ): Promise<UserPayload> => {
   try {
+    const readOnlyDataSource = GetReadOnlyDataSource(dataSources, { allowFallbackToReadWrite: true });
+    const readWriteDataSource = GetReadWriteDataSource(dataSources);
+
     if (requestApiKey && requestApiKey != String(undefined)) {
       // use requestApiKey for auth
       if (requestApiKey === apiKey) {
-        const systemUser = await getSystemUser(dataSource);
+        const systemUser = await getSystemUser(readOnlyDataSource);
         return {
           userRecord: systemUser,
           email: systemUser.Email,
@@ -81,7 +85,7 @@ export const getUserPayload = async (
     const fullName = payload?.name;
     const firstName = payload?.given_name || fullName?.split(' ')[0];
     const lastName = payload?.family_name || fullName?.split(' ')[1] || fullName?.split(' ')[0];
-    const userRecord = await verifyUserRecord(email, firstName, lastName, requestDomain, dataSource);
+    const userRecord = await verifyUserRecord(email, firstName, lastName, requestDomain, readWriteDataSource);
 
     if (!userRecord) {
       console.error(`User ${email} not found`);
@@ -101,7 +105,7 @@ export const getUserPayload = async (
 };
 
 export const contextFunction =
-  ({ setupComplete$, dataSource }: { setupComplete$: Subject<unknown>; dataSource: DataSource }) =>
+  ({ setupComplete$, dataSource, dataSources }: { setupComplete$: Subject<unknown>; dataSource: DataSource, dataSources: DataSourceInfo[] }) =>
   async ({ req }: { req: IncomingMessage }) => {
     await firstValueFrom(setupComplete$); // wait for setup to complete before processing the request
 
@@ -115,7 +119,7 @@ export const contextFunction =
     const userPayload = await getUserPayload(
       bearerToken,
       sessionId,
-      dataSource,
+      dataSources,
       requestDomain?.hostname ? requestDomain.hostname : undefined,
       apiKey
     );
@@ -126,5 +130,5 @@ export const contextFunction =
       console.log({ operationName });
     }
 
-    return { dataSource, userPayload };
+    return { dataSource, dataSources, userPayload };
   };

package/src/index.ts

@@ -20,7 +20,7 @@ import { BuildSchemaOptions, buildSchemaSync, GraphQLTimestamp } from 'type-grap
 import { DataSource } from 'typeorm';
 import { WebSocketServer } from 'ws';
 import buildApolloServer from './apolloServer/index.js';
-import { configInfo, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage } from './config.js';
+import { configInfo, dbDatabase, dbHost, dbPort, dbUsername, graphqlPort, graphqlRootPath, mj_core_schema, websiteRunFromPackage } from './config.js';
 import { contextFunction, getUserPayload } from './context.js';
 import { requireSystemUserDirective, publicDirective } from './directives/index.js';
 import orm from './orm.js';
@@ -64,9 +64,12 @@ export * from './resolvers/SyncRolesUsersResolver.js';
 export * from './resolvers/SyncDataResolver.js';
 export * from './resolvers/GetDataResolver.js';
 
+export { GetReadOnlyDataSource, GetReadWriteDataSource } from './util.js';
+
 export * from './generated/generated.js';
 
 import { resolve } from 'node:path';
+import { DataSourceInfo } from './types.js';
 
 export type MJServerOptions = {
   onBeforeServe?: () => void | Promise<void>;
@@ -103,6 +106,26 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
   await setupSQLServerClient(config); // datasource is already initialized, so we can setup the client right away
   const md = new Metadata();
   console.log(`Data Source has been initialized. ${md?.Entities ? md.Entities.length : 0} entities loaded.`);
+
+  const dataSources = [new DataSourceInfo({dataSource, type: 'Read-Write', host: dbHost, port: dbPort, database: dbDatabase, userName: dbUsername})];
+  
+  // Establish a second read-only connection to the database if dbReadOnlyUsername and dbReadOnlyPassword exist
+  let readOnlyDataSource: DataSource | null = null;
+  if (configInfo.dbReadOnlyUsername && configInfo.dbReadOnlyPassword) {
+    const readOnlyConfig = {
+      ...orm(paths),
+      username: configInfo.dbReadOnlyUsername,
+      password: configInfo.dbReadOnlyPassword,
+    };
+    readOnlyDataSource = new DataSource(readOnlyConfig);
+    await readOnlyDataSource.initialize();
+
+    // since we created a read-only data source, add it to the list of data sources
+    dataSources.push(new DataSourceInfo({dataSource: readOnlyDataSource, type: 'Read-Only', host: dbHost, port: dbPort, database: dbDatabase, userName: configInfo.dbReadOnlyUsername}));
+    console.log('Read-only Data Source has been initialized.');
+  }
+
+
   setupComplete$.next(true);
 
   /******TEST HARNESS FOR CHANGE DETECTION */
@@ -156,7 +179,7 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     {
       schema,
       context: async ({ connectionParams }) => {
-        const userPayload = await getUserPayload(String(connectionParams?.Authorization), undefined, dataSource);
+        const userPayload = await getUserPayload(String(connectionParams?.Authorization), undefined, dataSources);
         return { userPayload };
       },
     },
@@ -171,7 +194,11 @@ export const serve = async (resolverPaths: Array<string>, app = createApp(), opt
     cors<cors.CorsRequest>(),
     BodyParser.json({ limit: '50mb' }),
     expressMiddleware(apolloServer, {
-      context: contextFunction({ setupComplete$, dataSource }),
+      context: contextFunction({ 
+                                 setupComplete$, 
+                                 dataSource, // default read-write data source
+                                 dataSources // all data source
+                               }),
     })
   );
 

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

@@ -3,6 +3,7 @@ import { AppContext } from '../types.js';
 import { BaseEntity, CompositeKey, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { CompositeKeyInputType, CompositeKeyOutputType } from '../generic/KeyInputOutputTypes.js';
+import { DatasetItemEntity } from '@memberjunction/core-entities';
 
 
 
@@ -95,6 +96,9 @@ export class SyncDataResultType {
   Results: ActionItemOutputType[] = [];
 }
 
+
+const __metadata_DatasetItems: string[] = [];
+
 export class SyncDataResolver {
     /**
      * 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.
@@ -114,6 +118,10 @@ export class SyncDataResolver {
                 results.push(await this.SyncSingleItem(item, context, md)); 
             }
 
+            if (await this.DoSyncItemsAffectMetadata(items)) {
+                await md.Refresh(); // force refesh the metadata which will cause a reload from the DB
+            }
+
             const overallSuccess = !results.some((r) => !r.Success); // if any element in the array of results has a Success value of false, then the overall success is false
             return { Success: overallSuccess, Results: results };
         } 
@@ -123,6 +131,35 @@ export class SyncDataResolver {
         }
     }
 
+    protected async GetLowercaseMetadatEntitiesList(forceRefresh: boolean = false): Promise<string[]> {
+        if (forceRefresh || __metadata_DatasetItems.length === 0) {
+            const rv = new RunView(); // cache this, veyr simple - should use an engine for this stuff later
+            const result = await rv.RunView<DatasetItemEntity>({
+                EntityName: "Dataset Items",
+                ExtraFilter: "Dataset = 'MJ_Metadata'",
+            })
+            if (result && result.Success) {
+                __metadata_DatasetItems.length = 0;
+                __metadata_DatasetItems.push(...result.Results.map((r) => {
+                    return r.Entity.trim().toLowerCase();
+                }));
+            }    
+        }
+        // now return the list of entities
+        return __metadata_DatasetItems;
+    }
+
+    protected async DoSyncItemsAffectMetadata(items: ActionItemInputType[]): Promise<boolean> {
+        // check to see if any of the items affect any of these entities:
+        const entitiesToCheck = await this.GetLowercaseMetadatEntitiesList(false);
+        for (const item of items) {
+            if (entitiesToCheck.find(e => e === item.EntityName.trim().toLowerCase()) ) {
+                return true;
+            }
+        }
+        return false; // didn't find any
+    }
+
     protected async SyncSingleItem(item: ActionItemInputType, context: AppContext, md: Metadata): Promise<ActionItemOutputType> {
         const result = new ActionItemOutputType();
         result.AlternateKey = item.AlternateKey;
@@ -266,6 +303,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 +321,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 +352,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 +392,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

@@ -3,6 +3,7 @@ import { AppContext } from '../types.js';
 import { LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { RoleEntity, UserEntity, UserRoleEntity } from '@memberjunction/core-entities';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 
 @ObjectType()
 export class SyncRolesAndUsersResultType {
@@ -88,8 +89,16 @@ export class SyncRolesAndUsersResolver {
         try {
             // first we sync the roles, then the users 
             const roleResult = await this.SyncRoles(data.Roles, context);
-            if (roleResult.Success) {
-                return await this.SyncUsers(data.Users, context);
+            if (roleResult?.Success) {
+                const usersResult = await this.SyncUsers(data.Users, context);
+                if (usersResult?.Success) {
+                    // refresh the user cache, don't set an auto-refresh
+                    // interval here becuase that is alreayd done at startup
+                    // and will keep going on its own as per the config. This is a
+                    // special one-time refresh since we made changes here.
+                    await UserCache.Instance.Refresh(context.dataSource);
+                }
+                return usersResult;
             }
             else {
                 return roleResult;
@@ -398,4 +407,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');
+  }