The Deltastone Nest Common library is an extensive NestJS extension designed to accelerate enterprise application development by providing a comprehensive suite of type-safe, production-ready modules.
Advanced authentication with multiple strategies and granular access control:
Example :@Module({
imports: [
AuthModule.registerAsync({
useFactory: () => ({
applicationName: 'MyApp',
natsHost: 'localhost',
natsPort: 4222,
additionalApplications: ['AuthService'],
}),
}),
],
})
export class AppModule {}
// Role-based access control
@Controller('users')
export class UserController {
@Role('Admin')
@Post()
createUser(@Body() userDto: CreateUserDto) {
// Only admin users can create users
}
@Acl('create', User) // Fine-grained access control
@Post('profile')
createProfile(@Body() profileDto: ProfileDto) {
// Checks specific create permissions
}
}Comprehensive audit logging with multilingual support:
Example :@Module({
imports: [
ActivityStreamModule.register({
enabledModels: [
{
model: User,
actions: [ActivityStreamAction.CREATE, ActivityStreamAction.UPDATE, ActivityStreamAction.DELETE],
audit: true, // Store full record history
fields: ['email', 'role'], // Specific field tracking
},
],
}),
],
})
export class AppModule {}Secure, field-level data encryption:
Example :@Schema()
export class SensitiveRecord {
@Prop({
type: String,
encryption: 'rsa', // RSA encryption
})
privateKey: string;
@Prop({
type: String,
encryption: 'hash', // Hash-based encryption
})
password: string;
}Seamless data sharing between microservices:
Example :@Module({
imports: [
CrossAppDataModule.registerAsync({
useFactory: () => ({
dependantModels: [UserModel],
sharedModels: [PublicUserModel],
natsHost: 'localhost',
natsPort: 4222,
serverAddress: 'https://myapp.com',
}),
}),
],
})
export class AppModule {}Sophisticated data privacy utilities:
Example :@Module({
imports: [
AnonymizerModule.register({
batchSize: 100,
useSeed: true, // Deterministic anonymization
models: [
{
model: UserModel,
fields: [
{field: 'email', method: 'internet.email'},
{field: 'name', method: 'person.fullName'},
],
condition: (query) => {
query.where('lastLogin').lessThan(oneYearAgo);
},
},
],
}),
],
})
export class PrivacyModule {}Advanced data visualization and aggregation:
Example :@Controller('dashboards')
export class DashboardController {
@Post('widget')
async getWidgetData(@Body() widgetConfig: WidgetConfigDto) {
return this.dashboardService.processWidget(widgetConfig);
}
}Centralized, multilingual navigation management:
Example :@Module({
imports: [
NavigationModule.registerAsync({
useFactory: () => ({
appName: 'MyApp',
appIcon: 'app-icon',
routes: [
{
label: {
en: 'Dashboard',
de: 'Armaturenbrett',
},
route: '/dashboard',
acl: {
operation: 'read',
modelClass: 'Dashboard',
},
},
],
}),
}),
],
})
export class AppModule {}@Module({
imports: [
MailModule.registerAsync({
useFactory: () => ({
enabledModels: [UserModel],
applicationName: 'MyApp',
}),
}),
],
})
export class NotificationModule {}@Injectable()
export class NotificationService {
constructor(private pushService: PushNotificationService) {}
async sendNotification(subscription: PushSubscription, payload: NotificationPayload) {
await this.pushService.sendNotification(subscription, payload);
}
}Centralized, type-safe configuration:
Example :@Module({
imports: [
ConfigModule.register({
configJson: localConfig,
convictSchema: configDefinition,
}),
],
})
export class AppConfigModule {}OpenTelemetry integrated tracing:
Example :@Module({
imports: [
TracingModule.registerAsync({
useFactory: () => ({
exporterHost: 'jaeger.monitoring.svc',
exporterPort: 4317,
}),
}),
],
})
export class MonitoringModule {}Centralized system-wide property management:
Example :@Injectable()
export class ConfigService {
constructor(private systemPropertyService: SystemPropertyService) {}
async getApplicationSetting() {
// Retrieve a system-wide property
const maintenanceMode = await this.systemPropertyService.getProperty('maintenance_mode', Boolean, false);
}
}Simplified anonymous access for public endpoints:
Example :@Module({
imports: [
PublicAccessModule.registerAsync({
useFactory: () => ({
natsHost: 'localhost',
natsPort: 4222,
username: 'public_user',
}),
}),
],
})
export class PublicAccessModule {}Automatic ID generation with custom formatting:
Example :@Schema()
export class Invoice {
@Prop({
type: String,
autoIncrement: {
prefix: 'INV',
length: 8,
pad: true,
start: 1,
},
})
invoiceNumber: string;
}Reusable, shareable query filters:
Example :@Controller('filters')
export class FilterController {
@Post()
@Acl('create', PredefinedFilter)
createFilter(@Body() filterDto: PredefinedFilterCreateDto) {
// Create a reusable query filter
}
}Advanced multilingual support:
Example :@Injectable()
export class TranslationService {
constructor(private translateService: TranslateService) {}
translateValue(language: string, value: any, fieldDefinition: FieldDefinition) {
return this.translateService.translateValue(language, value, fieldDefinition);
}
}High-performance distributed caching:
Example :@Injectable()
export class CacheService {
constructor(private redisService: RedisService) {}
async cacheData(key: string, data: any, timeout: number = 3600) {
await this.redisService.set(key, data, timeout);
}
async getCachedData<T>(key: string): Promise<T | null> {
return this.redisService.get<T>(key);
}
}Dynamic script execution with controlled context:
Example :@Injectable()
export class DynamicScriptService {
constructor(private scriptEngine: ScriptEngineService) {}
async executeScript(script: string, context: Record<string, any>) {
return this.scriptEngine.runScript('dynamicScript', script, context);
}
}Background and migration task management:
Example :@Injectable()
export class MigrationTask extends DataTask {
protected async defineTask(dataTaskService: DataTaskService): Promise<void> {
dataTaskService.add({
title: 'Data Migration',
description: 'Migrate legacy data to new schema',
type: 'migration',
createdAt: new Date().toISOString(),
affectedModels: [...]
}, this.migrationLogic);
}
private async migrationLogic(): Promise<void> {
// Perform complex data migration
}
}(Keep the existing sections for Authentication, Activity Stream, Vault Encryption, etc.)
npm install @deltastone/nest-common
# Peer dependencies
npm install @nestjs/core @nestjs/common rxjs[Specify License - MIT/Apache/Proprietary]
[Link to Performance Comparisons]