@eventualize/core 1.0.0 → 2.0.0

package/dist/EvDbStream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/EvDbStream.test.js

@@ -0,0 +1,21 @@
+import { test, describe } from 'node:test';
+import * as assert from 'node:assert';
+describe('EvDbStream', () => {
+    test('module can be imported', async () => {
+        const module = await import('./EvDbStream.js');
+        assert.ok(module.default, 'EvDbStream should be exported as default');
+    });
+});
+describe('EvDbView', () => {
+    test('module can be imported', async () => {
+        const module = await import('./EvDbView.js');
+        assert.ok(module.EvDbView, 'EvDbView should be exported');
+    });
+});
+describe('EvDbEventStore', () => {
+    test('module can be imported', async () => {
+        const module = await import('./EvDbEventStore.js');
+        assert.ok(module.EvDbEventStoreBuilder, 'EvDbEventStoreBuilder should be exported');
+    });
+});
+//# sourceMappingURL=EvDbStream.test.js.map

package/dist/EvDbStream.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvDbStream.test.js","sourceRoot":"","sources":["../src/EvDbStream.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IAC1B,IAAI,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;QACxC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAC/C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,0CAA0C,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE;IACxB,IAAI,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;QACxC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,eAAe,CAAC,CAAC;QAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,6BAA6B,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,IAAI,CAAC,wBAAwB,EAAE,KAAK,IAAI,EAAE;QACxC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,qBAAqB,CAAC,CAAC;QACnD,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,qBAAqB,EAAE,0CAA0C,CAAC,CAAC;IACtF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@eventualize/core",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outsidenote/eventualize-js",
+    "directory": "packages/core"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -9,7 +14,13 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./*": "./dist/*.js"
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "tsc --build",
@@ -18,8 +29,11 @@
     "test": "echo not tests implemented yet."
   },
   "dependencies": {
-    "@eventualize/types": "1.0.0"
+    "@eventualize/types": "2.0.0"
   },
   "license": "ISC",
-  "type": "module"
+  "type": "module",
+  "files": [
+    "dist"
+  ]
 }

package/src/EvDbEventStore.ts

@@ -1,302 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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;
-    }
-}

package/src/EvDbStreamFactory.ts

@@ -1,290 +0,0 @@
-import IEvDbStorageSnapshotAdapter from '@eventualize/types/IEvDbStorageSnapshotAdapter';
-import IEvDbStorageStreamAdapter from '@eventualize/types/IEvDbStorageStreamAdapter';
-import IEvDbEventPayload from "@eventualize/types/IEvDbEventPayload";
-import EvDbStreamCursor from '@eventualize/types/EvDbStreamCursor';
-import EvDbStreamAddress from '@eventualize/types/EvDbStreamAddress';
-import EVDbMessagesProducer from '@eventualize/types/EvDbMessagesProducer';
-
-import EvDbStream from './EvDbStream.js';
-import { EvDbView } from './EvDbView.js';
-import { ViewFactory, createViewFactory, EvDbStreamEventHandlersMap } from './EvDbViewFactory.js';
-import EvDbEvent from '@eventualize/types/EvDbEvent.js';
-
-/**
- * Configuration for creating a stream factory
- */
-export interface EvDbStreamFactoryConfig<TEvents extends IEvDbEventPayload, TStreamType extends string> {
-  streamType: TStreamType;
-  viewFactories: ViewFactory<any, TEvents>[];
-  eventTypes: EventTypeConfig<TEvents>[];
-  viewNames: string[]; // Track view names for accessor creation
-}
-
-/**
- * Configuration for each event type
- */
-export interface EventTypeConfig<
-  TEvent extends IEvDbEventPayload,
-> {
-  eventClass: new (...args: any[]) => TEvent;
-  eventName: string;
-  eventMessagesProducer?: EVDbMessagesProducer;
-}
-
-/**
- * Type helper to extract event methods
- */
-type EventMethods<TEvents extends IEvDbEventPayload> = {
-  [K in TEvents as `appendEvent${K['payloadType']}`]: (event: K) => Promise<void>;
-};
-
-/**
- * Type helper to create view accessors map
- */
-type ViewAccessors<TViews extends Record<string, EvDbView<any>>> = {
-  readonly views: TViews;
-};
-
-/**
- * Combined stream type with event methods and view accessors
- */
-export type StreamWithEventMethods<TEvents extends IEvDbEventPayload, TViews extends Record<string, EvDbView<any>> = {}> =
-  EvDbStream & EventMethods<TEvents> & ViewAccessors<TViews>;
-
-/**
- * Stream Factory - creates stream instances with configured views and dynamic event methods
- */
-export class EvDbStreamFactory<TEvents extends IEvDbEventPayload, TStreamType extends string, TViews extends Record<string, EvDbView<any>> = {}> {
-  private DynamicStreamClass: new (
-    streamType: string,
-    views: EvDbView<any>[],
-    streamStorageAdapter: IEvDbStorageStreamAdapter,
-    streamId: string,
-    lastStreamOffset: number,
-  ) => StreamWithEventMethods<TEvents, TViews>;
-
-  constructor(private readonly config: EvDbStreamFactoryConfig<TEvents, TStreamType>) {
-    this.DynamicStreamClass = this.createDynamicStreamClass();
-  }
-
-  /**
-   * Creates a dynamic stream class with event-specific methods and view accessors
-   */
-  private createDynamicStreamClass() {
-    const eventTypes = this.config.eventTypes;
-    const viewNames = this.config.viewNames;
-
-    const messagesProducer: EVDbMessagesProducer = (event: EvDbEvent, viewsState: Readonly<Record<string, unknown>>) => {
-      const eventType = eventTypes.find(e => e.eventName === event.eventType);
-      if (!eventType || !eventType.eventMessagesProducer) return [];
-      return eventType.eventMessagesProducer(event, viewsState);
-    }
-
-    class DynamicStream extends EvDbStream {
-      public readonly views: Record<string, EvDbView<any>> = {};
-
-      constructor(
-        streamType: string,
-        views: EvDbView<any>[],
-        streamStorageAdapter: IEvDbStorageStreamAdapter,
-        streamId: string,
-        lastStreamOffset: number,
-      ) {
-        super(streamType, views, streamStorageAdapter, streamId, lastStreamOffset, messagesProducer);
-
-        // Create view accessors
-        views.forEach((view, index) => {
-          const viewName = viewNames[index];
-          if (viewName) {
-            this.views[viewName] = view;
-          }
-        });
-      }
-    }
-
-    // Add dynamic methods for each event type
-    eventTypes.forEach(({ eventName }) => {
-      const methodName = `appendEvent${eventName}`;
-      (DynamicStream.prototype as any)[methodName] = async function (event: IEvDbEventPayload) {
-        return this.appendEvent(event);
-      };
-    });
-
-    return DynamicStream as any;
-  }
-
-  /**
-   * Creates a stream instance with all configured views and dynamic event methods
-   */
-  public create(
-    streamId: string,
-    streamStorageAdapter: IEvDbStorageStreamAdapter,
-    snapshotStorageAdapter: IEvDbStorageSnapshotAdapter,
-    lastStreamOffset: number = 0
-  ): StreamWithEventMethods<TEvents, TViews> {
-    const views = this.createViews(streamId, snapshotStorageAdapter);
-
-    return new this.DynamicStreamClass(
-      this.config.streamType,
-      views,
-      streamStorageAdapter,
-      streamId,
-      lastStreamOffset,
-    );
-  }
-
-  private createViews(streamId: string, snapshotStorageAdapter: IEvDbStorageSnapshotAdapter): Array<EvDbView<any>> {
-    const views = this.config.viewFactories.map(factory =>
-      factory.create(streamId, snapshotStorageAdapter)
-    );
-    return views;
-  }
-
-  private getViews(streamId: string, snapshotStorageAdapter: IEvDbStorageSnapshotAdapter): Promise<EvDbView<any>>[] {
-    const getViewPromises = this.config.viewFactories.map(viewFactory =>
-      viewFactory.get(streamId, snapshotStorageAdapter)
-    );
-    return getViewPromises;
-  }
-
-  /**
-   * Fetches from storage a stream instance with all configured views and dynamic event methods
-   */
-  public async get(
-    streamId: string,
-    streamStorageAdapter: IEvDbStorageStreamAdapter,
-    snapshotStorageAdapter: IEvDbStorageSnapshotAdapter
-  ): Promise<StreamWithEventMethods<TEvents, TViews>> {
-    const streamAddress = new EvDbStreamAddress(this.config.streamType, streamId);
-
-    const views = await Promise.all(this.getViews(streamId, snapshotStorageAdapter));
-
-    if (!views.length) {
-      const lastStreamOffset = await streamStorageAdapter.getLastOffsetAsync(streamAddress);
-      const stream = this.create(streamId, streamStorageAdapter, snapshotStorageAdapter, lastStreamOffset);
-      return stream;
-    }
-
-    const lowestViewOffset = views.reduce((lowestOffset: number, currentView: EvDbView<any>) =>
-      Math.min(lowestOffset, currentView.storeOffset),
-      Number.MAX_VALUE
-    );
-
-    const streamCursor = new EvDbStreamCursor(streamAddress, lowestViewOffset + 1);
-    const events = await streamStorageAdapter.getEventsAsync(streamCursor);
-
-    let streamOffset = lowestViewOffset;
-    for await (const event of events) {
-      views.forEach(view => view.applyEvent(event));
-      streamOffset = event.streamCursor.offset;
-    }
-
-    return new this.DynamicStreamClass(
-      this.config.streamType,
-      views,
-      streamStorageAdapter,
-      streamId,
-      streamOffset
-    );
-  }
-
-  public getStreamType(): TStreamType {
-    return this.config.streamType;
-  }
-}
-
-/**
- * Factory function to create a StreamFactory
- */
-export function createEvDbStreamFactory<TEvents extends IEvDbEventPayload, TStreamType extends string, TViews extends Record<string, EvDbView<any>> = {}>(
-  config: EvDbStreamFactoryConfig<TEvents, TStreamType>
-): EvDbStreamFactory<TEvents, TStreamType, TViews> {
-  return new EvDbStreamFactory(config);
-}
-
-/**
- * Fluent builder for creating stream factories with inferred event types
- */
-export class StreamFactoryBuilder<
-  TStreamType extends string,
-  TEvents extends IEvDbEventPayload = never,
-  TViews extends Record<string, EvDbView<any>> = {}
-> {
-  private viewFactories: ViewFactory<any, TEvents>[] = [];
-  private eventTypes: EventTypeConfig<any>[] = [];
-  private viewNames: string[] = [];
-
-  constructor(private streamType: TStreamType) { }
-
-  /**
-   * Register event type for dynamic method generation - infers the event name from class name
-   */
-  withEventType<TEvent extends IEvDbEventPayload>(
-    eventClass: new (...args: any[]) => TEvent,
-    eventMessagesProducer?: EVDbMessagesProducer): StreamFactoryBuilder<
-      TStreamType,
-      TEvents | TEvent,
-      TViews
-    > {
-    // Use the class name as the event name
-    const eventName = eventClass.name;
-
-    this.eventTypes.push({ eventClass, eventName, eventMessagesProducer } as EventTypeConfig<TEvent>);
-    return this as any;
-  }
-
-  /**
-   * Add a view with inline handler definition
-   * This can only be called AFTER withEventType calls to ensure type safety
-   */
-  public withView<TViewName extends string, TState>(
-    viewName: TViewName,
-    stateClass: new (...args: any[]) => TState,
-    handlers: EvDbStreamEventHandlersMap<TState, TEvents>
-  ): StreamFactoryBuilder<TStreamType, TEvents, TViews & Record<TViewName, EvDbView<TState>>> {
-    // Create default state instance
-    const defaultState = new stateClass();
-
-    // Create the view factory
-    const viewFactory = createViewFactory<TState, TEvents>({
-      viewName,
-      streamType: this.streamType,
-      defaultState,
-      handlers
-    });
-
-    this.viewFactories.push(viewFactory);
-    this.viewNames.push(viewName);
-    return this as any;
-  }
-
-  /**
-   * Add a pre-created view factory (legacy support)
-   */
-  public withViewFactory<TViewName extends string, TState>(
-    viewName: TViewName,
-    viewFactory: ViewFactory<TState, TEvents>
-  ): StreamFactoryBuilder<TStreamType, TEvents, TViews & Record<TViewName, EvDbView<TState>>> {
-    this.viewFactories.push(viewFactory);
-    this.viewNames.push(viewName);
-    return this as any;
-  }
-
-  /**
-   * Build the stream factory
-   */
-  public build() {
-    const factory = new EvDbStreamFactory({
-      streamType: this.streamType,
-      viewFactories: this.viewFactories,
-      eventTypes: this.eventTypes,
-      viewNames: this.viewNames
-    }) as EvDbStreamFactory<TEvents, TStreamType, TViews>;
-
-    // Return factory with type helper for stream type extraction
-    return Object.assign(factory, {
-      // This is a type-only property for extracting the stream type
-      StreamType: null as unknown as StreamWithEventMethods<TEvents, TViews>
-    });
-  }
-}

