@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/rest/MediaStreamHandler.ts

@@ -23,10 +23,10 @@ import { LogError, Metadata, UserInfo } from '@memberjunction/core';
 import { MJFileEntity } from '@memberjunction/core-entities';
 import { FileStorageEngine } from '@memberjunction/storage';
 import type { FileStorageBase, ByteRange } from '@memberjunction/storage';
-import { getSystemUser } from '../auth/index.js';
+import { GetSystemUser } from '../auth/index.js';
 import { MediaAccessKeyManager } from './MediaAccessKeys.js';
 import { UploadTokenManager } from './UploadTokenManager.js';
-import { parseRange, parseRangeHeaderLoose } from './mediaRange.js';
+import { ParseRange, ParseRangeHeaderLoose } from './mediaRange.js';
 
 /** A located bytes source for a file: the driver + the provider key to read. */
 interface FileBytesSource {
@@ -41,7 +41,7 @@ interface FileBytesSource {
  * - `GET /media/:fileId` and `GET /media/:fileId/:filename` (Range streaming)
  * - `POST /media/upload-stage` (Raw binary upload staging)
  */
-export function createMediaStreamRouter(): Router {
+export function CreateMediaStreamRouter(): Router {
   const router = express.Router();
 
   router.post(
@@ -61,6 +61,11 @@ export function createMediaStreamRouter(): Router {
   return router;
 }
 
+/** @deprecated Use {@link CreateMediaStreamRouter}. */
+export function createMediaStreamRouter(): Router {
+  return CreateMediaStreamRouter();
+}
+
 /**
  * Authenticated raw binary upload staging handler (`POST /media/upload-stage`).
  *
@@ -203,7 +208,7 @@ function verifyMediaToken(token: string, fileId: string): { fileId: string; user
  * provider indistinguishable from a deleted file.
  */
 async function resolveFileBytesSource(fileId: string): Promise<FileBytesSource | null> {
-  const systemUser: UserInfo = await getSystemUser();
+  const systemUser: UserInfo = await GetSystemUser();
 
   // The /media route runs pre-auth on the server's own provider; access was already authorized
   // at token-mint time, so this load only locates the bytes.
@@ -261,7 +266,7 @@ async function streamOrBuffer(req: Request, res: Response, source: FileBytesSour
 
 /** True-streaming path: `GetObjectStream` + pipe, with 206 when a Range was honored. */
 async function serveViaStream(res: Response, source: FileBytesSource, rangeHeader: string | undefined): Promise<void> {
-  const range = rangeHeader ? parseRangeHeaderLoose(rangeHeader) : undefined;
+  const range = rangeHeader ? ParseRangeHeaderLoose(rangeHeader) : undefined;
   // Omit End for an open-ended range so the driver streams to EOF (per ByteRange semantics).
   const streamRange: ByteRange | undefined = range
     ? (range.end == null ? { Start: range.start } : { Start: range.start, End: range.end })
@@ -315,7 +320,7 @@ async function serveViaBuffer(res: Response, source: FileBytesSource, rangeHeade
     return;
   }
 
-  const range = parseRange(rangeHeader, total);
+  const range = ParseRange(rangeHeader, total);
   if (!range) {
     // Unsatisfiable range — per RFC 7233, 416 + Content-Range with the total size.
     res.setHeader('Content-Range', `bytes */${total}`);

package/src/rest/OAuthCallbackHandler.ts

@@ -33,11 +33,11 @@ const ENTITY_OAUTH_AUTHORIZATION_STATES = 'MJ: O Auth Authorization States';
  */
 export interface OAuthCallbackHandlerOptions {
     /** Base URL for this MJAPI instance (for redirects) */
-    publicUrl: string;
+    publicUrl: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /** URL to redirect to after successful authorization */
-    successRedirectUrl?: string;
+    successRedirectUrl?: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /** URL to redirect to after failed authorization */
-    errorRedirectUrl?: string;
+    errorRedirectUrl?: string;  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
     /**
      * Origins a caller-supplied `frontendReturnUrl` is allowed to point at, so the OAuth callback
      * cannot be turned into an open redirect from the trusted MJAPI origin. Normally wired to
@@ -54,7 +54,7 @@ export interface OAuthCallbackHandlerOptions {
      * dependency on configuration loading — importing the config module validates the whole config
      * as a side effect, which makes this handler unimportable in any context without one.
      */
-    allowedFrontendOrigins: string[];
+    allowedFrontendOrigins: string[];  // case-violation-ok-legacy-back-compat: renaming it broke a use the checker could not see from the declaration — the compile proved it
 }
 
 /**
@@ -863,16 +863,26 @@ export class OAuthCallbackHandler {
     /**
      * Gets the router for unauthenticated callback endpoint.
      */
-    public getCallbackRouter(): express.Router {
+    public GetCallbackRouter(): express.Router {
         return this.callbackRouter;
     }
 
+    /** @deprecated Use {@link GetCallbackRouter}. */
+    public getCallbackRouter(): express.Router {
+        return this.GetCallbackRouter();
+    }
+
     /**
      * Gets the router for authenticated OAuth endpoints.
      */
-    public getAuthenticatedRouter(): express.Router {
+    public GetAuthenticatedRouter(): express.Router {
         return this.authenticatedRouter;
     }
+
+    /** @deprecated Use {@link GetAuthenticatedRouter}. */
+    public getAuthenticatedRouter(): express.Router {
+        return this.GetAuthenticatedRouter();
+    }
 }
 
 /**
@@ -881,7 +891,7 @@ export class OAuthCallbackHandler {
  * @param options - Handler configuration
  * @returns Object with callback and authenticated routers
  */
-export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
+export function CreateOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
     callbackRouter: express.Router;
     authenticatedRouter: express.Router;
 } {
@@ -891,3 +901,11 @@ export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions)
         authenticatedRouter: handler.getAuthenticatedRouter()
     };
 }
+
+/** @deprecated Use {@link CreateOAuthCallbackHandler}. */
+export function createOAuthCallbackHandler(options: OAuthCallbackHandlerOptions): {
+    callbackRouter: express.Router;
+    authenticatedRouter: express.Router;
+} {
+    return CreateOAuthCallbackHandler(options);
+}

package/src/rest/RESTEndpointHandler.ts

@@ -16,7 +16,7 @@ export interface RESTEndpointHandlerOptions {
      * 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[];
     
     /**
      * Array of entity names to exclude from the API (case-insensitive)
@@ -24,20 +24,20 @@ export interface RESTEndpointHandlerOptions {
      * Supports wildcards using '*' (e.g., 'Secret*' matches 'Secret', 'SecretKey', etc.)
      * Note: Exclude patterns always override include patterns
      */
-    excludeEntities?: string[];
+    ExcludeEntities?: string[];
     
     /**
      * 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[];
     
     /**
      * 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[];
 }
 
 /**
@@ -85,21 +85,21 @@ export class RESTEndpointHandler {
         const schemaName = entity.SchemaName.toLowerCase();
         
         // 1. Check schema exclusions first (these take highest precedence)
-        if (this.options.excludeSchemas && this.options.excludeSchemas.length > 0) {
-            if (this.options.excludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
+        if (this.options.ExcludeSchemas && this.options.ExcludeSchemas.length > 0) {
+            if (this.options.ExcludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
                 return false;
             }
         }
         
         // 2. Check entity exclusions next (these override entity inclusions)
-        if (this.options.excludeEntities && this.options.excludeEntities.length > 0) {
+        if (this.options.ExcludeEntities && this.options.ExcludeEntities.length > 0) {
             // Check for direct match
-            if (this.options.excludeEntities.includes(name)) {
+            if (this.options.ExcludeEntities.includes(name)) {
                 return false;
             }
             
             // Check for wildcard matches
-            for (const pattern of this.options.excludeEntities) {
+            for (const pattern of this.options.ExcludeEntities) {
                 if (pattern.includes('*')) {
                     const regex = new RegExp('^' + pattern.toLowerCase().replace(/\*/g, '.*') + '$');
                     if (regex.test(name)) {
@@ -110,21 +110,21 @@ export class RESTEndpointHandler {
         }
         
         // 3. Check schema inclusions (if specified, only entities from these schemas are allowed)
-        if (this.options.includeSchemas && this.options.includeSchemas.length > 0) {
-            if (!this.options.includeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
+        if (this.options.IncludeSchemas && this.options.IncludeSchemas.length > 0) {
+            if (!this.options.IncludeSchemas.some(schema => schema.toLowerCase() === schemaName)) {
                 return false;
             }
         }
         
         // 4. Check entity inclusions
-        if (this.options.includeEntities && this.options.includeEntities.length > 0) {
+        if (this.options.IncludeEntities && this.options.IncludeEntities.length > 0) {
             // Check for direct match
-            if (this.options.includeEntities.includes(name)) {
+            if (this.options.IncludeEntities.includes(name)) {
                 return true;
             }
             
             // Check for wildcard matches
-            for (const pattern of this.options.includeEntities) {
+            for (const pattern of this.options.IncludeEntities) {
                 if (pattern.includes('*')) {
                     const regex = new RegExp('^' + pattern.toLowerCase().replace(/\*/g, '.*') + '$');
                     if (regex.test(name)) {
@@ -804,7 +804,12 @@ export class RESTEndpointHandler {
     /**
      * Get the Express router with all configured routes
      */
-    public getRouter(): express.Router {
+    public GetRouter(): express.Router {
         return this.router;
     }
+
+    /** @deprecated Use {@link GetRouter}. */
+    public getRouter(): express.Router {
+        return this.GetRouter();
+    }
 }

package/src/rest/RealtimeSdpBrokerHandler.ts

@@ -8,7 +8,7 @@ import { LogError, LogStatus } from '@memberjunction/core';
  * BEFORE any request body parsing occurs. This prevents anonymous/unauthorized callers
  * from causing body-parser memory allocations.
  */
-export function requireTicket(req: Request, res: Response, next: NextFunction): void {
+export function RequireTicket(req: Request, res: Response, next: NextFunction): void {
     const ticketId = (req.query['ticket'] as string) || '';
     if (!ticketId) {
         res.status(401).json({ error: 'Unauthorized: missing ticket' });
@@ -26,6 +26,11 @@ export function requireTicket(req: Request, res: Response, next: NextFunction):
     next();
 }
 
+/** @deprecated Use {@link RequireTicket}. */
+export function requireTicket(req: Request, res: Response, next: NextFunction): void {
+    return RequireTicket(req, res, next);
+}
+
 /**
  * Builds the Express router handling the Realtime WebRTC SDP exchange:
  * `POST /realtime/sdp-exchange?ticket=<ticketId>`
@@ -36,12 +41,12 @@ export function requireTicket(req: Request, res: Response, next: NextFunction):
  * BEFORE body parsing, delegates to `driver.ExchangeWebRtcSdp` to exchange the SDP offer for an
  * answer with upstream using the server's API key, and returns the answer SDP.
  */
-export function createRealtimeSdpBrokerRouter(): Router {
+export function CreateRealtimeSdpBrokerRouter(): Router {
     const router = express.Router();
 
     router.post(
         '/',
-        requireTicket,
+        RequireTicket,
         express.json({ limit: '2mb' }),
         async (req: Request, res: Response): Promise<void> => {
             const entry = res.locals.ticketEntry as RealtimeProxyTicketEntry;
@@ -95,7 +100,12 @@ export function createRealtimeSdpBrokerRouter(): Router {
     return router;
 }
 
+/** @deprecated Use {@link CreateRealtimeSdpBrokerRouter}. */
+export function createRealtimeSdpBrokerRouter(): Router {
+    return CreateRealtimeSdpBrokerRouter();
+}
+
 /**
  * @deprecated Use `createRealtimeSdpBrokerRouter` instead.
  */
-export const createOpenAILiveBrokerRouter = createRealtimeSdpBrokerRouter;
+export const createOpenAILiveBrokerRouter = CreateRealtimeSdpBrokerRouter;

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);
+}