@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/rest/setupRESTEndpoints.ts

@@ -3,7 +3,10 @@ import BodyParser from 'body-parser';
 import { LogStatusEx } from '@memberjunction/core';
 import { RESTEndpointHandler } from './RESTEndpointHandler.js';
 
-export const ___REST_API_BASE_PATH = '/api/v1';
+export const REST_API_BASE_PATH = '/api/v1';
+
+/** @deprecated Use {@link REST_API_BASE_PATH}. */
+export const ___REST_API_BASE_PATH = REST_API_BASE_PATH;
 
 /**
  * Configuration options for REST API endpoints
@@ -12,14 +15,14 @@ export interface RESTApiOptions {
     /**
      * Whether to enable REST API endpoints (default: false)
      */
-    enabled: boolean;
+    enabled: boolean;  // case-violation-ok-legacy-back-compat: the type is named in an exported signature, so consumers build object literals against it; an interface has no runtime carrier for a stub
 
     /**
      * Array of entity names to include in the API (case-insensitive)
      * If provided, only these entities will be accessible through the REST API
      * Supports wildcards using '*' (e.g., 'User*' matches 'User', 'UserRole', etc.)
      */
-    includeEntities?: string[];
+    includeEntities?: string[];  // case-violation-ok-legacy-back-compat: the type is named in an exported signature, so consumers build object literals against it; an interface has no runtime carrier for a stub
 
     /**
      * Array of entity names to exclude from the API (case-insensitive)
@@ -27,20 +30,20 @@ export interface RESTApiOptions {
      * Supports wildcards using '*' (e.g., 'Secret*' matches 'Secret', 'SecretKey', etc.)
      * Note: Exclude patterns always override include patterns
      */
-    excludeEntities?: string[];
+    excludeEntities?: string[];  // case-violation-ok-legacy-back-compat: the type is named in an exported signature, so consumers build object literals against it; an interface has no runtime carrier for a stub
 
     /**
      * Array of schema names to include in the API (case-insensitive)
      * If provided, only entities in these schemas will be accessible through the REST API
      */
-    includeSchemas?: string[];
+    includeSchemas?: string[];  // case-violation-ok-legacy-back-compat: the type is named in an exported signature, so consumers build object literals against it; an interface has no runtime carrier for a stub
 
     /**
      * Array of schema names to exclude from the API (case-insensitive)
      * Entities in these schemas will not be accessible through the REST API
      * Note: Exclude patterns always override include patterns
      */
-    excludeSchemas?: string[];
+    excludeSchemas?: string[];  // case-violation-ok-legacy-back-compat: the type is named in an exported signature, so consumers build object literals against it; an interface has no runtime carrier for a stub
 }
 
 /**
@@ -56,7 +59,7 @@ export const DEFAULT_REST_API_OPTIONS: RESTApiOptions = {
  * @param options Configuration options for REST API
  * @param authMiddleware Optional authentication middleware to use
  */
-export function setupRESTEndpoints(
+export function SetupRESTEndpoints(
     app: express.Application,
     options?: Partial<RESTApiOptions>,
     authMiddleware?: express.RequestHandler
@@ -71,14 +74,14 @@ export function setupRESTEndpoints(
         return;
     }
 
-    const basePath = ___REST_API_BASE_PATH;
+    const basePath = REST_API_BASE_PATH;
 
     // Create REST endpoint handler with entity and schema filters
     const restHandler = new RESTEndpointHandler({
-        includeEntities: config.includeEntities ? config.includeEntities.map(e => e.toLowerCase()) : undefined,
-        excludeEntities: config.excludeEntities ? config.excludeEntities.map(e => e.toLowerCase()) : undefined,
-        includeSchemas: config.includeSchemas ? config.includeSchemas.map(s => s.toLowerCase()) : undefined,
-        excludeSchemas: config.excludeSchemas ? config.excludeSchemas.map(s => s.toLowerCase()) : undefined
+        IncludeEntities: config.includeEntities ? config.includeEntities.map(e => e.toLowerCase()) : undefined,
+        ExcludeEntities: config.excludeEntities ? config.excludeEntities.map(e => e.toLowerCase()) : undefined,
+        IncludeSchemas: config.includeSchemas ? config.includeSchemas.map(s => s.toLowerCase()) : undefined,
+        ExcludeSchemas: config.excludeSchemas ? config.excludeSchemas.map(s => s.toLowerCase()) : undefined
     });
 
     // Mount REST API at the specified base path with authentication
@@ -90,4 +93,13 @@ export function setupRESTEndpoints(
     }
 
     LogStatusEx({ message: `REST API endpoints have been set up at ${basePath}`, verboseOnly: true });
+}
+
+/** @deprecated Use {@link SetupRESTEndpoints}. */
+export function setupRESTEndpoints(
+    app: express.Application,
+    options?: Partial<RESTApiOptions>,
+    authMiddleware?: express.RequestHandler
+): void {
+    return SetupRESTEndpoints(app, options, authMiddleware);
 }

package/src/serverExtensionReservedRoots.ts

@@ -40,7 +40,7 @@ export const CORE_CONSTANT_RESERVED_SERVER_EXTENSION_ROOTS: readonly string[] =
  * static `/graphql` baseline) is still protected. `/` as graphqlRootPath is
  * already reserved as the server root and does not prefix-match every path.
  */
