@bett3r-dev/pv3 1.0.0 → 1.1.7

package/src/adapters/configuration/dotEnv.ts

@@ -1,33 +0,0 @@
-import { mergeDeepRight } from 'ramda';
-import { ConfigurationAdapter } from '@bett3r-dev/pv3-types';
-
-const deepFilterUndefined = ( obj: Record<string, any> ): Record<string, any> => {
-  const result: Record<string, any> = {};
-  Object.keys( obj ).forEach(( key ) => {
-    if ( typeof obj[key] === 'object' && !Array.isArray( obj[key])) {
-      const value = deepFilterUndefined( obj[key]);
-      if ( Object.keys( value ).length > 0 ) {
-        result[key] = value;
-      }
-    } else if ( typeof obj[key] !== 'undefined' ) {
-      result[key] = obj[key];
-    }
-  });
-  return result;
-};
-
-export const DotEnv = ( envFilePath:string, configMap: ( env: Record<string, any>, previous: Record<string, any> ) => Record<string, any> ): ConfigurationAdapter => {
-  require( 'dotenv' ).config({ path: envFilePath });
-  const applyConfig = async <CONFIG extends object>( config: CONFIG ): Promise<CONFIG> => {
-    const envConfig = configMap( process.env, config );
-    return mergeDeepRight( config, deepFilterUndefined( envConfig )) as CONFIG;
-  };
-
-  return {
-    _adapter: () => {},
-    start: async()=>{},
-    stop: async()=>{},
-    name: 'dotEnv',
-    applyConfig
-  };
-};

package/src/adapters/configuration/index.ts

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

package/src/adapters/database/index.ts

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

package/src/adapters/database/memory/__tests__/memoryDb.test.ts

@@ -1,37 +0,0 @@
-// import { Database } from '../../../../ports/database';
-// import { DatabaseAdapterTest } from '@bett3r-dev/pv3-library-tests';
-// import { MemoryDb } from '../index';
-
-// describe( 'MemoryDb tests', () => {
-//   DatabaseAdapterTest( MemoryDb());
-// });
-
-// describe( 'Upsert', () => {
-//   it( 'when upserting a dot notation nested value then it stores it respecting the structure', async () => {
-//     const database = Database( MemoryDb());
-//     await database.getCollection( 'test' ).upsert( '1', { 'id': '1', 'string.nested.value': 4 });
-//     const result = await database.getCollection( 'test' ).readById( '1' );
-//     expect( result ).toEqual({ id: '1', string: { nested: { value: 4 }}}
-//     );
-//   });
-//   it( 'when upserting a dot notation nested value then it stores it respecting the structure', async () => {
-//     const database = Database( MemoryDb());
-//     await database.getCollection( 'test' ).upsert( 'processing', { events:
-//       { 2: 'Carts-CartsReadmodel-1',
-//         3: null,
-//         4: 'Carts-CartsReadmodel-3',
-//         5: 'Carts-CartsReadmodel-0' },
-//     lastProcessed: 3 });
-//     const result = await database.getCollection( 'test' ).readById( 'processing' );
-//     expect( result ).toEqual({
-//       events: {
-//         2: 'Carts-CartsReadmodel-1',
-//         3: null,
-//         4: 'Carts-CartsReadmodel-3',
-//         5: 'Carts-CartsReadmodel-0'
-//       },
-//       id: 'processing',
-//       lastProcessed: 3
-//     });
-//   });
-// });

package/src/adapters/database/memory/index.ts

