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

package/src/resolvers/__tests__/MergeRecordsResolver.test.ts

@@ -0,0 +1,93 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import { CompositeKey, KeyValuePair, RecordDependency, type IMetadataProvider } from '@memberjunction/core';
+import type { AppContext } from '../../types.js';
+import type { PubSubEngine } from 'type-graphql';
+
+vi.mock('../../util.js', () => ({
+  GetReadOnlyProvider: vi.fn(),
+  GetReadWriteProvider: vi.fn(),
+}));
+
+import { GetReadOnlyProvider } from '../../util.js';
+import { RecordDependencyResolver, RecordDependencyResult } from '../MergeRecordsResolver.js';
+
+describe('RecordDependencyResolver', () => {
+  it('returns PrimaryKey, IsSoftLink, and EntityIDFieldName from metadata provider', async () => {
+    const mockDep: RecordDependency = {
+      EntityName: 'Users',
+      RelatedEntityName: 'RecordChanges',
+      FieldName: 'RecordID',
+      PrimaryKey: new CompositeKey([new KeyValuePair('ID', 'CHG-100')]),
+      IsSoftLink: true,
+      EntityIDFieldName: 'EntityID',
+    };
+
+    const mockProvider = {
+      GetRecordDependencies: vi.fn().mockResolvedValue([mockDep]),
+    } as unknown as IMetadataProvider;
+
+    vi.mocked(GetReadOnlyProvider).mockReturnValue(mockProvider);
+
+    const resolver = new RecordDependencyResolver();
+    const mockContext = {
+      dataSource: {},
+      userPayload: {},
+      providers: [],
+    } as unknown as AppContext;
+    const mockPubSub = {} as PubSubEngine;
+
+    const result = await resolver.GetRecordDependencies(
+      'Users',
+      { KeyValuePairs: [{ FieldName: 'ID', Value: 'USER-1' }] },
+      mockContext,
+      mockPubSub
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0].EntityName).toBe('Users');
+    expect(result[0].RelatedEntityName).toBe('RecordChanges');
+    expect(result[0].FieldName).toBe('RecordID');
+    expect(result[0].PrimaryKey).toBe(mockDep.PrimaryKey);
+    expect(result[0].IsSoftLink).toBe(true);
+    expect(result[0].EntityIDFieldName).toBe('EntityID');
+
+    // The pre-6.2 name stays as a deprecated alias for one release, so older clients keep working
+    expect(result[0].CompositeKey).toBe(mockDep.PrimaryKey);
+  });
+
+  it('handles hard foreign key dependencies with undefined soft-link flags', async () => {
+    const mockDep: RecordDependency = {
+      EntityName: 'Customers',
+      RelatedEntityName: 'Orders',
+      FieldName: 'CustomerID',
+      PrimaryKey: new CompositeKey([new KeyValuePair('ID', 'ORD-555')]),
+    };
+
+    const mockProvider = {
+      GetRecordDependencies: vi.fn().mockResolvedValue([mockDep]),
+    } as unknown as IMetadataProvider;
+
+    vi.mocked(GetReadOnlyProvider).mockReturnValue(mockProvider);
+
+    const resolver = new RecordDependencyResolver();
+    const mockContext = {
+      dataSource: {},
+      userPayload: {},
+      providers: [],
+    } as unknown as AppContext;
+    const mockPubSub = {} as PubSubEngine;
+
+    const result = await resolver.GetRecordDependencies(
+      'Customers',
+      { KeyValuePairs: [{ FieldName: 'ID', Value: 'CUST-1' }] },
+      mockContext,
+      mockPubSub
+    );
+
+    expect(result).toHaveLength(1);
+    expect(result[0].PrimaryKey).toBe(mockDep.PrimaryKey);
+    expect(result[0].IsSoftLink).toBeUndefined();
+    expect(result[0].EntityIDFieldName).toBeUndefined();
+  });
+});

package/src/resolvers/__tests__/artifact-routing.test.ts

