@solidxai/core 0.1.10-beta.24 → 0.1.10-beta.26

package/src/helpers/module-metadata-helper.service.ts

@@ -37,21 +37,30 @@ export class ModuleMetadataHelperService {
         return path.resolve(process.cwd(), 'src', moduleName);
     }
 
-    async getModuleMetadataFilePath(moduleName: string): Promise<string> {
+    async getSolidUiModulePath(moduleName: string): Promise<string> {
         if (!moduleName) {
             return '';
         }
+
+        const dashModuleName = kebabCase(moduleName);
+        return path.resolve(process.cwd(), '..', 'solid-ui', 'src', dashModuleName);
+    }
+
+    private resolveModuleMetadataFolderPath(moduleName: string): string {
         const dashModuleName = kebabCase(moduleName);
-        const folderPath = path.resolve(process.cwd(), 'module-metadata', dashModuleName);
-        const filePath = path.join(folderPath, `${dashModuleName}-metadata.json`);
+        return path.resolve(process.cwd(), 'src', dashModuleName, 'metadata');
+    }
 
-        // Check if filePath exists
-        const fileExists = await this.fileService.exists(filePath);
-        if (fileExists) {
-            return filePath;
+    async getModuleMetadataFilePath(moduleName: string): Promise<string> {
+        if (!moduleName) {
+            return '';
         }
+        const dashModuleName = kebabCase(moduleName);
+        const filePath = path.join(
+            this.resolveModuleMetadataFolderPath(dashModuleName),
+            `${dashModuleName}-metadata.json`,
+        );
 
-        // If the module is solid-core, try the fallback path, in case the current root directory is the solid core project
         if (dashModuleName === SOLID_CORE_MODULE_NAME) {
             const fallbackPath = path.resolve(process.cwd(), 'src', 'seeders', 'seed-data', `${dashModuleName}-metadata.json`);
             const fallbackExists = await this.fileService.exists(fallbackPath);
@@ -68,25 +77,14 @@ export class ModuleMetadataHelperService {
             }
         }
 
-        this.logger.error(`Module metadata file not found for module: ${moduleName} at path: ${filePath}`);
-        return '';
+        return filePath;
     }
 
     async getModuleMetadataFolderPath(moduleName: string): Promise<string> {
         if (!moduleName) {
             return '';
         }
-
-        const dashModuleName = kebabCase(moduleName);
-
-        const folderPath = path.resolve(
-            process.cwd(),
-            'module-metadata',
-            dashModuleName,
-        );
-
-        const exists = await this.fileService.exists(folderPath);
-        return exists ? folderPath : '';
+        return this.resolveModuleMetadataFolderPath(moduleName);
     }
 
 }

package/src/helpers/module.helper.ts

@@ -38,26 +38,29 @@ export const getDynamicModuleNames = (): string[] => {
 export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
   const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
 
-  // Find a path that is ../${srcPath}/module-metadata save it in a variable.
-  // const srcPath = path.join(process.cwd(), 'src');
-  const moduleMetadataPath = path.join(process.cwd(), 'module-metadata');
+  const srcPath = path.join(process.cwd(), 'src');
   const coreModuleNames = getCoreModuleNames();
   const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
 
-  // if module-metadata path does not exist, return empty array
-  if (!fs.existsSync(moduleMetadataPath)) {
-    logger.warn(`Module metadata path does not exist: ${moduleMetadataPath}`);
+  if (!fs.existsSync(srcPath)) {
+    logger.warn(`Source path does not exist: ${srcPath}`);
     return [];
   }
 
-  const moduleMetadataDirectories = fs.readdirSync(moduleMetadataPath, { withFileTypes: true });
-  const enabledModules = moduleMetadataDirectories
+  const moduleDirectories = fs.readdirSync(srcPath, { withFileTypes: true });
+  const enabledModules = moduleDirectories
     .filter(dirent => {
       const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
 
       if (!isValidDirectory) return false;
 
-      const fullPath = path.join(moduleMetadataPath, dirent.name, `${dirent.name}-metadata.json`);
+      const moduleManifestPath = path.join(srcPath, dirent.name, `${dirent.name}.module.ts`);
+      const moduleManifestStats = fs.statSync(moduleManifestPath, { throwIfNoEntry: false });
+      if (!moduleManifestStats || !moduleManifestStats.isFile()) {
+        return false;
+      }
+
+      const fullPath = path.join(srcPath, dirent.name, 'metadata', `${dirent.name}-metadata.json`);
 
       const stats = fs.statSync(fullPath, { throwIfNoEntry: false });
       return !!stats && stats.isFile();

package/src/helpers/typeorm-migration-helpers.ts

@@ -0,0 +1,163 @@
+import { QueryRunner } from 'typeorm';
+
+export async function addColumnIfNotExists(
+  queryRunner: QueryRunner,
+  table: string,
+  column: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF COL_LENGTH('${table}', '${column}') IS NULL
+BEGIN
+    ${ddl}
+END
+  `);
+}
+
+export async function createUniqueIndexIfNotExists(
+  queryRunner: QueryRunner,
+  table: string,
+  indexName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF NOT EXISTS (
+  SELECT 1
+  FROM sys.indexes
+  WHERE name = '${indexName}'
+    AND object_id = OBJECT_ID('${table}')
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function addConstraintIfNotExists(
+  queryRunner: QueryRunner,
+  constraintName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF NOT EXISTS (
+  SELECT 1 FROM sys.objects
+  WHERE name = '${constraintName}'
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function dropColumnIfExists(
+  queryRunner: QueryRunner,
+  table: string,
+  column: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF COL_LENGTH('${table}', '${column}') IS NOT NULL
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function dropUniqueIndexIfExists(
+  queryRunner: QueryRunner,
+  table: string,
+  indexName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF EXISTS (
+  SELECT 1
+  FROM sys.indexes
+  WHERE name = '${indexName}'
+    AND object_id = OBJECT_ID('${table}')
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function dropConstraintIfExists(
+  queryRunner: QueryRunner,
+  constraintName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF EXISTS (
+  SELECT 1 FROM sys.objects
+  WHERE name = '${constraintName}'
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function createTableIfNotExists(
+  queryRunner: QueryRunner,
+  table: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF OBJECT_ID('${table}', 'U') IS NULL
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function dropTableIfExists(
+  queryRunner: QueryRunner,
+  table: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF OBJECT_ID('${table}', 'U') IS NOT NULL
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function createIndexIfNotExists(
+  queryRunner: QueryRunner,
+  table: string,
+  indexName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF NOT EXISTS (
+  SELECT 1
+  FROM sys.indexes
+  WHERE name = '${indexName}'
+    AND object_id = OBJECT_ID('${table}')
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}
+
+export async function dropIndexIfExists(
+  queryRunner: QueryRunner,
+  table: string,
+  indexName: string,
+  ddl: string,
+): Promise<void> {
+  await queryRunner.query(`
+IF EXISTS (
+  SELECT 1
+  FROM sys.indexes
+  WHERE name = '${indexName}'
+    AND object_id = OBJECT_ID('${table}')
+)
+BEGIN
+  ${ddl}
+END
+  `);
+}

package/src/index.ts

@@ -110,6 +110,9 @@ export * from './dtos/create-user-activity-history.dto'
 export * from './dtos/update-user-activity-history.dto'
 export * from './dtos/dashboard-variable-options-query.dto'
 export * from './dtos/dashboard-widget-data-request.dto'
+export * from './dtos/metadata-explorer-references-query.dto'
+export * from './dtos/metadata-explorer-search-query.dto'
+export * from './dtos/metadata-explorer-write.dto'
 export * from './dtos/create-dashboard-user-layout.dto'
 export * from './dtos/update-dashboard-user-layout.dto'
 
@@ -200,6 +203,7 @@ export * from './helpers/model-metadata-helper.service'
 export * from './helpers/image-encoding.helper'
 export * from './helpers/solid-microservice-adapter.service'
 export * from './helpers/typeorm-db-helper';
+export * from './helpers/typeorm-migration-helpers';
 
 export * from './services/crud.service'
 export * from './interceptors/logging.interceptor'
@@ -298,7 +302,9 @@ export * from './services/mediaStorageProviders/file-storage-provider'
 export * from './services/mediaStorageProviders/index'
 export * from './services/menu-item-metadata.service'
 export * from './services/model-metadata.service'
+export * from './services/module-metadata-explorer.service'
 export * from './services/module-metadata.service'
+export * from './services/module-package.service'
 export * from './services/mq-message-queue.service'
 export * from './services/mq-message.service'
 export * from './services/agent-session.service'
@@ -332,6 +338,8 @@ export * from './services/setting.service'
 export * from './services/encryption.service'
 export * from './services/info.service'
 export * from './controllers/info.controller'
+export * from './controllers/module-metadata-explorer.controller'
+export * from './controllers/module-package.controller'
 export * from './services/settings/default-settings-provider.service'
 export * from './services/security-rule.service'
 export * from './services/request-context.service'

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

@@ -95,14 +95,19 @@ export class ModuleMetadataSeederService {
         let currentModule = 'global';
         let currentStep = 'bootstrap';
         let modulesToSeed: string[] | null = null;
+        const shouldSeedGlobalMetadata = conf?.seedGlobalMetadata !== false;
 
         try {
             this.enablePruning = Boolean(conf?.pruneMetadata);
             console.log(this.enablePruning ? '▶ Pruning enabled: metadata not present in JSON will be removed.' : '▶ Pruning disabled: existing metadata will be kept.');
 
             // Global seeding steps i.e across all modules
-            currentStep = 'seedGlobalMetadata';
-            await this.seedGlobalMetadata();
+            if (shouldSeedGlobalMetadata) {
+                currentStep = 'seedGlobalMetadata';
+                await this.seedGlobalMetadata();
+            } else {
+                this.logger.log(`Skipping global metadata seeding.`);
+            }
 
             // Module specific seeding steps.
             // Get all the module metadata files which needs to be seeded.
@@ -139,6 +144,11 @@ export class ModuleMetadataSeederService {
                 const moduleMetadata: CreateModuleMetadataDto = 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}`);
 
@@ -242,33 +252,33 @@ export class ModuleMetadataSeederService {
 
     private async seedScheduledJobs(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing scheduled jobs for ${moduleMetadata.name}`);
-        const scheduledJobs: CreateScheduledJobDto[] = overallMetadata.scheduledJobs;
+        const scheduledJobs = this.getSeedArray<CreateScheduledJobDto>(overallMetadata?.scheduledJobs);
         const pruned = this.enablePruning ? await this.pruneScheduledJobs(scheduledJobs, moduleMetadata.name) : 0;
-        if (scheduledJobs?.length > 0) {
+        if (scheduledJobs.length > 0) {
             await this.handleSeedScheduledJobs(scheduledJobs);
         }
         this.logger.debug(`[End] Processing scheduled jobs for ${moduleMetadata.name}`);
-        return { pruned, upserted: scheduledJobs?.length ?? 0 };
+        return { pruned, upserted: scheduledJobs.length };
     }
 
     private async seedSavedFilters(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing saved filters for ${moduleMetadata.name}`);
-        const savedFilters: CreateSavedFiltersDto[] = overallMetadata.savedFilters;
+        const savedFilters = this.getSeedArray<CreateSavedFiltersDto>(overallMetadata?.savedFilters);
         const pruned = this.enablePruning ? await this.pruneSavedFilters(savedFilters, moduleMetadata.name) : 0;
-        if (savedFilters?.length > 0) {
+        if (savedFilters.length > 0) {
             await this.handleSeedSavedFilters(savedFilters);
         }
         this.logger.debug(`[End] Processing saved filters for ${moduleMetadata.name}`);
-        return { pruned, upserted: savedFilters?.length ?? 0 };
+        return { pruned, upserted: savedFilters.length };
     }
 
     private async seedListOfValues(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing List Of Values for ${moduleMetadata.name}`);
-        const listOfValues: CreateListOfValuesDto[] = overallMetadata.listOfValues;
+        const listOfValues = this.getSeedArray<CreateListOfValuesDto>(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}`);
-        return { pruned, upserted: listOfValues?.length ?? 0 };
+        return { pruned, upserted: listOfValues.length };
     }
 
     private async setupDefaultRolesWithPermissions() {
@@ -286,11 +296,11 @@ export class ModuleMetadataSeederService {
 
     private async seedSecurityRules(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing security rules`);
-        const securityRules: CreateSecurityRuleDto[] = overallMetadata.securityRules;
+        const securityRules = this.getSeedArray<CreateSecurityRuleDto>(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`);
-        return { pruned, upserted: securityRules?.length ?? 0 };
+        return { pruned, upserted: securityRules.length };
     }
 
     // Ok
@@ -302,75 +312,85 @@ export class ModuleMetadataSeederService {
 
     private async seedSmsTemplates(overallMetadata: any, moduleName: string): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing sms templates`);
-        const smsTemplates: CreateSmsTemplateDto[] = overallMetadata.smsTemplates;
+        const smsTemplates = this.getSeedArray<CreateSmsTemplateDto>(overallMetadata?.smsTemplates);
         await this.handleSeedSmsTemplates(smsTemplates, moduleName);
         this.logger.debug(`[End] Processing sms templates`);
-        return { pruned: 0, upserted: smsTemplates?.length ?? 0 };
+        return { pruned: 0, upserted: smsTemplates.length };
     }
 
     // OK
     private async seedEmailTemplates(overallMetadata: any, moduleName: string): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing email templates`);
-        const emailTemplates: CreateEmailTemplateDto[] = overallMetadata.emailTemplates;
+        const emailTemplates = this.getSeedArray<CreateEmailTemplateDto>(overallMetadata?.emailTemplates);
         await this.handleSeedEmailTemplates(emailTemplates, moduleName);
         this.logger.debug(`[End] Processing email templates`);
-        return { pruned: 0, upserted: emailTemplates?.length ?? 0 };
+        return { pruned: 0, upserted: emailTemplates.length };
     }
 
     // Ok
     private async seedMenus(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing menus`);
-        const menus = overallMetadata.menus;
+        const menus = this.getSeedArray<any>(overallMetadata?.menus);
         const pruned = this.enablePruning ? await this.pruneMenus(menus, overallMetadata?.moduleMetadata?.name) : 0;
         await this.handleSeedMenus(menus);
         this.logger.debug(`[End] Processing menus`);
-        return { pruned, upserted: menus?.length ?? 0 };
+        return { pruned, upserted: menus.length };
     }
 
     // Ok
     private async seedActions(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing actions`);
-        const actions = overallMetadata.actions;
+        const actions = this.getSeedArray<any>(overallMetadata?.actions);
         const pruned = this.enablePruning ? await this.pruneActions(actions, overallMetadata?.moduleMetadata?.name) : 0;
         await this.handleSeedActions(actions);
         this.logger.debug(`[End] Processing actions`);
-        return { pruned, upserted: actions?.length ?? 0 };
+        return { pruned, upserted: actions.length };
     }
 
     // Ok
     private async seedViews(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing views`);
-        const views = overallMetadata.views;
+        const views = this.getSeedArray<any>(overallMetadata?.views);
         const pruned = this.enablePruning ? await this.pruneViews(views, overallMetadata?.moduleMetadata?.name) : 0;
         await this.handleSeedViews(views);
         this.logger.debug(`[End] Processing views`);
-        return { pruned, upserted: views?.length ?? 0 };
+        return { pruned, upserted: views.length };
     }
 
     // Ok
     private async seedUsers(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing users`);
-        const users = overallMetadata.users;
+        const users = this.getSeedArray<SignUpDto>(overallMetadata?.users);
         // usersDetail = users;
         await this.handleSeedUsers(users);
         this.logger.debug(`[End] Processing users`);
-        return { pruned: 0, upserted: users?.length ?? 0 };
+        return { pruned: 0, upserted: users.length };
     }
 
     // OK
     private async seedRoles(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing roles`);
+        const roles = this.getSeedArray<CreateRoleMetadataDto>(overallMetadata?.roles);
         // While creating roles we are only passing the role name to be used. 
-        await this.roleService.createRolesIfNotExists(overallMetadata.roles.map(role => { return { name: role.name }; }));
+        await this.roleService.createRolesIfNotExists(
+            roles
+                .filter((role) => role?.name)
+                .map((role) => ({ name: role.name } as any)),
+        );
         // After roles are created, we iterate over all roles and attach permissions (if specified in the seeder json) to the respective role.
         // Every role configuration in the seeder json can optionally have a permissions attribute. 
-        for (const role of overallMetadata.roles) {
+        for (const role of roles) {
             if (role.permissions) {
-                await this.roleService.addPermissionsToRole(role.name, role.permissions);
+                await this.roleService.addPermissionsToRole(
+                    role.name,
+                    role.permissions
+                        .map((permission: any) => typeof permission === 'string' ? permission : permission?.name)
+                        .filter(Boolean),
+                );
             }
         }
         this.logger.debug(`[End] Processing roles`);
-        return { pruned: 0, upserted: overallMetadata.roles?.length ?? 0 };
+        return { pruned: 0, upserted: roles.length };
     }
 
     private async seedPermissions(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
@@ -388,7 +408,7 @@ export class ModuleMetadataSeederService {
         // const enabledModules = getDynamicModuleNames();
         const enabledModules = getDynamicModuleNamesBasedOnMetadata();
         for (const enabledModule of enabledModules) {
-            const enabledModuleSeedFile = `module-metadata/${enabledModule}/${enabledModule}-metadata.json`;
+            const enabledModuleSeedFile = `src/${enabledModule}/metadata/${enabledModule}-metadata.json`;
             const fullPath = path.join(process.cwd(), enabledModuleSeedFile);
 
             if (fs.existsSync(fullPath)) {
@@ -489,22 +509,23 @@ export class ModuleMetadataSeederService {
     // OK
     private async seedMediaStorageProviders(mediaStorageProviders: any[]): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing Media Storage Provider`);
+        const providers = this.getSeedArray<any>(mediaStorageProviders);
 
-        for (let i = 0; i < mediaStorageProviders.length; i++) {
-            const mediaStorageProvider = mediaStorageProviders[i];
+        for (let i = 0; i < providers.length; i++) {
+            const mediaStorageProvider = providers[i];
             await this.mediaStorageProviderMetadataService.upsert(mediaStorageProvider);
         }
         this.logger.debug(`[End] Processing Media Storage Provider`);
-        return { pruned: 0, upserted: mediaStorageProviders?.length ?? 0 };
+        return { pruned: 0, upserted: providers.length };
     }
 
     private async seedModelSequences(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         this.logger.debug(`[Start] Processing model sequences`);
-        const modelSequences: CreateModelSequenceDto[] = overallMetadata.modelSequences;
+        const modelSequences = this.getSeedArray<CreateModelSequenceDto>(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`);
-        return { pruned, upserted: modelSequences?.length ?? 0 };
+        return { pruned, upserted: modelSequences.length };
     }
 
     // OK
@@ -558,7 +579,7 @@ export class ModuleMetadataSeederService {
             }
             else {
                 // Check if file exists
-                const emailTemplateHandlebar = `module-metadata/${moduleName}/email-templates/${emailTemplate.body}`
+                const emailTemplateHandlebar = `src/${moduleName}/metadata/email-templates/${emailTemplate.body}`
                 const fullPath = path.join(process.cwd(), emailTemplateHandlebar);
                 // this.logger.log(`Seeding custom email template from consuming model at path: ${fullPath}`);
                 if (fs.existsSync(fullPath)) {
@@ -624,7 +645,7 @@ export class ModuleMetadataSeederService {
             }
             else {
                 // Check if file exists
-                const emailTemplateHandlebar = `module-metadata/${moduleName}/sms-templates/${smsTemplate.body}`
+                const emailTemplateHandlebar = `src/${moduleName}/metadata/sms-templates/${smsTemplate.body}`
                 const fullPath = path.join(process.cwd(), emailTemplateHandlebar);
                 // this.logger.log(`Seeding custom sms template from consuming model at path: ${fullPath}`);
                 if (fs.existsSync(fullPath)) {
@@ -827,8 +848,8 @@ export class ModuleMetadataSeederService {
         let upserted = 1;
 
         // Next create all the models. 
-        const modelsMetadata: CreateModelMetadataDto[] = moduleMetadata.models;
-        upserted += modelsMetadata?.length ?? 0;
+        const modelsMetadata = this.getSeedArray<CreateModelMetadataDto>(moduleMetadata?.models);
+        upserted += modelsMetadata.length;
         for (let j = 0; j < modelsMetadata.length; j++) {
             const modelMetadata = modelsMetadata[j];
 
@@ -882,6 +903,10 @@ export class ModuleMetadataSeederService {
         return { pruned, upserted };
     }
 
+    private getSeedArray<T>(value: T[] | null | undefined): T[] {
+        return Array.isArray(value) ? value : [];
+    }
+
     private async handleSeedSecurityRules(rulesDto: CreateSecurityRuleDto[]) {
         if (!rulesDto || rulesDto.length === 0) {
             this.logger.debug(`No security rules found to seed`);

package/src/seeders/module-test-data.service.ts

@@ -196,7 +196,7 @@ export class ModuleTestDataService {
     const testDataFiles = [typedSolidCoreMetadata];
     const enabledModules = getDynamicModuleNamesBasedOnMetadata();
     for (const enabledModule of enabledModules) {
-      const enabledModuleSeedFile = `module-metadata/${enabledModule}/${enabledModule}-metadata.json`;
+      const enabledModuleSeedFile = `src/${enabledModule}/metadata/${enabledModule}-metadata.json`;
       const fullPath = path.join(process.cwd(), enabledModuleSeedFile);
 
       if (fs.existsSync(fullPath)) {