Introduction
Hexagonal architecture. Beyond your own code.
AntelopeJS is a TypeScript framework and CLI for Node.js applications. It brings your business modules, local integrations and installed ecosystem modules into the same ports-and-adapters model. Consumers depend on explicit contracts, providers implement them, and the application selects the implementations.
If you already practice hexagonal architecture, the goal is not to teach you another folder structure. AntelopeJS supplies the interface binding, module lifecycle and application assembly mechanisms that make those boundaries usable across separately maintained modules.
Keep the boundary when you add a dependency
An integration should not force business modules to import the provider that implements it. In AntelopeJS, a consumer calls an interface package. A provider registers an implementation of that interface, and the runtime connects the calls.
For example, a consumer can depend on the shared database contract rather than a MongoDB module. An implementation may come from your own code or the ecosystem; both participate in the same module model. Calling a MongoDB-specific interface is also possible, but that choice intentionally reduces portability.
What AntelopeJS provides
Explicit contracts
Describe the capabilities consumers need through typed interface APIs. Keep the provider choice outside the consuming module.
One ecosystem model
Compose local modules and published packages through the same application configuration and lifecycle. You do not need a separate integration model for each module source.
Application-owned choices
Select an implementation in application configuration. A compatible replacement can preserve the consumer's import and calls while its provider-specific setup changes.
Shared runtime mechanisms
Use interface binding and module lifecycle instead of rebuilding that infrastructure. Keep responsibility for your contracts, business behavior and integration tests.
Development hot reload
Reload changed local modules during development. This shortens the edit-and-run loop; it is separate from changing a production provider.
What stays your responsibility
A replacement must support the contract version, capabilities and behavior your consumers require. Matching types alone does not guarantee compatibility. Configuration, credentials, data migrations and operational requirements still need attention.
AntelopeJS provides the mechanisms for explicit boundaries; it does not prevent modules from importing a provider directly. Your design still determines which dependencies belong in business code, and consumers remain coupled to their contracts.
Start building
- Quick Start — Create a project and your first module.
- Architecture — Map ports, adapters and application assembly to AntelopeJS.
- Interfaces — Define, consume and implement a contract.
- Explore the ecosystem — Find modules and inspect the interfaces they support.