@bett3r-dev/pv3 1.0.0 → 2.5.1

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

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

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

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

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

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