@bett3r-dev/pv3 1.0.0 → 2.5.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,72 +0,0 @@
-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}?',
-    ],
-  },
-];