@@ -1,279 +0,0 @@
-import { ensureArray, TypedEventEmitter } from '@bett3r-dev/bett3r-utils';
-import { Collection, CollectionFilter, CollectionFilterInstance, CollectionOperations, CollectionQueryParams, DatabaseAdapter, DatabaseChange, Document, filterOpMap, IndexOptions } from '@bett3r-dev/pv3-types';
-import { randomUUID } from 'crypto';
-import { assocPath, clone, path, pick, props } from 'ramda';
-import { DuplicatedValueInIndex } from '../../../ports/database';
-import { createError } from '../../../utils';
-
-export const MemoryDb = (): DatabaseAdapter => {
-  let _db = {};
-  const changeEmitters: Record<string, TypedEventEmitter<{'change': DatabaseChange}>> = {};
-  type UniqueIndexes = {
-    [collection: string]:{
-      [index: string] : string[]
-    }
-  }
-
-  const uniqueIndexes: UniqueIndexes = {};
-
-  const start = async () => {
-  };
-
-  const stop = async () => {
-  };
-
-
-  const getCollection = <Model extends Document>( collection:string ): Collection<Model> => {
-    const coll = _db[collection] ||= {};
-
-    const validateIndex = ( data: any ) => {
-      if ( !uniqueIndexes[collection]) return;
-      const duplicatedIndex = Object.keys( uniqueIndexes[collection]).find( index => {
-        const properties = uniqueIndexes[collection][index];
-        const recordComparison = Object.values( coll ).find(( d: any )=> {
-          const valueComparison = properties.every( p =>{
-            return path( p.split( '.' ), d ) === path( p.split( '.' ), data );
-          });
-          return valueComparison;
-        });
-        return recordComparison;
-      });
-      return duplicatedIndex && {
-        index: duplicatedIndex,
-        properties: uniqueIndexes[collection][duplicatedIndex]
-      };
-    };
-
-    const readById = async ( id: string|number ): Promise<Model | null> => {
-      return coll[id] || null;
-    };
-
-    const filterData = ( results: any[], filter: CollectionFilter<Model>[]) => {
-      const shouldFilter = ( row: any, filter: CollectionFilter<Model>[]) => filter.every( f=> {
-        if ( f.AND ){
-          return f.AND.every( andFilters=> shouldFilter( row, [andFilters]));
-        }
-        if ( f.OR ){
-          return f.OR.some( orFilters=> shouldFilter( row, [orFilters]));
-        }
-        return filterOpMap[( f as any ).op]( path([f.field as string], row ), f.value );
-      });
-      return results.filter( row => shouldFilter( row, filter ));
-    };
-
-    const hashId = ( id: string|number ) => {
-      let intId = Number( id );
-      if ( !isNaN( intId )) return intId;
-      const factor = 2;
-      let hash = 0;
-      for ( let i = 0; i < ( id as string ).length; i++ ) {
-        hash = hash * factor + ( id as string ).charCodeAt( i );
-      }
-      return Math.abs( hash );
-    };
-
-    const query = async (
-      queryParams: CollectionQueryParams<Model>
-    ): Promise<Model[]> => {
-      const { limit, filter, sort, after, select } = queryParams;
-      let result = Object.values( coll );
-
-      if ( after ){
-        const sortedKeys = Object.keys( coll ).map(( key ) => [ key, hashId( key ) ])
-          .sort(( a:any, b:any ) => a[1] - b[1])
-          .map(( a:any ) => a[0]);
-        const index = sortedKeys.indexOf( after.toString());
-        result = props( sortedKeys.slice( index + 1 ), coll );
-      }
-
-      result = !filter ? result : filterData( result, filter );
-
-      result = !sort ? result : sort
-        .reduce(( result, sort ) => {
-          return result.sort(( a: any, b: any ) => {
-            return sort.direction === 'desc'
-              ? ( a[sort.field] < b[sort.field] ? 1 : -1 )
-              : ( a[sort.field] >= b[sort.field] ? 1 : -1 );
-          });
-        }, result );
-
-      result = !limit ? result : result.slice( 0, limit );
-
-      result = !select ? result : result.map( pick( ensureArray( select as string )));
-
-      return result as Model[];
-    };
-
-    const forEach = async (
-      queryParams: CollectionQueryParams<Model>,
-      callback: ( record: Model, stop: () => void ) => void | Promise<void>
-    ): Promise<void> => {
-      let shouldStop = false;
-      const stop = () => {
-        shouldStop = true;
-      };
-      await query( queryParams )
-        .then( async records =>{
-          for ( let index = 0; index < records.length; index++ ) {
-            const element = records[index];
-            if ( shouldStop ) return;
-            await callback( element, stop );
-          }
-        });
-    };
-
-    const upsert = async (
-      id: string|number,
-      data: Partial<Model>
-    ): Promise<Model> => {
-      const _data = clone( data );
-      const changeType = coll[id] ? 'update' : 'insert';
-      if ( changeType === 'insert' ){
-        const index = validateIndex( _data );
-        if ( index ) return Promise.reject( createError( DuplicatedValueInIndex(), {
-          details: index.properties.reduce(( details, p ) => {
-            details[p] = path( p.split( '.' ), _data );
-            return details;
-          }, {})
-        }));
-      }
-      const previous = clone( coll[id]);
-      const formatedData = Object.keys( _data ).reduce(( response, key ) => {
-        return assocPath( key.split( '.' ), _data[key], response );
-      }, clone( coll[id]) || {});
-
-      coll[id] = { ...formatedData, id };
-      changeEmitters[collection]?.emit( 'change', { changeType, data: coll[id], previous });
-      return coll[id] as Model;
-    };
-
-    const destroyById = async ( id: string|number ) =>{
-      const previous = coll[id];
-      changeEmitters[collection]?.emit( 'change', { changeType: 'delete', previous });
-      delete coll[id];
-    };
-
-    const createMany = async ( documents: Model[]): Promise<Model[]> => {
-      return documents.map( data=>{
-        const _data = clone( data );
-        validateIndex( _data );
-        coll[_data.id] = _data;
-        changeEmitters[collection]?.emit( 'change', { changeType: 'insert', data: _data });
-        return _data as Model;
-      });
-    };
-
-    const updateMany = async ( filter: CollectionFilterInstance<Model>[], data: Partial<Model> ) => {
-      return Object.keys( coll )
-        .reduce(( response, rowId ) => {
-          if ( filter.every( f=> filterOpMap[( f as any ).op]( path([f.field], coll[rowId]), f.value ))){
-            const previous = coll[rowId];
-            coll[rowId] = { ...coll[rowId], ...clone( data ) };
-            changeEmitters[collection]?.emit( 'change', { changeType: 'update', previous, data: coll[rowId] });
-            response.push( coll[rowId]);
-          }
-          return response;
-        }, [] as any[]) as Model[];
-    };
-
-    const destroyMany = async ( filter: CollectionFilterInstance<Model>[]) => {
-      return Object.keys( coll )
-        .reduce(( response, rowId ) => {
-          if ( filter.every( f=> filterOpMap[( f as any ).op]( path([f.field], coll[rowId]), f.value ))){
-            const previous = coll[rowId];
-            delete coll[rowId];
-            changeEmitters[collection]?.emit( 'change', { changeType: 'delete', previous });
-            response.push( rowId );
-          }
-          return response;
-        }, [] as any[])
-        .length;
-    };
-
-    const atomicIncrement = async ( name: string, filter: CollectionFilterInstance<Model>, amount = 1 ): Promise<number> => {
-      const fnMap = filterOpMap[( filter as any ).op];
-      const key = Object.keys( coll ).find( id => fnMap( path([filter.field], coll[id]), filter.value ));
-      if ( !key ){
-        const id = randomUUID();
-        coll[id] = {
-          [filter.field]: filter.value,
-          [name]: amount
-        };
-        changeEmitters[collection]?.emit( 'change', { changeType: 'insert', data: coll[id] });
-        return amount;
-      } else {
-        const previous = coll[key];
-        coll[key][name] = ( coll[key][name] || 0 ) + amount;
-        changeEmitters[collection]?.emit( 'change', { changeType: 'update', data: coll[key], previous });
-        return coll[key][name];
-      }
-    };
-
-    const ensureIndex = async ( properties: string[], options: IndexOptions = {} as IndexOptions ) =>{
-      if ( options.isUnique === true ){
-        uniqueIndexes[collection] ||= {};
-        uniqueIndexes[collection][properties.join( '_' )] = properties;
-      }
-    };
-
-    const destroyIndex = async ( properties: string[]) =>{
-      if ( uniqueIndexes[collection] && uniqueIndexes[collection][properties.join( '_' )]){
-        delete uniqueIndexes[collection][properties.join( '_' )];
-      }
-    };
-
-    const watch = ( changeTypes: ( 'insert'|'update'|'delete' )[] = ['insert'], onData:( data: DatabaseChange<Model> )=>void, onError: ( e: Error ) => void ) => {
-      changeEmitters[collection] ||= new TypedEventEmitter<{'change': DatabaseChange}>();
-
-      const callback = ( change ) => {
-        if ( changeTypes.includes( change.changeType ))
-          onData( change );
-      };
-      changeEmitters[collection].on( 'change', callback );
-
-      return Promise.resolve({
-        close: () => changeEmitters[collection].off( 'change', callback )
-      });
-    };
-
-    return {
-      readById,
-      query,
-      upsert,
-      forEach,
-      destroyById,
-      createMany,
-      updateMany,
-      destroyMany,
-      atomicIncrement,
-      ensureIndex,
-      destroyIndex,
-      watch
-    };
-  };
-
-  const initTransaction = <Result = any>( operations: ( getCollection: <Model extends Document>( collection: string ) => CollectionOperations<Model> ) => Promise<Result | undefined> ): Promise<Result> => {
-    let backupDb = clone( _db );
-    const commitTransaction = async ( docs?: Result ) =>{
-      return docs || null as Result;
-    };
-
-    const rollbackTransaction = async ( error: Error ) =>{
-      _db = backupDb;
-      return Promise.reject( error );
-    };
-
-    return operations( getCollection )
-      .then( commitTransaction )
-      .catch( rollbackTransaction );
-  };
-
-  return {
-    _adapter: () => _db,
-    name: 'memoryDb',
-    start,
-    stop,
-    getCollection,
-    initTransaction
-  };
-};

