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

package/src/__tests__/DuplicateEntryCheckResolver.test.ts

@@ -0,0 +1,300 @@
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/** The slice of `APIKeyEngine.Authorize` that ResolverBase.CheckAPIKeyScopeAuthorization calls. */
+type AuthorizeFn = (
+  apiKeyHash: string,
+  application: string,
+  scopePath: string,
+  resource: string
+) => Promise<{ Allowed: boolean; Reason: string }>;
+
+const { mockAuthorize, mockLogError } = vi.hoisted(() => ({
+  mockAuthorize: vi.fn<AuthorizeFn>(),
+  mockLogError: vi.fn<(message: string) => void>(),
+}));
+
+// As in RunDecisionResolver.test.ts: vitest's esbuild transform does not apply
+// `emitDecoratorMetadata`, so the decorators are no-ops and the resolver runs as a plain class.
+vi.mock('type-graphql', () => {
+  const noopDecorator = () => () => undefined;
+  return {
+    Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, Subscription: noopDecorator,
+    ObjectType: noopDecorator, InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator,
+    Args: noopDecorator, Ctx: noopDecorator, PubSub: noopDecorator, Root: noopDecorator,
+    Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+    createUnionType: () => class {},
+    AuthorizationError: class AuthorizationError extends Error {
+      constructor(message?: string) {
+        super(message);
+        this.name = 'AuthorizationError';
+      }
+    },
+    Float: class {}, Int: class {}, ID: class {},
+  };
+});
+
+// Only logging is replaced, so a test can tell a logged fault from a quiet answer.
+vi.mock('@memberjunction/core', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return { ...actual, LogError: mockLogError };
+});
+
+// Only the API-key engine is replaced; ResolverBase's scope check itself is the production code.
+vi.mock('@memberjunction/api-keys', async (importOriginal) => {
+  const actual = await importOriginal<Record<string, unknown>>();
+  return { ...actual, GetAPIKeyEngine: () => ({ Authorize: mockAuthorize }) };
+});
+
+// The resolver's tests replace the detector through CreateEntryChecker, so the detector package
+// is never exercised here; it has its own specs.
+vi.mock('@memberjunction/ai-vector-dupe', () => ({ DuplicateRecordDetector: class {} }));
+
+import { EntityInfo, Metadata, UserInfo } from '@memberjunction/core';
+import { UserCache } from '@memberjunction/generic-database-provider';
+import type { DuplicateEntryCheckResult } from '@memberjunction/ai-vector-dupe';
+import {
+  DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH,
+  DuplicateEntryCheckResolver,
+  type DuplicateEntryChecker,
+} from '../resolvers/DuplicateEntryCheckResolver.js';
+import type { UserPayload } from '../types.js';
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const USER = new UserInfo(null, {
+  ID: 'user-1',
+  Name: 'Entry Person',
+  Email: 'person@example.com',
+  UserRoles: [{ UserID: 'user-1', RoleID: 'role-ui' }],
+});
+const SYSTEM_USER = new UserInfo(null, { ID: 'user-system', Name: 'System', Email: 'system@example.com' });
+
+/** An entity the user's role may read. */
+const ACCOUNTS = new EntityInfo({
+  ID: 'entity-accounts',
+  Name: 'Accounts',
+  Status: 'Active',
+  Fields: [
+    { Name: 'ID', Type: 'uniqueidentifier', IsPrimaryKey: true },
+    { Name: 'Name', Type: 'nvarchar', IsNameField: true, AllowUpdateAPI: true },
+    { Name: 'City', Type: 'nvarchar', AllowUpdateAPI: true },
+    { Name: 'Owner', Type: 'nvarchar', AllowUpdateAPI: false },
+    { Name: '__mj_CreatedAt', Type: 'datetimeoffset', AllowUpdateAPI: false },
+  ],
+  EntityPermissions: [{ RoleID: 'role-ui', CanRead: true }],
+});
+
+/** An entity only another role may read. */
+const PAYROLL = new EntityInfo({
+  ID: 'entity-payroll',
+  Name: 'Payroll',
+  Status: 'Active',
+  Fields: [{ Name: 'ID', Type: 'uniqueidentifier', IsPrimaryKey: true }],
+  EntityPermissions: [{ RoleID: 'role-finance', CanRead: true }],
+});
+
+const CHECKED: DuplicateEntryCheckResult = {
+  Status: 'Checked',
+  Candidates: [{ RecordID: 'acct-7', DisplayName: 'Acme Corp', VectorScore: 0.93, Probability: 0.81 }],
+  ElapsedMs: 212,
+};
+
+/** A session authenticated by JWT: no API key, so no scope check. */
+const sessionPayload = (): UserPayload => ({ email: USER.Email, userRecord: USER, sessionId: 'session-1' });
+/** A session authenticated by an MJ API key: scope-checked. */
+const apiKeyPayload = (): UserPayload => ({ ...sessionPayload(), apiKeyId: 'key-1', apiKeyHash: 'hash-1' });
+
+/** The resolver with its detector replaced by a double. */
+class TestResolver extends DuplicateEntryCheckResolver {
+  public readonly Checker = { CheckRecordValues: vi.fn<DuplicateEntryChecker['CheckRecordValues']>() };
+
+  protected override CreateEntryChecker(): DuplicateEntryChecker {
+    return this.Checker;
+  }
+}
+
+let resolver: TestResolver;
+
+const check = (entityName: string, valuesJSON: string, payload: UserPayload = sessionPayload()) =>
+  resolver.RunEntryCheck(entityName, valuesJSON, payload, null);
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+  mockAuthorize.mockReset();
+  mockLogError.mockReset();
+  vi.spyOn(Metadata.prototype, 'EntityByName').mockImplementation((name: string) =>
+    [ACCOUNTS, PAYROLL].find(e => e.Name.toLowerCase() === name.trim().toLowerCase())
+  );
+  vi.spyOn(UserCache.prototype, 'GetSystemUser').mockReturnValue(SYSTEM_USER);
+  resolver = new TestResolver();
+  resolver.Checker.CheckRecordValues.mockResolvedValue(CHECKED);
+});
+
+// ─── Authorization ───────────────────────────────────────────────────────────
+
+/** The scope checks made, other than the full_access fast path, as [scope, resource]. */
+const scopeChecks = () => mockAuthorize.mock.calls.filter(call => call[2] !== 'full_access').map(call => [call[2], call[3]]);
+
+describe('CheckDuplicateEntry: authorization', () => {
+  it('answers NotAuthorized, without logging, for a user who cannot read the entity', async () => {
+    const result = await check('Payroll', '{"ID":"x"}');
+
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain('does not have read permissions on Payroll');
+    expect(result.Candidates).toEqual([]);
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+    expect(mockLogError).not.toHaveBeenCalled();
+  });
+
+  it('fails an unknown entity without running the check', async () => {
+    const result = await check('No Such Entity', '{}');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'Entity not found in metadata' });
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('applies the view:run API-key scope for the entity, and a denial is a status', async () => {
+    mockAuthorize.mockResolvedValue({ Allowed: false, Reason: 'scope not granted' });
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts']]);
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain("requires the 'view:run' scope");
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+    expect(mockLogError).not.toHaveBeenCalled();
+  });
+
+  it('also requires prompt:execute, so a read-only key cannot spend on model calls', async () => {
+    mockAuthorize.mockImplementation(async (_hash, _app, scopePath) =>
+      scopePath === 'view:run' ? { Allowed: true, Reason: '' } : { Allowed: false, Reason: 'scope not granted' }
+    );
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts'], ['prompt:execute', '*']]);
+    expect(result.Status).toBe('NotAuthorized');
+    expect(result.ErrorMessage).toContain("requires the 'prompt:execute' scope");
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('runs the check for a key holding both scopes', async () => {
+    mockAuthorize.mockImplementation(async (_hash, _app, scopePath) =>
+      ({ Allowed: scopePath !== 'full_access', Reason: '' })
+    );
+
+    const result = await check('Accounts', '{"Name":"Acme"}', apiKeyPayload());
+
+    expect(scopeChecks()).toEqual([['view:run', 'Accounts'], ['prompt:execute', '*']]);
+    expect(result.Status).toBe('Checked');
+  });
+});
+
+// ─── The values ──────────────────────────────────────────────────────────────
+
+describe('CheckDuplicateEntry: the values', () => {
+  it('returns an error status, not a throw, for values that are not JSON', async () => {
+    const result = await check('Accounts', '{ Name: ');
+
+    expect(result.Status).toBe('Failed');
+    expect(result.ErrorMessage).toMatch(/^valuesJSON is not valid JSON: /);
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('returns an error status for JSON that is not an object', async () => {
+    const result = await check('Accounts', '["Acme"]');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'valuesJSON must be the JSON of an object of field values' });
+  });
+
+  it('ignores the fields the entity does not have, and keys the rest by the real field name', async () => {
+    await check('Accounts', JSON.stringify({ name: 'Acme', City: 'Boston', Revenue: 5, NotAField: 'x' }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme', City: 'Boston' }, USER);
+  });
+
+  it('ignores primary keys, read-only fields and MJ system fields', async () => {
+    await check('Accounts', JSON.stringify({ ID: 'acct-7', Name: 'Acme', Owner: 'someone', __mj_CreatedAt: '2026-01-01' }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme' }, USER);
+  });
+
+  it('accepts strings, numbers, booleans and null', async () => {
+    await check('Accounts', JSON.stringify({ Name: 'Acme', City: null, Revenue: 5, Active: true }));
+
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledWith('Accounts', { Name: 'Acme', City: null }, USER);
+  });
+
+  it.each([
+    ['an array', { Name: ['Acme', 'Corp'] }],
+    ['an object', { Name: { first: 'Acme' } }],
+  ])('refuses a value that is %s', async (_kind, values) => {
+    const result = await check('Accounts', JSON.stringify(values));
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: "valuesJSON field 'Name' must be a string, number, boolean or null" });
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('refuses a value of an unknown field that is not a scalar', async () => {
+    const result = await check('Accounts', JSON.stringify({ Name: 'Acme', Extra: [1, 2, 3] }));
+
+    expect(result.Status).toBe('Failed');
+    expect(resolver.Checker.CheckRecordValues).not.toHaveBeenCalled();
+  });
+
+  it('accepts valuesJSON up to DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH characters and refuses one more', async () => {
+    const padding = DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH - JSON.stringify({ Name: '' }).length;
+    const atLimit = JSON.stringify({ Name: 'x'.repeat(padding) });
+    const overLimit = JSON.stringify({ Name: 'x'.repeat(padding + 1) });
+    expect(atLimit).toHaveLength(DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH);
+
+    expect((await check('Accounts', atLimit)).Status).toBe('Checked');
+    const refused = await check('Accounts', overLimit);
+
+    expect(refused).toMatchObject({
+      Status: 'Failed',
+      ErrorMessage: `valuesJSON is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH + 1} characters; the limit is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH}`,
+    });
+    expect(resolver.Checker.CheckRecordValues).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps the limit to a few KB', () => {
+    expect(DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH).toBeLessThanOrEqual(32 * 1024);
+  });
+});
+
+// ─── The result ──────────────────────────────────────────────────────────────
+
+describe('CheckDuplicateEntry: the result', () => {
+  it('returns the detector result', async () => {
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toEqual({
+      Status: 'Checked',
+      ErrorMessage: undefined,
+      Candidates: [{ RecordID: 'acct-7', DisplayName: 'Acme Corp', VectorScore: 0.93, Probability: 0.81 }],
+      ElapsedMs: 212,
+    });
+  });
+
+  it('passes NotConfigured through', async () => {
+    resolver.Checker.CheckRecordValues.mockResolvedValue({ Status: 'NotConfigured', Candidates: [], ElapsedMs: 3 });
+
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toMatchObject({ Status: 'NotConfigured', Candidates: [] });
+  });
+
+  it('returns Failed, not a throw, when the check throws, and logs it', async () => {
+    resolver.Checker.CheckRecordValues.mockRejectedValue(new Error('vector index unreachable'));
+
+    const result = await check('Accounts', '{"Name":"Acme"}');
+
+    expect(result).toMatchObject({ Status: 'Failed', ErrorMessage: 'vector index unreachable', Candidates: [] });
+    expect(mockLogError).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/FileResolverPeaks.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { deriveSidecarPath, parsePeaksSidecar, MAX_PEAKS } from '../resolvers/peaksSidecar.js';
+import { DeriveSidecarPath, ParsePeaksSidecar, MAX_PEAKS } from '../resolvers/peaksSidecar.js';
 
 /**
  * Tests for the pure `peaks.json` sidecar helpers that back FileResolver.CreateMediaAccessToken's
@@ -14,51 +14,51 @@ import { deriveSidecarPath, parsePeaksSidecar, MAX_PEAKS } from '../resolvers/pe
 
 describe('deriveSidecarPath', () => {
   it('replaces the final path segment with peaks.json (recording in a session folder)', () => {
-    expect(deriveSidecarPath('realtime-recordings/sess-1/recording.wav')).toBe('realtime-recordings/sess-1/peaks.json');
+    expect(DeriveSidecarPath('realtime-recordings/sess-1/recording.wav')).toBe('realtime-recordings/sess-1/peaks.json');
   });
 
   it('uses a bare peaks.json when the key has no folder', () => {
-    expect(deriveSidecarPath('recording.wav')).toBe('peaks.json');
+    expect(DeriveSidecarPath('recording.wav')).toBe('peaks.json');
   });
 
   it('returns null when there is no ProviderKey (cannot derive a folder)', () => {
-    expect(deriveSidecarPath(null)).toBeNull();
-    expect(deriveSidecarPath(undefined)).toBeNull();
-    expect(deriveSidecarPath('')).toBeNull();
+    expect(DeriveSidecarPath(null)).toBeNull();
+    expect(DeriveSidecarPath(undefined)).toBeNull();
+    expect(DeriveSidecarPath('')).toBeNull();
   });
 });
 
 describe('parsePeaksSidecar', () => {
   it('returns sanitized peaks from a valid JSON array (clamped to 0..1)', () => {
     const bytes = Buffer.from(JSON.stringify([0, 0.5, 1, 1.7, -0.3]), 'utf8');
-    expect(parsePeaksSidecar(bytes)).toEqual([0, 0.5, 1, 1, 0]);
+    expect(ParsePeaksSidecar(bytes)).toEqual([0, 0.5, 1, 1, 0]);
   });
 
   it('returns undefined for non-JSON garbage (never throws)', () => {
-    expect(parsePeaksSidecar(Buffer.from('this is not json', 'utf8'))).toBeUndefined();
+    expect(ParsePeaksSidecar(Buffer.from('this is not json', 'utf8'))).toBeUndefined();
   });
 
   it('returns undefined when the JSON is not an array', () => {
-    expect(parsePeaksSidecar(Buffer.from(JSON.stringify({ not: 'an array' }), 'utf8'))).toBeUndefined();
+    expect(ParsePeaksSidecar(Buffer.from(JSON.stringify({ not: 'an array' }), 'utf8'))).toBeUndefined();
   });
 
   it('returns undefined for an empty array', () => {
-    expect(parsePeaksSidecar(Buffer.from('[]', 'utf8'))).toBeUndefined();
+    expect(ParsePeaksSidecar(Buffer.from('[]', 'utf8'))).toBeUndefined();
   });
 
   it('drops non-finite / non-number entries, keeping the finite numbers', () => {
     const bytes = Buffer.from(JSON.stringify([0.2, 'x', null, NaN, 0.8]), 'utf8');
     // NaN serializes to null in JSON; both 'x' and the nulls are dropped, leaving the two numbers.
-    expect(parsePeaksSidecar(bytes)).toEqual([0.2, 0.8]);
+    expect(ParsePeaksSidecar(bytes)).toEqual([0.2, 0.8]);
   });
 
   it('returns undefined when nothing finite survives sanitization', () => {
-    expect(parsePeaksSidecar(Buffer.from(JSON.stringify(['a', 'b', null]), 'utf8'))).toBeUndefined();
+    expect(ParsePeaksSidecar(Buffer.from(JSON.stringify(['a', 'b', null]), 'utf8'))).toBeUndefined();
   });
 
   it('caps the array length at MAX_PEAKS', () => {
     const huge = new Array(MAX_PEAKS + 500).fill(0.5);
-    const result = parsePeaksSidecar(Buffer.from(JSON.stringify(huge), 'utf8'));
+    const result = ParsePeaksSidecar(Buffer.from(JSON.stringify(huge), 'utf8'));
     expect(result).toHaveLength(MAX_PEAKS);
   });
 });

package/src/__tests__/ListOperationsResolver.test.ts

@@ -22,24 +22,24 @@ import type { ApplyResult, ListDelta } from '@memberjunction/lists-base';
 import {
   ApplyDeltaInput,
   ListSourceInput,
-  fromCoreApplyResult,
-  fromCoreDelta,
-  fromCoreWarning,
-  rebuildDeltaFromInput,
-  toCoreSource,
+  FromCoreApplyResult,
+  FromCoreDelta,
+  FromCoreWarning,
+  RebuildDeltaFromInput,
+  ToCoreSource,
 } from '../resolvers/ListOperationsResolver.js';
 
 describe('ListOperationsResolver — boundary converters', () => {
   describe('toCoreSource', () => {
     it('maps a list-kind input to a core ListSource', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'list', ListID: 'list-1' });
-      const result = toCoreSource(input);
+      const result = ToCoreSource(input);
       expect(result).toEqual({ kind: 'list', listId: 'list-1' });
     });
 
     it('maps a view-kind input to a core ListSource', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'view', ViewID: 'view-1' });
-      expect(toCoreSource(input)).toEqual({ kind: 'view', viewId: 'view-1' });
+      expect(ToCoreSource(input)).toEqual({ kind: 'view', viewId: 'view-1' });
     });
 
     it('maps an adhoc-kind input to a core ListSource', () => {
@@ -48,7 +48,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         EntityName: 'Contacts',
         ExtraFilter: "Status='Active'",
       });
-      expect(toCoreSource(input)).toEqual({
+      expect(ToCoreSource(input)).toEqual({
         kind: 'adhoc',
         entityName: 'Contacts',
         extraFilter: "Status='Active'",
@@ -57,22 +57,22 @@ describe('ListOperationsResolver — boundary converters', () => {
 
     it('throws when list-kind input has no ListID', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'list' });
-      expect(() => toCoreSource(input)).toThrow(/ListID is required/);
+      expect(() => ToCoreSource(input)).toThrow(/ListID is required/);
     });
 
     it('throws when view-kind input has no ViewID', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'view' });
-      expect(() => toCoreSource(input)).toThrow(/ViewID is required/);
+      expect(() => ToCoreSource(input)).toThrow(/ViewID is required/);
     });
 
     it('throws when adhoc-kind input lacks EntityName or ExtraFilter', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'adhoc', EntityName: 'X' });
-      expect(() => toCoreSource(input)).toThrow(/EntityName and ExtraFilter/);
+      expect(() => ToCoreSource(input)).toThrow(/EntityName and ExtraFilter/);
     });
 
     it('throws on an unknown discriminator', () => {
       const input = Object.assign(new ListSourceInput(), { Kind: 'mystery' as never });
-      expect(() => toCoreSource(input)).toThrow(/Unknown ListSourceInput\.Kind/);
+      expect(() => ToCoreSource(input)).toThrow(/Unknown ListSourceInput\.Kind/);
     });
   });
 
@@ -90,7 +90,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         ],
         DeltaToken: 'abc.def',
       };
-      const output = fromCoreDelta(delta);
+      const output = FromCoreDelta(delta);
       expect(output).toMatchObject({
         TargetListId: 'list-1',
         EntityName: 'Contacts',
@@ -111,7 +111,7 @@ describe('ListOperationsResolver — boundary converters', () => {
 
   describe('fromCoreWarning', () => {
     it('leaves DetailsJSON undefined when no details supplied', () => {
-      const output = fromCoreWarning({ Code: 'EMPTY_SOURCE', Message: 'No records' });
+      const output = FromCoreWarning({ Code: 'EMPTY_SOURCE', Message: 'No records' });
       expect(output.DetailsJSON).toBeUndefined();
     });
   });
@@ -126,7 +126,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         CreatedListId: 'list-1',
         Counts: { Added: 5, Removed: 2, Failed: 0 },
       };
-      const output = fromCoreApplyResult(result);
+      const output = FromCoreApplyResult(result);
       expect(output).toMatchObject({
         Success: true,
         ResultCode: 'SUCCESS',
@@ -145,7 +145,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         Message: 'partial',
         Errors: ['failed record a'],
       };
-      expect(fromCoreApplyResult(result).Errors).toEqual(['failed record a']);
+      expect(FromCoreApplyResult(result).Errors).toEqual(['failed record a']);
     });
   });
 
@@ -165,7 +165,7 @@ describe('ListOperationsResolver — boundary converters', () => {
         DeltaToken: 'tok',
         ConfirmDrops: true,
       });
-      const out = rebuildDeltaFromInput(input);
+      const out = RebuildDeltaFromInput(input);
       expect(out).toMatchObject({
         TargetListId: 'list-1',
         EntityName: 'Contacts',

package/src/__tests__/MediaStreamHandler.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseRangeHeaderLoose, parseRange } from '../rest/mediaRange.js';
+import { ParseRangeHeaderLoose, ParseRange } from '../rest/mediaRange.js';
 
 /**
  * Tests for the pure HTTP-Range parsing helpers behind the authenticated `/media/:fileId`
@@ -16,34 +16,34 @@ import { parseRangeHeaderLoose, parseRange } from '../rest/mediaRange.js';
 
 describe('parseRangeHeaderLoose (streaming path — no known total)', () => {
     it('parses a closed range bytes=start-end into inclusive offsets', () => {
-        expect(parseRangeHeaderLoose('bytes=0-499')).toEqual({ start: 0, end: 499 });
-        expect(parseRangeHeaderLoose('bytes=200-1023')).toEqual({ start: 200, end: 1023 });
+        expect(ParseRangeHeaderLoose('bytes=0-499')).toEqual({ start: 0, end: 499 });
+        expect(ParseRangeHeaderLoose('bytes=200-1023')).toEqual({ start: 200, end: 1023 });
     });
 
     it('leaves end undefined for an open-ended range bytes=start- (stream to EOF)', () => {
-        expect(parseRangeHeaderLoose('bytes=500-')).toEqual({ start: 500 });
-        expect(parseRangeHeaderLoose('bytes=0-')).toEqual({ start: 0 });
+        expect(ParseRangeHeaderLoose('bytes=500-')).toEqual({ start: 500 });
+        expect(ParseRangeHeaderLoose('bytes=0-')).toEqual({ start: 0 });
     });
 
     it('tolerates surrounding whitespace', () => {
-        expect(parseRangeHeaderLoose('  bytes=10-20  ')).toEqual({ start: 10, end: 20 });
+        expect(ParseRangeHeaderLoose('  bytes=10-20  ')).toEqual({ start: 10, end: 20 });
     });
 
     it('returns undefined when end < start (nonsensical range)', () => {
-        expect(parseRangeHeaderLoose('bytes=500-100')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=500-100')).toBeUndefined();
     });
 
     it('returns undefined for malformed / multi-range / suffix-only headers', () => {
-        expect(parseRangeHeaderLoose('bytes=abc-def')).toBeUndefined();
-        expect(parseRangeHeaderLoose('bytes=-500')).toBeUndefined(); // suffix range — left to a full read
-        expect(parseRangeHeaderLoose('bytes=0-100,200-300')).toBeUndefined(); // multi-range
-        expect(parseRangeHeaderLoose('items=0-100')).toBeUndefined(); // wrong unit
-        expect(parseRangeHeaderLoose('bytes=')).toBeUndefined();
-        expect(parseRangeHeaderLoose('')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=abc-def')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('bytes=-500')).toBeUndefined(); // suffix range — left to a full read
+        expect(ParseRangeHeaderLoose('bytes=0-100,200-300')).toBeUndefined(); // multi-range
+        expect(ParseRangeHeaderLoose('items=0-100')).toBeUndefined(); // wrong unit
+        expect(ParseRangeHeaderLoose('bytes=')).toBeUndefined();
+        expect(ParseRangeHeaderLoose('')).toBeUndefined();
     });
 
     it('accepts a zero-length point range bytes=N-N', () => {
-        expect(parseRangeHeaderLoose('bytes=42-42')).toEqual({ start: 42, end: 42 });
+        expect(ParseRangeHeaderLoose('bytes=42-42')).toEqual({ start: 42, end: 42 });
     });
 });
 
@@ -51,41 +51,41 @@ describe('parseRange (buffer path — known total)', () => {
     const TOTAL = 1000;
 
     it('parses a closed range within bounds', () => {
-        expect(parseRange('bytes=0-499', TOTAL)).toEqual({ start: 0, end: 499 });
+        expect(ParseRange('bytes=0-499', TOTAL)).toEqual({ start: 0, end: 499 });
     });
 
     it('clamps end to the last byte when the requested end exceeds total', () => {
         // bytes=500-99999 against a 1000-byte file → end clamps to 999.
-        expect(parseRange('bytes=500-99999', TOTAL)).toEqual({ start: 500, end: 999 });
+        expect(ParseRange('bytes=500-99999', TOTAL)).toEqual({ start: 500, end: 999 });
     });
 
     it('resolves an open-ended range to the last byte', () => {
-        expect(parseRange('bytes=200-', TOTAL)).toEqual({ start: 200, end: 999 });
+        expect(ParseRange('bytes=200-', TOTAL)).toEqual({ start: 200, end: 999 });
     });
 
     it('returns undefined when start is at or past EOF (unsatisfiable → 416)', () => {
-        expect(parseRange('bytes=1000-1100', TOTAL)).toBeUndefined(); // start === total
-        expect(parseRange('bytes=2000-', TOTAL)).toBeUndefined(); // start > total
+        expect(ParseRange('bytes=1000-1100', TOTAL)).toBeUndefined(); // start === total
+        expect(ParseRange('bytes=2000-', TOTAL)).toBeUndefined(); // start > total
     });
 
     it('returns undefined when end < start after parsing', () => {
-        expect(parseRange('bytes=600-100', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=600-100', TOTAL)).toBeUndefined();
     });
 
     it('returns undefined for malformed / multi-range / suffix-only headers', () => {
-        expect(parseRange('bytes=abc-', TOTAL)).toBeUndefined();
-        expect(parseRange('bytes=-200', TOTAL)).toBeUndefined();
-        expect(parseRange('bytes=0-100,200-300', TOTAL)).toBeUndefined();
-        expect(parseRange('items=0-100', TOTAL)).toBeUndefined();
-        expect(parseRange('', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=abc-', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=-200', TOTAL)).toBeUndefined();
+        expect(ParseRange('bytes=0-100,200-300', TOTAL)).toBeUndefined();
+        expect(ParseRange('items=0-100', TOTAL)).toBeUndefined();
+        expect(ParseRange('', TOTAL)).toBeUndefined();
     });
 
     it('handles the very first byte and the very last byte exactly', () => {
-        expect(parseRange('bytes=0-0', TOTAL)).toEqual({ start: 0, end: 0 });
-        expect(parseRange('bytes=999-999', TOTAL)).toEqual({ start: 999, end: 999 });
+        expect(ParseRange('bytes=0-0', TOTAL)).toEqual({ start: 0, end: 0 });
+        expect(ParseRange('bytes=999-999', TOTAL)).toEqual({ start: 999, end: 999 });
     });
 
     it('tolerates surrounding whitespace', () => {
-        expect(parseRange('  bytes=10-20  ', TOTAL)).toEqual({ start: 10, end: 20 });
+        expect(ParseRange('  bytes=10-20  ', TOTAL)).toEqual({ start: 10, end: 20 });
     });
 });

package/src/__tests__/NoLog.test.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { describe, it, expect } from 'vitest';
-import { NoLog, hasNoLogParameter, getNoLogFields } from '../logging/NoLog.js';
+import { NoLog, HasNoLogParameter, GetNoLogFields } from '../logging/NoLog.js';
 
 describe('NoLog decorator', () => {
   it('marks a resolver method parameter (3-arg call) and is readable via hasNoLogParameter', () => {
@@ -11,9 +11,9 @@ describe('NoLog decorator', () => {
     }
     NoLog(MyResolver.prototype, 'doThing', 1);
 
-    expect(hasNoLogParameter(MyResolver, 'doThing', 1)).toBe(true);
-    expect(hasNoLogParameter(MyResolver, 'doThing', 0)).toBe(false);
-    expect(hasNoLogParameter(MyResolver, 'unknownMethod', 0)).toBe(false);
+    expect(HasNoLogParameter(MyResolver, 'doThing', 1)).toBe(true);
+    expect(HasNoLogParameter(MyResolver, 'doThing', 0)).toBe(false);
+    expect(HasNoLogParameter(MyResolver, 'unknownMethod', 0)).toBe(false);
   });
 
   it('marks a field on an input class (2-arg call) and is readable via getNoLogFields', () => {
@@ -24,7 +24,7 @@ describe('NoLog decorator', () => {
     }
     NoLog(MyInput.prototype, 'Token');
 
-    const fields = getNoLogFields(MyInput);
+    const fields = GetNoLogFields(MyInput);
     expect(fields.has('Token')).toBe(true);
     expect(fields.has('Queries')).toBe(false);
     expect(fields.size).toBe(1);
@@ -41,8 +41,8 @@ describe('NoLog decorator', () => {
       B: string = '';
     }
 
-    expect(hasNoLogParameter(UndecoratedResolver, 'doNothing', 0)).toBe(false);
-    expect(getNoLogFields(UndecoratedInput).size).toBe(0);
+    expect(HasNoLogParameter(UndecoratedResolver, 'doNothing', 0)).toBe(false);
+    expect(GetNoLogFields(UndecoratedInput).size).toBe(0);
   });
 
   it('supports multiple parameter marks on the same method', () => {
@@ -54,9 +54,9 @@ describe('NoLog decorator', () => {
     NoLog(TwoSecrets.prototype, 'handle', 0);
     NoLog(TwoSecrets.prototype, 'handle', 2);
 
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 0)).toBe(true);
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 1)).toBe(false);
-    expect(hasNoLogParameter(TwoSecrets, 'handle', 2)).toBe(true);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 0)).toBe(true);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 1)).toBe(false);
+    expect(HasNoLogParameter(TwoSecrets, 'handle', 2)).toBe(true);
   });
 
   it('supports multiple field marks on the same input class', () => {
@@ -68,7 +68,7 @@ describe('NoLog decorator', () => {
     NoLog(TwoFieldSecrets.prototype, 'A');
     NoLog(TwoFieldSecrets.prototype, 'C');
 
-    const fields = getNoLogFields(TwoFieldSecrets);
+    const fields = GetNoLogFields(TwoFieldSecrets);
     expect(fields.has('A')).toBe(true);
     expect(fields.has('B')).toBe(false);
     expect(fields.has('C')).toBe(true);