@bett3r-dev/pv3 1.0.0

package/src/ports/eventsourcing/invariants/comparisons.ts

@@ -0,0 +1,90 @@
+import { noop, safePromise } from '@bett3r-dev/bett3r-utils';
+import S from '@bett3r-dev/jsonschema-definer';
+import { CommandHandlerState, DatabaseOps, EndpointsPort, InvariantParams, InvariantType, ReadmodelInvariantComparison, filterOpMap } from '@bett3r-dev/pv3-types';
+import { equals, path } from 'ramda';
+import { createInvariant } from '.';
+
+const compareCheck = ( val1:any, val2:any, op: DatabaseOps ) => {
+  return filterOpMap[op]( val1, val2 );
+};
+
+export const comparePaths = ( params: InvariantParams & { path1: string | (( state:CommandHandlerState ) => any ) ; path2?: string | (( data:CommandHandlerState ) => any ), op: DatabaseOps }): InvariantType => {
+  const { path1, path2, op } = params;
+  return createInvariant(
+    async ( handlerState: CommandHandlerState ) => {
+      const path1Value = typeof path1 === 'string' ? path( path1.split( '.' ), handlerState ) : path1( handlerState );
+      const path2Value = path2 && ( typeof path2 === 'string' ? path( path2.split( '.' ), handlerState ) : path2( handlerState ));
+      return safePromise( equals( true ), compareCheck( path1Value, path2Value, op )).then( noop ) ;
+    }, {
+      name: 'Invariant Error',
+      description: `Comparison failed on paths for operation ${op}`,
+      details: { path1, path2 },
+      type: 'BadRequestError',
+      schema: S.shape({
+        path1: S.string(),
+        path2: S.string(),
+      })
+    }
+  );
+};
+
+export const compareWithValue = ( params: InvariantParams & { path: string; value: any, op: DatabaseOps }): InvariantType => {
+  const { path: path1, value, op } = params;
+  return createInvariant(
+    async ( handlerState: CommandHandlerState ) => {
+      const path1Value = path( path1.split( '.' ), handlerState );
+      return safePromise( equals( true ), compareCheck( path1Value, value, op )).then( noop ) ;
+    }, {
+      name: 'Invariant Error',
+      description: `Comparison failed with value ${value} for operation ${op}`,
+      details: { path: path1 },
+      type: 'BadRequestError',
+      schema: S.shape({
+        path: S.string()
+      })
+    }
+  );
+};
+
+const checkReadmodelFilter = ( pathValue: any, readmodelValue:any, filter: ReadmodelInvariantComparison ) => {
+  if ( filter.OR ) {
+    return filter.OR.some(( _filter ) => checkReadmodelFilter( pathValue, readmodelValue, _filter ));
+  }
+  else if ( filter.AND ) {
+    return filter.AND.every(( _filter ) => checkReadmodelFilter( pathValue, readmodelValue, _filter ));
+  }
+  return compareCheck( pathValue, readmodelValue, filter.op! );
+};
+
+export const compareWithReadmodel = ( params: InvariantParams & {
+  endpoints: EndpointsPort;
+  readmodelBaseUrl: string;
+  comparisons: ReadmodelInvariantComparison[];
+  url: ( handlerState: CommandHandlerState ) => string;
+}
+): InvariantType => {
+  const { endpoints, readmodelBaseUrl, comparisons, url } = params;
+  return createInvariant(
+    async ( handlerState: CommandHandlerState ) => {
+      const requestPath = `${readmodelBaseUrl}${url( handlerState )}`;
+      return endpoints.get( requestPath ).then(( response: any[]) => {
+        if ( !response || !response.length || !comparisons.every(( comparison ) => {
+          const dataValue = path(( comparison.path as string ).split( '.' ), handlerState );
+          return checkReadmodelFilter( dataValue, path(( comparison.readmodelPath as string ).split( '.' ), response[0]), comparison );
+        }))
+          return Promise.reject({
+            details: { readmodelUrl: requestPath },
+            description: `Comparison failed with readmodel ${requestPath}`
+          });
+        return Promise.resolve();
+      });
+    }, {
+      name: 'Invariant Error',
+      description: 'Invariant Validation Failed',
+      type: 'BadRequestError',
+      schema: S.shape({
+        readmodelUrl: S.string(),
+      })
+    }
+  );
+};

