@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/__tests__/magicLinkService.consume.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
+
+// MagicLinkService is the imperative shell — importing it pulls the full
+// data-provider and communication stacks in at module load. Stub those out;
+// @memberjunction/core stays real (Metadata, RunView, LogError).
+vi.mock('@memberjunction/generic-database-provider', () => ({
+  UserCache: { Instance: { Users: [] } },
+}));
+vi.mock('@memberjunction/communication-engine', () => ({
+  CommunicationEngine: { Instance: {} },
+}));
+vi.mock('@memberjunction/communication-types', () => ({
+  Message: class {},
+}));
+vi.mock('../config.js', () => ({
+  configInfo: {},
+}));
+
+import { Metadata, RunView, type DatabaseProviderBase, type IMetadataProvider, type UserInfo } from '@memberjunction/core';
+import type { MJMagicLinkInviteEntity } from '@memberjunction/core-entities';
+import type { MagicLinkConfig } from '../config.js';
+import { MagicLinkService } from '../auth/magicLink/MagicLinkService.js';
+import { MAGIC_LINK_TOKEN_PREFIX, BuildConsumeInvitePostgresSQL } from '../auth/magicLink/magicLinkCore.js';
+
+type Platform = 'sqlserver' | 'postgresql';
+
+/** Provider surface consumeInvite/RedeemInvite touch, with real-shaped dialect behavior. */
+interface FakeProvider {
+  PlatformKey: Platform;
+  MJCoreSchemaName: string;
+  Roles: { ID: string; Name: string }[];
+  Applications: { ID: string; Name: string; Path: string }[];
+  Dialect: { ProcedureCallSyntax: (schema: string, name: string, params: string[]) => string };
+  BuildParameterPlaceholder: (index: number) => string;
+  ExecuteSQL: Mock;
+}
+
+function makeProvider(platform: Platform): FakeProvider {
+  const isPg = platform === 'postgresql';
+  return {
+    PlatformKey: platform,
+    MJCoreSchemaName: '__mj',
+    Roles: [{ ID: 'role-1', Name: 'Magic Link Baseline' }],
+    Applications: [],
+    Dialect: {
+      ProcedureCallSyntax: isPg
+        ? (s, n, p) => `SELECT * FROM ${s}."${n}"(${p.join(', ')})`
+        : (s, n, p) => `EXEC [${s}].[${n}] ${p.join(', ')}`,
+    },
+    BuildParameterPlaceholder: isPg ? (i) => `$${i + 1}` : (i) => `@p${i}`,
+    ExecuteSQL: vi.fn(),
+  };
+}
+
+const INVITE_ID = '11111111-2222-3333-4444-555555555555';
+
+function makeInvite(): MJMagicLinkInviteEntity {
+  return {
+    ID: INVITE_ID,
+    Status: 'Active',
+    UseCount: 0,
+    MaxUses: 1,
+    ExpiresAt: new Date(Date.now() + 3600_000),
+    RoleID: 'role-1',
+    CreatedByUserID: 'inviter-1',
+    ApplicationID: 'app-1',
+    Email: 'g@example.com',
+  } as unknown as MJMagicLinkInviteEntity;
+}
+
+/** Private surface of MagicLinkService the tests drive or stub. */
+interface ServicePrivates {
+  consumeInvite: (invite: MJMagicLinkInviteEntity, provider: DatabaseProviderBase, contextUser: UserInfo) => Promise<string>;
+  resolveProvisioningContextUser: () => UserInfo | null;
+  isInviterActive: (id: string) => boolean;
+  recordRedemption: () => Promise<void>;
+  provisionUser: () => Promise<{ success: boolean; error?: string }>;
+}
+
+describe('MagicLinkService.consumeInvite (#4753)', () => {
+  let service: MagicLinkService;
+  let privates: ServicePrivates;
+  let invite: MJMagicLinkInviteEntity;
+  const contextUser = { ID: 'ctx-user' } as UserInfo;
+
+  beforeEach(() => {
+    service = new MagicLinkService('https://mj.example.com', {} as MagicLinkConfig);
+    privates = service as unknown as ServicePrivates;
+    invite = makeInvite();
+  });
+
+  afterEach(() => {
+    Metadata.Provider = null as unknown as IMetadataProvider;
+  });
+
+  async function consume(provider: FakeProvider): Promise<string> {
+    return privates.consumeInvite(invite, provider as unknown as DatabaseProviderBase, contextUser);
+  }
+
+  it('SQL Server: calls spConsumeMagicLinkInvite with the ID bound by name, never interpolated', async () => {
+    const provider = makeProvider('sqlserver');
+    provider.ExecuteSQL.mockResolvedValue([{ ID: INVITE_ID }]);
+    await consume(provider);
+
+    expect(provider.ExecuteSQL).toHaveBeenCalledTimes(1);
+    const [sql, params, options, user] = provider.ExecuteSQL.mock.calls[0];
+    expect(sql).toBe('EXEC [__mj].[spConsumeMagicLinkInvite] @ID=@p0');
+    expect(params).toEqual([INVITE_ID]);
+    expect(options).toEqual(expect.objectContaining({ isMutation: true }));
+    expect(user).toBe(contextUser);
+    expect(sql).not.toContain(INVITE_ID);
+    expect(String(sql).toUpperCase()).not.toContain('UPDATE');
+  });
+
+  // PG has no spConsumeMagicLinkInvite function (the release-time converter does not emit
+  // procedures) and PG's runtime roles hold table DML, so PG keeps the direct guarded UPDATE.
+  it('PostgreSQL: runs the guarded UPDATE … RETURNING directly, with the ID bound as $1', async () => {
+    const provider = makeProvider('postgresql');
+    provider.ExecuteSQL.mockResolvedValue([{ ID: INVITE_ID }]);
+    await consume(provider);
+
+    expect(provider.ExecuteSQL).toHaveBeenCalledTimes(1);
+    const [sql, params, options, user] = provider.ExecuteSQL.mock.calls[0];
+    expect(sql).toBe(BuildConsumeInvitePostgresSQL('__mj.MagicLinkInvite'));
+    expect(sql).not.toContain('spConsumeMagicLinkInvite');
+    expect(params).toEqual([INVITE_ID]);
+    expect(options).toEqual(expect.objectContaining({ isMutation: true }));
+    expect(user).toBe(contextUser);
+    expect(sql).not.toContain(INVITE_ID);
+  });
+
+  it("PostgreSQL: maps one row to 'won', zero rows to 'lost', and a thrown error to 'failed'", async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const provider = makeProvider('postgresql');
+    provider.ExecuteSQL.mockResolvedValueOnce([{ ID: INVITE_ID }]).mockResolvedValueOnce([]).mockRejectedValueOnce(new Error('connection reset'));
+
+    expect(await consume(provider)).toBe('won');
+    expect(await consume(provider)).toBe('lost');
+    expect(await consume(provider)).toBe('failed');
+  });
+
+  it("returns 'won' when exactly one row comes back", async () => {
+    const provider = makeProvider('sqlserver');
+    provider.ExecuteSQL.mockResolvedValue([{ ID: INVITE_ID }]);
+    expect(await consume(provider)).toBe('won');
+  });
+
+  it("returns 'lost' when zero rows come back", async () => {
+    const provider = makeProvider('sqlserver');
+    provider.ExecuteSQL.mockResolvedValue([]);
+    expect(await consume(provider)).toBe('lost');
+  });
+
+  it("returns 'failed' and logs the invite ID when ExecuteSQL throws", async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const provider = makeProvider('sqlserver');
+    provider.ExecuteSQL.mockRejectedValue(new Error("The EXECUTE permission was denied on the object 'spConsumeMagicLinkInvite'"));
+
+    expect(await consume(provider)).toBe('failed');
+    const logged = errorSpy.mock.calls.map((call) => call.map(String).join(' '));
+    expect(logged.some((line) => line.includes(INVITE_ID) && line.includes('spConsumeMagicLinkInvite'))).toBe(true);
+  });
+
+  it("returns 'failed' when ExecuteSQL returns a non-array", async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    const provider = makeProvider('sqlserver');
+    provider.ExecuteSQL.mockResolvedValue(undefined);
+
+    expect(await consume(provider)).toBe('failed');
+    const logged = errorSpy.mock.calls.map((call) => call.map(String).join(' '));
+    expect(logged.some((line) => line.includes(INVITE_ID))).toBe(true);
+  });
+});
+
+describe('MagicLinkService.RedeemInvite consume outcome mapping (#4753)', () => {
+  let service: MagicLinkService;
+  let provider: FakeProvider;
+  let provisionUser: Mock;
+  const contextUser = { ID: 'ctx-user' } as UserInfo;
+  const rawToken = MAGIC_LINK_TOKEN_PREFIX + 'x';
+
+  beforeEach(() => {
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    provider = makeProvider('sqlserver');
+    Metadata.Provider = provider as unknown as IMetadataProvider;
+
+    service = new MagicLinkService('https://mj.example.com', {} as MagicLinkConfig);
+    const privates = service as unknown as ServicePrivates;
+    vi.spyOn(RunView.prototype, 'RunView').mockResolvedValue({ Success: true, Results: [makeInvite()] } as Awaited<ReturnType<RunView['RunView']>>);
+    vi.spyOn(privates, 'resolveProvisioningContextUser').mockReturnValue(contextUser);
+    vi.spyOn(privates, 'isInviterActive').mockReturnValue(true);
+    vi.spyOn(privates, 'recordRedemption').mockResolvedValue(undefined);
+    provisionUser = vi.fn().mockResolvedValue({ success: false, error: 'stop-here' });
+    privates.provisionUser = provisionUser;
+  });
+
+  afterEach(() => {
+    Metadata.Provider = null as unknown as IMetadataProvider;
+  });
+
+  it('RedeemInvite maps a failed consume to server_error, not consumed, and never provisions', async () => {
+    provider.ExecuteSQL.mockRejectedValue(new Error("The EXECUTE permission was denied on the object 'spConsumeMagicLinkInvite'"));
+    const result = await service.RedeemInvite(rawToken);
+
+    expect(result).toEqual(expect.objectContaining({ success: false, errorCode: 'server_error' }));
+    expect(provisionUser).not.toHaveBeenCalled();
+  });
+
+  it('RedeemInvite still reports consumed when the race is lost', async () => {
+    provider.ExecuteSQL.mockResolvedValue([]);
+    const result = await service.RedeemInvite(rawToken);
+
+    expect(result).toEqual(expect.objectContaining({ success: false, errorCode: 'consumed' }));
+    expect(provisionUser).not.toHaveBeenCalled();
+  });
+
+  it('RedeemInvite proceeds to provisioning when the consume wins', async () => {
+    provider.ExecuteSQL.mockResolvedValue([{ ID: INVITE_ID }]);
+    const result = await service.RedeemInvite(rawToken);
+
+    expect(provisionUser).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(expect.objectContaining({ success: false, errorCode: 'provisioning_failed' }));
+  });
+});

