@memberjunction/server 5.32.0 → 5.34.0

package/src/generic/ResolverBase.ts

@@ -356,7 +356,10 @@ export class ResolverBase {
           userPayload,
           viewInput.MaxRows,
           viewInput.StartRow,
-          viewInput.Aggregates
+          viewInput.Aggregates,
+          viewInput.AfterKey
+            ? CompositeKey.FromKeyValuePairs((viewInput.AfterKey as { KeyValuePairs: { FieldName: string; Value: string }[] }).KeyValuePairs)
+            : undefined
         );
       }
       else {
@@ -505,6 +508,9 @@ export class ResolverBase {
           ignoreMaxRows: viewInput.IgnoreMaxRows,
           maxRows: viewInput.MaxRows,
           startRow: viewInput.StartRow,
+          afterKey: viewInput.AfterKey
+            ? CompositeKey.FromKeyValuePairs((viewInput.AfterKey as { KeyValuePairs: { FieldName: string; Value: string }[] }).KeyValuePairs)
+            : undefined,
           excludeDataFromAllPriorViewRuns: viewInput.EntityName ? false : viewInput.ExcludeDataFromAllPriorViewRuns,
           forceAuditLog: viewInput.ForceAuditLog,
           auditLogDescription: viewInput.AuditLogDescription,
@@ -686,7 +692,8 @@ export class ResolverBase {
     userPayload: UserPayload | null,
     maxRows: number | undefined,
     startRow: number | undefined,
-    aggregates?: AggregateExpression[]
+    aggregates?: AggregateExpression[],
+    afterKey?: CompositeKey
   ) {
     try {
       if (!viewInfo || !userPayload) return null;
@@ -745,6 +752,7 @@ export class ResolverBase {
           IgnoreMaxRows: ignoreMaxRows,
           MaxRows: maxRows,
           StartRow: startRow,
+          AfterKey: afterKey,
           ForceAuditLog: forceAuditLog,
           AuditLogDescription: auditLogDescription,
           ResultType: rt,
@@ -857,6 +865,7 @@ export class ResolverBase {
           IgnoreMaxRows: param.ignoreMaxRows,
           MaxRows: param.maxRows,
           StartRow: param.startRow,
+          AfterKey: param.afterKey,
           ForceAuditLog: param.forceAuditLog,
           AuditLogDescription: param.auditLogDescription,
           ResultType: rt,

package/src/generic/RunViewResolver.ts

@@ -1,12 +1,12 @@
 import { Arg, Ctx, Field, InputType, Int, ObjectType, PubSubEngine, Query, Resolver } from 'type-graphql';
 import { AppContext } from '../types.js';
 import { ResolverBase } from './ResolverBase.js';
-import { LogError, LogStatus, EntityInfo, RunViewWithCacheCheckResult, RunViewsWithCacheCheckResponse, RunViewWithCacheCheckParams, AggregateResult } from '@memberjunction/core';
+import { LogError, LogStatus, EntityInfo, RunViewWithCacheCheckResult, RunViewsWithCacheCheckResponse, RunViewWithCacheCheckParams, AggregateResult, CompositeKey } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadOnlyProvider } from '../util.js';
 import { MJUserViewEntityExtended } from '@memberjunction/core-entities';
-import { KeyValuePairOutputType } from './KeyInputOutputTypes.js';
+import { CompositeKeyInputType, KeyValuePairOutputType } from './KeyInputOutputTypes.js';
 import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
 
 /********************************************************************************
@@ -159,6 +159,12 @@ export class RunViewByIDInput {
   })
   StartRow?: number;
 
+  @Field(() => CompositeKeyInputType, {
+    nullable: true,
+    description: 'Keyset (seek) pagination cursor. When provided, returns the next page of records after the given PK value, ordered by the PK column. Requires a single-column PK on the entity. Cannot be combined with StartRow.',
+  })
+  AfterKey?: CompositeKeyInputType;
+
   @Field(() => [AggregateExpressionInput], {
     nullable: true,
     description: 'Optional aggregate expressions to calculate on the full result set (e.g., SUM, COUNT, AVG). Results are returned in AggregateResults.',
@@ -260,6 +266,12 @@ export class RunViewByNameInput {
   })
   StartRow?: number;
 
+  @Field(() => CompositeKeyInputType, {
+    nullable: true,
+    description: 'Keyset (seek) pagination cursor. When provided, returns the next page of records after the given PK value, ordered by the PK column. Requires a single-column PK on the entity. Cannot be combined with StartRow.',
+  })
+  AfterKey?: CompositeKeyInputType;
+
   @Field(() => [AggregateExpressionInput], {
     nullable: true,
     description: 'Optional aggregate expressions to calculate on the full result set (e.g., SUM, COUNT, AVG). Results are returned in AggregateResults.',
@@ -347,6 +359,12 @@ export class RunDynamicViewInput {
   })
   StartRow?: number;
 
+  @Field(() => CompositeKeyInputType, {
+    nullable: true,
+    description: 'Keyset (seek) pagination cursor. When provided, returns the next page of records after the given PK value, ordered by the PK column. Requires a single-column PK on the entity. Cannot be combined with StartRow.',
+  })
+  AfterKey?: CompositeKeyInputType;
+
   @Field(() => [AggregateExpressionInput], {
     nullable: true,
     description: 'Optional aggregate expressions to calculate on the full result set (e.g., SUM, COUNT, AVG). Results are returned in AggregateResults.',
@@ -463,6 +481,12 @@ export class RunViewGenericInput {
   })
   StartRow?: number;
 
+  @Field(() => CompositeKeyInputType, {
+    nullable: true,
+    description: 'Keyset (seek) pagination cursor. When provided, returns the next page of records after the given PK value, ordered by the PK column. Requires a single-column PK on the entity. Cannot be combined with StartRow.',
+  })
+  AfterKey?: CompositeKeyInputType;
+
   @Field(() => [AggregateExpressionInput], {
     nullable: true,
     description: 'Optional aggregate expressions to calculate on the full result set (e.g., SUM, COUNT, AVG). Results are returned in AggregateResults.',
@@ -1017,6 +1041,9 @@ export class RunViewResolver extends ResolverBase {
           AuditLogDescription: item.params.AuditLogDescription,
           ResultType: (item.params.ResultType || 'simple') as 'simple' | 'entity_object' | 'count_only',
           StartRow: item.params.StartRow,
+          AfterKey: item.params.AfterKey
+            ? CompositeKey.FromKeyValuePairs(item.params.AfterKey.KeyValuePairs)
+            : undefined,
         },
         cacheStatus: item.cacheStatus ? {
           maxUpdatedAt: item.cacheStatus.maxUpdatedAt,

package/src/index.ts

@@ -5,7 +5,8 @@ dotenv.config({ quiet: true });
 import { expressMiddleware } from '@as-integrations/express5';
 import { mergeSchemas } from '@graphql-tools/schema';
 import { Metadata, DatabasePlatform, SetProvider, StartupManager as StartupManagerImport, BaseEntity, BaseEntityEvent, RunView } from '@memberjunction/core';
-import { MJGlobal, MJEventType, UUIDsEqual } from '@memberjunction/global';
+import { resolveDbPlatformFromEnv } from '@memberjunction/generic-database-provider';
+import { MJGlobal, MJEventType, UUIDsEqual, ShutdownRegistry } from '@memberjunction/global';
 import { setupSQLServerClient, SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { extendConnectionPoolWithQuery } from './util.js';
 import { default as BodyParser } from 'body-parser';
@@ -58,15 +59,19 @@ import { ServerExtensionLoader, ServerExtensionConfig } from '@memberjunction/se
 const cacheRefreshInterval = configInfo.databaseSettings.metadataCacheRefreshInterval;
 
 /**
- * Returns the configured database platform type based on the DB_TYPE environment variable.
- * Defaults to 'sqlserver' for backward compatibility.
+ * Returns the configured database platform from the `DB_PLATFORM` environment
+ * variable, falling back to `'sqlserver'` when the env var is unset. An
+ * unrecognized non-empty value (typo, legacy alias) throws — silent fallback
+ * is the bug we don't want, because it routes the wrong provider against a
+ * real database.
+ *
+ * Implementation note: the actual env-parsing lives in
+ * `@memberjunction/global` (single source of truth across MJCLI, MJServer,
+ * CodeGenLib). This wrapper keeps the public `getDbType()` symbol that
+ * MJServer consumers (and the broader stack) already import.
  */
 export function getDbType(): DatabasePlatform {
-    const dbType = process.env.DB_TYPE?.toLowerCase();
-    if (dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg') {
-        return 'postgresql';
-    }
-    return 'sqlserver';
+    return resolveDbPlatformFromEnv() ?? 'sqlserver';
 }
 
 export { MaxLength } from 'class-validator';
@@ -96,6 +101,8 @@ export * from './resolvers/RunAIPromptResolver.js';
 export * from './resolvers/RunAIAgentResolver.js';
 export * from './resolvers/VectorizeEntityResolver.js';
 export * from './resolvers/SearchKnowledgeResolver.js';
+export * from './resolvers/SearchKnowledgeStreamResolver.js';
+export * from './resolvers/AvailableSearchProvidersResolver.js';
 export * from './resolvers/FetchEntityVectorsResolver.js';
 export * from './resolvers/PipelineProgressResolver.js';
 export * from './resolvers/ClientToolRequestResolver.js';
@@ -417,7 +424,7 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       url: process.env.REDIS_URL,
       keyPrefix: process.env.REDIS_KEY_PREFIX || 'mj',
       enablePubSub: true,
-      enableLogging: true,
+      enableLogging: configInfo.cacheSettings?.verboseLogging ?? false,
     });
     (Metadata.Provider as GenericDatabaseProvider).SetLocalStorageProvider(redisProvider); // global-provider-ok: bootstrap (Redis cache wiring)
     await redisProvider.StartListening();
@@ -901,6 +908,19 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
       }
     }
 
+    // Drain anything self-registered with ShutdownRegistry — QueueManager,
+    // future engines/services with timers/intervals/listeners. Each is
+    // responsible for being idempotent and not throwing.
+    try {
+      const count = ShutdownRegistry.Instance.Count;
+      if (count > 0) {
+        await ShutdownRegistry.Instance.ShutdownAll();
+        console.log(`✅ ShutdownRegistry drained ${count} registered service(s)`);
+      }
+    } catch (error) {
+      console.error('❌ Error draining ShutdownRegistry:', error);
+    }
+
     // Close server
     httpServer.close(() => {
       console.log('✅ HTTP server closed');

package/src/resolvers/AvailableSearchProvidersResolver.ts

@@ -0,0 +1,43 @@
+import { Field, ObjectType, Query, Resolver } from 'type-graphql';
+import { BaseSearchProvider } from '@memberjunction/search-engine';
+
+/**
+ * Surfaces the runtime ClassFactory registrations of `BaseSearchProvider`
+ * subclasses for UI consumers (P5.5 — SearchScope form's provider dropdown).
+ *
+ * Why a GraphQL query and not a hardcoded client-side list:
+ *   - `@memberjunction/search-engine` is a Node-only package; the browser
+ *     can't import it directly, so it can't read `ClassFactory` itself.
+ *   - Third-party packages can register additional providers at server boot
+ *     without modifying any UI code; this query keeps the form auto-discovering.
+ *   - The list is also useful for ops debugging ("which providers does this
+ *     server build know about?").
+ *
+ * The resolver is intentionally read-only and does not require system-user
+ * privileges — knowing the registered driver-class names on a given server
+ * isn't sensitive, and the SearchScope form itself is gated by entity-level
+ * permission checks. Adjust if your deployment treats the provider catalog
+ * as confidential.
+ */
+@ObjectType()
+export class AvailableSearchProviderGQL {
+    @Field()
+    DriverClass!: string;
+
+    @Field()
+    SourceType!: string;
+}
+
+@Resolver()
+export class AvailableSearchProvidersResolver {
+    @Query(() => [AvailableSearchProviderGQL])
+    AvailableSearchProviders(): AvailableSearchProviderGQL[] {
+        const registrations = BaseSearchProvider.GetAvailableProviders();
+        return registrations.map(r => {
+            const gql = new AvailableSearchProviderGQL();
+            gql.DriverClass = r.DriverClass;
+            gql.SourceType = r.SourceType;
+            return gql;
+        });
+    }
+}

package/src/resolvers/ComponentRegistryResolver.ts

@@ -1,8 +1,8 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query, Mutation, Resolver } from 'type-graphql';
-import { UserInfo, IMetadataProvider, Metadata, LogError, LogStatus } from '@memberjunction/core';
-import { UUIDsEqual } from '@memberjunction/global';
+import { UserInfo, LogError, LogStatus } from '@memberjunction/core';
+import { UUIDsEqual, MJLruCache } from '@memberjunction/global';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
-import { MJComponentEntity, MJComponentRegistryEntity, ComponentMetadataEngine } from '@memberjunction/core-entities';
+import { MJComponentRegistryEntity, ComponentMetadataEngine } from '@memberjunction/core-entities';
 import { ComponentSpec } from '@memberjunction/interactive-component-types';
 import {
     ComponentRegistryClient,
@@ -16,7 +16,6 @@ import {
 } from '@memberjunction/component-registry-client-sdk';
 import { AppContext } from '../types.js';
 import { configInfo } from '../config.js';
-import { GetReadWriteProvider } from '../util.js';
 
 /**
  * GraphQL types for Component Registry operations
@@ -166,23 +165,43 @@ class ComponentFeedbackResponse {
  * - REGISTRY_API_KEY_<REGISTRY_NAME>: API key for authenticating with the registry
  *   Example: REGISTRY_API_KEY_MJ_CENTRAL=your-api-key-here
  */
+/** Server-side cache for registry component specs. Uses MJLruCache for isolated
+ *  LRU eviction with TTL — avoids sharing eviction budgets with RunView/RunQuery
+ *  data in LocalCacheManager. */
+const componentSpecCache = new MJLruCache<string, { specJson: string; hash: string }>({
+    maxSize: 200,
+    ttlMs: 60 * 60 * 1000 // 1 hour — components are immutable; TTL governs "latest" pointer freshness
+});
+
 @Resolver()
 export class ComponentRegistryExtendedResolver {
     private componentEngine = ComponentMetadataEngine.Instance;
-    
+
     constructor() {
         // No longer pre-initialize clients - create on demand
     }
-    
+
     /**
-     * Get a component from a registry with optional hash for caching
+     * Build a deterministic cache key for a registry component.
+     */
+    private getComponentCacheKey(registryName: string, namespace: string, name: string, version: string): string {
+        return `RegistryComponent|${registryName}|${namespace}|${name}|${version}`;
+    }
+
+    /**
+     * Get a component from a registry with optional hash for caching.
+     *
+     * Caching strategy (three tiers):
+     * 1. Client sends hash from a previous fetch → server can return 304 if unchanged
+     * 2. Server checks in-memory LRU cache for a cached spec from a recent fetch
+     * 3. On miss, fetches from the external registry, caches the result, and returns it
      */
     @Query(() => ComponentSpecWithHashType)
     async GetRegistryComponent(
         @Arg('registryName') registryName: string,
         @Arg('namespace') namespace: string,
         @Arg('name') name: string,
-        @Ctx() { userPayload, providers }: AppContext,
+        @Ctx() { userPayload }: AppContext,
         @Arg('version', { nullable: true }) version?: string,
         @Arg('hash', { nullable: true }) hash?: string
     ): Promise<ComponentSpecWithHashType> {
@@ -190,35 +209,59 @@ export class ComponentRegistryExtendedResolver {
             // Get user from cache
             const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email?.trim().toLowerCase());
             if (!user) throw new Error(`User ${userPayload.email} not found in UserCache`);
-            
+
             // Get registry from database by name
             const registry = await this.getRegistryByName(registryName, user);
             if (!registry) {
                 throw new Error(`Registry not found: ${registryName}`);
             }
-            
+
             // Check user permissions (use registry ID for permission check)
             await this.checkUserAccess(user, registry.ID);
-            
+
             // Initialize component engine
             await this.componentEngine.Config(false, user);
-            
-            // Create client on-demand for this registry
+
+            const resolvedVersion = version || 'latest';
+            const cacheKey = this.getComponentCacheKey(registry.Name, namespace, name, resolvedVersion);
+
+            // --- Tier 1: Check server-side cache ---
+            const cached = componentSpecCache.Get(cacheKey);
+
+            if (cached) {
+                // If client sent a hash and it matches, return 304
+                if (hash && hash === cached.hash) {
+                    return {
+                        specification: undefined,
+                        hash: cached.hash,
+                        notModified: true,
+                        message: 'Not modified'
+                    };
+                }
+
+                // Client has no hash or a different hash — return cached spec
+                return {
+                    specification: cached.specJson,
+                    hash: cached.hash,
+                    notModified: false,
+                    message: undefined
+                };
+            }
+
+            // --- Tier 2: Fetch from external registry ---
             const registryClient = this.createClientForRegistry(registry);
-            
-            // Fetch component from registry with hash support
+
             const response = await registryClient.getComponentWithHash({
                 registry: registry.Name,
                 namespace,
                 name,
-                version: version || 'latest',
+                version: resolvedVersion,
                 hash: hash,
                 userEmail: user.Email
             });
-            
-            // If not modified (304), return response with notModified flag
+
+            // If not modified (304 from registry), return to client
             if (response.notModified) {
-                LogStatus(`Component ${namespace}/${name} not modified (hash: ${response.hash})`);
                 return {
                     specification: undefined,
                     hash: response.hash,
@@ -226,22 +269,20 @@ export class ComponentRegistryExtendedResolver {
                     message: response.message || 'Not modified'
                 };
             }
-            
+
             // Extract the specification from the response
             const component = response.specification;
             if (!component) {
                 throw new Error(`Component ${namespace}/${name} returned without specification`);
             }
-            
-            // Optional: Cache in database if configured
-            if (this.shouldCache(registry)) {
-                const writeProvider = GetReadWriteProvider(providers, { allowFallbackToReadOnly: true }) as unknown as IMetadataProvider;
-                await this.cacheComponent(component, registry.ID, user, writeProvider);
-            }
-            
-            // Return the ComponentSpec as a JSON string
+
+            const specJson = JSON.stringify(component);
+
+            // --- Cache the result for subsequent requests ---
+            componentSpecCache.Set(cacheKey, { specJson, hash: response.hash });
+
             return {
-                specification: JSON.stringify(component),
+                specification: specJson,
                 hash: response.hash,
                 notModified: false,
                 message: undefined
@@ -489,100 +530,7 @@ export class ComponentRegistryExtendedResolver {
             headers: config?.headers
         });
     }
-    
-    /**
-     * Check if component should be cached
-     */
-    private shouldCache(registry: MJComponentRegistryEntity): boolean {
-        // Check config for caching settings
-        const config = configInfo.componentRegistries?.find(r =>
-            UUIDsEqual(r.id, registry.ID) || r.name === registry.Name
-        );
-        return config?.cache !== false; // Cache by default
-    }
-    
-    /**
-     * Cache component in database
-     */
-    private async cacheComponent(
-        component: ComponentSpec,
-        registryId: string,
-        userInfo: UserInfo,
-        provider?: IMetadataProvider
-    ): Promise<void> {
-        try {
-            // Find or create component entity
-            const md = provider ?? new Metadata();
-            const componentEntity = await md.GetEntityObject<MJComponentEntity>('MJ: Components', userInfo);
-            
-            // Check if component already exists
-            const existingComponent = this.componentEngine.Components?.find(
-                c => c.Name === component.name && 
-                     c.Namespace === component.namespace &&
-                     UUIDsEqual(c.SourceRegistryID, registryId)
-            );
-            
-            if (existingComponent) {
-                // Update existing component
-                if (!await componentEntity.Load(existingComponent.ID)) {
-                    throw new Error(`Failed to load component: ${existingComponent.ID}`);
-                }
-            } else {
-                // Create new component
-                componentEntity.NewRecord();
-                componentEntity.SourceRegistryID = registryId;
-            }
-            
-            // Update component fields
-            componentEntity.Name = component.name;
-            componentEntity.Namespace = component.namespace || '';
-            componentEntity.Version = component.version || '1.0.0';
-            componentEntity.Title = component.title;
-            componentEntity.Description = component.description;
-            componentEntity.Type = this.mapComponentType(component.type);
-            componentEntity.FunctionalRequirements = component.functionalRequirements;
-            componentEntity.TechnicalDesign = component.technicalDesign;
-            componentEntity.Specification = JSON.stringify(component);
-            componentEntity.LastSyncedAt = new Date();
-            
-            if (!existingComponent) {
-                componentEntity.ReplicatedAt = new Date();
-            }
-            
-            // Save component
-            const result = await componentEntity.Save();
-            if (!result) {
-                throw new Error(`Failed to cache component: ${component.name}`);
-            }
-            
-            // Refresh metadata cache
-            await this.componentEngine.Config(true, userInfo);
-        } catch (error) {
-            // Log but don't throw - caching failure shouldn't break the operation
-            LogError('Failed to cache component:');
-        }
-    }
-    
-    /**
-     * Map component type string to entity enum
-     */
-    private mapComponentType(type: string): MJComponentEntity['Type'] {
-        const typeMap: Record<string, MJComponentEntity['Type']> = {
-            'report': 'Report',
-            'dashboard': 'Dashboard',
-            'form': 'Form',
-            'table': 'Table',
-            'chart': 'Chart',
-            'navigation': 'Navigation',
-            'search': 'Search',
-            'widget': 'Widget',
-            'utility': 'Utility',
-            'other': 'Other'
-        };
-        
-        return typeMap[type.toLowerCase()] || 'Other';
-    }
-    
+
     /**
      * Map search result to GraphQL type
      */

package/src/resolvers/GetDataResolver.ts

@@ -216,8 +216,12 @@ export class GetDataResolver {
     async GetAllEntities(
     @Ctx() context: AppContext
     ): Promise<SimpleEntityResultType> {
-        try { 
-            const md = GetReadOnlyProvider(context.providers);
+        try {
+            // System-key contexts often only have a read-write provider configured;
+            // without the fallback, GetReadOnlyProvider returns null and `md.Entities`
+            // throws TypeError. Every other resolver passes this option — adding it
+            // here brings the call into line with the rest of the codebase.
+            const md = GetReadOnlyProvider(context.providers, { allowFallbackToReadWrite: true });
             const result = md.Entities.map((e) => {
                 return { 
                     ID: e.ID, 

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -1,5 +1,5 @@
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { CompositeKey, LocalCacheManager, Metadata, RunView, UserInfo, LogError, IMetadataProvider } from "@memberjunction/core";
+import { CompositeKey, DatabaseProviderBase, LocalCacheManager, Metadata, RunView, UserInfo, LogError, IMetadataProvider } from "@memberjunction/core";
 import { GetReadOnlyProvider, GetReadWriteProvider } from "../util.js";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
 import {
@@ -1747,9 +1747,13 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
         try {
             const user = this.getAuthenticatedUser(ctx);
             const rv = new RunView();
+            // Boolean literal goes through the active provider's dialect:
+            //   SQL Server emits `= 1`, PostgreSQL emits `= TRUE`.
+            // Filter stays server-side; no client-side `.filter()` post-pass.
+            const provider = GetReadOnlyProvider(ctx.providers, { allowFallbackToReadWrite: true }) as unknown as DatabaseProviderBase;
             const filters: string[] = [];
-            if (activeOnly) filters.push('IsActive=1');
             if (companyID) filters.push(`CompanyID='${companyID}'`);
+            if (activeOnly) filters.push(`IsActive = ${provider.Dialect.BooleanLiteral(true)}`);
             const filter = filters.join(' AND ');
             const result = await rv.RunView<MJCompanyIntegrationEntity>({
                 EntityName: 'MJ: Company Integrations',
@@ -1765,10 +1769,12 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
 
             if (!result.Success) return { Success: false, Message: result.ErrorMessage || 'Query failed' };
 
+            const filteredResults = result.Results;
+
             return {
                 Success: true,
-                Message: `${result.Results.length} connections`,
-                Connections: result.Results.map(ci => ({
+                Message: `${filteredResults.length} connections`,
+                Connections: filteredResults.map(ci => ({
                     ID: ci.ID,
                     IntegrationName: ci.Integration,
                     IntegrationID: ci.IntegrationID,

package/src/resolvers/QuerySystemUserResolver.ts

@@ -43,6 +43,15 @@ export class QueryPermissionInputType {
     RoleID!: string;
 }
 
+@InputType()
+export class QueryParameterHintInput {
+    @Field(() => String)
+    Name!: string;
+
+    @Field(() => String)
+    Value!: string;
+}
+
 @InputType()
 export class CreateQuerySystemUserInput {
     @Field(() => String)
@@ -98,6 +107,9 @@ export class CreateQuerySystemUserInput {
 
     @Field(() => [QueryPermissionInputType], { nullable: true })
     Permissions?: QueryPermissionInputType[];
+
+    @Field(() => [QueryParameterHintInput], { nullable: true })
+    ParameterHints?: QueryParameterHintInput[];
 }
 
 @InputType()
@@ -158,6 +170,9 @@ export class UpdateQuerySystemUserInput {
 
     @Field(() => [QueryPermissionInputType], { nullable: true })
     Permissions?: QueryPermissionInputType[];
+
+    @Field(() => [QueryParameterHintInput], { nullable: true })
+    ParameterHints?: QueryParameterHintInput[];
 }
 
 /**
@@ -246,7 +261,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             const record = await provider.GetEntityObject<MJQueryEntityServer>("MJ: Queries", context.userPayload.userRecord);
             
             // Destructure out non-database fields, keep only fields to persist
-            const { Permissions: _permissions, CategoryPath: _categoryPath, ...fieldsToSet } = {
+            const { Permissions: _permissions, CategoryPath: _categoryPath, ParameterHints: _parameterHints, ...fieldsToSet } = {
                 ...input,
                 CategoryID: finalCategoryID || input.CategoryID,
                 Status: input.Status || 'Approved',
@@ -259,6 +274,12 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             };
 
             record.SetMany(fieldsToSet, true);
+
+            // Pass caller-provided parameter sample values to override LLM guesses
+            if (input.ParameterHints && input.ParameterHints.length > 0) {
+                record.ParameterHints = new Map(input.ParameterHints.map(h => [h.Name, h.Value]));
+            }
+
             this.ListenForEntityMessages(record, pubSub, context.userPayload.userRecord);
 
             // Attempt to save the query
@@ -480,6 +501,11 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             // Use SetMany to update all fields at once
             queryEntity.SetMany(updateFields);
 
+            // Pass caller-provided parameter sample values to override LLM guesses
+            if (input.ParameterHints && input.ParameterHints.length > 0) {
+                queryEntity.ParameterHints = new Map(input.ParameterHints.map(h => [h.Name, h.Value]));
+            }
+
             // Save the updated query
             const saveResult = await queryEntity.Save();
             if (!saveResult) {