@memberjunction/server 6.1.4 → 6.1.6

package/src/__tests__/TaskGraphActionRunner.durablePayload.test.ts

@@ -0,0 +1,131 @@
+/**
+ * End-to-end-in-miniature regression test for #4794.
+ *
+ * The bug: `BuildDurableDeferral` persisted a durable entity action's redacted params as a
+ * `LoggedParam[]` ARRAY (`RedactParamsToJSON`'s shape), while `TaskGraphActionRunner.buildParams`
+ * reads `Task.InputPayload` back as a name→value RECORD. Every released build with durable dispatch
+ * (v6.1.0 onward, including 6.1.4) hit the same real-world failure: `TaskGraphDispatcher`'s
+ * `mergedPayload` only merges plain objects, so it silently dropped the array before `buildParams`
+ * ever saw it, and the action ran with NONE of its declared inputs. `buildParams` itself has no such
+ * guard — `Object.assign(merged, arrayValue)` treats an array's indices as keys — so params named
+ * `'0'`, `'1'`, ... would only appear if the array reached it directly, bypassing the dispatcher's
+ * drop. That narrower path is exactly what this test exercises, by calling `RunActionForTask`
+ * on its own rather than through the dispatcher.
+ *
+ * This test proves the whole pipe, not just the writer or the reader in isolation: build the
+ * payload exactly as the deferral does (`RedactParamsToRecord`), push it through the same
+ * `JSON.stringify` / `JSON.parse` round trip `TaskGraphService` performs to persist and reload
+ * `Task.InputPayload`, then run it through the real `TaskGraphActionRunner` and assert the action
+ * receives its declared parameters BY NAME.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@memberjunction/actions', () => ({
+    ActionEngineServer: {
+        Instance: {
+            Config: vi.fn(),
+            Actions: [{ ID: 'A1', Name: 'Log Activity' }],
+            RunAction: vi.fn(),
+        },
+    },
+}));
+
+import { ActionEngineServer } from '@memberjunction/actions';
+import { RedactParamsToRecord, ActionParam } from '@memberjunction/actions-base';
+import type { MJActionExecutionLogEntity, MJActionParamEntity, MJEntityActionParamEntity } from '@memberjunction/core-entities';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { TaskActionRunParams } from '@memberjunction/task-graph';
+import { TaskGraphActionRunner } from '../services/TaskGraphActionRunner';
+
+// ── Test fixture builders — same shape as packages/Actions/Base/src/__tests__/ParamRedaction.test.ts ──
+
+function actionParam(name: string, value: unknown): ActionParam {
+    return { Name: name, Value: value, Type: 'Input' } as ActionParam;
+}
+
+function definition(id: string, name: string, logValue: boolean = true): MJActionParamEntity {
+    return { ID: id, Name: name, LogValue: logValue } as MJActionParamEntity;
+}
+
+function binding(actionParamID: string, valueType: string, logValue: boolean | null = null): MJEntityActionParamEntity {
+    return { ActionParamID: actionParamID, ValueType: valueType, LogValue: logValue } as MJEntityActionParamEntity;
+}
+
+// The declared parameters for the durable entity action under test: three that log normally, and
+// one ("InternalNotes") whose binding opts out of logging (rule 2 in ParamRedaction.ts).
+const RUNTIME_PARAMS: ActionParam[] = [
+    actionParam('TypeCode', 'SystemEvent'),
+    actionParam('Title', 'Person created'),
+    actionParam('RecordID', 'REC-123'),
+    actionParam('InternalNotes', 'do not persist this'),
+];
+const ACTION_PARAMS: MJActionParamEntity[] = [
+    definition('p1', 'TypeCode'),
+    definition('p2', 'Title'),
+    definition('p3', 'RecordID'),
+    definition('p4', 'InternalNotes'),
+];
+const ENTITY_ACTION_PARAMS: MJEntityActionParamEntity[] = [binding('p4', 'Static', false)];
+
+function baseRunParams(inputPayload: unknown): TaskActionRunParams {
+    return {
+        TaskID: 'T1',
+        ActionID: 'A1',
+        InputPayload: inputPayload,
+        DependencyOutputs: new Map(),
+        Provider: {} as IMetadataProvider,
+        ContextUser: {} as UserInfo,
+    };
+}
+
+describe('TaskGraphActionRunner — durable payload round-trips by param name (#4794)', () => {
+    beforeEach(() => {
+        // vitest's `restoreMocks: true` clears mock implementations before every test, including
+        // the ones assigned inside the `vi.mock` factory above — so the return value is (re)armed here.
+        // Call history on a vi.fn created inside vi.mock survives that restore, so clear it too.
+        vi.mocked(ActionEngineServer.Instance.Config).mockResolvedValue(undefined);
+        vi.mocked(ActionEngineServer.Instance.RunAction, { partial: true }).mockClear();
+        vi.mocked(ActionEngineServer.Instance.RunAction, { partial: true }).mockResolvedValue({
+            Success: true,
+            Params: [],
+            LogEntry: { ID: 'L1' } as MJActionExecutionLogEntity,
+        });
+    });
+
+    it('delivers RedactParamsToRecord\'s output to the action by name, after a JSON round trip', async () => {
+        // Exactly what the deferral writes, then exactly what TaskGraphService's JSON column does to it.
+        const stored = JSON.parse(JSON.stringify(RedactParamsToRecord(RUNTIME_PARAMS, ACTION_PARAMS, ENTITY_ACTION_PARAMS)));
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams(stored));
+
+        expect(result.Success).toBe(true);
+        expect(result.ActionLogID).toBe('L1');
+
+        const runActionCall = vi.mocked(ActionEngineServer.Instance.RunAction).mock.calls[0][0];
+        const sentParams = runActionCall.Params as ActionParam[];
+
+        // The three logged declared names arrive, order-insensitive, with their values intact.
+        expect(sentParams.map((p) => p.Name).sort()).toEqual(['RecordID', 'Title', 'TypeCode']);
+        expect(sentParams.find((p) => p.Name === 'TypeCode')?.Value).toBe('SystemEvent');
+        expect(sentParams.find((p) => p.Name === 'Title')?.Value).toBe('Person created');
+        expect(sentParams.find((p) => p.Name === 'RecordID')?.Value).toBe('REC-123');
+
+        // The binding-suppressed parameter never reaches the action — absent, not present-with-undefined.
+        expect(sentParams.some((p) => p.Name === 'InternalNotes')).toBe(false);
+    });
+
+    it('does not turn dependency outputs into params named by the upstream task ID', async () => {
+        // The dispatcher keys DependencyOutputs by the upstream task's ID and has ALREADY merged their
+        // values into InputPayload (TaskGraphDispatcher.mergedPayload). A runner that also spread the
+        // map handed the action one extra param per dependency, named by a GUID and holding that
+        // task's whole output — which then landed, unredacted, in ActionExecutionLog.Params.
+        const upstreamID = '20924BD7-5128-4150-8404-FB44A55AEA0F';
+        const params = baseRunParams({ EntityName: 'MJ: Entities', Record: { ID: 'R1', Name: 'MJ: Tags' } });
+        params.DependencyOutputs = new Map([[upstreamID, { Record: { ID: 'R1', Name: 'MJ: Tags' } }]]);
+
+        await new TaskGraphActionRunner().RunActionForTask(params);
+
+        const sentParams = vi.mocked(ActionEngineServer.Instance.RunAction).mock.calls[0][0].Params as ActionParam[];
+        expect(sentParams.map((p) => p.Name).sort()).toEqual(['EntityName', 'Record']);
+    });
+});

package/src/__tests__/TaskGraphActionRunner.storableOutputs.test.ts

@@ -0,0 +1,76 @@
+/**
+ * A durable step's Output is stored on the Task row as JSON. An action that hands back an output
+ * param holding a live object (an entity, an observable) used to surface much later, from the
+ * dispatcher, as a bare "Converting circular structure to JSON" with no hint of WHICH action or
+ * param — seen live with Execute Agent's AgentResult. The runner is the boundary that knows both
+ * names, so it refuses the output there and says which param it was.
+ *
+ * Backported from `next` (#4963), where these cases live in TaskGraphActionRunner.durablePayload.test.ts;
+ * that file arrived with #4796, which is not on this line.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@memberjunction/actions', () => ({
+    ActionEngineServer: {
+        Instance: {
+            Config: vi.fn(),
+            Actions: [{ ID: 'A1', Name: 'Log Activity' }],
+            RunAction: vi.fn(),
+        },
+    },
+}));
+
+import { ActionEngineServer } from '@memberjunction/actions';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { TaskActionRunParams } from '@memberjunction/task-graph';
+import { TaskGraphActionRunner } from '../services/TaskGraphActionRunner';
+
+function baseRunParams(inputPayload: unknown): TaskActionRunParams {
+    return {
+        TaskID: 'T1',
+        ActionID: 'A1',
+        InputPayload: inputPayload,
+        DependencyOutputs: new Map(),
+        Provider: {} as IMetadataProvider,
+        ContextUser: {} as UserInfo,
+    };
+}
+
+describe('TaskGraphActionRunner: outputs must be storable', () => {
+    beforeEach(() => {
+        // vitest's `restoreMocks: true` clears implementations assigned inside the `vi.mock` factory,
+        // so Config's return value is (re)armed here.
+        vi.mocked(ActionEngineServer.Instance.Config).mockResolvedValue(undefined);
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockReset();
+    });
+
+    it('fails the step, naming the action and the param, when an output param cannot be serialized', async () => {
+        const cyclic: Record<string, unknown> = { kind: 'OperatorSubscriber' };
+        cyclic.self = cyclic;
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: 'started',
+            Params: [{ Name: 'AgentRunID', Type: 'Output', Value: 'RUN-1' }, { Name: 'AgentResult', Type: 'Output', Value: cyclic }],
+            LogEntry: { ID: 'LOG-1' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({}));
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toMatch(/Log Activity.*AgentResult.*cannot be stored/i);
+        expect(result.ActionLogID).toBe('LOG-1');
+    });
+
+    it('passes plain outputs through unchanged', async () => {
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: 'ok',
+            Params: [{ Name: 'AgentRunID', Type: 'Output', Value: 'RUN-1' }],
+            LogEntry: { ID: 'LOG-2' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({}));
+
+        expect(result).toMatchObject({ Success: true, Output: { AgentRunID: 'RUN-1' }, ActionLogID: 'LOG-2' });
+    });
+});

package/src/__tests__/UpdateMJDataContextItem.oldValues.test.ts

@@ -0,0 +1,220 @@
+// type-graphql decorators in the resolver graph need the Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+/**
+ * `UpdateMJDataContextItem` goes through `ResolverBase.UpdateRecord`. `MJ: Data Context Items` does
+ * not track record changes, so without special handling a client that sends `OldValues___` decides
+ * the record's starting state. It could repeat its new SQL as the old value, so the SQL field does
+ * not look changed. Or it could leave `Type` and `SQL` out entirely, so they are never loaded and
+ * the stored procedure keeps the stored SQL item. The server entity class for the item must still
+ * refuse a non-Owner's save of a SQL item on every one of these paths.
+ *
+ * The resolver base and the entity class are real. The provider hands out real entity objects,
+ * loads a fixed stored row, and records each save instead of writing it.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { EntityInfo, Metadata, UserInfo, UserRoleInfo } from '@memberjunction/core';
+import type { BaseEntity, DatabaseProviderBase, IEntityDataProvider, IMetadataProvider } from '@memberjunction/core';
+import { MJDataContextItemEntityServer } from '@memberjunction/core-entities-server';
+import type { PubSubEngine } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import type { UserPayload } from '../types.js';
+
+const ENTITY_ID = 'E0000000-0000-4000-8000-0000000000D2';
+const UI_ROLE_ID = 'E1000000-0000-4000-8000-000000000001';
+const DATA_CONTEXT_ID = 'B0000000-0000-4000-8000-000000000001';
+const OTHER_DATA_CONTEXT_ID = 'B0000000-0000-4000-8000-000000000002';
+const ITEM_ID = 'C0000000-0000-4000-8000-000000000001';
+const STORED_SQL = 'SELECT 1 AS One';
+const NEW_SQL = 'SELECT 2 AS Two';
+
+interface StoredRow {
+    ID: string;
+    DataContextID: string;
+    Type: string;
+    SQL: string | null;
+    DataJSON: string | null;
+    Description: string | null;
+}
+
+/** A SQL item in someone else's data context. */
+const STORED_SQL_ITEM: StoredRow = {
+    ID: ITEM_ID, DataContextID: DATA_CONTEXT_ID, Type: 'sql', SQL: STORED_SQL, DataJSON: null, Description: 'Revenue',
+};
+
+/** An item of another type, with no SQL. */
+const STORED_ENTITY_ITEM: StoredRow = {
+    ID: ITEM_ID, DataContextID: DATA_CONTEXT_ID, Type: 'full_entity', SQL: null, DataJSON: null, Description: 'Notes',
+};
+
+/**
+ * `MJ: Data Context Items` as the database describes it: record changes and field-level security
+ * off, the API open, and the UI role holding every permission with no row-level filter.
+ */
+const ITEM_ENTITY = new EntityInfo({
+    ID: ENTITY_ID,
+    Name: 'MJ: Data Context Items',
+    SchemaName: '__mj',
+    BaseTable: 'DataContextItem',
+    BaseView: 'vwDataContextItems',
+    Status: 'Active',
+    IncludeInAPI: true,
+    AllowCreateAPI: true,
+    AllowUpdateAPI: true,
+    AllowDeleteAPI: true,
+    TrackRecordChanges: false,
+    EnableFieldLevelSecurity: false,
+    EntityPermissions: [{
+        ID: 'P0000000-0000-4000-8000-000000000001', EntityID: ENTITY_ID, RoleID: UI_ROLE_ID,
+        CanCreate: true, CanRead: true, CanUpdate: true, CanDelete: true,
+    }],
+    EntityFields: [
+        { Name: 'ID', Type: 'uniqueidentifier', AllowsNull: false, IsPrimaryKey: true },
+        { Name: 'DataContextID', Type: 'uniqueidentifier', AllowsNull: false },
+        { Name: 'Type', Type: 'nvarchar', AllowsNull: false },
+        { Name: 'SQL', Type: 'nvarchar', AllowsNull: true },
+        { Name: 'DataJSON', Type: 'nvarchar', AllowsNull: true },
+        { Name: 'Description', Type: 'nvarchar', AllowsNull: true },
+    ].map((c, i) => ({
+        ID: `F0000000-0000-4000-8000-00000000000${i}`,
+        EntityID: ENTITY_ID,
+        Sequence: i + 1,
+        Length: 0,
+        Precision: 0,
+        Scale: 0,
+        AllowUpdateAPI: true,
+        ...c,
+    })),
+});
+
+/** A UI-role user who is not an administrator. */
+const UI_USER = new UserInfo(null, {
+    ID: 'A0000000-0000-4000-8000-000000000002',
+    Email: 'ui-user@example.com',
+    Type: 'User',
+    UserRoles: [new UserRoleInfo({ UserID: 'A0000000-0000-4000-8000-000000000002', RoleID: UI_ROLE_ID })],
+});
+
+const PAYLOAD: UserPayload = { email: UI_USER.Email, userRecord: UI_USER, sessionId: 'test-session' };
+const PUB_SUB = { publish: async (): Promise<void> => undefined } as unknown as PubSubEngine;
+
+/** What one save would have written. */
+interface RecordedSave {
+    DataContextID: string;
+    SQL: string | null;
+    DataJSON: string | null;
+}
+
+/** A database provider whose load returns `stored`, and which records each save it receives. */
+function recordingDatabase(stored: StoredRow): { Saves: RecordedSave[]; Provider: DatabaseProviderBase } {
+    const saves: RecordedSave[] = [];
+    const entityData = {
+        async Load(): Promise<Record<string, unknown>> {
+            return { ...stored };
+        },
+        async Save(entity: BaseEntity): Promise<Record<string, unknown>> {
+            const item = entity as MJDataContextItemEntityServer;
+            saves.push({ DataContextID: item.DataContextID, SQL: item.SQL, DataJSON: item.DataJSON });
+            return entity.GetAll();
+        },
+    } as unknown as IEntityDataProvider;
+    const database = {
+        async GetEntityObject(_entityName: string, user: UserInfo): Promise<MJDataContextItemEntityServer> {
+            const item = new MJDataContextItemEntityServer(ITEM_ENTITY, entityData);
+            item.ContextCurrentUser = user;
+            return item;
+        },
+    } as unknown as DatabaseProviderBase;
+    return { Saves: saves, Provider: database };
+}
+
+/** Builds an `OldValues___` array from a plain object. */
+function oldValues(values: Record<string, string | null>): Array<{ Key: string; Value: string | null }> {
+    return Object.entries(values).map(([Key, Value]) => ({ Key, Value }));
+}
+
+/** Exposes ResolverBase's generic update path, which the generated `UpdateMJDataContextItem` mutation calls. */
+class UpdateHarness extends ResolverBase {
+    /** Runs the update and reports how it ended: 'saved', or the message it was refused with. */
+    public async Update(input: Record<string, unknown>, provider: DatabaseProviderBase): Promise<string> {
+        try {
+            await this.UpdateRecord('MJ: Data Context Items', input, provider, PAYLOAD, PUB_SUB);
+            return 'saved';
+        } catch (e) {
+            return e instanceof Error ? e.message : String(e);
+        }
+    }
+}
+
+const harness = new UpdateHarness();
+
+describe('UpdateMJDataContextItem — a non-Owner may not change a SQL item', () => {
+    it('refuses new SQL when the update loads the stored row (no OldValues___)', async () => {
+        const db = recordingDatabase(STORED_SQL_ITEM);
+
+        const outcome = await harness.Update({ ...STORED_SQL_ITEM, SQL: NEW_SQL }, db.Provider);
+
+        expect(db.Saves).toEqual([]);
+        expect(outcome).toMatch(/Owner-type/);
+    });
+
+    it('refuses new SQL when OldValues___ repeats the new SQL, so the field does not look changed', async () => {
+        const db = recordingDatabase(STORED_SQL_ITEM);
+        const input = {
+            ...STORED_SQL_ITEM,
+            SQL: NEW_SQL,
+            Description: 'Renamed',
+            OldValues___: oldValues({ ID: ITEM_ID, DataContextID: DATA_CONTEXT_ID, Type: 'sql', SQL: NEW_SQL, Description: 'Revenue' }),
+        };
+
+        const outcome = await harness.Update(input, db.Provider);
+
+        expect(db.Saves).toEqual([]);
+        expect(outcome).toMatch(/Owner-type/);
+    });
+
+    it('refuses moving a SQL item to another data context when Type and SQL are left out of the input and OldValues___', async () => {
+        const db = recordingDatabase(STORED_SQL_ITEM);
+        const input = {
+            ID: ITEM_ID,
+            DataContextID: OTHER_DATA_CONTEXT_ID,
+            OldValues___: oldValues({ ID: ITEM_ID, DataContextID: DATA_CONTEXT_ID }),
+        };
+
+        const outcome = await harness.Update(input, db.Provider);
+
+        expect(db.Saves).toEqual([]);
+        expect(outcome).toMatch(/Owner-type/);
+    });
+
+    it('refuses changing the cached DataJSON of a SQL item when Type and SQL are left out of the input and OldValues___', async () => {
+        const db = recordingDatabase(STORED_SQL_ITEM);
+        const input = {
+            ID: ITEM_ID,
+            DataJSON: '[{"One":2}]',
+            OldValues___: oldValues({ ID: ITEM_ID, DataJSON: null }),
+        };
+
+        const outcome = await harness.Update(input, db.Provider);
+
+        expect(db.Saves).toEqual([]);
+        expect(outcome).toMatch(/Owner-type/);
+    });
+
+    it('still saves a non-Owner\'s change to an item of another type that sends OldValues___', async () => {
+        // The success path maps the saved row back through the process-wide metadata.
+        vi.spyOn(Metadata, 'Provider', 'get').mockReturnValue(
+            { Entities: [ITEM_ENTITY], EntityByName: () => ITEM_ENTITY } as unknown as IMetadataProvider,
+        );
+        const db = recordingDatabase(STORED_ENTITY_ITEM);
+        const input = {
+            ID: ITEM_ID,
+            Description: 'Renamed',
+            OldValues___: oldValues({ ID: ITEM_ID, Description: 'Notes' }),
+        };
+
+        const outcome = await harness.Update(input, db.Provider);
+
+        expect(outcome).toBe('saved');
+        expect(db.Saves).toEqual([{ DataContextID: DATA_CONTEXT_ID, SQL: null, DataJSON: null }]);
+    });
+});

