@solidxai/core 0.0.2

package/src/interfaces.ts

@@ -0,0 +1,386 @@
+import { CreateEmailTemplateDto } from 'src/dtos/create-email-template.dto';
+import { CreateSmsTemplateDto } from 'src/dtos/create-sms-template.dto';
+import { SignUpDto } from 'src/dtos/sign-up.dto';
+import { Readable } from 'stream';
+import { CreateMediaStorageProviderMetadataDto } from './dtos/create-media-storage-provider-metadata.dto';
+import { DatasourceType } from './dtos/create-model-metadata.dto';
+import { CreateModuleMetadataDto } from './dtos/create-module-metadata.dto';
+import { CreateRoleMetadataDto } from './dtos/create-role-metadata.dto';
+import { CreateSecurityRuleDto } from './dtos/create-security-rule.dto';
+import { FieldMetadata } from './entities/field-metadata.entity';
+import { Media } from './entities/media.entity';
+import { DashboardQuestion } from './entities/dashboard-question.entity';
+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;
+  // entityManager?: EntityManager;
+  // createDto: any;
+  // files : Array<Express.Multer.File>;
+  validate(
+    dto: any,
+    files: Array<Express.Multer.File>,
+  ): ValidationError[] | Promise<ValidationError[]>;
+  transformForCreate(dto: any, ctxt?: any): any | Promise<any>;
+}
+
+export interface ValidationError {
+  field: string;
+  error: string;
+}
+
+// export interface MediaStorage
+export interface MediaStorageProvider<T> {
+  store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void>;
+  retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
+  // delete(file: string): Promise<void>;
+}
+
+export interface ModuleMetadataConfiguration {
+  moduleMetadata?: CreateModuleMetadataDto,
+  roles?: CreateRoleMetadataDto[],
+  users?: SignUpDto[],
+  actions?: any[],
+  menus?: any[],
+  views?: any[],
+  emailTemplates?: CreateEmailTemplateDto[],
+  smsTemplates?: CreateSmsTemplateDto[],
+  mediaStorageProviders?: CreateMediaStorageProviderMetadataDto[]
+  securityRules?: CreateSecurityRuleDto[],
+  dashboards?: CreateDashboardDto[],
+}
+
+export enum SettingLevel {
+  SystemEnv = 'system-env',
+  SystemAdminReadonly = 'system-admin-readonly',
+  SystemAdminEditable = 'system-admin-editable',
+  InternalUser = "internal-user"
+}
+
+export interface SettingDefinition<T = any> {
+  moduleName: string;
+  key: string;
+  value: T;
+  level: SettingLevel;
+}
+
+// solid-core/settings/settings-provider.interface.ts
+export interface ISettingsProvider {
+  getSettings(): SettingDefinition[];
+}
+
+export interface CodeGenerationOptions {
+  moduleId?: number;
+  moduleUserKey?: string;
+  modelId?: number;
+  modelUserKey?: string;
+  fieldIdsForRemoval?: number[];
+  fieldNamesForRemoval?: string[];
+  dryRun?: boolean;
+  fieldIdsForRefresh?: number[];
+  fieldNamesForRefresh?: string[];
+}
+
+export interface TriggerMcpClientOptions {
+  aiInteractionId: number;
+  moduleName: string;
+}
+
+export interface McpResponse {
+  success: boolean;
+  request: string;
+  response: string;
+  model?: string;
+  tools_invoked?: string[];
+  tool_calls?: any[];
+  duration_ms?: number;
+  errors?: string[];
+  error_trace?: string[];
+  content_type?: string;
+}
+
+export interface ISelectionProviderContext {
+  limit: number;
+  offset: number;
+  formValues: Record<string, any>;
+  // query: string;
+}
+
+export interface ISelectionProviderValues {
+  label: string;
+  value: string;
+}
+
+export interface ISelectionProvider<T extends ISelectionProviderContext> {
+  help(): string;
+
+  name(): string;
+
+  value(optionValue: string, ctxt: T): Promise<ISelectionProviderValues | any>;
+
+  values(query: any, ctxt: T): Promise<readonly ISelectionProviderValues[]>;
+}
+
+export interface IDashboardVariableSelectionProvider<T extends ISelectionProviderContext> extends ISelectionProvider<T> {
+}
+
+export interface IMcpToolResponseHandler {
+  apply(aiInteraction: AiInteraction);
+}
+
+export interface IDashboardQuestionDataProvider<TContext, TData> {
+  help(): string;
+
+  name(): string;
+
+  getData(question: DashboardQuestion, expressions?: SqlExpression[], ctxt?: TContext): Promise<TData[] | TData>;
+}
+
+/**
+ * @deprecated Use `IEntityComputedFieldProvider` instead.
+ */
+export interface IComputedFieldProvider<T> {
+  help(): string;
+
+  name(): string;
+
+  valueType(): string;
+
+  computeValue(dto: any, ctxt: T): Promise<string | number>; // FIXME : Improve the types to make it more specific using generics
+}
+
+export interface IEntityComputedFieldProvider {
+  help(): string;
+
+  name(): string;
+}
+
+export interface IEntityPreComputeFieldProvider<TTriggerEntity, TContext, TValue = void> extends IEntityComputedFieldProvider {
+  preComputeValue(triggerEntity: TTriggerEntity, computedFieldMetadata: ComputedFieldMetadata<TContext>): Promise<TValue>;
+}
+
+export interface IEntityPostComputeFieldProvider<TTriggerEntity, TContext> extends IEntityComputedFieldProvider {
+  postComputeAndSaveValue(triggerEntity: TTriggerEntity, computedFieldMetadata: ComputedFieldMetadata<TContext>): Promise<void>;
+}
+
+export interface ISolidDatabaseModule {
+  name(): string;
+
+  type(): DatasourceType;
+}
+
+export enum EventType {
+  USER_REGISTERED = 'user.registered',
+}
+
+export class EventDetails<T> {
+  constructor(
+    public type: any,
+    public payload: T,
+  ) { }
+}
+
+export interface IMail<TResponse = unknown> {
+  sendEmail(
+    to: string,
+    subject: string,
+    body: string,
+    shouldQueueEmails: boolean,
+    wrapperAttachments?: MailAttachmentWrapper[],
+    attachments?: MailAttachment[],
+    parentEntity?: any,
+    parentEntityId?: any,
+    cc?: string[],
+    bcc?: string[],
+    from?: string,
+  ): Promise<TResponse>;
+
+  sendEmailUsingTemplate(
+    to: string,
+    templateName: string,
+    templateParams: any,
+    shouldQueueEmails: boolean,
+    wrapperAttachments?: MailAttachmentWrapper[],
+    attachments?: MailAttachment[],
+    parentEntity?: any,
+    parentEntityId?: any,
+    cc?: string[],
+    bcc?: string[],
+    from?: string,
+  ): Promise<TResponse>;
+}
+
+export interface ISMS {
+  sendSMS(to: string, body: string, shouldQueueSms: boolean): Promise<any>;
+
+  sendSMSUsingTemplate(
+    to: string,
+    templateName: string,
+    templateParams: any,
+    shouldQueueSms: boolean,
+  ): Promise<any>;
+}
+
+export interface IWhatsAppTransport {
+  sendWhatsAppMessage(
+    to: string,
+    templateId: string,
+    parameters: any,
+    parentEntity?: any,
+    parentEntityId?: any
+  ): Promise<any>;
+}
+
+export interface MailAttachmentWrapper {
+  relativePath?: string;
+  attachment?: MailAttachment;
+}
+
+export interface MailAttachment {
+  filename: string;
+  templatePath?: string; // deprecated
+  templateParams?: any; // deprecated
+  content?: string | Buffer;
+  contentType?: string;
+  path?: string; //Filesystem absolute path or URL. 
+}
+
+export enum BrokerType {
+  RabbitMQ = 'rabbitmq',
+  Database = 'database'
+}
+
+export interface QueuesModuleOptions {
+  name: string;
+  type: BrokerType;
+  queueName: string;
+}
+
+export type MediaWithFullUrl = Media & {
+  _full_url: string;
+};
+
+
+export type ErrorCode = string;
+
+export type ErrorMeta = {
+  message: string;
+  httpStatus?: number;
+};
+
+export type ErrorRule = {
+  /** Canonical error code. Keep them kebab-case for consistency. */
+  code: ErrorCode;
+  /** Higher runs earlier. Defaults to 0 if not provided. */
+  priority?: number;
+  /** Return true if this rule matches the combined error text. */
+  match: (combinedErrorText: string) => boolean;
+  /** Display + HTTP mapping for this code. */
+  meta: ErrorMeta;
+};
+
+export interface IErrorCodeProvider {
+  /** Used for registry identity & logs */
+  name(): string;
+
+  /**
+   * Return all rules this provider contributes.
+   * These will be merged with other providers’ rules, then sorted by priority.
+   */
+  rules(): ReadonlyArray<ErrorRule>;
+
+  /**
+   * Optional fallback meta for codes this provider owns (when called by getMessage/getHttpStatus).
+   * If omitted, the ErrorMapperService will rely on the rule.meta of the first matching rule.
+   */
+  resolve?(code: ErrorCode): ErrorMeta | undefined;
+}
+
+// MCP Tool Related
+
+export type PlanStep = CreateNewFileStep | RegisterNestProviderStep | AddMethodToExistingClassStep | RegisterSolidXExtensionComponentStep | AddListViewButtonStep | AddFormViewButtonStep | AddImportStep;
+export interface AddImportStep {
+  type: "addImport";
+  path: string;                 // e.g. apps/api/src/address-master/services/address-master.service.ts
+  importStatement: string;      // e.g. import { Something } from 'somewhere';
+  overwrite?: boolean;        // default=false
+  rationale?: string;           // optional, ignored by executor
+}
+
+export interface CreateNewFileStep {
+  type: "createNewFile";
+  path: string;         // repo-relative e.g. solid-api/api/src/computed-providers/foo.provider.ts
+  content: string;      // full file content
+  overwrite?: boolean;  // default=false
+  rationale?: string;   // optional, ignored by executor
+}
+
+export interface RegisterNestProviderStep {
+  type: "registerNestProvider";
+  modulePath: string;           // e.g. apps/api/src/address-master/address-master.module.ts
+  providerClassName: string;    // e.g. StateTotalCitiesComputedFieldProvider
+  importFrom: string;           // e.g. "@/computed-providers/state-total-cities.provider"
+  registerIn: Array<"providers" | "exports">; // which arrays to add to
+  uniqueGuard?: boolean;        // default=true
+  rationale?: string;           // optional, ignored by executor
+}
+
+export interface AddMethodToExistingClassStep {
+  type: "addMethodToExistingClass";
+  path: string;                 // e.g. apps/api/src/address-master/services/address-master.service.ts
+  className: string             // e.g. CountryService
+  methodName: string            // e.g. addCountry
+  content: string               // Full Method Code
+  importStatements?: string[];  // e.g. [ "import { X } from 'y';" ]
+  rationale?: string;           // optional, ignored by executor
+}
+
+export interface RegisterSolidXExtensionComponentStep {
+  type: "registerSolidXExtensionComponent";
+  path: string;                 // e.g. apps/api/src/address-master/services/address-master.service.ts
+  content?: string;               // Code
+  importExtensionComponent?: string;
+}
+
+export interface AddListViewButtonStep {
+  type: "addListViewButton";
+  moduleName?: string;
+  modelName?: string;
+  buttonType?: string;
+  content?: string;            // Code
+}
+
+export interface AddFormViewButtonStep {
+  type: "addFormViewButton";
+  moduleName?: string;
+  modelName?: string;
+  buttonType?: string;
+  content?: string;            // Code
+}
+
+export interface McpComputedProviderResponse {
+  plan: PlanStep[];
+  // provider?: any;  // (intentionally ignored per your note)
+}
+
+export interface ISecurityRuleConfigProvider {
+  securityRuleConfig(activeUser: ActiveUserData, securityRule: SecurityRule): Promise<SecurityRuleConfig>;
+}
+
+
+export interface AwsS3Config {
+  S3_AWS_ACCESS_KEY: string;
+  S3_AWS_SECRET_KEY: string;
+  S3_AWS_REGION_NAME: string;
+}
+
+// Prevents inference so callers must provide explicit type arguments; reusable for other APIs.
+export type NoInfer<T> = [T][T extends any ? 0 : never];

