@bett3r-dev/pv3 1.0.0

package/src/adapters/eventstore/database.ts

@@ -0,0 +1,178 @@
+import { ensureArray, map, reduce } from '@bett3r-dev/bett3r-utils';
+import { CollectionFilter, CollectionSort, CommittedEvent, DatabasePort, DatabaseTransaction, EventStoreAdapter, EventStoreConfig, EventToCommit, LoggerPort, ReadMultipleStreamOptions, ReadStreamOptions } from '@bett3r-dev/pv3-types';
+import { always, clone, flatten, path, pathOr } from 'ramda';
+import { ConcurrencyError, createError, dieOnError } from '../..';
+import { createPort } from '../../ports/base';
+
+export const DatabaseEventstore = ( config: EventStoreConfig, loggerPort: LoggerPort, database: DatabasePort ): EventStoreAdapter => {
+  const logger = loggerPort.createLoggerInstance( 'eventstore' );
+  const collection = config.collection || 'eventstore';
+
+  if ( config.enabled !== false )
+    database.onStarted(() => {
+      const eventstoreCollection = database.getCollection<CommittedEvent>( collection );
+      Promise.resolve()
+        .then(() => eventstoreCollection.ensureIndex([ 'stream', 'version' ], { isUnique: true }))
+        .then(() => eventstoreCollection.ensureIndex(['id'], { isUnique: true }))
+        .then(() => eventstoreCollection.ensureIndex(['name']))
+        .then(() => eventstoreCollection.ensureIndex(['metadata.correlationId']))
+        .then(() => {
+          eventstorePort.isStarted = true;
+          eventstorePort.emitter.emit( 'started' );
+        })
+        .catch( dieOnError( logger ));
+    });
+
+  const getNextEventPosition = () =>
+    database.getCollection( '__counters' ).atomicIncrement( 'eventPosition', { field: 'eventStore', op:'eq', value: collection });
+
+  const createEventToCommit = ( stream: string, actualVersion: number )=> ({ name, data, metadata, stream: eventCommit }: EventToCommit, index: number ): Promise<CommittedEvent> => {
+    return getNextEventPosition()
+      .then(( commit = 1 ) => ({
+        id: commit,
+        name,
+        version: actualVersion + index + 1,
+        timestamp: new Date().toISOString(),
+        data,
+        stream: eventCommit || stream,
+        metadata: {
+          ...metadata,
+        }
+      }));
+  };
+
+  const validateExpectedVersion = ( expectedVersion?: number ) => ( actualVersion: number ) => {
+    if ( expectedVersion === undefined || expectedVersion === actualVersion )
+      return Promise.resolve( actualVersion );
+    else
+      return Promise.reject( createError( ConcurrencyError(), {
+        details:{
+          expectedVersion: expectedVersion.toString(),
+          actualVersion: actualVersion.toString()
+        }
+      }));
+  };
+
+  const ensureNumber = ( value: string ) => value ? Number( value ) : 0;
+
+  const extractAndValidateExpectedVersion = ( expectedVersion: number | undefined ) => ( event: CommittedEvent ) => {
+    return Promise.resolve( event )
+      .then( pathOr( '0', ['version']))
+      .then( ensureNumber )
+      .then( validateExpectedVersion( expectedVersion ));
+  };
+
+  const appendToStream = <Type>(
+    stream: string,
+    events: EventToCommit|EventToCommit[],
+    expectedVersion?: number,
+    transaction?: DatabaseTransaction
+  ): Promise<CommittedEvent<Type>[]> =>{
+    const eventstoreCollection = transaction ? transaction.getCollection<CommittedEvent>( collection ) : database.getCollection<CommittedEvent>( collection );
+    return eventstoreCollection
+      .query({ filter:[{ field:'stream', op:'eq', value: stream }], sort:[{ field: 'version', direction:'desc' }], limit:1, select:['version']})
+      .then( path(['0']))
+      .then( extractAndValidateExpectedVersion( expectedVersion ))
+      .then(( actualVersion )=> map( createEventToCommit( stream, actualVersion ), ensureArray( events )) as unknown as Promise<CommittedEvent>[])
+      .then<CommittedEvent[]>(( promises ) => Promise.all( promises ))
+      .then(( events: CommittedEvent[]) => eventstoreCollection.createMany( clone( events )).then( always( events )));
+  };
+
+  const appendToMultipleStreams = <Type>(
+    streams: Record<string, {
+      events: EventToCommit|EventToCommit[]
+      expectedVersion?: number,
+    }>,
+    // transaction?: DatabaseTransaction
+  ): Promise<CommittedEvent<Type>[]> =>{
+    return database.initTransaction(( getCollection ) => {
+      const eventstoreCollection = getCollection<CommittedEvent>( collection );
+      return Promise.all( Object.keys( streams ).map(( stream ) => {
+        return eventstoreCollection
+          .query({ filter:[{ field:'stream', op:'eq', value: stream }], sort:[{ field: 'version', direction:'desc' }], limit:1, select:[ 'stream','version' ]});
+      }))
+        .then( flatten )
+        .then( reduce(( promise, e )=>{
+          return Promise.resolve( e )
+            .then( extractAndValidateExpectedVersion( streams[e.stream].expectedVersion ))
+            .then( actualVersion => Promise.all([ promise, actualVersion ]))
+            .then(([ state, actualVersion ]) => {
+              state[e.stream] = actualVersion;
+              return state;
+            });
+        }, Promise.resolve({})))
+        .then(( actualVersions )=> {
+          return Object.keys( streams ).map(( stream ) => {
+            return map( createEventToCommit( stream, actualVersions[stream]), ensureArray( streams[stream].events ));
+          }).flat();
+        })
+        .then<CommittedEvent[]>(( promises ) => Promise.all( promises ))
+        .then(( events: CommittedEvent[]) => eventstoreCollection.createMany( clone( events )).then( always( events )));
+    });
+  };
+  const readStream = async <ReducedModel=any>( readOptions: ReadStreamOptions, callback: ( event: CommittedEvent, stop: () => void ) => Partial<ReducedModel> | Promise<Partial<ReducedModel>> ): Promise<ReducedModel> => {
+    const eventstoreCollection = database.getCollection<CommittedEvent>( collection );
+    const filter: CollectionFilter<CommittedEvent>[] = [];
+    if ( readOptions.stream )
+      filter.push({ field:'stream', op:'eq', value: readOptions.stream } as CollectionFilter<CommittedEvent> );
+    if ( readOptions.fromVersion )
+      filter.push({ field:'version', op:'gt', value: readOptions.fromVersion } as CollectionFilter<CommittedEvent> );
+    const sort = ( readOptions.direction === 'backwards' ? [{ field: 'id', direction:'desc' }] : [{ field: 'id', direction:'asc' }]) as CollectionSort<CommittedEvent>[];
+    let result: Partial<ReducedModel>;
+    await eventstoreCollection.forEach({
+      limit: readOptions.limit,
+      after: readOptions.from,
+      filter,
+      sort,
+    }, async ( record: CommittedEvent, stop ) => {
+      result = await callback( record, stop );
+    });
+    return result! as ReducedModel;
+  };
+
+  const readMultipleStream = async <Model=unknown>( readOptions: ReadMultipleStreamOptions, callback: ( event: CommittedEvent, stop: () => void ) => Record<string,Partial<Model>> | Promise<Record<string,Partial<Model>>> ): Promise<Record<string, Model>> => {
+    const eventstoreCollection = database.getCollection<CommittedEvent>( collection );
+    const filter = readOptions.streams ? [{ field:'stream', op:'in', value: readOptions.streams } as CollectionFilter<CommittedEvent>] : undefined;
+    const sort = ( readOptions.direction === 'backwards' ? [{ field: 'id', direction:'desc' }] : [{ field: 'id', direction:'asc' }]) as CollectionSort<CommittedEvent>[];
+    let result: Record<string,Partial<Model>>;
+    await eventstoreCollection.forEach({
+      limit: readOptions.limit,
+      after: readOptions.from,
+      filter,
+      sort,
+    }, async ( record: CommittedEvent, stop ) => {
+      result = await callback( record, stop );
+    });
+    return result! as Record<string,Model>;
+  };
+
+  const flush = async () => {
+    if ( process.env.NODE_ENV !== 'production' ){
+      const eventstoreCollection = database.getCollection<CommittedEvent>( collection );
+      await eventstoreCollection.destroyMany([]);
+      const countersCollection = database.getCollection<CommittedEvent>( '__counters' );
+      await countersCollection.destroyMany([]);
+    }
+  };
+
+  const subscribe = ( onEvent: ( event: CommittedEvent ) => void, onError?: ( e: Error ) => void ) => {
+    return database.getCollection<CommittedEvent>( collection ).watch(['insert'], ( data ) => {
+      onEvent( data.data! );
+    }, onError );
+  };
+
+  const eventstorePort = createPort({
+    name: 'database',
+    appendToStream,
+    appendToMultipleStreams,
+    readStream,
+    readMultipleStream,
+    subscribe,
+    flush,
+    start: async () => {},
+    stop: async () => {},
+    _adapter: () => database
+  });
+
+  return eventstorePort;
+};