package/src/ports/eventsourcing/invariants/index.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './combinators';
+export * from './comparisons';
+export * from './stateExistance';

package/src/ports/eventsourcing/invariants/stateExistance.ts

@@ -0,0 +1,34 @@
+import { InvariantParams, InvariantType } from '@bett3r-dev/pv3-types';
+import { createInvariant } from '.';
+
+export const stateExists = ( params?: InvariantParams ): InvariantType => {
+  return createInvariant(
+    async ( handlerState ) => {
+      return handlerState.state
+        ? Promise.resolve()
+        : Promise.reject({
+          description: `Expected State in aggregate ${handlerState.commandHandler.name}`,
+          details: { requested: handlerState.stream }
+        });
+    },{
+      name: params?.errorName || `State Does Not Exists`,
+      type: params?.errorType || 'BadRequestError'
+    }
+  );
+};
+
+export const stateNotExists = ( params?: InvariantParams ): InvariantType => {
+  return createInvariant(
+    async ( handlerState ) => {
+      return !handlerState.state
+        ? Promise.resolve()
+        : Promise.reject({
+          description: `Unexpected State in aggregate ${handlerState.commandHandler.name}`,
+          details: { requested: handlerState.stream },
+        });
+    },{
+      name: params?.errorName || `Unexpected State`,
+      type: params?.errorType || 'BadRequestError'
+    }
+  );
+};

package/src/ports/eventsourcing/subscriptions/index.ts

@@ -0,0 +1 @@
+export * from './sseSubscriptions';

package/src/ports/eventsourcing/subscriptions/sseSubscriptions.ts

@@ -0,0 +1,103 @@
+import { ensureArray } from '@bett3r-dev/bett3r-utils';
+import { CollectionQueryParams, DatabaseChange, Document, filterOpMap, LoggerType, ReadmodelChange, ReadModelSubscription, ReadModelSubscriptionCloseEmitterEvents, ReadmodelSubscriptionManagerType, RequestObject, ResponseObject, TypedEventEmitter } from '@bett3r-dev/pv3-types';
+import { randomUUID } from 'crypto';
+
+export const SSESubscriptions = (): ReadmodelSubscriptionManagerType => {
+  const subscriptions: Record<string, ReadModelSubscription> = {};
+  const readModelSubscriptionCloseEmitter = new TypedEventEmitter<ReadModelSubscriptionCloseEmitterEvents>();
+
+  const send = ( logger:LoggerType, id: string, change:DatabaseChange,collection: string, res: ResponseObject, data: string ): void => {
+    logger.log( 'Sending SSE event in subscription', id, 'for', change.changeType, collection, change.data.id || change.previous.id );
+    res.raw.write( `data: ${data}\n\n` );
+  };
+
+  const subscriptionIncludes = ( s: ReadModelSubscription, data: any ) => {
+    return (
+      !s.filter ||
+      s.filter.every(( filter ) =>
+        filterOpMap[filter.op as string]( data[filter.field as string], filter.value )
+      )
+    );
+  };
+
+  const notifySubscriptions = ( logger: LoggerType, collection: string ) => <T>( change: DatabaseChange, subscriptionId?: string ) => {
+    if ( !change.data ) return;
+    setImmediate(() => {
+      const message = JSON.stringify({
+        type: change.changeType,
+        data: change.data,
+      } as ReadmodelChange<any> );
+      // if ( subscriptionId ){
+
+      // }
+      Object.values( subscriptions ).forEach(( s ) => {
+        if (( change.changeType === 'delete' && subscriptionIncludes( s, change.previous ))
+          || ([ 'insert', 'update' ].includes( change.changeType ) && subscriptionIncludes( s, change.data ))
+          || ( change.changeType === 'update' && subscriptionIncludes( s, change.previous ))
+        ){
+          send( logger, s.id, change, collection, s.res, message );
+        }
+      });
+    });
+  };
+
+  const initSubscription = (
+    req: RequestObject,
+    res: ResponseObject,
+    id: string
+  ): void => {
+    const headers = {
+      'Content-Type': 'text/event-stream',
+      'Connection': 'keep-alive',
+      'Cache-Control': 'no-cache',
+      'X-Accel-Buffering': 'no'
+    };
+
+    // FIXME: Como puedo detectar que el request viene de nginx?
+    if ( !req.headers['asdf']){
+      headers['Access-Control-Allow-Origin'] = '*';
+    }
+
+    res.raw.writeHead( 200, headers );
+    res.raw.write( `data: Connected\n\n` );
+    req.raw.on( 'close', () => {
+      readModelSubscriptionCloseEmitter.emit( 'close', id );
+      delete subscriptions[id];
+    });
+  };
+
+  const createSubscription = <Model extends Document = any>(
+    res: ResponseObject,
+    conditions: CollectionQueryParams<Model>
+  ): string => {
+    const id = randomUUID();
+    const newSubscription: ReadModelSubscription = {
+      id: id,
+      res,
+      filter: conditions.filter || []
+    };
+    subscriptions[id] = newSubscription;
+    return id;
+  };
+
+  const startSubscription = <Model extends Document>(
+    projectionParams: CollectionQueryParams<Model>,
+    req: RequestObject,
+    res: ResponseObject
+  ) => {
+    if ( ensureArray( req?.headers?.accept ).includes( 'text/event-stream' )){
+      const id = createSubscription( res, projectionParams );
+      initSubscription( req, res, id );
+      return id;
+    }
+  };
+
+  return {
+    type: 'SSE',
+    startSubscription,
+    notifySubscriptions,
+    readModelSubscriptionCloseEmitter,
+    send
+  };
+};
+