package/src/EvDbView.ts

@@ -1,100 +0,0 @@
-import IEvDbViewStore, { IEvDbViewStoreGeneric } from "@eventualize/types/IEvDbViewStore";
-import EvDbViewAddress from "@eventualize/types/EvDbViewAddress";
-import IEvDbStorageSnapshotAdapter from "@eventualize/types/IEvDbStorageSnapshotAdapter";
-import EvDbEvent from "@eventualize/types/src/EvDbEvent";
-import { EvDbStoredSnapshotData } from "@eventualize/types/EvDbStoredSnapshotData";
-import { EvDbStoredSnapshotResult } from "@eventualize/types/EvDbStoredSnapshotResult";
-import IEvDbEventMetadata from "@eventualize/types/IEvDbEventMetadata";
-import IEvDbEventPayload from "@eventualize/types/IEvDbEventPayload";
-
-
-export abstract class EvDbViewRaw implements IEvDbViewStore {
-    private _memoryOffset: number;
-    private _storeOffset: number;
-    private _storedAt: Date;
-
-    protected constructor(
-        private readonly _storageAdapter: IEvDbStorageSnapshotAdapter,
-        public readonly address: EvDbViewAddress,
-        snapshot: EvDbStoredSnapshotResult<any>
-
-    ) {
-        const storeOffset = snapshot.offset ?? 0;
-        this._memoryOffset = storeOffset;
-        this._storeOffset = storeOffset;
-
-        this._storedAt = snapshot.storedAt ?? new Date();
-    }
-    public abstract getSnapshotData(): EvDbStoredSnapshotData;
-
-    get storedAt(): Date { return this._storedAt };
-    get storeOffset(): number { return this._storeOffset };
-    get memoryOffset(): number { return this._memoryOffset };
-
-    shouldStoreSnapshot(offsetGapFromLastSave: number, durationSinceLastSaveMs: number): boolean {
-        return true;
-    }
-    applyEvent(e: EvDbEvent): void {
-        const offset = e.streamCursor.offset;
-        if (this.memoryOffset >= offset) {
-            return;
-        }
-        this.onApplyEvent(e);
-        this._memoryOffset = offset;
-    }
-
-    async store(): Promise<void> {
-        const eventsSinceLatestSnapshot = this.memoryOffset - this.storeOffset;
-        const secondsSinceLatestSnapshot = new Date().getTime() - this.storedAt.getTime();
-        if (!this.shouldStoreSnapshot(eventsSinceLatestSnapshot, secondsSinceLatestSnapshot)) {
-            return;
-        }
-        const snapshotData = this.getSnapshotData();
-        await this._storageAdapter.storeSnapshotAsync(snapshotData);
-        this._storeOffset = this._memoryOffset;
-    }
-
-    protected abstract onApplyEvent(e: EvDbEvent): void;
-}
-
-export abstract class EvDbView<TState> extends EvDbViewRaw implements IEvDbViewStoreGeneric<TState> {
-    protected getDefaultState(): TState {
-        return this.defaultState;
-    };
-    protected _state: TState = this.getDefaultState();
-    get state(): TState { return this._state }
-    // public getState(): TState {
-    //     return this._state;
-    // }
-
-    public constructor(
-        address: EvDbViewAddress,
-        storageAdapter: IEvDbStorageSnapshotAdapter,
-        snapshot: EvDbStoredSnapshotResult<TState>,
-        public readonly defaultState: TState
-    ) {
-        super(storageAdapter, address, snapshot);
-        if (snapshot.offset === 0)
-            this._state = this.getDefaultState();
-        else
-            this._state = snapshot.state;
-
-
-    }
-
-    getSnapshotData(): EvDbStoredSnapshotData {
-        return EvDbStoredSnapshotData.fromAddress(
-            this.address,
-            this.memoryOffset,
-            this.storeOffset,
-            this._state
-        );
-    }
-
-    public abstract handleOnApply(oldState: TState, event: IEvDbEventPayload, metadata: IEvDbEventMetadata): TState
-
-    protected onApplyEvent(e: EvDbEvent): void {
-        this._state = this.handleOnApply(this._state, e.payload, e);
-    }
-
-}

