@memberjunction/server 5.30.1 → 5.32.0

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -1,10 +1,11 @@
 import { Arg, Ctx, Field, InputType, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
-import { DatabaseProviderBase, EntityDeleteOptions, EntitySaveOptions, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { DatabaseProviderBase, EntityDeleteOptions, EntitySaveOptions, IMetadataProvider, LogError, Metadata, RunView, UserInfo } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { MJRoleEntity, MJUserEntity, MJUserRoleEntity } from '@memberjunction/core-entities';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
+import { GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class SyncRolesAndUsersResultType {
@@ -92,16 +93,17 @@ export class SyncRolesAndUsersResolver {
         // attempted this with a TransactionGroup but ran into nesting issues —
         // direct DB transactions per the plan doc avoid that.
         try {
-            const provider = Metadata.Provider as DatabaseProviderBase;
+            const md = GetReadWriteProvider(context.providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+            const provider = md as unknown as DatabaseProviderBase;
             await provider.BeginTransaction();
             try {
-                const roleResult = await this.DoSyncRoles(data.Roles, context.userPayload.userRecord, context.userPayload);
+                const roleResult = await this.DoSyncRoles(data.Roles, context.userPayload.userRecord, context.userPayload, md);
                 if (!roleResult.Success) {
                     await provider.RollbackTransaction();
                     return roleResult;
                 }
 
-                const usersResult = await this.DoSyncUsers(data.Users, context.userPayload.userRecord, context.userPayload);
+                const usersResult = await this.DoSyncUsers(data.Users, context.userPayload.userRecord, context.userPayload, md);
                 if (!usersResult.Success) {
                     await provider.RollbackTransaction();
                     return usersResult;
@@ -136,10 +138,11 @@ export class SyncRolesAndUsersResolver {
         // Wrap delete + add + update of roles in one DB transaction so any failure
         // rolls back the whole batch. Keeps the sync idempotent across retries.
         try {
-            const provider = Metadata.Provider as DatabaseProviderBase;
+            const md = GetReadWriteProvider(context.providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+            const provider = md as unknown as DatabaseProviderBase;
             await provider.BeginTransaction();
             try {
-                const result = await this.DoSyncRoles(roles, context.userPayload.userRecord, context.userPayload);
+                const result = await this.DoSyncRoles(roles, context.userPayload.userRecord, context.userPayload, md);
                 if (result.Success) {
                     await provider.CommitTransaction();
                 } else {
@@ -161,7 +164,7 @@ export class SyncRolesAndUsersResolver {
      * Throws on any Save/Delete failure so the outer transaction rolls back. A returned
      * `{ Success: true }` means every operation succeeded.
      */
-    protected async DoSyncRoles(roles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<SyncRolesAndUsersResultType> {
+    protected async DoSyncRoles(roles: RoleInputType[], user: UserInfo, userPayload: UserPayload, provider?: IMetadataProvider): Promise<SyncRolesAndUsersResultType> {
         const rv = new RunView();
         const result = await rv.RunView<MJRoleEntity>({
             EntityName: "MJ: Roles",
@@ -174,7 +177,7 @@ export class SyncRolesAndUsersResolver {
 
         const currentRoles = result.Results;
         await this.DeleteRemovedRoles(currentRoles, roles, user, userPayload);
-        await this.AddNewRoles(currentRoles, roles, user, userPayload);
+        await this.AddNewRoles(currentRoles, roles, user, userPayload, provider);
         await this.UpdateExistingRoles(currentRoles, roles, userPayload);
         return { Success: true };
     }
@@ -192,9 +195,9 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async AddNewRoles(currentRoles: MJRoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload): Promise<void> {
+    protected async AddNewRoles(currentRoles: MJRoleEntity[], futureRoles: RoleInputType[], user: UserInfo, userPayload: UserPayload, provider?: IMetadataProvider): Promise<void> {
         // go through the future roles and add any that are not in the current roles
-        const md = new Metadata();
+        const md = provider ?? new Metadata();
 
         for (const add of futureRoles) {
             if (!currentRoles.find(r => r.Name.trim().toLowerCase() === add.Name.trim().toLowerCase())) {
@@ -262,10 +265,11 @@ export class SyncRolesAndUsersResolver {
     ) : Promise<SyncRolesAndUsersResultType> {
         // Wrap delete + add + update + role-sync of users in one DB transaction.
         try {
-            const provider = Metadata.Provider as DatabaseProviderBase;
+            const md = GetReadWriteProvider(context.providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+            const provider = md as unknown as DatabaseProviderBase;
             await provider.BeginTransaction();
             try {
-                const result = await this.DoSyncUsers(users, context.userPayload.userRecord, context.userPayload);
+                const result = await this.DoSyncUsers(users, context.userPayload.userRecord, context.userPayload, md);
                 if (result.Success) {
                     await provider.CommitTransaction();
                 } else {
@@ -286,7 +290,7 @@ export class SyncRolesAndUsersResolver {
      * Transaction-free core of SyncUsers — expected to be invoked inside an outer transaction.
      * Throws on any Save/Delete failure so the outer transaction rolls back.
      */
-    protected async DoSyncUsers(users: UserInputType[], user: UserInfo, userPayload: UserPayload): Promise<SyncRolesAndUsersResultType> {
+    protected async DoSyncUsers(users: UserInputType[], user: UserInfo, userPayload: UserPayload, provider?: IMetadataProvider): Promise<SyncRolesAndUsersResultType> {
         const rv = new RunView();
         const result = await rv.RunView<MJUserEntity>({
             EntityName: "MJ: Users",
@@ -299,9 +303,9 @@ export class SyncRolesAndUsersResolver {
 
         const currentUsers = result.Results;
         await this.DeleteRemovedUsers(currentUsers, users, user, userPayload);
-        await this.AddNewUsers(currentUsers, users, userPayload);
+        await this.AddNewUsers(currentUsers, users, userPayload, provider);
         await this.UpdateExistingUsers(currentUsers, users, userPayload);
-        await this.SyncUserRoles(users, user, userPayload);
+        await this.SyncUserRoles(users, user, userPayload, provider);
         return { Success: true };
     }
 
@@ -322,9 +326,9 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async AddNewUsers(currentUsers: MJUserEntity[], futureUsers: UserInputType[], userPayload: UserPayload): Promise<void> {
+    protected async AddNewUsers(currentUsers: MJUserEntity[], futureUsers: UserInputType[], userPayload: UserPayload, provider?: IMetadataProvider): Promise<void> {
         // add users that are not in the current users
-        const md = new Metadata();
+        const md = provider ?? new Metadata();
 
         for (const add of futureUsers) {
             const match = currentUsers.find(currentUser => currentUser.Email?.trim().toLowerCase() === add.Email?.trim().toLowerCase());
@@ -389,10 +393,10 @@ export class SyncRolesAndUsersResolver {
         }
     }
 
-    protected async SyncUserRoles(users: UserInputType[], u: UserInfo, userPayload: UserPayload): Promise<void> {
+    protected async SyncUserRoles(users: UserInputType[], u: UserInfo, userPayload: UserPayload, provider?: IMetadataProvider): Promise<void> {
         // for each user in the users array, make sure there is a User Role that matches. First, get a list of all DATABASE user and roels so we have that for fast lookup in memory
         const rv = new RunView();
-        const md = new Metadata();
+        const md = provider ?? new Metadata();
 
         const p1 = rv.RunView<MJUserEntity>({
             EntityName: "MJ: Users",

package/src/resolvers/TagGovernanceResolver.ts

@@ -0,0 +1,189 @@
+import { Resolver, Mutation, Ctx, Arg, ObjectType, Field, Int } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { LogError, LogStatus } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { TagGovernanceEngine, TagHealthJob, DEFAULT_TAG_HEALTH_THRESHOLDS, TagEngine } from '@memberjunction/tag-engine';
+
+@ObjectType()
+export class PromoteSuggestionResult {
+    @Field()
+    Success: boolean;
+
+    @Field({ nullable: true })
+    ResolvedTagID?: string;
+
+    @Field({ nullable: true })
+    ResolvedTagName?: string;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+@ObjectType()
+export class RejectSuggestionResult {
+    @Field()
+    Success: boolean;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+@ObjectType()
+export class RebuildTagEmbeddingsResult {
+    @Field()
+    Success: boolean;
+
+    @Field(() => Int)
+    Refreshed: number;
+
+    @Field(() => Int)
+    Total: number;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+@ObjectType()
+export class RunTagHealthResult {
+    @Field()
+    Success: boolean;
+
+    @Field(() => Int)
+    MergeCount: number;
+
+    @Field(() => Int)
+    LowUsageCount: number;
+
+    @Field(() => Int)
+    WideNodeCount: number;
+
+    @Field(() => Int)
+    DurationMs: number;
+
+    @Field({ nullable: true })
+    ErrorMessage?: string;
+}
+
+/**
+ * GraphQL surface for the tag governance lifecycle that the Suggestion Inbox
+ * UI invokes. Wraps `TagGovernanceEngine` (PromoteSuggestion / RejectSuggestion),
+ * `TagEngine.RebuildTagEmbeddings`, and `TagHealthJob.Run` so the client gets a
+ * single transactional call per disposition instead of multiple BaseEntity saves.
+ *
+ * Multi-provider safety: each mutation reads the per-request user from the
+ * context and lets the engines use their default provider; if a non-default
+ * provider is in play it should be passed via `TagGovernanceEngine.Provider`.
+ */
+@Resolver()
+export class TagGovernanceResolver extends ResolverBase {
+    @Mutation(() => PromoteSuggestionResult)
+    async PromoteTagSuggestion(
+        @Arg('suggestionID') suggestionID: string,
+        @Arg('strategy') strategy: 'create-new' | 'merge-into-existing',
+        @Arg('targetTagID', { nullable: true }) targetTagID: string | undefined,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<PromoteSuggestionResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, ErrorMessage: 'Unable to determine current user' };
+            }
+
+            if (strategy !== 'create-new' && strategy !== 'merge-into-existing') {
+                return { Success: false, ErrorMessage: `Unknown strategy "${strategy}"` };
+            }
+            if (strategy === 'merge-into-existing' && !targetTagID) {
+                return { Success: false, ErrorMessage: 'targetTagID is required when strategy is "merge-into-existing".' };
+            }
+
+            const resolved = strategy === 'create-new'
+                ? await TagGovernanceEngine.Instance.PromoteSuggestion(suggestionID, { kind: 'create-new' }, currentUser)
+                : await TagGovernanceEngine.Instance.PromoteSuggestion(suggestionID, { kind: 'merge-into-existing', targetTagID: targetTagID! }, currentUser);
+
+            return {
+                Success: true,
+                ResolvedTagID: resolved.ID,
+                ResolvedTagName: resolved.Name,
+            };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`PromoteTagSuggestion failed for ${suggestionID}: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+
+    @Mutation(() => RejectSuggestionResult)
+    async RejectTagSuggestion(
+        @Arg('suggestionID') suggestionID: string,
+        @Arg('reviewerNotes', { nullable: true }) reviewerNotes: string | undefined,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<RejectSuggestionResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, ErrorMessage: 'Unable to determine current user' };
+            }
+            await TagGovernanceEngine.Instance.RejectSuggestion(suggestionID, reviewerNotes ?? null, currentUser);
+            return { Success: true };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`RejectTagSuggestion failed for ${suggestionID}: ${msg}`);
+            return { Success: false, ErrorMessage: msg };
+        }
+    }
+
+    @Mutation(() => RebuildTagEmbeddingsResult)
+    async RebuildTagEmbeddings(
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<RebuildTagEmbeddingsResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, Refreshed: 0, Total: 0, ErrorMessage: 'Unable to determine current user' };
+            }
+            const result = await TagEngine.Instance.RebuildTagEmbeddings(currentUser);
+            LogStatus(`RebuildTagEmbeddings: refreshed ${result.refreshed}/${result.total} tags.`);
+            return { Success: true, Refreshed: result.refreshed, Total: result.total };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`RebuildTagEmbeddings failed: ${msg}`);
+            return { Success: false, Refreshed: 0, Total: 0, ErrorMessage: msg };
+        }
+    }
+
+    @Mutation(() => RunTagHealthResult)
+    async RunTagHealth(
+        @Arg('minCoOccurrence', () => Int, { nullable: true }) minCoOccurrence: number | undefined,
+        @Arg('minNameSimilarity', { nullable: true }) minNameSimilarity: number | undefined,
+        @Arg('minEmbeddingSimilarity', { nullable: true }) minEmbeddingSimilarity: number | undefined,
+        @Arg('maxUsage', () => Int, { nullable: true }) maxUsage: number | undefined,
+        @Arg('maxImplicitChildren', () => Int, { nullable: true }) maxImplicitChildren: number | undefined,
+        @Ctx() { userPayload }: AppContext = {} as AppContext
+    ): Promise<RunTagHealthResult> {
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return { Success: false, MergeCount: 0, LowUsageCount: 0, WideNodeCount: 0, DurationMs: 0, ErrorMessage: 'Unable to determine current user' };
+            }
+            const summary = await TagHealthJob.Instance.Run({
+                ...DEFAULT_TAG_HEALTH_THRESHOLDS,
+                ...(minCoOccurrence != null ? { minCoOccurrence } : {}),
+                ...(minNameSimilarity != null ? { minNameSimilarity } : {}),
+                ...(minEmbeddingSimilarity != null ? { minEmbeddingSimilarity } : {}),
+                ...(maxUsage != null ? { maxUsage } : {}),
+                ...(maxImplicitChildren != null ? { maxImplicitChildren } : {}),
+            }, currentUser);
+            return {
+                Success: true,
+                MergeCount: summary.mergeCount,
+                LowUsageCount: summary.lowUsageCount,
+                WideNodeCount: summary.wideNodeCount,
+                DurationMs: summary.durationMs,
+            };
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            LogError(`RunTagHealth failed: ${msg}`);
+            return { Success: false, MergeCount: 0, LowUsageCount: 0, WideNodeCount: 0, DurationMs: 0, ErrorMessage: msg };
+        }
+    }
+}

package/src/resolvers/TaskResolver.ts

@@ -1,8 +1,9 @@
 import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { IMetadataProvider, LogError, LogStatus } from '@memberjunction/core';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { TaskOrchestrator, TaskGraphResponse, TaskExecutionResult } from '../services/TaskOrchestrator.js';
+import { GetReadWriteProvider } from '../util.js';
 
 @ObjectType()
 export class TaskExecutionResultType {
@@ -53,7 +54,7 @@ export class TaskOrchestrationResolver extends ResolverBase {
         @Arg('environmentId') environmentId: string,
         @Arg('sessionId') sessionId: string,
         @PubSub() pubSub: PubSubEngine,
-        @Ctx() { userPayload }: AppContext,
+        @Ctx() { userPayload, providers }: AppContext,
         @Arg('createNotifications', { nullable: true }) createNotifications?: boolean
     ): Promise<ExecuteTaskGraphResult> {
         // Check API key scope authorization for task execution
@@ -82,7 +83,8 @@ export class TaskOrchestrationResolver extends ResolverBase {
             }
 
             // Create task orchestrator with PubSub for progress updates
-            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload, createNotifications || false, conversationDetailId);
+            const provider = GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
+            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload, createNotifications || false, conversationDetailId, provider);
 
             // Create parent task and child tasks with dependencies
             const { parentTaskId, taskIdMap } = await orchestrator.createTasksFromGraph(

package/src/resolvers/TransactionGroupResolver.ts

@@ -1,7 +1,8 @@
 import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, registerEnumType } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { CompositeKey, KeyValuePair, LogError, Metadata, TransactionVariable, BaseEntity, EntityDeleteOptions, EntitySaveOptions } from '@memberjunction/core';
+import { CompositeKey, IMetadataProvider, KeyValuePair, LogError, Metadata, TransactionVariable, BaseEntity, EntityDeleteOptions, EntitySaveOptions } from '@memberjunction/core';
 import { SafeJSONParse } from '@memberjunction/global';
+import { GetReadWriteProvider } from '../util.js';
 
 export enum TransactionVariableType {
     Define = "Define",
@@ -84,7 +85,7 @@ export class TransactionResolver {
     ) {
         try { 
             // we have received the transaction group information via the network, now we need to reconstruct our TransactionGroup object and run it
-            const md = new Metadata();
+            const md = (GetReadWriteProvider(context.providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider) ?? new Metadata();
             const tg = await md.CreateTransactionGroup();
             const entityObjects: BaseEntity[] = [];
             const objectValues: any[] = [];

package/src/rest/EntityCRUDHandler.ts

@@ -14,7 +14,7 @@ export class EntityCRUDHandler {
     static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
             
             // Check permissions
@@ -84,7 +84,7 @@ export class EntityCRUDHandler {
     static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
         try {
             // Get entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
             
             // Check permissions
@@ -123,7 +123,7 @@ export class EntityCRUDHandler {
     static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
             
             // Check permissions
@@ -210,7 +210,7 @@ export class EntityCRUDHandler {
     static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
         try {
             // Get entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
             
             // Check permissions

package/src/rest/RESTEndpointHandler.ts

@@ -74,7 +74,7 @@ export class RESTEndpointHandler {
      */
     private isEntityAllowed(entityName: string): boolean {
         const name = entityName.toLowerCase();
-        const md = new Metadata();
+        const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
         const entity = md.Entities.find(e => e.Name.toLowerCase() === name);
         
         // If entity not found in metadata, don't allow it
@@ -417,7 +417,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key
@@ -445,7 +445,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key
@@ -473,7 +473,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key
@@ -589,7 +589,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
             
             // Filter entities based on user permissions and REST API configuration
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entities = md.Entities.filter(e => {
                 // First check if entity is allowed based on configuration
                 if (!this.isEntityAllowed(e.Name)) {
@@ -629,7 +629,7 @@ export class RESTEndpointHandler {
 
             const user = req['mjUser'];
             
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = md.Entities.find(e => e.Name === entityName);
             if (!entity) {
                 res.status(404).json({ error: `Entity '${entityName}' not found` });
@@ -695,7 +695,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key
@@ -723,7 +723,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key
@@ -751,7 +751,7 @@ export class RESTEndpointHandler {
             const user = req['mjUser'];
 
             // Get the entity object
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = await md.GetEntityObject(entityName, user);
 
             // Create a composite key

package/src/rest/ViewOperationsHandler.ts

@@ -14,7 +14,7 @@ export class ViewOperationsHandler {
     static async runView(params: RunViewParams, user: UserInfo): Promise<{ success: boolean, result?: RunViewResult, error?: string }> {
         try {
             // Validate entity exists
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = md.Entities.find(e => e.Name === params.EntityName);
             if (!entity) {
                 return { 
@@ -52,7 +52,7 @@ export class ViewOperationsHandler {
     static async runViews(paramsArray: RunViewParams[], user: UserInfo): Promise<{ success: boolean, results?: RunViewResult[], error?: string }> {
         try {
             // Validate and sanitize each set of parameters
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             for (const params of paramsArray) {
                 // Validate entity exists
                 const entity = md.Entities.find(e => e.Name === params.EntityName);
@@ -93,7 +93,7 @@ export class ViewOperationsHandler {
     static async listEntities(params: RunViewParams, user: UserInfo): Promise<RunViewResult> {
         try {
             // Check entity exists and user has permission
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = md.Entities.find(e => e.Name === params.EntityName);
             if (!entity) {
                 throw new Error(`Entity '${params.EntityName}' not found`);
@@ -122,7 +122,7 @@ export class ViewOperationsHandler {
     static async getEntityViews(entityName: string, user: UserInfo): Promise<{ success: boolean, views?: any[], error?: string }> {
         try {
             // Validate entity exists
-            const md = new Metadata();
+            const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
             const entity = md.Entities.find(e => e.Name === entityName);
             if (!entity) {
                 return { 

package/src/services/TaskOrchestrator.ts

@@ -1,4 +1,4 @@
-import { DatabaseProviderBase, Metadata, RunView, UserInfo, LogError, LogStatus } from '@memberjunction/core';
+import { DatabaseProviderBase, IMetadataProvider, Metadata, RunView, UserInfo, LogError, LogStatus } from '@memberjunction/core';
 import { MJTaskEntity, MJTaskDependencyEntity, MJTaskTypeEntity, MJConversationDetailEntity, MJArtifactEntity, MJArtifactVersionEntity, MJConversationDetailArtifactEntity, MJUserNotificationEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { ChatMessageRole } from '@memberjunction/ai';
@@ -53,9 +53,14 @@ export class TaskOrchestrator {
         private sessionId?: string,
         private userPayload?: UserPayload,
         private createNotifications: boolean = false,
-        private conversationDetailId?: string
+        private conversationDetailId?: string,
+        private provider?: IMetadataProvider
     ) {}
 
+    private getMetadata(): IMetadataProvider {
+        return this.provider ?? (new Metadata() as unknown as IMetadataProvider);
+    }
+
     /**
      * Initialize the orchestrator by finding/creating the AI Agent Task type
      */
@@ -77,7 +82,7 @@ export class TaskOrchestrator {
         }
 
         // Create the task type if it doesn't exist
-        const md = new Metadata();
+        const md = this.getMetadata();
         const taskType = await md.GetEntityObject<MJTaskTypeEntity>('MJ: Task Types', this.contextUser);
         taskType.Name = 'AI Agent Execution';
         taskType.Description = 'Task executed by an AI agent as part of conversation workflow';
@@ -104,7 +109,7 @@ export class TaskOrchestrator {
         environmentId: string
     ): Promise<{ parentTaskId: string; taskIdMap: Map<string, string> }> {
         const taskTypeId = await this.ensureTaskType();
-        const md = new Metadata();
+        const md = this.getMetadata();
         const tempIdToRealId = new Map<string, string>();
 
         // Build the parent task, deduplicate the incoming task defs, and resolve agents
@@ -142,7 +147,7 @@ export class TaskOrchestrator {
         }
 
         // Persist parent + children + dependency graph in one transaction
-        const provider = Metadata.Provider as DatabaseProviderBase;
+        const provider = (this.provider ?? Metadata.Provider) as DatabaseProviderBase;
         await provider.BeginTransaction();
         try {
             if (!await parentTask.Save()) {
@@ -302,7 +307,7 @@ export class TaskOrchestrator {
         let hasMore = true;
 
         // Get parent task for progress updates
-        const md = new Metadata();
+        const md = this.getMetadata();
         const parentTask = await md.GetEntityObject<MJTaskEntity>('MJ: Tasks', this.contextUser);
         await parentTask.Load(parentTaskId);
 
@@ -381,7 +386,7 @@ export class TaskOrchestrator {
      * Update parent task progress based on child task completion
      */
     private async updateParentTaskProgress(parentTaskId: string): Promise<void> {
-        const md = new Metadata();
+        const md = this.getMetadata();
         const parentTask = await md.GetEntityObject<MJTaskEntity>('MJ: Tasks', this.contextUser);
         const loaded = await parentTask.Load(parentTaskId);
         if (!loaded) return;
@@ -414,7 +419,7 @@ export class TaskOrchestrator {
      * Mark parent task as complete when all children are done
      */
     private async completeParentTask(parentTaskId: string): Promise<void> {
-        const md = new Metadata();
+        const md = this.getMetadata();
         const parentTask = await md.GetEntityObject<MJTaskEntity>('MJ: Tasks', this.contextUser);
         const loaded = await parentTask.Load(parentTaskId);
         if (!loaded) return;
@@ -464,7 +469,7 @@ export class TaskOrchestrator {
      * Load a task by ID
      */
     private async loadTask(taskId: string): Promise<MJTaskEntity | null> {
-        const md = new Metadata();
+        const md = this.getMetadata();
         const task = await md.GetEntityObject<MJTaskEntity>('MJ: Tasks', this.contextUser);
         const loaded = await task.Load(taskId);
         return loaded ? task : null;
@@ -483,7 +488,7 @@ export class TaskOrchestrator {
             await task.Save();
 
             // Load the agent entity
-            const md = new Metadata();
+            const md = this.getMetadata();
             const agentEntity = await md.GetEntityObject<MJAIAgentEntityExtended>('MJ: AI Agents', this.contextUser);
             const loaded = await agentEntity.Load(task.AgentID!);
             if (!loaded) {
@@ -707,8 +712,8 @@ export class TaskOrchestrator {
         agent: MJAIAgentEntityExtended,
         taskName: string
     ): Promise<void> {
-        const md = new Metadata();
-        const provider = Metadata.Provider as DatabaseProviderBase;
+        const md = this.getMetadata();
+        const provider = (this.provider ?? Metadata.Provider) as DatabaseProviderBase;
 
         await provider.BeginTransaction();
         try {
@@ -795,7 +800,7 @@ export class TaskOrchestrator {
                 return;
             }
 
-            const md = new Metadata();
+            const md = this.getMetadata();
 
             // Load conversation detail to get conversation ID
             const detail = await md.GetEntityObject<MJConversationDetailEntity>(