-export function coreReservedServerExtensionRoots(graphqlRootPath: string): string[] {
+export function CoreReservedServerExtensionRoots(graphqlRootPath: string): string[] {
     const graphql = typeof graphqlRootPath === 'string' ? graphqlRootPath.trim() : '';
     return [
         ...(graphql ? [graphql] : []),
@@ -48,3 +48,8 @@ export function coreReservedServerExtensionRoots(graphqlRootPath: string): strin
         ...CORE_STATIC_RESERVED_SERVER_EXTENSION_ROOTS,
     ];
 }
+
+/** @deprecated Use {@link CoreReservedServerExtensionRoots}. */
+export function coreReservedServerExtensionRoots(graphqlRootPath: string): string[] {
+    return CoreReservedServerExtensionRoots(graphqlRootPath);
+}

package/src/services/MJStorageBlobStore.ts

@@ -0,0 +1,209 @@
+import { LogError, UserInfo, IMetadataProvider, Metadata } from '@memberjunction/core';
+import { MJGlobal } from '@memberjunction/global';
+import type { MJFileEntity, MJFileStorageProviderEntity } from '@memberjunction/core-entities';
+import { FileStorageBase, FileStorageEngine } from '@memberjunction/storage';
+import type {
+    AttachmentBlobUploadInput,
+    AttachmentBlobUploadResult,
+    IAttachmentBlobStore,
+} from '@memberjunction/aiengine';
+
+/**
+ * @fileoverview MJStorage-backed implementation of the conversation-attachment blob seam.
+ *
+ * This is where `@memberjunction/storage` — and with it the AWS, Azure and Dropbox SDKs — now
+ * lives, instead of inside `@memberjunction/aiengine`. That single import previously made the
+ * whole attachment service server-only: no browser or React Native client could consume it, which
+ * is why the same attachment rules ended up reimplemented three times across the estate.
+ *
+ * The bodies here are the ones lifted out of `ConversationAttachmentService`, unchanged in
+ * behaviour. Only two things differ, both forced by the seam being runtime-neutral:
+ *
+ *  - content crosses as **base64**, not `Buffer`;
+ *  - account-versus-provider resolution is this implementation's business, because only it knows
+ *    how its credentials work.
+ */
+export class MJStorageBlobStore implements IAttachmentBlobStore {
+    /**
+     * Uploads bytes and creates the `MJ: Files` record.
+     *
+     * Prefers account-scoped upload through `FileStorageEngine` when an account id is supplied —
+     * that path handles OAuth credentials properly. Falls back to provider-only resolution, which
+     * relies on environment configuration and has no account credentials.
+     */
+    public async Upload(
+        input: AttachmentBlobUploadInput,
+        contextUser: UserInfo,
+        provider?: IMetadataProvider
+    ): Promise<AttachmentBlobUploadResult> {
+        const md = provider ?? Metadata.Provider;
+
+        if (input.StorageAccountID) {
+            try {
+                await FileStorageEngine.Instance.Config(false, contextUser);
+                const result = await FileStorageEngine.Instance.UploadFile({
+                    content: Buffer.from(input.Base64Data, 'base64'),
+                    fileName: input.FileName,
+                    mimeType: input.MimeType,
+                    contextUser,
+                    storageAccountId: input.StorageAccountID,
+                    provider: md,
+                    pathPrefix: input.PathPrefix ?? undefined,
+                });
+                return { Success: true, FileID: result.FileID };
+            } catch (err) {
+                return { Success: false, Error: (err as Error).message };
+            }
+        }
+
+        if (!input.StorageProviderID) {
+            return { Success: false, Error: 'No storage provider configured for attachments' };
+        }
+
+        const storageProviderEntity = await md.GetEntityObject<MJFileStorageProviderEntity>(
+            'MJ: File Storage Providers',
+            contextUser
+        );
+        if (!(await storageProviderEntity.Load(input.StorageProviderID))) {
+            return { Success: false, Error: 'Failed to load storage provider' };
+        }
+
+        const driver = MJGlobal.Instance.ClassFactory.CreateInstance<FileStorageBase>(
+            FileStorageBase,
+            storageProviderEntity.ServerDriverKey
+        );
+
+        const objectName = `${input.PathPrefix ?? 'conversation-attachments'}/${input.FileName}`;
+        const uploaded = await driver.PutObject(objectName, Buffer.from(input.Base64Data, 'base64'), input.MimeType);
+        if (!uploaded) {
+            return { Success: false, Error: 'Failed to upload file to storage' };
+        }
+
+        const file = await md.GetEntityObject<MJFileEntity>('MJ: Files', contextUser);
+        file.NewRecord();
+        file.Name = input.FileName;
+        file.ProviderID = input.StorageProviderID;
+        file.ContentType = input.MimeType;
+        file.ProviderKey = objectName;
+        file.Status = 'Uploaded';
+        if (!(await file.Save())) {
+            // The bytes are already in the bucket and nothing will ever point at them, so remove
+            // them before reporting the failure. Without this compensation an RLS rejection or a
+            // transient SQL error leaves a permanently orphaned object with no catalog row — the
+            // failure mode this seam's contract calls out by name.
+            const compensated = await driver.DeleteObject(objectName);
+            if (!compensated) {
+                LogError(
+                    `[MJStorageBlobStore] Orphaned object '${objectName}': the MJ: Files row failed to save ` +
+                        `and the compensating delete also failed.`
+                );
+            }
+            return {
+                Success: false,
+                Error: file.LatestResult?.CompleteMessage ?? 'Failed to create the file record',
+            };
+        }
+        return { Success: true, FileID: file.ID };
+    }
+
+    /** @inheritdoc */
+    public async Download(
+        fileId: string,
+        contextUser: UserInfo,
+        provider?: IMetadataProvider
+    ): Promise<string | null> {
+        try {
+            const resolved = await this.resolveFileAndDriver(fileId, contextUser, provider);
+            if (!resolved) return null;
+
+            const content = await resolved.driver.GetObject({ fullPath: resolved.objectKey });
+            // The seam is base64 so it stays runtime-neutral; the Buffer never leaves this file.
+            return content ? content.toString('base64') : null;
+        } catch (err) {
+            LogError(`[MJStorageBlobStore] Failed to download file ${fileId}: ${err}`);
+            return null;
+        }
+    }
+
+    /** @inheritdoc */
+    public async GetDownloadUrl(
+        fileId: string,
+        contextUser: UserInfo,
+        provider?: IMetadataProvider
+    ): Promise<string | null> {
+        try {
+            const resolved = await this.resolveFileAndDriver(fileId, contextUser, provider);
+            if (!resolved) return null;
+            return resolved.driver.CreatePreAuthDownloadUrl(resolved.objectKey);
+        } catch (err) {
+            LogError(`[MJStorageBlobStore] Failed to create download URL for ${fileId}: ${err}`);
+            return null;
+        }
+    }
+
+    /** @inheritdoc */
+    public async Delete(
+        fileId: string,
+        contextUser: UserInfo,
+        provider?: IMetadataProvider
+    ): Promise<boolean> {
+        try {
+            const resolved = await this.resolveFileAndDriver(fileId, contextUser, provider);
+            if (!resolved) return false;
+
+            const deleted = await resolved.driver.DeleteObject(resolved.objectKey);
+            // Only remove the catalog row once the bytes are gone — a row without content is
+            // recoverable, content without a row is orphaned storage nobody will find again.
+            if (deleted) {
+                await resolved.file.Delete();
+            }
+            return deleted;
+        } catch (err) {
+            LogError(`[MJStorageBlobStore] Failed to delete file ${fileId}: ${err}`);
+            return false;
+        }
+    }
+
+    /**
+     * Loads a file, its storage provider, and a driver able to act on it.
+     *
+     * Shared by download, URL and delete, which previously repeated this block three times with
+     * subtly different fallbacks — the account-credential path existed in only one of them.
+     */
+    private async resolveFileAndDriver(
+        fileId: string,
+        contextUser: UserInfo,
+        provider?: IMetadataProvider
+    ): Promise<{ file: MJFileEntity; driver: FileStorageBase; objectKey: string } | null> {
+        const md = provider ?? Metadata.Provider;
+
+        // Load the engine before asking it anything. `Accounts` returns an empty array when it has
+        // not been configured, so on a cold process the account-credential branch below would be
+        // skipped silently and the driver would fall back to environment-only credentials — which
+        // then fails to read a file that is perfectly readable. Every other MJServer call site
+        // configures immediately before use for the same reason.
+        await FileStorageEngine.Instance.Config(false, contextUser);
+
+        const file = await md.GetEntityObject<MJFileEntity>('MJ: Files', contextUser);
+        if (!(await file.Load(fileId))) return null;
+
+        const storageProvider = await md.GetEntityObject<MJFileStorageProviderEntity>(
+            'MJ: File Storage Providers',
+            contextUser
+        );
+        if (!(await storageProvider.Load(file.ProviderID))) return null;
+
+        // Prefer account-scoped credentials when an account links to this provider; fall back to
+        // environment-configured credentials otherwise.
+        const matchingAccounts = FileStorageEngine.Instance.GetAccountsByProviderID(file.ProviderID);
+        const driver =
+            matchingAccounts.length > 0
+                ? await FileStorageEngine.Instance.GetDriver(matchingAccounts[0].ID, contextUser)
+                : MJGlobal.Instance.ClassFactory.CreateInstance<FileStorageBase>(
+                      FileStorageBase,
+                      storageProvider.ServerDriverKey
+                  );
+
+        return { file, driver, objectKey: file.ProviderKey || file.Name };
+    }
+}

package/src/services/TaskGraphActionRunner.ts

@@ -75,25 +75,26 @@ export class TaskGraphActionRunner implements TaskActionRunner {
     }
 
     /**
-     * Rebuilds the action's parameters from the task's stored payload.
+     * Rebuilds the action's parameters from the task's input, one parameter per key.
      *
-     * **The values here have been through redaction**, because `Task.InputPayload` is persistent,
-     * user-visible storage and nothing writes a raw `ActionParam[]` there. A parameter the binding
-     * marked as not-logged therefore arrives absent rather than secret — the action sees a missing
-     * value, which is the honest consequence of choosing not to persist it, and the reason durable
-     * dispatch is opt-in per binding rather than the default.
+     * For a **durable entity-action** graph the input was written by `RedactParamsToRecord`
+     * (`@memberjunction/actions-base`) at deferral time, so its values have been through redaction:
+     * a parameter the binding marked as not-logged arrives absent rather than secret — the action
+     * sees a missing value, which is the honest consequence of choosing not to persist it, and the
+     * reason durable dispatch is opt-in per binding rather than the default. Every other graph's
+     * input is whatever its spec authored. This method re-applies no redaction rule in either case.
      *
-     * Dependency outputs are merged underneath the task's own input so a node's explicit parameters
-     * always win over an upstream node that happened to emit the same key.
+     * `InputPayload` already carries the dependency outputs: the dispatcher merges them underneath
+     * the task's own input (`mergedPayload`) before calling this runner, so a node's explicit
+     * parameters win and a step with an input mapping gets exactly the parameters it declared.
+     * `DependencyOutputs` is keyed by upstream task ID, not by parameter name, so it is deliberately
+     * not read here — spreading it would hand the action one extra parameter per dependency, named
+     * by a GUID and holding that task's whole output.
      */
     private buildParams(params: TaskActionRunParams): ActionParam[] {
-        const merged: Record<string, unknown> = {};
-        for (const [name, value] of params.DependencyOutputs) {
-            merged[name] = value;
+        if (!params.InputPayload || typeof params.InputPayload !== 'object') {
+            return [];
         }
-        if (params.InputPayload && typeof params.InputPayload === 'object') {
-            Object.assign(merged, params.InputPayload as Record<string, unknown>);
-        }
-        return Object.entries(merged).map(([Name, Value]) => ({ Name, Value, Type: 'Input' }));
+        return Object.entries(params.InputPayload as Record<string, unknown>).map(([Name, Value]) => ({ Name, Value, Type: 'Input' }));
     }
 }

package/src/types.ts

@@ -2,7 +2,7 @@ import { AggregateExpression, CompositeKey, DatabaseProviderBase, UserInfo } fro
 import { MJUserViewEntityExtended } from '@memberjunction/core-entities';
 import { GraphQLSchema } from 'graphql';
 import sql from 'mssql';
-import { getSystemUser } from './auth/index.js';
+import { GetSystemUser } from './auth/index.js';
 import { MJEvent, MJEventType, MJGlobal } from '@memberjunction/global';
 
 /**
@@ -57,18 +57,18 @@ export type AppContext = {
 };
 
 export class ProviderInfo {
-  provider: DatabaseProviderBase;
-  type: 'Admin' | 'Read-Write' | 'Read-Only' | 'Other';
+  provider: DatabaseProviderBase;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  type: 'Admin' | 'Read-Write' | 'Read-Only' | 'Other';  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
 }
 
 export class DataSourceInfo  {
-  dataSource: sql.ConnectionPool;
-  host: string;
-  port: number;
-  instance?: string;
-  database: string;
-  userName: string;
-  type: "Admin" | "Read-Write" | "Read-Only" | "Other";
+  dataSource: sql.ConnectionPool;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  host: string;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  port: number;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  instance?: string;  // case-violation-ok-legacy-back-compat: an accessor cannot be optional, so a stub would turn this into a required member
+  database: string;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  userName: string;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  type: "Admin" | "Read-Write" | "Read-Only" | "Other";  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
 
   constructor(init: {dataSource: sql.ConnectionPool, type: "Admin" | "Read-Write" | "Read-Only" | "Other", host: string, port: number, database: string, userName: string} ) {
     this.dataSource = init.dataSource;
@@ -125,20 +125,20 @@ export type RunViewGenericParams = {
 
 
 export class MJServerEvent {
-  type: 'setupComplete' | 'requestReceived' | 'requestCompleted' | 'requestFailed';
-  dataSources: DataSourceInfo[];
-  userPayload: UserPayload;
-  systemUser: UserInfo;
+  type: 'setupComplete' | 'requestReceived' | 'requestCompleted' | 'requestFailed';  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  dataSources: DataSourceInfo[];  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  userPayload: UserPayload;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
+  systemUser: UserInfo;  // case-violation-ok-legacy-back-compat: object literals are assigned to this class, so an accessor stub changes what they must supply
 }
 
 export const MJ_SERVER_EVENT_CODE = 'MJ_SERVER_EVENT';
 
-export async function raiseEvent(type: MJServerEvent['type'], dataSources: DataSourceInfo[], userPayload: UserPayload, component?: any) {
+export async function RaiseEvent(type: MJServerEvent['type'], dataSources: DataSourceInfo[], userPayload: UserPayload, component?: any) {
   const event = new MJServerEvent();
   event.type = type;
   event.dataSources = dataSources;
   event.userPayload = userPayload;
-  event.systemUser = await getSystemUser();
+  event.systemUser = await GetSystemUser();
 
   const mje = new MJEvent();
   mje.args = event;
@@ -146,4 +146,9 @@ export async function raiseEvent(type: MJServerEvent['type'], dataSources: DataS
   mje.event = MJEventType.ComponentEvent;
   mje.eventCode = MJ_SERVER_EVENT_CODE;
   MJGlobal.Instance.RaiseEvent(mje);
+}
+
+/** @deprecated Use {@link RaiseEvent}. */
+export async function raiseEvent(type: MJServerEvent['type'], dataSources: DataSourceInfo[], userPayload: UserPayload, component?: any) {
+  return RaiseEvent(type, dataSources, userPayload, component);
 }

package/src/util.ts

@@ -23,7 +23,7 @@ type StreamCallback = (jsonObject: any) => void;
  * @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[]> {
+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);
@@ -144,6 +144,11 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
   );
 }
 