package/src/ports/eventsourcing/utils/aggregateBuilder.ts

@@ -0,0 +1,49 @@
+import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { Aggregate, AggregateBuilderType, Command, DatabasePort, EventFactory, EventReducers } from '@bett3r-dev/pv3-types';
+import { ExternalSystemBuilder } from './externalSystemBuilder';
+
+export const AggregateBuilder = <Model, EVENTS extends Record<string, EventFactory>>( schema: BaseSchema<Model>, events: EVENTS, aggregate = {} as Aggregate ): AggregateBuilderType<Model, EVENTS> => {
+  const { system, ...builder } = ExternalSystemBuilder( events, schema, aggregate );
+  aggregate = system as Aggregate;
+  aggregate.schema = schema;
+  aggregate.initialValue = () => undefined;
+
+  const notEventsourced = ( database: DatabasePort, collection: string ) =>{
+    aggregate.isEventsourced = false;
+    aggregate.outboxDatabase = database;
+    aggregate.outboxCollection = collection;
+    return _builder;
+  };
+
+  const withCommandTemplate = ( command: Command ) => {
+    builder.withCommandTemplate( command );
+    return _builder;
+  };
+
+  const initialValue = ( init: () => ( Partial<Model> | null | undefined )) => {
+    aggregate.initialValue = init;
+    return {
+      withEventReducers: withEventReducers( events ),
+      withCommands: _builder.withCommands
+    };
+  };
+
+  const withEventReducers = <Events extends Record<string, EventFactory>>( events: Events ) => ( eventReducers: EventReducers<Events, Model> ) => {
+    aggregate.eventReducers = eventReducers;
+    return {
+      withCommands: _builder.withCommands
+    };
+  };
+
+  const _builder = {
+    ...builder,
+    notEventsourced,
+    withCommandTemplate,
+    withEventReducers: withEventReducers( events ),
+    withCommands: builder.withCommands,
+    initialValue,
+    system: aggregate
+  };
+
+  return _builder;
+};

package/src/ports/eventsourcing/utils/commandBuilder.ts