package/src/jobs/api-email-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import mailQueueOptions from './api-email-queue-options';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+@Injectable()
+export class ApiEmailQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...mailQueueOptions
+        }
+    }
+}

package/src/jobs/api-email-queue-options.ts

@@ -0,0 +1,14 @@
+import { QueueMessage } from 'src/interfaces/mq';
+import { BrokerType } from "../interfaces";
+
+const API_MAIL_QUEUE_NAME = 'api_mail_queue';
+
+export default {
+    name: 'apiMailInstance',
+    type: BrokerType.RabbitMQ,
+    queueName: API_MAIL_QUEUE_NAME,
+    // receive: async (message: QueueMessage<any>) => { // Default receive handler
+    //     console.log(`Received message: ${JSON.stringify(message)} from queue ${MAIL_QUEUE_NAME}`);
+    //     return 'Received';
+    // },
+};

package/src/jobs/api-email-subscriber.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import mailQueueOptions from './api-email-queue-options';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { ElasticEmailService } from '../services/mail/elastic-email.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+@Injectable()
+export class ApiEmailQueueSubscriber extends RabbitMqSubscriber<any> {
+    constructor(
+        private readonly emailService: ElasticEmailService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...mailQueueOptions
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.emailService.sendEmailSynchronously(message);
+    }
+}

