@solidstarters/solid-core 1.2.191 → 1.2.192

package/src/helpers/solid-registry.ts

@@ -5,7 +5,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext } from "../interfaces";
 
 type ControllerMetadata = {
   name: string;
@@ -66,9 +66,9 @@ export class SolidRegistry {
   private dashboardQuestionDataProviders: Set<InstanceWrapper> = new Set();
   private mailProviders: Set<InstanceWrapper> = new Set();
   private whatsappProviders: Set<InstanceWrapper> = new Set();
+  private securityRuleConfigProviders: Set<InstanceWrapper> = new Set();
   private errorCodeProviders: Set<InstanceWrapper> = new Set();
 
-
   registerErrorCodeProvider(errorCodeProvider: InstanceWrapper): void {
     this.errorCodeProviders.add(errorCodeProvider);
   }
@@ -77,6 +77,10 @@ export class SolidRegistry {
     this.whatsappProviders.add(whatsappProvider);
   }
 
+  registerSecurityRuleConfigProvider(securityRuleConfigProvider: InstanceWrapper): void {
+    this.securityRuleConfigProviders.add(securityRuleConfigProvider);
+  }
+
   registerMailProvider(mailProvider: InstanceWrapper): void {
     this.mailProviders.add(mailProvider);
   }
@@ -129,6 +133,21 @@ export class SolidRegistry {
     return Array.from(this.whatsappProviders);
   }
 
+  getSecurityRuleConfigProviders(): Array<InstanceWrapper> {
+    return Array.from(this.securityRuleConfigProviders);
+  }
+
+  getSecurityRuleConfigProviderInstance(name: string): ISecurityRuleConfigProvider {
+    const securityRuleConfigProviders = this.getSecurityRuleConfigProviders();
+
+    for (let i = 0; i < securityRuleConfigProviders.length; i++) {
+      const securityRuleConfigProvider = securityRuleConfigProviders[i];
+      if (securityRuleConfigProvider.name === name) {
+        return securityRuleConfigProvider.instance;
+      }
+    }
+  }
+
   getSeeders(): Array<InstanceWrapper> {
     return Array.from(this.seeders);
   }

package/src/helpers/user-helper.ts

@@ -0,0 +1,37 @@
+export function getUserExcludedFields(): string[] {
+  return [
+    "passwordScheme",
+    "passwordSchemeVersion",
+    "rehashedAt",
+    "accessCode",
+    "googleAccessCode",
+    "googleAccessToken",
+    "googleId",
+    "active",
+    "forcePasswordChange",
+    "lastLoginProvider",
+    "googleProfilePicture",
+    "forgotPasswordConfirmedAt",
+    "verificationTokenOnForgotPassword",
+    "verificationTokenOnForgotPasswordExpiresAt",
+    "emailVerifiedOnRegistrationAt",
+    "emailVerificationTokenOnRegistration",
+    "emailVerificationTokenOnRegistrationExpiresAt",
+    "mobileVerifiedOnRegistrationAt",
+    "mobileVerificationTokenOnRegistration",
+    "mobileVerificationTokenOnRegistrationExpiresAt",
+    "emailVerifiedOnLoginAt",
+    "emailVerificationTokenOnLogin",
+    "emailVerificationTokenOnLoginExpiresAt",
+    "mobileVerifiedOnLoginAt",
+    "mobileVerificationTokenOnLogin",
+    "mobileVerificationTokenOnLoginExpiresAt",
+    "customPayload",
+    "roles",
+    "rolesIds",
+    "rolesCommand",
+    "userViewMetadata",
+    "userViewMetadataIds",
+    "userViewMetadataCommand",
+  ];
+}

package/src/index.ts

@@ -280,7 +280,6 @@ export * from './factories/mail.factory'
 // Repositories
 export * from './repository/solid-base.repository'
 export * from './repository/security-rule.repository'
-export * from './repository/field.repository'
 export * from './repository/chatter-message.repository'
 export * from './repository/chatter-message-details.repository'
 

package/src/interfaces.ts

@@ -14,6 +14,9 @@ import { ComputedFieldMetadata } from './helpers/solid-registry';
 import { SqlExpression } from './services/question-data-providers/chartjs-sql-data-provider.service';
 import { CreateDashboardDto } from './dtos/create-dashboard.dto';
 import { AiInteraction } from './entities/ai-interaction.entity';
+import { ActiveUserData } from './interfaces/active-user-data.interface';
+import { SecurityRuleConfig } from './dtos/security-rule-config.dto';
+import { SecurityRule } from './entities/security-rule.entity';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -345,3 +348,7 @@ export interface McpComputedProviderResponse {
   plan: PlanStep[];
   // provider?: any;  // (intentionally ignored per your note)
 }
+
+export interface ISecurityRuleConfigProvider {
+  securityRuleConfig(activeUser: ActiveUserData, securityRule: SecurityRule): Promise<SecurityRuleConfig>;
+}

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

@@ -4,13 +4,13 @@ import { QueueMessage } from 'src/interfaces/mq';
 import triggerMcpClientQueueOptions from "./trigger-mcp-client-queue-options";
 import { AiInteractionService } from 'src/services/ai-interaction.service';
 import { PollerService } from 'src/services/poller.service';
-import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
 import { TriggerMcpClientOptions, QueuesModuleOptions } from 'src/interfaces';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { MqMessageService } from 'src/services/mq-message.service';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
 
 @Injectable()
-export class TriggerMcpClientSubscriberRabbitmq extends RabbitMqPublisher<TriggerMcpClientOptions> {
+export class TriggerMcpClientSubscriberRabbitmq extends RabbitMqSubscriber<TriggerMcpClientOptions> {
     private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberRabbitmq.name);
 
     constructor(

package/src/jobs/twilio-sms-subscriber.service.ts

@@ -5,12 +5,12 @@ import { QueueMessage } from 'src/interfaces/mq';
 import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
 import { MqMessageService } from 'src/services/mq-message.service';
 import { PollerService } from 'src/services/poller.service';
-import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
 import { TwilioSMSService } from 'src/services/sms/TwilioSMSService';
 import smsQueueOptions from './twilio-sms-queue-options';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
 
 @Injectable()
-export class TwilioSmsQueueSubscriberRabbitmq extends RabbitMqPublisher<any> {
+export class TwilioSmsQueueSubscriberRabbitmq extends RabbitMqSubscriber<any> {
     constructor(
         private readonly smsService: TwilioSMSService,
         readonly mqMessageService: MqMessageService,

package/src/repository/action-metadata.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { ActionMetadata } from 'src/entities/action-metadata.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';
+
+@Injectable()
+export class ActionMetadataRepository extends SolidBaseRepository<ActionMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ActionMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/ai-interaction.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { AiInteraction } from 'src/entities/ai-interaction.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';
+
+@Injectable()
+export class AiInteractionRepository extends SolidBaseRepository<AiInteraction> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(AiInteraction, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/chatter-message-details.repository.ts

@@ -31,12 +31,12 @@ export class ChatterMessageDetailsRepository extends SolidBaseRepository<Chatter
    *  - left join the polymorphic co-model table using message.co_model_* fields
    *  - (optionally) apply security rules on the co-model alias
    */
-  override createQueryBuilder(
+  override async createSecurityRuleAwareQueryBuilder(
     alias = 'detail',
     queryRunner?: QueryRunner,
-  ): SelectQueryBuilder<ChatterMessageDetails> {
+  ): Promise<SelectQueryBuilder<ChatterMessageDetails>> {
     const activeUser = this.requestContextService.getActiveUser();
-    let qb = super.createQueryBuilder(alias, queryRunner);
+    let qb = await super.createSecurityRuleAwareQueryBuilder(alias, queryRunner);
     if (!activeUser) return qb;
 
     // Example: join the "client" co-model (pass whatever co-model name you need)

package/src/repository/chatter-message.repository.ts

@@ -19,9 +19,9 @@ export class ChatterMessageRepository extends SolidBaseRepository<ChatterMessage
     }
 
     private readonly CO_MODEL_NAME_PATH = 'filters.coModelName.$eq';
-    override createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<ChatterMessage> {
+    override async createSecurityRuleAwareQueryBuilder(alias?: string, queryRunner?: QueryRunner): Promise<SelectQueryBuilder<ChatterMessage>> {
         const activeUserOrUndefined = this.requestContextService.getActiveUser();
-        let qb = super.createQueryBuilder(alias, queryRunner);
+        let qb = await super.createSecurityRuleAwareQueryBuilder(alias, queryRunner);
         if (!activeUserOrUndefined) return qb;
         
         //Left join on the associated chatter model entity

package/src/repository/dashboard-question-sql-dataset-config.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { DashboardQuestionSqlDatasetConfig } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class DashboardQuestionSqlDatasetConfigRepository extends SolidBaseRepository<DashboardQuestionSqlDatasetConfig> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(DashboardQuestionSqlDatasetConfig, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/dashboard-question.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { DashboardQuestion } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class DashboardQuestionRepository extends SolidBaseRepository<DashboardQuestion> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(DashboardQuestion, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/dashboard-variable.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { DashboardVariable } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class DashboardVariableRepository extends SolidBaseRepository<DashboardVariable> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(DashboardVariable, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/dashboard.repository.ts

@@ -1,19 +1,19 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
-import { DashboardVariable } from "src/entities/dashboard-variable.entity";
+import { Injectable } from "@nestjs/common";
 import { Dashboard } from "src/entities/dashboard.entity";
 import { ModuleMetadata } from "src/entities/module-metadata.entity";
-import { DashboardQuestionSqlDatasetConfig } from "src/entities/dashboard-question-sql-dataset-config.entity";
-import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { DataSource, Repository } from "typeorm";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource } from "typeorm";
+import { SecurityRuleRepository } from "./security-rule.repository";
+import { SolidBaseRepository } from "./solid-base.repository";
 
 @Injectable()
-export class DashboardRepository extends Repository<Dashboard> {
-    private readonly logger = new Logger(this.constructor.name);
+export class DashboardRepository extends SolidBaseRepository<Dashboard> {
     constructor(
-        private dataSource: DataSource,
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
     ) {
-        super(Dashboard, dataSource.createEntityManager());
+        super(Dashboard, dataSource, requestContextService, securityRuleRepository);
     }
 
 

package/src/repository/email-template.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { EmailTemplate } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class EmailTemplateRepository extends SolidBaseRepository<EmailTemplate> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(EmailTemplate, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/export-template.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { EmailTemplate, ExportTemplate } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ExportTemplateRepository extends SolidBaseRepository<ExportTemplate> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ExportTemplate, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/export-transaction.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { ExportTransaction } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ExportTransactionRepository extends SolidBaseRepository<ExportTransaction> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ExportTransaction, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/field-metadata.repository.ts

@@ -1,15 +1,17 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
 import { FieldMetadata } from 'src/entities/field-metadata.entity';
-import { DataSource, Repository } from 'typeorm';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
 
 @Injectable()
-export class FieldMetadataRepository extends Repository<FieldMetadata> {
-    private readonly logger = new Logger(FieldMetadataRepository.name);
+export class FieldMetadataRepository extends SolidBaseRepository<FieldMetadata> {
     constructor(
-        dataSource: DataSource,
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
     ) {
-        super(FieldMetadata, dataSource.createEntityManager());
+        super(FieldMetadata, dataSource, null, null);
     }
 
     async findComputedFieldsPopulatedWithModelAndModule() {

package/src/repository/import-transaction-error-log.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { ImportTransactionErrorLog } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ImportTransactionErrorLogRepository extends SolidBaseRepository<ImportTransactionErrorLog> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ImportTransactionErrorLog, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/import-transaction.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { ImportTransaction } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ImportTransactionRepository extends SolidBaseRepository<ImportTransaction> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ImportTransaction, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/list-of-values.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { ListOfValues } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ListOfValuesRepository extends SolidBaseRepository<ListOfValues> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ListOfValues, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/locale.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { Locale } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class LocaleRepository extends SolidBaseRepository<Locale> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(Locale, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/media-storage-provider-metadata.repository.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class MediaStorageProviderMetadataRepository extends SolidBaseRepository<MediaStorageProviderMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MediaStorageProviderMetadata, dataSource, null, null);
+    }
+}

package/src/repository/media.repository.ts

@@ -1,24 +1,30 @@
-import { Repository, DataSource } from 'typeorm';
 import { Injectable } from '@nestjs/common';
 import { Media } from 'src/entities/media.entity';
-import { FieldMetadata } from 'src/entities/field-metadata.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { ModelMetadata } from 'src/entities/model-metadata.entity';
-import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { FieldMetadataRepository } from './field-metadata.repository';
+import { MediaStorageProviderMetadataRepository } from './media-storage-provider-metadata.repository';
+import { ModelMetadataRepository } from './model-metadata.repository';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
 
 @Injectable()
-export class MediaRepository extends Repository<Media> {
+export class MediaRepository extends SolidBaseRepository<Media> {
     constructor(
-        private dataSource: DataSource,
-        @InjectRepository(ModelMetadata)
-        private readonly modelMetadataRepo: Repository<ModelMetadata>,
-        @InjectRepository(MediaStorageProviderMetadata)
-        private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
-        @InjectRepository(FieldMetadata)
-        private readonly fieldMetadataRepo: Repository<FieldMetadata>,
-
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+        // @InjectRepository(FieldMetadata)
+        // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+        // @InjectRepository(ModelMetadata)
+        // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        // @InjectRepository(MediaStorageProviderMetadata)
+        // private readonly mediaStorageProviderMetadataRepo: Repository<MediaStorageProviderMetadata>,
+        private readonly fieldMetadataRepo: FieldMetadataRepository,
+        private readonly modelMetadataRepo: ModelMetadataRepository,
+        private readonly mediaStorageProviderMetadataRepo: MediaStorageProviderMetadataRepository,
     ) {
-        super(Media, dataSource.createEntityManager());
+        super(Media, dataSource, requestContextService, securityRuleRepository);
     }
 
     async createMedia(createDto: any) {

package/src/repository/menu-item-metadata.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { MenuItemMetadata } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class MenuItemMetadataRepository extends SolidBaseRepository<MenuItemMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MenuItemMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { ModelMetadata } from 'src';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ModelMetadataRepository extends SolidBaseRepository<ModelMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModelMetadata, dataSource, null, null);
+    }
+}

package/src/repository/module-metadata.repository.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleMetadata } from 'src';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ModuleMetadataRepository extends SolidBaseRepository<ModuleMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModuleMetadata, dataSource, null, null);
+    }
+}

package/src/repository/mq-message-queue.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { MenuItemMetadata, MqMessageQueue } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class MqMessageQueueRepository extends SolidBaseRepository<MqMessageQueue> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MqMessageQueue, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/mq-message.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { MqMessage } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class MqMessageRepository extends SolidBaseRepository<MqMessage> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MqMessage, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/permission-metadata.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { PermissionMetadata } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class PermissionMetadataRepository extends SolidBaseRepository<PermissionMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(PermissionMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}