In memory inline projections - Add inMemoryDatabase

src/packages/emmett/src/database/inMemoryDatabase.ts

@@ -0,0 +1,49 @@
+import { JSONParser } from '../serialization';
+
+export interface DocumentsCollection<T> {
+  store: (id: string, obj: T) => void;
+  delete: (id: string) => void;
+  get: (id: string) => T | null;
+}
+
+export type DocumentHandler<T> =
+  | ((document: T | null) => T | null)
+  | ((document: T | null) => Promise<T | null>);
+
+export interface Database {
+  collection: <T>(name: string) => DocumentsCollection<T>;
+}
+
+export const getInMemoryDatabase = (): Database => {
+  const storage = new Map<string, unknown>();
+
+  return {
+    collection: <T>(
+      collectionName: string,
+      _collectionOptions: {
+        errors?: { throwOnOperationFailures?: boolean } | undefined;
+      } = {},
+    ): DocumentsCollection<T> => {
+      const toFullId = (id: string) => `${collectionName}-${id}`;
+
+      const collection = {
+        store: (id: string, obj: T): void => {
+          storage.set(toFullId(id), obj);
+        },
+        delete: (id: string): void => {
+          storage.delete(toFullId(id));
+        },
+        get: (id: string): T | null => {
+          const result = storage.get(toFullId(id));
+
+          return result
+            ? // Clone to simulate getting new instance on loading
+              (JSONParser.parse(JSONParser.stringify(result)) as T)
+            : null;
+        },
+      };
+
+      return collection;
+    },
+  };
+};

src/packages/emmett/src/eventStore/inMemoryEventStore.ts

@@ -19,14 +19,27 @@ import {
 } from './eventStore';
 import { assertExpectedVersionMatchesCurrent } from './expectedVersion';
 import { StreamingCoordinator } from './subscriptions';
+import type { ProjectionRegistration } from '../projections';
 
 export const InMemoryEventStoreDefaultStreamVersion = 0n;
 
 export type InMemoryEventStore =
   EventStore<ReadEventMetadataWithGlobalPosition>;
 
+export type InMemoryReadEventMetadata = ReadEventMetadataWithGlobalPosition;
+
+export type InMemoryProjectionHandlerContext = {
+  eventStore: InMemoryEventStore;
+};
+
 export type InMemoryEventStoreOptions =
-  DefaultEventStoreOptions<InMemoryEventStore>;
+  DefaultEventStoreOptions<InMemoryEventStore> & {
+    projections?: ProjectionRegistration<
+      'inline',
+      InMemoryReadEventMetadata,
+      InMemoryProjectionHandlerContext
+    >[];
+  };
 
 export type InMemoryReadEvent<EventType extends Event = Event> = ReadEvent<
   EventType,
@@ -48,6 +61,10 @@ export const getInMemoryEventStore = (
       .reduce((p, c) => p + c, 0);
   };
 
+  const _inlineProjections = (eventStoreOptions?.projections ?? [])
+    .filter(({ type }) => type === 'inline')
+    .map(({ projection }) => projection);
+
   return {
     async aggregateStream<State, EventType extends Event>(
       streamName: string,