Skip to main content

InMemoryStore

@rotorsoft/act-root

@rotorsoft/act-root / act/src / InMemoryStore

Class: InMemoryStore

Defined in: libs/act/src/adapters/InMemoryStore.ts:181

In-memory event store implementation.

This is the default store used by Act when no other store is injected. It stores all events in memory and is suitable for:

  • Development and prototyping
  • Unit and integration testing
  • Demonstrations and examples

Not suitable for production - all data is lost when the process exits. Use PostgresStore for production deployments.

The in-memory store provides:

  • Full Store interface implementation
  • Optimistic concurrency control
  • Stream leasing for distributed processing simulation
  • Snapshot support
  • Fast performance (no I/O overhead)

Examples​

import { store } from "@rotorsoft/act";

describe("Counter", () => {
  beforeEach(async () => {
    // Reset store between tests
    await store().seed();
  });

  it("increments", async () => {
    await app.do("increment", target, { by: 5 });
    const snapshot = await app.load(Counter, "counter-1");
    expect(snapshot.state.count).toBe(5);
  });
});
import { InMemoryStore } from "@rotorsoft/act";

const testStore = new InMemoryStore();
await testStore.seed();

// Use for specific test scenarios
await testStore.commit("test-stream", events, meta);
const events: any[] = [];
await store().query(
  (event) => events.push(event),
  { stream: "test-stream" }
);
console.log(`Found ${events.length} events`);

See​

  • Store for the interface definition
  • PostgresStore for production use
  • store for injecting stores

Implements​

Constructors​

Constructor​

new InMemoryStore(): InMemoryStore

Returns​

InMemoryStore

Methods​

ack()​

ack(leases): Promise<object[]>

Defined in: libs/act/src/adapters/InMemoryStore.ts:391

Acknowledge completion of processing for leased streams.

Parameters​

leases​

Lease[]

Leases to acknowledge, including last processed watermark and lease holder.

Returns​

Promise<object[]>

Implementation of​

Store.ack

block()​

block(leases): Promise<object[]>

Defined in: libs/act/src/adapters/InMemoryStore.ts:403

Block a stream for processing after failing to process and reaching max retries with blocking enabled.

Parameters​

leases​

Lease & object[]

Leases to block, including lease holder and last error message.

Returns​

Promise<object[]>

Blocked leases.

Implementation of​

Store.block

claim()​

claim(lagging, leading, by, millis): Promise<Lease[]>

Defined in: libs/act/src/adapters/InMemoryStore.ts:320

Atomically discovers and leases streams for processing. Fuses poll + lease into a single operation.

Parameters​

lagging​

number

Max streams from lagging frontier.

leading​

number

Max streams from leading frontier.

by​

string

Lease holder identifier.

millis​

number

Lease duration in milliseconds.

Returns​

Promise<Lease[]>

Granted leases.

Implementation of​

Store.claim

commit()​

commit<E>(stream, msgs, meta, expectedVersion?): Promise<Committed<E, keyof E>[]>

Defined in: libs/act/src/adapters/InMemoryStore.ts:274

Commit one or more events to a stream.

Type Parameters​

E​

E extends Schemas

Parameters​

stream​

string

The stream name.

msgs​

Message<E, keyof E>[]

The events/messages to commit.

meta​

EventMeta

Event metadata.

expectedVersion?​

number

Optional optimistic concurrency check.

Returns​

Promise<Committed<E, keyof E>[]>

The committed events with metadata.

Throws​

ConcurrencyError if expectedVersion does not match.

Implementation of​

Store.commit

dispose()​

dispose(): Promise<void>

Defined in: libs/act/src/adapters/InMemoryStore.ts:191

Dispose of the store and clear all events.

Returns​

Promise<void>

Promise that resolves when disposal is complete.

Implementation of​

Store.dispose

drop()​

drop(): Promise<void>

Defined in: libs/act/src/adapters/InMemoryStore.ts:208

Drop all data from the store.

Returns​

Promise<void>

Promise that resolves when the store is cleared.

Implementation of​

Store.drop

query()​

query<E>(callback, query?): Promise<number>

Defined in: libs/act/src/adapters/InMemoryStore.ts:230

Query events in the store, optionally filtered by query options.

Type Parameters​

E​

E extends Schemas

Parameters​

callback​

(event) => void

Function to call for each event.

query?​

Readonly<{ after?: number; backward?: boolean; before?: number; correlation?: string; created_after?: Date; created_before?: Date; limit?: number; names?: string[]; stream?: string; with_snaps?: boolean; }>

Optional query options.

Returns​

Promise<number>

The number of events processed.

Implementation of​

Store.query

seed()​

seed(): Promise<void>

Defined in: libs/act/src/adapters/InMemoryStore.ts:200

Seed the store with initial data (no-op for in-memory).

Returns​

Promise<void>

Promise that resolves when seeding is complete.

Implementation of​

Store.seed

subscribe()​

subscribe(streams): Promise<{ subscribed: number; watermark: number; }>

Defined in: libs/act/src/adapters/InMemoryStore.ts:371

Registers streams for event processing.

Parameters​

streams​

object[]

Streams to register with optional source.

Returns​

Promise<{ subscribed: number; watermark: number; }>

subscribed count and current max watermark.

Implementation of​

Store.subscribe