+/** @deprecated Use {@link SendPostRequest}. */
+export async function sendPostRequest(url: string, payload: any, useCompression: boolean, headers: Record<string, string> | null, streamCallback?: StreamCallback): Promise<any[]> {
+  return SendPostRequest(url, payload, useCompression, headers, streamCallback);
+}
+
 
   /**
    * 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.
@@ -154,23 +159,26 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
   export function GetReadOnlyDataSource(dataSources: DataSourceInfo[], options?: {allowFallbackToReadWrite: boolean}): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
     const readOnlyDataSource = dataSources.find((ds) => ds.type === 'Read-Only');
     if (readOnlyDataSource) {
-      return extendConnectionPoolWithQuery(readOnlyDataSource.dataSource);
+      return ExtendConnectionPoolWithQuery(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 extendConnectionPoolWithQuery(readWriteDataSource.dataSource);
+        return ExtendConnectionPoolWithQuery(readWriteDataSource.dataSource);
       }
     }
     throw new Error('No suitable data source found');
   }
 
   /**
-   * Returns the read-only provider if it exists, otherwise returns the original provider if options is not provided or if options.allowFallbackToReadWrite is true.
-   * @param options 
-   * @returns 
+   * Returns the read-only provider if one is configured. Otherwise returns the first (read-write)
+   * provider ONLY when `options.allowFallbackToReadWrite` is true, and `null` when it is omitted.
+   *
+   * The read-only pool exists only when `dbReadOnlyUsername`/`dbReadOnlyPassword` are set, which
+   * most deployments leave unset — so a caller that omits the flag gets `null` on those servers.
+   * Pass it for any pure read.
    */
   export function GetReadOnlyProvider(providers: Array<ProviderInfo>, options?: {allowFallbackToReadWrite: boolean}): DatabaseProviderBase {
     if (!providers || providers.length === 0) 
@@ -217,7 +225,7 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
   export function GetReadWriteDataSource(dataSources: DataSourceInfo[]): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
     const readWriteDataSource = dataSources.find((ds) => ds.type === 'Read-Write');
     if (readWriteDataSource) {
-      return extendConnectionPoolWithQuery(readWriteDataSource.dataSource);
+      return ExtendConnectionPoolWithQuery(readWriteDataSource.dataSource);
     }
     throw new Error('No suitable read-write data source found');
   }
@@ -226,7 +234,7 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
    * Extends a ConnectionPool with a query method that returns results in the format expected by generated code
    * This provides backwards compatibility with code that expects TypeORM-style query results
    */
-  export function extendConnectionPoolWithQuery(pool: sql.ConnectionPool): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
+  export function ExtendConnectionPoolWithQuery(pool: sql.ConnectionPool): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
     const extendedPool = pool as any;
     extendedPool.query = async (sqlQuery: string, parameters?: any): Promise<any[]> => {
       const request = new sql.Request(pool);
@@ -245,4 +253,9 @@ export async function sendPostRequest(url: string, payload: any, useCompression:
       return result.recordset || [];
     };
     return extendedPool;
-  }
+  }
+
+/** @deprecated Use {@link ExtendConnectionPoolWithQuery}. */
+export function extendConnectionPoolWithQuery(pool: sql.ConnectionPool): sql.ConnectionPool & { query: (sql: string, params?: any) => Promise<any[]> } {
+  return ExtendConnectionPoolWithQuery(pool);
+}