Mosu Backend Framework

A modern, modular backend framework built on NestJS for scalable microservices architecture. This framework provides standardized modules for common backend functionality including messaging, caching, and database operations.

Introduction

The Mosu Backend Framework is designed to accelerate development of microservices by providing pre-built, configurable modules for common backend requirements. The framework has recently undergone significant updates:

• Messaging: Kafka for more scalable and resilient message processing
• Caching: Dragonfly for improved performance and memory efficiency
• Analytics: ClickHouse for high-performance data analytics and time-series storage

Each module follows a consistent pattern with async configuration options, making them easy to integrate into any NestJS application.

Bucket Module

Module Registration

import { BucketModule } from '@mosu/be-framework';

@Module({
  imports: [
    BucketModule.forRootAsync({
        imports: [AppConfigModule],
        inject: [AppConfigService],
        useFactory: (config: AppConfigService) => ({
            provider: 'minio',
            endpoint: config.bucketEndpoint,
            cdnEndpoint: bucketCdnEndpoint,
            key: config.bucketKey,
            secret: config.bucketSecret,
            defaultConf: {
                defaultBucket: config.bucketDefaultBucket,
                defaultPrefix: config.bucketDefaultPrefix,
            },
            env: config.env,
        }),
    }),
 ]
})
export class AppModule {}

Available Methods

• getSignedUrl(key: string, options: SignedUrlOptions): Promise<string>
• getSignedPutUrl(key: string, options: SignedUrlOptions): Promise<string>
• upload(key: string, content: string | Buffer, options: UploadOptions): Promise<string>
• delete(key: string, options: SignedUrlOptions): Promise<string>
• buildUrl(key: string): string

Dragonfly Cache Module

Module Registration

import { DragonflyModule } from '@mosu/be-framework';

@Module({
  imports: [
    DragonflyModule.forRootAsync({
        imports: [AppConfigModule],
        inject: [AppConfigService],
        useFactory: (config: AppConfigService) => ({
            url: config.redisUrl, // Works with both Redis and Dragonfly servers
            ttl: 5 * 60 * 1000, // 5 minutes
            maxReconnectAttempts: 5,
            reconnectDelay: 5000, // 5 seconds
            pingInterval: 5000, // 5 seconds
            crashOnConnectFailure: true,
        }),
    }),
  ],
})
export class AppModule {}

Available Methods

• get<T>(key: string): Promise<T | undefined>
• set<T>(key: string, value: T, ttl?: number): Promise<void>
• del(key: string): Promise<void>
• reset(): Promise<void>
• wrap<T>(key: string, fn: () => Promise<T>, ttl?: number): Promise<T>
• mset<T>(keyValuePairs: Array<[string, T]>, ttl?: number): Promise<void>
• mget<T>(keys: string[]): Promise<(T | null)[]>
• exists(key: string): Promise<boolean>

Location Module

Module Registration

import { LocationModule } from '@mosu/be-framework';

@Module({
  imports: [
    LocationModule.forRootAsync({
        imports: [AppConfigModule],
        inject: [AppConfigService],
        useFactory: (config: AppConfigService) => ({
            apiKey: config.apiKey,
        }),
    }),
 ]
})
export class AppModule {}

Available Methods

• validateAddress(address: string): Promise<AddressValidationOutput>
• autocompleteAddress(payload: AddressAutocompleteInput): Promise<AddressValidationOutput[]>

Kafka Module

Module Registration

import { KafkaModule } from '@mosu/be-framework';

@Module({
  imports: [
    KafkaModule.forRootAsync({
        imports: [AppConfigModule],
        inject: [AppConfigService],
        useFactory: (config: AppConfigService) => ({
            clientId: 'my-app',
            brokers: config.kafkaBrokers,
            ssl: config.kafkaUseSsl,
            topics: [
              { name: 'user-events', numPartitions: 3, replicationFactor: 2 },
            ],
            consumerGroups: [
              { groupId: 'user-events-group', topics: ['user-events'] },
            ],
        }),
    }),
  ]
})
export class AppModule {}

Available Methods

• createProducer(config?: ProducerConfig): Promise<void>
• createTopic(topicConfig: KafkaTopicConfig): Promise<void>
• publish<T>(topic: string, message: T, key?: string): Promise<void>
• consume(groupId: string, topics: string[], config?: ConsumerConfig): Promise<ConsumerSubject>
• subscribeConsumer(consumerGroup: string, topic: string, messageKey?: string): Promise<ConsumerSubject>
• checkHealth(): Promise<KafkaHealthStatus>

ClickHouse Module

Module Registration

import { ClickHouseModule } from '@mosu/be-framework';

@Module({
  imports: [
    ClickHouseModule.forRootAsync({
        imports: [AppConfigModule],
        inject: [AppConfigService],
        useFactory: (config: AppConfigService) => ({
            host: config.clickhouseHost,
            port: config.clickhousePort,
            username: config.clickhouseUsername,
            password: config.clickhousePassword,
            database: config.clickhouseDatabase,
        }),
    }),
  ]
})
export class AppModule {}

Available Methods

• query<T>(sql: string, params?: Record<string, any>): Promise<T[]>
• insert<T>(table: string, data: T | T[]): Promise<void>
• createTable(tableName: string, schema: Record<string, string>): Promise<void>
• checkHealth(): Promise<{ status: 'ok' | 'error', details?: string }>