@memberjunction/server 5.24.0 → 5.26.0

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';
@@ -127,9 +128,11 @@ export * from './resolvers/TelemetryResolver.js';
 export * from './resolvers/APIKeyResolver.js';
 export * from './resolvers/MCPResolver.js';
 export * from './resolvers/ActionResolver.js';
+export * from './resolvers/CacheStatsResolver.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';
@@ -449,8 +452,21 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
   }
   // Ensure LocalCacheManager is initialized (no-op if already done during engine loading)
   if (!LocalCacheManager.Instance.IsInitialized) {
-    await LocalCacheManager.Instance.Initialize(Metadata.Provider.LocalStorageProvider);
-    console.log('LocalCacheManager initialized');
+    // Build cache config from mj.config.cjs cacheSettings
+    const cs = configInfo.cacheSettings;
+    const cacheConfig = {
+      maxSizeBytes: (cs.maxMemoryMB ?? 150) * 1024 * 1024,
+      maxPercentOfCachePerEntity: cs.maxPercentOfCachePerEntity ?? 50,
+      defaultTTLMs: (cs.defaultTTLSeconds ?? 0) * 1000,
+      evictionSweepIntervalMs: (cs.evictionSweepIntervalSeconds ?? 300) * 1000,
+      verboseLogging: cs.verboseLogging ?? false,
+    };
+    await LocalCacheManager.Instance.Initialize(Metadata.Provider.LocalStorageProvider, cacheConfig);
+    console.log('LocalCacheManager initialized with cache config:', JSON.stringify({
+      maxMemoryMB: cs.maxMemoryMB ?? 150,
+      maxPercentOfCachePerEntity: cs.maxPercentOfCachePerEntity ?? 50,
+      evictionSweepIntervalSeconds: cs.evictionSweepIntervalSeconds ?? 300,
+    }));
   }
 
   // Initialize APIKeyEngine singleton — reads apiKeyGeneration from mj.config.cjs automatically

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,6 @@
 import { Resolver, Mutation, Ctx, Arg, ObjectType, Field } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus, Metadata } 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';
@@ -67,11 +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...');
 
@@ -83,22 +85,26 @@ 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);
             };
 
-            // Build action params
+            // 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: '__progressCallback', Value: progressCallback, Type: 'Input' },
+                { Name: 'ContentProcessRunID', Value: pipelineRunID, Type: 'Input' }
             ];
             if (contentSourceIDs && contentSourceIDs.length > 0) {
                 actionParams.push({ Name: 'ContentSourceIDs', Value: contentSourceIDs, Type: 'Input' });
@@ -120,14 +126,122 @@ 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)}`);
         }
     }
 

package/src/resolvers/CacheStatsResolver.ts

@@ -0,0 +1,142 @@
+import { Field, Float, Int, ObjectType, Query, Resolver } from 'type-graphql';
+import { LocalCacheManager, CacheStats, CacheEntryType } from '@memberjunction/core';
+import { RequireSystemUser } from '../directives/index.js';
+
+// ============================================================================
+// GraphQL Object Types
+// ============================================================================
+
+@ObjectType()
+class CacheStatsByTypeGQL {
+    @Field(() => String)
+    Type: CacheEntryType;
+
+    @Field(() => Int)
+    Count: number;
+
+    @Field(() => Int)
+    SizeBytes: number;
+}
+
+@ObjectType()
+class CacheStatsGQL {
+    @Field(() => Int)
+    TotalEntries: number;
+
+    @Field(() => Int)
+    TotalSizeBytes: number;
+
+    @Field(() => [CacheStatsByTypeGQL])
+    ByType: CacheStatsByTypeGQL[];
+
+    @Field(() => Float)
+    OldestEntry: number;
+
+    @Field(() => Float)
+    NewestEntry: number;
+
+    @Field(() => Int)
+    Hits: number;
+
+    @Field(() => Int)
+    Misses: number;
+
+    @Field(() => Float)
+    HitRate: number;
+}
+
+@ObjectType()
+class CacheEntityBreakdownGQL {
+    @Field(() => String)
+    EntityName: string;
+
+    @Field(() => Int)
+    EntryCount: number;
+
+    @Field(() => Int)
+    TotalSizeBytes: number;
+
+    @Field(() => Int)
+    TotalAccessCount: number;
+}
+
+@ObjectType()
+class CacheStatsDetailGQL extends CacheStatsGQL {
+    @Field(() => [CacheEntityBreakdownGQL])
+    EntityBreakdown: CacheEntityBreakdownGQL[];
+}
+
+// ============================================================================
+// Helpers (pure core)
+// ============================================================================
+
+function toGQL(stats: CacheStats): CacheStatsGQL {
+    const gql = new CacheStatsGQL();
+    gql.TotalEntries = stats.totalEntries;
+    gql.TotalSizeBytes = stats.totalSizeBytes;
+    gql.ByType = (['dataset', 'runview', 'runquery'] as const).map(t => {
+        const bt = stats.byType[t];
+        const entry = new CacheStatsByTypeGQL();
+        entry.Type = t;
+        entry.Count = bt.count;
+        entry.SizeBytes = bt.sizeBytes;
+        return entry;
+    });
+    gql.OldestEntry = stats.oldestEntry;
+    gql.NewestEntry = stats.newestEntry;
+    gql.Hits = stats.hits;
+    gql.Misses = stats.misses;
+    gql.HitRate = (stats.hits + stats.misses) > 0
+        ? (stats.hits / (stats.hits + stats.misses)) * 100
+        : 0;
+    return gql;
+}
+
+function buildEntityBreakdown(): CacheEntityBreakdownGQL[] {
+    const entries = LocalCacheManager.Instance.GetAllEntries();
+    const entityMap = new Map<string, { count: number; sizeBytes: number; accessCount: number }>();
+
+    for (const entry of entries) {
+        if (entry.type !== 'runview' || !entry.name) continue;
+        const existing = entityMap.get(entry.name) ?? { count: 0, sizeBytes: 0, accessCount: 0 };
+        existing.count++;
+        existing.sizeBytes += entry.sizeBytes;
+        existing.accessCount += entry.accessCount;
+        entityMap.set(entry.name, existing);
+    }
+
+    return [...entityMap.entries()]
+        .map(([name, data]) => {
+            const gql = new CacheEntityBreakdownGQL();
+            gql.EntityName = name;
+            gql.EntryCount = data.count;
+            gql.TotalSizeBytes = data.sizeBytes;
+            gql.TotalAccessCount = data.accessCount;
+            return gql;
+        })
+        .sort((a, b) => b.EntryCount - a.EntryCount);
+}
+
+// ============================================================================
+// Resolver
+// ============================================================================
+
+@Resolver()
+export class CacheStatsResolver {
+    @RequireSystemUser()
+    @Query(() => CacheStatsGQL)
+    CacheStats(): CacheStatsGQL {
+        const stats = LocalCacheManager.Instance.GetStats();
+        return toGQL(stats);
+    }
+
+    @RequireSystemUser()
+    @Query(() => CacheStatsDetailGQL)
+    CacheStatsDetail(): CacheStatsDetailGQL {
+        const stats = LocalCacheManager.Instance.GetStats();
+        const result = new CacheStatsDetailGQL();
+        Object.assign(result, toGQL(stats));
+        result.EntityBreakdown = buildEntityBreakdown();
+        return result;
+    }
+}

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);
     }