@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.8

package/src/resolvers/AutotagPipelineResolver.ts

@@ -1,6 +1,7 @@
 import { Resolver, Mutation, Ctx, Arg, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { IMetadataProvider, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { IsValidUUID, EscapeSQLString } from '@memberjunction/global';
 import { MJContentProcessRunEntity } from '@memberjunction/core-entities';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { ActionEngineServer } from '@memberjunction/actions';
@@ -32,6 +33,7 @@ export class AutotagPipelineResolver extends ResolverBase {
     async RunAutotagPipeline(
         @Arg('contentSourceIDs', () => [String], { nullable: true }) contentSourceIDs: string[] | undefined,
         @Arg('forceReprocess', { nullable: true }) forceReprocess: boolean | undefined,
+        @Arg('pipelineRunID', { nullable: true }) clientPipelineRunID: string | undefined,
         @Ctx() { userPayload, providers }: AppContext = {} as AppContext
     ): Promise<AutotagPipelineResult> {
         try {
@@ -40,14 +42,37 @@ export class AutotagPipelineResolver extends ResolverBase {
                 return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
             }
 
-            const pipelineRunID = uuidv4();
-            LogStatus(`RunAutotagPipeline: starting pipeline ${pipelineRunID}`);
-
             // Capture the per-request provider snapshot before returning so the fire-and-forget
             // background job binds to the same connection the caller used. Without this, the
             // background job would silently use the global default — wrong for multi-tenant.
-            const provider = (GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider)
-                ?? (new Metadata() as unknown as IMetadataProvider);
+            const provider: IMetadataProvider = GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) ?? Metadata.Provider;
+
+            let pipelineRunID: string;
+            if (clientPipelineRunID != null) {
+                if (!IsValidUUID(clientPipelineRunID)) {
+                    return { Success: false, Status: 'Error', ErrorMessage: 'Invalid pipelineRunID format' };
+                }
+                const rv = RunView.FromMetadataProvider(provider);
+                const existing = await rv.RunView<{ ID: string }>({
+                    EntityName: 'MJ: Content Process Runs',
+                    ExtraFilter: `ID='${EscapeSQLString(clientPipelineRunID)}'`,
+                    Fields: ['ID'],
+                    ResultType: 'simple',
+                    MaxRows: 1,
+                    SkipTotalRowCount: true,
+                }, currentUser);
+                if (!existing.Success) {
+                    return { Success: false, Status: 'Error', ErrorMessage: existing.ErrorMessage || 'Failed to validate pipelineRunID' };
+                }
+                if (existing.Results.length > 0) {
+                    return { Success: false, Status: 'Error', ErrorMessage: `Pipeline run ${clientPipelineRunID} already exists` };
+                }
+                pipelineRunID = clientPipelineRunID;
+            } else {
+                pipelineRunID = uuidv4();
+            }
+
+            LogStatus(`RunAutotagPipeline: starting pipeline ${pipelineRunID}`);
 
             // Fire-and-forget: start the pipeline in the background and return immediately
             this.runPipelineInBackground(pipelineRunID, currentUser, provider, contentSourceIDs, forceReprocess);
@@ -101,9 +126,19 @@ export class AutotagPipelineResolver extends ResolverBase {
             // and keeps the process run record in sync
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Running autotaggers...');
 
+            let lastTotal = 0;
+            let lastProcessed = 0;
+            let lastLabel = 'Scanning & extracting content from sources...';
+
             const progressCallback = (processed: number, total: number, currentItem?: string) => {
-                const pct = total > 0 ? Math.round((processed / total) * 80) : 0; // 0-80% for tagging
-                this.publishProgress(pipelineRunID, 'autotag', total, pct, startTime, currentItem || `${processed}/${total} items`);
+                lastProcessed = processed;
+                lastTotal = total;
+                if (currentItem) {
+                    lastLabel = currentItem;
+                } else if (total > 0) {
+                    lastLabel = `${processed}/${total} items`;
+                }
+                this.publishProgress(pipelineRunID, 'autotag', total, processed, startTime, lastLabel);
                 this.updateProcessRunProgress(processRun, processed, total);
             };
 
@@ -121,12 +156,21 @@ export class AutotagPipelineResolver extends ResolverBase {
                 actionParams.push({ Name: 'ForceReprocess', Value: 1, Type: 'Input' });
             }
 
-            const result = await ActionEngineServer.Instance.RunAction({
-                Action: action,
-                ContextUser: currentUser,
-                Filters: [],
-                Params: actionParams
-            });
+            const heartbeatTimer = setInterval(() => {
+                this.publishProgress(pipelineRunID, 'autotag', lastTotal, lastProcessed, startTime, lastLabel);
+            }, 3000);
+
+            let result;
+            try {
+                result = await ActionEngineServer.Instance.RunAction({
+                    Action: action,
+                    ContextUser: currentUser,
+                    Filters: [],
+                    Params: actionParams
+                });
+            } finally {
+                clearInterval(heartbeatTimer);
+            }
 
             // Stage: vectorize complete
             this.publishProgress(pipelineRunID, 'vectorize', 100, 90, startTime, 'Vectorizing content...');
@@ -170,7 +214,8 @@ export class AutotagPipelineResolver extends ResolverBase {
                     EntityName: 'MJ: Content Sources',
                     Fields: ['ID'],
                     ResultType: 'simple',
-                    MaxRows: 1
+                    MaxRows: 1,
+                    SkipTotalRowCount: true
                 }, currentUser);
                 if (result.Success && result.Results.length > 0) {
                     sourceID = result.Results[0].ID;

package/src/resolvers/ConversationRunEventsResolver.ts

@@ -235,6 +235,7 @@ export class ConversationRunEventsResolver {
                 EntityName: 'MJ: Conversation Details',
                 ExtraFilter: `ID='${this.escape(conversationDetailID)}'`,
                 MaxRows: 1,
+                SkipTotalRowCount: true,
                 ResultType: 'entity_object',
                 BypassCache: true,
             },
@@ -259,6 +260,7 @@ export class ConversationRunEventsResolver {
                 ExtraFilter: `ConversationDetailID='${this.escape(conversationDetailID)}'`,
                 OrderBy: '__mj_CreatedAt DESC',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
                 Fields: RUN_FIELDS,
                 ResultType: 'simple',
                 BypassCache: true,

package/src/resolvers/ExecuteRemoteOperationResolver.ts

@@ -12,13 +12,13 @@ const REMOTE_OP_PROGRESS_TOPIC = 'RemoteOperationProgress';
 /** Input for the generic Remote Operation transport mutation. */
 @InputType()
 export class ExecuteRemoteOperationInput {
-    @Field()
+    @Field(() => 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()
+    @Field(() => 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()
+    @Field(() => String)
     invokeMode: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     /**
@@ -28,16 +28,24 @@ export class ExecuteRemoteOperationInput {
      */
     @Field(() => String, { nullable: true })
     progressChannelId?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
+
+    /**
+     * Optional structural contract fingerprint emitted by CodeGen (or supplied by the caller).
+     * When provided, the server rejects requests whose fingerprint diverges from the server's
+     * active operation contract with `ResultCode = 'CONTRACT_MISMATCH'`.
+     */
+    @Field(() => String, { nullable: true })
+    contractFingerprint?: string;  // case-violation-ok-legacy-back-compat: matches camelCase GraphQL input field convention on ExecuteRemoteOperationInput
 }
 
 /** A single streamed progress envelope delivered over the `RemoteOperationProgress` subscription. */
 @ObjectType()
 export class RemoteOperationProgressNotification {
-    @Field()
+    @Field(() => String)
     ChannelId: string;
 
     /** JSON-serialized {@link RemoteOpProgress}. */
-    @Field()
+    @Field(() => String)
     ProgressJSON: string;
 }
 
@@ -71,7 +79,7 @@ export class ExecuteRemoteOperationResultType {
 export class ExecuteRemoteOperationResolver extends ResolverBase {
     @Mutation(() => ExecuteRemoteOperationResultType)
     async ExecuteRemoteOperation(
-        @Arg('input') input: ExecuteRemoteOperationInput,
+        @Arg('input', () => ExecuteRemoteOperationInput) input: ExecuteRemoteOperationInput,
         @Ctx() ctx: AppContext,
         @PubSub() pubSub: PubSubEngine,
     ): Promise<ExecuteRemoteOperationResultType> {
@@ -111,9 +119,24 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
                 return fail(invokability.ResultCode ?? 'OPERATION_UNAVAILABLE', invokability.Reason ?? `Operation '${key}' is unavailable`);
             }
 
-            let parsedInput: unknown;
+            // (5) Contract fingerprint gate: when the client sends a contractFingerprint, verify it against
+            // the active server operation's ContractFingerprint (or metadata-derived fingerprint) so stale
+            // client bundles fail loudly with CONTRACT_MISMATCH rather than mis-deserializing.
+            const clientFingerprint = input.contractFingerprint?.trim();
+            if (clientFingerprint) {
+                const expectedFingerprint =
+                    opDecl?.ContractFingerprint ?? RemoteOperationEngineBase.Instance.GetContractFingerprint(key);
+                if (expectedFingerprint && clientFingerprint !== expectedFingerprint) {
+                    return fail(
+                        'CONTRACT_MISMATCH',
+                        `Contract fingerprint mismatch for operation '${key}' (client='${clientFingerprint}', server='${expectedFingerprint}')`,
+                    );
+                }
+            }
+
+            let parsedInput: object | string | number | boolean | null;
             try {
-                parsedInput = input.inputJSON ? JSON.parse(input.inputJSON) : {};
+                parsedInput = input.inputJSON ? (JSON.parse(input.inputJSON) as object | string | number | boolean | null) : {};
             } catch (e) {
                 return fail('INVALID_INPUT_JSON', `Invalid input JSON: ${e instanceof Error ? e.message : String(e)}`);
             }
@@ -127,7 +150,16 @@ export class ExecuteRemoteOperationResolver extends ResolverBase {
                 : undefined;
 
             // Route through the per-request provider (server in-process path; runs the op's Authorize + InternalExecute).
-            const result = await provider.RouteOperation(key, parsedInput, { user, mode: input.invokeMode as RemoteOpInvokeMode, onProgress });
+            const result = await provider.RouteOperation(key, parsedInput, {
+                user,
+                mode: input.invokeMode as RemoteOpInvokeMode,
+                onProgress,
+                contractFingerprint: clientFingerprint,
+                requestOrigin: ctx.RequestOrigin,
+                clientIp: ctx.ClientIp,
+                sessionId: ctx.userPayload?.sessionId,
+                apiKeyHash: ctx.userPayload?.apiKeyHash,
+            });
 
             return {
                 success: result.Success,

package/src/resolvers/GetDataResolver.ts

@@ -6,6 +6,7 @@ import { QueryCompositionEngine } from '@memberjunction/generic-database-provide
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { NoLog } from '../logging/NoLog.js';
 import { v4 as uuidv4 } from 'uuid';
+import { createHash, timingSafeEqual } from 'node:crypto';
 import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
 import { GetDbType } from '../index.js';
 import { GetSystemUser } from '../auth/index.js';
@@ -125,9 +126,9 @@ export class GetDataResolver {
             });
             LogStatus(`GetData invoked: ${input.Queries.length} queries`);
 
-            // validate the token
+            // validate the token (never echo the raw token into error messages or logs — Token is @NoLog)
             if (!IsTokenValid(input.Token)) {
-                throw new Error(`Token ${input.Token} is not valid or has expired`);
+                throw new Error('Access token is not valid or has expired');
             }
 
             // Use the read-only connection for executing queries
@@ -296,6 +297,26 @@ export class GetDataAccessToken {
 const __accessTokens: GetDataAccessToken[] = [];
 const __defaultTokenLifeSpan = 1000 * 60 * 5; // 5 minutes
 
+/**
+ * Non-short-circuiting constant-time scan over active access tokens: hashes the presented token
+ * once and compares against every stored token digest with `timingSafeEqual` without breaking early,
+ * so neither prefix similarity, token length, nor array index leaks through timing.
+ */
+function findMatchingAccessTokenIndex(token: string): number {
+    if (typeof token !== 'string' || token.length === 0) {
+        return -1;
+    }
+    const targetDigest = createHash('sha256').update(token).digest();
+    let matchedIndex = -1;
+    for (let i = 0; i < __accessTokens.length; i++) {
+        const candidateDigest = createHash('sha256').update(__accessTokens[i].Token).digest();
+        if (timingSafeEqual(candidateDigest, targetDigest)) {
+            matchedIndex = i;
+        }
+    }
+    return matchedIndex;
+}
+
 /**
  * Removes every token whose `ExpiresAt` has already passed (and its `TokenUses`
  * log along with it). Without this sweep `__accessTokens` grows forever — nothing
@@ -339,7 +360,7 @@ export function RegisterAccessToken(token?: string, lifeSpan: number = __default
 
     if (TokenExists(tokenToUse)) {
         // should never happen if we used the uuidv4() function but could happen if someone tries to use a custom token
-        throw new Error(`Token ${tokenToUse} already exists`);
+        throw new Error('Access token already exists');
     }
 
     const newToken = new GetDataAccessToken();
@@ -356,12 +377,12 @@ export function registerAccessToken(token?: string, lifeSpan: number = __default
     return RegisterAccessToken(token, lifeSpan, requestorPayload);
 }
 export function DeleteAccessToken(token: string) {
-    const index = __accessTokens.findIndex((t) => t.Token === token);
+    const index = findMatchingAccessTokenIndex(token);
     if (index >= 0) {
         __accessTokens.splice(index, 1);
     }
     else {
-        throw new Error(`Token ${token} does not exist`);
+        throw new Error('Access token does not exist');
     }
 }
 
@@ -370,7 +391,7 @@ export function deleteAccessToken(token: string) {
     return DeleteAccessToken(token);
 }
 export function TokenExists(token: string) {
-    return __accessTokens.find((t) => t.Token === token) !== undefined;
+    return findMatchingAccessTokenIndex(token) >= 0;
 }
 
 /** @deprecated Use {@link TokenExists}. */
@@ -378,9 +399,9 @@ export function tokenExists(token: string) {
     return TokenExists(token);
 }
 export function IsTokenValid(token: string) {
-    const t = __accessTokens.find((t) => t.Token === token);
-    if (t) {
-        return t.ExpiresAt > new Date();
+    const index = findMatchingAccessTokenIndex(token);
+    if (index >= 0) {
+        return __accessTokens[index].ExpiresAt > new Date();
     }
     return false;
 }
@@ -390,15 +411,16 @@ export function isTokenValid(token: string) {
     return IsTokenValid(token);
 } 
 export function RecordTokenUse(token: string, usePayload: any) {
-    const t = __accessTokens.find((t) => t.Token === token);
-    if (t) {
+    const index = findMatchingAccessTokenIndex(token);
+    if (index >= 0) {
+        const t = __accessTokens[index];
         if (!t.TokenUses) {
             t.TokenUses = [];
         }
-        t.TokenUses.push({ Token: token, UsedAt: new Date(), UsePayload: usePayload });
+        t.TokenUses.push({ Token: t.Token, UsedAt: new Date(), UsePayload: usePayload });
     }
     else {
-        throw new Error(`Token ${token} does not exist`);
+        throw new Error('Access token does not exist');
     }
 }
 

package/src/resolvers/InfoResolver.ts

@@ -42,7 +42,7 @@ export class InfoResolver {
       Version: packageJson.version,
       IsSystemUser: Boolean(context.userPayload.isSystemUser),
       Platform: os.platform(),
-      Arch: os.platform(),
+      Arch: os.arch(),
       CpuModel: os.cpus()?.[0].model,
       Hostname: os.hostname(),
     };