@eventualize/core 1.0.0

package/src/EvDbEventStore.ts

@@ -0,0 +1,302 @@
+import EvDbStream from './EvDbStream.js';
+import IEvDbStorageSnapshotAdapter from '@eventualize/types/IEvDbStorageSnapshotAdapter';
+import IEvDbStorageStreamAdapter from '@eventualize/types/IEvDbStorageStreamAdapter';
+import IEvDbEventPayload from "@eventualize/types/IEvDbEventPayload";
+import { EvDbStreamFactory } from './EvDbStreamFactory.js';
+
+/**
+ * Combined storage adapter interface
+ */
+export interface IEvDbStorageAdapter extends IEvDbStorageStreamAdapter, IEvDbStorageSnapshotAdapter { }
+
+/**
+ * Storage configuration - either separate adapters or combined
+ */
+interface StorageConfig {
+  streamAdapter: IEvDbStorageStreamAdapter;
+  snapshotAdapter: IEvDbStorageSnapshotAdapter;
+}
+
+/**
+ * Registry of stream factories by stream type
+ */
+interface StreamFactoryRegistry {
+  [streamType: string]: EvDbStreamFactory<any, any>;
+}
+
+/**
+ * Store class - manages stream creation with configured adapters and factories
+ */
+class BaseStore {
+  private readonly storage: StorageConfig;
+  private readonly streamFactories: StreamFactoryRegistry = {};
+
+  public constructor(storage: StorageConfig, streamFactories: StreamFactoryRegistry) {
+    this.storage = storage;
+    this.streamFactories = streamFactories;
+  }
+
+  /**
+   * Create a stream instance by stream type and ID
+   */
+  public createStream(streamType: string, streamId: string): EvDbStream {
+    const factory = this.streamFactories[streamType];
+
+    if (!factory) {
+      throw new Error(
+        `No stream factory registered for stream type: ${streamType}. ` +
+        `Available types: ${Object.keys(this.streamFactories).join(', ')}`
+      );
+    }
+
+    const stream = factory.create(
+      streamId,
+      this.storage.streamAdapter,
+      this.storage.snapshotAdapter
+    );
+
+    return stream;
+  }
+
+  /**
+   * Get a stream instance from the event store by stream type and ID
+   */
+  public async getStream(streamType: string, streamId: string): Promise<EvDbStream> {
+    const factory = this.streamFactories[streamType];
+
+    if (!factory) {
+      throw new Error(
+        `No stream factory registered for stream type: ${streamType}. ` +
+        `Available types: ${Object.keys(this.streamFactories).join(', ')}`
+      );
+    }
+
+    return factory.get(
+      streamId,
+      this.storage.streamAdapter,
+      this.storage.snapshotAdapter
+    );
+  }
+
+  /**
+   * Check if a stream type is registered
+   */
+  public hasStreamType(streamType: string): boolean {
+    return streamType in this.streamFactories;
+  }
+
+  /**
+   * Get all registered stream types
+   */
+  public getStreamTypes(): string[] {
+    return Object.keys(this.streamFactories);
+  }
+
+  /**
+   * Create a builder for configuring the store
+   */
+  public static builder(): BaseStoreBuilder {
+    return new BaseStoreBuilder();
+  }
+
+  public async close(): Promise<void> {
+    await Promise.all([this.storage.snapshotAdapter.close(), this.storage.streamAdapter.close()]);
+    return;
+  }
+}
+
+/**
+ * Builder for creating Store instances
+ */
+class BaseStoreBuilder {
+  private streamAdapter?: IEvDbStorageStreamAdapter;
+  private snapshotAdapter?: IEvDbStorageSnapshotAdapter;
+  private streamFactories: StreamFactoryRegistry = {};
+
+  /**
+   * Configure with separate stream and snapshot adapters
+   */
+  public withAdapters(
+    streamAdapter: IEvDbStorageStreamAdapter,
+    snapshotAdapter: IEvDbStorageSnapshotAdapter
+  ): this {
+    this.streamAdapter = streamAdapter;
+    this.snapshotAdapter = snapshotAdapter;
+    return this;
+  }
+
+  /**
+   * Configure with a combined adapter that implements both interfaces
+   */
+  public withAdapter(adapter: IEvDbStorageAdapter): this {
+    this.streamAdapter = adapter;
+    this.snapshotAdapter = adapter;
+    return this;
+  }
+
+  /**
+   * Register a stream factory
+   */
+  public withStreamFactory<TEvents extends IEvDbEventPayload, TStreamType extends string>(
+    factory: EvDbStreamFactory<TEvents, TStreamType>
+  ): this {
+    const streamType = factory.getStreamType();
+    if (this.streamFactories[streamType]) {
+      throw new Error(`Stream factory for type '${streamType}' is already registered`);
+    }
+    this.streamFactories[streamType] = factory;
+    return this;
+  }
+
+  /**
+   * Register multiple stream factories at once
+   */
+  public withStreamFactories(
+    factories: ReadonlyArray<EvDbStreamFactory<any, string>>
+  ): this {
+    factories.forEach(factory => {
+      this.withStreamFactory(factory);
+    });
+    return this;
+  }
+
+  /**
+   * Build the store instance
+   */
+  public build(): BaseStore {
+    if (!this.streamAdapter || !this.snapshotAdapter) {
+      throw new Error(
+        'Storage adapters must be configured. Use withAdapter() or withAdapters()'
+      );
+    }
+
+    if (Object.keys(this.streamFactories).length === 0) {
+      console.warn('Store created with no stream factories registered');
+    }
+
+    return new BaseStore(
+      {
+        streamAdapter: this.streamAdapter,
+        snapshotAdapter: this.snapshotAdapter
+      },
+      this.streamFactories
+    );
+  }
+}
+
+// ============================================================================
+// TYPED STORE - Type-safe stream creation
+// ============================================================================
+
+/**
+ * Helper type to create method signatures for each stream factory
+ */
+export type StreamCreatorMethods<TStreamTypes extends Record<string, EvDbStreamFactory<any, any>>> = {
+  [K in keyof TStreamTypes as `create${K & string}`]: (streamId: string) => EvDbStream;
+};
+
+export type StreamMap = Record<string, any>;
+
+/**
+ * Type-safe store that knows about specific stream types
+ */
+export class EvDbEventStore<TStreamTypes extends Record<string, EvDbStreamFactory<any, any>>> {
+  constructor(private readonly store: BaseStore) {
+    // Create dynamic methods for each stream type
+    this.createDynamicMethods();
+  }
+
+  /**
+   * Create a stream with type-safe stream type parameter (fallback method)
+   */
+  public createStream<K extends keyof TStreamTypes & string>(
+    streamType: K,
+    streamId: string,
+  ): EvDbStream {
+    return this.store.createStream(streamType, streamId);
+  }
+
+  /**
+   * Fetch a stream from the event store with type-safe stream type parameter (fallback method)
+   */
+  public getStream<K extends keyof TStreamTypes & string>(
+    streamType: K,
+    streamId: string
+  ): Promise<EvDbStream> {
+
+    return this.store.getStream(streamType, streamId);
+  }
+
+  /**
+   * Create dynamic methods for each registered stream factory
+   */
+  private createDynamicMethods(): void {
+    const streamTypes = this.store.getStreamTypes();
+
+    for (const streamType of streamTypes) {
+      const methodName = `create${streamType}` as keyof this;
+
+      // Create the dynamic method
+      (this as any)[methodName] = (streamId: string) => {
+        return this.store.createStream(streamType, streamId);
+      };
+    }
+  }
+
+  /**
+   * Get the underlying store
+   */
+  public getStore(): BaseStore {
+    return this.store;
+  }
+}
+
+// Make TypedStore callable with dynamic methods
+// export interface TypedStore<TStreamTypes extends Record<string, StreamFactory<any>>>
+//     extends StreamCreatorMethods<TStreamTypes> { }
+
+export type TypedStoreType<
+  TStreamTypes extends Record<string, EvDbStreamFactory<any, any>>
+> = StreamCreatorMethods<TStreamTypes>;
+
+/**
+ * Type-safe store builder
+ */
+export class EvDbEventStoreBuilder<
+  TStreamTypes extends Record<string, EvDbStreamFactory<any, string>> = {}
+> {
+  private builder = BaseStore.builder();
+
+  public withAdapters(
+    streamAdapter: IEvDbStorageStreamAdapter,
+    snapshotAdapter: IEvDbStorageSnapshotAdapter
+  ): this {
+    this.builder.withAdapters(streamAdapter, snapshotAdapter);
+    return this;
+  }
+
+  public withAdapter(adapter: IEvDbStorageAdapter): this {
+    this.builder.withAdapter(adapter);
+    return this;
+  }
+
+  // Track stream type in generics
+  public withStreamFactory<
+    F extends EvDbStreamFactory<any, string>,
+    K extends F extends EvDbStreamFactory<any, infer ST> ? ST : never
+  >(
+    factory: F
+  ): EvDbEventStoreBuilder<TStreamTypes & Record<K, F>> {
+    this.builder.withStreamFactory(factory);
+    // return as the new type that tracks K
+    return this as unknown as EvDbEventStoreBuilder<TStreamTypes & Record<K, F>>;
+  }
+
+  public build(): EvDbEventStore<TStreamTypes> & StreamCreatorMethods<TStreamTypes> {
+    const store = new EvDbEventStore(this.builder.build());
+    return store as EvDbEventStore<TStreamTypes> & StreamCreatorMethods<TStreamTypes>;
+  }
+}
+
+export type EvDbEventStoreType<TStreams extends StreamMap = StreamMap> =
+  EvDbEventStore<TStreams> & StreamCreatorMethods<TStreams>;

