@memberjunction/server 5.25.0 → 5.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/server",
-  "version": "5.25.0",
+  "version": "5.27.0",
   "description": "MemberJunction: This project provides API access via GraphQL to the common data store.",
   "main": "./dist/index.js",
   "types": "./src/index.ts",
@@ -27,68 +27,71 @@
     "@as-integrations/express5": "^1.0.0",
     "@graphql-tools/schema": "latest",
     "@graphql-tools/utils": "^11.0.0",
-    "@memberjunction/actions": "5.25.0",
-    "@memberjunction/actions-apollo": "5.25.0",
-    "@memberjunction/actions-base": "5.25.0",
-    "@memberjunction/actions-bizapps-accounting": "5.25.0",
-    "@memberjunction/actions-bizapps-crm": "5.25.0",
-    "@memberjunction/actions-bizapps-formbuilders": "5.25.0",
-    "@memberjunction/actions-bizapps-lms": "5.25.0",
-    "@memberjunction/actions-bizapps-social": "5.25.0",
-    "@memberjunction/ai": "5.25.0",
-    "@memberjunction/ai-agent-manager": "5.25.0",
-    "@memberjunction/ai-agent-manager-actions": "5.25.0",
-    "@memberjunction/ai-agents": "5.25.0",
-    "@memberjunction/ai-core-plus": "5.25.0",
-    "@memberjunction/ai-mcp-client": "5.25.0",
-    "@memberjunction/ai-prompts": "5.25.0",
-    "@memberjunction/ai-provider-bundle": "5.25.0",
-    "@memberjunction/ai-vector-sync": "5.25.0",
-    "@memberjunction/ai-vectors-pinecone": "5.25.0",
-    "@memberjunction/aiengine": "5.25.0",
-    "@memberjunction/api-keys": "5.25.0",
-    "@memberjunction/auth-providers": "5.25.0",
-    "@memberjunction/codegen-lib": "5.25.0",
-    "@memberjunction/communication-ms-graph": "5.25.0",
-    "@memberjunction/communication-sendgrid": "5.25.0",
-    "@memberjunction/communication-types": "5.25.0",
-    "@memberjunction/component-registry-client-sdk": "5.25.0",
-    "@memberjunction/computer-use-engine": "5.25.0",
-    "@memberjunction/config": "5.25.0",
-    "@memberjunction/core": "5.25.0",
-    "@memberjunction/core-actions": "5.25.0",
-    "@memberjunction/core-entities": "5.25.0",
-    "@memberjunction/core-entities-server": "5.25.0",
-    "@memberjunction/data-context": "5.25.0",
-    "@memberjunction/data-context-server": "5.25.0",
-    "@memberjunction/doc-utils": "5.25.0",
-    "@memberjunction/encryption": "5.25.0",
-    "@memberjunction/entity-communications-base": "5.25.0",
-    "@memberjunction/entity-communications-server": "5.25.0",
-    "@memberjunction/external-change-detection": "5.25.0",
-    "@memberjunction/generic-database-provider": "5.25.0",
-    "@memberjunction/global": "5.25.0",
-    "@memberjunction/graphql-dataprovider": "5.25.0",
-    "@memberjunction/integration-engine": "5.25.0",
-    "@memberjunction/integration-schema-builder": "5.25.0",
-    "@memberjunction/interactive-component-types": "5.25.0",
-    "@memberjunction/notifications": "5.25.0",
-    "@memberjunction/postgresql-dataprovider": "5.25.0",
-    "@memberjunction/queue": "5.25.0",
-    "@memberjunction/redis-provider": "5.25.0",
-    "@memberjunction/scheduling-actions": "5.25.0",
-    "@memberjunction/scheduling-base-types": "5.25.0",
-    "@memberjunction/scheduling-engine": "5.25.0",
-    "@memberjunction/scheduling-engine-base": "5.25.0",
-    "@memberjunction/server-extensions-core": "5.25.0",
-    "@memberjunction/skip-types": "5.25.0",
-    "@memberjunction/sql-dialect": "5.25.0",
-    "@memberjunction/sqlserver-dataprovider": "5.25.0",
-    "@memberjunction/storage": "5.25.0",
-    "@memberjunction/templates": "5.25.0",
-    "@memberjunction/testing-engine": "5.25.0",
-    "@memberjunction/testing-engine-base": "5.25.0",
-    "@memberjunction/version-history": "5.25.0",
+    "@memberjunction/actions": "5.27.0",
+    "@memberjunction/actions-apollo": "5.27.0",
+    "@memberjunction/actions-base": "5.27.0",
+    "@memberjunction/actions-bizapps-accounting": "5.27.0",
+    "@memberjunction/actions-bizapps-crm": "5.27.0",
+    "@memberjunction/actions-bizapps-formbuilders": "5.27.0",
+    "@memberjunction/actions-bizapps-lms": "5.27.0",
+    "@memberjunction/actions-bizapps-social": "5.27.0",
+    "@memberjunction/ai": "5.27.0",
+    "@memberjunction/ai-agent-manager": "5.27.0",
+    "@memberjunction/ai-agent-manager-actions": "5.27.0",
+    "@memberjunction/ai-agents": "5.27.0",
+    "@memberjunction/ai-core-plus": "5.27.0",
+    "@memberjunction/ai-mcp-client": "5.27.0",
+    "@memberjunction/ai-prompts": "5.27.0",
+    "@memberjunction/ai-provider-bundle": "5.27.0",
+    "@memberjunction/ai-vector-sync": "5.27.0",
+    "@memberjunction/ai-vectordb": "5.27.0",
+    "@memberjunction/ai-vectors-pinecone": "5.27.0",
+    "@memberjunction/aiengine": "5.27.0",
+    "@memberjunction/api-keys": "5.27.0",
+    "@memberjunction/auth-providers": "5.27.0",
+    "@memberjunction/codegen-lib": "5.27.0",
+    "@memberjunction/communication-ms-graph": "5.27.0",
+    "@memberjunction/communication-sendgrid": "5.27.0",
+    "@memberjunction/communication-types": "5.27.0",
+    "@memberjunction/component-registry-client-sdk": "5.27.0",
+    "@memberjunction/computer-use-engine": "5.27.0",
+    "@memberjunction/config": "5.27.0",
+    "@memberjunction/core": "5.27.0",
+    "@memberjunction/core-actions": "5.27.0",
+    "@memberjunction/core-entities": "5.27.0",
+    "@memberjunction/core-entities-server": "5.27.0",
+    "@memberjunction/data-context": "5.27.0",
+    "@memberjunction/data-context-server": "5.27.0",
+    "@memberjunction/doc-utils": "5.27.0",
+    "@memberjunction/encryption": "5.27.0",
+    "@memberjunction/entity-communications-base": "5.27.0",
+    "@memberjunction/entity-communications-server": "5.27.0",
+    "@memberjunction/external-change-detection": "5.27.0",
+    "@memberjunction/generic-database-provider": "5.27.0",
+    "@memberjunction/global": "5.27.0",
+    "@memberjunction/graphql-dataprovider": "5.27.0",
+    "@memberjunction/integration-engine": "5.27.0",
+    "@memberjunction/integration-schema-builder": "5.27.0",
+    "@memberjunction/interactive-component-types": "5.27.0",
+    "@memberjunction/notifications": "5.27.0",
+    "@memberjunction/postgresql-dataprovider": "5.27.0",
+    "@memberjunction/queue": "5.27.0",
+    "@memberjunction/redis-provider": "5.27.0",
+    "@memberjunction/scheduling-actions": "5.27.0",
+    "@memberjunction/scheduling-base-types": "5.27.0",
+    "@memberjunction/scheduling-engine": "5.27.0",
+    "@memberjunction/scheduling-engine-base": "5.27.0",
+    "@memberjunction/schema-engine": "5.27.0",
+    "@memberjunction/search-engine": "5.27.0",
+    "@memberjunction/server-extensions-core": "5.27.0",
+    "@memberjunction/skip-types": "5.27.0",
+    "@memberjunction/sql-dialect": "5.27.0",
+    "@memberjunction/sqlserver-dataprovider": "5.27.0",
+    "@memberjunction/storage": "5.27.0",
+    "@memberjunction/templates": "5.27.0",
+    "@memberjunction/testing-engine": "5.27.0",
+    "@memberjunction/testing-engine-base": "5.27.0",
+    "@memberjunction/version-history": "5.27.0",
     "@types/compression": "^1.8.1",
     "@types/cors": "^2.8.19",
     "@types/jsonwebtoken": "9.0.10",