package/src/adapters/eventstore/index.ts

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

package/src/adapters/infrastructure/index.ts

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

package/src/adapters/infrastructure/local/index.ts

@@ -0,0 +1,40 @@
+import { Ports } from '@bett3r-dev/pv3-types';
+import { EnvironmentServiceType, InfrastructureAdapterType } from '@bett3r-dev/pv3-types';
+import { getThisServiceIps } from '../../../ports/infrastructure/utils';
+import { HttpConfigSchema } from '@bett3r-dev/pv3-types';
+
+export const LocalInfrastructure = ( ports: Pick<Ports, 'configuration'|'endpoints'> ): InfrastructureAdapterType => {
+  const start = async () => {};
+  let { config } = ports.configuration.getModuleConfig( 'http', HttpConfigSchema );
+
+  const getServices = async (): Promise<EnvironmentServiceType[]> => {
+    const ips = getThisServiceIps();
+    return [
+      {
+        openApi: ports.endpoints.getOpenApiSpec(),
+        // FIXME: Hard coded
+        openApiEndpoint: '/documentation/json',
+        service: ips[0],
+        instances: [{ host: ips[0], timeRunning: 0 }],
+        port: Number( config.port ),
+      }
+    ];
+  };
+
+  const listenForInfrastructureChanges = () => {};
+
+  const reloadLoadBalancer = async () => {};
+
+  const stop = async () => {};
+
+  return {
+    _adapter: () => {},
+    name: 'local-environment',
+    scaleService: async () => {},
+    reloadLoadBalancer,
+    start,
+    stop,
+    getServices,
+    listenForInfrastructureChanges,
+  };
+};

