Most browser databases treat async as an afterthought — synchronous APIs wrapped in promises, storage on localStorage, persistence that blocks the main thread. GenosDB takes the opposite approach: an async-first engine built on OPFS and Web Workers from day one.
GenosDB has been rebuilt from the ground up — moving from a traditional Class-based architecture to a modern Async Factory Function. This isn't a cosmetic change. It's a fundamental shift in how the database initializes, connects to peers, and manages storage. The result: zero race conditions, seamless module loading, and an API that flows as naturally as the async/await pattern it's built on.
From Classes to Async Factory
The old approach served us well, but as a real-time, distributed database that interacts with networks (WebRTC) and advanced storage APIs (OPFS), asynchronous initialization is in our DNA. A traditional new GDB() constructor is synchronous, forcing developers into awkward patterns to wait for the database to be truly ready.
This could lead to subtle race conditions and boilerplate code just to answer a simple question: "Is the database ready yet?" We knew we could do better.
The Async Factory pattern is the definitive answer. It embraces the asynchronous nature of the modern web, guaranteeing that when you get a GenosDB instance, it is 100% initialized, connected, and ready for action.
The New Way: Elegant, Modern, and Foolproof
With our new async factory, your code becomes beautifully linear and intuitive.
import { gdb } from "https://cdn.jsdelivr.net/npm/genosdb@latest/dist/index.min.js";
// 1. Simply await the factory function.
const db = await gdb('my-app', { rtc: true });
// 2. That's it. The next line runs only when the DB is fully ready.
console.log("DB is ready. Zero ambiguity.");
// 3. Your application logic flows naturally.
const { results, unsubscribe } = await db.map( ... );
This isn't just syntactic sugar. The await keyword guarantees that every part of GenosDB — the OPFS storage connection, the WebRTC network layer, and all modules — are fully operational before you write another line of code. Race conditions are eliminated by design.
The Power of Modularity: Build Your Perfect Database
This new architecture makes our powerful modular system more seamless than ever. GenosDB is not a one-size-fits-all database; it's a core engine you can extend with powerful capabilities on demand. Need military-grade access control? Natural language queries? Geospatial indexing? Just ask for it during initialization.
// Initialize GenosDB with the exact features you need.
const db = await gdb('enterprise-app', {
rtc: true, // Enable P2P realtime communication
sm: true, // Security Manager with RBAC
nlq: true, // Natural Language Queries
geo: true, // Geospatial operators ($near, $bbox)
rx: true // Radix tree ($startsWith, prefix search)
});
// Now your `db` instance is supercharged with enterprise-grade features.
// Example: Using the Security Module to create a signed operation.
const recordId = await db.sm.put({ sensitive: "data" });
No complex plugin systems. No dependency hell. Just a simple boolean flag to unlock a world of functionality. This is the future of database extensibility.
Architecture Advantages
Many databases claim to be "distributed," but often rely on a central server for coordination, creating a single point of failure. GenosDB is different. Our new async core amplifies the unique advantages that set us apart:
Truly Serverless P2P Architecture: GenosDB uses WebRTC to form a genuine peer-to-peer mesh network (scaling to thousands of peers via Cellular Mesh) directly in the browser. Data syncs between users without ever touching a central server. This provides unparalleled resilience, privacy, and scalability.
Frictionless Real-Time Reactivity: The Hybrid Delta Protocol, now enhanced with a more robust event system, provides effortless real-time updates. The
db.map()API is a masterclass in simplicity: query your graph and get notified of any changes, from any peer, instantly.Advanced In-Browser Persistence: We are pioneers in using the Origin Private File System (OPFS) — a modern, sandboxed file system that runs in a dedicated Web Worker, offering near-native disk performance for large-scale offline storage, right in the browser. Your application works just as fast offline as it does online.
Unmatched Extensibility: As shown above, our modular architecture is second to none. The ability to seamlessly add features like Role-Based Access Control — Security Manager (sm) or an Natural Language Query engine (nlq) transforms GenosDB from a database into a full-fledged application platform.
Why This Matters
The transition to an async factory is more than an update; it's the culmination of our vision for a truly modern, developer-first distributed database. It makes GenosDB faster to initialize, safer to use, and infinitely more flexible.
The async factory pattern isn't just a refactor — it's the foundation that makes everything else in GenosDB possible.
Explore More
- Why I Built GenosDB — the full story and technical deep-dive
- GenosDB: Introducing Oplog-Driven Delta Sync — the sync protocol powering real-time updates
- Technical Features of GenosDB — complete feature overview
- GenosDB Cellular Mesh: Solving P2P Scalability — how the network scales
This article is part of the official documentation of GenosDB (GDB).
GenosDB is a distributed, modular, peer-to-peer graph database built with a Zero-Trust Security Model, created by Esteban Fuster Pozzi (estebanrfp).
📄 Whitepaper | overview of GenosDB design and architecture
🛠 Roadmap | planned features and future updates
💡 Examples | code snippets and usage demos
📖 Documentation | full reference guide
🔍 API Reference | detailed API methods
📚 Wiki | additional notes and guides
💬 GitHub Discussions | community questions and feedback
🗂 Repository | Minified production-ready files
📦 Install via npm | quick setup instructions
Top comments (0)