package/src/agents/skip-sdk.ts

@@ -17,12 +17,6 @@ import {
     SkipAPIRequestAPIKey,
     SkipQueryInfo,
     SkipQueryCatalogEntry,
-    SkipEntityInfo,
-    SkipEntityFieldInfo,
-    SkipEntityFieldValueInfo,
-    SkipEntityRelationshipInfo,
-    SkipEntityOrganicKeyInfo,
-    SkipEntityOrganicKeyRelatedEntityInfo,
     SkipAPIAgentNote,
     SkipAPIAgentNoteType,
     SkipAPIArtifact,
@@ -30,7 +24,7 @@ import {
     SkipAPIArtifactType
 } from '@memberjunction/skip-types';
 import { DataContext } from '@memberjunction/data-context';
-import { UserInfo, LogStatus, LogError, Metadata, RunQuery, EntityInfo, EntityFieldInfo, EntityRelationshipInfo, EntityOrganicKeyInfo, EntityOrganicKeyRelatedEntityInfo } from '@memberjunction/core';
+import { UserInfo, LogStatus, LogError, Metadata, RunQuery, EntityInfo, EntityFieldInfo, EntityFieldValueInfo, DatabaseProviderBase } from '@memberjunction/core';
 import { request as httpRequest } from 'http';
 import { request as httpsRequest } from 'https';
 import { gzip as gzipCompress, createGunzip } from 'zlib';
@@ -206,7 +200,7 @@ export class SkipSDK {
     private config: SkipSDKConfig;
 
     // Static cache for Skip entities (shared across all instances)
-    private static __skipEntitiesCache$: BehaviorSubject<Promise<SkipEntityInfo[]> | null> = new BehaviorSubject<Promise<SkipEntityInfo[]> | null>(null);
+    private static __skipEntitiesCache$: BehaviorSubject<Promise<EntityInfo[]> | null> = new BehaviorSubject<Promise<EntityInfo[]> | null>(null);
     private static __lastRefreshTime: number = 0;
 
     constructor(config?: SkipSDKConfig) {
@@ -396,7 +390,7 @@ export class SkipSDK {
         includeCallbackAuth: boolean,
         additionalTokenInfo: any = {}
     ): Promise<Partial<SkipAPIRequest>> {
-        const entities = includeEntities ? await this.buildEntities(dataSource, forceEntityRefresh) : [];
+        const entities = includeEntities ? await this.buildEntities(forceEntityRefresh) : [];
         const queries = includeQueries ? this.buildQueries() : [];
         // Always build the lightweight query catalog for collision detection,
         // regardless of whether full queries are included
@@ -442,7 +436,7 @@ export class SkipSDK {
      * Build entity metadata for Skip
      * Copied from AskSkipResolver.BuildSkipEntities - uses cached metadata with refresh logic
      */
-    private async buildEntities(dataSource: mssql.ConnectionPool, forceRefresh: boolean, refreshIntervalMinutes: number = 15): Promise<SkipEntityInfo[]> {
+    private async buildEntities(forceRefresh: boolean, refreshIntervalMinutes: number = 15): Promise<EntityInfo[]> {
         try {
             const now = Date.now();
             const cacheExpired = (now - SkipSDK.__lastRefreshTime) > (refreshIntervalMinutes * 60 * 1000);
@@ -450,7 +444,7 @@ export class SkipSDK {
             // If force refresh is requested OR cache expired OR cache is empty, refresh
             if (forceRefresh || cacheExpired || SkipSDK.__skipEntitiesCache$.value === null) {
                 LogStatus(`[SkipSDK] Refreshing Skip entities cache (force: ${forceRefresh}, expired: ${cacheExpired})`);
-                const newData = this.refreshSkipEntities(dataSource);
+                const newData = this.refreshSkipEntities();
                 SkipSDK.__skipEntitiesCache$.next(newData);
             }
 
@@ -856,9 +850,11 @@ export class SkipSDK {
     /**
      * Refreshes the Skip entities cache
      * Rebuilds the entity information that is provided to Skip
-     * Copied from AskSkipResolver.refreshSkipEntities
+     * Refreshes the entity metadata cache. Filters entities by schema/scope config,
+     * filters fields by AI scope, and enriches field values from the database.
+     * Returns EntityInfo objects directly — no intermediate Skip-specific types needed.
      */
-    private async refreshSkipEntities(dataSource: mssql.ConnectionPool): Promise<SkipEntityInfo[]> {
+    private async refreshSkipEntities(): Promise<EntityInfo[]> {
         try {
             const md = new Metadata();
 
@@ -891,12 +887,12 @@ export class SkipSDK {
                 LogError(`[SkipSDK.refreshSkipEntities] WARNING: No entities passed filtering! This will result in empty Skip entities list.`);
             }
 
-            // Now we have our list of entities, pack em up
-            const result = await Promise.all(entities.map((e) => this.packSingleSkipEntityInfo(e, dataSource)));
+            // Build enriched EntityInfo objects with filtered fields and packed values
+            const result = await Promise.all(entities.map((e) => this.buildEntityForSkip(e)));
 
             LogStatus(`[SkipSDK.refreshSkipEntities] Successfully packed ${result.length} entities for Skip`);
 
-            SkipSDK.__lastRefreshTime = Date.now(); // Update last refresh time
+            SkipSDK.__lastRefreshTime = Date.now();
             return result;
         }
         catch (e) {
@@ -906,258 +902,95 @@ export class SkipSDK {
     }
 
     /**
-     * Packs information about a single entity for Skip
-     * Includes fields, relationships, and sample data
-     * Copied from AskSkipResolver.PackSingleSkipEntityInfo
+     * Builds an EntityInfo object for Skip, filtering fields by AI scope and
+     * enriching field values from the database. Returns a new EntityInfo
+     * constructed from a plain object so it serializes cleanly via toJSON().
      */
-    private async packSingleSkipEntityInfo(e: EntityInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityInfo> {
+    private async buildEntityForSkip(e: EntityInfo): Promise<EntityInfo> {
         try {
-            const ret: SkipEntityInfo = {
-                id: e.ID,
-                name: e.Name,
-                schemaName: e.SchemaName,
-                baseView: e.BaseView,
-                description: e.Description,
-
-                fields: await Promise.all(e.Fields.filter(f => {
-                    // we want to check the scopes for the field level and make sure it is either All or AI or has both
-                    const scopes = f.ScopeDefault?.split(',').map((s) => s.trim().toLowerCase());
-                    return !scopes || scopes.length === 0 || scopes.includes('all') || scopes.includes('ai');
-                }).map(f => {
-                    return this.packSingleSkipEntityField(f, dataSource);
-                })),
-
-                relatedEntities: e.RelatedEntities.map((r) => {
-                    return this.packSingleSkipEntityRelationship(r);
-                }),
-
-                organicKeys: (e.OrganicKeys ?? [])
-                    .filter((ok) => ok.Status === 'Active')
-                    .map((ok) => this.packSingleSkipOrganicKey(ok))
-                    .filter((ok): ok is SkipEntityOrganicKeyInfo => ok !== null)
-            };
-            return ret;
-        }
-        catch (e) {
-            LogError(`[SkipSDK] packSingleSkipEntityInfo error: ${e}`);
-            return null;
-        }
-    }
-
-    /**
-     * Packs information about a single organic key for Skip.
-     * Organic keys express cross-entity relationships via shared business data
-     * (email, acronym, etc.) rather than database FK constraints.
-     */
-    private packSingleSkipOrganicKey(ok: EntityOrganicKeyInfo): SkipEntityOrganicKeyInfo | null {
-        try {
-            return {
-                id: ok.ID,
-                name: ok.Name,
-                description: ok.Description ?? undefined,
-                matchFieldNames: ok.MatchFieldNamesArray,
-                normalizationStrategy: ok.NormalizationStrategy,
-                customNormalizationExpression: ok.CustomNormalizationExpression ?? undefined,
-                sequence: ok.Sequence,
-                relatedEntities: ok.RelatedEntities
-                    .map((re) => this.packSingleSkipOrganicKeyRelatedEntity(re))
-                    .filter((re): re is SkipEntityOrganicKeyRelatedEntityInfo => re !== null)
-            };
-        }
-        catch (e) {
-            LogError(`[SkipSDK] packSingleSkipOrganicKey error: ${e}`);
-            return null;
-        }
-    }
+            // Filter fields by scope (only include fields visible to AI)
+            const filteredFields = e.Fields.filter(f => {
+                const scopes = f.ScopeDefault?.split(',').map((s) => s.trim().toLowerCase());
+                return !scopes || scopes.length === 0 || scopes.includes('all') || scopes.includes('ai');
+            });
 
-    /**
-     * Packs information about a single organic key related entity for Skip.
-     * Looks up schema name and base view from metadata since they are not
-     * stored on EntityOrganicKeyRelatedEntityInfo directly.
-     */
-    private packSingleSkipOrganicKeyRelatedEntity(
-        re: EntityOrganicKeyRelatedEntityInfo
-    ): SkipEntityOrganicKeyRelatedEntityInfo | null {
-        try {
-            // Look up the related entity to obtain schema name and base view, which
-            // Skip needs in order to generate schema-qualified SQL.
-            const relatedEntity = Metadata.Provider.Entities.find(
-                (ent) => UUIDsEqual(ent.ID, re.RelatedEntityID)
-            );
-            if (!relatedEntity) {
-                LogError(
-                    `[SkipSDK] packSingleSkipOrganicKeyRelatedEntity: related entity not found for ID ${re.RelatedEntityID}`
-                );
-                return null;
-            }
+            // Enrich each field with packed possible values
+            const enrichedFields = await Promise.all(filteredFields.map(f => this.enrichFieldValues(f)));
 
-            return {
-                id: re.ID,
-                relatedEntityID: re.RelatedEntityID,
-                relatedEntityName: relatedEntity.Name,
-                relatedEntitySchemaName: relatedEntity.SchemaName,
-                relatedEntityBaseView: relatedEntity.BaseView,
-                isDirectMatch: re.IsDirectMatch,
-                isTransitiveMatch: re.IsTransitiveMatch,
-                relatedEntityFieldNames: re.IsDirectMatch
-                    ? re.RelatedEntityFieldNamesArray
-                    : undefined,
-                transitiveObjectName: re.TransitiveObjectName ?? undefined,
-                transitiveObjectMatchFieldNames: re.IsTransitiveMatch
-                    ? re.TransitiveObjectMatchFieldNamesArray
-                    : undefined,
-                transitiveObjectOutputFieldName: re.TransitiveObjectOutputFieldName ?? undefined,
-                relatedEntityJoinFieldName: re.RelatedEntityJoinFieldName ?? undefined,
-                displayName: re.DisplayName ?? undefined,
-                sequence: re.Sequence
-            };
-        }
-        catch (e) {
-            LogError(`[SkipSDK] packSingleSkipOrganicKeyRelatedEntity error: ${e}`);
-            return null;
-        }
-    }
-
-    /**
-     * Packs information about a single entity relationship
-     * These relationships help Skip understand the data model
-     * Copied from AskSkipResolver.PackSingleSkipEntityRelationship
-     */
-    private packSingleSkipEntityRelationship(r: EntityRelationshipInfo): SkipEntityRelationshipInfo {
-        try {
-            return {
-                entityID: r.EntityID,
-                relatedEntityID: r.RelatedEntityID,
-                type: r.Type,
-                entityKeyField: r.EntityKeyField,
-                relatedEntityJoinField: r.RelatedEntityJoinField,
-                joinView: r.JoinView,
-                joinEntityJoinField: r.JoinEntityJoinField,
-                joinEntityInverseJoinField: r.JoinEntityInverseJoinField,
-                entity: r.Entity,
-                entityBaseView: r.EntityBaseView,
-                relatedEntity: r.RelatedEntity,
-                relatedEntityBaseView: r.RelatedEntityBaseView,
-            };
+            // Clone the entity via toJSON, then swap in filtered+enriched fields and Skip-specific
+            // Active-only organic keys. Any future EntityInfo properties flow through automatically.
+            return new EntityInfo({
+                ...e.toJSON(),
+                Fields: enrichedFields,
+                OrganicKeys: e.OrganicKeys.filter(ok => ok.Status === 'Active'),
+            });
         }
-        catch (e) {
-            LogError(`[SkipSDK] packSingleSkipEntityRelationship error: ${e}`);
+        catch (err) {
+            LogError(`[SkipSDK] buildEntityForSkip error: ${err}`);
             return null;
         }
     }
 
     /**
-     * Packs information about a single entity field
-     * Includes metadata and possible values
-     * Copied from AskSkipResolver.PackSingleSkipEntityField
+     * Enriches a field's EntityFieldValues with possible values from the database.
+     * Returns a plain object that can be used to construct an EntityFieldInfo.
      */
-    private async packSingleSkipEntityField(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldInfo> {
-        try {
-            return {
-                entityID: f.EntityID,
-                sequence: f.Sequence,
-                name: f.Name,
-                displayName: f.DisplayName,
-                category: f.Category,
-                type: f.Type,
-                description: f.Description,
-                isPrimaryKey: f.IsPrimaryKey,
-                allowsNull: f.AllowsNull,
-                isUnique: f.IsUnique,
-                length: f.Length,
-                precision: f.Precision,
-                scale: f.Scale,
-                sqlFullType: f.SQLFullType,
-                defaultValue: f.DefaultValue,
-                autoIncrement: f.AutoIncrement,
-                valueListType: f.ValueListType,
-                extendedType: f.ExtendedType,
-                defaultInView: f.DefaultInView,
-                defaultColumnWidth: f.DefaultColumnWidth,
-                isVirtual: f.IsVirtual,
-                isNameField: f.IsNameField,
-                relatedEntityID: f.RelatedEntityID,
-                relatedEntityFieldName: f.RelatedEntityFieldName,
-                relatedEntity: f.RelatedEntity,
-                relatedEntitySchemaName: f.RelatedEntitySchemaName,
-                relatedEntityBaseView: f.RelatedEntityBaseView,
-                possibleValues: await this.packFieldPossibleValues(f, dataSource),
-            };
-        }
-        catch (e) {
-            LogError(`[SkipSDK] packSingleSkipEntityField error: ${e}`);
-            return null;
-        }
+    private async enrichFieldValues(f: EntityFieldInfo): Promise<Record<string, unknown>> {
+        return {
+            ...f.toJSON(),
+            EntityFieldValues: await this.packFieldValues(f),
+        };
     }
 
     /**
-     * Packs possible values for an entity field
-     * These values help Skip understand the domain and valid values for fields
-     * Copied from AskSkipResolver.PackFieldPossibleValues
+     * Packs possible values for an entity field based on the ValuesToPackWithSchema setting.
+     * Returns EntityFieldValueInfo-compatible objects.
      */
-    private async packFieldPossibleValues(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldValueInfo[]> {
+    private async packFieldValues(f: EntityFieldInfo): Promise<EntityFieldValueInfo[]> {
         try {
             if (f.ValuesToPackWithSchema === 'None') {
-                return []; // don't pack anything
+                return [];
             }
             else if (f.ValuesToPackWithSchema === 'All') {
-                // wants ALL of the distinct values
-                return await this.getFieldDistinctValues(f, dataSource);
+                return await this.getFieldDistinctValues(f);
             }
             else if (f.ValuesToPackWithSchema === 'Auto') {
-                // default setting - pack based on the ValueListType
                 if (f.ValueListTypeEnum === 'List') {
-                    // simple list of values in the Entity Field Values table
-                    return f.EntityFieldValues.map((v) => {
-                        return { value: v.Value, displayValue: v.Value };
-                    });
+                    return f.EntityFieldValues.map((v) => new EntityFieldValueInfo({ Value: v.Value, Code: v.Value }));
                 }
                 else if (f.ValueListTypeEnum === 'ListOrUserEntry') {
-                    // could be a user provided value, OR the values in the list of possible values.
-                    // get the distinct list of values from the DB and concat that with the f.EntityFieldValues array - deduped and return
-                    const values = await this.getFieldDistinctValues(f, dataSource);
+                    const values = await this.getFieldDistinctValues(f);
                     if (!values || values.length === 0) {
-                        // no result, just return the EntityFieldValues
-                        return f.EntityFieldValues.map((v) => {
-                            return { value: v.Value, displayValue: v.Value };
-                        });
+                        return f.EntityFieldValues.map((v) => new EntityFieldValueInfo({ Value: v.Value, Code: v.Value }));
                     }
                     else {
-                        return [...new Set([...f.EntityFieldValues.map((v) => {
-                            return { value: v.Value, displayValue: v.Value };
-                        }), ...values])];
+                        const fromEntityFieldValues = f.EntityFieldValues.map((v) => new EntityFieldValueInfo({ Value: v.Value, Code: v.Value }));
+                        return [...new Set([...fromEntityFieldValues, ...values])];
                     }
                 }
             }
-            return []; // if we get here, nothing to pack
+            return [];
         }
         catch (e) {
-            LogError(`[SkipSDK] packFieldPossibleValues error: ${e}`);
+            LogError(`[SkipSDK] packFieldValues error: ${e}`);
             return [];
         }
     }
 
     /**
-     * Gets distinct values for a field from the database
-     * Used to provide Skip with information about the possible values
-     * Copied from AskSkipResolver.GetFieldDistinctValues
+     * Gets distinct values for a field from the database.
+     * Returns EntityFieldValueInfo objects.
      */
-    private async getFieldDistinctValues(f: EntityFieldInfo, dataSource: mssql.ConnectionPool): Promise<SkipEntityFieldValueInfo[]> {
+    private async getFieldDistinctValues(f: EntityFieldInfo): Promise<EntityFieldValueInfo[]> {
         try {
+            // Uses the provider's ExecuteSQL so this works on both SQL Server and PostgreSQL.
+            const provider = Metadata.Provider as DatabaseProviderBase;
             const sql = `SELECT DISTINCT ${f.Name} FROM ${f.SchemaName}.${f.BaseView}`;
-            const request = new mssql.Request(dataSource);
-            const result = await request.query(sql);
-            if (!result || !result.recordset) {
+            const rows = await provider.ExecuteSQL<Record<string, unknown>>(sql);
+            if (!rows || rows.length === 0) {
                 return [];
             }
-            else {
-                return result.recordset.map((r) => {
-                    return {
-                        value: r[f.Name],
-                        displayValue: r[f.Name]
-                    };
-                });
-            }
+            return rows.map((r) => new EntityFieldValueInfo({ Value: r[f.Name] as string, Code: r[f.Name] as string }));
         }
         catch (e) {
             LogError(`[SkipSDK] getFieldDistinctValues error: ${e}`);

package/src/config.ts

@@ -192,6 +192,19 @@ const serverExtensionSchema = z.object({
   Settings: z.record(z.unknown()).default({})
 }).passthrough();
 
+const cacheSettingsSchema = z.object({
+  /** Maximum total estimated memory for all cached results in MB. Default: 150. Set to 0 to disable memory-based eviction. */
+  maxMemoryMB: z.number().optional().default(150),
+  /** Maximum percentage of total cache memory that any single entity can occupy. Default: 50. Set to 0 to disable. */
+  maxPercentOfCachePerEntity: z.number().optional().default(50),
+  /** Default TTL in seconds. 0 = no TTL, rely on event-based invalidation. Default: 0. */
+  defaultTTLSeconds: z.number().optional().default(0),
+  /** Interval in seconds for periodic eviction sweep. 0 = disabled. Default: 300 (5 minutes). */
+  evictionSweepIntervalSeconds: z.number().optional().default(300),
+  /** Enable verbose cache logging (hits, misses, evictions). Default: false. */
+  verboseLogging: z.boolean().optional().default(false),
+});
+
 const configInfoSchema = z.object({
   userHandling: userHandlingInfoSchema,
   databaseSettings: databaseSettingsInfoSchema,
@@ -206,6 +219,7 @@ const configInfoSchema = z.object({
   queryDialects: queryDialectSchema.optional().default({}),
   multiTenancy: multiTenancySchema.optional().default({}),
   serverExtensions: z.array(serverExtensionSchema).optional().default([]),
+  cacheSettings: cacheSettingsSchema.optional().default({}),
 
   apiKey: z.string().optional(),
   baseUrl: z.string().default('http://localhost'),
@@ -252,6 +266,7 @@ export type TelemetryConfig = z.infer<typeof telemetrySchema>;
 export type QueryDialectConfig = z.infer<typeof queryDialectSchema>;
 export type MultiTenancyConfig = z.infer<typeof multiTenancySchema>;
 export type ServerExtensionConfig = z.infer<typeof serverExtensionSchema>;
+export type CacheSettingsConfig = z.infer<typeof cacheSettingsSchema>;
 export type ConfigInfo = z.infer<typeof configInfoSchema>;
 
 /**
@@ -378,6 +393,15 @@ export const DEFAULT_SERVER_CONFIG: Partial<ConfigInfo> = {
     level: 'standard'
   },
 
+  // Cache settings defaults
+  cacheSettings: {
+    maxMemoryMB: 150,
+    maxPercentOfCachePerEntity: 50,
+    defaultTTLSeconds: 0,
+    evictionSweepIntervalSeconds: 300,
+    verboseLogging: false,
+  },
+
   // Auth providers (environment-driven)
   authProviders: [
     // Microsoft Azure AD / Entra ID

package/src/generated/generated.ts

@@ -37711,6 +37711,12 @@ export class MJEntity_ {
     @Field(() => Boolean, {description: `When true (default), CodeGen can automatically set SupportsGeoCoding based on LLM analysis of entity fields. Set to 0 to lock the value and prevent CodeGen from changing it.`}) 
     AutoUpdateSupportsGeoCoding: boolean;
         
+    @Field(() => Boolean, {description: `Controls whether this entity participates in server-side and client-side caching. When false, all cache operations (PreRunView checks, auto-cache storage, BaseEntity event fingerprint scans, client-side IndexedDB cache) are skipped entirely. This column is the single source of truth at runtime; schema-level defaults are applied at CodeGen time via newEntityDefaults.AllowCachingBySchema.`}) 
+    AllowCaching: boolean;
+        
+    @Field(() => Boolean, {description: `When set to 1 AND TrackRecordChanges is also 1, the external change detection system will scan this entity for changes made outside the MJ framework (direct SQL, third-party tools, etc.) and replay them through Save() to create proper RecordChange audit entries. Default is 0 (opt-out) because most entities, especially __mj schema metadata tables, are managed by migrations/CodeGen and should not be scanned.`}) 
+    DetectExternalChanges: boolean;
+        
     @Field({nullable: true, description: `Schema-based programmatic code name derived from the entity Name. Uses GetClassNameSchemaPrefix(SchemaName) as the prefix, then strips EntityNamePrefix from the Name and removes spaces. For "__mj" schema with entity "MJ: AI Models", this produces "MJAIModels". For entities in other schemas, the sanitized schema name is prepended. Used in GraphQL type generation and internal code references.`}) 
     CodeName?: string;
         
@@ -38080,6 +38086,12 @@ export class CreateMJEntityInput {
 
     @Field(() => Boolean, { nullable: true })
     AutoUpdateSupportsGeoCoding?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    AllowCaching?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    DetectExternalChanges?: boolean;
 }
     
 
@@ -38265,6 +38277,12 @@ export class UpdateMJEntityInput {
     @Field(() => Boolean, { nullable: true })
     AutoUpdateSupportsGeoCoding?: boolean;
 
+    @Field(() => Boolean, { nullable: true })
+    AllowCaching?: boolean;
+
+    @Field(() => Boolean, { nullable: true })
+    DetectExternalChanges?: boolean;
+
     @Field(() => [KeyValuePairInput], { nullable: true })
     OldValues___?: KeyValuePairInput[];
 }