package/src/adapters/logger/console.ts

@@ -0,0 +1,42 @@
+import { compose, prepend } from 'ramda';
+import { LoggerAdapter } from '@bett3r-dev/pv3-types';
+
+export const ConsoleLogger = (): LoggerAdapter => {
+  const consoleLog = ( args: string[], level: string ) => {
+    level = level === 'silly' ? 'debug' : level;
+    console[level]( ...args );
+  };
+
+  function formatLogDateTime( date ) {
+    const timeMethods = [
+      'getHours',
+      'getMinutes',
+      'getSeconds',
+    ];
+    if ( typeof date === 'string' ) date = +date;
+    date = new Date( date );
+    const str = `${date.toLocaleDateString()} ${timeMethods.map( m=>date[m]().toString().padStart( 2, '0' )).join( ':' )}.${date.getMilliseconds().toString().padStart( 3,'0' )}`;
+    return str;
+  }
+
+  const formatArgs = ( originalArgs: any[], level: string, module: string ): string[] => {
+    const timestamp = formatLogDateTime( new Date());
+    return compose(
+      prepend( `[${level}]` ),
+      prepend( `[${module}]` ),
+      prepend( `[${timestamp }]` ),
+    )([...originalArgs]) as string[];
+  };
+
+  const log = ( originalArgs: any[], level: string, module: string ) => {
+    consoleLog( formatArgs( originalArgs, level, module ), level );
+  };
+
+  return {
+    _adapter: () => {},
+    start: async()=>{},
+    stop: async()=>{},
+    name: 'console',
+    log
+  };
+};

