@memberjunction/codegen-lib 5.32.0 → 5.34.0

package/dist/Database/manage-metadata.js

@@ -1,6 +1,10 @@
 import { CodeGenDatabaseProvider } from './codeGenDatabaseProvider.js';
-import { SQLServerCodeGenProvider } from './providers/sqlserver/SQLServerCodeGenProvider.js';
-import { configInfo, currentWorkingDirectory, dbType, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
+// Side-effect import — registers `SQLServerCodeGenProvider` with `MJGlobal.ClassFactory`
+// under the `'sqlserver'` key via its `@RegisterClass` decorator. Without this import,
+// `ClassFactory.CreateInstance(CodeGenDatabaseProvider, 'sqlserver')` returns nothing
+// and the SS code path silently fails.
+import './providers/sqlserver/SQLServerCodeGenProvider.js';
+import { configInfo, currentWorkingDirectory, dbPlatform, getSettingValue, mj_core_schema, outputDir } from '../Config/config.js';
 import { EntityInfo, ExtractActualDefaultValue, LogError, LogStatus, Metadata, SeverityType } from "@memberjunction/core";
 import { MJEntityFieldSchema } from "@memberjunction/core-entities";
 import { logError, logMessage, logStatus, startSpinner, updateSpinner, succeedSpinner } from "../Misc/status_logging.js";
@@ -36,31 +40,35 @@ export class ManageMetadataBase {
     constructor() {
         // ─── Database Provider Infrastructure ─────────────────────────────
         // All platform-specific SQL generation is delegated to the CodeGenDatabaseProvider.
-        // The provider is lazily initialized from the dbType() config on first access.
+        // The provider is lazily initialized from the dbPlatform() config on first access.
         this._dbProvider = null;
         // ─── End Dialect Infrastructure ───────────────────────────────────
         this._sqlUtilityObject = MJGlobal.Instance.ClassFactory.CreateInstance(SQLUtilityBase);
     }
     /**
      * Returns the CodeGenDatabaseProvider for the current database platform.
-     * Lazily initialized from dbType() configuration.
+     * Lazily initialized from dbPlatform() configuration.
+     *
+     * Lookup goes through `MJGlobal.ClassFactory` keyed by the platform string,
+     * which matches the `@RegisterClass(CodeGenDatabaseProvider, '<platform>')`
+     * decorators on the concrete providers (`'sqlserver'`, `'postgresql'`).
+     * Mismatched keys silently fall back to the abstract base class — fail loud
+     * with an explicit error so a misconfigured platform doesn't ship as a
+     * runtime breakage in dialect-specific methods.
      */
     get dbProvider() {
         if (!this._dbProvider) {
-            const platform = dbType();
-            if (platform === 'postgresql') {
-                const pgProvider = MJGlobal.Instance.ClassFactory.CreateInstance(CodeGenDatabaseProvider, 'PostgreSQLCodeGenProvider');
-                if (pgProvider) {
-                    this._dbProvider = pgProvider;
-                }
-                else {
-                    throw new Error('PostgreSQL CodeGen provider not found. Ensure @memberjunction/postgresql-dataprovider ' +
-                        'is installed and its CodeGen provider is registered before running CodeGen.');
-                }
-            }
-            else {
-                this._dbProvider = new SQLServerCodeGenProvider();
-            }
+            const platform = dbPlatform();
+            const provider = MJGlobal.Instance.ClassFactory.CreateInstance(CodeGenDatabaseProvider, platform);
+            // CreateInstance returns the abstract base class on a missed key (it
+            // doesn't throw), so disambiguate by constructor identity: anything
+            // that's still the bare base means lookup didn't resolve to a real
+            // dialect provider for this platform.
+            if (!provider || provider.constructor === CodeGenDatabaseProvider) {
+                throw new Error(`CodeGen provider for dbPlatform='${platform}' not found. Ensure the corresponding ` +
+                    `provider package is installed and registered via @RegisterClass(CodeGenDatabaseProvider, '${platform}').`);
+            }
+            this._dbProvider = provider;
         }
         return this._dbProvider;
     }
@@ -117,6 +125,49 @@ export class ManageMetadataBase {
     async runQueryWithParams(pool, sql, params) {
         return pool.queryWithParams(this.qsql(sql), params);
     }
+    /**
+     * Returns a sequence value safe to use for an EntityField INSERT under the given
+     * EntityID, defaulting to `candidate` when it doesn't collide. Otherwise returns
+     * `MAX(Sequence) + 1` for that entity.
+     *
+     * Why this exists: several insert paths (virtual-entity field sync, IS-A parent
+     * field sync, schema-derived field creation) compute a deterministic sequence
+     * up-front, but a partial prior run can leave rows at that exact ordinal under
+     * the target EntityID. SS hides the collision because retried runs typically
+     * succeed before failing; PG raises UQ_EntityField_EntityID_Sequence (~4 errors
+     * per advanced-generation run). The values are temporary anyway —
+     * spUpdateExistingEntityFieldsFromSchema renumbers them on the next pass.
+     */
+    async nextAvailableEntityFieldSequence(pool, entityId, candidate) {
+        const schema = mj_core_schema();
+        const tbl = this.qs(schema, 'EntityField');
+        const seqCol = this.qi('Sequence');
+        const entityIdCol = this.qi('EntityID');
+        const sql = `SELECT
+                      ${this.coalesce(`MAX(${seqCol})`, '0')} AS ${this.qi('MaxSeq')},
+                      ${this.coalesce(`MAX(CASE WHEN ${seqCol} = @Candidate THEN 1 ELSE 0 END)`, '0')} AS ${this.qi('Hit')}
+                   FROM ${tbl}
+                   WHERE ${entityIdCol} = @EntityID`;
+        try {
+            const result = await this.runQueryWithParams(pool, sql, {
+                EntityID: entityId,
+                Candidate: candidate,
+            });
+            const row = result.recordset?.[0];
+            if (!row)
+                return candidate;
+            const hit = Number(row.Hit ?? 0) > 0;
+            if (!hit)
+                return candidate;
+            const maxSeq = Number(row.MaxSeq ?? 0);
+            return maxSeq + 1;
+        }
+        catch {
+            // If the lookup itself fails, fall back to the candidate. The downstream
+            // INSERT will surface the real error if there's a true collision.
+            return candidate;
+        }
+    }
     /**
      * Wraps a SELECT query with a row limit.
      * SQL Server: SELECT TOP N ... , PostgreSQL: SELECT ... LIMIT N
@@ -374,6 +425,49 @@ export class ManageMetadataBase {
         }
         return results;
     }
+    /**
+     * Extracts value-list field configurations from the additionalSchemaInfo config file.
+     * Walks schema → tables → table.Fields[] and returns a map keyed by "schema.table".
+     */
+    extractFieldValueLists(config) {
+        const results = new Map();
+        // Check flat "Tables" array format
+        if (Array.isArray(config.Tables)) {
+            for (const table of config.Tables) {
+                this.extractFieldsFromTableEntry(table.SchemaName || 'dbo', table.TableName, table, results);
+            }
+            return results;
+        }
+        // Schema-as-key format
+        const metadataKeys = new Set(['$schema', 'description', 'version', 'VirtualEntities', 'ISARelationships', 'Entities', 'Tables', 'Schemas']);
+        for (const [key, value] of Object.entries(config)) {
+            if (metadataKeys.has(key))
+                continue;
+            if (!Array.isArray(value))
+                continue;
+            for (const table of value) {
+                this.extractFieldsFromTableEntry(key, table.TableName, table, results);
+            }
+        }
+        return results;
+    }
+    /**
+     * Extracts Fields[] entries from a single table config entry and adds them to the results map.
+     */
+    extractFieldsFromTableEntry(schemaName, tableName, tableConfig, results) {
+        const fields = tableConfig.Fields;
+        if (!Array.isArray(fields) || fields.length === 0)
+            return;
+        const key = `${schemaName}.${tableName}`;
+        const fieldConfigs = fields.map((f) => ({
+            FieldName: f.FieldName,
+            ValueListType: f.ValueListType || 'List',
+            PossibleValues: f.PossibleValues || [],
+            Description: f.Description || undefined,
+            Confidence: f.Confidence || undefined,
+        }));
+        results.set(key, fieldConfigs);
+    }
     /**
      * Processes organic key configurations from additionalSchemaInfo.
      * For each configured organic key:
@@ -954,6 +1048,11 @@ export class ManageMetadataBase {
             else {
                 // this means that we do NOT have a match so the field does not exist in the entity definition, so we need to add it
                 newEntityFieldUUID = this.createNewUUID();
+                // Compute a non-colliding sequence by querying MAX(Sequence) for this entity. The
+                // ordinal `fieldSequence` (column index in the view) is correct for stable ordering
+                // when nothing exists yet, but a partial prior run could have left rows at the same
+                // ordinal under this EntityID — UQ_EntityField_EntityID_Sequence then fires on PG.
+                const safeSequence = await this.nextAvailableEntityFieldSequence(pool, entity.ID, fieldSequence);
                 const q = (n) => this.qi(n);
                 const sqlAdd = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
                                       ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
@@ -962,7 +1061,7 @@ export class ManageMetadataBase {
                                       ${q('__mj_CreatedAt')}, ${q('__mj_UpdatedAt')} )
                             VALUES (  '${newEntityFieldUUID}', '${entity.ID}', '${veField.FieldName}', '${veField.Type}', ${this.boolLit(veField.AllowsNull)},
                                        ${veField.Length}, ${veField.Precision}, ${veField.Scale},
-                                       ${fieldSequence}, ${this.boolLit(makePrimaryKey)}, ${this.boolLit(makePrimaryKey)},
+                                       ${safeSequence}, ${this.boolLit(makePrimaryKey)}, ${this.boolLit(makePrimaryKey)},
                                        ${this.utcNow()}, ${this.utcNow()}
                                     )`;
                 await this.LogSQLAndExecute(pool, sqlAdd, `SQL text to add virtual entity field ${veField.FieldName} for entity ${virtualEntity.Name}`);
@@ -1187,7 +1286,7 @@ export class ManageMetadataBase {
                          WHERE EntityID='${entity.ID}' AND Name='${pk}'`);
             logStatus(`         ✓ Set PK for ${entity.Name}.${pk} (LLM-identified)`);
         }
-        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-identified PKs for ${entity.Name}: ${validPKs.join(', ')}`);
+        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified PKs for ${entity.Name}: ${validPKs.join(', ')}`);
         return true;
     }
     /**
@@ -1232,7 +1331,7 @@ export class ManageMetadataBase {
         if (sqlStatements.length === 0) {
             return false;
         }
-        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-identified FKs for ${entity.Name}`);
+        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-identified FKs for ${entity.Name}`);
         return true;
     }
     /**
@@ -1269,7 +1368,7 @@ export class ManageMetadataBase {
         if (sqlStatements.length === 0) {
             return false;
         }
-        await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set LLM-generated descriptions for ${entity.Name} (${sqlStatements.length} fields)`);
+        await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set LLM-generated descriptions for ${entity.Name} (${sqlStatements.length} fields)`);
         return true;
     }
     /**
@@ -1412,8 +1511,12 @@ export class ManageMetadataBase {
             else {
                 // Create new virtual field record for this parent field
                 const newFieldID = this.createNewUUID();
-                // Use high sequence — will be reordered by updateExistingEntityFieldsFromSchema
-                const sequence = 100000 + parentFields.indexOf(parentField);
+                // Use high sequence — will be reordered by updateExistingEntityFieldsFromSchema.
+                // Query MAX(Sequence) at insert time so we never collide with an existing row
+                // (e.g. partial prior run left a record at the candidate ordinal under this
+                // EntityID — UQ_EntityField_EntityID_Sequence then fires on PG).
+                const candidate = 100000 + parentFields.indexOf(parentField);
+                const sequence = await this.nextAvailableEntityFieldSequence(pool, childEntity.ID, candidate);
                 const q = (n) => this.qi(n);
                 const sqlInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'EntityField')} (
                   ${q('ID')}, ${q('EntityID')}, ${q('Name')}, ${q('Type')}, ${q('AllowsNull')},
@@ -1948,6 +2051,14 @@ export class ManageMetadataBase {
                 bSuccess = false;
             }
             logStatus(`      Managed entity field values in ${(new Date().getTime() - step6StartTime.getTime()) / 1000} seconds`);
+            // Apply soft value-list config from additionalSchemaInfo Fields[]
+            // Runs AFTER CHECK constraint pass so CHECK-derived values are authoritative
+            const stepValueListStartTime = new Date();
+            if (!await this.applyValueListConfig(pool)) {
+                logError('Error applying soft value-list configuration');
+                // Non-fatal: soft value-lists are supplementary
+            }
+            logStatus(`      Applied soft value-list configuration in ${(new Date().getTime() - stepValueListStartTime.getTime()) / 1000} seconds`);
         }
         // Advanced Generation - Smart field identification and form layout
         if (!skipAdvancedGeneration) {
@@ -2098,6 +2209,98 @@ export class ManageMetadataBase {
             return false;
         }
     }
+    /**
+     * Applies soft value-list configuration from Fields[] entries in additionalSchemaInfo.json.
+     * Runs AFTER manageEntityFieldValuesAndValidatorFunctions() so CHECK-constraint-derived
+     * values are already in the database. If EntityFieldValue rows already exist for a field
+     * (from CHECK constraints), the soft-enum pass skips that field — CHECK is authoritative.
+     */
+    async applyValueListConfig(pool) {
+        const config = ManageMetadataBase.getSoftPKFKConfig();
+        if (!config)
+            return true;
+        const fieldLists = this.extractFieldValueLists(config);
+        if (fieldLists.size === 0)
+            return true;
+        try {
+            // Load all existing EntityFieldValue rows for dedup checking
+            const efvSQL = `SELECT * FROM ${this.qs(mj_core_schema(), 'EntityFieldValue')} ORDER BY EntityFieldID, Sequence`;
+            const allEFVResult = await this.runQuery(pool, efvSQL);
+            const allEntityFieldValues = allEFVResult.recordset;
+            let totalApplied = 0;
+            let totalSkipped = 0;
+            for (const [schemaTable, fields] of fieldLists) {
+                const [schemaName, tableName] = schemaTable.split('.');
+                const result = await this.applyValueListsForTable(pool, schemaName, tableName, fields, allEntityFieldValues);
+                totalApplied += result.applied;
+                totalSkipped += result.skipped;
+            }
+            if (totalApplied > 0 || totalSkipped > 0) {
+                logStatus(`         Applied ${totalApplied} soft value-list(s), skipped ${totalSkipped} (CHECK-authoritative)`);
+            }
+            return true;
+        }
+        catch (e) {
+            logError(`Error applying value-list configuration: ${e}`);
+            return false;
+        }
+    }
+    /**
+     * Applies value-list fields for a single table. For each field, checks if
+     * EntityFieldValue rows already exist (from CHECK constraints) and skips if so.
+     */
+    async applyValueListsForTable(pool, schemaName, tableName, fields, allEntityFieldValues) {
+        const schema = mj_core_schema();
+        let applied = 0;
+        let skipped = 0;
+        // Look up entity ID
+        const entityLookupSQL = `SELECT ID FROM ${this.qs(schema, 'Entity')} WHERE SchemaName = '${schemaName}' AND BaseTable = '${tableName}'`;
+        const entityResult = await this.runQuery(pool, entityLookupSQL);
+        if (entityResult.recordset.length === 0) {
+            logStatus(`         ⚠️  Entity not found for ${schemaName}.${tableName} — skipping soft value-lists`);
+            return { applied, skipped };
+        }
+        const entityId = entityResult.recordset[0].ID;
+        for (const fieldCfg of fields) {
+            const fieldResult = await this.applyValueListForField(pool, schema, entityId, schemaName, tableName, fieldCfg, allEntityFieldValues);
+            if (fieldResult === 'applied')
+                applied++;
+            else
+                skipped++;
+        }
+        return { applied, skipped };
+    }
+    /**
+     * Applies value-list config for a single field. Returns 'applied' or 'skipped'.
+     */
+    async applyValueListForField(pool, schema, entityId, schemaName, tableName, fieldCfg, allEntityFieldValues) {
+        // Look up EntityField ID
+        const efSQL = `SELECT ID, ValueListType FROM ${this.qs(schema, 'EntityField')} WHERE EntityID = '${entityId}' AND Name = '${fieldCfg.FieldName}'`;
+        const efResult = await this.runQuery(pool, efSQL);
+        if (efResult.recordset.length === 0) {
+            logStatus(`         ⚠️  Field ${fieldCfg.FieldName} not found on ${schemaName}.${tableName} — skipping`);
+            return 'skipped';
+        }
+        const efRecord = efResult.recordset[0];
+        const entityFieldID = efRecord.ID;
+        // CHECK constraint is authoritative — if EntityFieldValue rows already exist, skip
+        const existing = allEntityFieldValues.filter((efv) => String(efv.EntityFieldID) === String(entityFieldID));
+        const currentValueListType = (efRecord.ValueListType || '').trim().toLowerCase();
+        if (existing.length > 0 && currentValueListType !== 'none' && currentValueListType !== '') {
+            return 'skipped';
+        }
+        // Apply: sync values and set ValueListType
+        const sortedValues = [...fieldCfg.PossibleValues].sort();
+        await this.syncEntityFieldValues(pool, entityFieldID, sortedValues, allEntityFieldValues);
+        // Update ValueListType
+        const newType = fieldCfg.ValueListType;
+        if (currentValueListType !== newType.toLowerCase()) {
+            const updateSQL = `UPDATE ${this.qs(schema, 'EntityField')} SET ValueListType='${newType}' WHERE ID='${entityFieldID}'`;
+            await this.LogSQLAndExecute(pool, updateSQL, `Set soft ValueListType='${newType}' for ${schemaName}.${tableName}.${fieldCfg.FieldName}`);
+        }
+        logStatus(`         ✓ Applied soft value-list for ${tableName}.${fieldCfg.FieldName} (${sortedValues.length} values, type=${newType})`);
+        return 'applied';
+    }
     /**
      * This method ensures that the __mj_CreatedAt and __mj_UpdatedAt fields exist in each entity that has TrackRecordChanges set to true. If the fields do not exist, they are created.
      * If the fields exist but have incorrect default values, the default values are updated. The default value that is to be used for these special fields is GETUTCDATE() which is the
@@ -2408,6 +2611,7 @@ export class ManageMetadataBase {
             ${this.qi('AutoIncrement')},
             ${this.qi('AllowUpdateAPI')},
             ${this.qi('IsVirtual')},
+            ${this.qi('IsComputed')},
             ${this.qi('RelatedEntityID')},
             ${this.qi('RelatedEntityFieldName')},
             ${this.qi('IsNameField')},
@@ -2437,6 +2641,7 @@ export class ManageMetadataBase {
             ${this.boolLit(n.AutoIncrement)},
             ${this.boolLit(n.AllowUpdateAPI)},
             ${this.boolLit(n.IsVirtual)},
+            ${this.boolLit(n.IsComputed)},
             ${n.RelatedEntityID && n.RelatedEntityID.length > 0 ? `'${n.RelatedEntityID}'` : 'NULL'},
             ${n.RelatedEntityFieldName && n.RelatedEntityFieldName.length > 0 ? `'${n.RelatedEntityFieldName}'` : 'NULL'},
             ${this.boolLit(n.IsNameField !== null ? n.IsNameField : false)},
@@ -3806,6 +4011,8 @@ export class ManageMetadataBase {
                 if (fieldAnalysis) {
                     await this.applySmartFieldIdentification(pool, {
                         ID: entity.ID,
+                        Name: entity.Name,
+                        SchemaName: entityRecord.SchemaName,
                         AllowUserSearchAPI: entityRecord.AllowUserSearchAPI,
                         AutoUpdateAllowUserSearchAPI: entityRecord.AutoUpdateAllowUserSearchAPI,
                         FullTextSearchEnabled: entityRecord.FullTextSearchEnabled,
@@ -3905,7 +4112,7 @@ export class ManageMetadataBase {
         const sqlStatements = [];
         this.applyNameFieldUpdates(sqlStatements, fields, result);
         this.applyDefaultInViewUpdates(sqlStatements, fields, result);
-        this.applySearchableFieldUpdates(sqlStatements, fields, result);
+        this.applySearchableFieldUpdates(sqlStatements, fields, result, entity);
         this.applySearchPredicateUpdates(sqlStatements, fields, result);
         this.applyEntitySearchConfig(sqlStatements, entity, result);
         if (configInfo.advancedGeneration?.allowFullTextSearchAutoUpdate) {
@@ -3913,9 +4120,8 @@ export class ManageMetadataBase {
         }
         // Execute all updates in one batch
         if (sqlStatements.length > 0) {
-            const combinedSQL = sqlStatements.join('\n');
             try {
-                await this.LogSQLAndExecute(pool, combinedSQL, `Set field properties for entity`, false);
+                await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set field properties for entity`, false);
             }
             catch (ex) {
                 logError('Error executing combined smart field SQL: ', ex);
@@ -3963,9 +4169,17 @@ export class ManageMetadataBase {
         }
     }
     /**
-     * Generate SQL UPDATEs for IncludeInUserSearchAPI on the identified searchable fields
+     * Generate SQL UPDATEs for IncludeInUserSearchAPI on the identified searchable fields.
+     *
+     * Guardrails: even if the SmartFieldIdentificationResult flags a field as searchable,
+     * we refuse to enable IncludeInUserSearchAPI when the field is a primary key, a
+     * non-text type (LIKE forces an implicit per-row CONVERT and never seeks an index),
+     * or an unbounded text type whose parent entity is not FTX-enabled (the LIKE path
+     * cannot seek MAX/ntext/text columns; FTX is the right tool there). These are
+     * always-wrong cases — they cause the data provider to emit unindexed scans on
+     * every search.
      */
-    applySearchableFieldUpdates(sqlStatements, fields, result) {
+    applySearchableFieldUpdates(sqlStatements, fields, result, entity) {
         if (!result.searchableFields || result.searchableFields.length === 0) {
             return;
         }
@@ -3974,7 +4188,13 @@ export class ManageMetadataBase {
         if (missingSearchableFields.length > 0) {
             logError(`Smart field identification returned invalid searchableFields: ${missingSearchableFields.join(', ')} not found in entity`);
         }
+        const ftxEnabled = !!entity?.FullTextSearchEnabled;
         for (const field of searchableFields) {
+            if (!this.isFieldEligibleForUserSearch(field, ftxEnabled)) {
+                // Silently skip — the LLM proposed a field we cannot honor without
+                // creating an unindexed scan. This is a guardrail, not a bug.
+                continue;
+            }
             if (!field.IncludeInUserSearchAPI) {
                 sqlStatements.push(`
                UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
@@ -3985,6 +4205,25 @@ export class ManageMetadataBase {
             }
         }
     }
+    /**
+     * Returns true if the field is a sensible target for LIKE-based user search.
+     * Mirrors the runtime guard in GenericDatabaseProvider.isTextSearchableType /
+     * the Phase 1 hygiene migration so CodeGen stops re-introducing invalid flags.
+     */
+    isFieldEligibleForUserSearch(field, ftxEnabled) {
+        if (field.IsPrimaryKey === true)
+            return false;
+        const type = (field.Type ?? '').toLowerCase();
+        // Non-text types are never appropriate for substring search.
+        const textTypes = new Set(['nvarchar', 'varchar', 'char', 'nchar']);
+        if (!textTypes.has(type))
+            return false;
+        // Unbounded text on a non-FTX entity cannot be index-seeked.
+        const length = field.Length;
+        if (length === -1 && !ftxEnabled)
+            return false;
+        return true;
+    }
     /**
      * Generate SQL UPDATEs for UserSearchPredicateAPI on each searchable field
      */
@@ -4013,7 +4252,14 @@ export class ManageMetadataBase {
         }
     }
     /**
-     * Generate SQL UPDATEs for entity-level AllowUserSearchAPI
+     * Generate SQL UPDATEs for entity-level AllowUserSearchAPI.
+     *
+     * Guardrail: even if the LLM proposes enabling AllowUserSearchAPI on an entity
+     * that looks like an audit/log/run-history table by name, refuse — those tables
+     * grow unboundedly, the LIKE fan-out across them dominates global-search latency,
+     * and they're virtually never the right target for a user-facing search box.
+     * The team can still enable search on such an entity by setting
+     * AutoUpdateAllowUserSearchAPI=0 and flipping the flag manually.
      */
     applyEntitySearchConfig(sqlStatements, entity, result) {
         if (result.allowUserSearch == null || !entity.AutoUpdateAllowUserSearchAPI) {
@@ -4021,6 +4267,11 @@ export class ManageMetadataBase {
         }
         const newValue = result.allowUserSearch;
         const currentValue = !!entity.AllowUserSearchAPI;
+        // If the LLM is proposing to ENABLE search on a log/audit/run-history-style
+        // entity, drop the proposal. We never block a proposal to DISABLE search.
+        if (newValue && !currentValue && this.isLikelyLogOrAuditEntity(entity.Name, entity.SchemaName)) {
+            return;
+        }
         if (newValue !== currentValue) {
             sqlStatements.push(`
             UPDATE ${this.qs(mj_core_schema(), 'Entity')}
@@ -4030,6 +4281,31 @@ export class ManageMetadataBase {
          `);
         }
     }
+    /**
+     * Heuristic: does the entity name match the shape of an audit / log /
+     * run-history / change-tracking table? These are the entities that drive
+     * the most LIKE-scan time and almost never belong in global search.
+     */
+    isLikelyLogOrAuditEntity(name, _schemaName) {
+        if (!name)
+            return false;
+        const n = name.trim();
+        // Common patterns: ends in "Logs"/"Log", ends in "Runs"/"Run History",
+        // contains "Audit", or matches MJ's "Record Changes" naming.
+        if (/\bLogs?$/i.test(n))
+            return true;
+        if (/\bAudit\b/i.test(n))
+            return true;
+        if (/\bRecord Changes?$/i.test(n))
+            return true;
+        if (/\bRuns?$/i.test(n) && !/Test Runs?$/i.test(n))
+            return true;
+        if (/\bRun (History|Steps|Messages)$/i.test(n))
+            return true;
+        if (/\bExecution Logs?$/i.test(n))
+            return true;
+        return false;
+    }
     /**
      * Generate SQL UPDATEs for entity-level and field-level FullTextSearch configuration
      */
@@ -4238,7 +4514,7 @@ WHERE
         }
         if (sqlStatements.length > 0) {
             try {
-                await this.LogSQLAndExecute(pool, sqlStatements.join('\n'), `Set categories for ${sqlStatements.length} fields`, false);
+                await this.LogSQLBatchAndExecute(pool, sqlStatements, `Set categories for ${sqlStatements.length} fields`, false);
             }
             catch (ex) {
                 logError('Error Applying Field Categories', ex);
@@ -4259,8 +4535,8 @@ WHERE
                 const escapedIcon = entityIcon.replace(/'/g, "''");
                 const updateSQL = `
                UPDATE ${this.qs(mj_core_schema(), 'Entity')}
-               SET Icon = '${escapedIcon}', __mj_UpdatedAt = ${this.utcNow()}
-               WHERE ID = '${entityId}'
+               SET ${this.qi('Icon')} = '${escapedIcon}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
+               WHERE ${this.qi('ID')} = '${entityId}'
             `;
                 try {
                     await this.LogSQLAndExecute(pool, updateSQL, `Set entity icon to ${entityIcon}`, false);
@@ -4280,14 +4556,14 @@ WHERE
             return;
         const infoJSON = JSON.stringify(categoryInfo).replace(/'/g, "''");
         // Upsert FieldCategoryInfo (new format)
-        const checkNewSQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'`;
+        const checkNewSQL = `SELECT ${this.qi('ID')} FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'`;
         const existingNew = await this.runQuery(pool, checkNewSQL);
         if (existingNew.recordset.length > 0) {
             try {
                 await this.LogSQLAndExecute(pool, `
                UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
-               SET Value = '${infoJSON}', __mj_UpdatedAt = ${this.utcNow()}
-               WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryInfo'
+               SET ${this.qi('Value')} = '${infoJSON}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
+               WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryInfo'
             `, `Update FieldCategoryInfo setting for entity`, false);
             }
             catch (ex) {
@@ -4298,7 +4574,7 @@ WHERE
             const newId = uuidv4();
             try {
                 await this.LogSQLAndExecute(pool, `
-               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
                VALUES ('${newId}', '${entityId}', 'FieldCategoryInfo', '${infoJSON}', ${this.utcNow()}, ${this.utcNow()})
             `, `Insert FieldCategoryInfo setting for entity`, false);
             }
@@ -4314,14 +4590,14 @@ WHERE
             }
         }
         const iconsJSON = JSON.stringify(iconsOnly).replace(/'/g, "''");
-        const checkLegacySQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'`;
+        const checkLegacySQL = `SELECT ${this.qi('ID')} FROM ${this.qs(mj_core_schema(), 'EntitySetting')} WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'`;
         const existingLegacy = await this.runQuery(pool, checkLegacySQL);
         if (existingLegacy.recordset.length > 0) {
             try {
                 await this.LogSQLAndExecute(pool, `
                UPDATE ${this.qs(mj_core_schema(), 'EntitySetting')}
-               SET Value = '${iconsJSON}', __mj_UpdatedAt = ${this.utcNow()}
-               WHERE EntityID = '${entityId}' AND Name = 'FieldCategoryIcons'
+               SET ${this.qi('Value')} = '${iconsJSON}', ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
+               WHERE ${this.qi('EntityID')} = '${entityId}' AND ${this.qi('Name')} = 'FieldCategoryIcons'
             `, `Update FieldCategoryIcons setting (legacy)`, false);
             }
             catch (ex) {
@@ -4332,7 +4608,7 @@ WHERE
             const newId = uuidv4();
             try {
                 await this.LogSQLAndExecute(pool, `
-               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (ID, EntityID, Name, Value, __mj_CreatedAt, __mj_UpdatedAt)
+               INSERT INTO ${this.qs(mj_core_schema(), 'EntitySetting')} (${this.qi('ID')}, ${this.qi('EntityID')}, ${this.qi('Name')}, ${this.qi('Value')}, ${this.qi(EntityInfo.CreatedAtFieldName)}, ${this.qi(EntityInfo.UpdatedAtFieldName)})
                VALUES ('${newId}', '${entityId}', 'FieldCategoryIcons', '${iconsJSON}', ${this.utcNow()}, ${this.utcNow()})
             `, `Insert FieldCategoryIcons setting (legacy)`, false);
             }
@@ -4348,8 +4624,8 @@ WHERE
     async applyEntityImportance(pool, entityId, importance) {
         const updateSQL = `
          UPDATE ${this.qs(mj_core_schema(), 'ApplicationEntity')}
-         SET DefaultForNewUser = ${this.boolLit(importance.defaultForNewUser)}, __mj_UpdatedAt = ${this.utcNow()}
-         WHERE EntityID = '${entityId}'
+         SET ${this.qi('DefaultForNewUser')} = ${this.boolLit(importance.defaultForNewUser)}, ${this.qi(EntityInfo.UpdatedAtFieldName)} = ${this.utcNow()}
+         WHERE ${this.qi('EntityID')} = '${entityId}'
       `;
         try {
             await this.LogSQLAndExecute(pool, updateSQL, `Set DefaultForNewUser=${importance.defaultForNewUser} for NEW entity (category: ${importance.entityCategory}, confidence: ${importance.confidence})`, false);
@@ -4373,5 +4649,33 @@ WHERE
     async LogSQLAndExecute(pool, query, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO') {
         return await SQLLogging.LogSQLAndExecute(pool, this.qsql(query), description, isRecurringScript, includeBatchSeparator, batchSeparator);
     }
+    /**
+     * Logs and executes a sequence of SQL statements as a single batch.
+     *
+     * Each statement is dialect-quoted (via `qsql`), has its trailing
+     * whitespace/`;` trimmed, then gets a single `;` re-appended. Statements
+     * are joined with `\n` and sent through `LogSQLAndExecute` so PG's strict
+     * parser sees properly-terminated boundaries between statements.
+     *
+     * Use this instead of `statements.join('\n')` followed by
+     * `LogSQLAndExecute(...)`. SQL Server tolerated the unterminated form;
+     * PG does not. SS still accepts the explicitly-terminated batch, so
+     * this is a no-cost upgrade for both dialects.
+     *
+     * Empty / whitespace-only statements are filtered out. Returns
+     * `undefined` (no execution) when nothing remains.
+     */
+    async LogSQLBatchAndExecute(pool, statements, description, isRecurringScript = false, includeBatchSeparator = false, batchSeparator = 'GO') {
+        const terminated = [];
+        for (const s of statements) {
+            const trimmed = (s ?? '').replace(/[\s;]+$/g, '');
+            if (trimmed.length === 0)
+                continue;
+            terminated.push(`${trimmed};`);
+        }
+        if (terminated.length === 0)
+            return undefined;
+        return await this.LogSQLAndExecute(pool, terminated.join('\n'), description, isRecurringScript, includeBatchSeparator, batchSeparator);
+    }
 }
 //# sourceMappingURL=manage-metadata.js.map