@event-driven-io/emmett-postgresql 0.15.0 → 0.16.0

package/dist/postgreSQLEventStore-loGROgA0.d.ts

@@ -0,0 +1,159 @@
+import { Dumbo, DumboOptions, QueryResultRow, SQL, NodePostgresClient, SQLExecutor, NodePostgresTransaction, NodePostgresConnector, NodePostgresPoolClientConnection, NodePostgresClientConnection } from '@event-driven-io/dumbo';
+import { Event, ReadEvent, CanHandle, ReadEventMetadataWithGlobalPosition, ThenThrows, ProjectionHandler, TypedProjectionDefinition, EventStore, DefaultStreamVersionType, ProjectionRegistration } from '@event-driven-io/emmett';
+import pg from 'pg';
+import { PongoDocument, WithId, PongoFilter, PongoClient } from '@event-driven-io/pongo';
+
+type PongoAssertOptions = {
+    inCollection: string;
+    inDatabase?: string;
+};
+type FilterOrId<Doc extends PongoDocument | WithId<PongoDocument>> = {
+    withId: string;
+} | {
+    matchingFilter: PongoFilter<Doc>;
+};
+declare const documentExists: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsAreTheSame: <Doc extends PongoDocument | WithId<PongoDocument>>(documents: Doc[], options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentsMatchingHaveCount: <Doc extends PongoDocument | WithId<PongoDocument>>(expectedCount: number, options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentMatchingExists: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const documentDoesNotExist: <Doc extends PongoDocument | WithId<PongoDocument>>(options: PongoAssertOptions & FilterOrId<Doc>) => PostgreSQLProjectionAssert;
+declare const expectPongoDocuments: {
+    fromCollection: (collectionName: string) => {
+        withId: (id: string) => {
+            toBeEqual: <Doc extends PongoDocument | WithId<PongoDocument>>(document: Doc) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+        matching: <Doc_1 extends PongoDocument | WithId<PongoDocument>>(filter: PongoFilter<Doc_1>) => {
+            toBeTheSame: (documents: Doc_1[]) => PostgreSQLProjectionAssert;
+            toHaveCount: (expectedCount: number) => PostgreSQLProjectionAssert;
+            toExist: () => PostgreSQLProjectionAssert;
+            notToExist: () => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PongoProjectionHandlerContext = PostgreSQLProjectionHandlerContext & {
+    pongo: PongoClient;
+};
+type PongoDocumentEvolve<Document extends PongoDocument, EventType extends Event> = ((document: Document | null, event: ReadEvent<EventType>) => Document | null) | ((document: Document | null, event: ReadEvent<EventType>) => Promise<Document | null>);
+type PongoProjectionOptions<EventType extends Event> = {
+    handle: (events: ReadEvent<EventType>[], context: PongoProjectionHandlerContext) => Promise<void>;
+    canHandle: CanHandle<EventType>;
+};
+declare const pongoProjection: <EventType extends Event>({ handle, canHandle, }: PongoProjectionOptions<EventType>) => PostgreSQLProjectionDefinition;
+type PongoMultiStreamProjectionOptions<Document extends PongoDocument, EventType extends Event> = {
+    collectionName: string;
+    getDocumentId: (event: ReadEvent<EventType>) => string;
+    evolve: PongoDocumentEvolve<Document, EventType>;
+    canHandle: CanHandle<EventType>;
+};
+declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event>({ collectionName, getDocumentId, evolve, canHandle, }: PongoMultiStreamProjectionOptions<Document, EventType>) => PostgreSQLProjectionDefinition;
+type PongoSingleStreamProjectionOptions<Document extends PongoDocument, EventType extends Event> = {
+    collectionName: string;
+    evolve: PongoDocumentEvolve<Document, EventType>;
+    canHandle: CanHandle<EventType>;
+};
+declare const pongoSingleStreamProjection: <Document extends PongoDocument, EventType extends Event>({ collectionName, evolve, canHandle, }: PongoSingleStreamProjectionOptions<Document, EventType>) => PostgreSQLProjectionDefinition;
+
+type PostgreSQLProjectionSpecEvent<EventType extends Event> = EventType & {
+    metadata?: Partial<ReadEventMetadataWithGlobalPosition>;
+};
+declare const eventInStream: <EventType extends Event = Event>(streamName: string, event: PostgreSQLProjectionSpecEvent<EventType>) => PostgreSQLProjectionSpecEvent<EventType>;
+declare const eventsInStream: <EventType extends Event = Event>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType>[]) => PostgreSQLProjectionSpecEvent<EventType>[];
+declare const newEventsInStream: <EventType extends Event = Event>(streamName: string, events: PostgreSQLProjectionSpecEvent<EventType>[]) => PostgreSQLProjectionSpecEvent<EventType>[];
+type PostgreSQLProjectionAssert = (options: {
+    pool: Dumbo;
+    connectionString: string;
+}) => Promise<void | boolean>;
+type PostgreSQLProjectionSpecOptions = {
+    projection: PostgreSQLProjectionDefinition;
+} & DumboOptions;
+type PostgreSQLProjectionSpec<EventType extends Event> = (givenEvents: PostgreSQLProjectionSpecEvent<EventType>[]) => {
+    when: (events: PostgreSQLProjectionSpecEvent<EventType>[]) => {
+        then: (assert: PostgreSQLProjectionAssert, message?: string) => Promise<void>;
+        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
+    };
+};
+declare const PostgreSQLProjectionSpec: {
+    for: <EventType extends Event>(options: PostgreSQLProjectionSpecOptions) => PostgreSQLProjectionSpec<EventType>;
+};
+declare const assertSQLQueryResultMatches: <T extends QueryResultRow>(sql: SQL, rows: T[]) => PostgreSQLProjectionAssert;
+declare const expectSQL: {
+    query: (sql: SQL) => {
+        resultRows: {
+            toBeTheSame: <T extends QueryResultRow>(rows: T[]) => PostgreSQLProjectionAssert;
+        };
+    };
+};
+
+type PostgreSQLProjectionHandlerContext = {
+    connectionString: string;
+    client: NodePostgresClient;
+    execute: SQLExecutor;
+    transaction: NodePostgresTransaction;
+};
+type PostgreSQLProjectionHandler<EventType extends Event = Event> = ProjectionHandler<EventType, PostgreSQLProjectionHandlerContext>;
+interface PostgreSQLProjectionDefinition<EventType extends Event = Event> extends TypedProjectionDefinition<EventType, PostgreSQLProjectionHandlerContext> {
+}
+declare const defaultPostgreSQLProjectionOptions: PostgresEventStoreOptions;
+declare const handleProjections: <EventType extends Event = Event>(allProjections: PostgreSQLProjectionDefinition<EventType>[], connectionString: string, transaction: NodePostgresTransaction, events: ReadEvent<EventType>[]) => Promise<void>;
+declare const postgreSQLProjection: <EventType extends Event>(definition: PostgreSQLProjectionDefinition<EventType>) => PostgreSQLProjectionDefinition;
+declare const postgreSQLRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[], ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition;
+declare const postgreSQLRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL> | SQL, ...canHandle: CanHandle<EventType>) => PostgreSQLProjectionDefinition;
+
+interface PostgresEventStore extends EventStore<DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition> {
+    close(): Promise<void>;
+}
+type PostgresEventStorePooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pool: pg.Pool;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: true;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+};
+type PostgresEventStoreNotPooledOptions = {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    client: pg.Client;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    pooled: false;
+} | {
+    connector?: NodePostgresConnector;
+    connectionString?: string;
+    database?: string;
+    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
+    pooled?: false;
+};
+type PostgresEventStoreConnectionOptions = PostgresEventStorePooledOptions | PostgresEventStoreNotPooledOptions;
+type PostgresEventStoreOptions = {
+    projections: ProjectionRegistration<'inline', PostgreSQLProjectionHandlerContext>[];
+    connectionOptions?: PostgresEventStoreConnectionOptions;
+};
+declare const getPostgreSQLEventStore: (connectionString: string, options?: PostgresEventStoreOptions) => PostgresEventStore;
+
+export { type PostgreSQLProjectionSpecEvent as A, eventInStream as B, eventsInStream as C, newEventsInStream as D, PostgreSQLProjectionSpec as E, type PostgreSQLProjectionAssert as F, type PostgreSQLProjectionSpecOptions as G, assertSQLQueryResultMatches as H, expectSQL as I, type PostgresEventStore as P, type PostgresEventStoreConnectionOptions as a, type PostgresEventStoreOptions as b, type PostgreSQLProjectionHandlerContext as c, type PostgreSQLProjectionHandler as d, type PostgreSQLProjectionDefinition as e, defaultPostgreSQLProjectionOptions as f, getPostgreSQLEventStore as g, handleProjections as h, postgreSQLRawBatchSQLProjection as i, postgreSQLRawSQLProjection as j, type PongoAssertOptions as k, documentExists as l, documentsAreTheSame as m, documentsMatchingHaveCount as n, documentMatchingExists as o, postgreSQLProjection as p, documentDoesNotExist as q, expectPongoDocuments as r, type PongoProjectionHandlerContext as s, type PongoDocumentEvolve as t, type PongoProjectionOptions as u, pongoProjection as v, type PongoMultiStreamProjectionOptions as w, pongoMultiStreamProjection as x, type PongoSingleStreamProjectionOptions as y, pongoSingleStreamProjection as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@event-driven-io/emmett-postgresql",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Emmett - PostgreSQL - Event Sourcing development made simple",
   "scripts": {
     "build": "tsup",
@@ -52,11 +52,7 @@
     "@event-driven-io/emmett-testcontainers": "^0.5.0"
   },
   "peerDependencies": {
-    "@event-driven-io/emmett": "0.15.0",
-    "@types/pg": "^8.11.6",
-    "@types/pg-format": "^1.0.5",
-    "pg": "^8.12.0",
-    "pg-format": "^1.0.4",
-    "@event-driven-io/pongo": "0.10.0"
+    "@event-driven-io/emmett": "0.16.0",
+    "@event-driven-io/pongo": "0.12.5"
   }
 }

package/dist/chunk-5DKEA5F6.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _pongo = require('@event-driven-io/pongo');require('pg');require('@event-driven-io/dumbo');var T={projections:[]},m= exports.e =async(e,o,t,n)=>{let r=n.map(i=>i.type),s=e.filter(i=>i.canHandle.some(v=>r.includes(v))),p=await t.connection.open();for(let i of s)await i.handle(n,{connectionString:o,client:p,transaction:t,execute:t.execute})},E= exports.f =e=>e,x= exports.g =E,c= exports.h =e=>E({type:"inline",...e}),S= exports.i =c,P= exports.j =(e,...o)=>c({canHandle:o,handle:async(t,n)=>{let r=await e(t,n);await n.execute.batchCommand(r)}}),j= exports.k =(e,...o)=>P(async(t,n)=>{let r=[];for(let s of t)r.push(await e(s,n));return r},...o);var a=(e,...o)=>c({canHandle:o,handle:async(t,n)=>{let{connectionString:r,client:s}=n,p=_pongo.pongoClient.call(void 0, r,{client:s});await e(p,t)}}),g= exports.b =(e,o,t,...n)=>a(async(r,s)=>{let p=r.db().collection(e);for(let i of s)await p.handle(o(i),async v=>await t(v,i))},...n),H= exports.c =(e,o,...t)=>g(e,n=>n.metadata.streamName,o,...t);exports.a = a; exports.b = g; exports.c = H; exports.d = T; exports.e = m; exports.f = E; exports.g = x; exports.h = c; exports.i = S; exports.j = P; exports.k = j;
-//# sourceMappingURL=chunk-5DKEA5F6.js.map

package/dist/chunk-5DKEA5F6.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eventStore/projections/pongo.ts","../src/eventStore/projections/index.ts"],"names":["pongoClient","defaultPostgreSQLProjectionOptions","handleProjections","allProjections","connectionString","transaction","events","eventTypes","e","projections","p","type","client","projection","postgreSQLProjection","definition","postgreSQLInlineProjection","inlineProjection","postgreSQLRawBatchSQLProjection","handle","canHandle","context","sqls","postgreSQLRawSQLProjection","event","pongoProjection","pongo","pongoMultiStreamProjection","collectionName","getDocumentId","evolve","collection","document","pongoSingleProjection"],"mappings":"AAKA,OACE,eAAAA,MAGK,yBACP,MAAe,KCVf,MAKO,yBA2BA,IAAMC,EAAgE,CAC3E,YAAa,CAAC,CAChB,EAEaC,EAAoB,MAC/BC,EACAC,EACAC,EACAC,IACkB,CAClB,IAAMC,EAAaD,EAAO,IAAKE,GAAMA,EAAE,IAAI,EAErCC,EAAcN,EAAe,OAAQO,GACzCA,EAAE,UAAU,KAAMC,GAASJ,EAAW,SAASI,CAAI,CAAC,CACtD,EAEMC,EAAU,MAAMP,EAAY,WAAW,KAAK,EAElD,QAAWQ,KAAcJ,EACvB,MAAMI,EAAW,OAAOP,EAAQ,CAC9B,iBAAAF,EACA,OAAAQ,EACA,YAAAP,EACA,QAASA,EAAY,OACvB,CAAC,CAEL,EAEaS,EACXC,GAEAA,EAGWF,EAAaC,EAEbE,EACXD,GAEAD,EAAqB,CAAE,KAAM,SAAU,GAAGC,CAAW,CAAC,EAG3CE,EAAmBD,EAEnBE,EAAkC,CAC7CC,KAIGC,IAEHJ,EAAsC,CACpC,UAAAI,EACA,OAAQ,MAAOd,EAAQe,IAAY,CACjC,IAAMC,EAAc,MAAMH,EAAOb,EAAQe,CAAO,EAEhD,MAAMA,EAAQ,QAAQ,aAAaC,CAAI,CACzC,CACF,CAAC,EAEUC,EAA6B,CACxCJ,KAIGC,IAEHF,EACE,MAAOZ,EAAQe,IAAY,CACzB,IAAMC,EAAc,CAAC,EAErB,QAAWE,KAASlB,EAClBgB,EAAK,KAAK,MAAMH,EAAOK,EAAOH,CAAO,CAAC,EAExC,OAAOC,CACT,EACA,GAAGF,CACL,EDnEK,IAAMK,EAAkB,CAC7BN,KACGC,IAEHJ,EAAsC,CACpC,UAAAI,EACA,OAAQ,MAAOd,EAAQe,IAAY,CACjC,GAAM,CAAE,iBAAAjB,EAAkB,OAAAQ,CAAO,EAAIS,EAC/BK,EAAQ1B,EAAYI,EAAkB,CAAE,OAAAQ,CAAO,CAAC,EACtD,MAAMO,EAAOO,EAAOpB,CAAM,CAC5B,CACF,CAAC,EAEUqB,EAA6B,CAIxCC,EACAC,EACAC,KACGV,IAEHK,EACE,MAAOC,EAAOpB,IAAW,CACvB,IAAMyB,EAAaL,EAAM,GAAG,EAAE,WAAqBE,CAAc,EAEjE,QAAWJ,KAASlB,EAClB,MAAMyB,EAAW,OAAOF,EAAcL,CAAK,EAAG,MAAOQ,GAC5C,MAAMF,EAAOE,EAAUR,CAAK,CACpC,CAEL,EACA,GAAGJ,CACL,EAEWa,EAAwB,CAInCL,EACAE,KACGV,IAEHO,EACEC,EACCJ,GAAUA,EAAM,SAAS,WAC1BM,EACA,GAAGV,CACL","sourcesContent":["import {\n  type Event,\n  type EventTypeOf,\n  type ReadEvent,\n} from '@event-driven-io/emmett';\nimport {\n  pongoClient,\n  type PongoClient,\n  type PongoDocument,\n} from '@event-driven-io/pongo';\nimport pg from 'pg';\nimport {\n  postgreSQLInlineProjection,\n  type PostgreSQLProjectionDefintion,\n} from './';\n\nexport type PongoProjectionOptions<EventType extends Event> = {\n  documentId: (event: ReadEvent<EventType>) => string;\n  eventHandler: PongoProjectionHandler<EventType>;\n  eventTypes: EventTypeOf<EventType>[];\n};\n\nexport type PongoProjectionHandler<EventType extends Event = Event> = (\n  documentId: (event: ReadEvent<EventType>) => string,\n  connectionString: string,\n  client: pg.PoolClient,\n  events: ReadEvent<EventType>[],\n) => Promise<void> | void;\n\nexport type PongoDocumentEvolve<\n  Document extends PongoDocument,\n  EventType extends Event,\n> =\n  | ((\n      document: Document | null,\n      event: ReadEvent<EventType>,\n    ) => Document | null)\n  | ((\n      document: Document | null,\n      event: ReadEvent<EventType>,\n    ) => Promise<Document | null>);\n\nexport const pongoProjection = <EventType extends Event>(\n  handle: (pongo: PongoClient, events: ReadEvent<EventType>[]) => Promise<void>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLInlineProjection<EventType>({\n    canHandle,\n    handle: async (events, context) => {\n      const { connectionString, client } = context;\n      const pongo = pongoClient(connectionString, { client });\n      await handle(pongo, events);\n    },\n  });\n\nexport const pongoMultiStreamProjection = <\n  Document extends PongoDocument,\n  EventType extends Event,\n>(\n  collectionName: string,\n  getDocumentId: (event: ReadEvent<EventType>) => string,\n  evolve: PongoDocumentEvolve<Document, EventType>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  pongoProjection(\n    async (pongo, events) => {\n      const collection = pongo.db().collection<Document>(collectionName);\n\n      for (const event of events) {\n        await collection.handle(getDocumentId(event), async (document) => {\n          return await evolve(document, event);\n        });\n      }\n    },\n    ...canHandle,\n  );\n\nexport const pongoSingleProjection = <\n  Document extends PongoDocument,\n  EventType extends Event,\n>(\n  collectionName: string,\n  evolve: PongoDocumentEvolve<Document, EventType>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  pongoMultiStreamProjection(\n    collectionName,\n    (event) => event.metadata.streamName,\n    evolve,\n    ...canHandle,\n  );\n","import {\n  type NodePostgresClient,\n  type NodePostgresTransaction,\n  type SQL,\n  type SQLExecutor,\n} from '@event-driven-io/dumbo';\nimport {\n  type Event,\n  type EventTypeOf,\n  type ProjectionDefintion,\n  type ProjectionHandler,\n  type ReadEvent,\n} from '@event-driven-io/emmett';\nimport type { PostgresEventStoreOptions } from '../postgreSQLEventStore';\n\nexport type PostgreSQLProjectionHandlerContext = {\n  connectionString: string;\n  client: NodePostgresClient;\n  execute: SQLExecutor;\n  transaction: NodePostgresTransaction;\n};\n\nexport type PostgreSQLProjectionHandler<EventType extends Event = Event> =\n  ProjectionHandler<EventType, PostgreSQLProjectionHandlerContext>;\n\nexport interface PostgreSQLProjectionDefintion<EventType extends Event = Event>\n  extends ProjectionDefintion<\n    'inline',\n    EventType,\n    PostgreSQLProjectionHandlerContext\n  > {}\n\nexport const defaultPostgreSQLProjectionOptions: PostgresEventStoreOptions = {\n  projections: [],\n};\n\nexport const handleProjections = async <EventType extends Event = Event>(\n  allProjections: PostgreSQLProjectionDefintion<EventType>[],\n  connectionString: string,\n  transaction: NodePostgresTransaction,\n  events: ReadEvent<EventType>[],\n): Promise<void> => {\n  const eventTypes = events.map((e) => e.type);\n\n  const projections = allProjections.filter((p) =>\n    p.canHandle.some((type) => eventTypes.includes(type)),\n  );\n\n  const client = (await transaction.connection.open()) as NodePostgresClient;\n\n  for (const projection of projections) {\n    await projection.handle(events, {\n      connectionString,\n      client,\n      transaction,\n      execute: transaction.execute,\n    });\n  }\n};\n\nexport const postgreSQLProjection = <EventType extends Event>(\n  definition: PostgreSQLProjectionDefintion<EventType>,\n): PostgreSQLProjectionDefintion =>\n  definition as unknown as PostgreSQLProjectionDefintion;\n\n/** @deprecated use postgreSQLProjection instead */\nexport const projection = postgreSQLProjection;\n\nexport const postgreSQLInlineProjection = <EventType extends Event>(\n  definition: Omit<PostgreSQLProjectionDefintion<EventType>, 'type'>,\n): PostgreSQLProjectionDefintion =>\n  postgreSQLProjection({ type: 'inline', ...definition });\n\n/** @deprecated use postgreSQLSingleProjection instead */\nexport const inlineProjection = postgreSQLInlineProjection;\n\nexport const postgreSQLRawBatchSQLProjection = <EventType extends Event>(\n  handle: (\n    events: EventType[],\n    context: PostgreSQLProjectionHandlerContext,\n  ) => Promise<SQL[]> | SQL[],\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLInlineProjection<EventType>({\n    canHandle,\n    handle: async (events, context) => {\n      const sqls: SQL[] = await handle(events, context);\n\n      await context.execute.batchCommand(sqls);\n    },\n  });\n\nexport const postgreSQLRawSQLProjection = <EventType extends Event>(\n  handle: (\n    event: EventType,\n    context: PostgreSQLProjectionHandlerContext,\n  ) => Promise<SQL> | SQL,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLRawBatchSQLProjection<EventType>(\n    async (events, context) => {\n      const sqls: SQL[] = [];\n\n      for (const event of events) {\n        sqls.push(await handle(event, context));\n      }\n      return sqls;\n    },\n    ...canHandle,\n  );\n\nexport * from './pongo';\n"]}

package/dist/chunk-7AXC6NM5.mjs

@@ -1,2 +0,0 @@
-import{pongoClient as y}from"@event-driven-io/pongo";import"pg";import"@event-driven-io/dumbo";var T={projections:[]},m=async(e,o,t,n)=>{let r=n.map(i=>i.type),s=e.filter(i=>i.canHandle.some(v=>r.includes(v))),p=await t.connection.open();for(let i of s)await i.handle(n,{connectionString:o,client:p,transaction:t,execute:t.execute})},E=e=>e,x=E,c=e=>E({type:"inline",...e}),S=c,P=(e,...o)=>c({canHandle:o,handle:async(t,n)=>{let r=await e(t,n);await n.execute.batchCommand(r)}}),j=(e,...o)=>P(async(t,n)=>{let r=[];for(let s of t)r.push(await e(s,n));return r},...o);var a=(e,...o)=>c({canHandle:o,handle:async(t,n)=>{let{connectionString:r,client:s}=n,p=y(r,{client:s});await e(p,t)}}),g=(e,o,t,...n)=>a(async(r,s)=>{let p=r.db().collection(e);for(let i of s)await p.handle(o(i),async v=>await t(v,i))},...n),H=(e,o,...t)=>g(e,n=>n.metadata.streamName,o,...t);export{a,g as b,H as c,T as d,m as e,E as f,x as g,c as h,S as i,P as j,j as k};
-//# sourceMappingURL=chunk-7AXC6NM5.mjs.map

package/dist/chunk-7AXC6NM5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eventStore/projections/pongo.ts","../src/eventStore/projections/index.ts"],"sourcesContent":["import {\n  type Event,\n  type EventTypeOf,\n  type ReadEvent,\n} from '@event-driven-io/emmett';\nimport {\n  pongoClient,\n  type PongoClient,\n  type PongoDocument,\n} from '@event-driven-io/pongo';\nimport pg from 'pg';\nimport {\n  postgreSQLInlineProjection,\n  type PostgreSQLProjectionDefintion,\n} from './';\n\nexport type PongoProjectionOptions<EventType extends Event> = {\n  documentId: (event: ReadEvent<EventType>) => string;\n  eventHandler: PongoProjectionHandler<EventType>;\n  eventTypes: EventTypeOf<EventType>[];\n};\n\nexport type PongoProjectionHandler<EventType extends Event = Event> = (\n  documentId: (event: ReadEvent<EventType>) => string,\n  connectionString: string,\n  client: pg.PoolClient,\n  events: ReadEvent<EventType>[],\n) => Promise<void> | void;\n\nexport type PongoDocumentEvolve<\n  Document extends PongoDocument,\n  EventType extends Event,\n> =\n  | ((\n      document: Document | null,\n      event: ReadEvent<EventType>,\n    ) => Document | null)\n  | ((\n      document: Document | null,\n      event: ReadEvent<EventType>,\n    ) => Promise<Document | null>);\n\nexport const pongoProjection = <EventType extends Event>(\n  handle: (pongo: PongoClient, events: ReadEvent<EventType>[]) => Promise<void>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLInlineProjection<EventType>({\n    canHandle,\n    handle: async (events, context) => {\n      const { connectionString, client } = context;\n      const pongo = pongoClient(connectionString, { client });\n      await handle(pongo, events);\n    },\n  });\n\nexport const pongoMultiStreamProjection = <\n  Document extends PongoDocument,\n  EventType extends Event,\n>(\n  collectionName: string,\n  getDocumentId: (event: ReadEvent<EventType>) => string,\n  evolve: PongoDocumentEvolve<Document, EventType>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  pongoProjection(\n    async (pongo, events) => {\n      const collection = pongo.db().collection<Document>(collectionName);\n\n      for (const event of events) {\n        await collection.handle(getDocumentId(event), async (document) => {\n          return await evolve(document, event);\n        });\n      }\n    },\n    ...canHandle,\n  );\n\nexport const pongoSingleProjection = <\n  Document extends PongoDocument,\n  EventType extends Event,\n>(\n  collectionName: string,\n  evolve: PongoDocumentEvolve<Document, EventType>,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  pongoMultiStreamProjection(\n    collectionName,\n    (event) => event.metadata.streamName,\n    evolve,\n    ...canHandle,\n  );\n","import {\n  type NodePostgresClient,\n  type NodePostgresTransaction,\n  type SQL,\n  type SQLExecutor,\n} from '@event-driven-io/dumbo';\nimport {\n  type Event,\n  type EventTypeOf,\n  type ProjectionDefintion,\n  type ProjectionHandler,\n  type ReadEvent,\n} from '@event-driven-io/emmett';\nimport type { PostgresEventStoreOptions } from '../postgreSQLEventStore';\n\nexport type PostgreSQLProjectionHandlerContext = {\n  connectionString: string;\n  client: NodePostgresClient;\n  execute: SQLExecutor;\n  transaction: NodePostgresTransaction;\n};\n\nexport type PostgreSQLProjectionHandler<EventType extends Event = Event> =\n  ProjectionHandler<EventType, PostgreSQLProjectionHandlerContext>;\n\nexport interface PostgreSQLProjectionDefintion<EventType extends Event = Event>\n  extends ProjectionDefintion<\n    'inline',\n    EventType,\n    PostgreSQLProjectionHandlerContext\n  > {}\n\nexport const defaultPostgreSQLProjectionOptions: PostgresEventStoreOptions = {\n  projections: [],\n};\n\nexport const handleProjections = async <EventType extends Event = Event>(\n  allProjections: PostgreSQLProjectionDefintion<EventType>[],\n  connectionString: string,\n  transaction: NodePostgresTransaction,\n  events: ReadEvent<EventType>[],\n): Promise<void> => {\n  const eventTypes = events.map((e) => e.type);\n\n  const projections = allProjections.filter((p) =>\n    p.canHandle.some((type) => eventTypes.includes(type)),\n  );\n\n  const client = (await transaction.connection.open()) as NodePostgresClient;\n\n  for (const projection of projections) {\n    await projection.handle(events, {\n      connectionString,\n      client,\n      transaction,\n      execute: transaction.execute,\n    });\n  }\n};\n\nexport const postgreSQLProjection = <EventType extends Event>(\n  definition: PostgreSQLProjectionDefintion<EventType>,\n): PostgreSQLProjectionDefintion =>\n  definition as unknown as PostgreSQLProjectionDefintion;\n\n/** @deprecated use postgreSQLProjection instead */\nexport const projection = postgreSQLProjection;\n\nexport const postgreSQLInlineProjection = <EventType extends Event>(\n  definition: Omit<PostgreSQLProjectionDefintion<EventType>, 'type'>,\n): PostgreSQLProjectionDefintion =>\n  postgreSQLProjection({ type: 'inline', ...definition });\n\n/** @deprecated use postgreSQLSingleProjection instead */\nexport const inlineProjection = postgreSQLInlineProjection;\n\nexport const postgreSQLRawBatchSQLProjection = <EventType extends Event>(\n  handle: (\n    events: EventType[],\n    context: PostgreSQLProjectionHandlerContext,\n  ) => Promise<SQL[]> | SQL[],\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLInlineProjection<EventType>({\n    canHandle,\n    handle: async (events, context) => {\n      const sqls: SQL[] = await handle(events, context);\n\n      await context.execute.batchCommand(sqls);\n    },\n  });\n\nexport const postgreSQLRawSQLProjection = <EventType extends Event>(\n  handle: (\n    event: EventType,\n    context: PostgreSQLProjectionHandlerContext,\n  ) => Promise<SQL> | SQL,\n  ...canHandle: EventTypeOf<EventType>[]\n): PostgreSQLProjectionDefintion =>\n  postgreSQLRawBatchSQLProjection<EventType>(\n    async (events, context) => {\n      const sqls: SQL[] = [];\n\n      for (const event of events) {\n        sqls.push(await handle(event, context));\n      }\n      return sqls;\n    },\n    ...canHandle,\n  );\n\nexport * from './pongo';\n"],"mappings":"AAKA,OACE,eAAAA,MAGK,yBACP,MAAe,KCVf,MAKO,yBA2BA,IAAMC,EAAgE,CAC3E,YAAa,CAAC,CAChB,EAEaC,EAAoB,MAC/BC,EACAC,EACAC,EACAC,IACkB,CAClB,IAAMC,EAAaD,EAAO,IAAKE,GAAMA,EAAE,IAAI,EAErCC,EAAcN,EAAe,OAAQO,GACzCA,EAAE,UAAU,KAAMC,GAASJ,EAAW,SAASI,CAAI,CAAC,CACtD,EAEMC,EAAU,MAAMP,EAAY,WAAW,KAAK,EAElD,QAAWQ,KAAcJ,EACvB,MAAMI,EAAW,OAAOP,EAAQ,CAC9B,iBAAAF,EACA,OAAAQ,EACA,YAAAP,EACA,QAASA,EAAY,OACvB,CAAC,CAEL,EAEaS,EACXC,GAEAA,EAGWF,EAAaC,EAEbE,EACXD,GAEAD,EAAqB,CAAE,KAAM,SAAU,GAAGC,CAAW,CAAC,EAG3CE,EAAmBD,EAEnBE,EAAkC,CAC7CC,KAIGC,IAEHJ,EAAsC,CACpC,UAAAI,EACA,OAAQ,MAAOd,EAAQe,IAAY,CACjC,IAAMC,EAAc,MAAMH,EAAOb,EAAQe,CAAO,EAEhD,MAAMA,EAAQ,QAAQ,aAAaC,CAAI,CACzC,CACF,CAAC,EAEUC,EAA6B,CACxCJ,KAIGC,IAEHF,EACE,MAAOZ,EAAQe,IAAY,CACzB,IAAMC,EAAc,CAAC,EAErB,QAAWE,KAASlB,EAClBgB,EAAK,KAAK,MAAMH,EAAOK,EAAOH,CAAO,CAAC,EAExC,OAAOC,CACT,EACA,GAAGF,CACL,EDnEK,IAAMK,EAAkB,CAC7BC,KACGC,IAEHC,EAAsC,CACpC,UAAAD,EACA,OAAQ,MAAOE,EAAQC,IAAY,CACjC,GAAM,CAAE,iBAAAC,EAAkB,OAAAC,CAAO,EAAIF,EAC/BG,EAAQC,EAAYH,EAAkB,CAAE,OAAAC,CAAO,CAAC,EACtD,MAAMN,EAAOO,EAAOJ,CAAM,CAC5B,CACF,CAAC,EAEUM,EAA6B,CAIxCC,EACAC,EACAC,KACGX,IAEHF,EACE,MAAOQ,EAAOJ,IAAW,CACvB,IAAMU,EAAaN,EAAM,GAAG,EAAE,WAAqBG,CAAc,EAEjE,QAAWI,KAASX,EAClB,MAAMU,EAAW,OAAOF,EAAcG,CAAK,EAAG,MAAOC,GAC5C,MAAMH,EAAOG,EAAUD,CAAK,CACpC,CAEL,EACA,GAAGb,CACL,EAEWe,EAAwB,CAInCN,EACAE,KACGX,IAEHQ,EACEC,EACCI,GAAUA,EAAM,SAAS,WAC1BF,EACA,GAAGX,CACL","names":["pongoClient","defaultPostgreSQLProjectionOptions","handleProjections","allProjections","connectionString","transaction","events","eventTypes","e","projections","p","type","client","projection","postgreSQLProjection","definition","postgreSQLInlineProjection","inlineProjection","postgreSQLRawBatchSQLProjection","handle","canHandle","context","sqls","postgreSQLRawSQLProjection","event","pongoProjection","handle","canHandle","postgreSQLInlineProjection","events","context","connectionString","client","pongo","pongoClient","pongoMultiStreamProjection","collectionName","getDocumentId","evolve","collection","event","document","pongoSingleProjection"]}

package/dist/chunk-BVWQBBMI.mjs

@@ -1,2 +0,0 @@
-import{d as v,e as y}from"./chunk-7AXC6NM5.mjs";import{b as T}from"./chunk-BPW6NK2N.mjs";import{b as f}from"./chunk-AVOQPWAR.mjs";import{a as C}from"./chunk-O23RI362.mjs";import{c as E,d as u,e as p,f as m}from"./chunk-SDQ3ERUN.mjs";import{dumbo as N,endPool as R}from"@event-driven-io/dumbo";import"pg";var M=(t,e=v)=>{let g=N({connectionString:t,...e.connectionOptions?e.connectionOptions:{}}),d=T(g),{projections:O}=e;return{async aggregateStream(o,n){await d;let{evolve:i,initialState:a,read:S}=n,l=S?.expectedStreamVersion,r=a(),s=await this.readStream(o,n.read);if(s===null)return null;let c=s.currentStreamVersion;b(c,l);for(let P of s.events)P&&(r=i(r,P));return{currentStreamVersion:c,state:r}},readStream:async(o,n)=>(await d,C(g.execute,o,n)),appendToStream:async(o,n,i)=>{await d;let[a,...S]=o.split("-"),l=a&&S.length>0?a:"emt:unknown",r=await f(g,o,l,n,{...i,preCommitHook:(s,c)=>y(O,t,s,c)});if(!r.success)throw new m(-1n,i?.expectedStreamVersion??p);return{nextExpectedStreamVersion:r.nextStreamPosition}},close:()=>R({connectionString:t})}},x=(t,e)=>e===p?!0:e==u?t===void 0:e==E?t!==void 0:t===e,b=(t,e)=>{if(e??=p,!x(t,e))throw new m(t,e)};export{M as a};
-//# sourceMappingURL=chunk-BVWQBBMI.mjs.map

package/dist/chunk-BVWQBBMI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eventStore/postgreSQLEventStore.ts"],"sourcesContent":["import {\n  dumbo,\n  endPool,\n  type NodePostgresClientConnection,\n  type NodePostgresConnector,\n  type NodePostgresPoolClientConnection,\n} from '@event-driven-io/dumbo';\nimport {\n  ExpectedVersionConflictError,\n  NO_CONCURRENCY_CHECK,\n  STREAM_DOES_NOT_EXIST,\n  STREAM_EXISTS,\n  type AggregateStreamOptions,\n  type AggregateStreamResult,\n  type AppendToStreamOptions,\n  type AppendToStreamResult,\n  type DefaultStreamVersionType,\n  type Event,\n  type EventStore,\n  type ExpectedStreamVersion,\n  type ReadEventMetadataWithGlobalPosition,\n  type ReadStreamOptions,\n  type ReadStreamResult,\n} from '@event-driven-io/emmett';\nimport pg from 'pg';\nimport {\n  defaultPostgreSQLProjectionOptions,\n  handleProjections,\n  type PostgreSQLProjectionDefintion,\n} from './projections';\nimport { appendToStream, createEventStoreSchema, readStream } from './schema';\n\nexport interface PostgresEventStore\n  extends EventStore<\n    DefaultStreamVersionType,\n    ReadEventMetadataWithGlobalPosition\n  > {\n  close(): Promise<void>;\n}\n\ntype PostgresEventStorePooledOptions =\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: true;\n      pool: pg.Pool;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pool: pg.Pool;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: true;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n    };\n\ntype PostgresEventStoreNotPooledOptions =\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: false;\n      client: pg.Client;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      client: pg.Client;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: false;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      connection:\n        | NodePostgresPoolClientConnection\n        | NodePostgresClientConnection;\n      pooled?: false;\n    };\n\nexport type PostgresEventStoreConnectionOptions =\n  | PostgresEventStorePooledOptions\n  | PostgresEventStoreNotPooledOptions;\n\nexport type PostgresEventStoreOptions = {\n  projections: PostgreSQLProjectionDefintion[];\n  connectionOptions?: PostgresEventStoreConnectionOptions;\n};\nexport const getPostgreSQLEventStore = (\n  connectionString: string,\n  options: PostgresEventStoreOptions = defaultPostgreSQLProjectionOptions,\n): PostgresEventStore => {\n  const pool = dumbo({\n    connectionString,\n    ...(options.connectionOptions ? options.connectionOptions : {}),\n  });\n  const ensureSchemaExists = createEventStoreSchema(pool);\n\n  const { projections } = options;\n\n  return {\n    async aggregateStream<State, EventType extends Event>(\n      streamName: string,\n      options: AggregateStreamOptions<State, EventType>,\n    ): Promise<AggregateStreamResult<State> | null> {\n      await ensureSchemaExists;\n      const { evolve, initialState, read } = options;\n\n      const expectedStreamVersion = read?.expectedStreamVersion;\n\n      let state = initialState();\n\n      const result = await this.readStream<EventType>(streamName, options.read);\n\n      if (result === null) return null;\n\n      const currentStreamVersion = result.currentStreamVersion;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        expectedStreamVersion,\n      );\n\n      for (const event of result.events) {\n        if (!event) continue;\n\n        state = evolve(state, event);\n      }\n\n      return {\n        currentStreamVersion: currentStreamVersion,\n        state,\n      };\n    },\n\n    readStream: async <EventType extends Event>(\n      streamName: string,\n      options?: ReadStreamOptions,\n    ): Promise<\n      ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      >\n    > => {\n      await ensureSchemaExists;\n      return readStream<EventType>(pool.execute, streamName, options);\n    },\n\n    appendToStream: async <EventType extends Event>(\n      streamName: string,\n      events: EventType[],\n      options?: AppendToStreamOptions,\n    ): Promise<AppendToStreamResult> => {\n      await ensureSchemaExists;\n      // TODO: This has to be smarter when we introduce urn-based resolution\n      const [firstPart, ...rest] = streamName.split('-');\n\n      const streamType =\n        firstPart && rest.length > 0 ? firstPart : 'emt:unknown';\n\n      const appendResult = await appendToStream(\n        pool,\n        streamName,\n        streamType,\n        events,\n        {\n          ...options,\n          preCommitHook: (client, events) =>\n            handleProjections(projections, connectionString, client, events),\n        },\n      );\n\n      if (!appendResult.success)\n        throw new ExpectedVersionConflictError<bigint>(\n          -1n, //TODO: Return actual version in case of error\n          options?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK,\n        );\n\n      return { nextExpectedStreamVersion: appendResult.nextStreamPosition };\n    },\n    close: () => endPool({ connectionString }),\n  };\n};\n\nconst matchesExpectedVersion = (\n  current: bigint | undefined,\n  expected: ExpectedStreamVersion,\n): boolean => {\n  if (expected === NO_CONCURRENCY_CHECK) return true;\n\n  if (expected == STREAM_DOES_NOT_EXIST) return current === undefined;\n\n  if (expected == STREAM_EXISTS) return current !== undefined;\n\n  return current === expected;\n};\n\nconst assertExpectedVersionMatchesCurrent = (\n  current: bigint | undefined,\n  expected: ExpectedStreamVersion | undefined,\n): void => {\n  expected ??= NO_CONCURRENCY_CHECK;\n\n  if (!matchesExpectedVersion(current, expected))\n    throw new ExpectedVersionConflictError(current, expected);\n};\n"],"mappings":"yOAAA,OACE,SAAAA,EACA,WAAAC,MAIK,yBAkBP,MAAe,KAgFR,IAAMC,EAA0B,CACrCC,EACAC,EAAqCC,IACd,CACvB,IAAMC,EAAOC,EAAM,CACjB,iBAAAJ,EACA,GAAIC,EAAQ,kBAAoBA,EAAQ,kBAAoB,CAAC,CAC/D,CAAC,EACKI,EAAqBC,EAAuBH,CAAI,EAEhD,CAAE,YAAAI,CAAY,EAAIN,EAExB,MAAO,CACL,MAAM,gBACJO,EACAP,EAC8C,CAC9C,MAAMI,EACN,GAAM,CAAE,OAAAI,EAAQ,aAAAC,EAAc,KAAAC,CAAK,EAAIV,EAEjCW,EAAwBD,GAAM,sBAEhCE,EAAQH,EAAa,EAEnBI,EAAS,MAAM,KAAK,WAAsBN,EAAYP,EAAQ,IAAI,EAExE,GAAIa,IAAW,KAAM,OAAO,KAE5B,IAAMC,EAAuBD,EAAO,qBAEpCE,EACED,EACAH,CACF,EAEA,QAAWK,KAASH,EAAO,OACpBG,IAELJ,EAAQJ,EAAOI,EAAOI,CAAK,GAG7B,MAAO,CACL,qBAAsBF,EACtB,MAAAF,CACF,CACF,EAEA,WAAY,MACVL,EACAP,KAQA,MAAMI,EACCa,EAAsBf,EAAK,QAASK,EAAYP,CAAO,GAGhE,eAAgB,MACdO,EACAW,EACAlB,IACkC,CAClC,MAAMI,EAEN,GAAM,CAACe,EAAW,GAAGC,CAAI,EAAIb,EAAW,MAAM,GAAG,EAE3Cc,EACJF,GAAaC,EAAK,OAAS,EAAID,EAAY,cAEvCG,EAAe,MAAMC,EACzBrB,EACAK,EACAc,EACAH,EACA,CACE,GAAGlB,EACH,cAAe,CAACwB,EAAQN,IACtBO,EAAkBnB,EAAaP,EAAkByB,EAAQN,CAAM,CACnE,CACF,EAEA,GAAI,CAACI,EAAa,QAChB,MAAM,IAAII,EACR,CAAC,GACD1B,GAAS,uBAAyB2B,CACpC,EAEF,MAAO,CAAE,0BAA2BL,EAAa,kBAAmB,CACtE,EACA,MAAO,IAAMM,EAAQ,CAAE,iBAAA7B,CAAiB,CAAC,CAC3C,CACF,EAEM8B,EAAyB,CAC7BC,EACAC,IAEIA,IAAaJ,EAA6B,GAE1CI,GAAYC,EAA8BF,IAAY,OAEtDC,GAAYE,EAAsBH,IAAY,OAE3CA,IAAYC,EAGfhB,EAAsC,CAC1Ce,EACAC,IACS,CAGT,GAFAA,IAAaJ,EAET,CAACE,EAAuBC,EAASC,CAAQ,EAC3C,MAAM,IAAIL,EAA6BI,EAASC,CAAQ,CAC5D","names":["dumbo","endPool","getPostgreSQLEventStore","connectionString","options","defaultPostgreSQLProjectionOptions","pool","dumbo","ensureSchemaExists","createEventStoreSchema","projections","streamName","evolve","initialState","read","expectedStreamVersion","state","result","currentStreamVersion","assertExpectedVersionMatchesCurrent","event","readStream","events","firstPart","rest","streamType","appendResult","appendToStream","client","handleProjections","t","n","endPool","matchesExpectedVersion","current","expected","a","s"]}

package/dist/chunk-NERVHTL2.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var n=class extends Error{constructor(t){super(`Cannot parse! ${t}`)}},i= exports.a ={stringify:(t,e)=>JSON.stringify(_optionalChain([e, 'optionalAccess', _ => _.map])?e.map(t):t,(r,a)=>typeof a=="bigint"?a.toString():a),parse:(t,e)=>{let r=JSON.parse(t,_optionalChain([e, 'optionalAccess', _2 => _2.reviver]));if(_optionalChain([e, 'optionalAccess', _3 => _3.typeCheck])&&!_optionalChain([e, 'optionalAccess', _4 => _4.typeCheck, 'call', _5 => _5(r)]))throw new n(t);return _optionalChain([e, 'optionalAccess', _6 => _6.map])?e.map(r):r}};var g=(t,e,r)=>({type:t,data:e,metadata:r});var l=(t=>(t.NOT_A_NONEMPTY_STRING="NOT_A_NONEMPTY_STRING",t.NOT_A_POSITIVE_NUMBER="NOT_A_POSITIVE_NUMBER",t.NOT_AN_UNSIGNED_BIGINT="NOT_AN_UNSIGNED_BIGINT",t))(l||{}),c=t=>typeof t=="number"&&t===t,m=t=>typeof t=="string";var s=class d extends Error{constructor(e){let r=e&&typeof e=="object"&&"errorCode"in e?e.errorCode:c(e)?e:500,a=e&&typeof e=="object"&&"message"in e?e.message:m(e)?e:`Error with status code '${r}' ocurred during Emmett processing`;super(a),this.errorCode=r,Object.setPrototypeOf(this,d.prototype)}},o=class f extends s{constructor(e,r,a){super({errorCode:412,message:_nullishCoalesce(a, () => (`Expected version ${r.toString()} does not match current ${_optionalChain([e, 'optionalAccess', _7 => _7.toString, 'call', _8 => _8()])}`))}),this.current=e,this.expected=r,Object.setPrototypeOf(this,f.prototype)}};var y="STREAM_EXISTS",u= exports.d ="STREAM_DOES_NOT_EXIST",p= exports.e ="NO_CONCURRENCY_CHECK";var w=class h extends o{constructor(e,r){super(_optionalChain([e, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]),_optionalChain([r, 'optionalAccess', _11 => _11.toString, 'call', _12 => _12()])),Object.setPrototypeOf(this,h.prototype)}};var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);var _webstreamspolyfill = require('web-streams-polyfill');var _uuid = require('uuid');exports.a = i; exports.b = g; exports.c = y; exports.d = u; exports.e = p; exports.f = w;
-//# sourceMappingURL=chunk-NERVHTL2.js.map

package/dist/chunk-NERVHTL2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../emmett/src/serialization/json/JSONParser.ts","../../emmett/src/typing/event.ts","../../emmett/src/validation/index.ts","../../emmett/src/errors/index.ts","../../emmett/src/eventStore/expectedVersion.ts","../../emmett/src/streaming/restream.ts","../../emmett/src/eventStore/inMemoryEventStore.ts"],"names":["ParseError","text","JSONParser","value","options","_","v","parsed","event","type","data","metadata","ValidationErrors","isNumber","val","isString","EmmettError","_EmmettError","errorCode","message","ConcurrencyError","_ConcurrencyError","current","expected","STREAM_EXISTS","STREAM_DOES_NOT_EXIST","NO_CONCURRENCY_CHECK","ExpectedVersionConflictError","_ExpectedVersionConflictError","retry","TransformStream","randomUUID"],"mappings":"AAAO,IAAMA,EAAN,cAAyB,KAAM,CACpC,YAAYC,EAAc,CACxB,MAAM,iBAAiBA,CAAI,EAAE,CAC/B,CACF,EA0BaC,EAAa,CACxB,UAAW,CACTC,EACAC,IAEO,KAAK,UACVA,GAAS,IAAMA,EAAQ,IAAID,CAA6B,EAAIA,EAG5D,CAACE,EAAGC,IAAO,OAAOA,GAAM,SAAWA,EAAE,SAAS,EAAIA,CACpD,EAEF,MAAO,CACLL,EACAG,IACmB,CACnB,IAAMG,EAAkB,KAAK,MAAMN,EAAMG,GAAS,OAAO,EAEzD,GAAIA,GAAS,WAAa,CAACA,GAAS,UAAcG,CAAM,EACtD,MAAM,IAAIP,EAAWC,CAAI,EAE3B,OAAOG,GAAS,IACZA,EAAQ,IAAIG,CAA8B,EACzCA,CACP,CACF,EC1BO,IAAMC,EAAQ,CACnBC,EACAC,EACAC,KAMO,CACL,KAAAF,EACA,KAAAC,EACA,SAAAC,CACF,GCxCK,IAAWC,GAAAA,IAChBA,EAAA,sBAAwB,wBACxBA,EAAA,sBAAwB,wBACxBA,EAAA,uBAAyB,yBAHTA,IAAAA,GAAA,CAAA,CAAA,EAMLC,EAAYC,GACvB,OAAOA,GAAQ,UAAYA,IAAQA,EAExBC,EAAYD,GACvB,OAAOA,GAAQ,SCLV,IAcME,EAAN,MAAMC,UAAoB,KAAM,CAC9B,UAEP,YACEb,EACA,CACA,IAAMc,EACJd,GAAW,OAAOA,GAAY,UAAY,cAAeA,EACrDA,EAAQ,UACRS,EAAST,CAAO,EACdA,EACA,IACFe,EACJf,GAAW,OAAOA,GAAY,UAAY,YAAaA,EACnDA,EAAQ,QACRW,EAASX,CAAO,EACdA,EACA,2BAA2Bc,CAAS,qCAE5C,MAAMC,CAAO,EACb,KAAK,UAAYD,EAGjB,OAAO,eAAe,KAAMD,EAAY,SAAS,CACnD,CACF,EAEaG,EAAN,MAAMC,UAAyBL,CAAY,CAChD,YACSM,EACAC,EACPJ,EACA,CACA,MAAM,CACJ,UAAW,IACX,QACEA,GACA,oBAAoBI,EAAS,SAAS,CAAC,2BAA2BD,GAAS,SAAS,CAAC,EACzF,CAAC,EATM,KAAA,QAAAA,EACA,KAAA,SAAAC,EAWP,OAAO,eAAe,KAAMF,EAAiB,SAAS,CACxD,CACF,EC/CO,IAAMG,EAAgB,gBAChBC,EACX,wBACWC,EACX,uBAJK,IAiCMC,EAAN,MAAMC,UAEHR,CAAiB,CACzB,YACEE,EACAC,EACA,CACA,MAAMD,GAAS,SAAS,EAAGC,GAAU,SAAS,CAAC,EAG/C,OAAO,eAAe,KAAMK,EAA6B,SAAS,CACpE,CACF,EC9DA,OAAOC,MAAW,cAClB,OAGE,mBAAAC,OAEK,uBCNP,OAAS,MAAMC,OAAkB","sourcesContent":["export class ParseError extends Error {\n  constructor(text: string) {\n    super(`Cannot parse! ${text}`);\n  }\n}\n\nexport type Mapper<From, To = From> =\n  | ((value: unknown) => To)\n  | ((value: Partial<From>) => To)\n  | ((value: From) => To)\n  | ((value: Partial<To>) => To)\n  | ((value: To) => To)\n  | ((value: Partial<To | From>) => To)\n  | ((value: To | From) => To);\n\nexport type MapperArgs<From, To = From> = Partial<From> &\n  From &\n  Partial<To> &\n  To;\n\nexport type ParseOptions<From, To = From> = {\n  reviver?: (key: string, value: unknown) => unknown;\n  map?: Mapper<From, To>;\n  typeCheck?: <To>(value: unknown) => value is To;\n};\n\nexport type StringifyOptions<From, To = From> = {\n  map?: Mapper<From, To>;\n};\n\nexport const JSONParser = {\n  stringify: <From, To = From>(\n    value: From,\n    options?: StringifyOptions<From, To>,\n  ) => {\n    return JSON.stringify(\n      options?.map ? options.map(value as MapperArgs<From, To>) : value,\n      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      (_, v) => (typeof v === 'bigint' ? v.toString() : v),\n    );\n  },\n  parse: <From, To = From>(\n    text: string,\n    options?: ParseOptions<From, To>,\n  ): To | undefined => {\n    const parsed: unknown = JSON.parse(text, options?.reviver);\n\n    if (options?.typeCheck && !options?.typeCheck<To>(parsed))\n      throw new ParseError(text);\n\n    return options?.map\n      ? options.map(parsed as MapperArgs<From, To>)\n      : (parsed as To | undefined);\n  },\n};\n","import type { DefaultRecord, Flavour } from './';\n\nexport type Event<\n  EventType extends string = string,\n  EventData extends DefaultRecord = DefaultRecord,\n  EventMetaData extends DefaultRecord = DefaultRecord,\n> = Flavour<\n  Readonly<{\n    type: EventType;\n    data: EventData;\n    metadata?: EventMetaData;\n  }>,\n  'Event'\n>;\n\nexport type EventTypeOf<T extends Event> = T['type'];\nexport type EventDataOf<T extends Event> = T['data'];\nexport type EventMetaDataOf<T extends Event> = T['metadata'];\n\nexport type CreateEventType<\n  EventType extends string,\n  EventData extends DefaultRecord,\n  EventMetaData extends DefaultRecord | undefined,\n> = Readonly<{\n  type: EventType;\n  data: EventData;\n  metadata?: EventMetaData;\n}>;\n\nexport const event = <EventType extends Event>(\n  type: EventTypeOf<EventType>,\n  data: EventDataOf<EventType>,\n  metadata?: EventMetaDataOf<EventType>,\n): CreateEventType<\n  EventTypeOf<EventType>,\n  EventDataOf<EventType>,\n  EventMetaDataOf<EventType>\n> => {\n  return {\n    type,\n    data,\n    metadata,\n  };\n};\n\nexport type ReadEvent<\n  EventType extends Event = Event,\n  EventMetaDataType extends EventMetaDataOf<EventType> &\n    ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata,\n> = CreateEventType<\n  EventTypeOf<EventType>,\n  EventDataOf<EventType>,\n  EventMetaDataType\n> &\n  EventType & { metadata: EventMetaDataType };\n\nexport type ReadEventMetadata = Readonly<{\n  eventId: string;\n  streamPosition: bigint;\n  streamName: string;\n}>;\n\nexport type ReadEventMetadataWithGlobalPosition = ReadEventMetadata & {\n  globalPosition: bigint;\n};\n","import { ValidationError } from '../errors';\n\nexport const enum ValidationErrors {\n  NOT_A_NONEMPTY_STRING = 'NOT_A_NONEMPTY_STRING',\n  NOT_A_POSITIVE_NUMBER = 'NOT_A_POSITIVE_NUMBER',\n  NOT_AN_UNSIGNED_BIGINT = 'NOT_AN_UNSIGNED_BIGINT',\n}\n\nexport const isNumber = (val: unknown): val is number =>\n  typeof val === 'number' && val === val;\n\nexport const isString = (val: unknown): val is string =>\n  typeof val === 'string';\n\nexport const assertNotEmptyString = (value: unknown): string => {\n  if (!isString(value) || value.length === 0) {\n    throw new ValidationError(ValidationErrors.NOT_A_NONEMPTY_STRING);\n  }\n  return value;\n};\n\nexport const assertPositiveNumber = (value: unknown): number => {\n  if (!isNumber(value) || value <= 0) {\n    throw new ValidationError(ValidationErrors.NOT_A_POSITIVE_NUMBER);\n  }\n  return value;\n};\n\nexport const assertUnsignedBigInt = (value: string): bigint => {\n  const number = BigInt(value);\n  if (number < 0) {\n    throw new ValidationError(ValidationErrors.NOT_AN_UNSIGNED_BIGINT);\n  }\n  return number;\n};\n\nexport * from './dates';\n","import { isNumber, isString } from '../validation';\n\nexport type ErrorConstructor<ErrorType extends Error> = new (\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...args: any[]\n) => ErrorType;\n\nexport const isErrorConstructor = <ErrorType extends Error>(\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  expect: Function,\n): expect is ErrorConstructor<ErrorType> => {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return (\n    typeof expect === 'function' &&\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    expect.prototype &&\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    expect.prototype.constructor === expect\n  );\n};\n\nexport class EmmettError extends Error {\n  public errorCode: number;\n\n  constructor(\n    options?: { errorCode: number; message?: string } | string | number,\n  ) {\n    const errorCode =\n      options && typeof options === 'object' && 'errorCode' in options\n        ? options.errorCode\n        : isNumber(options)\n          ? options\n          : 500;\n    const message =\n      options && typeof options === 'object' && 'message' in options\n        ? options.message\n        : isString(options)\n          ? options\n          : `Error with status code '${errorCode}' ocurred during Emmett processing`;\n\n    super(message);\n    this.errorCode = errorCode;\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, EmmettError.prototype);\n  }\n}\n\nexport class ConcurrencyError extends EmmettError {\n  constructor(\n    public current: string | undefined,\n    public expected: string,\n    message?: string,\n  ) {\n    super({\n      errorCode: 412,\n      message:\n        message ??\n        `Expected version ${expected.toString()} does not match current ${current?.toString()}`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ConcurrencyError.prototype);\n  }\n}\n\nexport class ValidationError extends EmmettError {\n  constructor(message?: string) {\n    super({\n      errorCode: 400,\n      message: message ?? `Validation Error ocurred during Emmett processing`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ValidationError.prototype);\n  }\n}\n\nexport class IllegalStateError extends EmmettError {\n  constructor(message?: string) {\n    super({\n      errorCode: 403,\n      message: message ?? `Illegal State ocurred during Emmett processing`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, IllegalStateError.prototype);\n  }\n}\n\nexport class NotFoundError extends EmmettError {\n  constructor(options?: { id: string; type: string; message?: string }) {\n    super({\n      errorCode: 404,\n      message:\n        options?.message ??\n        (options?.id\n          ? options.type\n            ? `${options.type} with ${options.id} was not found during Emmett processing`\n            : `State with ${options.id} was not found during Emmett processing`\n          : options?.type\n            ? `${options.type} was not found during Emmett processing`\n            : 'State was not found during Emmett processing'),\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, NotFoundError.prototype);\n  }\n}\n","import { ConcurrencyError } from '../errors';\nimport type { Flavour } from '../typing';\nimport type { DefaultStreamVersionType } from './eventStore';\n\nexport type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> =\n  | ExpectedStreamVersionWithValue<VersionType>\n  | ExpectedStreamVersionGeneral;\n\nexport type ExpectedStreamVersionWithValue<\n  VersionType = DefaultStreamVersionType,\n> = Flavour<VersionType, 'StreamVersion'>;\n\nexport type ExpectedStreamVersionGeneral = Flavour<\n  'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK',\n  'StreamVersion'\n>;\n\nexport const STREAM_EXISTS = 'STREAM_EXISTS' as ExpectedStreamVersionGeneral;\nexport const STREAM_DOES_NOT_EXIST =\n  'STREAM_DOES_NOT_EXIST' as ExpectedStreamVersionGeneral;\nexport const NO_CONCURRENCY_CHECK =\n  'NO_CONCURRENCY_CHECK' as ExpectedStreamVersionGeneral;\n\nexport const matchesExpectedVersion = <\n  StreamVersion = DefaultStreamVersionType,\n>(\n  current: StreamVersion | undefined,\n  expected: ExpectedStreamVersion<StreamVersion>,\n): boolean => {\n  if (expected === NO_CONCURRENCY_CHECK) return true;\n\n  if (expected == STREAM_DOES_NOT_EXIST) return current === undefined;\n\n  if (expected == STREAM_EXISTS) return current !== undefined;\n\n  return current === expected;\n};\n\nexport const assertExpectedVersionMatchesCurrent = <\n  StreamVersion = DefaultStreamVersionType,\n>(\n  current: StreamVersion | undefined,\n  expected: ExpectedStreamVersion<StreamVersion> | undefined,\n): void => {\n  expected ??= NO_CONCURRENCY_CHECK;\n\n  if (!matchesExpectedVersion(current, expected))\n    throw new ExpectedVersionConflictError(current, expected);\n};\n\nexport class ExpectedVersionConflictError<\n  VersionType = DefaultStreamVersionType,\n> extends ConcurrencyError {\n  constructor(\n    current: VersionType | undefined,\n    expected: ExpectedStreamVersion<VersionType>,\n  ) {\n    super(current?.toString(), expected?.toString());\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ExpectedVersionConflictError.prototype);\n  }\n}\n","import retry from 'async-retry';\nimport {\n  ReadableStream,\n  ReadableStreamDefaultReader,\n  TransformStream,\n  TransformStreamDefaultController,\n} from 'web-streams-polyfill';\nimport type { Decoder } from './decoders';\nimport { DefaultDecoder } from './decoders/composite';\n\nexport const restream = <\n  Source = unknown,\n  Transformed = Source,\n  StreamType = object,\n>(\n  createSourceStream: () => ReadableStream<StreamType>,\n  transform: (input: Source) => Transformed = (source) =>\n    source as unknown as Transformed,\n  retryOptions: retry.Options = { forever: true, minTimeout: 25 },\n  decoder: Decoder<StreamType, Source> = new DefaultDecoder<Source>(),\n): ReadableStream<Transformed> =>\n  new TransformStream<Source, Transformed>({\n    start(controller) {\n      retry(\n        () => onRestream(createSourceStream, controller, transform, decoder),\n        retryOptions,\n      ).catch((error) => {\n        controller.error(error);\n      });\n    },\n  }).readable;\n\nconst onRestream = async <StreamType, Source, Transformed = Source>(\n  createSourceStream: () => ReadableStream<StreamType>,\n  controller: TransformStreamDefaultController<Transformed>,\n  transform: (input: Source) => Transformed,\n  decoder: Decoder<StreamType, Source>,\n): Promise<void> => {\n  const sourceStream = createSourceStream();\n  const reader = sourceStream.getReader();\n  try {\n    let done: boolean;\n\n    do {\n      done = await restreamChunk(reader, controller, transform, decoder);\n    } while (!done);\n  } finally {\n    reader.releaseLock();\n  }\n};\n\nconst restreamChunk = async <StreamType, Source, Transformed = Source>(\n  reader: ReadableStreamDefaultReader<StreamType>,\n  controller: TransformStreamDefaultController<Transformed>,\n  transform: (input: Source) => Transformed,\n  decoder: Decoder<StreamType, Source>,\n): Promise<boolean> => {\n  const { done: isDone, value } = await reader.read();\n\n  if (value) decoder.addToBuffer(value);\n\n  if (!isDone && !decoder.hasCompleteMessage()) return false;\n\n  decodeAndTransform(decoder, transform, controller);\n\n  if (isDone) {\n    controller.terminate();\n  }\n\n  return isDone;\n};\n\nconst decodeAndTransform = <StreamType, Source, Transformed = Source>(\n  decoder: Decoder<StreamType, Source>,\n  transform: (input: Source) => Transformed,\n  controller: TransformStreamDefaultController<Transformed>,\n) => {\n  try {\n    const decoded = decoder.decode();\n    if (!decoded) return;\n\n    const transformed = transform(decoded);\n    controller.enqueue(transformed);\n  } catch (error) {\n    controller.error(new Error(`Decoding error: ${error?.toString()}`));\n  }\n};\n","import { v4 as randomUUID } from 'uuid';\nimport type {\n  Event,\n  ReadEvent,\n  ReadEventMetadataWithGlobalPosition,\n} from '../typing';\nimport {\n  type AggregateStreamOptions,\n  type AggregateStreamResult,\n  type AppendToStreamOptions,\n  type AppendToStreamResult,\n  type DefaultStreamVersionType,\n  type EventStore,\n  type ReadStreamOptions,\n  type ReadStreamResult,\n} from './eventStore';\nimport { assertExpectedVersionMatchesCurrent } from './expectedVersion';\n\nexport type EventHandler<E extends Event = Event> = (\n  eventEnvelope: ReadEvent<E>,\n) => void;\n\nexport const getInMemoryEventStore = (): EventStore<\n  DefaultStreamVersionType,\n  ReadEventMetadataWithGlobalPosition\n> => {\n  const streams = new Map<string, ReadEvent[]>();\n\n  const getAllEventsCount = () => {\n    return Array.from<ReadEvent[]>(streams.values())\n      .map((s) => s.length)\n      .reduce((p, c) => p + c, 0);\n  };\n\n  return {\n    async aggregateStream<State, EventType extends Event>(\n      streamName: string,\n      options: AggregateStreamOptions<State, EventType>,\n    ): Promise<AggregateStreamResult<State> | null> {\n      const { evolve, initialState, read } = options;\n\n      const result = await this.readStream<EventType>(streamName, read);\n\n      if (!result) return null;\n\n      const events = result?.events ?? [];\n\n      return {\n        currentStreamVersion: BigInt(events.length),\n        state: events.reduce(evolve, initialState()),\n      };\n    },\n\n    readStream: <EventType extends Event>(\n      streamName: string,\n      options?: ReadStreamOptions,\n    ): Promise<\n      ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      >\n    > => {\n      const events = streams.get(streamName);\n      const currentStreamVersion = events ? BigInt(events.length) : undefined;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        options?.expectedStreamVersion,\n      );\n\n      const from = Number(options && 'from' in options ? options.from : 0);\n      const to = Number(\n        options && 'to' in options\n          ? options.to\n          : options && 'maxCount' in options && options.maxCount\n            ? options.from + options.maxCount\n            : events?.length ?? 1,\n      );\n\n      const resultEvents =\n        events && events.length > 0\n          ? events\n              .map(\n                (e) =>\n                  e as ReadEvent<\n                    EventType,\n                    ReadEventMetadataWithGlobalPosition\n                  >,\n              )\n              .slice(from, to)\n          : [];\n\n      const result: ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      > =\n        events && events.length > 0\n          ? {\n              currentStreamVersion: currentStreamVersion!,\n              events: resultEvents,\n            }\n          : null;\n\n      return Promise.resolve(result);\n    },\n\n    appendToStream: <EventType extends Event>(\n      streamName: string,\n      events: EventType[],\n      options?: AppendToStreamOptions,\n    ): Promise<AppendToStreamResult> => {\n      const currentEvents = streams.get(streamName) ?? [];\n      const currentStreamVersion =\n        currentEvents.length > 0 ? BigInt(currentEvents.length) : undefined;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        options?.expectedStreamVersion,\n      );\n\n      const eventEnvelopes: ReadEvent<\n        EventType,\n        ReadEventMetadataWithGlobalPosition\n      >[] = events.map((event, index) => {\n        return {\n          ...event,\n          metadata: {\n            ...(event.metadata ?? {}),\n            streamName,\n            eventId: randomUUID(),\n            streamPosition: BigInt(currentEvents.length + index + 1),\n            globalPosition: BigInt(getAllEventsCount() + index + 1),\n          },\n        };\n      });\n\n      const positionOfLastEventInTheStream = BigInt(\n        eventEnvelopes.slice(-1)[0]!.metadata.streamPosition,\n      );\n\n      streams.set(streamName, [...currentEvents, ...eventEnvelopes]);\n\n      const result: AppendToStreamResult = {\n        nextExpectedStreamVersion: positionOfLastEventInTheStream,\n      };\n\n      return Promise.resolve(result);\n    },\n  };\n};\n"]}

package/dist/chunk-NVBEM46D.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _chunk5DKEA5F6js = require('./chunk-5DKEA5F6.js');var _chunkO4DQCKRQjs = require('./chunk-O4DQCKRQ.js');var _chunkT2TX7UPUjs = require('./chunk-T2TX7UPU.js');var _chunkXW7A55JHjs = require('./chunk-XW7A55JH.js');var _chunkNERVHTL2js = require('./chunk-NERVHTL2.js');var _dumbo = require('@event-driven-io/dumbo');require('pg');var M=(t,e=_chunk5DKEA5F6js.d)=>{let g=_dumbo.dumbo.call(void 0, {connectionString:t,...e.connectionOptions?e.connectionOptions:{}}),d=_chunkO4DQCKRQjs.b.call(void 0, g),{projections:O}=e;return{async aggregateStream(o,n){await d;let{evolve:i,initialState:a,read:S}=n,l=_optionalChain([S, 'optionalAccess', _ => _.expectedStreamVersion]),r=a(),s=await this.readStream(o,n.read);if(s===null)return null;let c=s.currentStreamVersion;b(c,l);for(let P of s.events)P&&(r=i(r,P));return{currentStreamVersion:c,state:r}},readStream:async(o,n)=>(await d,_chunkXW7A55JHjs.a.call(void 0, g.execute,o,n)),appendToStream:async(o,n,i)=>{await d;let[a,...S]=o.split("-"),l=a&&S.length>0?a:"emt:unknown",r=await _chunkT2TX7UPUjs.b.call(void 0, g,o,l,n,{...i,preCommitHook:(s,c)=>_chunk5DKEA5F6js.e.call(void 0, O,t,s,c)});if(!r.success)throw new (0, _chunkNERVHTL2js.f)(-1n,_nullishCoalesce(_optionalChain([i, 'optionalAccess', _2 => _2.expectedStreamVersion]), () => (_chunkNERVHTL2js.e)));return{nextExpectedStreamVersion:r.nextStreamPosition}},close:()=>_dumbo.endPool.call(void 0, {connectionString:t})}},x=(t,e)=>e===_chunkNERVHTL2js.e?!0:e==_chunkNERVHTL2js.d?t===void 0:e==_chunkNERVHTL2js.c?t!==void 0:t===e,b=(t,e)=>{if(e??=_chunkNERVHTL2js.e,!x(t,e))throw new (0, _chunkNERVHTL2js.f)(t,e)};exports.a = M;
-//# sourceMappingURL=chunk-NVBEM46D.js.map

package/dist/chunk-NVBEM46D.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/eventStore/postgreSQLEventStore.ts"],"names":["dumbo","endPool","getPostgreSQLEventStore","connectionString","options","defaultPostgreSQLProjectionOptions","pool","ensureSchemaExists","createEventStoreSchema","projections","streamName","evolve","initialState","read","expectedStreamVersion","state","result","currentStreamVersion","assertExpectedVersionMatchesCurrent","event","readStream","events","firstPart","rest","streamType","appendResult","appendToStream","client","handleProjections","t","n","matchesExpectedVersion","current","expected","a","s"],"mappings":"oOAAA,OACE,SAAAA,EACA,WAAAC,MAIK,yBAkBP,MAAe,KAgFR,IAAMC,EAA0B,CACrCC,EACAC,EAAqCC,IACd,CACvB,IAAMC,EAAON,EAAM,CACjB,iBAAAG,EACA,GAAIC,EAAQ,kBAAoBA,EAAQ,kBAAoB,CAAC,CAC/D,CAAC,EACKG,EAAqBC,EAAuBF,CAAI,EAEhD,CAAE,YAAAG,CAAY,EAAIL,EAExB,MAAO,CACL,MAAM,gBACJM,EACAN,EAC8C,CAC9C,MAAMG,EACN,GAAM,CAAE,OAAAI,EAAQ,aAAAC,EAAc,KAAAC,CAAK,EAAIT,EAEjCU,EAAwBD,GAAM,sBAEhCE,EAAQH,EAAa,EAEnBI,EAAS,MAAM,KAAK,WAAsBN,EAAYN,EAAQ,IAAI,EAExE,GAAIY,IAAW,KAAM,OAAO,KAE5B,IAAMC,EAAuBD,EAAO,qBAEpCE,EACED,EACAH,CACF,EAEA,QAAWK,KAASH,EAAO,OACpBG,IAELJ,EAAQJ,EAAOI,EAAOI,CAAK,GAG7B,MAAO,CACL,qBAAsBF,EACtB,MAAAF,CACF,CACF,EAEA,WAAY,MACVL,EACAN,KAQA,MAAMG,EACCa,EAAsBd,EAAK,QAASI,EAAYN,CAAO,GAGhE,eAAgB,MACdM,EACAW,EACAjB,IACkC,CAClC,MAAMG,EAEN,GAAM,CAACe,EAAW,GAAGC,CAAI,EAAIb,EAAW,MAAM,GAAG,EAE3Cc,EACJF,GAAaC,EAAK,OAAS,EAAID,EAAY,cAEvCG,EAAe,MAAMC,EACzBpB,EACAI,EACAc,EACAH,EACA,CACE,GAAGjB,EACH,cAAe,CAACuB,EAAQN,IACtBO,EAAkBnB,EAAaN,EAAkBwB,EAAQN,CAAM,CACnE,CACF,EAEA,GAAI,CAACI,EAAa,QAChB,MAAM,IAAII,EACR,CAAC,GACDzB,GAAS,uBAAyB0B,CACpC,EAEF,MAAO,CAAE,0BAA2BL,EAAa,kBAAmB,CACtE,EACA,MAAO,IAAMxB,EAAQ,CAAE,iBAAAE,CAAiB,CAAC,CAC3C,CACF,EAEM4B,EAAyB,CAC7BC,EACAC,IAEIA,IAAaH,EAA6B,GAE1CG,GAAYC,EAA8BF,IAAY,OAEtDC,GAAYE,EAAsBH,IAAY,OAE3CA,IAAYC,EAGff,EAAsC,CAC1Cc,EACAC,IACS,CAGT,GAFAA,IAAaH,EAET,CAACC,EAAuBC,EAASC,CAAQ,EAC3C,MAAM,IAAIJ,EAA6BG,EAASC,CAAQ,CAC5D","sourcesContent":["import {\n  dumbo,\n  endPool,\n  type NodePostgresClientConnection,\n  type NodePostgresConnector,\n  type NodePostgresPoolClientConnection,\n} from '@event-driven-io/dumbo';\nimport {\n  ExpectedVersionConflictError,\n  NO_CONCURRENCY_CHECK,\n  STREAM_DOES_NOT_EXIST,\n  STREAM_EXISTS,\n  type AggregateStreamOptions,\n  type AggregateStreamResult,\n  type AppendToStreamOptions,\n  type AppendToStreamResult,\n  type DefaultStreamVersionType,\n  type Event,\n  type EventStore,\n  type ExpectedStreamVersion,\n  type ReadEventMetadataWithGlobalPosition,\n  type ReadStreamOptions,\n  type ReadStreamResult,\n} from '@event-driven-io/emmett';\nimport pg from 'pg';\nimport {\n  defaultPostgreSQLProjectionOptions,\n  handleProjections,\n  type PostgreSQLProjectionDefintion,\n} from './projections';\nimport { appendToStream, createEventStoreSchema, readStream } from './schema';\n\nexport interface PostgresEventStore\n  extends EventStore<\n    DefaultStreamVersionType,\n    ReadEventMetadataWithGlobalPosition\n  > {\n  close(): Promise<void>;\n}\n\ntype PostgresEventStorePooledOptions =\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: true;\n      pool: pg.Pool;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pool: pg.Pool;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: true;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n    };\n\ntype PostgresEventStoreNotPooledOptions =\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: false;\n      client: pg.Client;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      client: pg.Client;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      pooled: false;\n    }\n  | {\n      connector?: NodePostgresConnector;\n      connectionString?: string;\n      database?: string;\n      connection:\n        | NodePostgresPoolClientConnection\n        | NodePostgresClientConnection;\n      pooled?: false;\n    };\n\nexport type PostgresEventStoreConnectionOptions =\n  | PostgresEventStorePooledOptions\n  | PostgresEventStoreNotPooledOptions;\n\nexport type PostgresEventStoreOptions = {\n  projections: PostgreSQLProjectionDefintion[];\n  connectionOptions?: PostgresEventStoreConnectionOptions;\n};\nexport const getPostgreSQLEventStore = (\n  connectionString: string,\n  options: PostgresEventStoreOptions = defaultPostgreSQLProjectionOptions,\n): PostgresEventStore => {\n  const pool = dumbo({\n    connectionString,\n    ...(options.connectionOptions ? options.connectionOptions : {}),\n  });\n  const ensureSchemaExists = createEventStoreSchema(pool);\n\n  const { projections } = options;\n\n  return {\n    async aggregateStream<State, EventType extends Event>(\n      streamName: string,\n      options: AggregateStreamOptions<State, EventType>,\n    ): Promise<AggregateStreamResult<State> | null> {\n      await ensureSchemaExists;\n      const { evolve, initialState, read } = options;\n\n      const expectedStreamVersion = read?.expectedStreamVersion;\n\n      let state = initialState();\n\n      const result = await this.readStream<EventType>(streamName, options.read);\n\n      if (result === null) return null;\n\n      const currentStreamVersion = result.currentStreamVersion;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        expectedStreamVersion,\n      );\n\n      for (const event of result.events) {\n        if (!event) continue;\n\n        state = evolve(state, event);\n      }\n\n      return {\n        currentStreamVersion: currentStreamVersion,\n        state,\n      };\n    },\n\n    readStream: async <EventType extends Event>(\n      streamName: string,\n      options?: ReadStreamOptions,\n    ): Promise<\n      ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      >\n    > => {\n      await ensureSchemaExists;\n      return readStream<EventType>(pool.execute, streamName, options);\n    },\n\n    appendToStream: async <EventType extends Event>(\n      streamName: string,\n      events: EventType[],\n      options?: AppendToStreamOptions,\n    ): Promise<AppendToStreamResult> => {\n      await ensureSchemaExists;\n      // TODO: This has to be smarter when we introduce urn-based resolution\n      const [firstPart, ...rest] = streamName.split('-');\n\n      const streamType =\n        firstPart && rest.length > 0 ? firstPart : 'emt:unknown';\n\n      const appendResult = await appendToStream(\n        pool,\n        streamName,\n        streamType,\n        events,\n        {\n          ...options,\n          preCommitHook: (client, events) =>\n            handleProjections(projections, connectionString, client, events),\n        },\n      );\n\n      if (!appendResult.success)\n        throw new ExpectedVersionConflictError<bigint>(\n          -1n, //TODO: Return actual version in case of error\n          options?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK,\n        );\n\n      return { nextExpectedStreamVersion: appendResult.nextStreamPosition };\n    },\n    close: () => endPool({ connectionString }),\n  };\n};\n\nconst matchesExpectedVersion = (\n  current: bigint | undefined,\n  expected: ExpectedStreamVersion,\n): boolean => {\n  if (expected === NO_CONCURRENCY_CHECK) return true;\n\n  if (expected == STREAM_DOES_NOT_EXIST) return current === undefined;\n\n  if (expected == STREAM_EXISTS) return current !== undefined;\n\n  return current === expected;\n};\n\nconst assertExpectedVersionMatchesCurrent = (\n  current: bigint | undefined,\n  expected: ExpectedStreamVersion | undefined,\n): void => {\n  expected ??= NO_CONCURRENCY_CHECK;\n\n  if (!matchesExpectedVersion(current, expected))\n    throw new ExpectedVersionConflictError(current, expected);\n};\n"]}

package/dist/chunk-SDQ3ERUN.mjs

@@ -1,2 +0,0 @@
-var n=class extends Error{constructor(t){super(`Cannot parse! ${t}`)}},i={stringify:(t,e)=>JSON.stringify(e?.map?e.map(t):t,(r,a)=>typeof a=="bigint"?a.toString():a),parse:(t,e)=>{let r=JSON.parse(t,e?.reviver);if(e?.typeCheck&&!e?.typeCheck(r))throw new n(t);return e?.map?e.map(r):r}};var g=(t,e,r)=>({type:t,data:e,metadata:r});var l=(t=>(t.NOT_A_NONEMPTY_STRING="NOT_A_NONEMPTY_STRING",t.NOT_A_POSITIVE_NUMBER="NOT_A_POSITIVE_NUMBER",t.NOT_AN_UNSIGNED_BIGINT="NOT_AN_UNSIGNED_BIGINT",t))(l||{}),c=t=>typeof t=="number"&&t===t,m=t=>typeof t=="string";var s=class d extends Error{errorCode;constructor(e){let r=e&&typeof e=="object"&&"errorCode"in e?e.errorCode:c(e)?e:500,a=e&&typeof e=="object"&&"message"in e?e.message:m(e)?e:`Error with status code '${r}' ocurred during Emmett processing`;super(a),this.errorCode=r,Object.setPrototypeOf(this,d.prototype)}},o=class f extends s{constructor(e,r,a){super({errorCode:412,message:a??`Expected version ${r.toString()} does not match current ${e?.toString()}`}),this.current=e,this.expected=r,Object.setPrototypeOf(this,f.prototype)}};var y="STREAM_EXISTS",u="STREAM_DOES_NOT_EXIST",p="NO_CONCURRENCY_CHECK";var w=class h extends o{constructor(e,r){super(e?.toString(),r?.toString()),Object.setPrototypeOf(this,h.prototype)}};import Q from"async-retry";import{TransformStream as te}from"web-streams-polyfill";import{v4 as xe}from"uuid";export{i as a,g as b,y as c,u as d,p as e,w as f};
-//# sourceMappingURL=chunk-SDQ3ERUN.mjs.map

package/dist/chunk-SDQ3ERUN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../emmett/src/serialization/json/JSONParser.ts","../../emmett/src/typing/event.ts","../../emmett/src/validation/index.ts","../../emmett/src/errors/index.ts","../../emmett/src/validation/dates.ts","../../emmett/src/eventStore/expectedVersion.ts","../../emmett/src/streaming/restream.ts","../../emmett/src/eventStore/inMemoryEventStore.ts"],"sourcesContent":["export class ParseError extends Error {\n  constructor(text: string) {\n    super(`Cannot parse! ${text}`);\n  }\n}\n\nexport type Mapper<From, To = From> =\n  | ((value: unknown) => To)\n  | ((value: Partial<From>) => To)\n  | ((value: From) => To)\n  | ((value: Partial<To>) => To)\n  | ((value: To) => To)\n  | ((value: Partial<To | From>) => To)\n  | ((value: To | From) => To);\n\nexport type MapperArgs<From, To = From> = Partial<From> &\n  From &\n  Partial<To> &\n  To;\n\nexport type ParseOptions<From, To = From> = {\n  reviver?: (key: string, value: unknown) => unknown;\n  map?: Mapper<From, To>;\n  typeCheck?: <To>(value: unknown) => value is To;\n};\n\nexport type StringifyOptions<From, To = From> = {\n  map?: Mapper<From, To>;\n};\n\nexport const JSONParser = {\n  stringify: <From, To = From>(\n    value: From,\n    options?: StringifyOptions<From, To>,\n  ) => {\n    return JSON.stringify(\n      options?.map ? options.map(value as MapperArgs<From, To>) : value,\n      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      (_, v) => (typeof v === 'bigint' ? v.toString() : v),\n    );\n  },\n  parse: <From, To = From>(\n    text: string,\n    options?: ParseOptions<From, To>,\n  ): To | undefined => {\n    const parsed: unknown = JSON.parse(text, options?.reviver);\n\n    if (options?.typeCheck && !options?.typeCheck<To>(parsed))\n      throw new ParseError(text);\n\n    return options?.map\n      ? options.map(parsed as MapperArgs<From, To>)\n      : (parsed as To | undefined);\n  },\n};\n","import type { DefaultRecord, Flavour } from './';\n\nexport type Event<\n  EventType extends string = string,\n  EventData extends DefaultRecord = DefaultRecord,\n  EventMetaData extends DefaultRecord = DefaultRecord,\n> = Flavour<\n  Readonly<{\n    type: EventType;\n    data: EventData;\n    metadata?: EventMetaData;\n  }>,\n  'Event'\n>;\n\nexport type EventTypeOf<T extends Event> = T['type'];\nexport type EventDataOf<T extends Event> = T['data'];\nexport type EventMetaDataOf<T extends Event> = T['metadata'];\n\nexport type CreateEventType<\n  EventType extends string,\n  EventData extends DefaultRecord,\n  EventMetaData extends DefaultRecord | undefined,\n> = Readonly<{\n  type: EventType;\n  data: EventData;\n  metadata?: EventMetaData;\n}>;\n\nexport const event = <EventType extends Event>(\n  type: EventTypeOf<EventType>,\n  data: EventDataOf<EventType>,\n  metadata?: EventMetaDataOf<EventType>,\n): CreateEventType<\n  EventTypeOf<EventType>,\n  EventDataOf<EventType>,\n  EventMetaDataOf<EventType>\n> => {\n  return {\n    type,\n    data,\n    metadata,\n  };\n};\n\nexport type ReadEvent<\n  EventType extends Event = Event,\n  EventMetaDataType extends EventMetaDataOf<EventType> &\n    ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata,\n> = CreateEventType<\n  EventTypeOf<EventType>,\n  EventDataOf<EventType>,\n  EventMetaDataType\n> &\n  EventType & { metadata: EventMetaDataType };\n\nexport type ReadEventMetadata = Readonly<{\n  eventId: string;\n  streamPosition: bigint;\n  streamName: string;\n}>;\n\nexport type ReadEventMetadataWithGlobalPosition = ReadEventMetadata & {\n  globalPosition: bigint;\n};\n","import { ValidationError } from '../errors';\n\nexport const enum ValidationErrors {\n  NOT_A_NONEMPTY_STRING = 'NOT_A_NONEMPTY_STRING',\n  NOT_A_POSITIVE_NUMBER = 'NOT_A_POSITIVE_NUMBER',\n  NOT_AN_UNSIGNED_BIGINT = 'NOT_AN_UNSIGNED_BIGINT',\n}\n\nexport const isNumber = (val: unknown): val is number =>\n  typeof val === 'number' && val === val;\n\nexport const isString = (val: unknown): val is string =>\n  typeof val === 'string';\n\nexport const assertNotEmptyString = (value: unknown): string => {\n  if (!isString(value) || value.length === 0) {\n    throw new ValidationError(ValidationErrors.NOT_A_NONEMPTY_STRING);\n  }\n  return value;\n};\n\nexport const assertPositiveNumber = (value: unknown): number => {\n  if (!isNumber(value) || value <= 0) {\n    throw new ValidationError(ValidationErrors.NOT_A_POSITIVE_NUMBER);\n  }\n  return value;\n};\n\nexport const assertUnsignedBigInt = (value: string): bigint => {\n  const number = BigInt(value);\n  if (number < 0) {\n    throw new ValidationError(ValidationErrors.NOT_AN_UNSIGNED_BIGINT);\n  }\n  return number;\n};\n\nexport * from './dates';\n","import { isNumber, isString } from '../validation';\n\nexport type ErrorConstructor<ErrorType extends Error> = new (\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...args: any[]\n) => ErrorType;\n\nexport const isErrorConstructor = <ErrorType extends Error>(\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  expect: Function,\n): expect is ErrorConstructor<ErrorType> => {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return (\n    typeof expect === 'function' &&\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    expect.prototype &&\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    expect.prototype.constructor === expect\n  );\n};\n\nexport class EmmettError extends Error {\n  public errorCode: number;\n\n  constructor(\n    options?: { errorCode: number; message?: string } | string | number,\n  ) {\n    const errorCode =\n      options && typeof options === 'object' && 'errorCode' in options\n        ? options.errorCode\n        : isNumber(options)\n          ? options\n          : 500;\n    const message =\n      options && typeof options === 'object' && 'message' in options\n        ? options.message\n        : isString(options)\n          ? options\n          : `Error with status code '${errorCode}' ocurred during Emmett processing`;\n\n    super(message);\n    this.errorCode = errorCode;\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, EmmettError.prototype);\n  }\n}\n\nexport class ConcurrencyError extends EmmettError {\n  constructor(\n    public current: string | undefined,\n    public expected: string,\n    message?: string,\n  ) {\n    super({\n      errorCode: 412,\n      message:\n        message ??\n        `Expected version ${expected.toString()} does not match current ${current?.toString()}`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ConcurrencyError.prototype);\n  }\n}\n\nexport class ValidationError extends EmmettError {\n  constructor(message?: string) {\n    super({\n      errorCode: 400,\n      message: message ?? `Validation Error ocurred during Emmett processing`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ValidationError.prototype);\n  }\n}\n\nexport class IllegalStateError extends EmmettError {\n  constructor(message?: string) {\n    super({\n      errorCode: 403,\n      message: message ?? `Illegal State ocurred during Emmett processing`,\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, IllegalStateError.prototype);\n  }\n}\n\nexport class NotFoundError extends EmmettError {\n  constructor(options?: { id: string; type: string; message?: string }) {\n    super({\n      errorCode: 404,\n      message:\n        options?.message ??\n        (options?.id\n          ? options.type\n            ? `${options.type} with ${options.id} was not found during Emmett processing`\n            : `State with ${options.id} was not found during Emmett processing`\n          : options?.type\n            ? `${options.type} was not found during Emmett processing`\n            : 'State was not found during Emmett processing'),\n    });\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, NotFoundError.prototype);\n  }\n}\n","import { ValidationError } from '../errors';\n\nexport const formatDateToUtcYYYYMMDD = (date: Date) => {\n  // Use the 'en-CA' locale which formats as 'yyyy-mm-dd'\n  const formatter = new Intl.DateTimeFormat('en-CA', {\n    timeZone: 'UTC',\n    year: 'numeric',\n    month: '2-digit',\n    day: '2-digit',\n  });\n\n  // Format the date\n  return formatter.format(date);\n};\n\n// Function to validate 'yyyy-mm-dd' format\nexport const isValidYYYYMMDD = (dateString: string) => {\n  const regex = /^\\d{4}-\\d{2}-\\d{2}$/;\n  return regex.test(dateString);\n};\n\nexport const parseDateFromUtcYYYYMMDD = (dateString: string) => {\n  const date = new Date(dateString + 'T00:00:00Z');\n\n  if (!isValidYYYYMMDD(dateString)) {\n    throw new ValidationError('Invalid date format, must be yyyy-mm-dd');\n  }\n\n  if (isNaN(date.getTime())) {\n    throw new ValidationError('Invalid date format');\n  }\n\n  return date;\n};\n","import { ConcurrencyError } from '../errors';\nimport type { Flavour } from '../typing';\nimport type { DefaultStreamVersionType } from './eventStore';\n\nexport type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> =\n  | ExpectedStreamVersionWithValue<VersionType>\n  | ExpectedStreamVersionGeneral;\n\nexport type ExpectedStreamVersionWithValue<\n  VersionType = DefaultStreamVersionType,\n> = Flavour<VersionType, 'StreamVersion'>;\n\nexport type ExpectedStreamVersionGeneral = Flavour<\n  'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK',\n  'StreamVersion'\n>;\n\nexport const STREAM_EXISTS = 'STREAM_EXISTS' as ExpectedStreamVersionGeneral;\nexport const STREAM_DOES_NOT_EXIST =\n  'STREAM_DOES_NOT_EXIST' as ExpectedStreamVersionGeneral;\nexport const NO_CONCURRENCY_CHECK =\n  'NO_CONCURRENCY_CHECK' as ExpectedStreamVersionGeneral;\n\nexport const matchesExpectedVersion = <\n  StreamVersion = DefaultStreamVersionType,\n>(\n  current: StreamVersion | undefined,\n  expected: ExpectedStreamVersion<StreamVersion>,\n): boolean => {\n  if (expected === NO_CONCURRENCY_CHECK) return true;\n\n  if (expected == STREAM_DOES_NOT_EXIST) return current === undefined;\n\n  if (expected == STREAM_EXISTS) return current !== undefined;\n\n  return current === expected;\n};\n\nexport const assertExpectedVersionMatchesCurrent = <\n  StreamVersion = DefaultStreamVersionType,\n>(\n  current: StreamVersion | undefined,\n  expected: ExpectedStreamVersion<StreamVersion> | undefined,\n): void => {\n  expected ??= NO_CONCURRENCY_CHECK;\n\n  if (!matchesExpectedVersion(current, expected))\n    throw new ExpectedVersionConflictError(current, expected);\n};\n\nexport class ExpectedVersionConflictError<\n  VersionType = DefaultStreamVersionType,\n> extends ConcurrencyError {\n  constructor(\n    current: VersionType | undefined,\n    expected: ExpectedStreamVersion<VersionType>,\n  ) {\n    super(current?.toString(), expected?.toString());\n\n    // 👇️ because we are extending a built-in class\n    Object.setPrototypeOf(this, ExpectedVersionConflictError.prototype);\n  }\n}\n","import retry from 'async-retry';\nimport {\n  ReadableStream,\n  ReadableStreamDefaultReader,\n  TransformStream,\n  TransformStreamDefaultController,\n} from 'web-streams-polyfill';\nimport type { Decoder } from './decoders';\nimport { DefaultDecoder } from './decoders/composite';\n\nexport const restream = <\n  Source = unknown,\n  Transformed = Source,\n  StreamType = object,\n>(\n  createSourceStream: () => ReadableStream<StreamType>,\n  transform: (input: Source) => Transformed = (source) =>\n    source as unknown as Transformed,\n  retryOptions: retry.Options = { forever: true, minTimeout: 25 },\n  decoder: Decoder<StreamType, Source> = new DefaultDecoder<Source>(),\n): ReadableStream<Transformed> =>\n  new TransformStream<Source, Transformed>({\n    start(controller) {\n      retry(\n        () => onRestream(createSourceStream, controller, transform, decoder),\n        retryOptions,\n      ).catch((error) => {\n        controller.error(error);\n      });\n    },\n  }).readable;\n\nconst onRestream = async <StreamType, Source, Transformed = Source>(\n  createSourceStream: () => ReadableStream<StreamType>,\n  controller: TransformStreamDefaultController<Transformed>,\n  transform: (input: Source) => Transformed,\n  decoder: Decoder<StreamType, Source>,\n): Promise<void> => {\n  const sourceStream = createSourceStream();\n  const reader = sourceStream.getReader();\n  try {\n    let done: boolean;\n\n    do {\n      done = await restreamChunk(reader, controller, transform, decoder);\n    } while (!done);\n  } finally {\n    reader.releaseLock();\n  }\n};\n\nconst restreamChunk = async <StreamType, Source, Transformed = Source>(\n  reader: ReadableStreamDefaultReader<StreamType>,\n  controller: TransformStreamDefaultController<Transformed>,\n  transform: (input: Source) => Transformed,\n  decoder: Decoder<StreamType, Source>,\n): Promise<boolean> => {\n  const { done: isDone, value } = await reader.read();\n\n  if (value) decoder.addToBuffer(value);\n\n  if (!isDone && !decoder.hasCompleteMessage()) return false;\n\n  decodeAndTransform(decoder, transform, controller);\n\n  if (isDone) {\n    controller.terminate();\n  }\n\n  return isDone;\n};\n\nconst decodeAndTransform = <StreamType, Source, Transformed = Source>(\n  decoder: Decoder<StreamType, Source>,\n  transform: (input: Source) => Transformed,\n  controller: TransformStreamDefaultController<Transformed>,\n) => {\n  try {\n    const decoded = decoder.decode();\n    if (!decoded) return;\n\n    const transformed = transform(decoded);\n    controller.enqueue(transformed);\n  } catch (error) {\n    controller.error(new Error(`Decoding error: ${error?.toString()}`));\n  }\n};\n","import { v4 as randomUUID } from 'uuid';\nimport type {\n  Event,\n  ReadEvent,\n  ReadEventMetadataWithGlobalPosition,\n} from '../typing';\nimport {\n  type AggregateStreamOptions,\n  type AggregateStreamResult,\n  type AppendToStreamOptions,\n  type AppendToStreamResult,\n  type DefaultStreamVersionType,\n  type EventStore,\n  type ReadStreamOptions,\n  type ReadStreamResult,\n} from './eventStore';\nimport { assertExpectedVersionMatchesCurrent } from './expectedVersion';\n\nexport type EventHandler<E extends Event = Event> = (\n  eventEnvelope: ReadEvent<E>,\n) => void;\n\nexport const getInMemoryEventStore = (): EventStore<\n  DefaultStreamVersionType,\n  ReadEventMetadataWithGlobalPosition\n> => {\n  const streams = new Map<string, ReadEvent[]>();\n\n  const getAllEventsCount = () => {\n    return Array.from<ReadEvent[]>(streams.values())\n      .map((s) => s.length)\n      .reduce((p, c) => p + c, 0);\n  };\n\n  return {\n    async aggregateStream<State, EventType extends Event>(\n      streamName: string,\n      options: AggregateStreamOptions<State, EventType>,\n    ): Promise<AggregateStreamResult<State> | null> {\n      const { evolve, initialState, read } = options;\n\n      const result = await this.readStream<EventType>(streamName, read);\n\n      if (!result) return null;\n\n      const events = result?.events ?? [];\n\n      return {\n        currentStreamVersion: BigInt(events.length),\n        state: events.reduce(evolve, initialState()),\n      };\n    },\n\n    readStream: <EventType extends Event>(\n      streamName: string,\n      options?: ReadStreamOptions,\n    ): Promise<\n      ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      >\n    > => {\n      const events = streams.get(streamName);\n      const currentStreamVersion = events ? BigInt(events.length) : undefined;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        options?.expectedStreamVersion,\n      );\n\n      const from = Number(options && 'from' in options ? options.from : 0);\n      const to = Number(\n        options && 'to' in options\n          ? options.to\n          : options && 'maxCount' in options && options.maxCount\n            ? options.from + options.maxCount\n            : events?.length ?? 1,\n      );\n\n      const resultEvents =\n        events && events.length > 0\n          ? events\n              .map(\n                (e) =>\n                  e as ReadEvent<\n                    EventType,\n                    ReadEventMetadataWithGlobalPosition\n                  >,\n              )\n              .slice(from, to)\n          : [];\n\n      const result: ReadStreamResult<\n        EventType,\n        DefaultStreamVersionType,\n        ReadEventMetadataWithGlobalPosition\n      > =\n        events && events.length > 0\n          ? {\n              currentStreamVersion: currentStreamVersion!,\n              events: resultEvents,\n            }\n          : null;\n\n      return Promise.resolve(result);\n    },\n\n    appendToStream: <EventType extends Event>(\n      streamName: string,\n      events: EventType[],\n      options?: AppendToStreamOptions,\n    ): Promise<AppendToStreamResult> => {\n      const currentEvents = streams.get(streamName) ?? [];\n      const currentStreamVersion =\n        currentEvents.length > 0 ? BigInt(currentEvents.length) : undefined;\n\n      assertExpectedVersionMatchesCurrent(\n        currentStreamVersion,\n        options?.expectedStreamVersion,\n      );\n\n      const eventEnvelopes: ReadEvent<\n        EventType,\n        ReadEventMetadataWithGlobalPosition\n      >[] = events.map((event, index) => {\n        return {\n          ...event,\n          metadata: {\n            ...(event.metadata ?? {}),\n            streamName,\n            eventId: randomUUID(),\n            streamPosition: BigInt(currentEvents.length + index + 1),\n            globalPosition: BigInt(getAllEventsCount() + index + 1),\n          },\n        };\n      });\n\n      const positionOfLastEventInTheStream = BigInt(\n        eventEnvelopes.slice(-1)[0]!.metadata.streamPosition,\n      );\n\n      streams.set(streamName, [...currentEvents, ...eventEnvelopes]);\n\n      const result: AppendToStreamResult = {\n        nextExpectedStreamVersion: positionOfLastEventInTheStream,\n      };\n\n      return Promise.resolve(result);\n    },\n  };\n};\n"],"mappings":"AAAO,IAAMA,EAAN,cAAyB,KAAM,CACpC,YAAYC,EAAc,CACxB,MAAM,iBAAiBA,CAAI,EAAE,CAC/B,CACF,EA0BaC,EAAa,CACxB,UAAW,CACTC,EACAC,IAEO,KAAK,UACVA,GAAS,IAAMA,EAAQ,IAAID,CAA6B,EAAIA,EAG5D,CAACE,EAAGC,IAAO,OAAOA,GAAM,SAAWA,EAAE,SAAS,EAAIA,CACpD,EAEF,MAAO,CACLL,EACAG,IACmB,CACnB,IAAMG,EAAkB,KAAK,MAAMN,EAAMG,GAAS,OAAO,EAEzD,GAAIA,GAAS,WAAa,CAACA,GAAS,UAAcG,CAAM,EACtD,MAAM,IAAIP,EAAWC,CAAI,EAE3B,OAAOG,GAAS,IACZA,EAAQ,IAAIG,CAA8B,EACzCA,CACP,CACF,EC1BO,IAAMC,EAAQ,CACnBC,EACAC,EACAC,KAMO,CACL,KAAAF,EACA,KAAAC,EACA,SAAAC,CACF,GCxCK,IAAWC,GAAAA,IAChBA,EAAA,sBAAwB,wBACxBA,EAAA,sBAAwB,wBACxBA,EAAA,uBAAyB,yBAHTA,IAAAA,GAAA,CAAA,CAAA,EAMLC,EAAYC,GACvB,OAAOA,GAAQ,UAAYA,IAAQA,EAExBC,EAAYD,GACvB,OAAOA,GAAQ,SCLV,IAcME,EAAN,MAAMC,UAAoB,KAAM,CAC9B,UAEP,YACEC,EACA,CACA,IAAMC,EACJD,GAAW,OAAOA,GAAY,UAAY,cAAeA,EACrDA,EAAQ,UACRE,EAASF,CAAO,EACdA,EACA,IACFG,EACJH,GAAW,OAAOA,GAAY,UAAY,YAAaA,EACnDA,EAAQ,QACRI,EAASJ,CAAO,EACdA,EACA,2BAA2BC,CAAS,qCAE5C,MAAME,CAAO,EACb,KAAK,UAAYF,EAGjB,OAAO,eAAe,KAAMF,EAAY,SAAS,CACnD,CACF,EAEaM,EAAN,MAAMC,UAAyBR,CAAY,CAChD,YACSS,EACAC,EACPL,EACA,CACA,MAAM,CACJ,UAAW,IACX,QACEA,GACA,oBAAoBK,EAAS,SAAS,CAAC,2BAA2BD,GAAS,SAAS,CAAC,EACzF,CAAC,EATM,KAAA,QAAAA,EACA,KAAA,SAAAC,EAWP,OAAO,eAAe,KAAMF,EAAiB,SAAS,CACxD,CACF,EE/CO,IAAMG,EAAgB,gBAChBC,EACX,wBACWC,EACX,uBAJK,IAiCMC,EAAN,MAAMC,UAEHC,CAAiB,CACzB,YACEC,EACAC,EACA,CACA,MAAMD,GAAS,SAAS,EAAGC,GAAU,SAAS,CAAC,EAG/C,OAAO,eAAe,KAAMH,EAA6B,SAAS,CACpE,CACF,EC9DA,OAAOI,MAAW,cAClB,OAGE,mBAAAC,OAEK,uBCNP,OAAS,MAAMC,OAAkB","names":["ParseError","text","JSONParser","value","options","_","v","parsed","event","type","data","metadata","ValidationErrors","isNumber","val","isString","EmmettError","_EmmettError","options","errorCode","isNumber","message","isString","ConcurrencyError","_ConcurrencyError","current","expected","STREAM_EXISTS","STREAM_DOES_NOT_EXIST","NO_CONCURRENCY_CHECK","ExpectedVersionConflictError","_ExpectedVersionConflictError","ConcurrencyError","current","expected","retry","TransformStream","randomUUID"]}

package/dist/eventStore/projections/pongo.d.mts

@@ -1,5 +0,0 @@
-import '@event-driven-io/emmett';
-import '@event-driven-io/pongo';
-import 'pg';
-export { q as PongoDocumentEvolve, o as PongoProjectionHandler, n as PongoProjectionOptions, s as pongoMultiStreamProjection, r as pongoProjection, t as pongoSingleProjection } from '../../postgreSQLEventStore-CVNHmyvr.mjs';
-import '@event-driven-io/dumbo';

package/dist/eventStore/projections/pongo.d.ts

@@ -1,5 +0,0 @@
-import '@event-driven-io/emmett';
-import '@event-driven-io/pongo';
-import 'pg';
-export { q as PongoDocumentEvolve, o as PongoProjectionHandler, n as PongoProjectionOptions, s as pongoMultiStreamProjection, r as pongoProjection, t as pongoSingleProjection } from '../../postgreSQLEventStore-CVNHmyvr.js';
-import '@event-driven-io/dumbo';

package/dist/eventStore/projections/pongo.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk5DKEA5F6js = require('../../chunk-5DKEA5F6.js');require('../../chunk-NERVHTL2.js');exports.pongoMultiStreamProjection = _chunk5DKEA5F6js.b; exports.pongoProjection = _chunk5DKEA5F6js.a; exports.pongoSingleProjection = _chunk5DKEA5F6js.c;
-//# sourceMappingURL=pongo.js.map

package/dist/eventStore/projections/pongo.mjs

@@ -1,2 +0,0 @@
-import{a,b,c}from"../../chunk-7AXC6NM5.mjs";import"../../chunk-SDQ3ERUN.mjs";export{b as pongoMultiStreamProjection,a as pongoProjection,c as pongoSingleProjection};
-//# sourceMappingURL=pongo.mjs.map

package/dist/postgreSQLEventStore-CVNHmyvr.d.mts

@@ -1,91 +0,0 @@
-import { NodePostgresClient, SQLExecutor, NodePostgresTransaction, SQL, NodePostgresConnector, NodePostgresPoolClientConnection, NodePostgresClientConnection } from '@event-driven-io/dumbo';
-import { Event, ReadEvent, EventTypeOf, ProjectionHandler, ProjectionDefintion, EventStore, DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition } from '@event-driven-io/emmett';
-import pg from 'pg';
-import { PongoDocument, PongoClient } from '@event-driven-io/pongo';
-
-type PongoProjectionOptions<EventType extends Event> = {
-    documentId: (event: ReadEvent<EventType>) => string;
-    eventHandler: PongoProjectionHandler<EventType>;
-    eventTypes: EventTypeOf<EventType>[];
-};
-type PongoProjectionHandler<EventType extends Event = Event> = (documentId: (event: ReadEvent<EventType>) => string, connectionString: string, client: pg.PoolClient, events: ReadEvent<EventType>[]) => Promise<void> | void;
-type PongoDocumentEvolve<Document extends PongoDocument, EventType extends Event> = ((document: Document | null, event: ReadEvent<EventType>) => Document | null) | ((document: Document | null, event: ReadEvent<EventType>) => Promise<Document | null>);
-declare const pongoProjection: <EventType extends Event>(handle: (pongo: PongoClient, events: ReadEvent<EventType>[]) => Promise<void>, ...canHandle: EventTypeOf<EventType>[]) => PostgreSQLProjectionDefintion;
-declare const pongoMultiStreamProjection: <Document extends PongoDocument, EventType extends Event>(collectionName: string, getDocumentId: (event: ReadEvent<EventType>) => string, evolve: PongoDocumentEvolve<Document, EventType>, ...canHandle: EventTypeOf<EventType>[]) => PostgreSQLProjectionDefintion;
-declare const pongoSingleProjection: <Document extends PongoDocument, EventType extends Event>(collectionName: string, evolve: PongoDocumentEvolve<Document, EventType>, ...canHandle: EventTypeOf<EventType>[]) => PostgreSQLProjectionDefintion;
-
-type PostgreSQLProjectionHandlerContext = {
-    connectionString: string;
-    client: NodePostgresClient;
-    execute: SQLExecutor;
-    transaction: NodePostgresTransaction;
-};
-type PostgreSQLProjectionHandler<EventType extends Event = Event> = ProjectionHandler<EventType, PostgreSQLProjectionHandlerContext>;
-interface PostgreSQLProjectionDefintion<EventType extends Event = Event> extends ProjectionDefintion<'inline', EventType, PostgreSQLProjectionHandlerContext> {
-}
-declare const defaultPostgreSQLProjectionOptions: PostgresEventStoreOptions;
-declare const handleProjections: <EventType extends Event = Event>(allProjections: PostgreSQLProjectionDefintion<EventType>[], connectionString: string, transaction: NodePostgresTransaction, events: ReadEvent<EventType>[]) => Promise<void>;
-declare const postgreSQLProjection: <EventType extends Event>(definition: PostgreSQLProjectionDefintion<EventType>) => PostgreSQLProjectionDefintion;
-/** @deprecated use postgreSQLProjection instead */
-declare const projection: <EventType extends Event>(definition: PostgreSQLProjectionDefintion<EventType>) => PostgreSQLProjectionDefintion;
-declare const postgreSQLInlineProjection: <EventType extends Event>(definition: Omit<PostgreSQLProjectionDefintion<EventType>, 'type'>) => PostgreSQLProjectionDefintion;
-/** @deprecated use postgreSQLSingleProjection instead */
-declare const inlineProjection: <EventType extends Event>(definition: Omit<PostgreSQLProjectionDefintion<EventType>, 'type'>) => PostgreSQLProjectionDefintion;
-declare const postgreSQLRawBatchSQLProjection: <EventType extends Event>(handle: (events: EventType[], context: PostgreSQLProjectionHandlerContext) => Promise<SQL[]> | SQL[], ...canHandle: EventTypeOf<EventType>[]) => PostgreSQLProjectionDefintion;
-declare const postgreSQLRawSQLProjection: <EventType extends Event>(handle: (event: EventType, context: PostgreSQLProjectionHandlerContext) => Promise<SQL> | SQL, ...canHandle: EventTypeOf<EventType>[]) => PostgreSQLProjectionDefintion;
-
-interface PostgresEventStore extends EventStore<DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition> {
-    close(): Promise<void>;
-}
-type PostgresEventStorePooledOptions = {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    pooled: true;
-    pool: pg.Pool;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    pool: pg.Pool;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    pooled: true;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-};
-type PostgresEventStoreNotPooledOptions = {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    pooled: false;
-    client: pg.Client;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    client: pg.Client;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    pooled: false;
-} | {
-    connector?: NodePostgresConnector;
-    connectionString?: string;
-    database?: string;
-    connection: NodePostgresPoolClientConnection | NodePostgresClientConnection;
-    pooled?: false;
-};
-type PostgresEventStoreConnectionOptions = PostgresEventStorePooledOptions | PostgresEventStoreNotPooledOptions;
-type PostgresEventStoreOptions = {
-    projections: PostgreSQLProjectionDefintion[];
-    connectionOptions?: PostgresEventStoreConnectionOptions;
-};
-declare const getPostgreSQLEventStore: (connectionString: string, options?: PostgresEventStoreOptions) => PostgresEventStore;
-
-export { type PostgresEventStore as P, type PostgresEventStoreConnectionOptions as a, type PostgresEventStoreOptions as b, type PostgreSQLProjectionHandlerContext as c, type PostgreSQLProjectionHandler as d, type PostgreSQLProjectionDefintion as e, defaultPostgreSQLProjectionOptions as f, getPostgreSQLEventStore as g, handleProjections as h, projection as i, postgreSQLInlineProjection as j, inlineProjection as k, postgreSQLRawBatchSQLProjection as l, postgreSQLRawSQLProjection as m, type PongoProjectionOptions as n, type PongoProjectionHandler as o, postgreSQLProjection as p, type PongoDocumentEvolve as q, pongoProjection as r, pongoMultiStreamProjection as s, pongoSingleProjection as t };