package/src/adapters/logger/index.ts

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

package/src/index.ts

@@ -0,0 +1,25 @@
+export * from './ports/authentication';
+export * from './ports/base';
+export * from './ports/cache';
+export * from './ports/configuration';
+export * from './ports/database';
+export * from './ports/endpoints';
+export * from './ports/eventsourcing';
+export * from './ports/eventstore';
+export * from './ports/logger';
+export * from './ports/infrastructure';
+
+export * from './adapters/cache';
+export * from './adapters/configuration';
+export * from './adapters/database';
+export * from './adapters/endpoints';
+export * from './adapters/logger';
+export * from './adapters/eventstore';
+export * from './adapters/infrastructure';
+
+export * from './libraries/tcp';
+export * from './libraries/validation';
+export * from './libraries/modules';
+export * from './libraries/openApi';
+
+export * from './utils';

package/src/libraries/modules/fs.ts

@@ -0,0 +1,88 @@
+import { Ports } from '@bett3r-dev/pv3-types';
+import fs from 'fs/promises';
+import path from 'path';
+
+export type LoadModuleOptions = {
+  whiteList?: ( string|RegExp )[]
+  blackList?: ( string|RegExp )[]
+}
+
+function rejectFilename( filename:string, module:string, { whiteList, blackList }: LoadModuleOptions ) {
+  if (
+    filename === '.git' ||
+    filename === '.DS_Store' ||
+    ( whiteList?.length && !whiteList?.some(( match: any ) => !match.test ? match === module : match.test( module ))) ||
+    ( blackList?.length && blackList?.some(( match: any ) => !match.test ? match === module : match.test( module )))
+  )
+    return true;
+}
+
+const getArtifactsFromModule = async ( modulesPath:string, moduleName: string, artifactsList: string[] = []): Promise<string[]> => {
+  const files = await fs.readdir( path.join( modulesPath, moduleName ));
+  for ( const file of files ) {
+    const stat = await fs.stat( path.join( modulesPath, moduleName, file ));
+    if ( stat.isDirectory()){
+      artifactsList = await getArtifactsFromModule( path.join( modulesPath, moduleName ), file, artifactsList );
+    } else {
+      if ( file.search( /\.(readmodel|aggregate|externalSystem|system|policy)\.(j|t)s/mig ) !== -1 ){
+        artifactsList.push( file.replace( /\.(j|t)s/mig, '' ));
+      }
+    }
+  }
+  return artifactsList;
+};
+
+export async function loadModulesFromDirectory( modulesPath: string, options: LoadModuleOptions = {}): Promise<{modules: Record<string, {create: ( ports: Partial<Ports> ) => any}>, modulesList: Record<string,string[]>}> {
+  const modules = await fs.readdir( modulesPath );
+  const modulesList = modules.reduce(( acc, component ) => {
+    acc[component] = {};
+    return acc;
+  }, {});
+
+  // const e = Error('x');
+  //   const line = e.stack?.split('\n')[2];
+  //   // regex to extract folder name from generic line
+  //   // const line = 'at Object.routeEventHandler (/Users/tomasruiz/Documents/development/pv3/src/ports/eventsourcing/index.ts:79:40)';
+  //   //REVIEW: Esto hay que probarlo en windows
+  //   const folder = line?.match(/[\/\\].+?\.(j|t)s/g)?.[0];
+  // if (folder){
+  //   const f = path.basename(folder);
+  //   fs.readdir(folder).then(async files => {
+  //     for (const file of files) {
+  //       const stat = await fs.stat(path.join(folder, file))
+  //       if (stat.isDirectory()){
+
+  //       } else {
+  //         console.log(files)
+  //       }
+  //     }
+  //   })
+
+
+  // }
+
+  // console.log('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%', e.stack);
+
+
+  if ( options.whiteList ){
+    const missing = options.whiteList.reduce(( errors, w ) => {
+      !modules.some( c => RegExp( w ).test( c )) && errors.push( w );
+      return errors;
+    }, [] as any[]);
+    if ( missing.length )
+      throw Error( `Whitelisted module or pattern not found or returned 0 matches: ${missing.join( ', ' )}` );
+  }
+  const modulesMap: Record<string, any> = {};
+  for ( let moduleName of modules ) {
+    const module = path.parse( moduleName ).name;
+    modulesList[moduleName] = await getArtifactsFromModule( modulesPath, moduleName );
+    const filePath = `${modulesPath}/${moduleName}`;
+    if ( rejectFilename( moduleName, module, options ))
+      continue;
+    else modulesMap[module] = await import( filePath );
+  }
+  return {
+    modules: modulesMap,
+    modulesList
+  };
+}