package/src/__tests__/meetingRecordingRegistration.test.ts

@@ -43,8 +43,8 @@ vi.mock('@memberjunction/core-entities', async (importOriginal) => {
 });
 
 import {
-  registerMeetingRecordingFile,
-  resolveMeetingConversation,
+  RegisterMeetingRecordingFile,
+  ResolveMeetingConversation,
   type MeetingRecordingEgressResult,
 } from '../resolvers/meetingRecordingRegistration';
 
@@ -124,7 +124,7 @@ describe('registerMeetingRecordingFile', () => {
       .mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-existing' }] });
 
     const { provider, created } = makeProvider();
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
 
     expect(result.Success).toBe(true);
     expect(result.RecordingFileID).toBe('file-123');
@@ -153,7 +153,7 @@ describe('registerMeetingRecordingFile', () => {
   it('prefers matching the conversation by EgressID when present', async () => {
     runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-by-egress' }] });
     const { provider } = makeProvider();
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
     expect(result.ConversationID).toBe('conv-by-egress');
     // Only the EgressID lookup ran (no fall-through to room-name lookup).
     expect(runViewMock).toHaveBeenCalledTimes(1);
@@ -162,7 +162,7 @@ describe('registerMeetingRecordingFile', () => {
   it('creates a Meeting-Room Conversation when none exists', async () => {
     runViewMock.mockResolvedValue({ Success: true, Results: [] }); // neither lookup matches
     const { provider, created } = makeProvider();
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
     expect(result.Success).toBe(true);
     const conv = created.conversation[0];
     expect(conv.fields.Type).toBe('Meeting Room');
@@ -173,7 +173,7 @@ describe('registerMeetingRecordingFile', () => {
   it('returns a graceful failure when the storage provider is not configured', async () => {
     delete process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
     const { provider } = makeProvider();
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
     expect(result.Success).toBe(false);
     expect(result.ErrorMessage).toMatch(/MJ_MEETING_RECORDING_STORAGE_PROVIDER/);
     expect(result.RecordingFileID).toBeUndefined();
@@ -182,14 +182,14 @@ describe('registerMeetingRecordingFile', () => {
   it('returns a graceful failure when no account is linked to the configured provider', async () => {
     storage.accountsByProvider = new Map(); // no accounts for prov-sink
     const { provider } = makeProvider();
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
     expect(result.Success).toBe(false);
     expect(result.ErrorMessage).toMatch(/No active MJStorage account/i);
   });
 
   it('returns a graceful failure when the egress has no output yet', async () => {
     const { provider } = makeProvider();
-    const result = await registerMeetingRecordingFile({ ...egress, OutputLocation: undefined }, user, provider);
+    const result = await RegisterMeetingRecordingFile({ ...egress, OutputLocation: undefined }, user, provider);
     expect(result.Success).toBe(false);
     expect(result.ErrorMessage).toMatch(/no output/i);
   });
@@ -204,7 +204,7 @@ describe('registerMeetingRecordingFile', () => {
       runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
 
       const { provider, created } = makeProvider();
-      const result = await registerMeetingRecordingFile(egress, user, provider);
+      const result = await RegisterMeetingRecordingFile(egress, user, provider);
 
       expect(result.Success).toBe(true);
       // Bytes were read from the sink and uploaded into the canonical provider.
@@ -221,7 +221,7 @@ describe('registerMeetingRecordingFile', () => {
       process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER = 'prov-sink'; // same as sink
       runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
       const { provider, created } = makeProvider();
-      const result = await registerMeetingRecordingFile(egress, user, provider);
+      const result = await RegisterMeetingRecordingFile(egress, user, provider);
       expect(result.Success).toBe(true);
       expect(storage.getObject).not.toHaveBeenCalled();
       expect(created.file[0].fields.ProviderID).toBe('prov-sink');
@@ -231,7 +231,7 @@ describe('registerMeetingRecordingFile', () => {
   it('fails gracefully (no throw) when the Files row save fails', async () => {
     runViewMock.mockResolvedValueOnce({ Success: true, Results: [{ ID: 'conv-1' }] });
     const { provider } = makeProvider({ fileSaveOk: false });
-    const result = await registerMeetingRecordingFile(egress, user, provider);
+    const result = await RegisterMeetingRecordingFile(egress, user, provider);
     expect(result.Success).toBe(false);
     expect(result.ErrorMessage).toMatch(/Files row/i);
   });
@@ -241,7 +241,7 @@ describe('resolveMeetingConversation', () => {
   it('falls back to creating a conversation when neither lookup matches', async () => {
     runViewMock.mockResolvedValue({ Success: true, Results: [] });
     const { provider, created } = makeProvider();
-    const id = await resolveMeetingConversation(egress, user, provider);
+    const id = await ResolveMeetingConversation(egress, user, provider);
     expect(id).toBe('conv-new');
     expect(created.conversation).toHaveLength(1);
   });

package/src/__tests__/metadataRefreshSignal.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/**
+ * Tests for the SIGHUP operator control that hard-reloads metadata in a running MJAPI.
+ * What matters: a signal triggers exactly one refresh, a burst of signals does not stack
+ * reloads, and a failing refresh never rejects out of a process signal listener.
+ */
+
+const { logStatusMock, logErrorMock } = vi.hoisted(() => ({
+  logStatusMock: vi.fn(),
+  logErrorMock: vi.fn()
+}));
+
+vi.mock('@memberjunction/core', () => ({
+  LogStatus: logStatusMock,
+  LogError: logErrorMock
+}));
+
+import { CreateMetadataRefreshSignalHandler, METADATA_REFRESH_SIGNAL } from '../metadataRefreshSignal.js';
+
+describe('CreateMetadataRefreshSignalHandler', () => {
+  beforeEach(() => {
+    logStatusMock.mockReset();
+    logErrorMock.mockReset();
+  });
+
+  it('uses SIGHUP, not SIGUSR1 (reserved by the Node inspector)', () => {
+    expect(METADATA_REFRESH_SIGNAL).toBe('SIGHUP');
+  });
+
+  it('runs the refresh once per signal', async () => {
+    const refresh = vi.fn(async () => true);
+    const handler = CreateMetadataRefreshSignalHandler(refresh);
+
+    await handler();
+    await handler();
+
+    expect(refresh).toHaveBeenCalledTimes(2);
+    expect(logErrorMock).not.toHaveBeenCalled();
+  });
+
+  it('ignores a signal that arrives while a refresh is still running', async () => {
+    let finish: (ok: boolean) => void = () => {};
+    const refresh = vi.fn(async () => true)
+      .mockImplementationOnce(() => new Promise<boolean>((resolve) => { finish = resolve; }));
+    const handler = CreateMetadataRefreshSignalHandler(refresh);
+
+    const first = handler();
+    await handler(); // arrives mid-refresh
+    finish(true);
+    await first;
+
+    expect(refresh).toHaveBeenCalledTimes(1);
+    expect(logStatusMock).toHaveBeenCalledWith(expect.stringContaining('already running'));
+
+    await handler(); // in-flight flag cleared after completion
+    expect(refresh).toHaveBeenCalledTimes(2);
+  });
+
+  it('logs, does not reject, and re-arms when the refresh throws', async () => {
+    const refresh = vi.fn(async (): Promise<boolean> => { throw new Error('db down'); });
+    const handler = CreateMetadataRefreshSignalHandler(refresh);
+
+    await expect(handler()).resolves.toBeUndefined();
+    expect(logErrorMock).toHaveBeenCalledTimes(1);
+
+    await handler();
+    expect(refresh).toHaveBeenCalledTimes(2);
+  });
+
+  it('logs an error when the refresh reports failure', async () => {
+    const handler = CreateMetadataRefreshSignalHandler(async () => false);
+
+    await handler();
+
+    expect(logErrorMock).toHaveBeenCalledWith(expect.stringContaining('reported failure'));
+  });
+});