Brackets Memory Database

1.0.5 · active · verified Wed Apr 22

brackets-memory-db is an in-memory implementation of the `CrudInterface` for the `brackets-manager.js` ecosystem, designed to store tournament bracket data directly in application memory. The current stable version is 1.0.5, last published over two years ago, indicating a stable but infrequent release cadence. It provides a simple, type-safe storage solution that is particularly well-suited for client-side applications running in the browser, where data persistence is managed by the client's session or explicitly handled by the application logic. It's also an excellent choice for testing, prototyping, or scenarios requiring temporary, ephemeral storage without the overhead of a persistent database. Its key differentiators are its tight integration with `brackets-manager.js` and its straightforward, zero-configuration setup for in-memory operations.

Common errors

```
Error: Cannot find module 'brackets-memory-db' or its corresponding type declarations.
```
cause This error often occurs when mixing CommonJS `require()` with an ESM-first package, using an incorrect import path, or when TypeScript cannot find the type definitions.

fix Ensure you are using ESM `import { MemoryStorage } from 'brackets-memory-db';`. If in Node.js, ensure your `package.json` has `"type": "module"` or you are using `.mjs` files. For TypeScript, verify `tsconfig.json` settings (`moduleResolution`, `module`).
```
TypeError: Cannot read properties of undefined (reading 'create')
```
cause This error typically indicates that the `BracketsManager` instance was not properly initialized with a valid storage implementation, or the storage instance itself is `undefined`.

fix Double-check that `const storage = new MemoryStorage();` successfully creates an instance and that `new BracketsManager(storage);` is correctly called, passing the `storage` object.

Warnings

gotcha Data stored in `brackets-memory-db` is volatile and will be lost when the application process terminates or the browser page is refreshed. It does not provide any inherent persistence mechanism.
Fix: For persistent storage, consider other `brackets-manager` implementations like `brackets-json-db`, `brackets-prisma-db`, or `brackets-sql-db`, or implement custom serialization/deserialization logic to save/load the in-memory state.
gotcha This package is suitable for browser-based applications or backend processes where data can be re-generated or is explicitly saved externally. It is not designed as a primary, durable database for production systems requiring data integrity across restarts.
Fix: Evaluate your persistence requirements. For server-side applications, choose a database-backed `CrudInterface` implementation. For browser apps, ensure any critical data is saved to `localStorage`, `indexedDB`, or a remote API.
gotcha The package's last publish was over two years ago. While this can indicate stability, it also means infrequent updates, which might lead to slower bug fixes or a delay in adopting new features or TypeScript versions from its `brackets-manager` peer dependency.
Fix: Review the GitHub repository's issue tracker and commit history for current activity. Be mindful of potential compatibility issues with newer versions of `brackets-manager` if this package is not updated concurrently.

Install

npm install brackets-memory-db npm
yarn add brackets-memory-db yarn
pnpm add brackets-memory-db pnpm

Imports

MemoryStorage
wrong:
```
const { MemoryStorage } = require('brackets-memory-db');
```
correct:
```
import { MemoryStorage } from 'brackets-memory-db';
```
The primary export is a named class, `MemoryStorage`. While CommonJS `require` might technically work in some setups, ESM import syntax is recommended and correctly typed.
MemoryStorage
wrong:
```
import { MemoryStorage, CrudInterface } from 'brackets-memory-db';
```
correct:
```
import type { CrudInterface } from 'brackets-manager';
```
The `CrudInterface` itself is typically imported from `brackets-manager` for type declarations, not `brackets-memory-db`, as this package implements that interface.

Quickstart

This quickstart demonstrates how to set up `brackets-manager` with `brackets-memory-db` as its storage backend, creating a simple tournament and stage entirely in memory. It highlights the basic instantiation and interaction pattern.

import { BracketsManager } from 'brackets-manager';
import { MemoryStorage } from 'brackets-memory-db';

async function setupTournament() {
  // 1. Instantiate the in-memory storage.
  const storage = new MemoryStorage();

  // 2. Pass the storage instance to the BracketsManager.
  const manager = new BracketsManager(storage);

  // 3. Create a new tournament.
  await manager.create.tournament({
    name: 'My Awesome Tournament',
    slug: 'my-awesome-tournament',
    description: 'A test tournament running in memory.',
    sport: 'esports',
  });

  // 4. Create a stage for the tournament.
  const tournamentId = (await manager.get.tournament('my-awesome-tournament'))?.id;
  if (tournamentId === undefined) {
    throw new Error('Tournament not found');
  }

  await manager.create.stage({
    tournamentId,
    name: 'Single Elimination Stage',
    type: 'single_elimination',
    seeding: ['Team A', 'Team B', 'Team C', 'Team D'],
    settings: { size: 4 },
  });

  console.log('Tournament and stage created in memory!');
  const matches = await manager.get.matches(tournamentId);
  console.log('Current matches:', matches);
}

setupTournament().catch(console.error);

view raw JSON →