package/src/EvDbStream.ts

@@ -0,0 +1,184 @@
+import EvDbEvent from "@eventualize/types/EvDbEvent";
+import EvDbMessage from "@eventualize/types/EvDbMessage";
+import IEvDbStorageStreamAdapter from "@eventualize/types/IEvDbStorageStreamAdapter";
+import IEvDbView from "@eventualize/types/IEvDbView";
+import EvDbStreamAddress from "@eventualize/types/EvDbStreamAddress";
+import IEvDbViewStore from "@eventualize/types/IEvDbViewStore";
+import IEvDbStreamStore from "@eventualize/types/IEvDbStreamStore";
+import IEvDbStreamStoreData from "@eventualize/types/IEvDbStreamStoreData";
+import IEvDbEventPayload from "@eventualize/types/IEvDbEventPayload";
+import StreamStoreAffected from "@eventualize/types/StreamStoreAffected";
+import IEvDbEventMetadata from "@eventualize/types/IEvDbEventMetadata";
+import EvDbStreamCursor from "@eventualize/types/EvDbStreamCursor";
+import OCCException from "@eventualize/types/OCCException";
+import { EvDbStreamType } from "@eventualize/types/primitiveTypes";
+import EVDbMessagesProducer from "@eventualize/types/EvDbMessagesProducer";
+import { EvDbView } from "./EvDbView.js"
+
+
+type ImmutableIEvDbView = Readonly<EvDbView<unknown>>;
+export type ImmutableIEvDbViewMap = Readonly<Record<string, ImmutableIEvDbView>>;
+
+
+
+export default class EvDbStream implements IEvDbStreamStore, IEvDbStreamStoreData {
+
+    protected _pendingEvents: ReadonlyArray<EvDbEvent> = [];
+    protected _pendingMessages: ReadonlyArray<EvDbMessage> = [];
+
+    private static readonly ASSEMBLY_NAME = {
+        name: 'evdb-core',
+        version: '1.0.0'
+    };
+
+    private static readonly DEFAULT_CAPTURE_BY =
+        `${EvDbStream.ASSEMBLY_NAME.name}-${EvDbStream.ASSEMBLY_NAME.version}`;
+
+    private readonly _storageAdapter: IEvDbStorageStreamAdapter;
+
+    // Views
+    protected readonly _views: ImmutableIEvDbViewMap;
+
+    getViews(): ImmutableIEvDbViewMap {
+        return this._views;
+    }
+
+    getView(viewName: string): Readonly<IEvDbView> | undefined {
+        return this._views[viewName];
+    }
+
+    // Events
+    /**
+     * Unspecialized events
+     */
+    getEvents(): ReadonlyArray<EvDbEvent> {
+        return this._pendingEvents;
+    }
+
+    // StreamAddress
+    public streamAddress: EvDbStreamAddress;
+
+    // StoredOffset
+    public storedOffset: number;
+
+    // Constructor
+    public constructor(
+        streamType: EvDbStreamType,
+        views: ImmutableIEvDbView[],
+        storageAdapter: IEvDbStorageStreamAdapter,
+        streamId: string,
+        lastStoredOffset: number,
+        protected messagesProducer: EVDbMessagesProducer
+    ) {
+        this._views = views.reduce((acc, view) => {
+            const viewName = view.address.viewName;
+            acc[viewName] = view;
+            return acc;
+        }, {} as Record<string, IEvDbViewStore>) as ImmutableIEvDbViewMap;
+        this._storageAdapter = storageAdapter;
+        this.streamAddress = new EvDbStreamAddress(streamType, streamId);
+        this.storedOffset = lastStoredOffset;
+    }
+
+    protected appendEvent(
+        payload: IEvDbEventPayload,
+        capturedBy?: string | null
+    ): IEvDbEventMetadata {
+        capturedBy = capturedBy ?? EvDbStream.DEFAULT_CAPTURE_BY;
+        // const json = JSON.stringify(payload); // Or use custom serializer
+
+        const cursor = this.getNextCursor(this._pendingEvents);
+        const e = new EvDbEvent(
+            payload.payloadType,
+            cursor,
+            payload,
+            new Date(),
+            capturedBy,
+        );
+        this._pendingEvents = [...this._pendingEvents, e];
+
+        // Apply to views
+        for (const view of Object.values(this._views)) {
+            view.applyEvent(e);
+        }
+
+        // Outbox producer
+        const viewsStates = Object.fromEntries(Object.entries(this._views)
+            .map(([k, v]) => {
+                return [k, (v as EvDbView<unknown>).state]
+            }));
+        const producedMessages = this.messagesProducer(e, viewsStates);
+        this._pendingMessages = [...this._pendingMessages, ...producedMessages]
+
+        return e;
+    }
+
+    private getNextCursor(events: ReadonlyArray<EvDbEvent>): EvDbStreamCursor {
+        if (events.length === 0) {
+            return new EvDbStreamCursor(this.streamAddress, this.storedOffset + 1);
+        }
+
+        const lastEvent = events[events.length - 1];
+        const offset = lastEvent.streamCursor.offset;
+        return new EvDbStreamCursor(this.streamAddress, offset + 1);
+    }
+
+    // AppendToOutbox
+    /**
+     * Put a row into the publication (out-box pattern).
+     */
+    public appendToOutbox(e: EvDbMessage): void {
+        this._pendingMessages = [...this._pendingMessages, e];
+    }
+
+    // StoreAsync
+    public async store(): Promise<StreamStoreAffected> {
+        // Telemetry
+        // const tags = this.streamAddress.toOtelTags();
+        // const duration = EvDbStream._sysMeters.measureStoreEventsDuration(tags);
+        // const activity = EvDbStream._trace.startActivity(tags, 'EvDb.Store');
+
+        try {
+            if (this._pendingEvents.length === 0) {
+                return StreamStoreAffected.Empty;
+            }
+
+            const affected = await this._storageAdapter.storeStreamAsync(
+                this._pendingEvents,
+                this._pendingMessages,
+            );
+
+            const lastEvent = this._pendingEvents[this._pendingEvents.length - 1];
+            this.storedOffset = lastEvent.streamCursor.offset;
+            this._pendingEvents = [];
+            this._pendingMessages = [];
+
+            const viewSaveTasks = Object.values(this._views).map(v => v.store());
+            await Promise.all(viewSaveTasks);
+
+            return affected;
+        } catch (error) {
+            if (error instanceof OCCException) {
+                throw error;
+            }
+            throw error;
+        }
+
+    }
+
+    // CountOfPendingEvents
+    /**
+     * number of events that were not stored yet.
+     */
+    public get countOfPendingEvents(): number {
+        return this._pendingEvents.length;
+    }
+
+    // Notifications
+    /**
+     * Unspecialized messages
+     */
+    public getMessages(): ReadonlyArray<EvDbMessage> {
+        return this._pendingMessages;
+    }
+}