package/src/libraries/modules/index.ts

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

package/src/libraries/openApi/index.ts

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

package/src/libraries/openApi/pruneUnusedRef.ts

@@ -0,0 +1,35 @@
+import { OpenAPIV3_1 } from 'openapi-types';
+
+const collectRefs = ( obj: object, refs = new Set<string>()) => {
+  if ( !obj || typeof obj !== 'object' ) return refs;
+
+  if ( obj['$ref'] && typeof obj['$ref'] === 'string' ) {
+    refs.add( obj['$ref']);
+  }
+
+  for ( let key in obj ) {
+    if ( obj.hasOwnProperty( key )) {
+      collectRefs( obj[key], refs );
+    }
+  }
+
+  return refs;
+};
+
+export const pruneUnusedRefs = ( spec: OpenAPIV3_1.Document ) => {
+  const refs = collectRefs( spec );
+  const definedSchemas = spec.components && spec.components.schemas ? Object.keys( spec.components.schemas ) : [];
+
+  const unusedSchemas = definedSchemas.filter( schema => {
+    const ref = `#/components/schemas/${schema}`;
+    return !refs.has( ref );
+  });
+
+  unusedSchemas.forEach( schema => {
+    delete spec.components!.schemas![schema];
+  });
+
+  return spec;
+};
+
+

package/src/libraries/tcp/index.ts

