@memberjunction/codegen-lib 5.24.0 → 5.26.0

package/dist/Database/manage-metadata.js

@@ -2,7 +2,7 @@ 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';
 import { EntityInfo, ExtractActualDefaultValue, LogError, LogStatus, Metadata, SeverityType } from "@memberjunction/core";
-import { logError, logMessage, logStatus } from "../Misc/status_logging.js";
+import { logError, logMessage, logStatus, startSpinner, updateSpinner, succeedSpinner } from "../Misc/status_logging.js";
 import { SQLUtilityBase } from "./sql.js";
 import { AdvancedGeneration } from "../Misc/advanced_generation.js";
 import { SQLParser } from "@memberjunction/sql-parser";
@@ -186,6 +186,20 @@ export class ManageMetadataBase {
     static get modifiedEntityList() {
         return this._modifiedEntityList;
     }
+    static { this._entitiesRequiringViewRegen = []; }
+    /**
+     * Entities that had late-phase changes requiring their base views to be
+     * regenerated after the main SQL generation pass. Each entry includes
+     * the reason for regen so downstream logic can apply reason-specific fixups.
+     */
+    static get EntitiesRequiringViewRegen() {
+        return this._entitiesRequiringViewRegen;
+    }
+    static AddEntityRequiringViewRegen(entityName, reason) {
+        if (!this._entitiesRequiringViewRegen.some(e => e.EntityName === entityName && e.Reason === reason)) {
+            this._entitiesRequiringViewRegen.push({ EntityName: entityName, Reason: reason });
+        }
+    }
     static { this._generatedValidators = []; }
     /**
      * Globally scoped list of validators that have been generated during the metadata management process.
@@ -1260,7 +1274,8 @@ export class ManageMetadataBase {
      * Valid values for EntityField.ExtendedType, plus common LLM aliases mapped to valid values.
      */
     static { this.VALID_EXTENDED_TYPES = new Set([
-        'Code', 'Email', 'FaceTime', 'Geo', 'MSTeams', 'Other', 'SIP', 'SMS', 'Skype', 'Tel', 'URL', 'WhatsApp', 'ZoomMtg'
+        'Code', 'Email', 'FaceTime', 'Geo', 'GeoLatitude', 'GeoLongitude', 'GeoCountry', 'GeoStateProvince',
+        'GeoCity', 'GeoPostalCode', 'GeoAddress', 'MSTeams', 'Other', 'SIP', 'SMS', 'Skype', 'Tel', 'URL', 'WhatsApp', 'ZoomMtg'
     ]); }
     static { this.EXTENDED_TYPE_ALIASES = {
         'phone': 'Tel',
@@ -1273,6 +1288,19 @@ export class ManageMetadataBase {
         'text': 'SMS',
         'location': 'Geo',
         'address': 'Geo',
+        'latitude': 'GeoLatitude',
+        'lat': 'GeoLatitude',
+        'longitude': 'GeoLongitude',
+        'lng': 'GeoLongitude',
+        'lon': 'GeoLongitude',
+        'country': 'GeoCountry',
+        'state': 'GeoStateProvince',
+        'province': 'GeoStateProvince',
+        'city': 'GeoCity',
+        'postalcode': 'GeoPostalCode',
+        'zipcode': 'GeoPostalCode',
+        'zip': 'GeoPostalCode',
+        'streetaddress': 'GeoAddress',
         'teams': 'MSTeams',
         'facetime': 'FaceTime',
         'zoom': 'ZoomMtg',
@@ -1866,11 +1894,13 @@ export class ManageMetadataBase {
         // Advanced Generation - Smart field identification and form layout
         if (!skipAdvancedGeneration) {
             const step7StartTime = new Date();
+            startSpinner('Applying AI-powered advanced generation (smart fields, form layout)...');
             if (!await this.applyAdvancedGeneration(pool, excludeSchemas, currentUser)) {
                 logError('Error applying advanced generation features');
                 // Don't fail the entire process - advanced generation is optional
             }
-            logStatus(`      Applied advanced generation features in ${(new Date().getTime() - step7StartTime.getTime()) / 1000} seconds`);
+            const step7Elapsed = ((new Date().getTime() - step7StartTime.getTime()) / 1000).toFixed(1);
+            succeedSpinner(`Advanced generation completed (${step7Elapsed}s)`);
         }
         logStatus(`      Total time to manage entity fields: ${(new Date().getTime() - startTime.getTime()) / 1000} seconds`);
         return bSuccess;
@@ -3296,6 +3326,8 @@ export class ManageMetadataBase {
                        VALUES ('${appID}', '${appName}', 'Generated for schema', '${schemaName}', '${path}', 1)`;
             await this.LogSQLAndExecute(pool, sSQL, `SQL generated to create new application ${appName}`);
             LogStatus(`Created new application ${appName} with Path: ${path}`);
+            // Auto-assign default roles to the new application
+            await this.addDefaultRolesForApplication(pool, appID, appName);
             return appID;
         }
         catch (e) {
@@ -3303,6 +3335,29 @@ export class ManageMetadataBase {
             return null;
         }
     }
+    /**
+     * Adds default ApplicationRole records for a newly created application based on config settings.
+     * This grants configured roles access to the new application automatically.
+     */
+    async addDefaultRolesForApplication(pool, appId, appName) {
+        const defaults = configInfo.newSchemaDefaults.ApplicationRoleDefaults;
+        if (!defaults?.AutoAddRolesForNewApplications) {
+            return;
+        }
+        const md = new Metadata();
+        for (const roleDef of defaults.Roles) {
+            const role = md.Roles.find(r => r.Name.trim().toLowerCase() === roleDef.RoleName.trim().toLowerCase());
+            if (role) {
+                const sSQLInsert = `INSERT INTO ${this.qs(mj_core_schema(), 'ApplicationRole')}
+                                 (${this.qi('ApplicationID')}, ${this.qi('RoleID')}, ${this.qi('CanAccess')}, ${this.qi('CanAdmin')}) VALUES
+                                 ('${appId}', '${role.ID}', ${roleDef.CanAccess ? 1 : 0}, ${roleDef.CanAdmin ? 1 : 0})`;
+                await this.LogSQLAndExecute(pool, sSQLInsert, `Adding role ${roleDef.RoleName} to application ${appName}`);
+            }
+            else {
+                LogError(`Unable to find Role '${roleDef.RoleName}' for application ${appName}`);
+            }
+        }
+    }
     async applicationExists(pool, applicationName) {
         const sSQL = `SELECT ID FROM ${this.qs(mj_core_schema(), 'Application')} WHERE Name = '${applicationName}'`;
         const resultResult = await this.runQuery(pool, sSQL);
@@ -3390,6 +3445,7 @@ export class ManageMetadataBase {
     createNewEntityInsertSQL(newEntityUUID, newEntityName, newEntity, newEntitySuffix, newEntityDisplayName) {
         const newEntityDefaults = configInfo.newEntityDefaults;
         const newEntityDescriptionEscaped = newEntity.EntityDescription ? `'${newEntity.EntityDescription.replace(/'/g, "''")}'` : null;
+        const allowCaching = this.resolveAllowCachingForSchema(newEntity.SchemaName);
         const q = (name) => this.qi(name);
         const sSQLInsert = `
       INSERT INTO ${this.qs(mj_core_schema(), 'Entity')} (
@@ -3402,7 +3458,8 @@ export class ManageMetadataBase {
          ${q('BaseView')},
          ${q('SchemaName')},
          ${q('IncludeInAPI')},
-         ${q('AllowUserSearchAPI')}
+         ${q('AllowUserSearchAPI')},
+         ${q('AllowCaching')}
          ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', ' + q('TrackRecordChanges')}
          ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', ' + q('AuditRecordAccess')}
          ${newEntityDefaults.AuditViewRuns === undefined ? '' : ', ' + q('AuditViewRuns')}
@@ -3424,7 +3481,8 @@ export class ManageMetadataBase {
          'vw${generatePluralName(newEntity.TableName, { capitalizeFirstLetterOnly: true }) + (newEntitySuffix && newEntitySuffix.length > 0 ? newEntitySuffix : '')}',
          '${newEntity.SchemaName}',
          1,
-         ${newEntityDefaults.AllowUserSearchAPI === undefined ? 1 : newEntityDefaults.AllowUserSearchAPI ? 1 : 0}
+         ${newEntityDefaults.AllowUserSearchAPI === undefined ? 1 : newEntityDefaults.AllowUserSearchAPI ? 1 : 0},
+         ${allowCaching ? 1 : 0}
          ${newEntityDefaults.TrackRecordChanges === undefined ? '' : ', ' + (newEntityDefaults.TrackRecordChanges ? '1' : '0')}
          ${newEntityDefaults.AuditRecordAccess === undefined ? '' : ', ' + (newEntityDefaults.AuditRecordAccess ? '1' : '0')}
          ${newEntityDefaults.AuditViewRuns === undefined ? '' : ', ' + (newEntityDefaults.AuditViewRuns ? '1' : '0')}
@@ -3439,6 +3497,26 @@ export class ManageMetadataBase {
    `;
         return sSQLInsert;
     }
+    /**
+     * Resolves the AllowCaching default for a new entity in the given schema.
+     * AllowCachingBySchema entries override the global AllowCaching default. The
+     * `${mj_core_schema}` placeholder is expanded so core-schema rules apply
+     * regardless of how the core schema is named in this deployment.
+     */
+    resolveAllowCachingForSchema(schemaName) {
+        const defaults = configInfo.newEntityDefaults;
+        const overrides = defaults.AllowCachingBySchema ?? [];
+        const match = overrides.find(entry => {
+            let candidate = entry.SchemaName;
+            if (candidate?.trim().toLowerCase() === '${mj_core_schema}') {
+                candidate = mj_core_schema();
+            }
+            return candidate.trim().toLowerCase() === schemaName.trim().toLowerCase();
+        });
+        if (match)
+            return match.AllowCaching;
+        return defaults.AllowCaching ?? false;
+    }
     /**
      * Apply Advanced Generation features - Smart Field Identification and Form Layout Generation
      */
@@ -3486,7 +3564,11 @@ export class ManageMetadataBase {
                e.Description,
                e.SchemaName,
                e.BaseTable,
-               e.ParentID
+               e.ParentID,
+               e.AllowUserSearchAPI,
+               e.AutoUpdateAllowUserSearchAPI,
+               e.FullTextSearchEnabled,
+               e.AutoUpdateFullTextSearch
             FROM
                ${this.qs(mj_core_schema(), 'vwEntities')} e
             WHERE
@@ -3524,7 +3606,12 @@ export class ManageMetadataBase {
                ef.AllowUpdateAPI,
                ef.IsNameField,
                ef.DefaultInView,
-               ef.IncludeInUserSearchAPI
+               ef.IncludeInUserSearchAPI,
+               ef.UserSearchPredicateAPI,
+               ef.AutoUpdateUserSearchPredicate,
+               ef.FullTextSearchEnabled,
+               ef.AutoUpdateFullTextSearch,
+               ef.Length as MaxLength
             FROM
                ${this.qs(mj_core_schema(), 'vwEntityFields')} ef
             WHERE
@@ -3570,19 +3657,16 @@ export class ManageMetadataBase {
         }
     }
     /**
-     * Process entities in batches with parallel execution
-     * @param pool Database connection pool
-     * @param entities Entities to process
-     * @param allFields All fields for all entities (will be filtered per entity)
-     * @param ag AdvancedGeneration instance
-     * @param currentUser User context
-     * @param batchSize Number of entities to process in parallel (default 5)
+     * Process entities in batches with parallel execution.
+     * Batch size is configurable via advancedGeneration.batchSize in mj.config.cjs (default: 5).
      */
-    async processEntitiesBatched(pool, entities, allFields, ag, currentUser, batchSize = 5) {
+    async processEntitiesBatched(pool, entities, allFields, ag, currentUser) {
+        const batchSize = configInfo.advancedGeneration?.batchSize ?? 5;
         let processedCount = 0;
         let errorCount = 0;
+        const total = entities.length;
         // Process in batches
-        for (let i = 0; i < entities.length; i += batchSize) {
+        for (let i = 0; i < total; i += batchSize) {
             const batch = entities.slice(i, i + batchSize);
             // Process batch in parallel
             const batchResults = await Promise.allSettled(batch.map(entity => this.processEntityAdvancedGeneration(pool, entity, allFields, ag, currentUser)));
@@ -3596,9 +3680,9 @@ export class ManageMetadataBase {
                     logError(`         Error processing entity: ${result.reason}`);
                 }
             }
-            logStatus(`      Progress: ${processedCount}/${entities.length} entities processed`);
+            const pct = Math.round((processedCount / total) * 100);
+            updateSpinner(`Advanced generation: ${processedCount}/${total} entities (${pct}%)${errorCount > 0 ? ` — ${errorCount} error(s)` : ''}`);
         }
-        logStatus(`      Advanced Generation complete: ${processedCount} entities processed, ${errorCount} errors`);
         return errorCount === 0;
     }
     /**
@@ -3616,15 +3700,26 @@ export class ManageMetadataBase {
             // Determine if this is a new entity (for DefaultForNewUser decision)
             const isNewEntity = ManageMetadataBase.newEntityList.includes(entity.Name);
             // Smart Field Identification
-            // Only run if at least one field allows auto-update for any of the smart field properties
-            if (fields.some((f) => f.AutoUpdateIsNameField || f.AutoUpdateDefaultInView || f.AutoUpdateIncludeInUserSearchAPI)) {
+            // Only run if at least one field allows auto-update for any of the smart field properties,
+            // or if entity-level search/FTS auto-update flags are set
+            const needsFieldAnalysis = fields.some((f) => f.AutoUpdateIsNameField || f.AutoUpdateDefaultInView || f.AutoUpdateIncludeInUserSearchAPI || f.AutoUpdateUserSearchPredicate || f.AutoUpdateFullTextSearch);
+            // entity-level auto-update flags come from the raw SQL query, not EntityInfo
+            const entityRecord = entity;
+            const needsEntitySearchConfig = entityRecord.AutoUpdateAllowUserSearchAPI || entityRecord.AutoUpdateFullTextSearch;
+            if (needsFieldAnalysis || needsEntitySearchConfig) {
                 const fieldAnalysis = await ag.identifyFields({
                     Name: entity.Name,
                     Description: entity.Description,
                     Fields: fields
                 }, currentUser);
                 if (fieldAnalysis) {
-                    await this.applySmartFieldIdentification(pool, entity.ID, fields, fieldAnalysis);
+                    await this.applySmartFieldIdentification(pool, {
+                        ID: entity.ID,
+                        AllowUserSearchAPI: entityRecord.AllowUserSearchAPI,
+                        AutoUpdateAllowUserSearchAPI: entityRecord.AutoUpdateAllowUserSearchAPI,
+                        FullTextSearchEnabled: entityRecord.FullTextSearchEnabled,
+                        AutoUpdateFullTextSearch: entityRecord.AutoUpdateFullTextSearch,
+                    }, fields, fieldAnalysis);
                 }
             }
             // Form Layout Generation
@@ -3713,14 +3808,36 @@ export class ManageMetadataBase {
         return null;
     }
     /**
-     * Apply smart field identification results to entity fields
+     * Apply smart field identification results to entity fields and entity-level search configuration
      */
-    async applySmartFieldIdentification(pool, entityId, fields, result) {
+    async applySmartFieldIdentification(pool, entity, fields, result) {
         const sqlStatements = [];
-        // Find the name field(s) — one or more fields that together form the display name
+        this.applyNameFieldUpdates(sqlStatements, fields, result);
+        this.applyDefaultInViewUpdates(sqlStatements, fields, result);
+        this.applySearchableFieldUpdates(sqlStatements, fields, result);
+        this.applySearchPredicateUpdates(sqlStatements, fields, result);
+        this.applyEntitySearchConfig(sqlStatements, entity, result);
+        if (configInfo.advancedGeneration?.allowFullTextSearchAutoUpdate) {
+            this.applyFullTextSearchUpdates(sqlStatements, entity, fields, result);
+        }
+        // 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);
+            }
+            catch (ex) {
+                logError('Error executing combined smart field SQL: ', ex);
+            }
+        }
+    }
+    /**
+     * Generate SQL UPDATEs for IsNameField on the identified name fields
+     */
+    applyNameFieldUpdates(sqlStatements, fields, result) {
         const nameFieldNames = result.nameFields ?? [];
         for (const nfName of nameFieldNames) {
-            const nameField = fields.find((f) => f.Name === nfName);
+            const nameField = fields.find(f => f.Name === nfName);
             if (nameField && nameField.AutoUpdateIsNameField && nameField.ID && !nameField.IsNameField) {
                 sqlStatements.push(`
                UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
@@ -3733,17 +3850,18 @@ export class ManageMetadataBase {
                 logError(`Smart field identification returned invalid nameField: '${nfName}' not found in entity fields`);
             }
         }
-        // Find all default in view fields (one or more)
+    }
+    /**
+     * Generate SQL UPDATEs for DefaultInView on the identified default view fields
+     */
+    applyDefaultInViewUpdates(sqlStatements, fields, result) {
         const defaultInViewFields = fields.filter(f => result.defaultInView.includes(f.Name) && f.AutoUpdateDefaultInView && f.ID);
-        // Warn about any fields that weren't found
         const missingFields = result.defaultInView.filter(name => !fields.some(f => f.Name === name));
         if (missingFields.length > 0) {
             logError(`Smart field identification returned invalid defaultInView fields: ${missingFields.join(', ')} not found in entity`);
         }
-        // Build update statements for all default in view fields
         for (const field of defaultInViewFields) {
             if (!field.DefaultInView) {
-                // only set these when DefaultInView not already on, otherwise wasteful
                 sqlStatements.push(`
                UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
                SET DefaultInView = 1
@@ -3752,35 +3870,112 @@ export class ManageMetadataBase {
             `);
             }
         }
-        // Find all searchable fields (one or more) - for IncludeInUserSearchAPI
-        if (result.searchableFields && result.searchableFields.length > 0) {
-            const searchableFields = fields.filter(f => result.searchableFields.includes(f.Name) && f.AutoUpdateIncludeInUserSearchAPI && f.ID);
-            // Warn about any fields that weren't found
-            const missingSearchableFields = result.searchableFields.filter(name => !fields.some(f => f.Name === name));
-            if (missingSearchableFields.length > 0) {
-                logError(`Smart field identification returned invalid searchableFields: ${missingSearchableFields.join(', ')} not found in entity`);
+    }
+    /**
+     * Generate SQL UPDATEs for IncludeInUserSearchAPI on the identified searchable fields
+     */
+    applySearchableFieldUpdates(sqlStatements, fields, result) {
+        if (!result.searchableFields || result.searchableFields.length === 0) {
+            return;
+        }
+        const searchableFields = fields.filter(f => result.searchableFields.includes(f.Name) && f.AutoUpdateIncludeInUserSearchAPI && f.ID);
+        const missingSearchableFields = result.searchableFields.filter(name => !fields.some(f => f.Name === name));
+        if (missingSearchableFields.length > 0) {
+            logError(`Smart field identification returned invalid searchableFields: ${missingSearchableFields.join(', ')} not found in entity`);
+        }
+        for (const field of searchableFields) {
+            if (!field.IncludeInUserSearchAPI) {
+                sqlStatements.push(`
+               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               SET IncludeInUserSearchAPI = 1
+               WHERE ID = '${field.ID}'
+               AND AutoUpdateIncludeInUserSearchAPI = 1
+            `);
             }
-            // Build update statements for all searchable fields
-            for (const field of searchableFields) {
-                if (!field.IncludeInUserSearchAPI) {
-                    // only set this if IncludeInUserSearchAPI isn't already set
-                    sqlStatements.push(`
-                  UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
-                  SET IncludeInUserSearchAPI = 1
-                  WHERE ID = '${field.ID}'
-                  AND AutoUpdateIncludeInUserSearchAPI = 1
-               `);
-                }
+        }
+    }
+    /**
+     * Generate SQL UPDATEs for UserSearchPredicateAPI on each searchable field
+     */
+    applySearchPredicateUpdates(sqlStatements, fields, result) {
+        if (!result.searchPredicates || result.searchPredicates.length === 0) {
+            return;
+        }
+        for (const sp of result.searchPredicates) {
+            const field = fields.find(f => f.Name === sp.field);
+            if (!field) {
+                logError(`Smart field identification returned invalid searchPredicate field: '${sp.field}' not found in entity fields`);
+                continue;
+            }
+            if (!field.AutoUpdateUserSearchPredicate || !field.ID) {
+                continue;
+            }
+            // Only update if the current value differs from the recommended predicate
+            if (field.UserSearchPredicateAPI !== sp.predicate) {
+                sqlStatements.push(`
+               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               SET UserSearchPredicateAPI = '${sp.predicate}'
+               WHERE ID = '${field.ID}'
+               AND AutoUpdateUserSearchPredicate = 1
+            `);
             }
         }
-        // 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);
+    }
+    /**
+     * Generate SQL UPDATEs for entity-level AllowUserSearchAPI
+     */
+    applyEntitySearchConfig(sqlStatements, entity, result) {
+        if (result.allowUserSearch == null || !entity.AutoUpdateAllowUserSearchAPI) {
+            return;
+        }
+        const newValue = result.allowUserSearch ? 1 : 0;
+        const currentValue = entity.AllowUserSearchAPI ? 1 : 0;
+        if (newValue !== currentValue) {
+            sqlStatements.push(`
+            UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+            SET AllowUserSearchAPI = ${newValue}
+            WHERE ID = '${entity.ID}'
+            AND AutoUpdateAllowUserSearchAPI = 1
+         `);
+        }
+    }
+    /**
+     * Generate SQL UPDATEs for entity-level and field-level FullTextSearch configuration
+     */
+    applyFullTextSearchUpdates(sqlStatements, entity, fields, result) {
+        // Entity-level FullTextSearchEnabled
+        if (result.enableFullTextSearch != null && entity.AutoUpdateFullTextSearch) {
+            const newValue = result.enableFullTextSearch ? 1 : 0;
+            const currentValue = entity.FullTextSearchEnabled ? 1 : 0;
+            if (newValue !== currentValue) {
+                sqlStatements.push(`
+               UPDATE ${this.qs(mj_core_schema(), 'Entity')}
+               SET FullTextSearchEnabled = ${newValue}
+               WHERE ID = '${entity.ID}'
+               AND AutoUpdateFullTextSearch = 1
+            `);
             }
-            catch (ex) {
-                logError('Error executing combined smart field SQL: ', ex);
+        }
+        // Field-level FullTextSearchEnabled
+        if (!result.fullTextSearchFields || result.fullTextSearchFields.length === 0) {
+            return;
+        }
+        for (const ftsFieldName of result.fullTextSearchFields) {
+            const field = fields.find(f => f.Name === ftsFieldName);
+            if (!field) {
+                logError(`Smart field identification returned invalid fullTextSearchField: '${ftsFieldName}' not found in entity fields`);
+                continue;
+            }
+            if (!field.AutoUpdateFullTextSearch || !field.ID) {
+                continue;
+            }
+            if (!field.FullTextSearchEnabled) {
+                sqlStatements.push(`
+               UPDATE ${this.qs(mj_core_schema(), 'EntityField')}
+               SET FullTextSearchEnabled = 1
+               WHERE ID = '${field.ID}'
+               AND AutoUpdateFullTextSearch = 1
+            `);
             }
         }
     }
@@ -3796,6 +3991,8 @@ export class ManageMetadataBase {
     async applyFormLayout(pool, entity, fields, result, isNewEntity = false) {
         const existingCategories = this.buildExistingCategorySet(fields);
         await this.applyFieldCategories(pool, entity, fields, result.fieldCategories, existingCategories);
+        // Auto-detect geo-capable entities and set SupportsGeoCoding
+        await this.detectAndSetGeoCodingSupport(pool, entity, result.fieldCategories);
         if (result.entityIcon) {
             await this.applyEntityIcon(pool, entity.ID, result.entityIcon);
         }
@@ -3810,6 +4007,52 @@ export class ManageMetadataBase {
             await this.applyEntityImportance(pool, entity.ID, result.entityImportance);
         }
     }
+    /**
+     * Detect if an entity has geo-capable fields based on LLM-assigned ExtendedType values.
+     * If any field has a Geo* ExtendedType, set Entity.SupportsGeoCoding = 1.
+     * Respects the AutoUpdateSupportsGeoCoding flag — if 0, the value is locked.
+     */
+    async detectAndSetGeoCodingSupport(pool, entity, fieldCategories) {
+        const schema = mj_core_schema();
+        // Check if the entity's AutoUpdateSupportsGeoCoding flag allows us to modify it
+        const autoUpdateResult = await pool.query(`
+         SELECT ${this.qi('AutoUpdateSupportsGeoCoding')}, ${this.qi('SupportsGeoCoding')}
+         FROM ${this.qs(schema, 'Entity')}
+         WHERE ${this.qi('ID')} = '${entity.ID}'
+      `);
+        const row = autoUpdateResult?.recordset?.[0];
+        if (!row || !row.AutoUpdateSupportsGeoCoding) {
+            return; // Flag is locked, don't modify
+        }
+        // Detect geo-capable fields from the LLM results
+        const geoExtendedTypes = new Set([
+            'Geo', 'GeoLatitude', 'GeoLongitude', 'GeoCountry', 'GeoStateProvince',
+            'GeoCity', 'GeoPostalCode', 'GeoAddress'
+        ]);
+        const hasGeoFields = fieldCategories.some(fc => fc.extendedType != null && geoExtendedTypes.has(fc.extendedType));
+        // Also check existing fields in the database for Geo* ExtendedTypes
+        // (in case the LLM didn't re-assign them this run but they were previously set)
+        const existingGeoResult = await pool.query(`
+         SELECT COUNT(*) AS ${this.qi('GeoFieldCount')}
+         FROM ${this.qs(schema, 'EntityField')}
+         WHERE ${this.qi('EntityID')} = '${entity.ID}'
+           AND ${this.qi('ExtendedType')} IN ('Geo', 'GeoLatitude', 'GeoLongitude', 'GeoCountry', 'GeoStateProvince', 'GeoCity', 'GeoPostalCode', 'GeoAddress')
+      `);
+        const existingGeoCount = existingGeoResult?.recordset?.[0]?.GeoFieldCount ?? 0;
+        const shouldSupportGeo = hasGeoFields || existingGeoCount > 0;
+        const currentValue = row.SupportsGeoCoding ? true : false;
+        if (shouldSupportGeo !== currentValue) {
+            await this.LogSQLAndExecute(pool, `
+            UPDATE ${this.qs(schema, 'Entity')}
+            SET ${this.qi('SupportsGeoCoding')} = ${shouldSupportGeo ? 1 : 0}
+            WHERE ${this.qi('ID')} = '${entity.ID}' AND ${this.qi('AutoUpdateSupportsGeoCoding')} = 1
+         `, `Set SupportsGeoCoding = ${shouldSupportGeo ? 1 : 0} for ${entity.Name}`);
+            logStatus(`  Entity ${entity.Name}: SupportsGeoCoding = ${shouldSupportGeo ? 1 : 0} (auto-detected from ${hasGeoFields ? 'LLM' : 'existing'} geo fields)`);
+            // Queue for late-phase view regeneration — the view was already generated
+            // before this flag was set, so it needs to be regenerated with the geo JOIN
+            ManageMetadataBase.AddEntityRequiringViewRegen(entity.Name, 'Geocoding');
+        }
+    }
     // ─────────────────────────────────────────────────────────────────
     // Shared category / icon / settings persistence methods
     // Used by both the regular entity pipeline and VE decoration pipeline