@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -144,7 +144,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
 
         const existingControllerAndTheirMethods = this.solidRegistry.getControllers();
 
-        
+
 
         // Build markdown sections using template interpolation
         const modulesSection = (existingModules ?? [])
@@ -170,7 +170,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
                 `- name: ${d.name}`,
                 `- description: ${d.description ?? ""}`,
             ].join('\n'))
-            .join('\n\n');    
+            .join('\n\n');
 
         const computationProvidersSection = (existingComputationProviders ?? [])
             .map(m => [
@@ -183,7 +183,7 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
         const controllersAndTheirMethods = (existingControllerAndTheirMethods ?? [])
             .map(m => [
                 `### ${m.name}`,
-                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n'): '- No methods found'}`,
+                `- methods: ${m.methods.length ? m.methods.map(m => `- ${m}`).join('\n') : '- No methods found'}`,
             ].join('\n'))
             .join('\n\n');
 
@@ -224,11 +224,10 @@ Use the below list of computed field providers to infer which provider the user
 ${computationProvidersSection}
 `.trim();
 
+        // ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
+        // Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
 
-// ## LIST OF EXISTING CONTROLLERS AND THEIR METHODS
-// Use the below list of controllers and their methods to infer whether the api call being made to a particular controller exists or not.
-
-// ${controllersAndTheirMethods}
+        // ${controllersAndTheirMethods}
 
         const aiResponse = await this.aiInteractionService.runMcpPrompt(finalPrompt);
         this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
@@ -247,7 +246,7 @@ ${computationProvidersSection}
             //     role: 'gen-ai',
             //     message: '-',
             //     contentType: aiResponse.content_type,
-            //     errorMessage: errorsStr,
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
             //     modelUsed: aiResponse.model,
             //     responseTimeMs: aiResponse.duration_ms,
             //     metadata: JSON.stringify(aiResponse, null, 2),
@@ -257,7 +256,7 @@ ${computationProvidersSection}
 
             // TODO: Update the previously created genAiInteraction record with the respective error fields and save to DB
             await this.aiInteractionService.update(genAiInteraction.id, {
-                // contentType: aiResponse.content_type,
+                contentType: aiResponse.content_type,
                 errorMessage: `${errorsStr}\n\n${errorTrace}`,
                 modelUsed: aiResponse.model,
                 responseTimeMs: aiResponse.duration_ms,
@@ -271,6 +270,10 @@ ${computationProvidersSection}
         else {
             let nestedResponse = this.cleanNestedResponse(aiResponse);
 
+            // TODO: Update the previously created genAiInteraction record with the respective success fields and save to DB
+            const errorsStr = nestedResponse?.status == "error" && nestedResponse?.errors.join('\n ');
+            const errorTrace = nestedResponse?.status == "error" && nestedResponse?.error_trace?.join('\n');
+
             // const genAiInteraction = await this.aiInteractionService.create({
             //     userId: aiInteraction.user.id,
             //     threadId: aiInteraction.threadId,
@@ -278,7 +281,7 @@ ${computationProvidersSection}
             //     role: 'gen-ai',
             //     message: nestedResponse,
             //     contentType: aiResponse.content_type,
-            //     errorMessage: '',
+            //     errorMessage: `${errorsStr}\n\n${errorTrace}`,
             //     modelUsed: aiResponse.model,
             //     responseTimeMs: aiResponse.duration_ms,
             //     metadata: JSON.stringify(aiResponse, null, 2),
@@ -286,21 +289,14 @@ ${computationProvidersSection}
             //     status: aiResponse.success ? 'succeeded' : 'failed'
             // });
 
-            // TODO: Update the previously created genAiInteraction record with the respective success fields and save to DB
-            const errorsStr = nestedResponse?.status == "error" && nestedResponse?.errors.join('\n ');
-            // const errorTrace = nestedResponse?.status == "error" && nestedResponse?.error_trace?.join('\n');
-
-
             await this.aiInteractionService.update(genAiInteraction.id, {
-                errorMessage: nestedResponse.status == "error" ? `${errorsStr}` : "",
-                // errorMessage:"",
-                // contentType: aiResponse.content_type,
-                // message: nestedResponse,
+                errorMessage: nestedResponse.status == "error" ? `${errorsStr}\n\n${errorTrace}` : "",
+                contentType: aiResponse.content_type,
+                message: JSON.stringify(nestedResponse),
                 modelUsed: aiResponse.model,
                 responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse, null, 2),
                 isApplied: aiInteraction.isApplied,
-
-                // status: aiResponse.success ? 'succeeded' : 'failed'
                 status: aiResponse.success && nestedResponse.status == "success" ? 'succeeded' : 'failed'
             }, [], true);
 

package/src/repository/media.repository.ts

@@ -1,7 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { Media } from 'src/entities/media.entity';
 import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
+import { DataSource, In } from 'typeorm';
 import { FieldMetadataRepository } from './field-metadata.repository';
 import { MediaStorageProviderMetadataRepository } from './media-storage-provider-metadata.repository';
 import { ModelMetadataRepository } from './model-metadata.repository';
@@ -21,6 +21,7 @@ export class MediaRepository extends SolidBaseRepository<Media> {
         // @InjectRepository(MediaStorageProviderMetadata)
         // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
         private readonly fieldMetadataRepo: FieldMetadataRepository,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
         private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
     ) {

package/src/repository/model-sequence.repository.ts

@@ -0,0 +1,97 @@
+import { Injectable } from '@nestjs/common';
+import { ModelSequence } from 'src/entities/model-sequence.entity';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { CreateModelSequenceDto } from 'src/dtos/create-model-sequence.dto';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+
+@Injectable()
+export class ModelSequenceRepository extends SolidBaseRepository<ModelSequence> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModelSequence, dataSource, requestContextService, securityRuleRepository);
+    }
+
+    async upsertWithDto(createDto: CreateModelSequenceDto) {
+        // Populate the module from moduleId or moduleUserKey
+        const moduleRepository = this.dataSource.getRepository(ModuleMetadata);
+        if (createDto.moduleId) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    id: createDto.moduleId,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        if (createDto.moduleUserKey) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    name: createDto.moduleUserKey,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        // Populate the model from modelId or modelUserKey
+        const modelRepository = this.dataSource.getRepository(ModelMetadata);
+        if (createDto.modelId) {
+            const model = await modelRepository.findOne({
+                where: {
+                    id: createDto.modelId,
+                },
+            });
+            createDto['model'] = model;
+        }
+        if (createDto.modelUserKey) {
+            const model = await modelRepository.findOne({
+                where: {
+                    singularName: createDto.modelUserKey,
+                },
+            });
+            createDto['model'] = model;
+        }
+
+        // Populate the field from fieldId or fieldUserKey
+        const fieldRepository = this.dataSource.getRepository(FieldMetadata);
+        if (createDto.fieldId) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    id: createDto.fieldId,
+                },
+            });
+            createDto['field'] = field;
+        }
+        if (createDto.fieldUserKey) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    name: createDto.fieldUserKey,
+                },
+            });
+            createDto['field'] = field;
+        }
+
+        // First check if sequence already exists using name
+        const existingModelSequence = await this.findOne({
+            where: {
+                sequenceName: createDto.sequenceName,
+            },
+        });
+
+        if (existingModelSequence) {
+            const updatedModelSequence = this.merge(existingModelSequence, createDto);
+            return this.save(updatedModelSequence);
+        }
+        else {
+            const modelSequence = this.create(createDto);
+            return this.save(modelSequence);
+        }
+    }
+}

package/src/seeders/module-metadata-seeder.service.ts

@@ -1,18 +1,13 @@
-import { Inject, Injectable, Logger } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import * as fs from 'fs';
 import * as path from 'path';
 
-import { ConfigType } from '@nestjs/config';
-import { InjectRepository } from '@nestjs/typeorm';
-import commonConfig from 'src/config/common.config';
-import { iamConfig } from 'src/config/iam.config';
 import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
 import { CreateEmailTemplateDto } from 'src/dtos/create-email-template.dto';
 import { CreateListOfValuesDto } from 'src/dtos/create-list-of-values.dto';
 import { CreateSecurityRuleDto } from 'src/dtos/create-security-rule.dto';
 import { CreateSettingDto } from 'src/dtos/create-setting.dto';
 import { CreateSmsTemplateDto } from 'src/dtos/create-sms-template.dto';
-import { Setting } from 'src/entities/setting.entity';
 import { DashboardRepository } from 'src/repository/dashboard.repository';
 import { SecurityRuleRepository } from 'src/repository/security-rule.repository';
 import { AuthenticationService } from 'src/services/authentication.service';
@@ -25,14 +20,12 @@ import { DataSource, In, Repository } from 'typeorm';
 import appBuilderConfig from '../config/app-builder.config';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { CreateModuleMetadataDto } from '../dtos/create-module-metadata.dto';
-import { PermissionMetadata } from '../entities/permission-metadata.entity';
-import { getDynamicModuleNames } from '../helpers/module.helper';
+import { getDynamicModuleNames, getDynamicModuleNamesBasedOnMetadata } from '../helpers/module.helper';
 import { SolidRegistry } from '../helpers/solid-registry';
 import { ActionMetadataService } from '../services/action-metadata.service';
 import { FieldMetadataService } from '../services/field-metadata.service';
 import { MediaStorageProviderMetadataSeederService } from '../services/media-storage-provider-metadata-seeder.service';
 import { MediaStorageProviderMetadataService } from '../services/media-storage-provider-metadata.service';
-import { MenuItemMetadataService } from '../services/menu-item-metadata.service';
 import { ModelMetadataService } from '../services/model-metadata.service';
 import { ModuleMetadataService } from '../services/module-metadata.service';
 import { RoleMetadataService } from '../services/role-metadata.service';
@@ -42,12 +35,14 @@ import { SystemFieldsSeederService } from './system-fields-seeder.service';
 // import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
 import { ActionMetadata, MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL, MenuItemMetadata, ModuleMetadata, RoleMetadata } from 'src';
 import { ADMIN_ROLE_NAME, INTERNAL_ROLE_NAME, INTERNAL_ROLE_PERMISSIONS, PUBLIC_ROLE_NAME } from 'src/dtos/create-role-metadata.dto';
+import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
 import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
-import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
-import { SettingRepository } from 'src/repository/setting.repository';
-import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
 import { SavedFiltersRepository } from 'src/repository/saved-filters.repository';
+import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
+import { SettingRepository } from 'src/repository/setting.repository';
+import { CreateModelSequenceDto } from 'src/dtos/create-model-sequence.dto';
+import { ModelSequenceRepository } from 'src/repository/model-sequence.repository';
 
 
 @Injectable()
@@ -57,6 +52,7 @@ export class ModuleMetadataSeederService {
 
     constructor(
         private readonly moduleMetadataService: ModuleMetadataService,
+        @Inject(forwardRef(() => ModelMetadataService))
         private readonly modelMetadataService: ModelMetadataService,
         private readonly fieldMetadataService: FieldMetadataService,
         private readonly mediaStorageProviderMetadataService: MediaStorageProviderMetadataService,
@@ -64,7 +60,6 @@ export class ModuleMetadataSeederService {
         private readonly userService: UserService,
         private readonly authenticationService: AuthenticationService,
         private readonly solidActionService: ActionMetadataService,
-        private readonly solidMenuItemService: MenuItemMetadataService,
         private readonly solidViewService: ViewMetadataService,
         private readonly mediaStorageProviderSeederService: MediaStorageProviderMetadataSeederService,
         private readonly emailTemplateService: EmailTemplateService,
@@ -74,11 +69,6 @@ export class ModuleMetadataSeederService {
         // private readonly permissionRepo: Repository<PermissionMetadata>,
         private readonly permissionRepo: PermissionMetadataRepository,
         private readonly solidRegistry: SolidRegistry,
-        @Inject(appBuilderConfig.KEY)
-        private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
-        @Inject(iamConfig.KEY) private readonly iamConfiguration: ConfigType<typeof iamConfig>,
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
         private readonly settingService: SettingService,
         // @InjectRepository(Setting, 'default')
         // readonly settingsRepo: Repository<Setting>,
@@ -87,22 +77,51 @@ export class ModuleMetadataSeederService {
         readonly systemFieldsSeederService: SystemFieldsSeederService,
         readonly dashboardRepo: DashboardRepository,
         readonly scheduledJobRepository: ScheduledJobRepository,
-        readonly savedFiltersRepo : SavedFiltersRepository,
+        readonly savedFiltersRepo: SavedFiltersRepository,
         readonly dataSource: DataSource,
+        readonly modelSequenceRepo: ModelSequenceRepository,
     ) { }
 
-    async seed() {
+    async seed(conf?: any) {
         // Global seeding steps i.e across all modules
         await this.seedGlobalMetadata();
 
+
         // Module specific seeding steps.
         // Get all the module metadata files which needs to be seeded.
         const seedDataFiles = this.seedDataFiles;
         this.logger.debug(`Seed data files are: ${seedDataFiles}`);
+
+        /** -------------------------------------------------------------
+         * Selective module seeding via: 
+         *   solid seed -c "{\"modulesToSeed\": [\"onboarding\", \"reports\"]}"
+         * -------------------------------------------------------------
+         */
+        let modulesToSeed: string[] | null = null;
+
+        if (conf && Array.isArray(conf.modulesToSeed)) {
+            modulesToSeed = conf.modulesToSeed;
+            this.logger.log(`Selective seeding enabled. Modules to seed: ${modulesToSeed.join(', ')}`);
+        } else {
+            this.logger.log(`No modulesToSeed provided. Seeding ALL modules.`);
+        }
+
+        // Filter modules if needed
+        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;
+        }
+
         // let usersDetail;
         // For each module metadata file, we will process the seeding steps one by one.
-        for (let i = 0; i < seedDataFiles.length; i++) {
-            const overallMetadata = seedDataFiles[i];
+        for (let i = 0; i < filteredSeedDataFiles.length; i++) {
+            const overallMetadata = filteredSeedDataFiles[i];
             const moduleMetadata: CreateModuleMetadataDto = overallMetadata.moduleMetadata;
             this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
 
@@ -162,10 +181,14 @@ export class ModuleMetadataSeederService {
             this.logger.log(`Seeding Scheduled Jobs`);
             await this.seedScheduledJobs(moduleMetadata, overallMetadata);
 
-             // Saved Filters
-             this.logger.log(`Seeding Saved Filters`);
-             await this.seedSavedFilters(moduleMetadata, overallMetadata);
- 
+            // Saved Filters
+            this.logger.log(`Seeding Saved Filters`);
+            await this.seedSavedFilters(moduleMetadata, overallMetadata);
+
+            // Model Sequences
+            this.logger.log(`Seeding Model Sequences`);
+            await this.seedModelSequences(overallMetadata);
+
             this.logger.debug(`[End] module seed data: ${overallMetadata}`);
         }
 
@@ -194,7 +217,7 @@ export class ModuleMetadataSeederService {
             await this.handleSeedSavedFilters(savedFilters);
         }
         this.logger.debug(`[End] Processing saved filters for ${moduleMetadata.name}`);
-    }   
+    }
 
     private async seedDashboards(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any) {
         this.logger.debug(`[Start] Processing dashboards for ${moduleMetadata.name}`);
@@ -301,7 +324,8 @@ export class ModuleMetadataSeederService {
     private get seedDataFiles(): any[] {
         const typedSolidCoreMetadata = structuredClone(solidCoreMetadata);
         const seedDataFiles = [typedSolidCoreMetadata];
-        const enabledModules = getDynamicModuleNames();
+        // const enabledModules = getDynamicModuleNames();
+        const enabledModules = getDynamicModuleNamesBasedOnMetadata();
         for (const enabledModule of enabledModules) {
             const enabledModuleSeedFile = `module-metadata/${enabledModule}/${enabledModule}-metadata.json`;
             const fullPath = path.join(process.cwd(), enabledModuleSeedFile);
@@ -325,6 +349,8 @@ export class ModuleMetadataSeederService {
 
         this.logger.log(`Seeding System Fields Metadata`);
         await this.seedDefaultSystemFields();
+
+        this.logger.debug(`Global metadata seeding completed`);
     }
 
     private async seedDefaultSystemFields() {
@@ -395,6 +421,13 @@ export class ModuleMetadataSeederService {
         this.logger.debug(`[End] Processing Media Storage Provider`);
     }
 
+    private async seedModelSequences(overallMetadata: any) {
+        this.logger.debug(`[Start] Processing model sequences`);
+        const modelSequences: CreateModelSequenceDto[] = overallMetadata.modelSequences;
+        await this.handleSeedModelSequences(modelSequences);
+        this.logger.debug(`[End] Processing model sequences`);
+    }
+
     // OK
     private async handleSeedEmailTemplates(emailTemplates: CreateEmailTemplateDto[], moduleName: string) {
         if (!emailTemplates) {
@@ -407,12 +440,41 @@ export class ModuleMetadataSeederService {
 
             // We need to load the actual template contents. 
             if (moduleName === 'solid-core') {
-                const modulePath = path.dirname(require.resolve('@solidstarters/solid-core'));
-                const seedDataPath = path.join(modulePath, '../src/seeders/seed-data/email-templates');
-                const filePath = path.join(seedDataPath, emailTemplate.body);
-                // this.logger.log(`Seeding email template from solid-core at path: ${filePath}`);
+                let moduleRoot: string | null = null;
+
+                try {
+                    // Always resolve package.json, never the module entry
+                    moduleRoot = path.dirname(
+                        require.resolve('@solidstarters/solid-core/package.json'),
+                    );
+                } catch (err) {
+                    this.logger.debug(
+                        'Could not resolve @solidstarters/solid-core from node_modules, assuming local execution',
+                    );
+                }
+
+                const filePathInternal = 'src/seeders/seed-data/email-templates/';
+                let filePath: string;
+                // Case 1: solid-core installed as dependency
+                if (moduleRoot) {
+                    filePath = path.join(
+                        moduleRoot,
+                        filePathInternal,
+                        emailTemplate.body,
+                    );
+                }
+                else {
+                    // Case 2: running INSIDE solid-core repo
+                    const localCoreRoot = process.cwd(); // or configurable root
+                    filePath = path.join(
+                        localCoreRoot,
+                        filePathInternal,
+                        emailTemplate.body,
+                    );
+                }
+
                 if (fs.existsSync(filePath)) {
-                    emailTemplate.body = fs.readFileSync(filePath, 'utf-8').toString();
+                    emailTemplate.body = fs.readFileSync(filePath, 'utf-8');
                 }
             }
             else {
@@ -444,12 +506,41 @@ export class ModuleMetadataSeederService {
 
             // We need to load the actual template contents. 
             if (moduleName === 'solid-core') {
-                const modulePath = path.dirname(require.resolve('@solidstarters/solid-core'));
-                const seedDataPath = path.join(modulePath, '../src/seeders/seed-data/sms-templates');
-                const filePath = path.join(seedDataPath, smsTemplate.body);
-                // this.logger.log(`Seeding sms template from solid-core at path: ${filePath}`);
+                let moduleRoot: string | null = null;
+
+                try {
+                    // Always resolve package.json, never the module entry
+                    moduleRoot = path.dirname(
+                        require.resolve('@solidstarters/solid-core/package.json'),
+                    );
+                } catch (err) {
+                    this.logger.debug(
+                        'Could not resolve @solidstarters/solid-core from node_modules, assuming local execution',
+                    );
+                }
+
+                const filePathInternal = 'src/seeders/seed-data/sms-templates/';
+                let filePath: string;
+                // Case 1: solid-core installed as dependency
+                if (moduleRoot) {
+                    filePath = path.join(
+                        moduleRoot,
+                        filePathInternal,
+                        smsTemplate.body,
+                    );
+                }
+                else {
+                    // Case 2: running INSIDE solid-core repo
+                    const localCoreRoot = process.cwd(); // or configurable root
+                    filePath = path.join(
+                        localCoreRoot,
+                        filePathInternal,
+                        smsTemplate.body,
+                    );
+                }
+
                 if (fs.existsSync(filePath)) {
-                    smsTemplate.body = fs.readFileSync(filePath, 'utf-8').toString();
+                    smsTemplate.body = fs.readFileSync(filePath, 'utf-8');
                 }
             }
             else {
@@ -469,7 +560,7 @@ export class ModuleMetadataSeederService {
         }
     }
 
-    // Not OK
+    // Ok
     private async handleSeedMenus(menus: any) {
         if (!menus) {
             return;
@@ -481,22 +572,42 @@ export class ModuleMetadataSeederService {
             const actionRepo = trx.getRepository(ActionMetadata);
             const moduleRepo = trx.getRepository(ModuleMetadata);
 
-            // 1) Upsert menus WITHOUT roles
+            // 1) Upsert menus WITHOUT roles (manual upsert)
             for (const m of menus) {
-                const entity = menuRepo.create({
+                const action = m.actionUserKey
+                    ? await actionRepo.findOne({ where: { name: m.actionUserKey }, select: ["id"] })
+                    : null;
+
+                const module = m.moduleUserKey
+                    ? await moduleRepo.findOne({ where: { name: m.moduleUserKey }, select: ["id"] })
+                    : null;
+
+                const parentMenuItem = m.parentMenuItemUserKey
+                    ? await menuRepo.findOne({ where: { name: m.parentMenuItemUserKey }, select: ["id"] })
+                    : null;
+
+                // Check if a menu with this name already exists
+                const existing = await menuRepo.findOne({
+                    where: { name: m.name },
+                    select: ["id"],
+                });
+
+                // Build the entity data (without id)
+                const base = {
                     name: m.name,
                     displayName: m.displayName,
-                    action: m.actionUserKey
-                        ? await actionRepo.findOne({ where: { name: m.actionUserKey }, select: ["id"] })
-                        : null,
-                    module: m.moduleUserKey
-                        ? await moduleRepo.findOne({ where: { name: m.moduleUserKey }, select: ["id"] })
-                        : null,
-                    parentMenuItem: m.parentMenuItemUserKey
-                        ? await menuRepo.findOne({ where: { name: m.parentMenuItemUserKey }, select: ["id"] })
-                        : null,
-                });
-                await menuRepo.upsert(entity, ["name"]); // or ["userKey"]
+                    action,
+                    module,
+                    parentMenuItem,
+                    sequenceNumber: m.sequenceNumber
+                };
+
+                // If existing, set its id so save() will perform an update, otherwise insert
+                const entity = menuRepo.create(
+                    existing ? { id: existing.id, ...base } : base,
+                );
+
+                await menuRepo.save(entity);
             }
 
             // 2) Fetch ids for batching
@@ -528,8 +639,7 @@ export class ModuleMetadataSeederService {
                 }
             }
 
-            // 4) Replace in bulk — QueryBuilder version
-
+            // 4) Replace in bulk — no orIgnore, safe for MSSQL
             // 4a) delete existing for affected menus
             const menuIds = [...new Set(joinRows.map(r => r.menuId))];
             if (menuIds.length) {
@@ -543,7 +653,6 @@ export class ModuleMetadataSeederService {
 
             // 4b) bulk insert all pairs
             if (joinRows.length) {
-                // Build objects with the exact column names used by the join table
                 const values = joinRows.map(r => ({
                     [MENU_ROLE_JOIN_TABLE_NAME_MENU_COL]: r.menuId,
                     [MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL]: r.roleId,
@@ -552,9 +661,9 @@ export class ModuleMetadataSeederService {
                 await trx
                     .createQueryBuilder()
                     .insert()
-                    .into(MENU_ROLE_JOIN_TABLE_NAME) // string table name
+                    .into(MENU_ROLE_JOIN_TABLE_NAME)
                     .values(values)
-                    .orIgnore() // optional if you have a UNIQUE(menuItemId, roleId) and want to skip dups
+                    // .orIgnore()  // ❌ remove this – it triggers unsupported onUpdate path
                     .execute();
             }
         });
@@ -664,7 +773,7 @@ export class ModuleMetadataSeederService {
                 // console.log(fieldMetadata.displayName);
 
                 const affectedField = await this.fieldMetadataService.upsert(fieldMetadata);
-                if (fieldMetadata.name === userKeyFieldName) {
+                if (fieldMetadata.name === userKeyFieldName || fieldMetadata.isUserKey) {
                     const { model, ...fieldData } = affectedField;
                     userKeyField = fieldData;
                 }
@@ -738,5 +847,14 @@ export class ModuleMetadataSeederService {
             await this.savedFiltersRepo.upsertWithDto({ ...dto, filterQueryJson: JSON.stringify(dto.filterQueryJson) });
         }
     }
+    private async handleSeedModelSequences(modelSequencesDto: CreateModelSequenceDto[]) {
+        if (!modelSequencesDto || modelSequencesDto.length === 0) {
+            this.logger.debug(`No Model Sequences found to seed`);
+            return;
+        }
+        for (const dto of modelSequencesDto) {
+            await this.modelSequenceRepo.upsertWithDto(dto);
+        }
+    }
 
 }