@bett3r-dev/pv3 1.0.0

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

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

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

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

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

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

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

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

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