package/src/adapters/endpoints/addAuthUser/index.ts

@@ -1,55 +0,0 @@
-import { Endpoint, EndpointActionParams, EndpointsAdapter } from '@bett3r-dev/pv3-types';
-import { path } from 'ramda';
-import { AuthenticationError, createError } from '../../..';
-
-const propMapper = ( map: Record<string, string>, object: Record<string, any> ) => {
-  const result = {};
-  Object.keys( map ).forEach( key => {
-    result[map[key]] = path( key.split( '.' ), object );
-  });
-  return result;
-};
-
-/**
- * Adds the user object to the request context
- * @param customTokenAttributes - Object with key as the path to the attribute in the token and value as the name of the attribute in the user object
- * @returns
- */
-export const AddAuthUserToRequest = ( customTokenAttributes: Record<string, string> ): EndpointsAdapter => {
-  const addUserToContext = async ( params: EndpointActionParams ): Promise<EndpointActionParams> =>{
-    const token: string = params.context?.req?.headers?.authorization as string || params.query?.access_token;
-    if ( !token ) return params;
-    try{
-      const payload = JSON.parse( Buffer.from( token.split( '.' )[1], 'base64' ).toString());
-      if ( !params.context )
-        params.context = {};
-      params.context.token = token.slice( token.lastIndexOf( ' ' ) + 1 );
-      params.context.user = propMapper({
-        'email': 'email',
-        'realm_access.roles': 'roles',
-        'app_id': 'id',
-        ...customTokenAttributes
-      }, payload );
-      return Promise.resolve( params );
-    } catch ( err ) {
-      return Promise.reject( createError( AuthenticationError(), { description: 'Invalid Token' }));
-    }
-  };
-
-  const registerEndpoint = ( endpoint: Endpoint ) => {
-    const originalAction = endpoint.action;
-    endpoint.action = ( params: EndpointActionParams<any, any, any> ) => {
-      return addUserToContext( params )
-        .then( originalAction );
-    };
-    return endpoint;
-  };
-
-  return {
-    _adapter: () => {},
-    name: 'addAuthUser',
-    start: async()=>{},
-    stop: async()=>{},
-    registerEndpoint
-  };
-};

