@memberjunction/server 6.2.0-edge.0 → 6.2.0-edge.1

package/src/rest/SignatureWebhookHandler.ts

@@ -21,7 +21,7 @@ import { SignatureEngine } from '@memberjunction/esignature/server';
  * Build an Express router exposing the eSignature webhook. Mount it unauthenticated:
  * `app.use('/esignature', createSignatureWebhookHandler())`.
  */
-export function createSignatureWebhookHandler(): express.Router {
+export function CreateSignatureWebhookHandler(): express.Router {
     const router = express.Router();
 
     // Capture the raw body so drivers that HMAC-verify over the exact bytes can do so.
@@ -36,6 +36,11 @@ export function createSignatureWebhookHandler(): express.Router {
     return router;
 }
 
+/** @deprecated Use {@link CreateSignatureWebhookHandler}. */
+export function createSignatureWebhookHandler(): express.Router {
+    return CreateSignatureWebhookHandler();
+}
+
 /** Stash the raw request bytes on the request for signature verification by the driver. */
 function captureRawBody(req: express.Request, _res: express.Response, buf: Buffer): void {
     (req as RawBodyRequest).rawBody = buf;

package/src/rest/UploadTokenManager.ts

@@ -22,15 +22,15 @@ import { randomBytes } from 'node:crypto';
  * An ephemeral in-memory staged upload record.
  */
 export interface StagedUploadEntry {
-  token: string;
-  buffer: Buffer;
-  fileName: string;
-  mimeType: string;
-  contentLength: number;
-  userId: string;
-  createdAt: number;
-  expiresAt: number;
-  timer: NodeJS.Timeout;
+  token: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  Buffer: Buffer;
+  fileName: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  mimeType: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  ContentLength: number;
+  userId: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  CreatedAt: number;
+  expiresAt: number;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  Timer: NodeJS.Timeout;
 }
 
 /**
@@ -47,10 +47,46 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
   private readonly _staged = new Map<string, StagedUploadEntry>();
   private _totalMemoryBytes = 0;
 
-  public defaultTtlSeconds = 300; // 5 minutes
-  public maxFileSizeBytes = 100 * 1024 * 1024; // 100 MB
-  public maxUserMemoryBytes = 150 * 1024 * 1024; // 150 MB per user
-  public maxPoolMemoryBytes = 500 * 1024 * 1024; // 500 MB
+  public DefaultTtlSeconds = 300;
+
+  /** @deprecated Use {@link DefaultTtlSeconds}. */
+  public get defaultTtlSeconds() {
+    return this.DefaultTtlSeconds;
+  }
+  /** @deprecated Use {@link DefaultTtlSeconds}. */
+  public set defaultTtlSeconds(value) {
+    this.DefaultTtlSeconds = value;
+  } // 5 minutes
+  public MaxFileSizeBytes = 100 * 1024 * 1024;
+
+  /** @deprecated Use {@link MaxFileSizeBytes}. */
+  public get maxFileSizeBytes() {
+    return this.MaxFileSizeBytes;
+  }
+  /** @deprecated Use {@link MaxFileSizeBytes}. */
+  public set maxFileSizeBytes(value) {
+    this.MaxFileSizeBytes = value;
+  } // 100 MB
+  public MaxUserMemoryBytes = 150 * 1024 * 1024;
+
+  /** @deprecated Use {@link MaxUserMemoryBytes}. */
+  public get maxUserMemoryBytes() {
+    return this.MaxUserMemoryBytes;
+  }
+  /** @deprecated Use {@link MaxUserMemoryBytes}. */
+  public set maxUserMemoryBytes(value) {
+    this.MaxUserMemoryBytes = value;
+  } // 150 MB per user
+  public MaxPoolMemoryBytes = 500 * 1024 * 1024;
+
+  /** @deprecated Use {@link MaxPoolMemoryBytes}. */
+  public get maxPoolMemoryBytes() {
+    return this.MaxPoolMemoryBytes;
+  }
+  /** @deprecated Use {@link MaxPoolMemoryBytes}. */
+  public set maxPoolMemoryBytes(value) {
+    this.MaxPoolMemoryBytes = value;
+  } // 500 MB
 
   // Public constructor required by BaseSingleton
   public constructor() {
@@ -68,7 +104,7 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
     let total = 0;
     for (const entry of this._staged.values()) {
       if (UUIDsEqual(entry.userId, userId)) {
-        total += entry.contentLength;
+        total += entry.ContentLength;
       }
     }
     return total;
@@ -88,27 +124,27 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
   }): string {
     const size = params.buffer.length;
 
-    if (size > this.maxFileSizeBytes) {
+    if (size > this.MaxFileSizeBytes) {
       throw new Error(
-        `Staged upload exceeds maximum allowed file size of ${Math.round(this.maxFileSizeBytes / (1024 * 1024))}MB (received ${Math.round(size / (1024 * 1024))}MB).`
+        `Staged upload exceeds maximum allowed file size of ${Math.round(this.MaxFileSizeBytes / (1024 * 1024))}MB (received ${Math.round(size / (1024 * 1024))}MB).`
       );
     }
 
     const userCurrentBytes = this.GetUserMemoryBytes(params.userId);
-    if (userCurrentBytes + size > this.maxUserMemoryBytes) {
+    if (userCurrentBytes + size > this.MaxUserMemoryBytes) {
       throw new Error(
-        `Per-user upload memory quota reached (${Math.round(userCurrentBytes / (1024 * 1024))}MB / ${Math.round(this.maxUserMemoryBytes / (1024 * 1024))}MB used). Please wait for active uploads to finalize.`
+        `Per-user upload memory quota reached (${Math.round(userCurrentBytes / (1024 * 1024))}MB / ${Math.round(this.MaxUserMemoryBytes / (1024 * 1024))}MB used). Please wait for active uploads to finalize.`
       );
     }
 
-    if (this._totalMemoryBytes + size > this.maxPoolMemoryBytes) {
+    if (this._totalMemoryBytes + size > this.MaxPoolMemoryBytes) {
       throw new Error(
-        `Staged upload memory capacity reached (${Math.round(this._totalMemoryBytes / (1024 * 1024))}MB / ${Math.round(this.maxPoolMemoryBytes / (1024 * 1024))}MB used). Please try again shortly.`
+        `Staged upload memory capacity reached (${Math.round(this._totalMemoryBytes / (1024 * 1024))}MB / ${Math.round(this.MaxPoolMemoryBytes / (1024 * 1024))}MB used). Please try again shortly.`
       );
     }
 
     const token = 'upt_' + randomBytes(32).toString('hex');
-    const ttl = params.ttlSeconds || this.defaultTtlSeconds;
+    const ttl = params.ttlSeconds || this.DefaultTtlSeconds;
     const now = Date.now();
     const expiresAt = now + ttl * 1000;
 
@@ -123,14 +159,14 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
 
     const entry: StagedUploadEntry = {
       token,
-      buffer: params.buffer,
+      Buffer: params.buffer,
       fileName: params.fileName,
       mimeType: params.mimeType,
-      contentLength: size,
+      ContentLength: size,
       userId: params.userId,
-      createdAt: now,
+      CreatedAt: now,
       expiresAt,
-      timer,
+      Timer: timer,
     };
 
     this._staged.set(token, entry);
@@ -168,10 +204,10 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
     this.Evict(token);
 
     return {
-      buffer: entry.buffer,
+      buffer: entry.Buffer,
       fileName: entry.fileName,
       mimeType: entry.mimeType,
-      contentLength: entry.contentLength,
+      contentLength: entry.ContentLength,
     };
   }
 
@@ -184,9 +220,9 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
       return false;
     }
 
-    clearTimeout(entry.timer);
+    clearTimeout(entry.Timer);
     this._staged.delete(token);
-    this._totalMemoryBytes = Math.max(0, this._totalMemoryBytes - entry.contentLength);
+    this._totalMemoryBytes = Math.max(0, this._totalMemoryBytes - entry.ContentLength);
     return true;
   }
 
@@ -203,7 +239,7 @@ export class UploadTokenManager extends BaseSingleton<UploadTokenManager> {
   /** Clears all active staged uploads. */
   public Clear(): void {
     for (const [, entry] of this._staged) {
-      clearTimeout(entry.timer);
+      clearTimeout(entry.Timer);
     }
     this._staged.clear();
     this._totalMemoryBytes = 0;

package/src/rest/ViewOperationsHandler.ts

@@ -11,7 +11,7 @@ export class ViewOperationsHandler {
     /**
      * Run a view and return results
      */
-    static async runView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean, result?: RunViewResult, error?: string }> {
+    static async RunView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean, result?: RunViewResult, error?: string }> {
         try {
             // Validate entity exists
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -45,11 +45,16 @@ export class ViewOperationsHandler {
             return { success: false, error: (error as Error)?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link RunView}. */
+    static async runView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean, result?: RunViewResult, error?: string }> {
+        return this.RunView(params, user);
+    }
     
     /**
      * Run multiple views in batch
      */
-    static async runViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
+    static async RunViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
         try {
             // Validate and sanitize each set of parameters
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -86,11 +91,16 @@ export class ViewOperationsHandler {
             return { success: false, error: (error as Error)?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link RunViews}. */
+    static async runViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
+        return this.RunViews(paramsArray, user);
+    }
     
     /**
      * List entities with optional filtering
      */
-    static async listEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
+    static async ListEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
         try {
             // Check entity exists and user has permission
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -115,11 +125,16 @@ export class ViewOperationsHandler {
             throw error;
         }
     }
+
+    /** @deprecated Use {@link ListEntities}. */
+    static async listEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
+        return this.ListEntities(params, user);
+    }
     
     /**
      * Get available views for an entity
      */
-    static async getEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean, views?: any[], error?: string }> {
+    static async GetEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean, views?: any[], error?: string }> {
         try {
             // Validate entity exists
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -171,6 +186,11 @@ export class ViewOperationsHandler {
             return { success: false, error: (error as Error)?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link GetEntityViews}. */
+    static async getEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean, views?: any[], error?: string }> {
+        return this.GetEntityViews(entityName, user);
+    }
     
     /**
      * Sanitize and validate RunViewParams

package/src/rest/mediaRange.ts

@@ -15,8 +15,8 @@
 
 /** A parsed, validated `Range` request against a known total size. */
 export interface ParsedRange {
-  start: number;
-  end: number;
+  start: number;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  end: number;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
 }
 
 /**
@@ -24,8 +24,8 @@ export interface ParsedRange {
  * for an open-ended `bytes=start-` request, matching `ByteRange`'s "omit End = EOF".
  */
 export interface ParsedOpenRange {
-  start: number;
-  end?: number;
+  start: number;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+  end?: number;  // case-violation-ok-legacy-back-compat: optional, and the old name is also read off a value the checker cannot type; renaming it stays assignable and silently yields undefined
 }
 
 /**
@@ -34,7 +34,7 @@ export interface ParsedOpenRange {
  * suffix-only (those we leave to the driver as a full read). `end` is left undefined when
  * open-ended (`bytes=start-`) so the driver streams to EOF.
  */
-export function parseRangeHeaderLoose(rangeHeader: string): ParsedOpenRange | undefined {
+export function ParseRangeHeaderLoose(rangeHeader: string): ParsedOpenRange | undefined {
   const match = /^bytes=(\d+)-(\d*)$/.exec(rangeHeader.trim());
   if (!match) {
     return undefined;
@@ -53,12 +53,17 @@ export function parseRangeHeaderLoose(rangeHeader: string): ParsedOpenRange | un
   return { start, end };
 }
 
+/** @deprecated Use {@link ParseRangeHeaderLoose}. */
+export function parseRangeHeaderLoose(rangeHeader: string): ParsedOpenRange | undefined {
+  return ParseRangeHeaderLoose(rangeHeader);
+}
+
 /**
  * Parses a single-range `bytes=start-end` header against a known total (buffer path),
  * clamping `end` to the last byte. Returns undefined when unsatisfiable (→ 416) or
  * malformed/multi-range.
  */
-export function parseRange(rangeHeader: string, total: number): ParsedRange | undefined {
+export function ParseRange(rangeHeader: string, total: number): ParsedRange | undefined {
   const match = /^bytes=(\d+)-(\d*)$/.exec(rangeHeader.trim());
   if (!match) {
     return undefined;
@@ -74,3 +79,8 @@ export function parseRange(rangeHeader: string, total: number): ParsedRange | un
   }
   return { start, end };
 }
+
+/** @deprecated Use {@link ParseRange}. */
+export function parseRange(rangeHeader: string, total: number): ParsedRange | undefined {
+  return ParseRange(rangeHeader, total);
+}

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/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,14 +159,14 @@ 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');
@@ -220,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');
   }
@@ -229,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);
@@ -248,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);
+}