package/src/EvDbViewFactory.ts

@@ -1,123 +0,0 @@
-import { EvDbView } from './EvDbView.js';
-import IEvDbEventPayload from "@eventualize/types/IEvDbEventPayload";
-import IEvDbEventMetadata from '@eventualize/types/IEvDbEventMetadata';
-import IEvDbStorageSnapshotAdapter from '@eventualize/types/IEvDbStorageSnapshotAdapter';
-import EvDbViewAddress from '@eventualize/types/EvDbViewAddress';
-import EvDbStreamAddress from '@eventualize/types/EvDbStreamAddress';
-import { EvDbStoredSnapshotResult } from '@eventualize/types/EvDbStoredSnapshotResult';
-
-/**
- * Handler function type for applying an event to state
- */
-export type EvDbViewEventHandler<TState, TEvent extends IEvDbEventPayload> = (
-    oldState: TState,
-    event: TEvent,
-    metadata: IEvDbEventMetadata
-) => TState;
-
-/**
- * Map of event handlers - one handler per event type in the union
- * Key is the payloadType string, value is the handler function
- */
-export type EvDbStreamEventHandlersMap<TState, TEvents extends IEvDbEventPayload> = {
-    [K in TEvents['payloadType']]: EvDbViewEventHandler<
-        TState,
-        Extract<TEvents, { payloadType: K }>
-    >;
-};
-/**
- * Configuration for creating a view
- */
-export interface ViewConfig<TState, TEvents extends IEvDbEventPayload> {
-    viewName: string;
-    streamType: string;
-    defaultState: TState;
-    handlers: Partial<EvDbStreamEventHandlersMap<TState, TEvents>>;
-}
-
-/**
- * Generic View class that uses the handlers map
- */
-class GenericView<TState, TEvents extends IEvDbEventPayload> extends EvDbView<TState> {
-
-    constructor(
-        viewAddress: EvDbViewAddress,
-        storageAdapter: IEvDbStorageSnapshotAdapter,
-        snapshot: EvDbStoredSnapshotResult<TState>,
-        public readonly config: ViewConfig<TState, TEvents>
-    ) {
-        super(viewAddress, storageAdapter, snapshot, config.defaultState);
-        this.config = config;
-    }
-
-
-    /**
-     * Dynamically applies events based on the handlers map
-     */
-    public handleOnApply(oldState: TState, event: TEvents, metadata: IEvDbEventMetadata): TState {
-        const payloadType = event.payloadType as keyof typeof this.config.handlers;
-        const handler = this.config.handlers[payloadType];
-
-        if (!handler) {
-            // console.warn(`No handler found for event type: ${event.payloadType}`);
-            return oldState;
-        }
-
-        return handler(oldState, event as any, metadata);
-    }
-}
-
-/**
- * View Factory - creates view instances with the handlers map
- */
-export class ViewFactory<TState, TEvents extends IEvDbEventPayload> {
-    constructor(private readonly config: ViewConfig<TState, TEvents>) { }
-
-    /**
-     * Creates a view instance
-     */
-    public create(
-        streamId: string,
-        storageAdapter: IEvDbStorageSnapshotAdapter
-    ): EvDbView<TState> {
-        const streamAddress = new EvDbStreamAddress(this.config.streamType, streamId);
-        const viewAddress = new EvDbViewAddress(streamAddress, this.config.viewName);
-
-        return new GenericView<TState, TEvents>(
-            viewAddress,
-            storageAdapter,
-            EvDbStoredSnapshotResult.getEmptyState<TState>(),
-            this.config
-        );
-    }
-
-    /**
-     * Get a view instance from event store
-     */
-    public async get(
-        streamId: string,
-        storageAdapter: IEvDbStorageSnapshotAdapter
-    ): Promise<EvDbView<TState>> {
-        const streamAddress = new EvDbStreamAddress(this.config.streamType, streamId);
-        const viewAddress = new EvDbViewAddress(streamAddress, this.config.viewName);
-
-        const snapshot = await storageAdapter.getSnapshotAsync(viewAddress)
-
-        return new GenericView<TState, TEvents>(
-            viewAddress,
-            storageAdapter,
-            snapshot,
-            this.config
-        );
-    }
-}
-
-/**
- * Factory function to create a ViewFactory
- */
-export function createViewFactory<TState, TEvents extends IEvDbEventPayload>(
-    config: ViewConfig<TState, TEvents>
-): ViewFactory<TState, TEvents> {
-    return new ViewFactory(config);
-}
-

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "moduleResolution": "node",
-    "module": "es2020",
-    "target": "es2020",
-    "strict": true,
-    "esModuleInterop": true,
-  },
-  "references": [
-    {
-      "path": "../types"
-    }
-  ],
-  "include": ["src/**/*"]
-}