@@ -2,14 +2,14 @@ import { describe, it, expect, vi } from 'vitest';
 import { RouteArtifact, type ArtifactRoutingInput } from '../artifact-routing';
 
 const baseInput = (overrides: Partial<ArtifactRoutingInput> = {}): ArtifactRoutingInput => ({
-    typeDefault: 'Inline',
-    forceToolsOnly: false,
+    TypeDefault: 'Inline',
+    ForceToolsOnly: false,
     mimeType: 'image/png',
-    sizeBytes: 5_000,
-    inlineSizeCap: 100 * 1024,
-    modelSupportsModality: () => true,
-    modelName: 'TestModel',
-    artifactTypeName: 'Image',
+    SizeBytes: 5_000,
+    InlineSizeCap: 100 * 1024,
+    ModelSupportsModality: () => true,
+    ModelName: 'TestModel',
+    ArtifactTypeName: 'Image',
     ...overrides,
 });
 
@@ -20,18 +20,18 @@ describe('RouteArtifact', () => {
     });
 
     it('routes ToolsOnly type default to tools', () => {
-        const result = RouteArtifact(baseInput({ typeDefault: 'ToolsOnly' }));
+        const result = RouteArtifact(baseInput({ TypeDefault: 'ToolsOnly' }));
         expect(result).toEqual({ delivery: 'tools' });
     });
 
     it('routes ForceToolsOnly per-instance override to tools regardless of type default', () => {
-        const result = RouteArtifact(baseInput({ forceToolsOnly: true }));
+        const result = RouteArtifact(baseInput({ ForceToolsOnly: true }));
         expect(result).toEqual({ delivery: 'tools' });
     });
 
     it('returns an error when the model lacks modality support for an Inline type', () => {
         const result = RouteArtifact(baseInput({
-            modelSupportsModality: () => false,
+            ModelSupportsModality: () => false,
         }));
         expect(result.delivery).toBe('error');
         if (result.delivery !== 'error') return;
@@ -46,22 +46,22 @@ describe('RouteArtifact', () => {
 
     it('falls back to tools with annotation when size exceeds the cap', () => {
         const result = RouteArtifact(baseInput({
-            sizeBytes: 200 * 1024,
-            inlineSizeCap: 100 * 1024,
+            SizeBytes: 200 * 1024,
+            InlineSizeCap: 100 * 1024,
         }));
         expect(result.delivery).toBe('tools');
         if (result.delivery !== 'tools') return;
-        expect(result.annotation).toBeDefined();
-        expect(result.annotation).toMatch(/exceeds the inline cap/);
-        expect(result.annotation).toContain('204800');
-        expect(result.annotation).toContain('102400');
+        expect(result.Annotation).toBeDefined();
+        expect(result.Annotation).toMatch(/exceeds the inline cap/);
+        expect(result.Annotation).toContain('204800');
+        expect(result.Annotation).toContain('102400');
     });
 
     it('checks ToolsOnly before modality (modality check is irrelevant when type is ToolsOnly)', () => {
         const modelSupportsModality = vi.fn(() => false);
         const result = RouteArtifact(baseInput({
-            typeDefault: 'ToolsOnly',
-            modelSupportsModality,
+            TypeDefault: 'ToolsOnly',
+            ModelSupportsModality: modelSupportsModality,
         }));
         expect(result).toEqual({ delivery: 'tools' });
         expect(modelSupportsModality).not.toHaveBeenCalled();
@@ -69,8 +69,8 @@ describe('RouteArtifact', () => {
 
     it('checks modality before size (modality error wins over size fallback)', () => {
         const result = RouteArtifact(baseInput({
-            modelSupportsModality: () => false,
-            sizeBytes: 200 * 1024,
+            ModelSupportsModality: () => false,
+            SizeBytes: 200 * 1024,
         }));
         expect(result.delivery).toBe('error');
     });
@@ -78,9 +78,9 @@ describe('RouteArtifact', () => {
     it('ForceToolsOnly bypasses both modality and size checks', () => {
         const modelSupportsModality = vi.fn(() => false);
         const result = RouteArtifact(baseInput({
-            forceToolsOnly: true,
-            modelSupportsModality,
-            sizeBytes: 200 * 1024,
+            ForceToolsOnly: true,
+            ModelSupportsModality: modelSupportsModality,
+            SizeBytes: 200 * 1024,
         }));
         expect(result).toEqual({ delivery: 'tools' });
         expect(modelSupportsModality).not.toHaveBeenCalled();

package/src/resolvers/adhoc-query-helpers.ts

@@ -15,7 +15,7 @@
  * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
  *   signal that a `COUNT(*)` is required to know the true total.
  */
-export function exactTotalFromPage(
+export function ExactTotalFromPage(
     startRow: number,
     pageLength: number,
     maxRows: number | null,
@@ -29,13 +29,22 @@ export function exactTotalFromPage(
     return null;
 }
 
+/** @deprecated Use {@link ExactTotalFromPage}. */
+export function exactTotalFromPage(
+    startRow: number,
+    pageLength: number,
+    maxRows: number | null,
+): number | null {
+    return ExactTotalFromPage(startRow, pageLength, maxRows);
+}
+
 /**
  * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
  * falling back to `fallback` when the count is absent, non-numeric, or negative — so
  * an unexpected count shape never yields a misleading total. `fallback` should be a
  * safe lower bound (e.g. `startRow + rowsReturned`).
  */
-export function resolveAdhocTotalRowCount(
+export function ResolveAdhocTotalRowCount(
     countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
     fallback: number,
 ): number {
@@ -48,3 +57,11 @@ export function resolveAdhocTotalRowCount(
     }
     return fallback;
 }
+
+/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
+export function resolveAdhocTotalRowCount(
+    countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
+    fallback: number,
+): number {
+    return ResolveAdhocTotalRowCount(countRows, fallback);
+}

package/src/resolvers/artifact-routing.ts

@@ -12,38 +12,38 @@ export type ArtifactDeliveryMode = 'Inline' | 'ToolsOnly';
 
 export interface ArtifactRoutingInput {
     /** The Artifact Type's DefaultDeliveryMode. */
-    typeDefault: ArtifactDeliveryMode;
+    TypeDefault: ArtifactDeliveryMode;
     /** Per-instance opt-out — `true` forces tools regardless of typeDefault. */
-    forceToolsOnly: boolean;
+    ForceToolsOnly: boolean;
     /** MIME type of the artifact content (e.g. 'image/png'). */
-    mimeType: string;
+    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
     /** Size of the content in bytes. */
-    sizeBytes: number;
+    SizeBytes: number;
     /** Maximum inline size in bytes; over this, even Inline-default artifacts go to tools. */
-    inlineSizeCap: number;
+    InlineSizeCap: number;
     /** Predicate: does the active model driver support the given MIME modality inline? */
-    modelSupportsModality: (mimeType: string) => boolean;
+    ModelSupportsModality: (mimeType: string) => boolean;
     /** Model name used in error messages — never used to make decisions. */
-    modelName: string;
+    ModelName: string;
     /** Artifact type name used in error messages. */
-    artifactTypeName: string;
+    ArtifactTypeName: string;
 }
 
 export type ArtifactRoutingDecision =
-    | { delivery: 'inline' }
-    | { delivery: 'tools'; annotation?: string }
-    | { delivery: 'error'; message: string };
+    | { delivery: 'inline' }  // 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
+    | { delivery: 'tools'; Annotation?: 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
+    | { delivery: 'error'; message: 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
 
 export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecision {
     const {
-        typeDefault,
-        forceToolsOnly,
+        TypeDefault: typeDefault,
+        ForceToolsOnly: forceToolsOnly,
         mimeType,
-        sizeBytes,
-        inlineSizeCap,
-        modelSupportsModality,
-        modelName,
-        artifactTypeName,
+        SizeBytes: sizeBytes,
+        InlineSizeCap: inlineSizeCap,
+        ModelSupportsModality: modelSupportsModality,
+        ModelName: modelName,
+        ArtifactTypeName: artifactTypeName,
     } = input;
 
     // Path 1: ToolsOnly default or per-instance opt-out — always tools.
@@ -71,7 +71,7 @@ export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecis
     if (sizeBytes >= inlineSizeCap) {
         return {
             delivery: 'tools',
-            annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
+            Annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
         };
     }
 

package/src/resolvers/meetingRecordingRegistration.ts

@@ -81,13 +81,13 @@ export interface MeetingRecordingRegistrationConfig {
    * The `MJ: File Storage Providers` id whose accounts target the egress sink (where LiveKit wrote the
    * MP4). Falls back to `process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER`.
    */
-  sinkStorageProviderID?: string;
+  SinkStorageProviderID?: string;
   /**
    * OPTIONAL canonical provider id — when set AND different from the sink, the MP4 is copied into it and
    * the Files row points there (the "copy into Box" option). Falls back to
    * `process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER`. OFF by default.
    */
-  canonicalStorageProviderID?: string;
+  CanonicalStorageProviderID?: string;
 }
 
 /**
@@ -100,7 +100,7 @@ export interface MeetingRecordingRegistrationConfig {
  * @param provider The metadata provider servicing this request.
  * @param config Optional config overrides (otherwise read from env).
  */
-export async function registerMeetingRecordingFile(
+export async function RegisterMeetingRecordingFile(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -115,7 +115,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const sinkProviderID = config?.sinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
+    const sinkProviderID = config?.SinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
     if (!sinkProviderID) {
       return {
         Success: false,
@@ -138,7 +138,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const conversationID = await resolveMeetingConversation(egress, contextUser, provider);
+    const conversationID = await ResolveMeetingConversation(egress, contextUser, provider);
     if (!conversationID) {
       return { Success: false, ErrorMessage: 'Could not resolve or create the Meeting-Room Conversation for the recording.' };
     }
@@ -175,6 +175,16 @@ export async function registerMeetingRecordingFile(
   }
 }
 
+/** @deprecated Use {@link RegisterMeetingRecordingFile}. */
+export async function registerMeetingRecordingFile(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+  config?: MeetingRecordingRegistrationConfig,
+): Promise<MeetingRecordingRegistrationResult> {
+  return RegisterMeetingRecordingFile(egress, contextUser, provider, config);
+}
+
 /**
  * Best-effort correlation when a recording STARTS: stamps `Conversation.EgressID` onto the room's
  * Meeting-Room Conversation (if it already exists) so a live recording is tracked against the room. If the
@@ -187,7 +197,7 @@ export async function registerMeetingRecordingFile(
  * @param provider The metadata provider.
  * @returns `true` when an existing conversation was stamped, else `false`.
  */
-export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+export async function CorrelateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
   try {
     const conversationID = await findConversationByRoomName(roomName, contextUser, provider);
     if (!conversationID) {
@@ -210,12 +220,17 @@ export async function correlateRecordingStart(roomName: string, egressID: string
   }
 }
 
+/** @deprecated Use {@link CorrelateRecordingStart}. */
+export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+  return CorrelateRecordingStart(roomName, egressID, contextUser, provider);
+}
+
 /**
  * Resolves the Meeting-Room Conversation for a completed recording: prefer matching by `EgressID` (set on
  * start), fall back to the room name (`ExternalID` + `Type`), else create one following the transcript
  * sink's pattern (scoped `Application` so it stays out of the normal chat list).
  */
-export async function resolveMeetingConversation(
+export async function ResolveMeetingConversation(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -231,6 +246,15 @@ export async function resolveMeetingConversation(
   return createMeetingConversation(egress.RoomName, contextUser, provider);
 }
 
+/** @deprecated Use {@link ResolveMeetingConversation}. */
+export async function resolveMeetingConversation(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+): Promise<string | null> {
+  return ResolveMeetingConversation(egress, contextUser, provider);
+}
+
 /** Finds a non-archived Meeting-Room Conversation by its `EgressID`. */
 async function findConversationByEgressID(egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<string | null> {
   if (!egressID) {
@@ -310,7 +334,7 @@ async function resolveFileLocation(
   config?: MeetingRecordingRegistrationConfig,
 ): Promise<FileLocationResult> {
   const outputLocation = egress.OutputLocation!;
-  const canonicalProviderID = config?.canonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
+  const canonicalProviderID = config?.CanonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
 
   // Default (v1): point directly at the sink output — playback streams straight from it, no byte copy.
   if (!canonicalProviderID || canonicalProviderID === sinkProviderID) {
@@ -319,7 +343,7 @@ async function resolveFileLocation(
 
   // OPTIONAL "copy into Box": a separate canonical provider IS configured and differs from the sink —
   // read the bytes from the sink and upload them into the canonical provider, then point there.
-  const canonicalKey = await copyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+  const canonicalKey = await CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
   if (!canonicalKey.Success) {
     return { Success: false, ErrorMessage: canonicalKey.ErrorMessage, ProviderID: '', ProviderKey: '' };
   }
@@ -338,7 +362,7 @@ interface CanonicalCopyResult {
  * into Box" option). Reads the bytes via the sink driver's `GetObject({ fullPath })` and re-uploads them
  * into the canonical provider via `FileStorageEngine.UploadFile`. Returns the canonical `ProviderKey`.
  */
-export async function copyEgressOutputToCanonical(
+export async function CopyEgressOutputToCanonical(
   outputLocation: string,
   sinkAccountID: string,
   canonicalProviderID: string,
@@ -369,6 +393,16 @@ export async function copyEgressOutputToCanonical(
   return { Success: true, ProviderKey: uploaded.StoragePath };
 }
 
+/** @deprecated Use {@link CopyEgressOutputToCanonical}. */
+export async function copyEgressOutputToCanonical(
+  outputLocation: string,
+  sinkAccountID: string,
+  canonicalProviderID: string,
+  contextUser: UserInfo,
+): Promise<CanonicalCopyResult> {
+  return CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+}
+
 /** Creates the `MJ: Files` row pointing at the recording (no byte copy in the default v1 path). */
 async function createRecordingFileRow(
   egress: MeetingRecordingEgressResult,

package/src/resolvers/peaksSidecar.ts

@@ -15,7 +15,7 @@
  * @example deriveSidecarPath('realtime-recordings/sess-1/recording.wav') === 'realtime-recordings/sess-1/peaks.json'
  * @example deriveSidecarPath('recording.wav') === 'peaks.json'
  */
-export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+export function DeriveSidecarPath(providerKey: string | null | undefined): string | null {
     if (!providerKey) {
         return null;
     }
@@ -23,6 +23,11 @@ export function deriveSidecarPath(providerKey: string | null | undefined): strin
     return lastSlash >= 0 ? `${providerKey.slice(0, lastSlash)}/peaks.json` : 'peaks.json';
 }
 
+/** @deprecated Use {@link DeriveSidecarPath}. */
+export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+    return DeriveSidecarPath(providerKey);
+}
+
 /** Generous ceiling on the number of peaks returned — matches the capture-side cap. */
 export const MAX_PEAKS = 4096;
 
@@ -35,7 +40,7 @@ export const MAX_PEAKS = 4096;
  * @param bytes The raw sidecar bytes (e.g. from a storage `GetObject`).
  * @returns Sanitized `0..1` peaks, or `undefined`.
  */
-export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+export function ParsePeaksSidecar(bytes: Buffer): number[] | undefined {
     try {
         const parsed: unknown = JSON.parse(bytes.toString('utf8'));
         if (!Array.isArray(parsed) || parsed.length === 0) {
@@ -50,3 +55,8 @@ export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
         return undefined;
     }
 }
+
+/** @deprecated Use {@link ParsePeaksSidecar}. */
+export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+    return ParsePeaksSidecar(bytes);
+}

package/src/rest/EntityCRUDHandler.ts

@@ -11,7 +11,7 @@ export class EntityCRUDHandler {
     /**
      * Create a new entity
      */
-    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async CreateEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -77,11 +77,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link CreateEntity}. */
+    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.CreateEntity(entityName, data, user);
+    }
     
     /**
      * Read an entity by ID
      */
-    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+    static async GetEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -116,11 +121,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link GetEntity}. */
+    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+        return this.GetEntity(entityName, id, relatedEntities, user);
+    }
     
     /**
      * Update an existing entity
      */
-    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async UpdateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -203,11 +213,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link UpdateEntity}. */
+    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.UpdateEntity(entityName, id, data, user);
+    }
     
     /**
      * Delete an entity
      */
-    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+    static async DeleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -252,6 +267,11 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link DeleteEntity}. */
+    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+        return this.DeleteEntity(entityName, id, options, user);
+    }
     
     /**
      * Build the record key from the `:id` path segment. A single-column key (any column name) is

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