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

package/src/resolvers/DuplicateEntryCheckResolver.ts

@@ -0,0 +1,232 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, Float, Int } from 'type-graphql';
+import { AppContext, UserPayload } from '../types.js';
+import { EntityFieldInfo, EntityInfo, IMetadataProvider, LogError, Metadata } from '@memberjunction/core';
+import { DuplicateRecordDetector } from '@memberjunction/ai-vector-dupe';
+import type { DuplicateEntryCheckResult, DuplicateEntryCheckStatus } from '@memberjunction/ai-vector-dupe';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadOnlyProvider } from '../util.js';
+
+/**
+ * The most characters `valuesJSON` may hold. A larger request is refused before it is parsed. The
+ * form sends each field's text cut to 500 characters, so a real entry stays well under it; the
+ * detector then cuts what reaches the template and the decision model on its own.
+ */
+export const DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH = 16 * 1024;
+
+/**
+ * How a `CheckDuplicateEntry` call ended: a detector status, or `NotAuthorized` when the caller may
+ * not run the check (an API key without the scopes, or a user who cannot read the entity). Nothing
+ * ran, and a form stops asking about the entity for the session, as it does on `NotConfigured`.
+ */
+export type DuplicateEntryCheckOutputStatus = DuplicateEntryCheckStatus | 'NotAuthorized';
+
+/** One entered value, as `valuesJSON` may carry it. */
+type EntryValue = string | number | boolean | null;
+
+/** One existing record the entry-time check flags as a possible duplicate. */
+@ObjectType()
+export class DuplicateEntryCandidateOutput {
+    /** The candidate's primary key as a compact URL segment; `CompositeKey.FromURLSegment` reads it back. */
+    @Field()
+    RecordID: string;
+
+    /** The candidate's name, or its key when the caller may not read a name. */
+    @Field()
+    DisplayName: string;
+
+    /** The vector similarity score that surfaced the candidate. */
+    @Field(() => Float)
+    VectorScore: number;
+
+    /** The decision's probability that the candidate is the same entity; null when it gave no answer. */
+    @Field(() => Float, { nullable: true })
+    Probability: number | null;
+}
+
+/**
+ * The result of the `CheckDuplicateEntry` mutation. The mutation never throws to the client: an
+ * authorization denial is `Status: 'NotAuthorized'` and any other failure is `Status: 'Failed'`,
+ * each with an `ErrorMessage`.
+ */
+@ObjectType()
+export class DuplicateEntryCheckOutput {
+    /** `Checked`, `NotConfigured`, `NotAuthorized` or `Failed`. */
+    @Field(() => String)
+    Status: DuplicateEntryCheckOutputStatus;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+
+    /** The flagged candidates, most probable first. Empty unless `Status` is `Checked`. */
+    @Field(() => [DuplicateEntryCandidateOutput])
+    Candidates: DuplicateEntryCandidateOutput[];
+
+    /** How long the check took on the server, in milliseconds. */
+    @Field(() => Int)
+    ElapsedMs: number;
+}
+
+/** What the resolver needs from the detector. `DuplicateRecordDetector` provides it. */
+export type DuplicateEntryChecker = Pick<DuplicateRecordDetector, 'CheckRecordValues'>;
+
+/**
+ * Checks the values a person is entering for a new record against the entity's existing records,
+ * through `DuplicateRecordDetector.CheckRecordValues`, and returns the plausible duplicates to flag.
+ * It only flags: it saves, merges and blocks nothing.
+ */
+@Resolver()
+export class DuplicateEntryCheckResolver extends ResolverBase {
+    /**
+     * Flags existing records that may duplicate a new record being entered.
+     *
+     * Authorization comes before any other work. An API key needs two scopes: `view:run` on the
+     * entity, the scope `RunDynamicView` checks, since the check reads the entity's records; and
+     * `prompt:execute`, the scope `ExecuteSimplePrompt` checks, since each check pays for an embedding
+     * and a decision-model call. A session without an API key skips both. Then the user needs read
+     * permission on the entity. A denial is `NotAuthorized`, and is not logged. The detector then
+     * narrows the candidates to the rows the user can read.
+     *
+     * The detector bounds the check's time on the server (`DUPLICATE_ENTRY_CHECK_SERVER_BUDGET_MS` in
+     * `@memberjunction/ai-vector-dupe`), a little above the form's own budget.
+     *
+     * @param entityName The entity the new record belongs to.
+     * @param valuesJSON The entered values as the JSON of an object, by field name, at most
+     *   {@link DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH} characters. Each value is a string,
+     *   number, boolean or null. Fields the entity does not have, primary keys, read-only fields and
+     *   MJ system fields are ignored.
+     */
+    @Mutation(() => DuplicateEntryCheckOutput)
+    async CheckDuplicateEntry(
+        @Arg('entityName') entityName: string,
+        @Arg('valuesJSON') valuesJSON: string,
+        @Ctx() { userPayload, providers }: AppContext
+    ): Promise<DuplicateEntryCheckOutput> {
+        const provider = GetReadOnlyProvider(providers, { allowFallbackToReadWrite: true });
+        return this.RunEntryCheck(entityName, valuesJSON, userPayload, provider);
+    }
+
+    /**
+     * The check without the GraphQL plumbing: authorizes, reads the values, and runs the detector.
+     * Never throws.
+     *
+     * @param provider the request's metadata provider; the global one when null
+     */
+    public async RunEntryCheck(
+        entityName: string,
+        valuesJSON: string,
+        userPayload: UserPayload,
+        provider: IMetadataProvider | null
+    ): Promise<DuplicateEntryCheckOutput> {
+        const startTime = Date.now();
+        const entity = (provider ?? new Metadata()).EntityByName(entityName);
+        if (!entity) {
+            return this.failure('Failed', 'Entity not found in metadata', startTime);
+        }
+        const denial = await this.authorizeEntryCheck(entity, userPayload, provider);
+        if (denial) {
+            return this.failure('NotAuthorized', denial, startTime);
+        }
+        try {
+            const user = this.GetUserFromPayload(userPayload);
+            if (!user) {
+                return this.failure('Failed', 'Unable to determine current user', startTime);
+            }
+            const values = this.parseValues(valuesJSON, entity);
+            if ('Error' in values) {
+                return this.failure('Failed', values.Error, startTime);
+            }
+            const result = await this.CreateEntryChecker(provider).CheckRecordValues(entity.Name, values.Values, user);
+            return this.mapResult(result);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            LogError(`CheckDuplicateEntry failed for ${entityName}: ${message}`);
+            return this.failure('Failed', message || 'Unknown error occurred', startTime);
+        }
+    }
+
+    /** The detector a check runs on, bound to the request's provider. */
+    protected CreateEntryChecker(provider: IMetadataProvider | null): DuplicateEntryChecker {
+        return new DuplicateRecordDetector(provider);
+    }
+
+    /**
+     * Why the caller may not run the check, or null when they may: the API-key scopes, then the
+     * user's read permission on the entity. A denial is an answer, not a fault, so nothing is logged.
+     */
+    private async authorizeEntryCheck(
+        entity: EntityInfo,
+        userPayload: UserPayload,
+        provider: IMetadataProvider | null
+    ): Promise<string | null> {
+        try {
+            await this.CheckAPIKeyScopeAuthorization('view:run', entity.Name, userPayload);
+            await this.CheckAPIKeyScopeAuthorization('prompt:execute', '*', userPayload);
+            this.CheckUserReadPermissions(entity.Name, userPayload, provider ?? undefined);
+            return null;
+        } catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+
+    /**
+     * Reads the entered values: the JSON of an object of scalar values, at most
+     * {@link DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH} characters, kept to the fields a person
+     * can enter (matched by name, case-insensitively, and keyed by the field's real name).
+     */
+    private parseValues(valuesJSON: string, entity: EntityInfo): { Values: Record<string, EntryValue> } | { Error: string } {
+        if (valuesJSON.length > DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH) {
+            return { Error: `valuesJSON is ${valuesJSON.length} characters; the limit is ${DUPLICATE_ENTRY_CHECK_MAX_VALUES_JSON_LENGTH}` };
+        }
+        let parsed: unknown;
+        try {
+            parsed = JSON.parse(valuesJSON);
+        } catch (e) {
+            return { Error: `valuesJSON is not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+        }
+        if (!this.isPlainObject(parsed)) {
+            return { Error: 'valuesJSON must be the JSON of an object of field values' };
+        }
+        const values: Record<string, EntryValue> = {};
+        for (const [name, value] of Object.entries(parsed)) {
+            if (!this.isEntryValue(value)) {
+                return { Error: `valuesJSON field '${name}' must be a string, number, boolean or null` };
+            }
+            const field = entity.FieldByName(name);
+            if (field && this.isEnterable(field)) {
+                values[field.Name] = value;
+            }
+        }
+        return { Values: values };
+    }
+
+    /** Whether a person can enter the field: not a primary key, not read-only, not an MJ system field. */
+    private isEnterable(field: EntityFieldInfo): boolean {
+        return !field.IsPrimaryKey && !field.ReadOnly && !field.Name.startsWith('__mj_');
+    }
+
+    private isEntryValue(value: unknown): value is EntryValue {
+        return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+    }
+
+    private isPlainObject(value: unknown): value is Record<string, unknown> {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+
+    private mapResult(result: DuplicateEntryCheckResult): DuplicateEntryCheckOutput {
+        return {
+            Status: result.Status,
+            ErrorMessage: result.ErrorMessage,
+            Candidates: result.Candidates.map(c => ({
+                RecordID: c.RecordID,
+                DisplayName: c.DisplayName,
+                VectorScore: c.VectorScore,
+                Probability: c.Probability,
+            })),
+            ElapsedMs: result.ElapsedMs,
+        };
+    }
+
+    private failure(status: DuplicateEntryCheckOutputStatus, errorMessage: string, startTime: number): DuplicateEntryCheckOutput {
+        return { Status: status, ErrorMessage: errorMessage, Candidates: [], ElapsedMs: Date.now() - startTime };
+    }
+}

package/src/resolvers/EntityCommunicationsResolver.ts

@@ -31,10 +31,10 @@ export class CommunicationProviderMessageType {
   AdditionalAttributes: string;
 
   @Field()
-  _mj_CreatedAt: Date;
+  _mj_CreatedAt: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field()
-  _mj_UpdatedAt: Date;
+  _mj_UpdatedAt: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field()
   CommunicationProvider?: string;
@@ -73,10 +73,10 @@ export class TemplateInputType {
   IsActive: boolean;
 
   @Field()
-  _mj_CreatedAt: Date;
+  _mj_CreatedAt: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field()
-  _mj_UpdatedAt: Date;
+  _mj_UpdatedAt: Date;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field({ nullable: true })
   Category?: string;

package/src/resolvers/ExecuteRemoteOperationResolver.ts

@@ -13,13 +13,13 @@ const REMOTE_OP_PROGRESS_TOPIC = 'RemoteOperationProgress';
 @InputType()
 export class ExecuteRemoteOperationInput {
     @Field()
-    operationKey: string;
+    operationKey: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    inputJSON: string;
+    inputJSON: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    invokeMode: string;
+    invokeMode: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     /**
      * Optional client-generated channel id. When set (attached mode over the wire), the server publishes every
@@ -27,7 +27,7 @@ export class ExecuteRemoteOperationInput {
      * so the caller's `onProgress` fires live while the operation runs. Omitted for sync / no-progress calls.
      */
     @Field(() => String, { nullable: true })
-    progressChannelId?: string;
+    progressChannelId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /** A single streamed progress envelope delivered over the `RemoteOperationProgress` subscription. */
@@ -45,19 +45,19 @@ export class RemoteOperationProgressNotification {
 @ObjectType()
 export class ExecuteRemoteOperationResultType {
     @Field(() => Boolean)
-    success: boolean;
+    success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String, { nullable: true })
-    resultCode?: string;
+    resultCode?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String, { nullable: true })
-    outputJSON?: string;
+    outputJSON?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String, { nullable: true })
-    handle?: string;
+    handle?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => String, { nullable: true })
-    errorMessage?: string;
+    errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**

package/src/resolvers/FetchEntityVectorsResolver.ts

@@ -5,6 +5,7 @@ import { MJEntityDocumentEntity, MJVectorIndexEntity, MJVectorDatabaseEntity } f
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetAIAPIKey } from '@memberjunction/ai';
 import { VectorDBBase } from '@memberjunction/ai-vectordb';
+import { AIEngine } from '@memberjunction/aiengine';
 import { EscapeSQLString, MJGlobal, UUIDsEqual } from '@memberjunction/global';
 
 /* ───── GraphQL types ───── */
@@ -99,7 +100,7 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             const metadataFilter: Record<string, unknown> = { Entity: { $eq: entityName } };
 
             const queryResponse = await vectorDBInstance.QueryIndex({
-                id: vectorIndex.Name,  // index name (stripped before Pinecone query)
+                id: AIEngine.Instance.GetProviderIndexName(vectorIndex),
                 vector: uniformVector,
                 topK: limit,
                 includeMetadata: true,

package/src/resolvers/FileResolver.ts

@@ -42,7 +42,7 @@ import { GetReadOnlyProvider } from '../util.js';
 import { configInfo } from '../config.js';
 import { MediaAccessKeyManager } from '../rest/MediaAccessKeys.js';
 import { UploadTokenManager } from '../rest/UploadTokenManager.js';
-import { deriveSidecarPath, parsePeaksSidecar } from './peaksSidecar.js';
+import { DeriveSidecarPath, ParsePeaksSidecar } from './peaksSidecar.js';
 
 @InputType()
 export class CreateUploadURLInput {
@@ -126,40 +126,40 @@ export class FileExt extends MJFile_ {
 @ObjectType()
 export class StorageObjectMetadata {
   @Field(() => String)
-  name: string;
+  name: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  path: string;
+  path: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  fullPath: string;
+  fullPath: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int)
-  size: number;
+  size: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  contentType: string;
+  contentType: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  lastModified: string;
+  lastModified: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Boolean)
-  isDirectory: boolean;
+  isDirectory: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  etag?: string;
+  etag?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  cacheControl?: string;
+  cacheControl?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class StorageListResult {
   @Field(() => [StorageObjectMetadata])
-  objects: StorageObjectMetadata[];
+  objects: StorageObjectMetadata[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => [String])
-  prefixes: string[];
+  prefixes: string[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
@@ -264,25 +264,25 @@ export class CopyObjectBetweenAccountsInput {
 @ObjectType()
 export class CopyObjectBetweenAccountsPayload {
   @Field(() => Boolean)
-  success: boolean;
+  success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  message: string;
+  message: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { nullable: true })
-  bytesTransferred?: number;
+  bytesTransferred?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  sourceAccount: string;
+  sourceAccount: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  destinationAccount: string;
+  destinationAccount: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  sourcePath: string;
+  sourcePath: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  destinationPath: string;
+  destinationPath: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
@@ -306,73 +306,73 @@ export class SearchAcrossAccountsInput {
 @ObjectType()
 export class FileSearchResultPayload {
   @Field(() => String)
-  path: string;
+  path: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  name: string;
+  name: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int)
-  size: number;
+  size: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  contentType: string;
+  contentType: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  lastModified: string;
+  lastModified: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Number, { nullable: true })
-  relevance?: number;
+  relevance?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  excerpt?: string;
+  excerpt?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Boolean, { nullable: true })
-  matchInFilename?: boolean;
+  matchInFilename?: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  objectId?: string;
+  objectId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class AccountSearchResultPayload {
   @Field(() => String)
-  accountID: string;
+  accountID: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String)
-  accountName: string;
+  accountName: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Boolean)
-  success: boolean;
+  success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  errorMessage?: string;
+  errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => [FileSearchResultPayload])
-  results: FileSearchResultPayload[];
+  results: FileSearchResultPayload[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { nullable: true })
-  totalMatches?: number;
+  totalMatches?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Boolean)
-  hasMore: boolean;
+  hasMore: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true })
-  nextPageToken?: string;
+  nextPageToken?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class SearchAcrossAccountsPayload {
   @Field(() => [AccountSearchResultPayload])
-  accountResults: AccountSearchResultPayload[];
+  accountResults: AccountSearchResultPayload[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int)
-  totalResultsReturned: number;
+  totalResultsReturned: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int)
-  successfulAccounts: number;
+  successfulAccounts: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int)
-  failedAccounts: number;
+  failedAccounts: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -503,7 +503,7 @@ export class FileResolver extends FileResolverBase {
   private async tryReadPeaksSidecar(file: MJFileEntity, contextUser: UserInfo): Promise<number[] | undefined> {
     try {
       // The sidecar lives next to the recording: replace the final path segment with peaks.json.
-      const sidecarPath = deriveSidecarPath(file.ProviderKey);
+      const sidecarPath = DeriveSidecarPath(file.ProviderKey);
       if (!sidecarPath) {
         return undefined;
       }
@@ -524,7 +524,7 @@ export class FileResolver extends FileResolverBase {
       if (!bytes || bytes.length === 0) {
         return undefined;
       }
-      return parsePeaksSidecar(bytes);
+      return ParsePeaksSidecar(bytes);
     } catch {
       // No sidecar / unreadable / parse failure — peaks are optional, never surface the error.
       return undefined;

package/src/resolvers/GeoResolver.ts

@@ -98,7 +98,7 @@ export class GeoResolver extends ResolverBase {
     /**
      * Lazily load all countries into memory (~250 records).
      */
-    private async GetCountries(contextUser: UserInfo | undefined): Promise<MJCountryEntity[]> {
+    private async getCountries(contextUser: UserInfo | undefined): Promise<MJCountryEntity[]> {
         if (this._countries) return this._countries;
         const rv = new RunView();
         const result = await rv.RunView<MJCountryEntity>({
@@ -114,7 +114,7 @@ export class GeoResolver extends ResolverBase {
     /**
      * Lazily load all state/provinces into memory (~5000 records).
      */
-    private async GetStates(contextUser: UserInfo | undefined): Promise<MJStateProvinceEntity[]> {
+    private async getStates(contextUser: UserInfo | undefined): Promise<MJStateProvinceEntity[]> {
         if (this._states) return this._states;
         const rv = new RunView();
         const result = await rv.RunView<MJStateProvinceEntity>({
@@ -138,7 +138,7 @@ export class GeoResolver extends ResolverBase {
     ): Promise<GeoResolveResult> {
         try {
             const user = this.GetUserFromPayload(userPayload);
-            const countries = await this.GetCountries(user);
+            const countries = await this.getCountries(user);
             const normalized = input.trim().toLowerCase();
 
             // 1. Exact match on Name, ISO2, ISO3
@@ -204,7 +204,7 @@ export class GeoResolver extends ResolverBase {
                 return { Success: false, ErrorMessage: `Could not resolve country "${countryInput}"` };
             }
 
-            const states = await this.GetStates(user);
+            const states = await this.getStates(user);
             const countryStates = states.filter(s => s.CountryID === countryResult.CountryID);
             const normalized = stateInput.trim().toLowerCase();