package/src/__tests__/VectorizeEntityResolver.test.ts

@@ -0,0 +1,106 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DatabaseProviderBase, UserInfo, type IMetadataProvider } from '@memberjunction/core';
+import sql from 'mssql';
+import { VectorizeEntityResolver } from '../resolvers/VectorizeEntityResolver.js';
+import type { AppContext, ProviderInfo } from '../types.js';
+
+const mockSyncerConstructedWith: (IMetadataProvider | undefined)[] = [];
+
+vi.mock('@memberjunction/ai-vector-sync', () => {
+    return {
+        EntityVectorSyncer: class {
+            constructor(provider?: IMetadataProvider) {
+                mockSyncerConstructedWith.push(provider);
+            }
+            Config() {
+                return Promise.resolve(undefined);
+            }
+            VectorizeEntity() {
+                return Promise.resolve({ success: true, status: 'Completed' });
+            }
+        },
+    };
+});
+
+vi.mock('../generic/PubSubManager.js', () => ({
+    PubSubManager: {
+        Instance: {
+            Publish: vi.fn(),
+        },
+    },
+}));
+
+function createAppContext(providers?: ProviderInfo[]): AppContext {
+    return {
+        dataSource: Object.create(sql.ConnectionPool.prototype) as sql.ConnectionPool,
+        dataSources: [],
+        providers: providers ?? [],
+        userPayload: {
+            email: 'test@example.com',
+            sessionId: 'test-session',
+            userRecord: new UserInfo(),
+        },
+    };
+}
+
+describe('VectorizeEntityResolver — provider propagation', () => {
+    beforeEach(() => {
+        mockSyncerConstructedWith.length = 0;
+    });
+
+    it('passes request-scoped Read-Write provider from AppContext to EntityVectorSyncer', async () => {
+        const mockProvider = Object.create(DatabaseProviderBase.prototype) as DatabaseProviderBase;
+        const providerInfo: ProviderInfo = {
+            provider: mockProvider,
+            type: 'Read-Write',
+        };
+
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-1',
+            'entity-1',
+            10,
+            createAppContext([providerInfo])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(result.Status).toBe('Started');
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBe(mockProvider);
+    });
+
+    it('falls back to Read-Only provider when no Read-Write provider exists', async () => {
+        const readOnlyProvider = Object.create(DatabaseProviderBase.prototype) as DatabaseProviderBase;
+        const providerInfo: ProviderInfo = {
+            provider: readOnlyProvider,
+            type: 'Read-Only',
+        };
+
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-2',
+            'entity-2',
+            10,
+            createAppContext([providerInfo])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBe(readOnlyProvider);
+    });
+
+    it('passes undefined provider to EntityVectorSyncer when no providers in AppContext', async () => {
+        const resolver = new VectorizeEntityResolver();
+        const result = await resolver.VectorizeEntity(
+            'doc-3',
+            'entity-3',
+            10,
+            createAppContext([])
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockSyncerConstructedWith.length).toBe(1);
+        expect(mockSyncerConstructedWith[0]).toBeUndefined();
+    });
+});