@bett3r-dev/pv3 1.0.0 → 1.1.7

package/src/adapters/eventstore/database.ts

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

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

package/src/adapters/infrastructure/index.ts

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

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

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

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

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

package/src/index.ts

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

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

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

package/src/libraries/openApi/index.ts

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

package/src/libraries/openApi/pruneUnusedRef.ts

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

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

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

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

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

@@ -1,25 +0,0 @@
-/**
- * @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;
-};