@@ -0,0 +1,98 @@
+import { LoggerPort } from '@bett3r-dev/pv3-types';
+import { stream } from 'flyd';
+import net, { Server, Socket } from 'net';
+import { Connections, TcpClientObject, TcpServerConnectionHandler, TcpServerObject, TcpSocket, TcpType } from './types';
+export * from './types';
+
+export const send = ( socket: Socket ) => ( message:string | Buffer ) => new Promise<void>(( resolve, reject ) => socket.write( message, ( err?: Error ) => err ? reject( err ) : resolve( undefined )));
+
+export const Tcp = ( loggerPort: LoggerPort ): TcpType => {
+  const logger = loggerPort.createLoggerInstance( 'Tcp' );
+
+  const createTcpServerConnectionHandler = ( idGenerator: () => string, connections: Connections ): TcpServerConnectionHandler => {
+    const connectedStream: flyd.Stream<{socket: Socket}> = stream();
+    const disconnectedStream: flyd.Stream<any> = stream();
+    const dataStream: flyd.Stream<any> = stream();
+    const errorStream: flyd.Stream<any> = stream();
+    const handleClientTcpConnection = ( socket: TcpSocket ) => {
+      const id = idGenerator();
+      socket.id = id;
+      socket.send = send( socket );
+      socket.on( 'data', message=>dataStream({ socket, message }));
+      socket.on( 'error', message=>errorStream({ socket, message: message.toString() }));
+      socket.on( 'close', () => {
+        disconnectedStream( id );
+        delete connections[id];
+      });
+      connections[id] = socket;
+      connectedStream({ socket });
+    };
+    const broadcast = message => Object.values( connections ).forEach(( socket: any ) => socket.write( message ));
+
+    return {
+      handleClientTcpConnection,
+      streams: {
+        connectedStream,
+        disconnectedStream,
+        dataStream,
+        errorStream,
+        broadcast,
+      }
+    };
+  };
+
+  const clientTcpConnection = ( socket: TcpSocket ): TcpClientObject => {
+    const dataStream: flyd.Stream<any> = stream();
+    const errorStream: flyd.Stream<any> = stream();
+    const disconnectedStream: flyd.Stream<any> = stream();
+    socket.send = send( socket );
+    socket.on( 'data', message => dataStream({ socket, message }));
+    socket.on( 'error', message => errorStream({ socket, message }));
+    socket.on( 'close', () => { disconnectedStream( true ); disconnectedStream.end( true ); dataStream.end( true ); });
+    return {
+      socket,
+      send: socket.send,
+      dataStream,
+      errorStream,
+      disconnectedStream,
+      destroy: () => !socket.destroyed ? socket.destroy() : socket
+    };
+  };
+
+  const createTCPClient = ( tcpPort: number, tcpServerAddress: string, timeout: number = 15000 ): Promise<TcpClientObject> =>
+    new Promise(( resolve, reject ) => {
+      const client: TcpSocket = net.createConnection( tcpPort, tcpServerAddress, () => {
+        clearTimeout( destroyTimeout );
+        client.id = `${tcpServerAddress}:${tcpPort}`;
+        const handler = clientTcpConnection( client );
+        resolve( handler );
+      });
+      client.on( 'error', reject );
+      const destroyTimeout = setTimeout(() => {
+        client.destroy();
+        reject( 'Connection TimedOut' );
+      }, timeout );
+    });
+
+  const createTCPServer = ( tcpPort: number, idGenerator:() => string = () => ( Math.floor( Math.random() * 1000000 )).toString(), connections: Connections = {}) : Promise<TcpServerObject> =>
+    new Promise(( resolve ) => {
+      const manager: TcpServerConnectionHandler = createTcpServerConnectionHandler( idGenerator, connections );
+      const server: Server = net.createServer( manager.handleClientTcpConnection );
+      server.listen( tcpPort, () => {
+        logger.log( 'TCP Server listening at tcpPort: ', tcpPort );
+        resolve({
+          ...manager.streams,
+          close: () => new Promise(( resolve, reject ) => {
+            Object.values( connections ).map(( c : TcpSocket )=>c.destroy());
+            server.close( err => err ? reject( err ) : resolve({}));
+          })
+        });
+      });
+    });
+
+
+  return {
+    createTCPServer,
+    createTCPClient
+  };
+};

package/src/libraries/tcp/types.ts

@@ -0,0 +1,43 @@
+import { Socket } from 'net';
+import {} from 'flyd';
+
+export type Connections = { [id:string|number] : TcpSocket }
+
+export type TcpSocket = Socket & {
+  id?: string
+  send?: ( message: string ) => Promise<void>
+}
+
+export type TcpServerConnectionStreams = {
+  connectedStream: flyd.Stream<{socket: Socket}>,
+  disconnectedStream: flyd.Stream<any>,
+  dataStream: flyd.Stream<{socket: TcpSocket, message: string}>,
+  errorStream: flyd.Stream<any>,
+  broadcast: ( message: string ) => void,
+}
+
+export type TcpServerConnectionHandler = {
+  handleClientTcpConnection: ( socket: TcpSocket ) => void,
+  streams: TcpServerConnectionStreams
+}
+
+export type TcpServerObject = TcpServerConnectionStreams & {
+  close: () => Promise<unknown>
+}
+
+export type TcpDataMessage = {socket: TcpSocket, message: string};
+
+export type TcpClientObject = {
+  socket: TcpSocket,
+  disconnectedStream: flyd.Stream<any>,
+  dataStream: flyd.Stream<TcpDataMessage>,
+  errorStream: flyd.Stream<any>,
+  send?: ( message: string ) => Promise<void>
+  destroy: ( error?: Error ) => TcpSocket
+}
+
+
+export type TcpType = {
+  createTCPServer: ( tcpPort:number, idGenerator?: () => string, connections?: Connections ) => Promise<TcpServerObject>,
+  createTCPClient: ( tcpPort: number, tcpServer: string, timeout?: number ) => Promise<TcpClientObject>,
+}

