State of this library?

[oxc]

Happy New Year! 🥳 I have asked this question before, and back then it indeed triggered a reaction: a Pull Request updating all kinds of dependencies was created, and marked to close this question.

Unfortunately, this is the only reply I got so far, apart from a few emoji reactions.

Even more unfortunately, those changes were merged and released, but the release never made it to NPM due to a breakage introduced into the build pipeline. This was not addressed yet, and everyone went radio silence since then.
Why go through the trouble of updating the dependency base line if nobody seems interested in whether it is actually released?

I feel a bit bad about "nagging" twice about this, and probably the timeline gives an answer on its own. However, since my last question did spike some interest, I would like to try one more time to get an honest answer.

Are there any plans to keep this library maintained and developed? Is there willingness to include and steward community contributions, or is this library in a state where it might or might not still be working in some legacy in-house products, but is dead otherwise?

I don't intend to blame anyone about anything, or put someone on the spot. Even less so, I want to seem ungrateful, since this great library is provided open source and for free, and nobody is owing me anything.
But knowing the answer to this question is paramount for our own way forward, whether we want to contribute to this library, or consider forking.

There are some mandatory features (like snapshotting) still missing, which I don't want to "build around" the library. I'm happy to contribute in any helpful way, but I'm not keen on producing pull requests that will just sit around uncommented, and make it double-hard for us to move forward.

Getting an actual response or some insights from one of the developers would be greatly preferred over having to deduce an answer on my own.

Thank you!

[jeremycare]

Hey,

It doesn't look like this is maintained anymore, but I'll let the maintainer reply to this.

For the snapshot, this is what we did:

export interface SnapshotsRepository<AggregateState extends Aggregate> {
  getSnapshot(params: { id: string, reducerVersion: string, options: { eventStoreId: string } }): Promise<AggregateState | undefined>
  saveSnapshot(params: { state: AggregateState, reducerVersion: string, options: { eventStoreId: string } }): Promise<void>
}

export class EventStoreImpl<
    EVENT_STORE extends CastoreEventStoreImpl,
    AGGREGATE_CLASS extends AggregateRoot<$AGGREGATE, EventStoreEventDetails<EVENT_STORE>>,
    $AGGREGATE extends Aggregate = $Contravariant<Aggregate, EventStoreAggregate<EVENT_STORE>>,
