@memberjunction/server 5.45.0 → 5.46.0

package/src/__tests__/RunAIAgentResolver.streaming.test.ts

@@ -0,0 +1,128 @@
+/**
+ * @fileoverview Wire-shape tests for RunAIAgentResolver's streaming callback.
+ *
+ * The conversation client (ConversationsRuntime's ConversationStreaming) parses the
+ * exact JSON this resolver publishes to the PushStatusUpdates topic — in particular
+ * `data.type === 'streaming'` and `data.streaming.{content,isPartial,kind}`. These
+ * tests pin the published shape so the server and client can't silently drift
+ * (the client's own parsing of this same shape is pinned in
+ * packages/ConversationsRuntime/src/__tests__/ConversationStreaming.test.ts).
+ */
+import 'reflect-metadata'; // must precede any type-graphql decorator evaluation
+import { describe, it, expect, vi } from 'vitest';
+import type { PubSubEngine } from 'type-graphql';
+
+// type-graphql's real decorators need emitDecoratorMetadata to infer field types
+// (`@Field() success: boolean`), which vitest's esbuild transform does not emit.
+// The GraphQL schema is irrelevant here — no-op every decorator so the resolver
+// module can be imported and its streaming callback exercised directly.
+vi.mock('type-graphql', () => {
+    const decoratorFactory = (..._args: unknown[]) => (..._decorated: unknown[]) => undefined;
+    const exportNames = [
+        'Resolver', 'Query', 'Mutation', 'Subscription', 'Arg', 'Args', 'ArgsType', 'Ctx', 'Root',
+        'Info', 'Field', 'FieldResolver', 'ObjectType', 'InputType', 'InterfaceType', 'Authorized',
+        'UseMiddleware', 'Extensions', 'Directive', 'ID', 'Int', 'Float', 'GraphQLISODateTime',
+        'GraphQLTimestamp', 'registerEnumType', 'createMethodDecorator', 'createParamDecorator',
+        'buildSchema', 'buildSchemaSync', 'PubSub',
+    ];
+    return Object.fromEntries(exportNames.map((name) => [name, decoratorFactory]));
+});
+import type { AgentExecutionStreamingCallback } from '@memberjunction/ai-core-plus';
+
+import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import type { UserPayload } from '../types.js';
+
+/** Access the private factory without widening the class's public API. */
+interface StreamingCallbackFactory {
+    createStreamingCallback(
+        pubSub: PubSubEngine,
+        sessionId: string,
+        userPayload: UserPayload,
+        agentRunRef: { current: unknown }
+    ): AgentExecutionStreamingCallback;
+}
+
+function buildHarness() {
+    const publish = vi.fn().mockResolvedValue(undefined);
+    const pubSub = { publish } as unknown as PubSubEngine;
+    const userPayload = { sessionId: 'session-1' } as UserPayload;
+    const agentRunRef = {
+        current: {
+            ID: 'run-1',
+            GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
+        },
+    };
+    const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
+    const callback = resolver.createStreamingCallback(pubSub, 'session-1', userPayload, agentRunRef);
+    return { publish, callback };
+}
+
+/** Parse the published envelope back out of the pubSub.publish mock. */
+function publishedData(publish: ReturnType<typeof vi.fn>): Record<string, unknown> {
+    expect(publish).toHaveBeenCalledOnce();
+    const envelope = publish.mock.calls[0][1] as { message: string };
+    const parsed = JSON.parse(envelope.message) as Record<string, unknown>;
+    expect(parsed.type).toBe('StreamingContent');
+    expect(parsed.resolver).toBe('RunAIAgentResolver');
+    return parsed.data as Record<string, unknown>;
+}
+
+describe('RunAIAgentResolver.createStreamingCallback', () => {
+    it('publishes the streaming wire shape the conversation client parses', () => {
+        const { publish, callback } = buildHarness();
+
+        callback({ content: 'Hel', isComplete: false, stepType: 'prompt', modelName: 'gpt-x', kind: 'final-response' });
+
+        const data = publishedData(publish);
+        expect(data.type).toBe('streaming');
+        expect(data.agentRunId).toBe('run-1');
+        expect((data.agentRun as Record<string, unknown>).ConversationDetailID).toBe('detail-1');
+        expect(data.streaming).toMatchObject({
+            content: 'Hel',
+            isPartial: true,
+            stepName: 'prompt',
+            kind: 'final-response',
+        });
+    });
+
+    it('maps isComplete=true to isPartial=false on the final chunk', () => {
+        const { publish, callback } = buildHarness();
+
+        callback({ content: '', isComplete: true, kind: 'final-response' });
+
+        const data = publishedData(publish);
+        expect((data.streaming as Record<string, unknown>).isPartial).toBe(false);
+    });
+
+    it('passes an absent kind through untouched — unmarked raw streams must stay unrendered', () => {
+        // Guard rail: if the resolver ever defaults unmarked chunks to a renderable
+        // kind (e.g. `chunk.kind ?? 'final-response'` left in from local testing),
+        // every Loop agent's raw JSON envelope would render into chat bubbles.
+        // This test fails the moment such a fallback exists.
+        const { publish, callback } = buildHarness();
+
+        callback({ content: '{"taskComplete":', isComplete: false, stepType: 'prompt' });
+
+        const data = publishedData(publish);
+        expect((data.streaming as Record<string, unknown>).kind).toBeUndefined();
+    });
+
+    it('does not publish when no agent run is available yet', () => {
+        const publish = vi.fn();
+        const pubSub = { publish } as unknown as PubSubEngine;
+        const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
+        const callback = resolver.createStreamingCallback(
+            pubSub,
+            'session-1',
+            { sessionId: 'session-1' } as UserPayload,
+            { current: null }
+        );
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        try {
+            callback({ content: 'early', isComplete: false });
+            expect(publish).not.toHaveBeenCalled();
+        } finally {
+            consoleSpy.mockRestore();
+        }
+    });
+});

