@solidxai/core 0.1.10-beta.9 → 0.1.11-beta.0

package/dist/services/model-metadata.service.js

@@ -54,7 +54,6 @@ const typeorm_2 = require("typeorm");
 const model_metadata_entity_1 = require("../entities/model-metadata.entity");
 const module_metadata_entity_1 = require("../entities/module-metadata.entity");
 const lodash_1 = require("lodash");
-const string_helper_1 = require("../helpers/string.helper");
 const error_messages_1 = require("../constants/error-messages");
 const disallow_in_production_decorator_1 = require("../decorators/disallow-in-production.decorator");
 const create_field_metadata_dto_1 = require("../dtos/create-field-metadata.dto");
@@ -63,25 +62,31 @@ const field_metadata_repository_1 = require("../repository/field-metadata.reposi
 const model_metadata_repository_1 = require("../repository/model-metadata.repository");
 const action_metadata_entity_1 = require("../entities/action-metadata.entity");
 const field_metadata_entity_1 = require("../entities/field-metadata.entity");
+const import_transaction_error_log_entity_1 = require("../entities/import-transaction-error-log.entity");
+const import_transaction_entity_1 = require("../entities/import-transaction.entity");
 const menu_item_metadata_entity_1 = require("../entities/menu-item-metadata.entity");
+const user_view_metadata_entity_1 = require("../entities/user-view-metadata.entity");
+const permission_metadata_entity_1 = require("../entities/permission-metadata.entity");
+const role_metadata_entity_1 = require("../entities/role-metadata.entity");
 const view_metadata_entity_1 = require("../entities/view-metadata.entity");
+const command_service_1 = require("../helpers/command.service");
 const schematic_service_1 = require("../helpers/schematic.service");
+const string_helper_1 = require("../helpers/string.helper");
 const crud_helper_service_1 = require("./crud-helper.service");
 const field_metadata_service_1 = require("./field-metadata.service");
 const media_storage_provider_metadata_service_1 = require("./media-storage-provider-metadata.service");
-const role_metadata_service_1 = require("./role-metadata.service");
 const solid_introspect_service_1 = require("./solid-introspect.service");
 const solid_ts_morph_service_1 = require("./solid-ts-morph.service");
 let ModelMetadataService = class ModelMetadataService {
-    constructor(modelMetadataRepo, fieldMetadataRepo, schematicService, dataSource, crudHelperService, mediaStorageProviderMetadataService, fieldMetadataService, roleService, moduleMetadataHelperService, introspectService, solidTsMorphService) {
+    constructor(modelMetadataRepo, fieldMetadataRepo, schematicService, commandService, dataSource, crudHelperService, mediaStorageProviderMetadataService, fieldMetadataService, moduleMetadataHelperService, introspectService, solidTsMorphService) {
         this.modelMetadataRepo = modelMetadataRepo;
         this.fieldMetadataRepo = fieldMetadataRepo;
         this.schematicService = schematicService;
+        this.commandService = commandService;
         this.dataSource = dataSource;
         this.crudHelperService = crudHelperService;
         this.mediaStorageProviderMetadataService = mediaStorageProviderMetadataService;
         this.fieldMetadataService = fieldMetadataService;
-        this.roleService = roleService;
         this.moduleMetadataHelperService = moduleMetadataHelperService;
         this.introspectService = introspectService;
         this.solidTsMorphService = solidTsMorphService;
@@ -92,26 +97,15 @@ let ModelMetadataService = class ModelMetadataService {
     }
     async findMany(basicFilterDto) {
         const alias = 'modelMetadata';
-        let { limit, offset } = basicFilterDto;
-        var qb = await this.modelMetadataRepo.createSecurityRuleAwareQueryBuilder(alias);
-        qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-        const [entities, count] = await qb.getManyAndCount();
-        const currentPage = Math.floor(offset / limit) + 1;
-        const totalPages = Math.ceil(count / limit);
-        const nextPage = currentPage < totalPages ? currentPage + 1 : null;
-        const prevPage = currentPage > 1 ? currentPage - 1 : null;
-        const r = {
-            meta: {
-                totalRecords: count,
-                currentPage: currentPage,
-                nextPage: nextPage,
-                prevPage: prevPage,
-                totalPages: totalPages,
-                perPage: +limit,
-            },
-            records: entities
-        };
-        return r;
+        const { limit, offset } = basicFilterDto;
+        const qb = await this.modelMetadataRepo.createSecurityRuleAwareQueryBuilder(alias);
+        if (basicFilterDto.groupBy?.length) {
+            const groupFilterQb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, undefined, undefined, undefined, crud_helper_service_1.FilterCombinator.AND, false, false);
+            return this.crudHelperService.executeGroupPipeline(groupFilterQb, basicFilterDto, alias, () => this.modelMetadataRepo.createSecurityRuleAwareQueryBuilder(alias));
+        }
+        const filteredQb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+        const [entities, count] = await filteredQb.getManyAndCount();
+        return this.crudHelperService.pagedResponse(offset, limit, count, entities);
     }
     async findOne(id, query) {
         const entity = await this.modelMetadataRepo.findOne({
@@ -256,8 +250,7 @@ let ModelMetadataService = class ModelMetadataService {
                 tableName: model.tableName,
                 userKeyFieldUserKey: model.fields.find(field => field.isUserKey)?.name,
                 isChild: model?.isChild,
-                isLegacyTable: model?.isLegacyTable,
-                isLegacyTableWithId: model?.isLegacyTableWithId,
+                legacyTableType: model?.legacyTableType,
                 parentModelUserKey: model?.parentModel?.singularName,
                 enableAuditTracking: model?.enableAuditTracking,
                 enableSoftDelete: model?.enableSoftDelete,
@@ -422,6 +415,25 @@ let ModelMetadataService = class ModelMetadataService {
             }
         });
         if (existingModelMetadata) {
+            const hasChanges = Object.entries(updateDto).some(([key, value]) => {
+                if (key === 'module' || key === 'parentModel' || key === 'userKeyField') {
+                    return existingModelMetadata[key]?.id !== value?.id;
+                }
+                if (key === 'fields') {
+                    return JSON.stringify(existingModelMetadata.fields ?? null) !== JSON.stringify(value ?? null);
+                }
+                const currentValue = existingModelMetadata[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 existingModelMetadata;
+            }
             const updatedModelMetadata = { ...existingModelMetadata, ...updateDto };
             const updatedModel = await this.modelMetadataRepo.save(updatedModelMetadata);
             return updatedModel;
@@ -470,7 +482,7 @@ let ModelMetadataService = class ModelMetadataService {
             where: {
                 id: modelEntityId,
             },
-            relations: ['module']
+            relations: ['module', 'fields']
         });
         if (!modelEntity) {
             this.logger.log(`Invalid modelEntityId: ${modelEntityId} unable to resolve model metadata`);
@@ -510,21 +522,71 @@ let ModelMetadataService = class ModelMetadataService {
                     this.logger.log(`Deleted file: ${fileToDelete}`);
                 }
                 catch (error) {
+                    if (error?.code === 'ENOENT') {
+                        this.logger.warn(`File already absent, skipping delete: ${fileToDelete}`);
+                        continue;
+                    }
                     this.logger.error(`Error deleting file: ${fileToDelete}`, error);
                 }
             }
         }
-        await this.dataSource.query(`CALL cleanup_model_metadata($1, $2)`, [modelEntity.singularName, true]);
+        const { removedActionNames, removedMenuNames, removedViewNames } = await this.cleanupAssociatedViewsActionsAndMenus(modelEntity.id);
+        await this.cleanupAssociatedImports(modelEntity.id);
+        await this.cleanupAssociatedPermissions(modelEntity.singularName);
+        await this.clearModelReferencesBeforeDelete(modelEntity);
         const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module?.name);
         const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
         if (metaData) {
-            const existingModelIndex = metaData.moduleMetadata.models.findIndex((existingModel) => existingModel.singularName === modelEntity.singularName);
+            const moduleMetadata = metaData?.moduleMetadata ?? metaData;
+            const vamMetadata = Array.isArray(metaData?.views) || Array.isArray(metaData?.actions) || Array.isArray(metaData?.menus)
+                ? metaData
+                : moduleMetadata;
+            const removedActionNameSet = new Set(removedActionNames);
+            const removedMenuNameSet = new Set(removedMenuNames);
+            const removedViewNameSet = new Set(removedViewNames);
+            const existingModels = Array.isArray(moduleMetadata?.models) ? moduleMetadata.models : [];
+            const existingModelIndex = existingModels.findIndex((existingModel) => existingModel.singularName === modelEntity.singularName);
             if (existingModelIndex !== -1) {
-                metaData.moduleMetadata.models.splice(existingModelIndex, 1);
+                existingModels.splice(existingModelIndex, 1);
             }
-            metaData.moduleMetadata.menus = metaData.moduleMetadata?.menus?.filter((menu) => menu.modelUserKey !== modelEntity.singularName);
-            metaData.moduleMetadata.actions = metaData.moduleMetadata?.actions?.filter((action) => action.modelUserKey !== modelEntity.singularName);
-            metaData.moduleMetadata.views = metaData.moduleMetadata?.views?.filter((view) => view.modelUserKey !== modelEntity.singularName);
+            const existingViews = Array.isArray(vamMetadata?.views) ? vamMetadata.views : [];
+            vamMetadata.views = existingViews.filter((view) => {
+                const shouldRemove = view?.modelUserKey === modelEntity.singularName || removedViewNameSet.has(view?.name);
+                if (shouldRemove && view?.name) {
+                    removedViewNameSet.add(view.name);
+                }
+                return !shouldRemove;
+            });
+            const existingActions = Array.isArray(vamMetadata?.actions) ? vamMetadata.actions : [];
+            vamMetadata.actions = existingActions.filter((action) => {
+                const shouldRemove = action?.modelUserKey === modelEntity.singularName ||
+                    removedActionNameSet.has(action?.name) ||
+                    removedViewNameSet.has(action?.viewUserKey);
+                if (shouldRemove && action?.name) {
+                    removedActionNameSet.add(action.name);
+                }
+                return !shouldRemove;
+            });
+            let pendingMenus = Array.isArray(vamMetadata?.menus) ? [...vamMetadata.menus] : [];
+            let menuRemovedOnPass = true;
+            while (menuRemovedOnPass) {
+                menuRemovedOnPass = false;
+                pendingMenus = pendingMenus.filter((menu) => {
+                    const shouldRemove = menu?.modelUserKey === modelEntity.singularName ||
+                        removedMenuNameSet.has(menu?.name) ||
+                        removedActionNameSet.has(menu?.actionUserKey) ||
+                        removedMenuNameSet.has(menu?.parentMenuItemUserKey);
+                    if (shouldRemove) {
+                        if (menu?.name) {
+                            removedMenuNameSet.add(menu.name);
+                        }
+                        menuRemovedOnPass = true;
+                        return false;
+                    }
+                    return true;
+                });
+            }
+            vamMetadata.menus = pendingMenus;
             const updatedContent = JSON.stringify(metaData, null, 2);
             await fs.writeFile(filePath, updatedContent);
         }
@@ -544,6 +606,195 @@ let ModelMetadataService = class ModelMetadataService {
             }
         }
     }
+    async cleanupAssociatedViewsActionsAndMenus(modelId) {
+        const viewRepo = this.dataSource.getRepository(view_metadata_entity_1.ViewMetadata);
+        const actionRepo = this.dataSource.getRepository(action_metadata_entity_1.ActionMetadata);
+        const menuRepo = this.dataSource.getRepository(menu_item_metadata_entity_1.MenuItemMetadata);
+        const userViewRepo = this.dataSource.getRepository(user_view_metadata_entity_1.UserViewMetadata);
+        const views = await viewRepo.find({
+            where: {
+                model: { id: modelId },
+            },
+        });
+        const viewIds = views.map((view) => view.id);
+        const removedViewNames = views.map((view) => view.name).filter(Boolean);
+        const actions = await actionRepo.find({
+            where: [
+                {
+                    model: { id: modelId },
+                },
+                ...(viewIds.length > 0
+                    ? [
+                        {
+                            view: { id: (0, typeorm_2.In)(viewIds) },
+                        },
+                    ]
+                    : []),
+            ],
+            relations: ['view'],
+        });
+        const uniqueActions = Array.from(new Map(actions.map((action) => [action.id, action])).values());
+        const actionIds = uniqueActions.map((action) => action.id);
+        const removedActionNames = uniqueActions.map((action) => action.name).filter(Boolean);
+        const menus = await this.findMenusForActionIds(actionIds);
+        const removedMenuNames = menus.map((menu) => menu.name).filter(Boolean);
+        if (menus.length > 0) {
+            const menuIds = menus.map((menu) => menu.id).filter(Boolean);
+            for (const menu of menus) {
+                if (menu.roles?.length) {
+                    await this.dataSource
+                        .createQueryBuilder()
+                        .relation(menu_item_metadata_entity_1.MenuItemMetadata, 'roles')
+                        .of(menu.id)
+                        .remove(menu.roles.map((role) => role.id));
+                }
+            }
+            if (menuIds.length > 0) {
+                await menuRepo
+                    .createQueryBuilder()
+                    .update(menu_item_metadata_entity_1.MenuItemMetadata)
+                    .set({ parentMenuItem: null })
+                    .where('id IN (:...menuIds)', { menuIds })
+                    .execute();
+                await menuRepo
+                    .createQueryBuilder()
+                    .delete()
+                    .from(menu_item_metadata_entity_1.MenuItemMetadata)
+                    .where('id IN (:...menuIds)', { menuIds })
+                    .execute();
+            }
+            this.logger.log(`Deleted ${menus.length} menu metadata record(s) for model id ${modelId}`);
+        }
+        if (uniqueActions.length > 0) {
+            await actionRepo.remove(uniqueActions);
+            this.logger.log(`Deleted ${uniqueActions.length} action metadata record(s) for model id ${modelId}`);
+        }
+        if (viewIds.length > 0) {
+            const userViews = await userViewRepo.find({
+                where: {
+                    viewMetadata: { id: (0, typeorm_2.In)(viewIds) },
+                },
+                relations: ['viewMetadata'],
+            });
+            if (userViews.length > 0) {
+                await userViewRepo.remove(userViews);
+                this.logger.log(`Deleted ${userViews.length} user view metadata record(s) for model id ${modelId}`);
+            }
+            await viewRepo.remove(views);
+            this.logger.log(`Deleted ${views.length} view metadata record(s) for model id ${modelId}`);
+        }
+        return {
+            removedActionNames,
+            removedMenuNames,
+            removedViewNames,
+        };
+    }
+    async cleanupAssociatedImports(modelId) {
+        const importTransactionRepo = this.dataSource.getRepository(import_transaction_entity_1.ImportTransaction);
+        const importTransactionErrorLogRepo = this.dataSource.getRepository(import_transaction_error_log_entity_1.ImportTransactionErrorLog);
+        const importTransactions = await importTransactionRepo.find({
+            where: {
+                modelMetadata: { id: modelId },
+            },
+        });
+        if (importTransactions.length === 0) {
+            return;
+        }
+        const importTransactionIds = importTransactions.map((transaction) => transaction.id);
+        const importTransactionErrorLogs = await importTransactionErrorLogRepo.find({
+            where: {
+                importTransaction: { id: (0, typeorm_2.In)(importTransactionIds) },
+            },
+            relations: ['importTransaction'],
+        });
+        if (importTransactionErrorLogs.length > 0) {
+            await importTransactionErrorLogRepo.remove(importTransactionErrorLogs);
+            this.logger.log(`Deleted ${importTransactionErrorLogs.length} import transaction error log record(s) for model id ${modelId}`);
+        }
+        await importTransactionRepo.remove(importTransactions);
+        this.logger.log(`Deleted ${importTransactions.length} import transaction record(s) for model id ${modelId}`);
+    }
+    async cleanupAssociatedPermissions(modelSingularName) {
+        const permissionsRepo = this.dataSource.getRepository(permission_metadata_entity_1.PermissionMetadata);
+        const controllerName = `${(0, string_helper_1.classify)(modelSingularName)}Controller`;
+        const permissions = await permissionsRepo
+            .createQueryBuilder('permission')
+            .leftJoinAndSelect('permission.roles', 'role')
+            .where('permission.name LIKE :pattern', { pattern: `${controllerName}.%` })
+            .getMany();
+        if (permissions.length === 0) {
+            return;
+        }
+        for (const permission of permissions) {
+            if (permission.roles?.length) {
+                await this.dataSource
+                    .createQueryBuilder()
+                    .relation(permission_metadata_entity_1.PermissionMetadata, 'roles')
+                    .of(permission.id)
+                    .remove(permission.roles.map((role) => role.id));
+            }
+        }
+        await permissionsRepo.remove(permissions);
+        this.logger.log(`Deleted ${permissions.length} permission metadata record(s) for model '${modelSingularName}'`);
+    }
+    async clearModelReferencesBeforeDelete(modelEntity) {
+        const modelRepo = this.dataSource.getRepository(model_metadata_entity_1.ModelMetadata);
+        const fieldIds = (modelEntity.fields ?? []).map((field) => field.id).filter(Boolean);
+        if (fieldIds.length > 0) {
+            await modelRepo
+                .createQueryBuilder()
+                .update(model_metadata_entity_1.ModelMetadata)
+                .set({ userKeyField: null })
+                .where('user_key_field_id IN (:...fieldIds)', { fieldIds })
+                .execute();
+        }
+        await modelRepo
+            .createQueryBuilder()
+            .update(model_metadata_entity_1.ModelMetadata)
+            .set({ parentModel: null })
+            .where('parent_model_id = :modelId', { modelId: modelEntity.id })
+            .execute();
+    }
+    async findMenusForActionIds(actionIds) {
+        if (!actionIds?.length) {
+            return [];
+        }
+        const menuRepo = this.dataSource.getRepository(menu_item_metadata_entity_1.MenuItemMetadata);
+        const menusById = new Map();
+        const rootMenus = await menuRepo.find({
+            where: {
+                action: { id: (0, typeorm_2.In)(actionIds) },
+            },
+            relations: ['roles', 'action', 'parentMenuItem'],
+        });
+        rootMenus.forEach((menu) => menusById.set(menu.id, menu));
+        let parentIds = rootMenus.map((menu) => menu.id);
+        while (parentIds.length > 0) {
+            const childMenus = await menuRepo.find({
+                where: {
+                    parentMenuItem: { id: (0, typeorm_2.In)(parentIds) },
+                },
+                relations: ['roles', 'action', 'parentMenuItem'],
+            });
+            const nextParentIds = [];
+            for (const childMenu of childMenus) {
+                if (!menusById.has(childMenu.id)) {
+                    menusById.set(childMenu.id, childMenu);
+                    nextParentIds.push(childMenu.id);
+                }
+            }
+            parentIds = nextParentIds;
+        }
+        return Array.from(menusById.values());
+    }
+    async generateCodeViaCtl(modelId) {
+        const model = await this.findOne(modelId);
+        return this.commandService.executeCommandWithArgs({
+            command: 'npx',
+            args: ['@solidxai/solidctl@latest', 'generate', 'model', `--name=${model.singularName}`],
+            cwd: path.join(process.cwd(), '..'),
+        });
+    }
     async handleGenerateCode(options) {
         const affectedModelIds = [], refreshModelCodeOutputLines = [], removeFieldCodeOutputLines = [];
         const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.generateCode(options);
@@ -915,20 +1166,31 @@ let ModelMetadataService = class ModelMetadataService {
             const createdTreeViewAction = actionRepo.create(treeViewActionData);
             existingTreeViewAction = await actionRepo.save(createdTreeViewAction);
         }
-        const adminRole = await this.roleService.findRoleByName('Admin');
+        const roleRepo = this.dataSource.getRepository(role_metadata_entity_1.RoleMetadata);
+        const adminRole = await roleRepo.findOne({
+            where: { name: 'Admin' },
+            select: { id: true, name: true }
+        });
+        if (!adminRole) {
+            throw new common_1.NotFoundException(`Entity #Admin not found`);
+        }
         const menuData = {
             displayName: `${model.displayName}`,
             name: `${model.singularName}-menu-item`,
             sequenceNumber: 1,
             action: existingAction,
             module: resolvedModule,
-            roles: [adminRole],
             parentMenuItemUserKey: ""
         };
         let existingMenu = await menuRepo.findOne({ where: { name: menuData.name } });
         if (!existingMenu) {
             const createdMenu = menuRepo.create(menuData);
-            await menuRepo.save(createdMenu);
+            existingMenu = await menuRepo.save(createdMenu);
+            await menuRepo
+                .createQueryBuilder()
+                .relation(menu_item_metadata_entity_1.MenuItemMetadata, 'roles')
+                .of(existingMenu.id)
+                .add(adminRole.id);
         }
     }
     async generateCode(options) {
@@ -958,11 +1220,11 @@ let ModelMetadataService = class ModelMetadataService {
         const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
         const fieldsForRemoval = model.fields.filter((field) => options.fieldIdsForRemoval.includes(+field.id));
         const removeOutput = await this.executeRemoveFieldsCommand(model, fieldsForRemoval, options.dryRun);
-        fieldsForRemoval.forEach((field) => {
+        for (const field of fieldsForRemoval) {
             if (field.isMarkedForRemoval) {
-                this.fieldMetadataService.delete(field.id);
+                await this.fieldMetadataService.delete(field.id);
             }
-        });
+        }
         const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(model.module.name);
         const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
         const existingModelIndex = metaData.moduleMetadata.models.findIndex((existingModel) => existingModel.singularName === model.singularName);
@@ -986,17 +1248,10 @@ let ModelMetadataService = class ModelMetadataService {
             populate: ["module", "fields", "parentModel", "parentModel.module"]
         };
         const model = options.modelId ? await this.findOne(options.modelId, query) : await this.findOneByUserKey(options.modelUserKey, query.populate);
-        let fieldsForRefresh = model.fields.filter((field) => !field.isMarkedForRemoval);
-        if (options.fieldIdsForRefresh && options.fieldIdsForRefresh.length > 0) {
-            fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldIdsForRefresh.includes(+field.id));
-        }
-        else if (options.fieldNamesForRefresh && options.fieldNamesForRefresh.length > 0) {
-            fieldsForRefresh = fieldsForRefresh.filter((field) => options.fieldNamesForRefresh.includes(field.name));
-        }
-        const refreshOuput = await this.executeRefreshModelCommand(model, fieldsForRefresh, options.dryRun);
+        const refreshOuput = await this.executeRefreshModelCommand(model, options.dryRun);
         return `${refreshOuput}`;
     }
-    async executeRefreshModelCommand(model, fieldsForRefresh, dryRun = false) {
+    async executeRefreshModelCommand(model, dryRun = false) {
         const output = await this.schematicService.executeSchematicCommand(schematic_service_1.REFRESH_MODEL_COMMAND, {
             module: model.module.name,
             model: model.singularName,
@@ -1168,6 +1423,12 @@ __decorate([
     __metadata("design:paramtypes", [Number]),
     __metadata("design:returntype", Promise)
 ], ModelMetadataService.prototype, "remove", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], ModelMetadataService.prototype, "generateCodeViaCtl", null);
 __decorate([
     (0, disallow_in_production_decorator_1.DisallowInProduction)(),
     __metadata("design:type", Function),
@@ -1177,15 +1438,15 @@ __decorate([
 exports.ModelMetadataService = ModelMetadataService = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => model_metadata_repository_1.ModelMetadataRepository))),
-    __param(3, (0, typeorm_1.InjectDataSource)()),
+    __param(4, (0, typeorm_1.InjectDataSource)()),
     __metadata("design:paramtypes", [model_metadata_repository_1.ModelMetadataRepository,
         field_metadata_repository_1.FieldMetadataRepository,
         schematic_service_1.SchematicService,
+        command_service_1.CommandService,
         typeorm_2.DataSource,
         crud_helper_service_1.CrudHelperService,
         media_storage_provider_metadata_service_1.MediaStorageProviderMetadataService,
         field_metadata_service_1.FieldMetadataService,
-        role_metadata_service_1.RoleMetadataService,
         module_metadata_helper_service_1.ModuleMetadataHelperService,
         solid_introspect_service_1.SolidIntrospectService,
         solid_ts_morph_service_1.SolidTsMorphService])