@bett3r-dev/pv3 1.0.0

package/src/ports/eventsourcing/commandTemplates/snapshot.ts

@@ -0,0 +1,43 @@
+import { Aggregate, Command, CommandExecutionResponse, CommandHandlerState, Ports } from '@bett3r-dev/pv3-types';
+import { defaultEventsourcingLoad, reduceEventsIntoState } from '../commandHandlers';
+
+export type SnapshotType<T = any> = {
+  id:string,
+  eventId: number,
+  version: number,
+  data: T,
+}
+
+export const snapshot = ( ports: Pick<Ports, 'database' | 'eventstore'>, collection: string, frequency: number = 500 ): Command => {
+  const coll = ports.database.getCollection<SnapshotType>( collection );
+  coll.ensureIndex(['stream']);
+  coll.ensureIndex(['eventId']);
+  return {
+    load: async <Model, Payload>( commandHandlerState: CommandHandlerState<Model,Payload> ): Promise<CommandHandlerState<Model, Payload>> => {
+      return coll.readById( commandHandlerState.stream )
+        .then(( snapshot ) => {
+          return defaultEventsourcingLoad( ports.eventstore )( commandHandlerState as any, {
+            stream: commandHandlerState.stream,
+            from: snapshot?.eventId || 0
+          }, snapshot?.data )
+            .then(( state ) => ({
+              ...state,
+              snapshot,
+            }));
+        }) as Promise<CommandHandlerState<Model,Payload>>;
+    },
+    format: async <Model, Payload>( commandHandlerState: CommandHandlerState<Model,Payload> ): Promise<CommandExecutionResponse<Model>> => {
+      const { state, commandHandler, committedEvents } = commandHandlerState;
+      const formattedResult = reduceEventsIntoState( state, commandHandler as Aggregate, committedEvents! );
+      if ( commandHandlerState.committedEvents ){
+        const lastEvent = commandHandlerState.committedEvents?.slice( -1 )[0];
+        const lastVersion = ( commandHandlerState as any ).snapshot?.version || 0;
+        if ( lastEvent.version - lastVersion >= frequency ){
+          // Not waiting for the operation since this is not required to be consistent
+          coll.upsert( commandHandlerState.stream, { id: lastEvent.stream, version: lastEvent.version, eventId: lastEvent.id, data: formattedResult.state });
+        }
+      }
+      return formattedResult as CommandExecutionResponse<Model>;
+    }
+  } as Command;
+};

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