package/src/adapters/endpoints/endpointValidation/index.ts

@@ -1,26 +0,0 @@
-import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
-import { Endpoint, EndpointActionParams, EndpointsAdapter } from '@bett3r-dev/pv3-types';
-import { validateEndpoint } from '../../../libraries/validation';
-
-export const EndpointValidation = ( validateSchema: <T>( schema: BaseSchema<T> ) => ( value:T ) => T, onError: ( err:any, endpoint: Endpoint ) => void = () => {}): EndpointsAdapter => {
-  const registerEndpoint = ( endpoint: Endpoint ) => {
-    if ( endpoint.shouldValidate === false ) return endpoint;
-    const originalAction = endpoint.action;
-    endpoint.action = ( params: EndpointActionParams ) =>
-      validateEndpoint( validateSchema, endpoint.schemas )( params )
-        .catch( e => {
-          onError( e, endpoint );
-          return Promise.reject( e );
-        })
-        .then( originalAction );
-    return endpoint;
-  };
-
-  return {
-    _adapter: () => {},
-    name: 'endpointValidation',
-    start: async()=>{},
-    stop: async()=>{},
-    registerEndpoint
-  };
-};

package/src/adapters/endpoints/index.ts

@@ -1,4 +0,0 @@
-export * from './addAuthUser';
-export * from './endpointValidation';
-// export * from './localAuthorization';
-export * from './userSession';

