@futdevpro/nts-dynamo
Advanced tools
Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.
Dynamo-NTS (NodeTS) is a comprehensive backend framework for building robust, secure, and scalable Node.js applications with TypeScript. Built on top of Dynamo FSM (@futdevpro/fsm-dynamo), it provides a structured approach to server-side development with clear separation of concerns, extensive configuration options, and production-ready implementations for common backend tasks.
Dynamo-NTS uses Dynamo FSM as its foundational layer, implementing the server-side components of the FSM architecture. All core interfaces, types, and utilities are provided by FSM, ensuring consistency and type safety across the entire Dynamo ecosystem.
Dynamo-NTS is part of the unified Dynamo ecosystem, a full-stack development framework designed to accelerate the development of scalable web applications. The ecosystem consists of interconnected packages that work together seamlessly, with Dynamo-NTS serving as the backend implementation layer. The frontend counterpart is Dynamo NGX, which uses Dynamo NGX Models for type-safe model definitions.
Dynamo-NTS is built with two key principles:
Full Override Capability: Every component, service, and class can be overridden or extended. The framework provides a solid foundation with sensible defaults, but you have complete control to customize or replace any part to fit your specific needs. This makes Dynamo-NTS highly customizable and adaptable to any project requirements.
Complete Type Information: All types, interfaces, and definitions are included in the compiled output. This ensures excellent readability and maintainability—everything you need is available at compile time through TypeScript's type system, providing full IntelliSense support and eliminating the need to reference external documentation during development.
Dynamo-NTS simplifies complex system definitions by abstracting common backend infrastructure into simple parameterization. Instead of manually configuring various libraries and services, you define your application through straightforward parameter objects:
DyNTS_App_Params, DyNTS_Http_Settings, and DyNTS_RoutingModule parameters (simplifies Express server initialization and route management)DyNTS_DBService and DyNTS_DataService with simple data model parameter definitions (simplifies Mongoose schema creation and model management)DyNTS_SocketServerService parameters and the DyNTS_AppExtended class (simplifies Socket.io server initialization and event management)DyNTS_EmailService with template component definitions (simplifies Nodemailer transporter setup and email template management)DyNTS_OAuth2_Controller and DyNTS_OAuth2_AuthService (simplifies complex OAuth2 flow implementation)DyNTS_ApiService with DyNTS_ApiCall_Params configuration (simplifies Axios request setup, error handling, and response management)DyNTS_Bot_MessagingProvider_ServiceBase and bot modules (simplifies Discord.js, Slack, and Teams bot development with unified interfaces)DyNTS_AI_Provider_ServiceBase and provider implementations (simplifies OpenAI SDK usage and enables multi-provider architecture)geoip-lite is integrated into the usage tracking module (simplifies location data collection from HTTP requests)This parameterization approach eliminates boilerplate code and provides a consistent, type-safe interface for all backend operations. Instead of learning multiple library APIs and their configuration patterns, developers work with unified Dynamo-NTS parameter objects that handle the underlying complexity.
Install Dynamo-NTS using pnpm (recommended) or npm:
pnpm add @futdevpro/dynamo-nts
# or
npm install @futdevpro/dynamo-nts
Dynamo-NTS requires peer dependencies that are divided into two categories: core dependencies (required for the main module) and module-specific dependencies (required only when using specific modules).
These dependencies are required for the main Dynamo-NTS functionality:
@futdevpro/fsm-dynamo - The foundational package providing core interfaces and utilities (always required)express - Web framework for Node.js (simplified through Dynamo-NTS parameterization)mongoose - MongoDB object modeling (simplified through Dynamo-NTS data services)axios - HTTP client (simplified through Dynamo-NTS API service)body-parser - Request body parsing middlewaredotenv - Environment variable managementrxjs - Reactive programming library@types/express - TypeScript types for Express@types/node - TypeScript types for Node.jsts-node - TypeScript execution environmentInstall core dependencies:
pnpm add @futdevpro/fsm-dynamo express mongoose axios body-parser dotenv rxjs @types/express @types/node ts-node
These dependencies are only required when using specific modules:
socket.io - Real-time communication (simplified through Dynamo-NTS socket services)nodemailer - Email sending (simplified through Dynamo-NTS email services)geoip-lite and @types/geoip-lite - IP geolocation (simplified through Dynamo-NTS usage module)discord.js - Discord bot development (simplified through Dynamo-NTS bot module)openai - OpenAI API integration (simplified through Dynamo-NTS AI module)Install module-specific dependencies as needed:
# For Socket module
pnpm add socket.io
# For Email service
pnpm add nodemailer
# For Usage module
pnpm add geoip-lite @types/geoip-lite
# For Bot module (Discord)
pnpm add discord.js
# For AI module (OpenAI)
pnpm add openai
The following example demonstrates how to set up a basic Dynamo-NTS application with routing and socket support:
import {
DyNTS_AppExtended,
DyNTS_App_Params,
DyNTS_GlobalService_Settings,
DyNTS_Http_Settings,
DyNTS_RoutingModule
} from '@futdevpro/nts-dynamo';
import {
DyNTS_SocketServerService
} from '@futdevpro/nts-dynamo/socket';
import { DyFM_usageSession_dataParams } from '@futdevpro/fsm-dynamo/usage';
import { DyFM_customData_dataParams } from '@futdevpro/fsm-dynamo/custom-data';
import { DyNTS_getUsageRoutingModule } from '@futdevpro/nts-dynamo/usage';
import { DyNTS_getTestRoutingModule } from '@futdevpro/nts-dynamo/test';
import { AuthService } from './core-services/auth.service';
import { Email_ServiceCollection } from './core-services/email.service-collection';
import { User_Controller } from './routes/user/user.controller';
import { Chat_SocketServerService } from './socket-services/chat.socket-server-service';
export class App extends DyNTS_AppExtended {
getAppParams(): DyNTS_App_Params {
return new DyNTS_App_Params({
name: 'My Application',
version: '1.0.0',
dbName: 'myapp',
dbUri: process.env.MONGO_URL || 'mongodb://localhost:27017/myapp',
systemShortCodeName: 'MYAPP',
});
}
getGlobalServiceCollection(): DyNTS_GlobalService_Settings {
return {
authService: AuthService.getInstance(),
emailServiceCollection: Email_ServiceCollection.getInstance(),
dbModels: [
// Your data model parameters here
DyFM_usageSession_dataParams,
DyFM_customData_dataParams,
],
};
}
getPortSettings(): DyNTS_Http_Settings {
return new DyNTS_Http_Settings({
httpPort: 3000,
});
}
getRoutingModules(): DyNTS_RoutingModule[] {
return [
new DyNTS_RoutingModule({
route: '/user',
controllers: [
User_Controller.getInstance(),
],
}),
DyNTS_getTestRoutingModule(),
DyNTS_getUsageRoutingModule(),
];
}
getSocketServices(): DyNTS_SocketServerService<any>[] {
return [
Chat_SocketServerService.getInstance(),
];
}
}
// Start the application
const app = new App();
Dynamo-NTS uses Dynamo FSM as its foundation, implementing all server-side components defined in the FSM architecture. All types, interfaces, and base models are provided by FSM, ensuring full type safety and consistency.
Dynamo-NTS is designed with extensibility in mind. Every component, service, and class can be overridden or extended to meet your specific requirements:
This design philosophy ensures that Dynamo-NTS provides a solid foundation while remaining fully customizable for your specific use cases.
All types, interfaces, and definitions are included in the compiled output, ensuring excellent readability and maintainability. When you compile your project, you have access to:
This approach eliminates the need to reference external documentation during development—everything you need is available in your IDE's autocomplete and type hints.
Dynamo-NTS provides two main application base classes that simplify Express server setup:
DyNTS_App: Basic application class for standard HTTP server applications without real-time socket supportDyNTS_AppExtended: Extended application class that includes built-in socket server capabilities for real-time communication (simplifies Socket.io setup)Both classes abstract away Express server configuration, requiring you to implement several abstract methods with simple parameter objects:
getAppParams(): Define application parameters (name, version, database name, etc.) - replaces Express app initializationgetGlobalServiceCollection(): Configure global services (authentication, email, database models) - replaces manual service registrationgetPortSettings(): Configure HTTP/HTTPS ports - replaces Express server.listen() configurationgetRoutingModules(): Define API routes and controllers - replaces Express router setupData services provide a structured way to interact with MongoDB, simplifying Mongoose model and schema definitions:
DyNTS_DBService<T>: Low-level MongoDB service for direct database operations (simplifies Mongoose model creation)DyNTS_DataService<T>: High-level data service with business logic, validation, and dependency management (simplifies MongoDB CRUD operations)DyNTS_ArchiveDataService<T>: Service for managing archived data in separate collectionsInstead of manually creating Mongoose schemas and models, you define data models through DyFM_DataModel_Params (from FSM), and Dynamo-NTS handles schema generation, model creation, and connection management automatically. Data services handle CRUD operations, data validation, dependency tracking, and provide methods for searching, filtering, and managing data relationships.
The routing system provides a structured approach to defining RESTful API endpoints, simplifying Express router configuration:
DyNTS_RoutingModule: Groups related controllers under a common route path (replaces Express Router setup)DyNTS_Controller: Abstract base class for defining HTTP endpoints (simplifies Express route handlers)DyNTS_Endpoint_Params: Configuration for individual API endpoints (replaces Express route definitions)Instead of manually setting up Express routers and route handlers, you define endpoints through parameter objects. Controllers define endpoints with support for:
The DyNTS_GlobalService provides centralized access to:
Dynamo-NTS provides an abstract DyNTS_AuthService class that you can extend to implement your authentication logic. The framework supports:
Dynamo-NTS is organized into focused modules, each providing specific functionality:
The core foundation providing essential components:
Provides abstractions and implementations for AI operations:
The OAI service-ek (DyNTS_OAI_LLM_ServiceBase, DyNTS_OAI_LLMChat_ServiceBase, DyNTS_OAI_Embedding_ControlService) bármely OpenAI-API-kompatibilis endpoint-tal működnek — lokál LLM (LM Studio, Ollama), self-hosted (vLLM, LocalAI) is — a DyFM_OAI_ClientOptions.baseURL mező segítségével. Részletek + provider-konfig sample-ök: __documentations/2026-05-17-oai-compatible-providers.md.
Platform and AI provider agnostic solutions for creating intelligent assistants:
Platform-agnostic bot functionality:
Real-time communication capabilities that simplify Socket.io setup:
Backend implementation for unified messaging system:
Complete OAuth2.0 protocol implementation:
Solutions for basic server endpoints:
Default implementations for common services:
Tools for managing custom data:
Testing and monitoring tools:
Session and usage tracking tools:
This example shows a complete application setup using DyNTS_AppExtended:
import {
DyNTS_AppExtended,
DyNTS_App_Params,
DyNTS_GlobalService_Settings,
DyNTS_Http_Settings,
DyNTS_RoutingModule
} from '@futdevpro/nts-dynamo';
import { DyNTS_SocketServerService } from '@futdevpro/nts-dynamo/socket';
export class App extends DyNTS_AppExtended {
getAppParams(): DyNTS_App_Params {
return new DyNTS_App_Params({
name: 'My Server',
version: '1.0.0',
dbName: 'myapp',
});
}
getGlobalServiceCollection(): DyNTS_GlobalService_Settings {
return {
authService: AuthService.getInstance(),
dbModels: [
// Your data models
],
};
}
getPortSettings(): DyNTS_Http_Settings {
return new DyNTS_Http_Settings({
httpPort: 3000,
});
}
getRoutingModules(): DyNTS_RoutingModule[] {
return [
new DyNTS_RoutingModule({
route: '/api',
controllers: [
MyController.getInstance(),
],
}),
];
}
getSocketServices(): DyNTS_SocketServerService<any>[] {
return [
MySocketService.getInstance(),
];
}
}
Multiple routing modules can be configured to organize your API:
getRoutingModules(): DyNTS_RoutingModule[] {
return [
new DyNTS_RoutingModule({
route: '/user',
controllers: [
User_Controller.getInstance(),
UserData_Controller.getInstance(),
UserSettings_Controller.getInstance(),
],
}),
new DyNTS_RoutingModule({
route: '/project',
controllers: [
Project_Controller.getInstance(),
ProjectExtension_Controller.getInstance(),
],
}),
new DyNTS_RoutingModule({
route: '/server',
controllers: [
ServerStatus_Controller.getInstance(),
],
}),
DyNTS_getTestRoutingModule(),
DyNTS_getUsageRoutingModule(),
];
}
Controllers define API endpoints with authentication and business logic:
import { Request, Response } from 'express';
import { DyNTS_Controller, DyNTS_Endpoint_Params } from '@futdevpro/nts-dynamo';
import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
export class User_Controller extends DyNTS_Controller {
static getInstance(): User_Controller {
return User_Controller.getSingletonInstance();
}
private authService: AuthService = AuthService.getInstance();
setupEndpoints(): void {
this.endpoints = [
new DyNTS_Endpoint_Params({
name: 'getUser',
type: DyFM_HttpCallType.get,
endpoint: '/get/:userId',
preProcesses: [this.authService.authenticate_tokenSelf],
tasks: [
async (req: Request, res: Response, issuer: string): Promise<void> => {
const userService = new User_DataService({ issuer });
await userService.getDataById(req.params.userId);
res.send(userService.data);
},
],
}),
new DyNTS_Endpoint_Params({
name: 'updateUser',
type: DyFM_HttpCallType.post,
endpoint: '/update',
preProcesses: [this.authService.authenticate_tokenSelf],
tasks: [
async (req: Request, res: Response, issuer: string): Promise<void> => {
const userService = new User_DataService({ issuer });
await userService.saveData(req.body);
res.send(userService.data);
},
],
}),
];
}
}
Data services provide a structured way to interact with MongoDB:
import { DyNTS_DataService } from '@futdevpro/nts-dynamo';
import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo'; // FSM provides the data model parameter definition
// Define your data model parameters
const userDataParams: DyFM_DataModel_Params<UserData> = new DyFM_DataModel_Params({
dataName: 'userData',
typeSample: {
userId: '',
preferences: {},
},
// ... additional configuration
});
export class User_DataService extends DyNTS_DataService<UserData> {
constructor(params: { issuer: string }) {
super(userDataParams);
this.issuer = params.issuer;
}
// Custom business logic methods
async getUserPreferences(userId: string): Promise<UserPreferences> {
await this.getDataByDependencyId({ userId });
return this.data?.preferences || {};
}
}
Socket services enable real-time communication:
import { DyNTS_SocketServerService, DyNTS_SocketPresence } from '@futdevpro/nts-dynamo/socket';
export class Chat_SocketServerService extends DyNTS_SocketServerService<DyNTS_SocketPresence, any> {
static getInstance(): Chat_SocketServerService {
return Chat_SocketServerService.getSingletonInstance();
}
protected setupSocketEvents(): void {
this.socketServer.on('connection', (socket) => {
socket.on('joinRoom', (roomId: string) => {
socket.join(roomId);
});
socket.on('sendMessage', async (data: { roomId: string; message: string }) => {
this.socketServer.to(data.roomId).emit('newMessage', data);
});
});
}
}
Dynamo-NTS provides built-in support for MongoDB Atlas vector search with automatic vectorization:
import { DyNTS_OAI_VectorDataService } from '@futdevpro/nts-dynamo/ai/open-ai';
export class Knowledge_DataService extends DyNTS_OAI_VectorDataService<Knowledge> {
constructor() {
super(knowledgeDataParams);
}
async searchSimilarContent(query: string, limit: number = 10): Promise<Knowledge[]> {
return await this.vectorSearch({
input: query,
searchInKey: 'content', // Property that has vectorization enabled
limit: limit,
numberOfCandidates: 100,
});
}
}
The vector search automatically:
Dynamo-NTS is part of the unified Dynamo ecosystem, which consists of several interconnected packages:
The foundational package @futdevpro/fsm-dynamo that provides:
DyFM_DataModel_Params)Dynamo-NTS is built on top of Dynamo FSM and implements the server-side components of the FSM architecture. All data models, interfaces, and type definitions used in Dynamo-NTS are provided by FSM, ensuring consistency and type safety across the entire ecosystem.
The frontend counterpart @futdevpro/dynamo-ngx provides:
The Dynamo ecosystem enforces consistent patterns across all packages:
DyNTS_ for backend, DyNX_ for frontend, DyFM_ for shared)This unified approach ensures that:
For detailed API documentation, see:
ISC
For issues, questions, or contributions, please refer to the project repository.
FAQs
Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.
The npm package @futdevpro/nts-dynamo receives a total of 1,202 weekly downloads. As such, @futdevpro/nts-dynamo popularity was classified as popular.
We found that @futdevpro/nts-dynamo demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 3 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
/Security News
A mini Shai-Hulud campaign compromised Red Hat Cloud Services npm packages to steal developer and CI/CD secrets during installation.
Research
/Security News
The North Korean malware loader hides in a Packagist-listed package and its GitHub branch to fetch and execute remote code in a likely Contagious Interview-style lure.
Security News
The Rust project is moving toward formal rules on LLM use in contributions after months of internal debate over maintainer burden, code quality, and contributor experience.