@@ -0,0 +1,429 @@
+import { ensureArray } from '@bett3r-dev/bett3r-utils';
+import S, { BaseSchema, ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import {
+  AppErrorInstance,
+  Collection,
+  CollectionFilter,
+  CollectionQueryParams,
+  CollectionSort,
+  CommandExecutionResponse,
+  CommittedEvent,
+  CommittedEventSchema,
+  Document,
+  EndpointActionParams,
+  EndpointSchemas,
+  EndpointsPort,
+  EventHandler,
+  ExecuteCommandFunction,
+  LoggerType,
+  Policy,
+  PolicyResponse,
+  Query,
+  QueryHandler,
+  ReadModel,
+  ReadModelDefaultParams,
+  ReadModelDefaultQuery,
+  RequestObject,
+  ResponseObject,
+  defaultParamsSchemas,
+  defaultQuerySchemas,
+} from '@bett3r-dev/pv3-types';
+import { QueueObject, queue } from 'async';
+import { paramCase } from 'change-case';
+import { dieOnError, validateSchema } from '../../../libraries/validation';
+
+//TODO: Consider Objects
+export const coerceFilterType = (
+  value: string[],
+  targetType: string,
+  op: string
+) => {
+  const inOrNin = op === 'in' || op === 'nin';
+  if ( !value.length || [ 'exists', 'notExists' ].includes( op )) return undefined;
+  if ( targetType === 'string' ) return !inOrNin ? value[0] : value;
+  else if ( targetType === 'number' )
+    return !inOrNin ? Number( value[0]) : value.map(( v ) => Number( v ));
+  else if ( targetType === 'boolean' )
+    return !inOrNin ? value[0] === 'true' : value.map(( v ) => v === 'true' );
+};
+
+export const formatFilter = <Model extends Document>(
+  filters: string[],
+  schema: ObjectSchema<Model>
+): CollectionFilter<Model>[] => {
+  return (
+    filters &&
+    ensureArray( filters ).map(( f ) => {
+      const operands = f.split( ',' );
+      const [ field, op, ...value ] = operands;
+      return {
+        field,
+        op,
+        value: coerceFilterType(
+          value,
+          ((( schema.plain.properties as {})[field] || {}).type as string ) ||
+            'string',
+          op
+        ),
+      } as CollectionFilter<Model>;
+    })
+  );
+};
+
+export const formatSort = <Model extends Document>( sorts: string[]) => {
+  return (
+    sorts &&
+    ensureArray( sorts ).map(( s ) => {
+      const operands = s.split( ',' );
+      const [ field, direction ] = operands;
+      return {
+        field,
+        direction: direction || 'asc',
+      } as CollectionSort<Model>;
+    })
+  );
+};
+
+export const formatSelect = <Model extends Document>(
+  select: string[],
+  schema: ObjectSchema<Model>
+) => {
+  select = ensureArray( select );
+  const omit = select.filter(( s ) => s[0] === '!' ).map(( s ) => s.slice( 1 ));
+  if ( omit?.length ) {
+    return Object.keys( schema.plain.properties as {}).filter(
+      ( key ) => !omit.includes( key )
+    );
+  }
+  return select;
+};
+
+export const defaultQueryParamsTranslator = <
+  Model extends Document = any,
+  Query extends ReadModelDefaultQuery = ReadModelDefaultQuery,
+  Params extends ReadModelDefaultParams = ReadModelDefaultParams
+>(
+  schema: ObjectSchema<Model>,
+  {
+    params,
+    query,
+  }: Pick<EndpointActionParams<Model, Query, Params>, 'params' | 'query'>
+): CollectionQueryParams<Model> => {
+  return {
+    id: params?.id,
+    limit: query?.limit ? Number( query.limit ) : undefined,
+    after: query?.after,
+    select: query?.select
+      ? formatSelect( query?.select as string[], schema )
+      : undefined,
+    filter: query?.filter
+      ? formatFilter( query?.filter as string[], schema )
+      : undefined,
+    sort: query?.sort ? formatSort( query?.sort as string[]) : undefined,
+  };
+};
+
+export const createEventHandlers = ( logger: LoggerType, endpoints: EndpointsPort ) => {
+  const activeSubscriptions: Record<string, string> = {};
+
+  const eventHandlerMap: {
+    [name: string]: {
+      eventHandler: Partial<Policy>;
+      events: string[];
+      queue: QueueObject<CommittedEvent>;
+    };
+  } = {};
+
+  const processEvent =
+    ( eventHandlerName: string ) =>
+      ( event: CommittedEvent ): Promise<CommandExecutionResponse> => {
+        return new Promise(( resolve, reject ) => {
+          eventHandlerMap[eventHandlerName].queue.push(
+            event,
+            ( err: AppErrorInstance, result: CommandExecutionResponse ) => {
+              if ( err ) {
+                logger.error( err );
+                return reject( err );
+              }
+              return resolve( result );
+            }
+          );
+        });
+      };
+
+  const pauseQueue = ( eventHandlerName: string, value: boolean ) =>
+    value
+      ? eventHandlerMap[eventHandlerName].queue.pause()
+      : eventHandlerMap[eventHandlerName].queue.resume();
+
+  const getEventHandlerLabel = ( eventHandler: EventHandler ) =>
+    `${( eventHandler as Policy ).eventHandlers ? 'Policy' : 'Projector'}`;
+
+  const isReadModel = ( eventHandler: EventHandler ) =>
+    !!( eventHandler as ReadModel ).isReadModel;
+
+  const handleEvent =
+    ( eventHandler: EventHandler, executeCommand: ExecuteCommandFunction ) =>
+      ( event: CommittedEvent ) => {
+        const _isReadModel = isReadModel( eventHandler );
+        return Promise.resolve( event )
+          .then( validateSchema( getEventSchema( eventHandler )( event.name )))
+          .then<PolicyResponse | void>(
+          _isReadModel
+            ? (( eventHandler as ReadModel ).eventProjectors || {})[
+              event.name as string
+            ]
+            : ( eventHandler as Policy ).eventHandlers[event.name as string]
+        )
+          .then(( response ) => {
+            if ( !response || _isReadModel ) return Promise.resolve();
+            const policy = eventHandler as Policy;
+            if ( policy.commandHandler && response.name ) {
+              return executeCommand(
+                policy.commandHandler,
+                response.name
+              )({
+                context: {
+                  user: event.metadata.user,
+                },
+                body: response.data,
+                params: { id: response.id },
+                query: {
+                  correlationId: event.metadata.correlationId,
+                  causationId: event.id.toString(),
+                },
+              } as EndpointActionParams );
+            }
+          })
+          .catch(( error ) => {
+            logger.debug( 'Handling error for event', event.name );
+            if (
+              eventHandler.errorHandlers &&
+            eventHandler.errorHandlers[event.name] &&
+            typeof eventHandler.errorHandlers[event.name] === 'function'
+            )
+              return eventHandler.errorHandlers[event.name]!( error, event );
+            return Promise.reject( error );
+          });
+      };
+
+  const addEventHandlerToMap = (
+    eventHandler: EventHandler,
+    q: QueueObject<CommittedEvent<any>>
+  ) => {
+    eventHandlerMap[eventHandler.name] = {
+      eventHandler: {
+        ...eventHandler,
+      },
+      events: Object.keys( eventHandler.events ),
+      queue: q,
+    };
+  };
+
+  const EventHandlerQueueFunction =
+    (
+      executeCommand: ExecuteCommandFunction,
+      eventHandler: EventHandler,
+      label: string
+    ) =>
+      ( event: CommittedEvent, callback ) => {
+        return Promise.resolve( event )
+          .then(( event ) => {
+            if ( !eventHandler.events[event.name || ''])
+              return Promise.reject(
+                Error(
+                  `Event ${event.name} Not recognized for ${label} ${eventHandler.name}`
+                )
+              );
+            logger.log(
+              'Handling Event',
+              event.name,
+              'in',
+              label,
+              eventHandler.name
+            );
+            logger.debug( 'with payload:', event );
+            return event;
+          })
+          .then( handleEvent( eventHandler, executeCommand ))
+          .then(() => callback(), callback );
+      };
+
+  const getEventSchema =
+    ( eventHandler: EventHandler ) => ( eventName: string ) => {
+      return CommittedEventSchema(
+        eventHandler.events[eventName]().schema?.copyWith({
+          plain: { $id: eventName },
+        }) as BaseSchema,
+        eventName
+      ).required( 'name', 'data' );
+    };
+
+  const registerEventHandlerEndpoint = (
+    eventHandler: EventHandler,
+    label: string,
+    tags?: string[]
+  ) => {
+    const route = `/${paramCase( eventHandler.name )}`;
+
+    endpoints.registerEndpoint({
+      module: eventHandler.name,
+      name: `Subscription endpoint for ${eventHandler.name}`,
+      description: `Process events sent to the ${label}`,
+      tags,
+      schemas: {
+        body: S.anyOf(
+          ...Object.keys( eventHandler.events ).map( getEventSchema( eventHandler ))
+        ),
+      },
+      shouldValidate: false,
+      route,
+      method: 'POST',
+      action: ({ body }) => processEvent( eventHandler.name )( body ),
+    });
+
+    return route;
+  };
+
+  const defaultQueryHandler: QueryHandler = <Model extends Document>(
+    repository: Collection<Model>,
+    { id, limit, after, filter, sort, select }: CollectionQueryParams<Model>
+  ) => {
+    if ( id ) return repository.readById( id as string );
+
+    return repository.query({
+      limit,
+      after,
+      filter,
+      sort,
+      select,
+    });
+  };
+
+  const registerReadModelQueryEndpoint = (
+    query: Query,
+    readModel: ReadModel
+  ) => {
+    const route = query.route || `/${paramCase( readModel.name )}`;
+    const schema = readModel.schema.id( readModel.name );
+    const schemas: EndpointSchemas<any, any, any> = {
+      ...defaultParamsSchemas,
+      ...defaultQuerySchemas,
+      ...( query.schemas ? query.schemas : {}),
+      responses: {
+        200: [
+          {
+            name: 'OK',
+            schema: S.oneOf( schema, S.array().items( schema )),
+          },
+        ],
+      },
+    };
+    if ( readModel.database && query.subscriptions ) {
+      const subscriptions = query.subscriptions?.map(( s ) => {
+        // FIXME: Esto esta pasando por cada request de subscription
+        s.readModelSubscriptionCloseEmitter.on( 'close', ( id ) => {
+          logger.debug( 'Subscription Closed for id', id, 'in subscription' );
+          delete activeSubscriptions[id];
+          if ( Object.keys( activeSubscriptions ).length === 0 )
+            endpoints.callEventConnectionsInactive();
+        });
+        return s.notifySubscriptions( logger, readModel.collection! );
+      });
+      readModel.database.onStarted(() => {
+        readModel
+          .database!.getCollection( readModel.collection! )
+          .watch([ 'delete', 'insert', 'update' ], ( data ) => {
+            subscriptions?.forEach(( s ) => {
+              s( data );
+            });
+          });
+      });
+    }
+
+    endpoints.registerEndpoint({
+      method: 'GET',
+      module: readModel.name,
+      name: `Readmodel Query endpoint for ${readModel.name}`,
+      description: query.description,
+      schemas,
+      tags: ['readmodel'],
+      route: `${route}/:id?`,
+      action: async ( params ) => {
+        const projectionParams = (
+          query.translator || defaultQueryParamsTranslator
+        )( readModel.schema, params );
+        const transformedProjectionParams = !query.transformers
+          ? projectionParams
+          : await query.transformers.reduce(( promise, transformer ) => {
+            return promise.then(( projectionParams ) =>
+              transformer( projectionParams, params )
+            );
+          }, Promise.resolve( projectionParams ));
+        const data = await ( query.queryHandler || defaultQueryHandler )(
+          readModel.database?.getCollection( readModel.collection || readModel.name ) as any,
+          { ...transformedProjectionParams, params }
+        );
+        readModel.database &&
+          query.subscriptions?.forEach(( s ) => {
+            const id = s.startSubscription(
+              transformedProjectionParams,
+              params.context?.req as RequestObject,
+              params.context?.res as ResponseObject
+            );
+            if ( id ) {
+              activeSubscriptions[id] = s.type;
+              endpoints.callEventConnectionsActive();
+              ensureArray( data ).forEach(( data: any ) => {
+                s.notifySubscriptions( logger, readModel.collection! )(
+                  { changeType: 'update', data },
+                  id
+                );
+              });
+            }
+          });
+        return data;
+      },
+    });
+
+    return route;
+  };
+
+  const registerEventHandler = (
+    eventHandler: EventHandler,
+    executeCommand: ExecuteCommandFunction
+  ): string => {
+    const isReadmodel = isReadModel( eventHandler );
+    if ( eventHandlerMap[eventHandler.name]) {
+      dieOnError( logger )(
+        `A policy or projector with the name ${eventHandler.name} already exists on this instance.`
+      );
+    }
+    const label = getEventHandlerLabel( eventHandler );
+    const q = queue(
+      EventHandlerQueueFunction( executeCommand, eventHandler, label ),
+      eventHandler.concurrency || 1
+    );
+    addEventHandlerToMap( eventHandler, q );
+    const eventHandlerRoute = registerEventHandlerEndpoint(
+      eventHandler,
+      label,
+      isReadmodel ? ['readmodel'] : ['policy']
+    );
+
+    if ( isReadmodel ) {
+      const qs = ( eventHandler as ReadModel ).queries || [{}];
+      qs.forEach(( q ) => {
+        registerReadModelQueryEndpoint( q, eventHandler as ReadModel );
+      });
+    }
+
+    return eventHandlerRoute;
+  };
+
+  return {
+    handleEvent,
+    pauseQueue,
+    registerEventHandler,
+  };
+};

package/src/ports/eventsourcing/index.ts

@@ -0,0 +1,98 @@
+import { map } from '@bett3r-dev/bett3r-utils';
+import { Aggregate, Builder, EndpointsPort, EventHandler, EventSourcingPort, EventStorePort, LoggerPort, ReadModel, System } from '@bett3r-dev/pv3-types';
+import c from 'ansi-colors';
+import { createPort } from '../base';
+import { createCommandHandlers } from './commandHandlers';
+import { createEventHandlers } from './eventHandlers';
+export * from './commandHandlers';
+export * from './commandTemplates';
+export * from './eventHandlers';
+export * from './invariants';
+export * from './subscriptions';
+export * from './utils';
+
+export const EventSourcing = ( loggerPort: LoggerPort, eventstore: EventStorePort, endpoints: EndpointsPort ): EventSourcingPort => {
+  const logger = loggerPort.createLoggerInstance( 'eventsourcing' );
+
+  const commandHandlersManager = createCommandHandlers( logger, endpoints, eventstore );
+  const eventHandlersManager = createEventHandlers( logger, endpoints );
+  const registeredEndpoints: {
+    aggregates: Record<string,any>,
+    systems: Record<string,any>,
+    policies: Record<string,any>,
+    projectors: Record<string,any>
+  } = {
+    aggregates: {},
+    systems: {},
+    policies: {},
+    projectors: {},
+  };
+
+  const logRoute = ( name: string, { route, events }, inverse = false ) => {
+    logger.log( name, c.underline( route ), inverse ? '<=' : '=>', events.join( ', ' ));
+  };
+
+  const logEventsourcingRoutes = () => {
+    Object.keys( registeredEndpoints.aggregates ).forEach(( aggregate ) => {
+      logger.log( c.bgYellowBright( c.bold.blackBright( aggregate )));
+      Object.keys( registeredEndpoints.aggregates[aggregate].commands ).forEach(( command ) => {
+        logRoute( `\t${ c.bold( command )}`, registeredEndpoints.aggregates[aggregate].commands[command]);
+      });
+    });
+    Object.keys( registeredEndpoints.systems ).forEach(( system ) => {
+      logger.log( c.bgMagentaBright( c.bold.whiteBright( system )));
+      Object.keys( registeredEndpoints.systems[system].commands ).forEach(( command ) => {
+        logRoute( `\t${ c.bold( command )}`, registeredEndpoints.systems[system].commands[command]);
+      });
+    });
+    Object.keys( registeredEndpoints.policies ).forEach(( policy ) => {
+      logger.log( c.bgMagenta( c.bold.whiteBright( policy )));
+      logRoute( `\t${ c.bold( policy )}`, registeredEndpoints.policies[policy], true );
+    });
+    Object.keys( registeredEndpoints.projectors ).forEach(( projector ) => {
+      logger.log( c.bgGreenBright( c.bold.whiteBright( projector )));
+      logRoute( `\t${ c.bold( projector )}`, registeredEndpoints.projectors[projector], true );
+    });
+  };
+
+  const routeCommandHandler = ( commandHandler: System ): void => {
+    const commands = commandHandler.commands;
+    const getEndpoints = commandHandlersManager.registerCommandHandlerGetEndpoints( commandHandler );
+    const commandEndpoints = commandHandlersManager.registerCommandHandlerPostEndpoints( commandHandler );
+    const c = map(( route, command ) => ({
+      route,
+      events: ( commands[command].build ? commands[command].build() : commands[command]).events
+    }), commandEndpoints );
+    if (( commandHandler as Aggregate ).isAggregate )
+      registeredEndpoints.aggregates[commandHandler.name] = { getEndpoints, commands:c };
+    else
+      registeredEndpoints.systems[commandHandler.name] = { getEndpoints, commands:c };
+  };
+
+  const routeEventHandler = (
+    eventHandler: EventHandler | Builder<EventHandler>
+  ) :void => {
+    const eh = ( eventHandler as Builder ).build ? ( eventHandler as Builder ).build() : eventHandler;
+    const route = eventHandlersManager.registerEventHandler( eh, commandHandlersManager.executeCommand );
+    if (( eh as ReadModel ).isReadModel )
+      registeredEndpoints.projectors[eh.name] = { route, events: Object.keys( eh.events ) };
+    else
+      registeredEndpoints.policies[eh.name] = { route, events: Object.keys( eh.events ) };
+  };
+
+  const eventsourcingPort = createPort({
+    _eventstore: eventstore,
+    routeEventHandler,
+    routeCommandHandler,
+
+    loadStream: commandHandlersManager.loadStream,
+    loadAggregateState: commandHandlersManager.loadAggregateState,
+
+    handleEvent: eventHandlersManager.handleEvent,
+    executeCommand: commandHandlersManager.executeCommand,
+
+    logEventsourcingRoutes
+  });
+
+  return eventsourcingPort;
+};

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

@@ -0,0 +1,25 @@
+import { noop } from '@bett3r-dev/bett3r-utils';
+import { InvariantType } from '@bett3r-dev/pv3-types';
+import { createInvariant } from '.';
+
+export const and = ( ...invariants: InvariantType[]): InvariantType => {
+  return createInvariant(
+    async ( handlerState ) => {
+      return Promise.all(
+        invariants.map( i => i.check( handlerState ))
+      )
+        .then( noop );
+    }
+  );
+};
+
+export const or = ( ...invariants: InvariantType[]): InvariantType => {
+  return createInvariant(
+    async ( handlerState ) => {
+      return Promise.any(
+        invariants.map( i => i.check( handlerState ))
+      )
+        .then( noop );
+    }
+  );
+};

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

@@ -0,0 +1,42 @@
+import S, { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { CommandHandlerState, ErrorTypes, InvariantType } from '@bett3r-dev/pv3-types';
+import { always } from 'ramda';
+import { AppError, createError } from '../../../utils';
+
+export function createInvariant<Model, Payload, Error = any>(
+  check: ( handlerState: CommandHandlerState<any, Payload, Model> ) => Promise<void>,
+  error: {
+    name?: string,
+    description?: string,
+    type?: ErrorTypes,
+    details?: Error,
+    schema?: BaseSchema<Error>
+  } = {
+    name: 'Invariant Error',
+    description: 'Invariant Validation Failed',
+    details: null as Error,
+    type: 'BadRequestError',
+    schema: S.shape<any>({})
+  }
+): InvariantType<Model, Payload> {
+  const GenericError = AppError({
+    schema: error.schema,
+    error: error.name,
+    type: error.type || 'BadRequestError'
+  });
+  return {
+    rejects: [GenericError],
+    check: async ( handlerState ) => {
+      return check( handlerState )
+        .then( always( handlerState ))
+        .catch(( err ) => {
+          return Promise.reject(
+            createError( GenericError, {
+              ...error,
+              ...err
+            })
+          );
+        });
+    }
+  };
+}