package/src/adapters/endpoints/localAuthorization/index.ts

@@ -1,75 +0,0 @@
-// import S from '@bett3r-dev/jsonschema-definer';
-// import { compose, mergeRight } from 'ramda';
-// import { AuthenticationPort, /* EndpointMarkedAsPublicSchema, EndpointRolesUpsertedSchema, RouteManagerEndpointAuth */ } from '../../../ports/authentication';
-// import { DatabasePort } from '../../../ports/database';
-// import { Endpoint, EndpointActionParams, EndpointsAdapter, EndpointsPort } from '../../../ports/endpoints';
-
-// export type LocalAuthorizationType = EndpointsAdapter & {
-//   registerRouteManagementEndpoints: ( endpoints: EndpointsPort ) => void;
-// }
-
-// /**
-//  * Performs a local authorization of the incoming request by validating the JWT and performing RBAC authorization
-//  * @param authentication Authentication Port
-//  * @returns
-//  */
-// export const LocalAuthorization = ( authentication: AuthenticationPort, database: DatabasePort ): LocalAuthorizationType => {
-//   const routeManager = authentication.RouteManager( database );
-//   const _authorizeRequest = authentication.authorizeRequest( routeManager );
-
-//   const authorizeRequest = async ( params: EndpointActionParams<any, any, any> ) => {
-//     await _authorizeRequest( params.context.token!, params.context.req?.method!, params.context.req?.route! );
-//     return params;
-//   };
-
-//   const registerEndpoint = ( endpoint: Endpoint ) => {
-//     const originalAction = endpoint.action;
-//     endpoint.action = ( params: EndpointActionParams<any, any, any> ) => {
-//       return authorizeRequest( params )
-//         .then( originalAction );
-//     };
-//     return endpoint;
-//   };
-
-//   const registerRouteManagementEndpoints = ( endpoints: EndpointsPort ) => {
-//     const upsertEndpointAuth = ( patchValue?: Partial<RouteManagerEndpointAuth> ) => ({ body } : {body: {id: string}[]}) => {
-//       return Promise.all( body.map( compose(
-//         routeManager.upsertRoute,
-//         mergeRight( patchValue || {})
-//       )));
-//     };
-
-//     endpoints.registerEndpoint({
-//       module: 'Authorization',
-//       name: 'Mark as Public',
-//       description: 'Mark an endpoint as public',
-//       route: '/authorization/mark-as-public',
-//       method: 'POST',
-//       schemas: {
-//         body: S.array().items( EndpointMarkedAsPublicSchema )
-//       },
-//       action: upsertEndpointAuth({ isPublic:true })
-//     });
-
-//     endpoints.registerEndpoint({
-//       module: 'Authorization',
-//       name: 'Upsert Roles',
-//       description: 'Upsert roles for endpoint',
-//       route: '/authorization/upsert-roles',
-//       method: 'POST',
-//       schemas: {
-//         body: S.array().items( EndpointRolesUpsertedSchema )
-//       },
-//       action: upsertEndpointAuth()
-//     });
-//   };
-
-//   return {
-//     _adapter: () => {},
-//     name: 'localAuthorization',
-//     registerRouteManagementEndpoints,
-//     start: async()=>{},
-//     stop: async()=>{},
-//     registerEndpoint
-//   };
-// };

package/src/adapters/endpoints/tcpConsumer/index.ts