@@ -0,0 +1,113 @@
+import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { Command, CommandBuilderType, CommandCommitFunction, CommandErrorHandlerFunction, CommandFormatFunction, CommandHandlerFunction, CommandLoadFunction, EventFactory, InvariantType } from '@bett3r-dev/pv3-types';
+
+export const CommandBuilder = ( systemLevelInit?: Omit<Command, 'handler' | 'events' | 'schema'> ): CommandBuilderType => <Model, EVENTS extends Record<string, EventFactory>>( init?: Omit<Command, 'handler' | 'events' | 'schema'> ) => {
+  const command = {
+    ...systemLevelInit,
+    ...init
+  } as Command;
+
+  const withDescription = ( description: string ) => {
+    command.description = description;
+    return builder;
+  };
+
+  const allowingActors = ( actors: string[]) => {
+    command.actors = actors;
+    return builder;
+  };
+
+  const withDataPropertyId = ( dataPath: string ) => {
+    command.dataPropertyId = dataPath;
+    return builder;
+  };
+
+  const withSchema = <Payload>( schema: BaseSchema<Payload> ) => {
+    command.schema = schema;
+    return {
+      withInvariant: withInvariant( schema ),
+      produces: produces( schema ),
+      withResultFormatFunction: withResultFormatFunction( schema ),
+      withLoadFunction: withLoadFunction( schema ),
+      withCommitFunction: withCommitFunction( schema ),
+    };
+  };
+
+  const withInvariant = <Payload>( schema: BaseSchema<Payload> ) => ( invariant: InvariantType<Model, Payload> ) => {
+    command.events = [ ...( command.events || []), ...( invariant.events || []) ];
+    command.invariants = [ ...( command.invariants || []), invariant ];
+    return {
+      withInvariant: withInvariant( schema ),
+      produces: produces( schema ),
+      withLoadFunction: withLoadFunction( schema ),
+      withCommitFunction: withCommitFunction( schema ),
+      withResultFormatFunction: withResultFormatFunction( schema ),
+    };
+  };
+
+  const withLoadFunction = <Payload>( schema: BaseSchema<Payload> ) =>( loadFunction: CommandLoadFunction<Model,Payload> ) => {
+    command.load = loadFunction;
+    return {
+      withLoadFunction: withLoadFunction( schema ),
+      withCommitFunction: withCommitFunction( schema ),
+      withResultFormatFunction: withResultFormatFunction( schema ),
+      produces: produces( schema ),
+      withInvariant: withInvariant( schema ),
+    };
+  };
+
+  const withCommitFunction = <Payload>( schema: BaseSchema<Payload> ) => ( commitFunction: CommandCommitFunction<Model, Payload> ) => {
+    command.commit = commitFunction;
+    return {
+      withLoadFunction: withLoadFunction( schema ),
+      withCommitFunction: withCommitFunction( schema ),
+      withResultFormatFunction: withResultFormatFunction( schema ),
+      produces: produces( schema ),
+      withInvariant: withInvariant( schema ),
+    };
+  };
+
+  const withResultFormatFunction = <Payload>( schema: BaseSchema<Payload> ) => ( resultFormatFunction: CommandFormatFunction<Model, Payload> ) => {
+    command.format = resultFormatFunction;
+    return {
+      withLoadFunction: withLoadFunction( schema ),
+      withCommitFunction: withCommitFunction( schema ),
+      withResultFormatFunction: withResultFormatFunction( schema ),
+      produces: produces( schema ),
+      withInvariant: withInvariant( schema ),
+    };
+  };
+
+  const produces = <Payload>( schema: BaseSchema<Payload> ) => <EVENT extends keyof EVENTS>( events: EVENT[]) => {
+    command.events = [ ...( command.events || []), ...events ];
+    return {
+      withHandler: withHandler( events )( schema ),
+      withErrorHandler: withErrorHandler( events )( schema ),
+      build: () => command as Command<EVENTS, EVENT, Model, Payload>
+    };
+  };
+
+  const withHandler = <EVENT extends keyof EVENTS>( events: EVENT[]) => <CommandPayload>( schema: BaseSchema<CommandPayload> ) => <USER>( handler: CommandHandlerFunction<Model, CommandPayload, EVENTS, EVENT, USER> ) => {
+    ( command as Command<EVENTS, EVENT, Model, CommandPayload> ).handler = handler;
+    return {
+      withErrorHandler: withErrorHandler( events )( schema ),
+      build: () => command as Command<EVENTS, EVENT, Model, CommandPayload>
+    };
+  };
+
+  const withErrorHandler = <EVENT extends keyof EVENTS>( events: EVENT[]) => <Payload>( schema: BaseSchema<Payload> ) => ( onErrorHandler: CommandErrorHandlerFunction<Payload> ) => {
+    command.onErrorHandler = onErrorHandler;
+    return {
+      build: () => command as Command<EVENTS, any, Model, Payload>
+    };
+  };
+
+  const builder = {
+    withSchema,
+    withDataPropertyId,
+    allowingActors,
+    withDescription,
+  };
+
+  return builder;
+};