package/src/__tests__/magicLink.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import jwt from 'jsonwebtoken';
-import { createPublicKey } from 'node:crypto';
+import { createPublicKey, type JsonWebKey } from 'node:crypto';
 import {
   generateRawToken,
   hashToken,
@@ -228,6 +228,56 @@ describe('magic-link core', () => {
     });
   });
 
+  describe('buildConsumeInviteSQL (postgresql dialect)', () => {
+    // PG uses `schema.table` (unquoted — PostgreSQLDataProvider.ExecuteSQL auto-quotes
+    // the PascalCase identifiers). SS uses the bracket-quoted `[schema].[table]` form.
+    const pgTable = '__mj.MagicLinkInvite';
+    const pgSql = buildConsumeInviteSQL(pgTable, 'postgresql');
+
+    it('targets the supplied unquoted schema.table', () => {
+      expect(pgSql).toContain(`UPDATE ${pgTable} `);
+    });
+
+    it('uses UPDATE … RETURNING as the atomic single-use gate (no OUTPUT/DECLARE table var)', () => {
+      expect(pgSql).toContain('RETURNING ID;');
+      expect(pgSql).not.toContain('OUTPUT');
+      expect(pgSql).not.toContain('DECLARE');
+    });
+
+    it('binds the invite ID as PG positional param $1, not T-SQL @p0 (injection-safe)', () => {
+      expect(pgSql).toContain('ID = $1');
+      expect(pgSql).not.toContain('@p0');
+      expect(pgSql).not.toMatch(/@/); // no T-SQL @-anything survives on PG
+      expect(pgSql).not.toMatch(/ID = '/);
+    });
+
+    it('uses PG timestamp expressions, not T-SQL SYSUTCDATETIME()', () => {
+      expect(pgSql).not.toContain('SYSUTCDATETIME');
+      expect(pgSql).toContain("(now() AT TIME ZONE 'utc')");
+      expect(pgSql).toContain("ConsumedAt = COALESCE(ConsumedAt, (now() AT TIME ZONE 'utc'))");
+    });
+
+    it('guards atomically on Active + not-exhausted + not-expired (same predicate as SS)', () => {
+      const where = pgSql.slice(pgSql.indexOf('WHERE'));
+      expect(where).toContain("Status = 'Active'");
+      expect(where).toContain('UseCount < MaxUses');
+      expect(where).toContain("ExpiresAt > (now() AT TIME ZONE 'utc')");
+    });
+
+    it('increments UseCount and flips Status on the last use (same semantics as SS)', () => {
+      expect(pgSql).toContain('UseCount = UseCount + 1');
+      expect(pgSql).toContain("Status = CASE WHEN UseCount + 1 >= MaxUses THEN 'Consumed' ELSE Status END");
+    });
+
+    it('rejects a non-whitelisted PG table identifier (defense-in-depth against injection)', () => {
+      // Bracket-quoted (SS) form is not a valid PG identifier here.
+      expect(() => buildConsumeInviteSQL('[__mj].[MagicLinkInvite]', 'postgresql')).toThrow();
+      expect(() => buildConsumeInviteSQL('__mj.MagicLinkInvite; DROP TABLE x;--', 'postgresql')).toThrow();
+      expect(() => buildConsumeInviteSQL('__mj.Magic Link', 'postgresql')).toThrow();
+      expect(() => buildConsumeInviteSQL(pgTable, 'postgresql')).not.toThrow();
+    });
+  });
+
   describe('canIssueInvites', () => {
     it('always allows Owners, regardless of issuer-role config (case/space-insensitive)', () => {
       expect(canIssueInvites('Owner', [], [])).toBe(true);
@@ -351,7 +401,7 @@ describe('MagicLinkKeyManager', () => {
     expect(header.kid).toBe(jwk.kid);
 
     // Full verification against the public key reconstructed from the JWK.
-    const publicKey = createPublicKey({ key: jwk as object, format: 'jwk' });
+    const publicKey = createPublicKey({ key: jwk as unknown as JsonWebKey, format: 'jwk' });
     const decoded = jwt.verify(token, publicKey, {
       algorithms: ['RS256'],
       issuer: 'http://localhost:4051',
@@ -375,7 +425,7 @@ describe('MagicLinkKeyManager', () => {
       ttlSeconds: 3600,
     });
     const token = km.Sign(claims);
-    const publicKey = createPublicKey({ key: km.GetJWKS().keys[0] as object, format: 'jwk' });
+    const publicKey = createPublicKey({ key: km.GetJWKS().keys[0] as unknown as JsonWebKey, format: 'jwk' });
 
     // Flip a character in the payload segment.
     const parts = token.split('.');

package/src/auth/magicLink/MagicLinkService.ts

@@ -640,6 +640,13 @@ export class MagicLinkService {
    * a single atomic operation. Returns true ONLY when this call updated the row
    * (won the race); concurrent redemptions of a single-use link see 0 rows.
    *
+   * Dialect-aware: SQL Server uses an `OUTPUT`-into-table-variable win-detect;
+   * PostgreSQL uses `UPDATE … WHERE … RETURNING` (the WHERE guard is itself the
+   * atomic single-use gate). The platform is read from the provider itself
+   * (`PlatformKey`), not from process env, so this is correct even under a
+   * non-default per-connection provider. The invite ID always binds as a
+   * parameter (`@p0` / `$1`), never interpolated.
+   *
    * Fail-closed: any DB error returns false and the redemption is rejected.
    */
   private async consumeInvite(invite: MJMagicLinkInviteEntity, provider: DatabaseProviderBase, contextUser: UserInfo): Promise<boolean> {
@@ -649,9 +656,12 @@ export class MagicLinkService {
         LogError(`[MagicLink] Entity metadata for '${INVITE_ENTITY}' not found; cannot consume invite.`);
         return false;
       }
-      const table = `[${entityInfo.SchemaName}].[${entityInfo.BaseTable}]`;
-      // OUTPUT returns one row iff the WHERE matched — the atomic single-use gate.
-      const sql = buildConsumeInviteSQL(table);
+      const isPg = provider.PlatformKey === 'postgresql';
+      // PG identifiers are auto-quoted by PostgreSQLDataProvider.ExecuteSQL, so
+      // pass the bare `schema.table`; SQL Server takes the bracket-quoted form.
+      const table = isPg ? `${entityInfo.SchemaName}.${entityInfo.BaseTable}` : `[${entityInfo.SchemaName}].[${entityInfo.BaseTable}]`;
+      // OUTPUT/RETURNING yields one row iff the WHERE matched — the atomic single-use gate.
+      const sql = buildConsumeInviteSQL(table, isPg ? 'postgresql' : 'sqlserver');
       const rows = await provider.ExecuteSQL<{ ID: string }>(sql, [invite.ID], { isMutation: true }, contextUser);
       return Array.isArray(rows) && rows.length === 1;
     } catch (e) {

package/src/auth/magicLink/magicLinkCore.ts

@@ -106,35 +106,63 @@ export function evaluateInvite(invite: InviteEvaluationInput, nowMs: number): {
   return { ok: true };
 }
 
+/** SQL dialect for {@link buildConsumeInviteSQL}. */
+export type ConsumeInviteDialect = 'sqlserver' | 'postgresql';
+
+/** SQL Server table identifier — bracket-quoted `[schema].[table]` (word chars only). */
+const QUALIFIED_TABLE_PATTERN = /^\[\w+\]\.\[\w+\]$/;
+/** PostgreSQL table identifier — `schema.table` (word chars only); auto-quoted downstream. */
+const QUALIFIED_TABLE_PATTERN_PG = /^\w+\.\w+$/;
+
 /**
- * Builds the atomic compare-and-swap UPDATE that consumes one use of an invite.
+ * Builds the atomic compare-and-swap UPDATE that consumes one use of an invite,
+ * in the given SQL dialect.
  *
  * The WHERE clause re-checks every eligibility condition at the DB level, so the
  * increment and the guard are a single atomic operation: concurrent redemptions
- * of a single-use link race on the row and exactly one matches (the matched row
- * is returned via OUTPUT). This is what actually enforces single-use — the
- * JS-side `evaluateInvite` is only a friendly pre-check.
+ * of a single-use link race on the row and exactly one matches. This is what
+ * actually enforces single-use — the JS-side `evaluateInvite` is only a friendly
+ * pre-check. The matched row's ID is returned to the caller (via `OUTPUT` on SQL
+ * Server, `RETURNING` on PostgreSQL) so it can detect a win (exactly one row).
+ *
+ * The invite ID MUST be bound as a parameter by the caller (`@p0` on SQL Server,
+ * `$1` on PostgreSQL) — it is never interpolated into the string, so this builder
+ * is injection-safe regardless of the ID's contents.
  *
- * The invite ID MUST be bound as parameter `@p0` by the caller — it is never
- * interpolated into the string, so this builder is injection-safe regardless of
- * the ID's contents.
+ * **SQL Server** — `OUTPUT` goes `INTO` a table variable (not a bare OUTPUT):
+ * SQL Server forbids a bare OUTPUT clause on a table that has enabled triggers,
+ * and CodeGen adds an `__mj_UpdatedAt` trigger to every MJ table. The trailing
+ * SELECT returns the matched row(s) regardless of trigger behavior.
  *
- * OUTPUT goes `INTO` a table variable (not a bare OUTPUT): SQL Server forbids a
- * bare OUTPUT clause on a table that has enabled triggers, and CodeGen adds an
- * `__mj_UpdatedAt` trigger to every MJ table. The trailing SELECT returns exactly
- * the matched row(s) so the caller can detect a win (exactly one row) regardless
- * of trigger behavior.
+ * **PostgreSQL** — the `UPDATE … WHERE` guard IS itself the atomic single-use
+ * gate: the row is locked for the UPDATE's duration, so concurrent redemptions
+ * serialize and only the first matching `Status='Active' AND UseCount < MaxUses`
+ * wins; `RETURNING` yields the row iff the guard matched (equivalent to the SS
+ * `OUTPUT`-into-table win-detect). PascalCase identifiers are auto-quoted by
+ * `PostgreSQLDataProvider.ExecuteSQL`, so the table is passed unquoted (`schema.table`).
  *
- * `qualifiedTable` is asserted to be a bracket-quoted `[schema].[table]` (word
- * chars only) before interpolation. The caller derives it from `EntityInfo`
- * (never user input), so this is defense-in-depth: even a future careless caller
- * cannot turn this into an injection vector — a non-conforming table throws.
+ * `qualifiedTable` is asserted to match the dialect's whitelist pattern before
+ * interpolation. The caller derives it from `EntityInfo` (never user input), so
+ * this is defense-in-depth: even a future careless caller cannot turn this into
+ * an injection vector — a non-conforming table throws.
  *
- * @param qualifiedTable  bracket-quoted `[schema].[table]` for MagicLinkInvite
+ * @param qualifiedTable  `[schema].[table]` (sqlserver) or `schema.table` (postgresql) for MagicLinkInvite
+ * @param dialect         target SQL dialect (defaults to `'sqlserver'`)
  */
-const QUALIFIED_TABLE_PATTERN = /^\[\w+\]\.\[\w+\]$/;
-
-export function buildConsumeInviteSQL(qualifiedTable: string): string {
+export function buildConsumeInviteSQL(qualifiedTable: string, dialect: ConsumeInviteDialect = 'sqlserver'): string {
+  if (dialect === 'postgresql') {
+    if (!QUALIFIED_TABLE_PATTERN_PG.test(qualifiedTable)) {
+      throw new Error(`buildConsumeInviteSQL: refusing to build SQL for non-whitelisted table identifier '${qualifiedTable}'.`);
+    }
+    return (
+      `UPDATE ${qualifiedTable} ` +
+      `SET UseCount = UseCount + 1, ` +
+      `ConsumedAt = COALESCE(ConsumedAt, (now() AT TIME ZONE 'utc')), ` +
+      `Status = CASE WHEN UseCount + 1 >= MaxUses THEN 'Consumed' ELSE Status END ` +
+      `WHERE ID = $1 AND Status = 'Active' AND UseCount < MaxUses AND ExpiresAt > (now() AT TIME ZONE 'utc') ` +
+      `RETURNING ID;`
+    );
+  }
   if (!QUALIFIED_TABLE_PATTERN.test(qualifiedTable)) {
     throw new Error(`buildConsumeInviteSQL: refusing to build SQL for non-whitelisted table identifier '${qualifiedTable}'.`);
   }