@memberjunction/server 5.23.0 → 5.25.0

package/src/generic/RunViewResolver.ts

@@ -765,6 +765,7 @@ export class RunViewResolver extends ResolverBase {
       for (const [index, data] of rawData.entries()) {
         // EntityName is backfilled by RunViewsGeneric when ViewID/ViewName was used
         const entity = input[index].EntityName ? provider.Entities.find((e) => e.Name === input[index].EntityName) : null;
+
         const returnData: any[] = this.processRawData(data.Results, entity ? entity.ID : null, entity);
 
         results.push({

package/src/index.ts

@@ -108,6 +108,7 @@ export * from './generic/DeleteOptionsInput.js';
 export * from './agents/skip-agent.js';
 export * from './agents/skip-sdk.js';
 
+export * from './resolvers/GeoResolver.js';
 export * from './resolvers/ColorResolver.js';
 export * from './resolvers/ComponentRegistryResolver.js';
 export * from './resolvers/DatasetResolver.js';
@@ -130,6 +131,7 @@ export * from './resolvers/ActionResolver.js';
 export * from './resolvers/EntityCommunicationsResolver.js';
 export * from './resolvers/EntityResolver.js';
 export * from './resolvers/ISAEntityResolver.js';
+export * from './resolvers/ArtifactFileResolver.js';
 export * from './resolvers/FileCategoryResolver.js';
 export * from './resolvers/FileResolver.js';
 export * from './resolvers/InfoResolver.js';

package/src/resolvers/ArtifactFileResolver.ts

@@ -0,0 +1,71 @@
+import { Resolver, Query, Arg, Ctx } from 'type-graphql';
+import { Metadata, IMetadataProvider } from '@memberjunction/core';
+import { MJArtifactVersionEntity, MJFileEntity } from '@memberjunction/core-entities';
+import { FileStorageEngine } from '@memberjunction/storage';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { AppContext } from '../types.js';
+import { GetReadWriteProvider } from '../util.js';
+
+/**
+ * GraphQL resolver that produces a short-lived download URL for an artifact version
+ * stored as a binary file (ContentMode = 'File').
+ *
+ * Separating this from the generated FileResolver keeps the artifact-specific
+ * logic in one place and avoids mixing concerns in the large FileResolver class.
+ */
+@Resolver()
+export class ArtifactFileResolver extends ResolverBase {
+
+    @Query(() => String, { description: 'Returns a pre-authenticated download URL for an artifact version whose ContentMode is "File".' })
+    async ArtifactFileDownloadUrl(
+        @Arg('artifactVersionId', () => String) artifactVersionId: string,
+        @Ctx() context: AppContext,
+    ): Promise<string> {
+        const user = this.GetUserFromPayload(context.userPayload);
+        if (!user) {
+            throw new Error('Unauthorized');
+        }
+
+        const p = GetReadWriteProvider(context.providers);
+
+        // Load the artifact version
+        const artifactVersion = await p.GetEntityObject<MJArtifactVersionEntity>('MJ: Artifact Versions', user);
+        const loaded = await artifactVersion.Load(artifactVersionId);
+        if (!loaded) {
+            throw new Error(`Artifact version ${artifactVersionId} not found`);
+        }
+
+        if (artifactVersion.ContentMode !== 'File') {
+            throw new Error(`Artifact version ${artifactVersionId} is not a file artifact (ContentMode=${artifactVersion.ContentMode})`);
+        }
+
+        if (!artifactVersion.FileID) {
+            throw new Error(`Artifact version ${artifactVersionId} has no associated file`);
+        }
+
+        return this.buildDownloadUrl(artifactVersion.FileID, user, p);
+    }
+
+    /** Load the File + its storage account/provider and generate a signed URL. */
+    private async buildDownloadUrl(
+        fileId: string,
+        user: ReturnType<ResolverBase['GetUserFromPayload']>,
+        provider: IMetadataProvider,
+    ): Promise<string> {
+        const fileEntity = await provider.GetEntityObject<MJFileEntity>('MJ: Files', user);
+        const fileLoaded = await fileEntity.Load(fileId);
+        if (!fileLoaded) {
+            throw new Error(`File record ${fileId} not found`);
+        }
+
+        // Find the storage account for this file's provider using cached metadata
+        await FileStorageEngine.Instance.Config(false, user!);
+        const matchingAccounts = FileStorageEngine.Instance.GetAccountsByProviderID(fileEntity.ProviderID);
+        if (matchingAccounts.length === 0) {
+            throw new Error(`No FileStorageAccount found for ProviderID ${fileEntity.ProviderID}. Cannot generate download URL.`);
+        }
+
+        const driver = await FileStorageEngine.Instance.GetDriver(matchingAccounts[0].ID, user!);
+        return driver.CreatePreAuthDownloadUrl(fileEntity.ProviderKey ?? fileEntity.Name);
+    }
+}

package/src/resolvers/AutotagPipelineResolver.ts

@@ -1,6 +1,7 @@
-import { Resolver, Mutation, Ctx, ObjectType, Field } from 'type-graphql';
+import { Resolver, Mutation, Ctx, Arg, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { MJContentProcessRunEntity } from '@memberjunction/core-entities';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { ActionEngineServer } from '@memberjunction/actions';
 import { PubSubManager } from '../generic/PubSubManager.js';
@@ -28,6 +29,8 @@ export class AutotagPipelineResult {
 export class AutotagPipelineResolver extends ResolverBase {
     @Mutation(() => AutotagPipelineResult)
     async RunAutotagPipeline(
+        @Arg('contentSourceIDs', () => [String], { nullable: true }) contentSourceIDs: string[] | undefined,
+        @Arg('forceReprocess', { nullable: true }) forceReprocess: boolean | undefined,
         @Ctx() { userPayload }: AppContext = {} as AppContext
     ): Promise<AutotagPipelineResult> {
         try {
@@ -40,7 +43,7 @@ export class AutotagPipelineResolver extends ResolverBase {
             LogStatus(`RunAutotagPipeline: starting pipeline ${pipelineRunID}`);
 
             // Fire-and-forget: start the pipeline in the background and return immediately
-            this.runPipelineInBackground(pipelineRunID, currentUser);
+            this.runPipelineInBackground(pipelineRunID, currentUser, contentSourceIDs, forceReprocess);
 
             return {
                 Success: true,
@@ -64,9 +67,13 @@ export class AutotagPipelineResolver extends ResolverBase {
      */
     private async runPipelineInBackground(
         pipelineRunID: string,
-        currentUser: import('@memberjunction/core').UserInfo
+        currentUser: UserInfo,
+        contentSourceIDs?: string[],
+        forceReprocess?: boolean
     ): Promise<void> {
         const startTime = Date.now();
+        const processRun = await this.createProcessRun(pipelineRunID, currentUser, contentSourceIDs);
+
         try {
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Initializing pipeline...');
 
@@ -78,27 +85,39 @@ export class AutotagPipelineResolver extends ResolverBase {
             if (!action) {
                 LogError(`RunAutotagPipeline: Action 'Autotag and Vectorize Content' not found`);
                 this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, 'Autotag action not found');
+                await this.completeProcessRun(processRun, 'Failed', 'Autotag action not found', currentUser);
                 return;
             }
 
             // Stage: autotagging — provide a progress callback that publishes per-item updates
+            // and keeps the process run record in sync
             this.publishProgress(pipelineRunID, 'autotag', 0, 0, startTime, 'Running autotaggers...');
 
             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`);
+                this.updateProcessRunProgress(processRun, processed, total);
             };
 
-            // Run with both Autotag=1 and Vectorize=1: the action will tag and embed in parallel
+            // Build action params — include the process run ID so the action can create detail records
+            const actionParams: Array<{ Name: string; Value: unknown; Type: 'Input' | 'Output' | 'Both' }> = [
+                { Name: 'Autotag', Value: 1, Type: 'Input' },
+                { Name: 'Vectorize', Value: 1, Type: 'Input' },
+                { Name: '__progressCallback', Value: progressCallback, Type: 'Input' },
+                { Name: 'ContentProcessRunID', Value: pipelineRunID, Type: 'Input' }
+            ];
+            if (contentSourceIDs && contentSourceIDs.length > 0) {
+                actionParams.push({ Name: 'ContentSourceIDs', Value: contentSourceIDs, Type: 'Input' });
+            }
+            if (forceReprocess) {
+                actionParams.push({ Name: 'ForceReprocess', Value: 1, Type: 'Input' });
+            }
+
             const result = await ActionEngineServer.Instance.RunAction({
                 Action: action,
                 ContextUser: currentUser,
                 Filters: [],
-                Params: [
-                    { Name: 'Autotag', Value: 1, Type: 'Input' },
-                    { Name: 'Vectorize', Value: 1, Type: 'Input' },
-                    { Name: '__progressCallback', Value: progressCallback, Type: 'Input' }
-                ]
+                Params: actionParams
             });
 
             // Stage: vectorize complete
@@ -107,14 +126,198 @@ export class AutotagPipelineResolver extends ResolverBase {
             if (result.Success) {
                 LogStatus(`RunAutotagPipeline: pipeline ${pipelineRunID} completed successfully`);
                 this.publishProgress(pipelineRunID, 'complete', 100, 100, startTime);
+                await this.completeProcessRun(processRun, 'Completed', undefined, currentUser);
             } else {
                 LogError(`RunAutotagPipeline: pipeline ${pipelineRunID} failed: ${result.Message}`);
                 this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, String(result.Message));
+                await this.completeProcessRun(processRun, 'Failed', String(result.Message), currentUser);
             }
         } catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             LogError(`RunAutotagPipeline pipeline ${pipelineRunID} failed: ${msg}`);
             this.publishProgress(pipelineRunID, 'error', 0, 0, startTime, msg);
+            await this.completeProcessRun(processRun, 'Failed', msg, currentUser);
+        }
+    }
+
+    /**
+     * Create a ContentProcessRun record to track this pipeline execution.
+     * Returns the entity so it can be updated during and after the run.
+     */
+    private async createProcessRun(
+        pipelineRunID: string,
+        currentUser: UserInfo,
+        contentSourceIDs?: string[]
+    ): Promise<MJContentProcessRunEntity | null> {
+        try {
+            // Resolve the source ID — use the specified source or the first available
+            let sourceID: string | undefined;
+            if (contentSourceIDs && contentSourceIDs.length > 0) {
+                sourceID = contentSourceIDs[0];
+            } else {
+                // Load content sources to get any available source ID (SourceID is NOT NULL)
+                const rv = new RunView();
+                const result = await rv.RunView<{ ID: string }>({
+                    EntityName: 'MJ: Content Sources',
+                    Fields: ['ID'],
+                    ResultType: 'simple',
+                    MaxRows: 1
+                }, currentUser);
+                if (result.Success && result.Results.length > 0) {
+                    sourceID = result.Results[0].ID;
+                }
+            }
+
+            if (!sourceID) {
+                LogError('RunAutotagPipeline: no content sources available, cannot create process run');
+                return null;
+            }
+
+            const md = new Metadata();
+            const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
+            run.NewRecord();
+            run.ID = pipelineRunID;
+            run.SourceID = sourceID;
+            run.StartTime = new Date();
+            run.Status = 'Running';
+            run.StartedByUserID = currentUser.ID;
+            run.ProcessedItems = 0;
+            run.TotalItemCount = 0;
+            run.LastProcessedOffset = 0;
+            run.ErrorCount = 0;
+            run.BatchSize = 20;
+            run.CancellationRequested = false;
+            const saved = await run.Save();
+            if (!saved) {
+                LogError(`RunAutotagPipeline: failed to create ContentProcessRun: ${run.LatestResult?.CompleteMessage}`);
+                return null;
+            }
+            LogStatus(`RunAutotagPipeline: created ContentProcessRun ${pipelineRunID}`);
+            return run;
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`RunAutotagPipeline: error creating ContentProcessRun: ${msg}`);
+            return null;
+        }
+    }
+
+    /**
+     * Update the process run record with current progress (fire-and-forget, non-blocking).
+     */
+    private updateProcessRunProgress(
+        processRun: MJContentProcessRunEntity | null,
+        processedItems: number,
+        totalItems: number
+    ): void {
+        if (!processRun) return;
+        processRun.ProcessedItems = processedItems;
+        processRun.TotalItemCount = totalItems;
+        processRun.LastProcessedOffset = processedItems;
+        // Fire-and-forget save — don't await to avoid slowing down the pipeline
+        processRun.Save().catch(e => {
+            LogError(`RunAutotagPipeline: error updating process run progress: ${e instanceof Error ? e.message : String(e)}`);
+        });
+    }
+
+    /**
+     * Mark the process run as completed, failed, or cancelled.
+     */
+    private async completeProcessRun(
+        processRun: MJContentProcessRunEntity | null,
+        status: string,
+        errorMessage: string | undefined,
+        currentUser: import('@memberjunction/core').UserInfo
+    ): Promise<void> {
+        if (!processRun) return;
+        try {
+            processRun.Status = status;
+            processRun.EndTime = new Date();
+            if (errorMessage) {
+                processRun.ErrorMessage = errorMessage;
+                processRun.ErrorCount = (processRun.ErrorCount ?? 0) + 1;
+            }
+            const saved = await processRun.Save();
+            if (!saved) {
+                LogError(`RunAutotagPipeline: failed to complete ContentProcessRun: ${processRun.LatestResult?.CompleteMessage}`);
+            }
+        } catch (error) {
+            LogError(`RunAutotagPipeline: error completing ContentProcessRun: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    /**
+     * Pause a running classification pipeline by setting CancellationRequested on the process run.
+     * The engine checks this flag between batches and pauses gracefully.
+     */
+    @Mutation(() => AutotagPipelineResult)
+    async PauseClassificationPipeline(
+        @Arg('processRunID') processRunID: string,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<AutotagPipelineResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
+            }
+
+            const md = new Metadata();
+            const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
+            const loaded = await run.Load(processRunID);
+            if (!loaded) {
+                return { Success: false, Status: 'Error', ErrorMessage: `Process run ${processRunID} not found` };
+            }
+
+            run.CancellationRequested = true;
+            await run.Save();
+
+            LogStatus(`PauseClassificationPipeline: Pause requested for run ${processRunID}`);
+            return { Success: true, Status: 'PauseRequested' };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { Success: false, Status: 'Error', ErrorMessage: msg };
+        }
+    }
+
+    /**
+     * Resume a paused classification pipeline from its last completed offset.
+     */
+    @Mutation(() => AutotagPipelineResult)
+    async ResumeClassificationPipeline(
+        @Arg('processRunID') processRunID: string,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<AutotagPipelineResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, Status: 'Error', ErrorMessage: 'Unable to determine current user' };
+            }
+
+            const md = new Metadata();
+            const run = await md.GetEntityObject<MJContentProcessRunEntity>('MJ: Content Process Runs', currentUser);
+            const loaded = await run.Load(processRunID);
+            if (!loaded) {
+                return { Success: false, Status: 'Error', ErrorMessage: `Process run ${processRunID} not found` };
+            }
+
+            if (run.Status !== 'Paused') {
+                return { Success: false, Status: 'Error', ErrorMessage: `Run is not paused (Status: ${run.Status})` };
+            }
+
+            // Reset cancellation flag and set status back to Running
+            run.CancellationRequested = false;
+            run.Status = 'Running';
+            await run.Save();
+
+            // Fire-and-forget: resume pipeline in background from the last offset
+            const pipelineRunID = uuidv4();
+            LogStatus(`ResumeClassificationPipeline: Resuming run ${processRunID} from offset ${run.LastProcessedOffset}`);
+
+            this.runPipelineInBackground(pipelineRunID, currentUser, undefined, undefined);
+
+            return { Success: true, Status: 'Resumed', PipelineRunID: pipelineRunID };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { Success: false, Status: 'Error', ErrorMessage: msg };
         }
     }
 

package/src/resolvers/FetchEntityVectorsResolver.ts

@@ -90,13 +90,17 @@ export class FetchEntityVectorsResolver extends ResolverBase {
             // but the metadata filter ensures we only get vectors for this entity.
             const entityName = entityDoc.Entity;
             const dimensions = vectorIndex.Dimensions || 1536; // fall back to common embedding size
-            const zeroVector = new Array(dimensions).fill(0);
+            // Use a tiny uniform vector instead of zero — cosine similarity is undefined
+            // for a zero vector (division by zero), causing Pinecone to return 0 matches.
+            // A uniform vector has equal similarity to all vectors, giving us an unbiased
+            // listing that respects the metadata filter.
+            const uniformVector = new Array(dimensions).fill(1.0 / Math.sqrt(dimensions));
 
             const metadataFilter: Record<string, unknown> = { Entity: { $eq: entityName } };
 
             const queryResponse = await vectorDBInstance.QueryIndex({
                 id: vectorIndex.Name,  // index name (stripped before Pinecone query)
-                vector: zeroVector,
+                vector: uniformVector,
                 topK: limit,
                 includeMetadata: true,
                 includeValues: true,

package/src/resolvers/FileResolver.ts

@@ -1,4 +1,4 @@
-import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions, RunView } from '@memberjunction/core';
+import { EntityPermissionType, Metadata, FieldValueCollection, EntitySaveOptions } from '@memberjunction/core';
 import { NormalizeUUID } from '@memberjunction/global';
 import { MJFileEntity, MJFileStorageProviderEntity, MJFileStorageAccountEntity } from '@memberjunction/core-entities';
 import {
@@ -32,7 +32,7 @@ import {
   FileSearchResult,
   UserContextOptions,
   ExtendedUserContextOptions,
-  initializeDriverWithAccountCredentials,
+  FileStorageEngine,
 } from '@memberjunction/storage';
 import { CreateMJFileInput, MJFileResolver as FileResolverBase, MJFile_, UpdateMJFileInput } from '../generated/generated.js';
 import { FieldMapper } from '@memberjunction/graphql-dataprovider';
@@ -648,12 +648,9 @@ export class FileResolver extends FileResolverBase {
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Create, true);
 
-    // Initialize driver with account-based credentials from Credential Engine
-    const driver = await initializeDriverWithAccountCredentials({
-      accountEntity,
-      providerEntity,
-      contextUser: user,
-    });
+    // Initialize driver via FileStorageEngine (handles credential decryption + token refresh)
+    await FileStorageEngine.Instance.Config(false, user);
+    const driver = await FileStorageEngine.Instance.GetDriver(accountEntity.ID, user);
 
     const success = await driver.CreateDirectory(input.Path);
     return success;
@@ -726,23 +723,12 @@ export class FileResolver extends FileResolverBase {
     const fileEntity = await md.GetEntityObject<MJFileEntity>('MJ: Files', user);
     fileEntity.CheckPermissions(EntityPermissionType.Read, true);
 
-    // Load all requested account entities in a single query
-    const rv = new RunView();
-    const quotedIDs = input.AccountIDs.map((id) => `'${id}'`).join(', ');
-    const accountResult = await rv.RunView<MJFileStorageAccountEntity>(
-      {
-        EntityName: 'MJ: File Storage Accounts',
-        ExtraFilter: `ID IN (${quotedIDs})`,
-        ResultType: 'entity_object',
-      },
-      user,
-    );
+    // Use cached accounts from the engine — no RunView needed
+    await FileStorageEngine.Instance.Config(false, user);
+    const normalizedIDs = new Set(input.AccountIDs.map((id: string) => NormalizeUUID(id)));
+    const accountEntities = FileStorageEngine.Instance.Accounts
+      .filter(a => normalizedIDs.has(NormalizeUUID(a.ID)));
 
-    if (!accountResult.Success) {
-      throw new Error(`Failed to load storage accounts: ${accountResult.ErrorMessage}`);
-    }
-
-    const accountEntities = accountResult.Results;
     if (accountEntities.length === 0) {
       throw new Error('No valid storage accounts found for the provided IDs');
     }
@@ -754,24 +740,9 @@ export class FileResolver extends FileResolverBase {
       console.warn(`[FileResolver] Accounts not found: ${missingIDs.join(', ')}`);
     }
 
-    // Load providers for all accounts
-    const providerIDs = [...new Set(accountEntities.map((a) => a.ProviderID))];
-    const quotedProviderIDs = providerIDs.map((id) => `'${id}'`).join(', ');
-    const providerResult = await rv.RunView<MJFileStorageProviderEntity>(
-      {
-        EntityName: 'MJ: File Storage Providers',
-        ExtraFilter: `ID IN (${quotedProviderIDs})`,
-        ResultType: 'entity_object',
-      },
-      user,
-    );
-
-    if (!providerResult.Success) {
-      throw new Error(`Failed to load storage providers: ${providerResult.ErrorMessage}`);
-    }
-
+    // Load providers from cached metadata
     const providerMap = new Map<string, MJFileStorageProviderEntity>();
-    for (const provider of providerResult.Results) {
+    for (const provider of FileStorageEngine.Instance.Providers) {
       providerMap.set(provider.ID, provider);
     }