@solidxai/core 0.1.11-beta.0 → 0.1.11-beta.2

package/dist/seeders/module-metadata-seeder.service.js

@@ -84,6 +84,7 @@ const saved_filters_repository_1 = require("../repository/saved-filters.reposito
 const scheduled_job_repository_1 = require("../repository/scheduled-job.repository");
 const setting_repository_1 = require("../repository/setting.repository");
 const model_sequence_repository_1 = require("../repository/model-sequence.repository");
+const locale_repository_1 = require("../repository/locale.repository");
 const model_sequence_entity_1 = require("../entities/model-sequence.entity");
 const saved_filters_entity_1 = require("../entities/saved-filters.entity");
 const scheduled_job_entity_1 = require("../entities/scheduled-job.entity");
@@ -94,7 +95,7 @@ const model_metadata_entity_1 = require("../entities/model-metadata.entity");
 const permission_metadata_entity_1 = require("../entities/permission-metadata.entity");
 const view_metadata_entity_1 = require("../entities/view-metadata.entity");
 let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMetadataSeederService {
-    constructor(moduleMetadataService, modelMetadataService, fieldMetadataService, mediaStorageProviderMetadataService, roleService, userService, authenticationService, solidActionService, solidViewService, emailTemplateService, smsTemplateService, listOfValuesService, permissionRepo, solidRegistry, settingService, settingsRepo, securityRuleRepo, systemFieldsSeederService, scheduledJobRepository, savedFiltersRepo, dataSource, modelSequenceRepo) {
+    constructor(moduleMetadataService, modelMetadataService, fieldMetadataService, mediaStorageProviderMetadataService, roleService, userService, authenticationService, solidActionService, solidViewService, emailTemplateService, smsTemplateService, listOfValuesService, permissionRepo, solidRegistry, settingService, settingsRepo, securityRuleRepo, systemFieldsSeederService, scheduledJobRepository, savedFiltersRepo, dataSource, modelSequenceRepo, localeRepo) {
         this.moduleMetadataService = moduleMetadataService;
         this.modelMetadataService = modelMetadataService;
         this.fieldMetadataService = fieldMetadataService;
@@ -117,7 +118,16 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
         this.savedFiltersRepo = savedFiltersRepo;
         this.dataSource = dataSource;
         this.modelSequenceRepo = modelSequenceRepo;
+        this.localeRepo = localeRepo;
         this.logger = new common_1.Logger(ModuleMetadataSeederService_1.name);
+        this.seedTimingTag = 'SEED_TIMING';
+        this.permissionSeedBatchSize = 500;
+        this.viewComparableFields = ['name', 'displayName', 'type', 'context', 'layout', 'module', 'model'];
+        this.actionComparableFields = ['name', 'displayName', 'type', 'domain', 'context', 'customComponent', 'customIsModal', 'serverEndpoint', 'module', 'model', 'view'];
+        this.moduleLookupCache = new Map();
+        this.modelLookupCache = new Map();
+        this.viewLookupCache = new Map();
+        this.mediaStorageProviderLookupCache = new Map();
         this.enablePruning = false;
     }
     async seed(conf) {
@@ -127,105 +137,114 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
         const shouldSeedGlobalMetadata = conf?.seedGlobalMetadata !== false;
         try {
             this.enablePruning = Boolean(conf?.pruneMetadata);
+            this.resetLookupCaches();
             console.log(this.enablePruning ? '▶ Pruning enabled: metadata not present in JSON will be removed.' : '▶ Pruning disabled: existing metadata will be kept.');
-            if (shouldSeedGlobalMetadata) {
-                currentStep = 'seedGlobalMetadata';
-                await this.seedGlobalMetadata();
-            }
-            else {
-                this.logger.log(`Skipping global metadata seeding.`);
-            }
-            const seedDataFiles = this.seedDataFiles;
-            this.logger.debug(`Found seed data for modules: ${seedDataFiles.map(s => s.moduleMetadata?.name)}`);
-            currentStep = 'resolveModulesToSeed';
-            if (conf && Array.isArray(conf.modulesToSeed)) {
-                modulesToSeed = conf.modulesToSeed;
-                console.log(`▶ Selective seeding enabled. Modules to seed: ${modulesToSeed.join(', ')}`);
-                this.logger.log(`Selective seeding enabled. Modules to seed: ${modulesToSeed.join(', ')}`);
-            }
-            else {
-                console.log(`▶ No modulesToSeed provided. Seeding ALL modules.`);
-                this.logger.log(`No modulesToSeed provided. Seeding ALL modules.`);
-            }
-            const filteredSeedDataFiles = modulesToSeed ? seedDataFiles.filter((file) => modulesToSeed.includes(file.moduleMetadata?.name)) : seedDataFiles;
-            if (filteredSeedDataFiles.length === 0) {
-                this.logger.warn(`No modules matched the provided modulesToSeed list.`);
-                return;
-            }
-            for (let i = 0; i < filteredSeedDataFiles.length; i++) {
-                const overallMetadata = filteredSeedDataFiles[i];
-                const moduleMetadata = overallMetadata.moduleMetadata;
-                currentModule = moduleMetadata?.name ?? 'unknown';
-                if (!moduleMetadata?.name) {
-                    this.logger.warn(`Skipping seed metadata file because moduleMetadata.name is missing.`);
-                    continue;
+            await this.timeOperation('seed-run', async () => {
+                if (shouldSeedGlobalMetadata) {
+                    currentStep = 'seedGlobalMetadata';
+                    await this.timeOperation('global-seed', () => this.seedGlobalMetadata(), { moduleName: 'global', component: 'global-metadata' });
                 }
-                console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
-                this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
-                currentStep = 'seedMediaStorageProviders';
-                this.logger.log(`Seeding Media Storage Providers`);
-                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
-                currentStep = 'seedModuleModelFields';
-                this.logger.log(`Seeding Module / Model / Fields`);
-                const moduleModelFieldCounts = await this.seedModuleModelFields(moduleMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
-                currentStep = 'seedPermissions';
-                this.logger.log(`Seeding Permissions`);
-                const permissionCounts = await this.seedPermissions(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Permissions', permissionCounts)}`);
-                currentStep = 'seedRoles';
-                this.logger.log(`Seeding Roles`);
-                const roleCounts = await this.seedRoles(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Roles', roleCounts)}`);
-                currentStep = 'seedUsers';
-                this.logger.log(`Seeding Users`);
-                const userCounts = await this.seedUsers(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Users', userCounts)}`);
-                currentStep = 'seedViews';
-                this.logger.log(`Seeding Views`);
-                const viewCounts = await this.seedViews(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Views', viewCounts)}`);
-                currentStep = 'seedActions';
-                this.logger.log(`Seeding Actions`);
-                const actionCounts = await this.seedActions(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Actions', actionCounts)}`);
-                currentStep = 'seedMenus';
-                this.logger.log(`Seeding Menus`);
-                const menuCounts = await this.seedMenus(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Menus', menuCounts)}`);
-                currentStep = 'seedEmailTemplates';
-                this.logger.log(`Seeding Email Templates`);
-                const emailTemplateCounts = await this.seedEmailTemplates(overallMetadata, moduleMetadata.name);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Email Templates', emailTemplateCounts)}`);
-                currentStep = 'seedSmsTemplates';
-                this.logger.log(`Seeding Sms Templates`);
-                const smsTemplateCounts = await this.seedSmsTemplates(overallMetadata, moduleMetadata.name);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Sms Templates', smsTemplateCounts)}`);
-                currentStep = 'seedSecurityRules';
-                this.logger.log(`Seeding Security Rules`);
-                const securityRuleCounts = await this.seedSecurityRules(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Security Rules', securityRuleCounts)}`);
-                currentStep = 'seedListOfValues';
-                this.logger.log(`Seeding List Of Values`);
-                const lovCounts = await this.seedListOfValues(moduleMetadata, overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'List Of Values', lovCounts)}`);
-                currentStep = 'seedScheduledJobs';
-                this.logger.log(`Seeding Scheduled Jobs`);
-                const scheduledJobCounts = await this.seedScheduledJobs(moduleMetadata, overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Scheduled Jobs', scheduledJobCounts)}`);
-                currentStep = 'seedSavedFilters';
-                this.logger.log(`Seeding Saved Filters`);
-                const savedFilterCounts = await this.seedSavedFilters(moduleMetadata, overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Saved Filters', savedFilterCounts)}`);
-                currentStep = 'seedModelSequences';
-                this.logger.log(`Seeding Model Sequences`);
-                const modelSequenceCounts = await this.seedModelSequences(overallMetadata);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Model Sequences', modelSequenceCounts)}`);
-            }
-            currentModule = 'global';
-            currentStep = 'setupDefaultRolesWithPermissions';
-            await this.setupDefaultRolesWithPermissions();
+                else {
+                    this.logger.log(`Skipping global metadata seeding.`);
+                }
+                const seedDataFiles = this.seedDataFiles;
+                this.logger.debug(`Found seed data for modules: ${seedDataFiles.map(s => s.moduleMetadata?.name)}`);
+                currentStep = 'resolveModulesToSeed';
+                if (conf && Array.isArray(conf.modulesToSeed)) {
+                    modulesToSeed = conf.modulesToSeed;
+                    console.log(`▶ Selective seeding enabled. Modules to seed: ${modulesToSeed.join(', ')}`);
+                    this.logger.log(`Selective seeding enabled. Modules to seed: ${modulesToSeed.join(', ')}`);
+                }
+                else {
+                    console.log(`▶ No modulesToSeed provided. Seeding ALL modules.`);
+                    this.logger.log(`No modulesToSeed provided. Seeding ALL modules.`);
+                }
+                const filteredSeedDataFiles = modulesToSeed ? seedDataFiles.filter((file) => modulesToSeed.includes(file.moduleMetadata?.name)) : seedDataFiles;
+                if (filteredSeedDataFiles.length === 0) {
+                    this.logger.warn(`No modules matched the provided modulesToSeed list.`);
+                    return;
+                }
+                for (let i = 0; i < filteredSeedDataFiles.length; i++) {
+                    const overallMetadata = filteredSeedDataFiles[i];
+                    const moduleMetadata = overallMetadata.moduleMetadata;
+                    currentModule = moduleMetadata?.name ?? 'unknown';
+                    if (!moduleMetadata?.name) {
+                        this.logger.warn(`Skipping seed metadata file because moduleMetadata.name is missing.`);
+                        continue;
+                    }
+                    console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
+                    this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
+                    await this.timeOperation('module-total', async () => {
+                        currentStep = 'seedMediaStorageProviders';
+                        this.logger.log(`Seeding Media Storage Providers`);
+                        const mediaStorageCounts = await this.timeOperation('seed-media-storage-providers', () => this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders), { moduleName: moduleMetadata.name, component: 'media-storage-providers' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
+                        currentStep = 'seedModuleModelFields';
+                        this.logger.log(`Seeding Module / Model / Fields`);
+                        const moduleModelFieldCounts = await this.timeOperation('seed-module-model-fields', () => this.seedModuleModelFields(moduleMetadata), { moduleName: moduleMetadata.name, component: 'module-model-fields' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
+                        currentStep = 'seedLocales';
+                        this.logger.log(`Seeding Locales`);
+                        const localeCounts = await this.seedLocales(overallMetadata);
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Locales', localeCounts)}`);
+                        currentStep = 'seedPermissions';
+                        this.logger.log(`Seeding Permissions`);
+                        const permissionCounts = await this.timeOperation('seed-permissions', () => this.seedPermissions(overallMetadata), { moduleName: moduleMetadata.name, component: 'permissions' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Permissions', permissionCounts)}`);
+                        currentStep = 'seedRoles';
+                        this.logger.log(`Seeding Roles`);
+                        const roleCounts = await this.timeOperation('seed-roles', () => this.seedRoles(overallMetadata), { moduleName: moduleMetadata.name, component: 'roles' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Roles', roleCounts)}`);
+                        currentStep = 'seedUsers';
+                        this.logger.log(`Seeding Users`);
+                        const userCounts = await this.timeOperation('seed-users', () => this.seedUsers(overallMetadata), { moduleName: moduleMetadata.name, component: 'users' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Users', userCounts)}`);
+                        currentStep = 'seedViews';
+                        this.logger.log(`Seeding Views`);
+                        const viewCounts = await this.timeOperation('seed-views', () => this.seedViews(overallMetadata), { moduleName: moduleMetadata.name, component: 'views' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Views', viewCounts)}`);
+                        currentStep = 'seedActions';
+                        this.logger.log(`Seeding Actions`);
+                        const actionCounts = await this.timeOperation('seed-actions', () => this.seedActions(overallMetadata), { moduleName: moduleMetadata.name, component: 'actions' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Actions', actionCounts)}`);
+                        currentStep = 'seedMenus';
+                        this.logger.log(`Seeding Menus`);
+                        const menuCounts = await this.timeOperation('seed-menus', () => this.seedMenus(overallMetadata), { moduleName: moduleMetadata.name, component: 'menus' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Menus', menuCounts)}`);
+                        currentStep = 'seedEmailTemplates';
+                        this.logger.log(`Seeding Email Templates`);
+                        const emailTemplateCounts = await this.timeOperation('seed-email-templates', () => this.seedEmailTemplates(overallMetadata, moduleMetadata.name), { moduleName: moduleMetadata.name, component: 'email-templates' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Email Templates', emailTemplateCounts)}`);
+                        currentStep = 'seedSmsTemplates';
+                        this.logger.log(`Seeding Sms Templates`);
+                        const smsTemplateCounts = await this.timeOperation('seed-sms-templates', () => this.seedSmsTemplates(overallMetadata, moduleMetadata.name), { moduleName: moduleMetadata.name, component: 'sms-templates' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Sms Templates', smsTemplateCounts)}`);
+                        currentStep = 'seedSecurityRules';
+                        this.logger.log(`Seeding Security Rules`);
+                        const securityRuleCounts = await this.timeOperation('seed-security-rules', () => this.seedSecurityRules(overallMetadata), { moduleName: moduleMetadata.name, component: 'security-rules' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Security Rules', securityRuleCounts)}`);
+                        currentStep = 'seedListOfValues';
+                        this.logger.log(`Seeding List Of Values`);
+                        const lovCounts = await this.timeOperation('seed-list-of-values', () => this.seedListOfValues(moduleMetadata, overallMetadata), { moduleName: moduleMetadata.name, component: 'list-of-values' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'List Of Values', lovCounts)}`);
+                        currentStep = 'seedScheduledJobs';
+                        this.logger.log(`Seeding Scheduled Jobs`);
+                        const scheduledJobCounts = await this.timeOperation('seed-scheduled-jobs', () => this.seedScheduledJobs(moduleMetadata, overallMetadata), { moduleName: moduleMetadata.name, component: 'scheduled-jobs' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Scheduled Jobs', scheduledJobCounts)}`);
+                        currentStep = 'seedSavedFilters';
+                        this.logger.log(`Seeding Saved Filters`);
+                        const savedFilterCounts = await this.timeOperation('seed-saved-filters', () => this.seedSavedFilters(moduleMetadata, overallMetadata), { moduleName: moduleMetadata.name, component: 'saved-filters' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Saved Filters', savedFilterCounts)}`);
+                        currentStep = 'seedModelSequences';
+                        this.logger.log(`Seeding Model Sequences`);
+                        const modelSequenceCounts = await this.timeOperation('seed-model-sequences', () => this.seedModelSequences(overallMetadata), { moduleName: moduleMetadata.name, component: 'model-sequences' });
+                        console.log(`${this.formatSeedResult(moduleMetadata.name, 'Model Sequences', modelSequenceCounts)}`);
+                    }, { moduleName: moduleMetadata.name, component: 'module-seed' });
+                }
+                currentModule = 'global';
+                currentStep = 'setupDefaultRolesWithPermissions';
+                await this.timeOperation('setup-default-roles-with-permissions', () => this.setupDefaultRolesWithPermissions(), { moduleName: 'global', component: 'default-roles' });
+            }, { moduleName: 'global', component: 'seed-run' });
             console.log(`✔ Seeding completed.`);
         }
         catch (error) {
@@ -238,117 +257,303 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             throw error;
         }
     }
+    buildTimingPrefix(itemTag, options) {
+        const parts = [`[${this.seedTimingTag}]`, `[ITEM:${itemTag}]`];
+        if (options?.moduleName) {
+            parts.push(`[MODULE:${options.moduleName}]`);
+        }
+        if (options?.component) {
+            parts.push(`[COMPONENT:${options.component}]`);
+        }
+        if (options?.serviceCall) {
+            parts.push(`[CALL:${options.serviceCall}]`);
+        }
+        return parts.join(' ');
+    }
+    formatDuration(durationMs) {
+        return durationMs >= 1000
+            ? `${(durationMs / 1000).toFixed(2)} s (${durationMs.toFixed(2)} ms)`
+            : `${durationMs.toFixed(2)} ms`;
+    }
+    resetLookupCaches() {
+        this.moduleLookupCache.clear();
+        this.modelLookupCache.clear();
+        this.viewLookupCache.clear();
+        this.mediaStorageProviderLookupCache.clear();
+    }
+    async getModuleByUserKeyCached(moduleUserKey, options) {
+        if (!moduleUserKey) {
+            return null;
+        }
+        if (this.moduleLookupCache.has(moduleUserKey)) {
+            return this.moduleLookupCache.get(moduleUserKey) ?? null;
+        }
+        const module = await this.timeOperation('module-find-by-user-key-cache-miss', () => this.moduleMetadataService.findOneByUserKey(moduleUserKey), {
+            moduleName: options?.moduleName ?? moduleUserKey,
+            component: options?.component,
+            serviceCall: 'moduleMetadataService.findOneByUserKey',
+            details: options?.details ?? `module=${moduleUserKey}`,
+        });
+        this.moduleLookupCache.set(moduleUserKey, module ?? null);
+        return module ?? null;
+    }
+    async getModelByUserKeyCached(modelUserKey, options) {
+        if (!modelUserKey) {
+            return null;
+        }
+        if (this.modelLookupCache.has(modelUserKey)) {
+            return this.modelLookupCache.get(modelUserKey) ?? null;
+        }
+        const model = await this.timeOperation('model-find-by-user-key-cache-miss', () => this.modelMetadataService.findOneByUserKey(modelUserKey), {
+            moduleName: options?.moduleName,
+            component: options?.component,
+            serviceCall: 'modelMetadataService.findOneByUserKey',
+            details: options?.details ?? `model=${modelUserKey}`,
+        });
+        this.modelLookupCache.set(modelUserKey, model ?? null);
+        return model ?? null;
+    }
+    async getViewByUserKeyCached(viewUserKey, options) {
+        if (!viewUserKey) {
+            return null;
+        }
+        if (this.viewLookupCache.has(viewUserKey)) {
+            return this.viewLookupCache.get(viewUserKey) ?? null;
+        }
+        const view = await this.timeOperation('view-find-by-user-key-cache-miss', () => this.solidViewService.findOneByUserKey(viewUserKey), {
+            moduleName: options?.moduleName,
+            component: options?.component,
+            serviceCall: 'solidViewService.findOneByUserKey',
+            details: options?.details ?? `view=${viewUserKey}`,
+        });
+        this.viewLookupCache.set(viewUserKey, view ?? null);
+        return view ?? null;
+    }
+    async getMediaStorageProviderByUserKeyCached(mediaStorageProviderUserKey, options) {
+        if (!mediaStorageProviderUserKey) {
+            return null;
+        }
+        if (this.mediaStorageProviderLookupCache.has(mediaStorageProviderUserKey)) {
+            return this.mediaStorageProviderLookupCache.get(mediaStorageProviderUserKey) ?? null;
+        }
+        const mediaStorageProvider = await this.timeOperation('media-storage-provider-find-by-user-key-cache-miss', () => this.mediaStorageProviderMetadataService.findOneByUserKey(mediaStorageProviderUserKey), {
+            moduleName: options?.moduleName,
+            component: options?.component,
+            serviceCall: 'mediaStorageProviderMetadataService.findOneByUserKey',
+            details: options?.details ?? `provider=${mediaStorageProviderUserKey}`,
+        });
+        this.mediaStorageProviderLookupCache.set(mediaStorageProviderUserKey, mediaStorageProvider ?? null);
+        return mediaStorageProvider ?? null;
+    }
+    async timeOperation(itemTag, operation, options) {
+        const prefix = this.buildTimingPrefix(itemTag, options);
+        const detailSuffix = options?.details ? ` ${options.details}` : '';
+        const start = process.hrtime.bigint();
+        try {
+            const result = await operation();
+            const durationMs = Number(process.hrtime.bigint() - start) / 1_000_000;
+            this.logger.debug(`${prefix} done in ${this.formatDuration(durationMs)}${detailSuffix}`);
+            return result;
+        }
+        catch (error) {
+            const durationMs = Number(process.hrtime.bigint() - start) / 1_000_000;
+            this.logger.debug(`${prefix} failed after ${this.formatDuration(durationMs)}${detailSuffix}`);
+            throw error;
+        }
+    }
     async seedScheduledJobs(moduleMetadata, overallMetadata) {
-        this.logger.debug(`[Start] Processing scheduled jobs for ${moduleMetadata.name}`);
         const scheduledJobs = this.getSeedArray(overallMetadata?.scheduledJobs);
-        const pruned = this.enablePruning ? await this.pruneScheduledJobs(scheduledJobs, moduleMetadata.name) : 0;
+        const pruned = this.enablePruning ? await this.timeOperation('prune-scheduled-jobs', () => this.pruneScheduledJobs(scheduledJobs, moduleMetadata.name), {
+            moduleName: moduleMetadata.name,
+            component: 'scheduled-jobs',
+            serviceCall: 'pruneScheduledJobs',
+        }) : 0;
         if (scheduledJobs.length > 0) {
-            await this.handleSeedScheduledJobs(scheduledJobs);
+            await this.timeOperation('handle-scheduled-jobs', () => this.handleSeedScheduledJobs(scheduledJobs), {
+                moduleName: moduleMetadata.name,
+                component: 'scheduled-jobs',
+                serviceCall: 'handleSeedScheduledJobs',
+            });
         }
-        this.logger.debug(`[End] Processing scheduled jobs for ${moduleMetadata.name}`);
         return { pruned, upserted: scheduledJobs.length };
     }
     async seedSavedFilters(moduleMetadata, overallMetadata) {
-        this.logger.debug(`[Start] Processing saved filters for ${moduleMetadata.name}`);
         const savedFilters = this.getSeedArray(overallMetadata?.savedFilters);
-        const pruned = this.enablePruning ? await this.pruneSavedFilters(savedFilters, moduleMetadata.name) : 0;
+        const pruned = this.enablePruning ? await this.timeOperation('prune-saved-filters', () => this.pruneSavedFilters(savedFilters, moduleMetadata.name), {
+            moduleName: moduleMetadata.name,
+            component: 'saved-filters',
+            serviceCall: 'pruneSavedFilters',
+        }) : 0;
         if (savedFilters.length > 0) {
-            await this.handleSeedSavedFilters(savedFilters);
+            await this.timeOperation('handle-saved-filters', () => this.handleSeedSavedFilters(savedFilters), {
+                moduleName: moduleMetadata.name,
+                component: 'saved-filters',
+                serviceCall: 'handleSeedSavedFilters',
+            });
         }
-        this.logger.debug(`[End] Processing saved filters for ${moduleMetadata.name}`);
         return { pruned, upserted: savedFilters.length };
     }
     async seedListOfValues(moduleMetadata, overallMetadata) {
-        this.logger.debug(`[Start] Processing List Of Values for ${moduleMetadata.name}`);
         const listOfValues = this.getSeedArray(overallMetadata?.listOfValues);
-        const pruned = this.enablePruning ? await this.pruneListOfValues(listOfValues, moduleMetadata.name) : 0;
-        await this.handleSeedListOfValues(listOfValues);
-        this.logger.debug(`[End] Processing List Of Values for ${moduleMetadata.name}`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-list-of-values', () => this.pruneListOfValues(listOfValues, moduleMetadata.name), {
+            moduleName: moduleMetadata.name,
+            component: 'list-of-values',
+            serviceCall: 'pruneListOfValues',
+        }) : 0;
+        await this.timeOperation('handle-list-of-values', () => this.handleSeedListOfValues(listOfValues), {
+            moduleName: moduleMetadata.name,
+            component: 'list-of-values',
+            serviceCall: 'handleSeedListOfValues',
+        });
         return { pruned, upserted: listOfValues.length };
     }
+    async seedLocales(overallMetadata) {
+        this.logger.debug(`[Start] Processing locales`);
+        const locales = this.getSeedArray(overallMetadata?.locales);
+        const existingLocales = await this.localeRepo.find();
+        if (existingLocales.length > 0) {
+            this.solidRegistry.registerlocales(existingLocales);
+            this.logger.debug(`[End] Skipping locale seed because locales already exist`);
+            return { pruned: 0, upserted: 0 };
+        }
+        await this.handleSeedLocales(locales);
+        this.logger.debug(`[End] Processing locales`);
+        return { pruned: 0, upserted: locales.length };
+    }
     async setupDefaultRolesWithPermissions() {
         this.logger.debug(`About to add all permissions to the Admin role`);
-        await this.roleService.addAllPermissionsToRole(create_role_metadata_dto_1.ADMIN_ROLE_NAME);
+        await this.timeOperation('role-add-all-permissions', () => this.roleService.addAllPermissionsToRole(create_role_metadata_dto_1.ADMIN_ROLE_NAME), {
+            moduleName: 'global',
+            component: 'default-roles',
+            serviceCall: 'roleService.addAllPermissionsToRole',
+            details: `role=${create_role_metadata_dto_1.ADMIN_ROLE_NAME}`,
+        });
     }
     async seedSecurityRules(overallMetadata) {
-        this.logger.debug(`[Start] Processing security rules`);
         const securityRules = this.getSeedArray(overallMetadata?.securityRules);
-        const pruned = this.enablePruning ? await this.pruneSecurityRules(securityRules, overallMetadata?.moduleMetadata?.name) : 0;
-        await this.handleSeedSecurityRules(securityRules);
-        this.logger.debug(`[End] Processing security rules`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-security-rules', () => this.pruneSecurityRules(securityRules, overallMetadata?.moduleMetadata?.name), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'security-rules',
+            serviceCall: 'pruneSecurityRules',
+        }) : 0;
+        await this.timeOperation('handle-security-rules', () => this.handleSeedSecurityRules(securityRules), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'security-rules',
+            serviceCall: 'handleSeedSecurityRules',
+        });
         return { pruned, upserted: securityRules.length };
     }
     async seedDefaultSettings() {
-        this.logger.debug(`[Start] Processing settings`);
-        await this.settingService.seedSystemAdminEditableAndAboveSettings();
-        this.logger.debug(`[End] Processing settings`);
+        await this.timeOperation('seed-default-settings-call', () => this.settingService.seedSystemAdminEditableAndAboveSettings(), {
+            moduleName: 'global',
+            component: 'settings',
+            serviceCall: 'settingService.seedSystemAdminEditableAndAboveSettings',
+        });
     }
     async seedSmsTemplates(overallMetadata, moduleName) {
-        this.logger.debug(`[Start] Processing sms templates`);
         const smsTemplates = this.getSeedArray(overallMetadata?.smsTemplates);
-        await this.handleSeedSmsTemplates(smsTemplates, moduleName);
-        this.logger.debug(`[End] Processing sms templates`);
+        await this.timeOperation('handle-sms-templates', () => this.handleSeedSmsTemplates(smsTemplates, moduleName), {
+            moduleName,
+            component: 'sms-templates',
+            serviceCall: 'handleSeedSmsTemplates',
+        });
         return { pruned: 0, upserted: smsTemplates.length };
     }
     async seedEmailTemplates(overallMetadata, moduleName) {
-        this.logger.debug(`[Start] Processing email templates`);
         const emailTemplates = this.getSeedArray(overallMetadata?.emailTemplates);
-        await this.handleSeedEmailTemplates(emailTemplates, moduleName);
-        this.logger.debug(`[End] Processing email templates`);
+        await this.timeOperation('handle-email-templates', () => this.handleSeedEmailTemplates(emailTemplates, moduleName), {
+            moduleName,
+            component: 'email-templates',
+            serviceCall: 'handleSeedEmailTemplates',
+        });
         return { pruned: 0, upserted: emailTemplates.length };
     }
     async seedMenus(overallMetadata) {
-        this.logger.debug(`[Start] Processing menus`);
         const menus = this.getSeedArray(overallMetadata?.menus);
-        const pruned = this.enablePruning ? await this.pruneMenus(menus, overallMetadata?.moduleMetadata?.name) : 0;
-        await this.handleSeedMenus(menus);
-        this.logger.debug(`[End] Processing menus`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-menus', () => this.pruneMenus(menus, overallMetadata?.moduleMetadata?.name), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'menus',
+            serviceCall: 'pruneMenus',
+        }) : 0;
+        await this.timeOperation('handle-menus', () => this.handleSeedMenus(menus), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'menus',
+            serviceCall: 'handleSeedMenus',
+        });
         return { pruned, upserted: menus.length };
     }
     async seedActions(overallMetadata) {
-        this.logger.debug(`[Start] Processing actions`);
         const actions = this.getSeedArray(overallMetadata?.actions);
-        const pruned = this.enablePruning ? await this.pruneActions(actions, overallMetadata?.moduleMetadata?.name) : 0;
-        await this.handleSeedActions(actions);
-        this.logger.debug(`[End] Processing actions`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-actions', () => this.pruneActions(actions, overallMetadata?.moduleMetadata?.name), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'actions',
+            serviceCall: 'pruneActions',
+        }) : 0;
+        await this.timeOperation('handle-actions', () => this.handleSeedActions(actions), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'actions',
+            serviceCall: 'handleSeedActions',
+        });
         return { pruned, upserted: actions.length };
     }
     async seedViews(overallMetadata) {
-        this.logger.debug(`[Start] Processing views`);
         const views = this.getSeedArray(overallMetadata?.views);
-        const pruned = this.enablePruning ? await this.pruneViews(views, overallMetadata?.moduleMetadata?.name) : 0;
-        await this.handleSeedViews(views);
-        this.logger.debug(`[End] Processing views`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-views', () => this.pruneViews(views, overallMetadata?.moduleMetadata?.name), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'views',
+            serviceCall: 'pruneViews',
+        }) : 0;
+        await this.timeOperation('handle-views', () => this.handleSeedViews(views), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'views',
+            serviceCall: 'handleSeedViews',
+        });
         return { pruned, upserted: views.length };
     }
     async seedUsers(overallMetadata) {
-        this.logger.debug(`[Start] Processing users`);
         const users = this.getSeedArray(overallMetadata?.users);
-        await this.handleSeedUsers(users);
-        this.logger.debug(`[End] Processing users`);
+        await this.timeOperation('handle-users', () => this.handleSeedUsers(users), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'users',
+            serviceCall: 'handleSeedUsers',
+        });
         return { pruned: 0, upserted: users.length };
     }
     async seedRoles(overallMetadata) {
-        this.logger.debug(`[Start] Processing roles`);
         const roles = this.getSeedArray(overallMetadata?.roles);
-        await this.roleService.createRolesIfNotExists(roles
+        await this.timeOperation('roles-create-if-not-exists', () => this.roleService.createRolesIfNotExists(roles
             .filter((role) => role?.name)
-            .map((role) => ({ name: role.name })));
+            .map((role) => ({
+            name: role.name,
+            moduleId: role.moduleId,
+            moduleUserKey: role.moduleUserKey ?? overallMetadata?.moduleMetadata?.name,
+        }))), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'roles',
+            serviceCall: 'roleService.createRolesIfNotExists',
+            details: `roleCount=${roles.length}`,
+        });
         for (const role of roles) {
             if (role.permissions) {
-                await this.roleService.addPermissionsToRole(role.name, role.permissions
+                await this.timeOperation('role-add-permissions', () => this.roleService.addPermissionsToRole(role.name, role.permissions
                     .map((permission) => typeof permission === 'string' ? permission : permission?.name)
-                    .filter(Boolean));
+                    .filter(Boolean)), {
+                    moduleName: overallMetadata?.moduleMetadata?.name,
+                    component: 'roles',
+                    serviceCall: 'roleService.addPermissionsToRole',
+                    details: `role=${role.name} permissionCount=${role.permissions.length}`,
+                });
             }
         }
-        this.logger.debug(`[End] Processing roles`);
         return { pruned: 0, upserted: roles.length };
     }
     async seedPermissions(overallMetadata) {
-        this.logger.debug(`[Start] Processing permissions`);
         const permissions = overallMetadata.permissions ?? [];
-        await this.handleSeedPermissions(permissions);
-        this.logger.debug(`[End] Processing permissions`);
+        await this.timeOperation('handle-permissions', () => this.handleSeedPermissions(permissions), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'permissions',
+            serviceCall: 'handleSeedPermissions',
+        });
         return { pruned: 0, upserted: permissions?.length ?? 0 };
     }
     get seedDataFiles() {
@@ -367,15 +572,28 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
     }
     async seedGlobalMetadata() {
         this.logger.log(`Seeding Permissions`);
-        await this.seedControllerPermissions();
+        await this.timeOperation('seed-controller-permissions', () => this.seedControllerPermissions(), {
+            moduleName: 'global',
+            component: 'controller-permissions',
+        });
         this.logger.log(`Seeding System Fields Metadata`);
-        await this.seedDefaultSystemFields();
+        await this.timeOperation('seed-default-system-fields', () => this.seedDefaultSystemFields(), {
+            moduleName: 'global',
+            component: 'system-fields',
+        });
         this.logger.log(`Seeding Default Settings`);
-        await this.seedDefaultSettings();
+        await this.timeOperation('seed-default-settings', () => this.seedDefaultSettings(), {
+            moduleName: 'global',
+            component: 'settings',
+        });
         this.logger.debug(`Global metadata seeding completed`);
     }
     async seedDefaultSystemFields() {
-        await this.systemFieldsSeederService.seed();
+        await this.timeOperation('system-fields-seed', () => this.systemFieldsSeederService.seed(), {
+            moduleName: 'global',
+            component: 'system-fields',
+            serviceCall: 'systemFieldsSeederService.seed',
+        });
     }
     async seedControllerPermissions() {
         const controllers = this.solidRegistry.getControllers();
@@ -388,55 +606,112 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
                     const methodName = methods[mId];
                     const permissionName = `${controller.name}.${methodName}`;
                     permissionNames.push(permissionName);
-                    await this.createPermissionIfNotExists(permissionName);
                 }
             }
             catch (error) {
                 this.logger.error(error);
             }
         }
+        await this.timeOperation('seed-controller-permissions-bulk', () => this.seedPermissionsInBatches(permissionNames, {
+            moduleName: 'global',
+            component: 'controller-permissions',
+        }), {
+            moduleName: 'global',
+            component: 'controller-permissions',
+            serviceCall: 'seedPermissionsInBatches',
+            details: `permissionCount=${permissionNames.length} batchSize=${this.permissionSeedBatchSize}`,
+        });
         if (this.enablePruning) {
-            await this.prunePermissions(permissionNames);
+            await this.timeOperation('prune-controller-permissions', () => this.prunePermissions(permissionNames), {
+                moduleName: 'global',
+                component: 'controller-permissions',
+                serviceCall: 'prunePermissions',
+            });
         }
     }
-    async createPermissionIfNotExists(permissionName) {
-        const existingPermission = await this.permissionRepo.findOne({
-            where: {
-                name: permissionName
-            }
+    async handleSeedPermissions(permissions) {
+        const permissionNames = permissions
+            .map((permission) => typeof permission === 'string' ? permission : permission?.name)
+            .filter(Boolean);
+        await this.seedPermissionsInBatches(permissionNames, {
+            component: 'permissions',
         });
-        if (!existingPermission) {
-            this.logger.log(`Permission ${permissionName} does not exist, creating new.`);
-            const newPermission = this.permissionRepo.create({
-                name: permissionName
+    }
+    async seedPermissionsInBatches(permissionNames, options) {
+        const uniquePermissionNames = this.getUniquePermissionNames(permissionNames);
+        if (uniquePermissionNames.length === 0) {
+            return;
+        }
+        for (let index = 0; index < uniquePermissionNames.length; index += this.permissionSeedBatchSize) {
+            const batch = uniquePermissionNames.slice(index, index + this.permissionSeedBatchSize);
+            const batchNumber = Math.floor(index / this.permissionSeedBatchSize) + 1;
+            const existingPermissions = await this.timeOperation('permission-batch-find', () => this.permissionRepo.find({
+                where: {
+                    name: (0, typeorm_1.In)(batch),
+                }
+            }), {
+                moduleName: options?.moduleName,
+                component: options?.component ?? 'permissions',
+                serviceCall: 'permissionRepo.find',
+                details: `batch=${batchNumber} batchSize=${batch.length}`,
+            });
+            const existingPermissionNames = new Set(existingPermissions.map((permission) => this.normalizePermissionName(permission.name)));
+            const missingPermissionNames = batch.filter((name) => !existingPermissionNames.has(this.normalizePermissionName(name)));
+            if (missingPermissionNames.length === 0) {
+                continue;
+            }
+            this.logger.log(`Creating ${missingPermissionNames.length} missing permissions in batch ${batchNumber}.`);
+            await this.timeOperation('permission-batch-save', () => this.permissionRepo.save(missingPermissionNames.map((name) => this.permissionRepo.create({ name }))), {
+                moduleName: options?.moduleName,
+                component: options?.component ?? 'permissions',
+                serviceCall: 'permissionRepo.save',
+                details: `batch=${batchNumber} createCount=${missingPermissionNames.length}`,
             });
-            await this.permissionRepo.save(newPermission);
         }
     }
-    async handleSeedPermissions(permissions) {
-        for (const permission of permissions) {
-            const permissionName = typeof permission === 'string' ? permission : permission?.name;
-            if (permissionName) {
-                await this.createPermissionIfNotExists(permissionName);
+    getUniquePermissionNames(permissionNames) {
+        const normalizedPermissionNames = new Set();
+        const uniquePermissionNames = [];
+        for (const permissionName of permissionNames) {
+            if (!permissionName) {
+                continue;
             }
+            const normalizedPermissionName = this.normalizePermissionName(permissionName);
+            if (normalizedPermissionNames.has(normalizedPermissionName)) {
+                continue;
+            }
+            normalizedPermissionNames.add(normalizedPermissionName);
+            uniquePermissionNames.push(permissionName.trim());
         }
+        return uniquePermissionNames;
+    }
+    normalizePermissionName(permissionName) {
+        return permissionName.trim().toLowerCase();
     }
     async seedMediaStorageProviders(mediaStorageProviders) {
-        this.logger.debug(`[Start] Processing Media Storage Provider`);
         const providers = this.getSeedArray(mediaStorageProviders);
         for (let i = 0; i < providers.length; i++) {
             const mediaStorageProvider = providers[i];
-            await this.mediaStorageProviderMetadataService.upsert(mediaStorageProvider);
+            await this.timeOperation('media-storage-provider-upsert', () => this.mediaStorageProviderMetadataService.upsert(mediaStorageProvider), {
+                component: 'media-storage-providers',
+                serviceCall: 'mediaStorageProviderMetadataService.upsert',
+                details: `provider=${mediaStorageProvider?.name ?? mediaStorageProvider?.userKey ?? i}`,
+            });
         }
-        this.logger.debug(`[End] Processing Media Storage Provider`);
         return { pruned: 0, upserted: providers.length };
     }
     async seedModelSequences(overallMetadata) {
-        this.logger.debug(`[Start] Processing model sequences`);
         const modelSequences = this.getSeedArray(overallMetadata?.modelSequences);
-        const pruned = this.enablePruning ? await this.pruneModelSequences(modelSequences, overallMetadata?.moduleMetadata?.name) : 0;
-        await this.handleSeedModelSequences(modelSequences);
-        this.logger.debug(`[End] Processing model sequences`);
+        const pruned = this.enablePruning ? await this.timeOperation('prune-model-sequences', () => this.pruneModelSequences(modelSequences, overallMetadata?.moduleMetadata?.name), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'model-sequences',
+            serviceCall: 'pruneModelSequences',
+        }) : 0;
+        await this.timeOperation('handle-model-sequences', () => this.handleSeedModelSequences(modelSequences), {
+            moduleName: overallMetadata?.moduleMetadata?.name,
+            component: 'model-sequences',
+            serviceCall: 'handleSeedModelSequences',
+        });
         return { pruned, upserted: modelSequences.length };
     }
     async handleSeedEmailTemplates(emailTemplates, moduleName) {
@@ -473,8 +748,18 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
                     emailTemplate.body = fs.readFileSync(fullPath, 'utf-8').toString();
                 }
             }
-            await this.emailTemplateService.removeByName(emailTemplate.name);
-            await this.emailTemplateService.create(emailTemplate);
+            await this.timeOperation('email-template-remove', () => this.emailTemplateService.removeByName(emailTemplate.name), {
+                moduleName,
+                component: 'email-templates',
+                serviceCall: 'emailTemplateService.removeByName',
+                details: `template=${emailTemplate.name}`,
+            });
+            await this.timeOperation('email-template-create', () => this.emailTemplateService.create(emailTemplate), {
+                moduleName,
+                component: 'email-templates',
+                serviceCall: 'emailTemplateService.create',
+                details: `template=${emailTemplate.name}`,
+            });
         }
     }
     async handleSeedSmsTemplates(smsTemplates, moduleName) {
@@ -511,32 +796,62 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
                     smsTemplate.body = fs.readFileSync(fullPath, 'utf-8').toString();
                 }
             }
-            await this.smsTemplateService.removeByName(smsTemplate.name);
-            await this.smsTemplateService.create(smsTemplate);
+            await this.timeOperation('sms-template-remove', () => this.smsTemplateService.removeByName(smsTemplate.name), {
+                moduleName,
+                component: 'sms-templates',
+                serviceCall: 'smsTemplateService.removeByName',
+                details: `template=${smsTemplate.name}`,
+            });
+            await this.timeOperation('sms-template-create', () => this.smsTemplateService.create(smsTemplate), {
+                moduleName,
+                component: 'sms-templates',
+                serviceCall: 'smsTemplateService.create',
+                details: `template=${smsTemplate.name}`,
+            });
         }
     }
     async handleSeedMenus(menus) {
         if (!menus) {
             return;
         }
-        await this.dataSource.transaction(async (trx) => {
+        await this.timeOperation('menus-transaction', () => this.dataSource.transaction(async (trx) => {
             const menuRepo = trx.getRepository(menu_item_metadata_entity_1.MenuItemMetadata);
             const roleRepo = trx.getRepository(role_metadata_entity_1.RoleMetadata);
             const actionRepo = trx.getRepository(action_metadata_entity_1.ActionMetadata);
             const moduleRepo = trx.getRepository(module_metadata_entity_1.ModuleMetadata);
             for (const m of menus) {
                 const action = m.actionUserKey
-                    ? await actionRepo.findOne({ where: { name: m.actionUserKey }, select: ["id"] })
+                    ? await this.timeOperation('menu-action-find-one', () => actionRepo.findOne({ where: { name: m.actionUserKey }, select: ["id"] }), {
+                        component: 'menus',
+                        serviceCall: 'actionRepo.findOne',
+                        details: `action=${m.actionUserKey}`,
+                    })
                     : null;
                 const module = m.moduleUserKey
-                    ? await moduleRepo.findOne({ where: { name: m.moduleUserKey }, select: ["id"] })
+                    ? await this.timeOperation('menu-module-find-one', () => moduleRepo.findOne({ where: { name: m.moduleUserKey }, select: ["id"] }), {
+                        component: 'menus',
+                        serviceCall: 'moduleRepo.findOne',
+                        details: `module=${m.moduleUserKey}`,
+                    })
                     : null;
                 const parentMenuItem = m.parentMenuItemUserKey
-                    ? await menuRepo.findOne({ where: { name: m.parentMenuItemUserKey }, select: ["id"] })
+                    ? await this.timeOperation('menu-parent-find-one', () => menuRepo.findOne({ where: { name: m.parentMenuItemUserKey }, select: ["id"] }), {
+                        component: 'menus',
+                        serviceCall: 'menuRepo.findOne',
+                        details: `parent=${m.parentMenuItemUserKey}`,
+                    })
                     : null;
-                const existing = await menuRepo.findOne({
+                const existing = await this.timeOperation('menu-existing-find-one', () => menuRepo.findOne({
                     where: { name: m.name },
-                    select: ["id"],
+                    relations: {
+                        action: true,
+                        module: true,
+                        parentMenuItem: true,
+                    },
+                }), {
+                    component: 'menus',
+                    serviceCall: 'menuRepo.findOne',
+                    details: `menu=${m.name}`,
                 });
                 const base = {
                     name: m.name,
@@ -547,23 +862,51 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
                     sequenceNumber: m.sequenceNumber,
                     iconName: m.iconName,
                 };
+                const hasChanges = existing
+                    ? existing.displayName !== base.displayName
+                        || existing.sequenceNumber !== base.sequenceNumber
+                        || existing.iconName !== base.iconName
+                        || existing.action?.id !== base.action?.id
+                        || existing.module?.id !== base.module?.id
+                        || existing.parentMenuItem?.id !== base.parentMenuItem?.id
+                    : true;
+                if (existing && !hasChanges) {
+                    this.logger.debug(`Skipping menu upsert for ${m.name}; no changes detected.`);
+                    continue;
+                }
                 const entity = menuRepo.create(existing ? { id: existing.id, ...base } : base);
-                await menuRepo.save(entity);
+                await this.timeOperation('menu-save', () => menuRepo.save(entity), {
+                    component: 'menus',
+                    serviceCall: 'menuRepo.save',
+                    details: `menu=${m.name}`,
+                });
             }
-            const seeded = await menuRepo.find({
+            const seeded = await this.timeOperation('menu-seeded-find', () => menuRepo.find({
                 where: { name: (0, typeorm_1.In)(menus.map((m) => m.name)) },
                 select: ["id", "name"],
+            }), {
+                component: 'menus',
+                serviceCall: 'menuRepo.find',
+                details: `count=${menus.length}`,
             });
             const idByName = new Map(seeded.map(s => [s.name, s.id]));
-            const admin = await roleRepo.findOne({ where: { name: create_role_metadata_dto_1.ADMIN_ROLE_NAME }, select: ["id", "name"] });
+            const admin = await this.timeOperation('menu-admin-role-find-one', () => roleRepo.findOne({ where: { name: create_role_metadata_dto_1.ADMIN_ROLE_NAME }, select: ["id", "name"] }), {
+                component: 'menus',
+                serviceCall: 'roleRepo.findOne',
+                details: `role=${create_role_metadata_dto_1.ADMIN_ROLE_NAME}`,
+            });
             const allRoleNames = new Set();
             for (const m of menus)
                 (m.roles ?? []).forEach((r) => allRoleNames.add(r));
             if (admin)
                 allRoleNames.add(admin.name);
-            const roles = await roleRepo.find({
+            const roles = await this.timeOperation('menu-roles-find', () => roleRepo.find({
                 where: { name: (0, typeorm_1.In)([...allRoleNames]) },
                 select: ["id", "name"],
+            }), {
+                component: 'menus',
+                serviceCall: 'roleRepo.find',
+                details: `roleCount=${allRoleNames.size}`,
             });
             const roleByName = new Map(roles.map(r => [r.name, r]));
             const joinRows = [];
@@ -578,57 +921,153 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             }
             const menuIds = [...new Set(joinRows.map(r => r.menuId))];
             if (menuIds.length) {
-                await trx
+                await this.timeOperation('menu-role-joins-delete', () => trx
                     .createQueryBuilder()
                     .delete()
                     .from(create_menu_item_metadata_dto_1.MENU_ROLE_JOIN_TABLE_NAME)
                     .where(`${create_menu_item_metadata_dto_1.MENU_ROLE_JOIN_TABLE_NAME_MENU_COL} IN (:...ids)`, { ids: menuIds })
-                    .execute();
+                    .execute(), {
+                    component: 'menus',
+                    serviceCall: 'trx.delete.menuRoleJoins',
+                    details: `menuCount=${menuIds.length}`,
+                });
             }
             if (joinRows.length) {
                 const values = joinRows.map(r => ({
                     [create_menu_item_metadata_dto_1.MENU_ROLE_JOIN_TABLE_NAME_MENU_COL]: r.menuId,
                     [create_menu_item_metadata_dto_1.MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL]: r.roleId,
                 }));
-                await trx
+                await this.timeOperation('menu-role-joins-insert', () => trx
                     .createQueryBuilder()
                     .insert()
                     .into(create_menu_item_metadata_dto_1.MENU_ROLE_JOIN_TABLE_NAME)
                     .values(values)
-                    .execute();
+                    .execute(), {
+                    component: 'menus',
+                    serviceCall: 'trx.insert.menuRoleJoins',
+                    details: `rowCount=${values.length}`,
+                });
             }
-        });
+        }), { component: 'menus', serviceCall: 'dataSource.transaction' });
     }
     async handleSeedActions(actions) {
         if (!actions) {
             return;
         }
+        const actionRepo = this.dataSource.getRepository(action_metadata_entity_1.ActionMetadata);
+        await this.timeOperation('action-prime-module-cache', () => this.primeModuleLookupCache(actions.map((action) => action?.moduleUserKey)), {
+            component: 'actions',
+            serviceCall: 'primeModuleLookupCache',
+            details: `count=${actions.length}`,
+        });
+        await this.timeOperation('action-prime-model-cache', () => this.primeModelLookupCache(actions.map((action) => action?.modelUserKey)), {
+            component: 'actions',
+            serviceCall: 'primeModelLookupCache',
+            details: `count=${actions.length}`,
+        });
+        await this.timeOperation('action-prime-view-cache', () => this.primeViewLookupCache(actions.map((action) => action?.viewUserKey)), {
+            component: 'actions',
+            serviceCall: 'primeViewLookupCache',
+            details: `count=${actions.length}`,
+        });
+        const existingActionsByName = await this.timeOperation('action-preload-existing', () => this.loadExistingActionsByName(actionRepo, actions.map((action) => action?.name).filter(Boolean)), {
+            component: 'actions',
+            serviceCall: 'loadExistingActionsByName',
+            details: `count=${actions.length}`,
+        });
+        let created = 0;
+        let updated = 0;
+        let skipped = 0;
         for (let j = 0; j < actions.length; j++) {
             const actionData = actions[j];
-            actionData['module'] = await this.moduleMetadataService.findOneByUserKey(actionData.moduleUserKey);
+            actionData['module'] = await this.getModuleByUserKeyCached(actionData.moduleUserKey, {
+                moduleName: actionData.moduleUserKey,
+                component: 'actions',
+                details: `module=${actionData.moduleUserKey}`,
+            });
             if (actionData.type === 'solid') {
-                actionData['model'] = await this.modelMetadataService.findOneByUserKey(actionData.modelUserKey);
-                actionData['view'] = await this.solidViewService.findOneByUserKey(actionData.viewUserKey);
+                actionData['model'] = await this.getModelByUserKeyCached(actionData.modelUserKey, {
+                    moduleName: actionData.moduleUserKey,
+                    component: 'actions',
+                    details: `model=${actionData.modelUserKey}`,
+                });
+                actionData['view'] = await this.getViewByUserKeyCached(actionData.viewUserKey, {
+                    moduleName: actionData.moduleUserKey,
+                    component: 'actions',
+                    details: `view=${actionData.viewUserKey}`,
+                });
             }
             else {
                 if (actionData.modelUserKey) {
-                    actionData['model'] = await this.modelMetadataService.findOneByUserKey(actionData.modelUserKey);
+                    actionData['model'] = await this.getModelByUserKeyCached(actionData.modelUserKey, {
+                        moduleName: actionData.moduleUserKey,
+                        component: 'actions',
+                        details: `model=${actionData.modelUserKey}`,
+                    });
                 }
             }
-            await this.solidActionService.upsert(actionData);
+            const result = await this.upsertActionMetadataWithPreloadedExisting(actionRepo, existingActionsByName, actionData);
+            if (result.outcome === 'created') {
+                created += 1;
+            }
+            else if (result.outcome === 'updated') {
+                updated += 1;
+            }
+            else {
+                skipped += 1;
+            }
         }
+        this.logger.debug(`Action seed summary: created=${created}, updated=${updated}, skipped=${skipped}.`);
     }
     async handleSeedViews(views) {
         if (!views) {
             return;
         }
+        const viewRepo = this.dataSource.getRepository(view_metadata_entity_1.ViewMetadata);
+        await this.timeOperation('view-prime-module-cache', () => this.primeModuleLookupCache(views.map((view) => view?.moduleUserKey)), {
+            component: 'views',
+            serviceCall: 'primeModuleLookupCache',
+            details: `count=${views.length}`,
+        });
+        await this.timeOperation('view-prime-model-cache', () => this.primeModelLookupCache(views.map((view) => view?.modelUserKey)), {
+            component: 'views',
+            serviceCall: 'primeModelLookupCache',
+            details: `count=${views.length}`,
+        });
+        const existingViewsByName = await this.timeOperation('view-preload-existing', () => this.loadExistingViewsByName(viewRepo, views.map((view) => view?.name).filter(Boolean)), {
+            component: 'views',
+            serviceCall: 'loadExistingViewsByName',
+            details: `count=${views.length}`,
+        });
+        let created = 0;
+        let updated = 0;
+        let skipped = 0;
         for (let j = 0; j < views.length; j++) {
             const viewData = views[j];
             viewData['layout'] = JSON.stringify(viewData['layout'], null, 2);
-            viewData['module'] = await this.moduleMetadataService.findOneByUserKey(viewData.moduleUserKey);
-            viewData['model'] = await this.modelMetadataService.findOneByUserKey(viewData.modelUserKey);
-            await this.solidViewService.upsert(viewData);
+            viewData['module'] = await this.getModuleByUserKeyCached(viewData.moduleUserKey, {
+                moduleName: viewData.moduleUserKey,
+                component: 'views',
+                details: `module=${viewData.moduleUserKey}`,
+            });
+            viewData['model'] = await this.getModelByUserKeyCached(viewData.modelUserKey, {
+                moduleName: viewData.moduleUserKey,
+                component: 'views',
+                details: `model=${viewData.modelUserKey}`,
+            });
+            const result = await this.upsertViewMetadataWithPreloadedExisting(viewRepo, existingViewsByName, viewData);
+            this.viewLookupCache.set(viewData.name, result.entity ?? null);
+            if (result.outcome === 'created') {
+                created += 1;
+            }
+            else if (result.outcome === 'updated') {
+                updated += 1;
+            }
+            else {
+                skipped += 1;
+            }
         }
+        this.logger.debug(`View seed summary: created=${created}, updated=${updated}, skipped=${skipped}.`);
     }
     async handleSeedUsers(users) {
         if (!users) {
@@ -636,19 +1075,33 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
         }
         for (let l = 0; l < users.length; l++) {
             const user = users[l];
-            let exisitingUser = await this.userService.findOneByUsername(user.username);
+            let exisitingUser = await this.timeOperation('user-find-by-username', () => this.userService.findOneByUsername(user.username), {
+                component: 'users',
+                serviceCall: 'userService.findOneByUsername',
+                details: `username=${user.username}`,
+            });
             if (!exisitingUser) {
                 if (user.username === 'sa') {
                     user.password = create_user_dto_1.DEFAULT_SA_PASSWORD;
                 }
-                exisitingUser = await this.authenticationService.signUp(user);
+                exisitingUser = await this.timeOperation('user-sign-up', () => this.authenticationService.signUp(user), {
+                    component: 'users',
+                    serviceCall: 'authenticationService.signUp',
+                    details: `username=${user.username}`,
+                });
                 this.logger.log(`Newly created user ${user.username}`);
             }
         }
     }
     async seedModuleModelFields(moduleMetadata) {
-        this.logger.debug(`[Start] Processing module metadata`);
-        const module = await this.moduleMetadataService.upsert(moduleMetadata);
+        const fieldMetadataRepo = this.dataSource.getRepository(field_metadata_entity_1.FieldMetadata);
+        const module = await this.timeOperation('module-upsert', () => this.moduleMetadataService.upsert(moduleMetadata), {
+            moduleName: moduleMetadata.name,
+            component: 'module-model-fields',
+            serviceCall: 'moduleMetadataService.upsert',
+            details: `module=${moduleMetadata.name}`,
+        });
+        this.moduleLookupCache.set(moduleMetadata.name, module ?? null);
         let pruned = 0;
         let upserted = 1;
         const modelsMetadata = this.getSeedArray(moduleMetadata?.models);
@@ -658,24 +1111,59 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             modelMetadata['module'] = module;
             const { fields: fieldsMetadata, ...modelMetaDataWithoutFields } = modelMetadata;
             if (modelMetadata.isChild && modelMetadata.parentModelUserKey) {
-                const parentModel = await this.modelMetadataService.findOneByUserKey(modelMetadata.parentModelUserKey);
+                const parentModel = await this.getModelByUserKeyCached(modelMetadata.parentModelUserKey, {
+                    moduleName: moduleMetadata.name,
+                    component: 'module-model-fields',
+                    details: `parentModel=${modelMetadata.parentModelUserKey}`,
+                });
                 modelMetaDataWithoutFields['parentModel'] = parentModel;
             }
-            await this.modelMetadataService.upsert(modelMetaDataWithoutFields);
-            const model = await this.modelMetadataService.findOneBySingularName(modelMetadata.singularName);
+            const upsertedModel = await this.timeOperation('model-upsert', () => this.modelMetadataService.upsert(modelMetaDataWithoutFields), {
+                moduleName: moduleMetadata.name,
+                component: 'module-model-fields',
+                serviceCall: 'modelMetadataService.upsert',
+                details: `model=${modelMetadata.singularName}`,
+            });
+            this.modelLookupCache.set(modelMetadata.singularName, upsertedModel ?? null);
+            const model = await this.timeOperation('model-find-by-singular-name', () => this.modelMetadataService.findOneBySingularName(modelMetadata.singularName), {
+                moduleName: moduleMetadata.name,
+                component: 'module-model-fields',
+                serviceCall: 'modelMetadataService.findOneBySingularName',
+                details: `model=${modelMetadata.singularName}`,
+            });
             if (this.enablePruning) {
-                pruned += await this.pruneFieldsForModel(model, fieldsMetadata);
+                pruned += await this.timeOperation('prune-fields-for-model', () => this.pruneFieldsForModel(model, fieldsMetadata), {
+                    moduleName: moduleMetadata.name,
+                    component: 'module-model-fields',
+                    serviceCall: 'pruneFieldsForModel',
+                    details: `model=${modelMetadata.singularName}`,
+                });
             }
             let userKeyField = null;
             const userKeyFieldName = modelMetadata.userKeyFieldUserKey;
+            const existingFieldsByName = await this.timeOperation('field-preload-for-model', () => this.loadExistingFieldsByName(fieldMetadataRepo, model.id), {
+                moduleName: moduleMetadata.name,
+                component: 'module-model-fields',
+                serviceCall: 'loadExistingFieldsByName',
+                details: `model=${modelMetadata.singularName}`,
+            });
             upserted += fieldsMetadata?.length ?? 0;
             for (let k = 0; k < fieldsMetadata.length; k++) {
                 const fieldMetadata = fieldsMetadata[k];
                 fieldMetadata['model'] = model;
                 if (fieldMetadata.mediaStorageProviderUserKey) {
-                    fieldMetadata['mediaStorageProvider'] = await this.mediaStorageProviderMetadataService.findOneByUserKey(fieldMetadata.mediaStorageProviderUserKey);
+                    fieldMetadata['mediaStorageProvider'] = await this.getMediaStorageProviderByUserKeyCached(fieldMetadata.mediaStorageProviderUserKey, {
+                        moduleName: moduleMetadata.name,
+                        component: 'module-model-fields',
+                        details: `provider=${fieldMetadata.mediaStorageProviderUserKey}`,
+                    });
                 }
-                const affectedField = await this.fieldMetadataService.upsert(fieldMetadata);
+                const affectedField = await this.timeOperation('field-upsert', () => this.upsertFieldMetadataWithPreloadedExisting(fieldMetadataRepo, existingFieldsByName, fieldMetadata), {
+                    moduleName: moduleMetadata.name,
+                    component: 'module-model-fields',
+                    serviceCall: 'upsertFieldMetadataWithPreloadedExisting',
+                    details: `field=${fieldMetadata.name} model=${modelMetadata.singularName}`,
+                });
                 if (fieldMetadata.name === userKeyFieldName || fieldMetadata.isUserKey) {
                     const { model, ...fieldData } = affectedField;
                     userKeyField = fieldData;
@@ -683,25 +1171,285 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             }
             if (userKeyField) {
                 modelMetaDataWithoutFields['userKeyField'] = userKeyField;
-                await this.modelMetadataService.upsert(modelMetaDataWithoutFields);
+                await this.timeOperation('model-user-key-field-upsert', () => this.modelMetadataService.upsert(modelMetaDataWithoutFields), {
+                    moduleName: moduleMetadata.name,
+                    component: 'module-model-fields',
+                    serviceCall: 'modelMetadataService.upsert',
+                    details: `model=${modelMetadata.singularName} userKeyField=${userKeyField?.name ?? 'unknown'}`,
+                });
             }
         }
         if (this.enablePruning) {
-            pruned += await this.pruneModels(modelsMetadata, moduleMetadata.name);
+            pruned += await this.timeOperation('prune-models', () => this.pruneModels(modelsMetadata, moduleMetadata.name), {
+                moduleName: moduleMetadata.name,
+                component: 'module-model-fields',
+                serviceCall: 'pruneModels',
+            });
         }
-        this.logger.debug(`[End] Processing module metadata`);
         return { pruned, upserted };
     }
     getSeedArray(value) {
         return Array.isArray(value) ? value : [];
     }
+    async loadExistingFieldsByName(fieldMetadataRepo, modelId) {
+        const existingFields = await fieldMetadataRepo.find({
+            where: {
+                model: { id: modelId },
+            },
+            relations: {
+                model: true,
+                mediaStorageProvider: true,
+            },
+        });
+        return new Map(existingFields.map((field) => [field.name, field]));
+    }
+    async primeModuleLookupCache(moduleUserKeys) {
+        const missingModuleUserKeys = [...new Set(moduleUserKeys.filter((moduleUserKey) => Boolean(moduleUserKey) && !this.moduleLookupCache.has(moduleUserKey)))];
+        if (missingModuleUserKeys.length === 0) {
+            return;
+        }
+        const moduleRepo = this.dataSource.getRepository(module_metadata_entity_1.ModuleMetadata);
+        const existingModules = await moduleRepo.find({
+            where: {
+                name: (0, typeorm_1.In)(missingModuleUserKeys),
+            },
+        });
+        const moduleByName = new Map(existingModules.map((module) => [module.name, module]));
+        for (const moduleUserKey of missingModuleUserKeys) {
+            this.moduleLookupCache.set(moduleUserKey, moduleByName.get(moduleUserKey) ?? null);
+        }
+    }
+    async primeModelLookupCache(modelUserKeys) {
+        const missingModelUserKeys = [...new Set(modelUserKeys.filter((modelUserKey) => Boolean(modelUserKey) && !this.modelLookupCache.has(modelUserKey)))];
+        if (missingModelUserKeys.length === 0) {
+            return;
+        }
+        const modelRepo = this.dataSource.getRepository(model_metadata_entity_1.ModelMetadata);
+        const existingModels = await modelRepo.find({
+            where: {
+                singularName: (0, typeorm_1.In)(missingModelUserKeys),
+            },
+            relations: {
+                module: true,
+                userKeyField: true,
+            },
+        });
+        const modelBySingularName = new Map(existingModels.map((model) => [model.singularName, model]));
+        for (const modelUserKey of missingModelUserKeys) {
+            this.modelLookupCache.set(modelUserKey, modelBySingularName.get(modelUserKey) ?? null);
+        }
+    }
+    async primeViewLookupCache(viewUserKeys) {
+        const missingViewUserKeys = [...new Set(viewUserKeys.filter((viewUserKey) => Boolean(viewUserKey) && !this.viewLookupCache.has(viewUserKey)))];
+        if (missingViewUserKeys.length === 0) {
+            return;
+        }
+        const viewRepo = this.dataSource.getRepository(view_metadata_entity_1.ViewMetadata);
+        const existingViews = await viewRepo.find({
+            where: {
+                name: (0, typeorm_1.In)(missingViewUserKeys),
+            },
+            relations: {
+                module: true,
+                model: true,
+            },
+        });
+        const viewByName = new Map(existingViews.map((view) => [view.name, view]));
+        for (const viewUserKey of missingViewUserKeys) {
+            this.viewLookupCache.set(viewUserKey, viewByName.get(viewUserKey) ?? null);
+        }
+    }
+    async loadExistingViewsByName(viewRepo, viewNames) {
+        const uniqueViewNames = [...new Set(viewNames.filter(Boolean))];
+        if (uniqueViewNames.length === 0) {
+            return new Map();
+        }
+        const existingViews = await viewRepo.find({
+            where: {
+                name: (0, typeorm_1.In)(uniqueViewNames),
+            },
+            relations: {
+                module: true,
+                model: true,
+            },
+        });
+        return new Map(existingViews.map((view) => [view.name, view]));
+    }
+    async loadExistingActionsByName(actionRepo, actionNames) {
+        const uniqueActionNames = [...new Set(actionNames.filter(Boolean))];
+        if (uniqueActionNames.length === 0) {
+            return new Map();
+        }
+        const existingActions = await actionRepo.find({
+            where: {
+                name: (0, typeorm_1.In)(uniqueActionNames),
+            },
+            relations: {
+                module: true,
+                model: true,
+                view: true,
+            },
+        });
+        return new Map(existingActions.map((action) => [action.name, action]));
+    }
+    normalizeJsonFieldValue(value) {
+        if (typeof value === 'string') {
+            const trimmedValue = value.trim();
+            if ((trimmedValue.startsWith('{') && trimmedValue.endsWith('}'))
+                || (trimmedValue.startsWith('[') && trimmedValue.endsWith(']'))) {
+                try {
+                    return this.normalizeJsonFieldValue(JSON.parse(trimmedValue));
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.normalizeJsonFieldValue(item));
+        }
+        if (value && typeof value === 'object') {
+            return Object.keys(value)
+                .sort()
+                .reduce((result, key) => {
+                result[key] = this.normalizeJsonFieldValue(value[key]);
+                return result;
+            }, {});
+        }
+        return value;
+    }
+    getCanonicalJsonFieldString(value) {
+        return JSON.stringify(this.normalizeJsonFieldValue(value) ?? null);
+    }
+    hasViewMetadataChanges(existingView, updateDto) {
+        const relationFields = new Set(['module', 'model']);
+        const jsonFields = new Set(['layout', 'context']);
+        return this.viewComparableFields.some((key) => {
+            const value = updateDto[key];
+            if (typeof value === 'undefined') {
+                return false;
+            }
+            if (relationFields.has(key)) {
+                const relationValue = value;
+                return existingView[key]?.id !== relationValue?.id;
+            }
+            if (jsonFields.has(key)) {
+                return this.getCanonicalJsonFieldString(existingView[key]) !== this.getCanonicalJsonFieldString(value);
+            }
+            return existingView[key] !== value;
+        });
+    }
+    hasActionMetadataChanges(existingAction, updateDto) {
+        const relationFields = new Set(['module', 'model', 'view']);
+        const jsonFields = new Set(['domain', 'context']);
+        return this.actionComparableFields.some((key) => {
+            const value = updateDto[key];
+            if (typeof value === 'undefined') {
+                return false;
+            }
+            if (relationFields.has(key)) {
+                const relationValue = value;
+                return existingAction[key]?.id !== relationValue?.id;
+            }
+            if (jsonFields.has(key)) {
+                return this.getCanonicalJsonFieldString(existingAction[key]) !== this.getCanonicalJsonFieldString(value);
+            }
+            return existingAction[key] !== value;
+        });
+    }
+    async upsertViewMetadataWithPreloadedExisting(viewRepo, existingViewsByName, updateDto) {
+        const existingView = existingViewsByName.get(updateDto.name);
+        if (existingView) {
+            if (!this.hasViewMetadataChanges(existingView, updateDto)) {
+                return { entity: existingView, outcome: 'skipped' };
+            }
+            const updatedView = { ...existingView, ...updateDto };
+            const savedView = await this.timeOperation('view-save', () => viewRepo.save(updatedView), {
+                component: 'views',
+                serviceCall: 'viewRepo.save',
+                details: `view=${updateDto.name}`,
+            });
+            existingViewsByName.set(updateDto.name, savedView);
+            return { entity: savedView, outcome: 'updated' };
+        }
+        const view = viewRepo.create(updateDto);
+        const savedView = await this.timeOperation('view-save', () => viewRepo.save(view), {
+            component: 'views',
+            serviceCall: 'viewRepo.save',
+            details: `view=${updateDto.name}`,
+        });
+        existingViewsByName.set(updateDto.name, savedView);
+        return { entity: savedView, outcome: 'created' };
+    }
+    async upsertActionMetadataWithPreloadedExisting(actionRepo, existingActionsByName, updateDto) {
+        const existingAction = existingActionsByName.get(updateDto.name);
+        if (existingAction) {
+            if (!this.hasActionMetadataChanges(existingAction, updateDto)) {
+                return { entity: existingAction, outcome: 'skipped' };
+            }
+            const updatedAction = { ...existingAction, ...updateDto };
+            const savedAction = await this.timeOperation('action-save', () => actionRepo.save(updatedAction), {
+                component: 'actions',
+                serviceCall: 'actionRepo.save',
+                details: `action=${updateDto.name}`,
+            });
+            existingActionsByName.set(updateDto.name, savedAction);
+            return { entity: savedAction, outcome: 'updated' };
+        }
+        const action = actionRepo.create(updateDto);
+        const savedAction = await this.timeOperation('action-save', () => actionRepo.save(action), {
+            component: 'actions',
+            serviceCall: 'actionRepo.save',
+            details: `action=${updateDto.name}`,
+        });
+        existingActionsByName.set(updateDto.name, savedAction);
+        return { entity: savedAction, outcome: 'created' };
+    }
+    async upsertFieldMetadataWithPreloadedExisting(fieldMetadataRepo, existingFieldsByName, updateDto) {
+        const existingFieldMetadata = existingFieldsByName.get(updateDto.name);
+        if (existingFieldMetadata) {
+            const hasChanges = Object.entries(updateDto).some(([key, value]) => {
+                const relationValue = value;
+                if (key === 'model') {
+                    return existingFieldMetadata.model?.id !== relationValue?.id;
+                }
+                if (key === 'mediaStorageProvider') {
+                    return existingFieldMetadata.mediaStorageProvider?.id !== relationValue?.id;
+                }
+                const currentValue = existingFieldMetadata[key];
+                if (Array.isArray(currentValue) || Array.isArray(value)) {
+                    return JSON.stringify(currentValue ?? null) !== JSON.stringify(value ?? null);
+                }
+                if (value && typeof value === 'object') {
+                    return JSON.stringify(currentValue ?? null) !== JSON.stringify(value ?? null);
+                }
+                return currentValue !== value;
+            });
+            if (!hasChanges) {
+                return existingFieldMetadata;
+            }
+            const updatedFieldMetadata = { ...existingFieldMetadata, ...updateDto };
+            const savedFieldMetadata = await fieldMetadataRepo.save(updatedFieldMetadata);
+            existingFieldsByName.set(updateDto.name, savedFieldMetadata);
+            return savedFieldMetadata;
+        }
+        const fieldMetadata = fieldMetadataRepo.create(updateDto);
+        const savedFieldMetadata = await fieldMetadataRepo.save(fieldMetadata);
+        existingFieldsByName.set(updateDto.name, savedFieldMetadata);
+        return savedFieldMetadata;
+    }
     async handleSeedSecurityRules(rulesDto) {
         if (!rulesDto || rulesDto.length === 0) {
             this.logger.debug(`No security rules found to seed`);
             return;
         }
         for (const dto of rulesDto) {
-            await this.securityRuleRepo.upsertWithDto({ ...dto, securityRuleConfig: JSON.stringify(dto.securityRuleConfig) });
+            await this.timeOperation('security-rule-upsert', () => this.securityRuleRepo.upsertWithDto({ ...dto, securityRuleConfig: JSON.stringify(dto.securityRuleConfig) }), {
+                component: 'security-rules',
+                serviceCall: 'securityRuleRepo.upsertWithDto',
+                details: `rule=${dto.name}`,
+            });
         }
     }
     async handleSeedListOfValues(listOfValuesDto) {
@@ -711,8 +1459,16 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
         }
         for (let j = 0; j < listOfValuesDto.length; j++) {
             const listOfValueDto = listOfValuesDto[j];
-            listOfValueDto['module'] = await this.moduleMetadataService.findOneByUserKey(listOfValueDto.moduleUserKey);
-            await this.listOfValuesService.upsert(listOfValuesDto[j]);
+            listOfValueDto['module'] = await this.getModuleByUserKeyCached(listOfValueDto.moduleUserKey, {
+                moduleName: listOfValueDto.moduleUserKey,
+                component: 'list-of-values',
+                details: `module=${listOfValueDto.moduleUserKey}`,
+            });
+            await this.timeOperation('lov-upsert', () => this.listOfValuesService.upsert(listOfValuesDto[j]), {
+                component: 'list-of-values',
+                serviceCall: 'listOfValuesService.upsert',
+                details: `type=${listOfValueDto.type} value=${listOfValueDto.value}`,
+            });
         }
     }
     async handleSeedScheduledJobs(createScheduledJobDto) {
@@ -721,7 +1477,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return;
         }
         for (const dto of createScheduledJobDto) {
-            await this.scheduledJobRepository.upsertWithDto(dto);
+            await this.timeOperation('scheduled-job-upsert', () => this.scheduledJobRepository.upsertWithDto(dto), {
+                component: 'scheduled-jobs',
+                serviceCall: 'scheduledJobRepository.upsertWithDto',
+                details: `schedule=${dto.scheduleName}`,
+            });
         }
     }
     async handleSeedSavedFilters(createSavedFilterDto) {
@@ -731,8 +1491,46 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
         }
         for (const dto of createSavedFilterDto) {
             this.validateSavedFilterQueryJsonWrapper(dto);
-            await this.savedFiltersRepo.upsertWithDto({ ...dto, filterQueryJson: JSON.stringify(dto.filterQueryJson), isSeeded: true });
+            await this.timeOperation('saved-filter-upsert', () => this.savedFiltersRepo.upsertWithDto({ ...dto, filterQueryJson: JSON.stringify(dto.filterQueryJson), isSeeded: true }), {
+                component: 'saved-filters',
+                serviceCall: 'savedFiltersRepo.upsertWithDto',
+                details: `filter=${dto.name}`,
+            });
+        }
+    }
+    async handleSeedLocales(localesDto) {
+        if (!localesDto || localesDto.length === 0) {
+            this.logger.debug(`No locales found to seed`);
+            return;
+        }
+        for (const dto of localesDto) {
+            if (dto.isDefault) {
+                const existingDefaultLocales = await this.localeRepo.find({
+                    where: {
+                        isDefault: true,
+                    },
+                });
+                for (const locale of existingDefaultLocales) {
+                    if (locale.locale !== dto.locale) {
+                        await this.localeRepo.save({
+                            ...locale,
+                            isDefault: false,
+                        });
+                    }
+                }
+            }
+            const existingLocale = await this.localeRepo.findOne({
+                where: {
+                    locale: dto.locale,
+                },
+            });
+            await this.localeRepo.save(this.localeRepo.create({
+                ...existingLocale,
+                ...dto,
+            }));
         }
+        const locales = await this.localeRepo.find();
+        this.solidRegistry.registerlocales(locales);
     }
     validateSavedFilterQueryJsonWrapper(dto) {
         const filterName = dto?.name ?? '<unnamed>';
@@ -755,7 +1553,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return;
         }
         for (const dto of modelSequencesDto) {
-            await this.modelSequenceRepo.upsertWithDto(dto);
+            await this.timeOperation('model-sequence-upsert', () => this.modelSequenceRepo.upsertWithDto(dto), {
+                component: 'model-sequences',
+                serviceCall: 'modelSequenceRepo.upsertWithDto',
+                details: `sequence=${dto.sequenceName}`,
+            });
         }
     }
     async pruneModelSequences(modelSequencesDto, moduleName) {
@@ -764,7 +1566,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const sequences = modelSequencesDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'model-sequences',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping model sequence prune: module not found for ${moduleName}.`);
             return 0;
@@ -798,7 +1604,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const savedFilters = savedFiltersDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'saved-filters',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping saved filters prune: module not found for ${moduleName}.`);
             return 0;
@@ -833,7 +1643,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const scheduledJobs = scheduledJobsDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'scheduled-jobs',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping scheduled jobs prune: module not found for ${moduleName}.`);
             return 0;
@@ -867,7 +1681,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const securityRules = securityRulesDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'security-rules',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping security rules prune: module not found for ${moduleName}.`);
             return 0;
@@ -902,7 +1720,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const listOfValues = listOfValuesDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'list-of-values',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping list of values prune: module not found for ${moduleName}.`);
             return 0;
@@ -944,7 +1766,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const menus = menusDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'menus',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping menus prune: module not found for ${moduleName}.`);
             return 0;
@@ -986,7 +1812,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const views = viewsDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'views',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping views prune: module not found for ${moduleName}.`);
             return 0;
@@ -1039,7 +1869,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const actions = actionsDto ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'actions',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping actions prune: module not found for ${moduleName}.`);
             return 0;
@@ -1125,7 +1959,11 @@ let ModuleMetadataSeederService = ModuleMetadataSeederService_1 = class ModuleMe
             return 0;
         }
         const models = modelsMetadata ?? [];
-        const module = await this.moduleMetadataService.findOneByUserKey(moduleName);
+        const module = await this.getModuleByUserKeyCached(moduleName, {
+            moduleName,
+            component: 'module-model-fields',
+            details: `module=${moduleName}`,
+        });
         if (!module) {
             this.logger.warn(`Skipping models prune: module not found for ${moduleName}.`);
             return 0;
@@ -1255,6 +2093,7 @@ exports.ModuleMetadataSeederService = ModuleMetadataSeederService = ModuleMetada
         scheduled_job_repository_1.ScheduledJobRepository,
         saved_filters_repository_1.SavedFiltersRepository,
         typeorm_1.DataSource,
-        model_sequence_repository_1.ModelSequenceRepository])
+        model_sequence_repository_1.ModelSequenceRepository,
+        locale_repository_1.LocaleRepository])
 ], ModuleMetadataSeederService);
 //# sourceMappingURL=module-metadata-seeder.service.js.map