package/src/jobs/chatter-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../interfaces";
+
+const QUEUE_NAME = 'chatter_queue';
+
+export default {
+    name: 'queueChatter',
+    type: BrokerType.RabbitMQ,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/chatter-queue-publisher.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import chatterQueueOptions from './chatter-queue-options';
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { MqMessageService } from '../services/mq-message.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+
+export type ChatterEventType = 'insert' | 'update' | 'delete';
+
+export interface ChatterMessagePayload {
+    eventType: ChatterEventType;
+    model: string;         // entity name
+    entityId: string;      // id string
+    occurredAt: string;    // ISO
+    before?: any;
+    after?: any;
+    diff?: string[];       // changed column names for updates
+    userId?: string | null;
+}
+
+@Injectable()
+export class ChatterQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptions
+        }
+    }
+}

package/src/jobs/chatter-queue-subscriber.service.ts

@@ -0,0 +1,46 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageService } from '../services/mq-message.service';
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+import chatterQueueOptions from './chatter-queue-options';
+import { ChatterMessagePayload } from './chatter-queue-publisher.service';
+import { ChatterMessageService } from 'src/services/chatter-message.service';
+
+@Injectable()
+export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
+    private readonly chatterQueueLogger = new Logger(ChatterQueueSubscriber.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly chatterMessageService: ChatterMessageService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptions
+        }
+    }
+
+    async subscribe(message: QueueMessage<ChatterMessagePayload>) {
+        const p = message.payload;
+        this.chatterQueueLogger.debug(`Audit event ${p.eventType} ${p.model}#${p.entityId}`);
+
+        switch (p.eventType) {
+            case 'insert':
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.model } as any);
+                break;
+            case 'update':
+                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.model } as any, p.before, (p.diff || []).map(n => ({ propertyName: n })));
+                break;
+            case 'delete':
+                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.model } as any, p.before);
+                break;
+        }
+    }
+}