@@ -1,69 +0,0 @@
-import S from '@bett3r-dev/jsonschema-definer';
-import {
-  AppErrorInstance, ConfigurationPort, Endpoint,
-  EndpointAction,
-  EndpointsAdapter, LoggerPort,
-  TcpEventMessageRequest, TcpEventMessageResponse
-} from '@bett3r-dev/pv3-types';
-import { Socket } from 'net';
-import { Tcp as TcpLib, TcpServerObject } from '../../../libraries/tcp';
-
-const TcpConsumerConfigSchema = S.shape({
-  port: S.number().optional().default( 9520 ),
-});
-
-
-export const TcpConsumer = ( configuration: ConfigurationPort, loggerPort: LoggerPort ): EndpointsAdapter => {
-  const { config } = configuration.getModuleConfig( 'tcpConsumer', TcpConsumerConfigSchema.optional());
-  const logger = loggerPort.createLoggerInstance( 'TcpConsumer' );
-  const tcp = TcpLib( loggerPort );
-  let server: TcpServerObject;
-  const endpointMap: Map<string, EndpointAction> = new Map();
-
-  const registerEndpoint = ( endpoint: Endpoint ): Endpoint => {
-    const { route, module, action } = endpoint;
-    logger.log( 'Registering TCP Consumer endpoint:', module, route );
-    endpointMap.set( route, action );
-    return endpoint;
-  };
-
-  const start = async ( port: number | undefined = config.port || 9520 ): Promise<void> =>{
-    tcp.createTCPServer( port ).then( _server => {
-      server = _server;
-      let broker: Socket;
-      logger.info( 'TCP server listening on port', port );
-      server.connectedStream.map(({ socket }) => broker = socket );
-      server.dataStream.map(({ message }) => {
-        const { endpoint, event } = JSON.parse( message ) as TcpEventMessageRequest;
-        const action = endpointMap.get( endpoint );
-        if ( !action ) logger.error( 'No endpoint found for', endpoint );
-        action!({
-          body: event,
-          params: {},
-          query: {},
-          // TODO: Contemplar el contexto que viene del event?
-          context: {},
-        })
-          .then(() => {
-            broker.write( JSON.stringify({ id: event.id, status: 200 } as TcpEventMessageResponse ));
-          })
-          .catch(( e: AppErrorInstance ) => {
-            broker.write( JSON.stringify({ id: event.id, status: e.status, error: e.message } as TcpEventMessageResponse ));
-          });
-      });
-    });
-  };
-
-  const stop = () => new Promise<void>(( resolve, reject ) => {
-    return server.close();
-  });
-
-  return {
-    name: 'express',
-    adapterType: 'httpHandler',
-    _adapter: () => {},
-    registerEndpoint,
-    start,
-    stop,
-  };
-};

package/src/adapters/endpoints/userSession/index.ts

@@ -1,40 +0,0 @@
-import { CachePort, Endpoint, EndpointActionParams, EndpointsAdapter, LoggerPort } from '@bett3r-dev/pv3-types';
-
-/**
- * Adds the user session object to the request context
- * @param customTokenAttributes - Object with key as the path to the attribute in the token and value as the name of the attribute in the user object
- * @returns
- */
-export const UserSession = ( logger: LoggerPort, cache: CachePort, keyFormatter: ( user: Record<string, any> ) => string = ( user ) => user.id ): EndpointsAdapter => {
-  const log = logger.createLoggerInstance( 'UserSessionEndpointsAdapter' );
-  const addUserSessionToContext = async ( params: EndpointActionParams ): Promise<EndpointActionParams> =>{
-    if ( !params.context?.user ) return params;
-    try{
-      const key = keyFormatter( params.context.user );
-      const session = await cache.get( key );
-      if ( !params.context )
-        params.context = {};
-      params.context.session = session;
-    } catch ( err ) {
-      log.error( err );
-    }
-    return Promise.resolve( params );
-  };
-
-  const registerEndpoint = ( endpoint: Endpoint ) => {
-    const originalAction = endpoint.action;
-    endpoint.action = ( params: EndpointActionParams<any, any, any> ) => {
-      return addUserSessionToContext( params )
-        .then( originalAction );
-    };
-    return endpoint;
-  };
-
-  return {
-    _adapter: () => {},
-    name: 'addUserSessionToContext',
-    start: async()=>{},
-    stop: async()=>{},
-    registerEndpoint
-  };
-};