package/src/libraries/validation/__tests__/validation.test.ts

@@ -0,0 +1,25 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import * as validation from '..';
+
+describe( 'validation', () => {
+  describe( 'validateResult', () => {
+    const schema = S.shape({
+      string: S.string(),
+      number: S.number()
+    });
+
+    it( 'returns the same value being validated is ok', () => {
+      const val = validation.validateSchema( schema )({ string:'asdf', number:12 });
+      expect( val ).toEqual({ string:'asdf', number:12 });
+    });
+    it( 'returns err detail if value being validated is not ok', () => {
+      try{
+        //@ts-ignore for testing purposes
+        validation.validateSchema( schema )({ string:34, number:12 });
+      } catch ( err ) {
+        expect( err ).toBeInstanceOf( Error );
+        expect( err.name ).toEqual( 'BadRequestError' );
+      }
+    });
+  });
+});

package/src/libraries/validation/index.ts

@@ -0,0 +1,48 @@
+import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { EndpointActionParams, EndpointSchemas } from '@bett3r-dev/pv3-types';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { ValidationError, createError } from '../../utils';
+
+const ajv = new Ajv({ allErrors: true, schemaId: '$id', useDefaults: true });
+addFormats( ajv );
+const schemas = new WeakMap();
+
+const getCompiledSchema = ( schema: object, coerceTypes: boolean ) => {
+  ajv.opts.coerceTypes = coerceTypes;
+  const compiled = schemas.get( schema );
+  if ( !compiled ){
+    const compiled = ajv.compile( schema );
+    schemas.set( schema, compiled );
+    return compiled;
+  }
+  return compiled;
+};
+
+export const validateSchema = <T>( schema: BaseSchema<T>, coerceTypes = false )=> ( value:T ): T => {
+  const compiled = getCompiledSchema( schema.plain, coerceTypes );
+
+  if ( schema === null && value !== undefined ){
+    throw createError( ValidationError(), { description: 'Must not have body', details: [value]});
+  }
+  if ( !compiled( value )){
+    throw createError( ValidationError(), { description: 'Validation Error', details: compiled.errors });
+  }
+  return value;
+};
+
+export const validateEndpoint = <B=any,Q=any,P=any>( validateSchema: <T>( schema: BaseSchema<T> ) => ( value:T ) => T, schemas?: EndpointSchemas<B,Q,P> ) => async ( epParams: EndpointActionParams<B> ): Promise<EndpointActionParams<B>> =>{
+  const response = {
+    ...epParams,
+    query: schemas?.query && epParams.query ? validateSchema( schemas.query )( epParams.query ) : epParams.query,
+    params: schemas?.params && epParams.params ? validateSchema( schemas.params )( epParams.params ) : epParams.params,
+    body: schemas?.body && epParams.body ? validateSchema( schemas.body )( epParams.body ) : epParams.body
+  };
+  return response;
+};
+
+export function dieOnError ( logger: {error: ( err:any ) => void} = console, err?: any ) {
+  if ( arguments.length === 1 ) return ( err: any ) => dieOnError( logger, err );
+  logger.error( err );
+  process.exit( 1 );
+}

package/src/ports/authentication/index.ts

@@ -0,0 +1,25 @@
+/**
+ * @packageDocumentation
+ * Provides the abstraction over the Authentication and Authorization functionality with an external provider like Auth0, Okta, Keycloak, etc.
+ */
+import { AuthenticationAdapter, AuthenticationPort, RouteAuthManagerFactory } from '@bett3r-dev/pv3-types';
+import { createPort } from '../base';
+
+/**
+ * @category Factories
+ * @param adapter
+ * @returns
+ */
+export const Authentication = ( adapter: AuthenticationAdapter, routesAuthManager: RouteAuthManagerFactory ): AuthenticationPort => {
+  const authentication = createPort({
+    ...adapter,
+    RouteManager: routesAuthManager
+  });
+  adapter.start()
+    .then(() => {
+      authentication.isStarted = true;
+      authentication.emitter.emit( 'started' );
+    });
+
+  return authentication;
+};