@memberjunction/server 5.37.0 → 5.39.0

package/src/resolvers/SearchEntitiesResolver.ts

@@ -0,0 +1,173 @@
+import { Arg, Ctx, Field, Float, InputType, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { EntitySearchResult, SearchEntityParams } from '@memberjunction/core';
+import { AppContext } from '../types.js';
+import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { GetReadOnlyProvider } from '../util.js';
+
+/**
+ * GraphQL surface for {@link Metadata.Provider.SearchEntity} / `SearchEntities`.
+ *
+ * Both client forms ({@link GraphQLDataProvider.SearchEntity} and `SearchEntities`)
+ * proxy through this single batched resolver — one HTTP round-trip carries N
+ * per-entity searches in both directions. The actual ranking (lexical +
+ * semantic + RRF blend + permission filter) runs server-side via
+ * `GenericDatabaseProvider.SearchEntity`, fanned out concurrently across
+ * the input list.
+ *
+ * Result groups are aligned by input order so the client can map them back
+ * to the original `params[i]` slot without needing the entity name.
+ */
+
+@InputType()
+export class SearchEntityInput {
+    @Field(() => String)
+    declare EntityName: string;
+
+    @Field(() => String)
+    declare SearchText: string;
+
+    @Field(() => String, { nullable: true })
+    Mode?: 'lexical' | 'semantic' | 'hybrid';
+
+    @Field(() => Int, { nullable: true })
+    RrfK?: number;
+
+    @Field(() => Float, { nullable: true })
+    LexicalWeight?: number;
+
+    @Field(() => Float, { nullable: true })
+    SemanticWeight?: number;
+
+    @Field(() => Int, { nullable: true })
+    TopK?: number;
+
+    @Field(() => Float, { nullable: true })
+    MinScore?: number;
+
+    @Field(() => String, { nullable: true })
+    EntityDocumentID?: string;
+}
+
+@ObjectType()
+export class EntitySearchResultType {
+    @Field(() => String, { nullable: true })
+    declare EntityRecordDocumentID: string | null;
+
+    @Field(() => String)
+    declare RecordID: string;
+
+    @Field(() => Float)
+    declare Score: number;
+
+    @Field(() => String)
+    declare MatchType: 'lexical' | 'semantic' | 'hybrid';
+
+    @Field(() => Float, { nullable: true })
+    LexicalScore?: number | null;
+
+    @Field(() => Float, { nullable: true })
+    SemanticScore?: number | null;
+}
+
+@ObjectType()
+export class EntitySearchResultGroupType {
+    @Field(() => String)
+    declare EntityName: string;
+
+    @Field(() => [EntitySearchResultType])
+    declare Results: EntitySearchResultType[];
+}
+
+@ObjectType()
+export class SearchEntitiesResponseType {
+    @Field(() => Boolean)
+    declare Success: boolean;
+
+    @Field(() => String, { nullable: true })
+    ErrorMessage?: string;
+
+    @Field(() => [EntitySearchResultGroupType])
+    declare Groups: EntitySearchResultGroupType[];
+}
+
+/**
+ * Per-request cap on how many entities a single `SearchEntities` call may
+ * search. Each entity in the batch triggers 2–4 RunViews server-side; an
+ * uncapped batch from a malicious or buggy client could fan out into
+ * thousands of concurrent DB queries. 20 covers every realistic use case
+ * (agent prompt seeding, multi-entity navbar search) with margin to spare.
+ */
+const MAX_SEARCH_ENTITIES_BATCH_SIZE = 20;
+
+@Resolver(SearchEntitiesResponseType)
+export class SearchEntitiesResolver {
+    @Query(() => SearchEntitiesResponseType)
+    async SearchEntities(
+        @Ctx() { providers, userPayload }: AppContext,
+        @Arg('params', () => [SearchEntityInput]) params: SearchEntityInput[]
+    ): Promise<SearchEntitiesResponseType> {
+        try {
+            if (params.length > MAX_SEARCH_ENTITIES_BATCH_SIZE) {
+                return {
+                    Success: false,
+                    ErrorMessage: `Batch size ${params.length} exceeds the per-request cap of ${MAX_SEARCH_ENTITIES_BATCH_SIZE}. Split the request.`,
+                    Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+                };
+            }
+            const md = GetReadOnlyProvider(providers);
+            const user = UserCache.Instance.Users.find(
+                (u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase()
+            );
+            if (!user) {
+                return {
+                    Success: false,
+                    ErrorMessage: `User ${userPayload.email} not found`,
+                    Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+                };
+            }
+
+            const callParams: SearchEntityParams[] = params.map(p => ({
+                entityName: p.EntityName,
+                searchText: p.SearchText,
+                options: {
+                    mode: p.Mode ?? 'hybrid',
+                    rrfK: p.RrfK ?? undefined,
+                    weights: {
+                        lexical: p.LexicalWeight ?? undefined,
+                        semantic: p.SemanticWeight ?? undefined,
+                    },
+                    topK: p.TopK ?? undefined,
+                    minScore: p.MinScore ?? undefined,
+                    entityDocumentId: p.EntityDocumentID ?? undefined,
+                    contextUser: user,
+                },
+            }));
+
+            // Server-side provider fans the batch out via Promise.all under the
+            // hood — see ProviderBase.SearchEntities. Results arrive aligned by
+            // input order; we just map each group's records to the GraphQL shape.
+            const groupedResults: EntitySearchResult[][] = await md.SearchEntities(callParams);
+
+            return {
+                Success: true,
+                Groups: groupedResults.map((results, i) => ({
+                    EntityName: params[i].EntityName,
+                    Results: results.map(r => ({
+                        EntityRecordDocumentID: r.entityRecordDocumentId,
+                        RecordID: r.recordId,
+                        Score: r.score,
+                        MatchType: r.matchType,
+                        LexicalScore: r.components.lexical ?? null,
+                        SemanticScore: r.components.semantic ?? null,
+                    })),
+                })),
+            };
+        } catch (e) {
+            return {
+                Success: false,
+                ErrorMessage: e instanceof Error ? e.message : String(e),
+                Groups: params.map(p => ({ EntityName: p.EntityName, Results: [] })),
+            };
+        }
+    }
+}

package/src/resolvers/VectorizeEntityResolver.ts

@@ -90,7 +90,13 @@ export class VectorizeEntityResolver extends ResolverBase {
             };
 
             const result = await syncer.VectorizeEntity(params, currentUser);
-            LogStatus(`VectorizeEntity pipeline ${pipelineRunID} complete: success=${result.success}`);
+            if (result.success) {
+                LogStatus(`VectorizeEntity pipeline ${pipelineRunID} complete: success=true`);
+            } else {
+                // The run finished but some/all records failed to render or upsert. Surface it
+                // loudly instead of logging a bare "success=false" that reads like a clean finish.
+                LogError(`VectorizeEntity pipeline ${pipelineRunID} completed with errors (status=${result.status}): ${result.errorMessage}`);
+            }
         } catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             LogError(`VectorizeEntity pipeline ${pipelineRunID} failed: ${msg}`);
@@ -110,11 +116,18 @@ export class VectorizeEntityResolver extends ResolverBase {
      * Publish a progress update to the PipelineProgress subscription topic.
      */
     private publishProgress(pipelineRunID: string, update: VectorizeProgressUpdate): void {
+        // Carry a short error summary to the client via CurrentItem when the update reports failures,
+        // so the subscription reflects that the run didn't cleanly succeed.
+        const errorSummary = update.Errors && update.Errors.length > 0
+            ? `${update.Errors.length} record(s) failed — e.g. ${update.Errors[0].Message}`
+            : undefined;
+
         const notification: PipelineProgressNotification = {
             PipelineRunID: pipelineRunID,
             Stage: update.Stage,
             TotalItems: update.TotalRecords,
             ProcessedItems: update.ProcessedRecords,
+            CurrentItem: errorSummary,
             ElapsedMs: update.ElapsedMs,
             PercentComplete: update.PercentComplete,
         };

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

@@ -0,0 +1,170 @@
+// type-graphql decorators (`@Field`, `@ObjectType`) call `Reflect.getMetadata`,
+// which only exists once this polyfill is loaded. Vitest doesn't bring it in
+// automatically — it MUST come before any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the PubSubManager singleton so PublishIntegrationProgress never touches a
+// real PubSubEngine (no network, no resolver-build dependency).
+const publishSpy = vi.fn();
+vi.mock('../../generic/PubSubManager.js', () => ({
+    PubSubManager: {
+        Instance: {
+            Publish: (...args: unknown[]) => publishSpy(...args),
+        },
+    },
+}));
+
+// Silence LogError so a deliberately-failing serialization test doesn't spam output.
+vi.mock('@memberjunction/core', () => ({
+    LogError: vi.fn(),
+}));
+
+import {
+    INTEGRATION_PROGRESS_TOPIC,
+    IntegrationProgressTopicForKind,
+    BuildIntegrationProgressNotification,
+    MatchesIntegrationSubscription,
+    PublishIntegrationProgress,
+    type IntegrationProgressNotification,
+    type PublishIntegrationProgressArgs,
+} from '../IntegrationProgressResolver';
+
+const baseArgs = (overrides: Partial<PublishIntegrationProgressArgs> = {}): PublishIntegrationProgressArgs => ({
+    RunID: 'run-1',
+    Kind: 'SyncRun',
+    EventType: 'stage.start',
+    Seq: 1,
+    CompanyIntegrationID: 'ci-1',
+    Message: 'starting',
+    Stage: 'extract',
+    Level: 'info',
+    Data: { foo: 'bar' },
+    ...overrides,
+});
+
+const baseNotification = (overrides: Partial<IntegrationProgressNotification> = {}): IntegrationProgressNotification => ({
+    RunID: 'run-1',
+    CompanyIntegrationID: 'ci-1',
+    Kind: 'SyncRun',
+    Topic: 'Sync',
+    EventType: 'stage.start',
+    Seq: 1,
+    Message: 'starting',
+    Stage: 'extract',
+    Level: 'info',
+    DataJSON: '{"foo":"bar"}',
+    ...overrides,
+});
+
+describe('IntegrationProgressTopicForKind', () => {
+    it('maps each run kind to its logical channel', () => {
+        expect(IntegrationProgressTopicForKind('Discovery')).toBe('MetadataRefresh');
+        expect(IntegrationProgressTopicForKind('Enrichment')).toBe('MetadataRefresh');
+        expect(IntegrationProgressTopicForKind('ConnectorCreation')).toBe('ConnectorCreation');
+        expect(IntegrationProgressTopicForKind('SyncRun')).toBe('Sync');
+        expect(IntegrationProgressTopicForKind('RSU')).toBe('RSU');
+        expect(IntegrationProgressTopicForKind('TableCreation')).toBe('RSU');
+    });
+
+    it('returns undefined for kinds without a dedicated channel', () => {
+        expect(IntegrationProgressTopicForKind('Other')).toBeUndefined();
+    });
+});
+
+describe('BuildIntegrationProgressNotification', () => {
+    it('builds the full notification shape with derived topic and serialized data', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs());
+        expect(n).toEqual(baseNotification());
+    });
+
+    it('derives ConnectorCreation topic from ConnectorCreation kind', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Kind: 'ConnectorCreation' }));
+        expect(n.Kind).toBe('ConnectorCreation');
+        expect(n.Topic).toBe('ConnectorCreation');
+    });
+
+    it('leaves DataJSON undefined when no data is supplied', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Data: undefined }));
+        expect(n.DataJSON).toBeUndefined();
+    });
+
+    it('swallows un-serializable data and leaves DataJSON undefined', () => {
+        const cyclic: Record<string, unknown> = {};
+        cyclic.self = cyclic;
+        const n = BuildIntegrationProgressNotification(baseArgs({ Data: cyclic }));
+        expect(n.DataJSON).toBeUndefined();
+        // The rest of the payload is unaffected.
+        expect(n.RunID).toBe('run-1');
+        expect(n.Topic).toBe('Sync');
+    });
+
+    it('omits Topic for an Other-kind run', () => {
+        const n = BuildIntegrationProgressNotification(baseArgs({ Kind: 'Other' }));
+        expect(n.Topic).toBeUndefined();
+    });
+});
+
+describe('MatchesIntegrationSubscription', () => {
+    it('matches everything when no args are supplied', () => {
+        expect(MatchesIntegrationSubscription(baseNotification(), {})).toBe(true);
+    });
+
+    it('filters by runID', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-2' })).toBe(false);
+    });
+
+    it('filters by companyIntegrationID', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { companyIntegrationID: 'ci-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { companyIntegrationID: 'ci-2' })).toBe(false);
+    });
+
+    it('filters by topic', () => {
+        const n = baseNotification({ Topic: 'Sync' });
+        expect(MatchesIntegrationSubscription(n, { topic: 'Sync' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { topic: 'RSU' })).toBe(false);
+    });
+
+    it('requires all supplied filters to match', () => {
+        const n = baseNotification();
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1', topic: 'Sync', companyIntegrationID: 'ci-1' })).toBe(true);
+        expect(MatchesIntegrationSubscription(n, { runID: 'run-1', topic: 'RSU' })).toBe(false);
+    });
+});
+
+describe('PublishIntegrationProgress', () => {
+    beforeEach(() => {
+        publishSpy.mockClear();
+    });
+
+    it('publishes the built notification to the integration topic and returns it', () => {
+        const result = PublishIntegrationProgress(baseArgs());
+
+        expect(result).toEqual(baseNotification());
+        expect(publishSpy).toHaveBeenCalledTimes(1);
+
+        const [topic, payload] = publishSpy.mock.calls[0];
+        expect(topic).toBe(INTEGRATION_PROGRESS_TOPIC);
+        expect(payload).toEqual(baseNotification());
+    });
+
+    it('publishes a fresh object copy (not the internal notification reference)', () => {
+        const result = PublishIntegrationProgress(baseArgs());
+        const [, payload] = publishSpy.mock.calls[0];
+        // Spread copy semantics: structurally equal but a distinct instance.
+        expect(payload).not.toBe(result);
+        expect(payload).toEqual(result);
+    });
+
+    it('returns undefined and does not throw when publishing fails', () => {
+        publishSpy.mockImplementationOnce(() => {
+            throw new Error('pubsub down');
+        });
+        const result = PublishIntegrationProgress(baseArgs());
+        expect(result).toBeUndefined();
+    });
+});