package/src/ports/eventsourcing/utils/eventHandlerBuilder.ts

@@ -0,0 +1,22 @@
+import { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { AppErrorInstance, CommittedEvent, Document, EventFactory, EventHandler, EventHandlerBuilderType, GetMessageType, Policy, ReadModel } from '@bett3r-dev/pv3-types';
+
+export const eventHandlerBuilder = <EVENTS extends Record<string, EventFactory>, T extends Policy | ReadModel>( eventHandler = {} as EventHandler<EVENTS> ): EventHandlerBuilderType<EVENTS, T> => {
+  const withErrorHandlers = ( errorHandlers: {
+    [Name in keyof EVENTS]?: ( error: AppErrorInstance, event: CommittedEvent<GetMessageType<EVENTS[Name]>> ) => Promise<unknown>
+  }) => {
+    eventHandler.errorHandlers = errorHandlers;
+    return { build };
+  };
+
+  const build = () => eventHandler as T extends Policy ? Policy<T['commandHandler'], EVENTS> : T extends ReadModel ? ReadModel<T['schema'] extends ObjectSchema<infer MODEL extends Document> ? MODEL: Document, EVENTS> : any;
+  // const build = () => eventHandler;
+
+  const builder: EventHandlerBuilderType<EVENTS, T> = {
+    eventHandler,
+    withErrorHandlers,
+    build
+  };
+
+  return builder;
+};

package/src/ports/eventsourcing/utils/externalSystemBuilder.ts

@@ -0,0 +1,42 @@
+import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { Builder, Command, CommandBuilderType, EventFactory, ExternalSystemBuilderType, System } from '@bett3r-dev/pv3-types';
+import { createEvent } from '../../../utils';
+import { CommandBuilder } from './commandBuilder';
+import { getStackTrace } from '.';
+
+export const ExternalSystemBuilder = <Model, EVENTS extends Record<string, EventFactory>>( events: EVENTS, schema?: BaseSchema<Model>, system = {} as System ): ExternalSystemBuilderType<Model, EVENTS> => {
+  const isAggregate = !!schema;
+  const name = system.name || getStackTrace();
+  system = { ...system, name, events, isAggregate, isStreamable: isAggregate || system.isStreamable } as System;
+  system.isEventsourced = true;
+
+  const withCommandTemplate = ( command: Command ) => {
+    system.templateCommand = command;
+    return builder;
+  };
+
+  /**
+   * This is the last function that builds the aggregate, the last function you'll call
+   */
+  const withCommands = <
+    EVENT extends keyof EVENTS,
+    Commands extends Record<string, Command<EVENTS, EVENT, Model> | Builder<Command<EVENTS, EVENT, Model>>>
+  > ( commands: ( params: {
+    commandBuilder: CommandBuilderType<Model, EVENTS>,
+    createEvent: ReturnType<typeof createEvent< System< any, EVENTS >>>,
+  }) => Commands ): System<Commands, EVENTS> => {
+    system.commands = commands({
+      commandBuilder: CommandBuilder( system.templateCommand ),
+      createEvent: createEvent<System<any, EVENTS>>( system ),
+    });
+    return system;
+  };
+
+  const builder = {
+    system,
+    withCommandTemplate,
+    withCommands
+  };
+
+  return builder;
+};

package/src/ports/eventsourcing/utils/index.ts

@@ -0,0 +1,25 @@
+import path from 'path';
+import { curry } from 'ramda';
+
+export * from './aggregateBuilder';
+export * from './commandBuilder';
+export * from './externalSystemBuilder';
+export * from './policyBuilder';
+export * from './readmodelBuilder';
+
+export const formatStream = curry(( aggreateOrSystem:string, id: string ) => `${aggreateOrSystem}${id ? `-${ id}` : ''}` );
+export const getIdFromStream = ( stream: string ) => stream.slice( stream.indexOf( '-' ) + 1 );
+export const extractIdFromEventStream = ( event: {stream: string}) => getIdFromStream( event.stream );
+
+
+export const getStackTrace = () => {
+  const e = Error( 'ReadModelBuilder' );
+  const line = e.stack?.split( '\n' ).find(( l ) => /\.(readmodel|aggregate|system|externalSystem|policy)\.(t|j)s:/.test( l ));
+  const file = line?.match( /[\/\\].+?\.(j|t)s/g )?.[0];
+  if ( !file ){
+    // FIXME: que deberiamos hacer con esto?
+    throw Error( 'Artifact Found!!!!!!!!!!!!!!!!!' );
+  }
+  const f = path.basename( file );
+  return f.replace( /\..+$/, '' );
+};

package/src/ports/eventsourcing/utils/policyBuilder.ts

@@ -0,0 +1,31 @@
+import { CommandInstance, CommittedEvent, EventFactory, GetMessageType, Policy, PolicyBuilderType, System, createCommand } from '@bett3r-dev/pv3-types';
+import { eventHandlerBuilder } from './eventHandlerBuilder';
+import { getStackTrace } from '.';
+
+export const PolicyBuilder = <EVENTS extends Record<string, EventFactory>, CommandHandler extends System>( events: EVENTS, commandHandler?: CommandHandler, policy = {} as Policy ): PolicyBuilderType<CommandHandler, EVENTS> => {
+  const { eventHandler, ...builder } = eventHandlerBuilder<EVENTS, Policy<CommandHandler, EVENTS>>( policy );
+  policy = eventHandler as Policy<CommandHandler, EVENTS>;
+  policy.name = getStackTrace();
+  policy.events = events;
+  policy.commandHandler = commandHandler;
+
+  const withEventHandlers = ( handlers: ( params: {createCommand: ReturnType<typeof createCommand<CommandHandler>>}) => {
+    [Name in keyof EVENTS]: ( event: CommittedEvent<GetMessageType<EVENTS[Name]>> ) => Promise<CommandInstance|void>
+  }) => {
+    policy.eventHandlers = handlers({
+      createCommand: createCommand<CommandHandler>( commandHandler as CommandHandler )
+    });
+    return _builder;
+  };
+
+  const build = () => policy as Policy<CommandHandler, EVENTS>;
+
+  const _builder = {
+    ...builder,
+    withEventHandlers,
+    eventHandler: policy,
+    build
+  };
+
+  return _builder;
+};

package/src/ports/eventsourcing/utils/readmodelBuilder.ts

@@ -0,0 +1,52 @@
+import { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { Collection, CommittedEvent, DatabasePort, Document, EventFactory, EventProjectors, Query, ReadModel, ReadModelDefaultParams, ReadModelDefaultQuery, ReadmodelBuilderType } from '@bett3r-dev/pv3-types';
+import { path, pick } from 'ramda';
+import { eventHandlerBuilder } from './eventHandlerBuilder';
+import { getStackTrace } from '.';
+import { pascalCase } from 'change-case';
+
+export const mergeReducer = <Model extends Document>( collection: Collection<Model>, idPathOrFunction: string | (( event: CommittedEvent ) => string | number ), includeId = true ) => async ( event: CommittedEvent ) => {
+  const id = typeof idPathOrFunction === 'string' ? path( idPathOrFunction.split( '.' ), event ) : idPathOrFunction( event );
+  return collection.upsert( id as string, { ...( includeId ? { id } : {}), ...event.data, lastEvent: pick([ 'id', 'name', 'version' ], event ) });
+};
+
+export const ReadModelBuilder = <Model extends Document, EVENTS extends Record<string, EventFactory>>( schema: ObjectSchema<Model>, events: EVENTS, readmodel = {} as ReadModel<Model, EVENTS> ): ReadmodelBuilderType<Model, EVENTS> => {
+  // ApplicationsReadModel
+  // applications-readmodel
+  readmodel.name = readmodel.name || pascalCase( `${getStackTrace()}ReadModel` );
+  const { eventHandler, ...builder } = eventHandlerBuilder<EVENTS, ReadModel>( readmodel );
+  readmodel = eventHandler as ReadModel<Model, EVENTS>;
+  readmodel.isReadModel = true;
+  readmodel.schema = schema;
+  readmodel.events = events;
+
+  const withDatabase = ( database: DatabasePort, collection?:string ) => {
+    readmodel.database = database;
+    readmodel.collection = collection || readmodel.name;
+    return _builder;
+  };
+
+  const withProjector = ( eventProjectors?: ( params: {database: DatabasePort, collection:string}) => EventProjectors<EVENTS> ) => {
+    readmodel.eventProjectors = eventProjectors ? eventProjectors({ database: readmodel.database!, collection: readmodel.collection! }) : {} as EventProjectors<EVENTS>;
+    return _builder;
+  };
+
+  const withQuery = <PARAMS extends Record<string, any>=ReadModelDefaultParams, QUERY extends Record<string, any>=ReadModelDefaultQuery>( query?: Query<Model, PARAMS, QUERY> /* | QueryFactory */ ) => {
+    readmodel.queries ||= [];
+    readmodel.queries.push( query || {});
+    return _builder;
+  };
+
+  const build = () => readmodel as ReadModel<Model, EVENTS>;
+
+  const _builder = {
+    ...builder,
+    withDatabase,
+    withProjector,
+    withQuery,
+    eventHandler: readmodel,
+    build
+  };
+
+  return _builder;
+};

package/src/ports/eventstore/index.ts

@@ -0,0 +1,11 @@
+import { createPort } from '../base';
+import { EventStoreAdapter, EventStorePort } from '@bett3r-dev/pv3-types';
+
+export const EventStore = ( adapter: EventStoreAdapter ): EventStorePort => {
+  const eventstorePort = {
+    ...createPort( adapter ),
+    _adapter: adapter
+  };
+
+  return eventstorePort;
+};

package/src/ports/infrastructure/__tests__/fixture/index.ts

@@ -0,0 +1,2 @@
+export * from './infrastructureServices';
+export * from './structureState';

package/src/ports/infrastructure/__tests__/fixture/infrastructureServices.ts

@@ -0,0 +1,72 @@
+export const infrastructureServices = [
+  {
+    service: 'service0',
+    port: 2013,
+    instances: [
+      {
+        timeRunning: 1.848,
+        host: '10.0.0.23',
+      },
+      {
+        timeRunning: 1.811,
+        host: '10.0.0.24',
+      },
+    ],
+    consumes: {
+      OperationCountByColorReadModel: [
+        'DividedBy_17',
+        'MultipliedBy_18',
+        'MultipliedBy_2',
+        'MultipliedBy_5',
+        'Subtracted_50',
+        'Added_20',
+        'Added_7',
+        'Added_3',
+        'DividedBy_3',
+      ],
+      TotalByColorReadModel: [
+        'MultipliedBy_18',
+        'DividedBy_17',
+        'MultipliedBy_5',
+        'MultipliedBy_2',
+        'Subtracted_50',
+        'Added_20',
+        'Added_7',
+        'Added_3',
+        'DividedBy_3',
+      ],
+    },
+    produces: {
+      ArithmeticOperationsAggregate: [
+        'DividedBy_17',
+        'Added_20',
+        'MultipliedBy_5',
+        'Added_3',
+        'Added_7',
+        'MultipliedBy_2',
+        'Subtracted_50',
+        'DividedBy_3',
+        'MultipliedBy_18',
+      ],
+    },
+    isBroker: true,
+    isService: true,
+    endpoints: [
+      'GET:/arithmetic-operations-aggregate/{id}',
+      'GET:/arithmetic-operations-aggregate/{id}/stream',
+      'POST:/arithmetic-operations-aggregate/{id}/divide-by-17',
+      'POST:/arithmetic-operations-aggregate/{id}/add-20',
+      'POST:/arithmetic-operations-aggregate/{id}/multiply-by-5',
+      'POST:/arithmetic-operations-aggregate/{id}/add-3',
+      'POST:/arithmetic-operations-aggregate/{id}/add-7',
+      'POST:/arithmetic-operations-aggregate/{id}/multiply-by-2',
+      'POST:/arithmetic-operations-aggregate/{id}/subtract-50',
+      'POST:/arithmetic-operations-aggregate/{id}/divide-by-3',
+      'POST:/arithmetic-operations-aggregate/{id}/multiply-by-18',
+      'POST:/operation-count-by-color-read-model',
+      'GET:/operation-count-by-color-read-model/{id}?',
+      'POST:/total-by-color-read-model',
+      'GET:/total-by-color-read-model/{id}?',
+    ],
+  },
+];