package/src/jobs/computed-field-evaluation-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { QueuesModuleOptions } from "src/interfaces";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { RabbitMqPublisher } from "src/services/queues/rabbitmq-publisher.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationPublisherRabbitmq extends RabbitMqPublisher<ComputedFieldEvaluationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        };
+    }
+}

package/src/jobs/computed-field-evaluation-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../interfaces";
+
+const QUEUE_NAME = 'computed_field_evaluation_queue';
+
+export default {
+    name: 'computedFieldEvaluationQueue',
+    type: BrokerType.RabbitMQ,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/computed-field-evaluation-subscriber.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "src/interfaces";
+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 { RabbitMqSubscriber } from "src/services/queues/rabbitmq-subscriber.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscriber<ComputedFieldEvaluationPayload> {
+    private readonly _logger = new Logger(ComputedFieldEvaluationSubscriberRabbitmq.name);
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly solidRegistry: SolidRegistry,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        }
+    }
+
+    // This method will use the ComputedFieldEvaluationPayload to evaluate the computed fields
+    // It will then call the corresponding provider computeAndSave method to perform the evaluation
+    async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
+        const { databaseEntity, ...computedFieldMetadata } = message.payload;
+        const { computedFieldValueProviderName } = computedFieldMetadata;
+        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldValueProviderName);
+        // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
+        const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider
+        if (typeof providerInstance.postComputeAndSaveValue !== 'function') {
+            this._logger.warn(`Provider "${computedFieldValueProviderName}" does not implement postComputeAndSaveValue; skipping post-compute.`);
+            return;
+        }
+        await providerInstance.postComputeAndSaveValue(databaseEntity, {
+            ...computedFieldMetadata,
+            computedFieldValueProviderCtxt: {
+                ...(computedFieldMetadata.computedFieldValueProviderCtxt || {}),
+            },
+        }); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+    }
+}

package/src/jobs/database/api-email-publisher-database.service.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import mailQueueOptions from './api-email-queue-options-database';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+
+
+@Injectable()
+export class ApiEmailQueuePublisherDatabase extends DatabasePublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...mailQueueOptions
+        }
+    }
+}

package/src/jobs/database/api-email-queue-options-database.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const API_MAIL_QUEUE_NAME = 'api_mail_queue_database';
+
+export default {
+    name: 'apiMailInstance',
+    type: BrokerType.Database,
+    queueName: API_MAIL_QUEUE_NAME,
+};