package/src/services/ScheduledJobsService.ts

@@ -67,7 +67,18 @@ export class ScheduledJobsService {
         }
 
         try {
-            this.engine.StartPolling(this.systemUser);
+            // Wire engine tunables from MJServer's scheduledJobs config block.
+            // Both fields have schema defaults (maxConcurrentJobs=5, defaultLockTimeout=600000ms),
+            // but apply explicitly so the values are visible in startup logs and
+            // a future config change is picked up without an engine code change.
+            if (this.config.maxConcurrentJobs != null) {
+                this.engine.MaxConcurrentJobs = this.config.maxConcurrentJobs;
+            }
+            if (this.config.defaultLockTimeout != null) {
+                this.engine.LeaseTimeoutMs = this.config.defaultLockTimeout;
+            }
+
+            await this.engine.StartPolling(this.systemUser);
             this.isRunning = true;
 
             // Single consolidated console message
@@ -102,7 +113,9 @@ export class ScheduledJobsService {
 
         try {
             LogStatus('[ScheduledJobsService] Stopping scheduled job polling');
-            this.engine.StopPolling();
+            // Graceful shutdown: wait for in-flight dispatched jobs to settle,
+            // bounded by 30s so a zombie can't hang the shutdown indefinitely.
+            await this.engine.StopPolling({ waitForInflight: true, maxWaitMs: 30_000 });
             this.isRunning = false;
             LogStatus('[ScheduledJobsService] Polling stopped successfully');
         } catch (error) {