> {
  private eventStore: EVENT_STORE;

  private readonly factory: (state: EventStoreAggregate<EVENT_STORE>) => AGGREGATE_CLASS;

  private readonly snapshotsRepository: SnapshotsRepository<$AGGREGATE>;

  private readonly reducerVersion: string;

  constructor({
    eventStore, factory, snapshotsRepository, reducerVersion,
  }: {
    eventStore: EVENT_STORE,
    factory: (state: EventStoreAggregate<EVENT_STORE>) => AGGREGATE_CLASS,
    snapshotsRepository: SnapshotsRepository<$AGGREGATE>,
    reducerVersion: string
  }) {
    this.eventStore = eventStore;
    this.factory = factory;
    this.snapshotsRepository = snapshotsRepository;
    this.reducerVersion = reducerVersion;
  }

  public async getState(id: string): Promise<EventStoreAggregate<EVENT_STORE> | undefined> {
    const snapshot = await this.snapshotsRepository.getSnapshot({
      id,
      reducerVersion: this.reducerVersion,
      options: {
        eventStoreId: this.eventStore.eventStoreId,
      },
    });
    const eventsAfterSnapshot = await this.eventStore.getEvents(id, {
      minVersion: snapshot ? snapshot.version + 1 : 0,
    });
    return this.eventStore.buildAggregate(eventsAfterSnapshot.events, snapshot);
  }

  public async getAggregate(id: string): Promise<AGGREGATE_CLASS | undefined> {
    const state = await this.getState(id);
    if (!state) {
      return undefined;
    }

    return this.factory(state);
  }

  public async getEvents(id: string): Promise<EventStoreEventDetails<EVENT_STORE>[]> {
    const response = await this.eventStore.getEvents(id);
    return response.events;
  }

  public async saveEvents(events: EventStoreEventDetails<EVENT_STORE>[]): Promise<void> {
    if (events.length === 0) {
      return;
    }

    const groupedEvents = events.map((event) => this.eventStore.groupEvent(event));

    // @ts-ignore  https://github.com/castore-dev/castore/issues/177
    await CastoreEventStoreImpl.pushEventGroup(groupedEvents[0], ...groupedEvents.slice(1));
  }

  public async save(aggregate: AGGREGATE_CLASS): Promise<void> {
    const state = aggregate.getState();
    const events = aggregate.popChanges();
    await this.saveEvents(events);

    if (this.shouldSnapshot(events)) {
      await this.snapshotsRepository.saveSnapshot({
        reducerVersion: this.reducerVersion,
        state,
        options: {
          eventStoreId: this.eventStore.eventStoreId,
        },
      });
    }
  }

  private shouldSnapshot(events : { version: number }[]): boolean {
    return events.some((event) => event.version % 500 === 0);
  }

  public getTransactionalEvents(aggregate: AGGREGATE_CLASS): TransactionalEvent[] {
    const events = aggregate.popChanges();
    return events.map((event) => this.eventStore.groupEvent(event));
  }

  public async transactionalSave(aggregate: AGGREGATE_CLASS, otherTransactionalEvents?: TransactionalEvent[]) {
    const state = aggregate.getState();
    const newTransactionalEvents = this.getTransactionalEvents(aggregate);
    if (newTransactionalEvents.length === 0 && (otherTransactionalEvents === undefined || otherTransactionalEvents.length === 0)) {
      return;
    }

    const allTransactionalEvents = [
      ...newTransactionalEvents,
      ...otherTransactionalEvents || [],
    ];

    // @ts-ignore  https://github.com/castore-dev/castore/issues/177
    await CastoreEventStoreImpl.pushEventGroup(allTransactionalEvents[0], ...allTransactionalEvents.slice(1));

    if (this.shouldSnapshot(newTransactionalEvents.map((transactionalEvent) => (
      transactionalEvent.event
    )))) {
      await this.snapshotsRepository.saveSnapshot({
        reducerVersion: this.reducerVersion,
        state,
        options: {
          eventStoreId: this.eventStore.eventStoreId,
        },
      });
    }
  }

  public async listAggregateIds({ limit, pageToken }: ListAggregateIdsInput = { limit: 100 }): Promise<ListAggregateIdsOutput> {
    const castoreOutput = await this.eventStore.listAggregateIds({
      limit,
      pageToken,
    });
    return {
      aggregateIds: castoreOutput.aggregateIds.map((aggregateId) => aggregateId.aggregateId),
      nextPageToken: castoreOutput.nextPageToken,
    };
  }
}

To be honest I think creating your own event sourcing micro lib is probably easier long term. We started to use this library few years ago. But if I were to do it again, I would gave wrote everything myself. It's actually not that hard to implement, and you can have full control

Hope this helps!

[ThomasAribart]

Hi @oxc and @jeremycare !

Sadly I'm too focused on my own project and https://www.dynamodbtoolbox.com at the moment to maintain Castore.

This is a shame because the lib doesn't miss much to be feature-complete. Event validation and snapshot handling, features for which I already had a technical strategy.

I'm proud of Castore and I know I will return to it at some point to make it feature complete but I can't say when. Sorry about that. Feel free to fork, copy-paste or contribute if you want to.

[oxc]

Hi @ThomasAribart,

Thank you for your response! I fully understand and know first-hand that resources for maintaining a project in one's free time can simply be too scarce.

I'm all the more grateful for all the work you have put into Castore so far! (and DynamoDB Toolbox, which I also love!) It's indeed something you can be proud of!

Nevertheless, it is important for us to be able to iterate somewhat quickly on this, so I have indeed taken the liberty of forking into hamstore 🐹

I have adjusted the build and CI/CD stack a bit to be a bit more performant and use the tools I feel comfortable with. Apart from that, however, I'm trying to follow your lead based on what's already there. Hopefully, we can merge the projects back together at some point.

Meanwhile, I would be more than happy to get your input on the features I'm working on, provided that you're interested and find the time. If I may, I will ping you on new PRs.

I have started to work on the Event Validation feature in hamstore#19 based on #175

Please let me know if anything in this fork is displeasing to you, or if you feel any copyright has been violated. I want to build on your work, not steal anything.

Thank you for your work! 🦫