@bett3r-dev/pv3 1.0.0

package/src/ports/endpoints/openApi.ts

@@ -0,0 +1,191 @@
+import { Endpoint } from '../../../../pv3-types/src/endpoints';
+import OpenApiConvert from 'json-schema-for-openapi';
+import { JSONSchema7 } from 'json-schema';
+import { OpenAPIV3_1 } from 'openapi-types';
+import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { clone, objOf } from 'ramda';
+import { reduce } from '@bett3r-dev/bett3r-utils';
+import http from 'http';
+
+const convert = ( schema: JSONSchema7 ) => {
+  return OpenApiConvert.convert( schema, 'main' ).schemas.main;
+};
+
+const getBodySchema = ( schema: any ) => {
+  if ( schema ){
+    if ( schema.anyOf ) {
+      return {
+        anyOf: schema.anyOf.map(( s: any ) => getBodySchema( s ))
+      };
+    } else if ( schema.properties?.data ) {
+      const _schema = clone( schema );
+      _schema.properties.data = getBodySchema( _schema.properties.data );
+      return convert( _schema );
+    } else {
+      return schema.$id
+        ? { $ref: `#/components/schemas/${schema.$id}` }
+        : convert( schema );
+    }
+  }
+};
+
+const getCommandHandlerResponseSchema = ( responseInstance )=>{
+  //REVIEW: Only place not so abstract: Conditional for Systems and Aggregates
+
+  // READMODELS
+  if ( responseInstance?.schema?.plain?.oneOf ){
+    const ref = `#/components/schemas/${responseInstance.schema.plain.oneOf[0].$id}`;
+    responseInstance.schema.plain.oneOf[0] = { $ref: ref };
+    responseInstance.schema.plain.oneOf[1].items = { $ref: ref };
+  }
+  // COMMAND HANDLERS
+  if ( responseInstance?.schema?.plain?.properties?.state ){
+    responseInstance.schema.plain.properties.state = { $ref: `#/components/schemas/${responseInstance?.schema?.plain?.properties?.state.$id}` };
+  }
+  if ( responseInstance?.schema?.plain?.properties?.events )
+    for ( let index = 0; index < responseInstance.schema.plain.properties.events.properties.data.anyOf.length; index++ ) {
+      const element = responseInstance.schema.plain.properties.events.properties.data.anyOf[index];
+      responseInstance.schema.plain.properties.events.properties.data.anyOf[index] = { $ref: `#/components/schemas/${element.$id}` };
+    }
+  // DEFAULT
+  return convert( responseInstance.schema.plain as JSONSchema7 );
+};
+
+export const registerOpenApiSchema = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, name:string, schema: JSONSchema7, tags: string[]) => {
+  const openApiSchema = convert( schema );
+  openApiSchema.tags = tags.map(( t ) => ({ name: t }));
+  schemas[name] = openApiSchema;
+  return schemas;
+};
+
+export const registerAggregateState = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, name:string, schema: JSONSchema7 ) => {
+  return registerOpenApiSchema( schemas, name, schema, ['AggregateState']);
+};
+
+export const registerCommandSchema = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, name:string, schema: BaseSchema ) => {
+  return registerOpenApiSchema( schemas, name, schema.plain as JSONSchema7, ['Commands']);
+};
+
+export const registerProducerEventSchemas = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, schema: BaseSchema ) => {
+  schema.plain.properties.events.properties.data.anyOf?.map(( schema ) => {
+    registerOpenApiSchema( schemas, schema.$id, schema, ['Events']);
+  });
+  schema.plain.properties.state && registerAggregateState( schemas, schema.plain.properties.state.$id, schema.plain.properties.state );
+};
+export const registerConsumerEventsSchemas = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, schema: BaseSchema ) => {
+  schema.plain.anyOf?.map(( s ) => {
+    const schema = s.properties.data;
+    registerOpenApiSchema( schemas, schema.$id, schema, ['Events']);
+  });
+};
+
+export const registerReadmodelSchema = ( schemas: Record<string, OpenAPIV3_1.SchemaObject>, schema: JSONSchema7 ) => {
+  registerOpenApiSchema( schemas, schema.$id as string, schema, ['Readmodel']);
+};
+
+export const registerOpenApiEndpoint = ( paths: OpenAPIV3_1.PathsObject, endpoint: Endpoint ) => {
+  let endpointParams: any[] = [];
+
+  const paramsSchemas = endpoint.schemas?.params?.plain && endpoint.schemas.params.plain.properties;
+  if ( paramsSchemas ) {
+    endpointParams = Object.keys( paramsSchemas ).reduce(( acc, paramSchemaKey ) => {
+      acc.push({
+        in: 'path',
+        name: paramSchemaKey,
+        description: paramsSchemas[paramSchemaKey].flags?.description || 'No description provided',
+        schema: { type: paramsSchemas[paramSchemaKey].type },
+        required: paramsSchemas[paramSchemaKey].preferences?.presence || false
+      });
+      return acc;
+    }, endpointParams );
+  }
+
+  const querySchemas = endpoint.schemas?.query && endpoint.schemas.query.plain.properties;
+  if ( querySchemas ) {
+    endpointParams = Object.keys( querySchemas ).reduce(( acc, paramSchemaKey ) => {
+      const schema = convert( querySchemas[paramSchemaKey]);
+      acc.push({
+        in: 'query',
+        name: paramSchemaKey,
+        description: querySchemas[paramSchemaKey].flags?.description || 'No description provided',
+        schema,
+      });
+      return acc;
+    }, endpointParams );
+  }
+
+  const route = endpoint.route as string;
+
+  paths[route.replace( '/:id', '/{id}' )] = {
+    parameters: endpointParams.length ? endpointParams : [],
+    ...paths[route.replace( '/:id', '/{id}' )],
+    [( endpoint.method || 'GET' ).toLocaleLowerCase()]: { operationId: endpoint.name,
+      description: endpoint.description,
+      tags: [ endpoint.module, ...( endpoint.tags || []) ],
+      ...endpoint.method !== 'GET' && endpoint.schemas?.body && {
+        requestBody: {
+          required: true,
+          content: { 'application/json': {
+            schema: getBodySchema( endpoint.schemas.body.plain )
+          }, ...( !endpoint.multipartProperties ? {} : {
+            'application/json': {
+              schema: convert( endpoint.schemas.body.plain as JSONSchema7 )
+                .then(( schema: OpenAPIV3_1.SchemaObject ) => {
+                  for ( const prop of endpoint.multipartProperties as string[]) {
+                    delete ( schema.properties as Object )[prop];
+                  }
+                  return schema;
+                })
+            },
+            'multipart/form-data': {
+              schema: convert( endpoint.schemas.body.plain as JSONSchema7 )
+            }
+          }) }
+        }
+      }, responses: {
+        ...reduce(( acc, response, status ) => {
+          if ( status === 204 ){
+            acc[status] = {
+              description: 'No Content'
+            };
+          }
+          else {
+            acc[status] = {
+              description: `Response Status Message: ${http.STATUS_CODES[status]}`,
+              content:{
+                'application/json': {
+                  schema: response.length === 1
+                    ? getCommandHandlerResponseSchema( response[0])
+                    : {
+                      anyOf: ( response.map( getCommandHandlerResponseSchema ))
+                    }
+                }
+              }
+            };
+          }
+          return acc;
+        }, {}, { ...endpoint.schemas?.responses, ...endpoint.schemas?.errors }),
+        500: { description: 'Internal Server Error' }
+      }
+
+    }};
+
+  return paths;
+};
+
+export const generateOpenApiDocument = ( paths: OpenAPIV3_1.PathsObject, schemas: Record<string, OpenAPIV3_1.SchemaObject>, packageJson: {name:string, version: string}, _tags: string[] = []) : OpenAPIV3_1.Document => {
+  const tags = _tags.map( objOf( 'name' ));
+  return {
+    openapi: '3.0.3',
+    tags,
+    info: {
+      title: packageJson.name || 'Title',
+      version: packageJson.version || '0.1.1',
+    },
+    servers: [{ url: 'http://localhost:1984' }],
+    components: {
+      schemas
+    },
+    paths
+  };
+};

package/src/ports/endpoints/utils.ts

@@ -0,0 +1,31 @@
+import { omit } from 'ramda';
+
+
+export type FetchResponse<T = any> = Omit<Response,'body'> & {
+  body: T,
+}
+
+export const parseResponseBody = ( type:'json'|'text' ,response: Response, method: 'reject'| 'resolve' ): Promise<FetchResponse> =>{
+  return response[type]()
+    .then( body => {
+      return Promise[method]({
+        ...omit(['body'], response ),
+        body
+      }) as Promise<FetchResponse>;
+    });
+};
+export const processFetchResponse = <T = any>( response: Response ): Promise<FetchResponse<T>> =>{
+  if ( response.ok === true )
+    return parseResponseBody( 'json', response, 'resolve' );
+  else
+    return parseResponseBody( 'json', response, 'reject' );
+};
+
+export const getTokenFromHeader = ( req: {headers: Record<string, string | string[]>}) => {
+  const authHeader = req.headers['authorization'] as string;
+  return authHeader && authHeader.split( ' ' )[1];
+};
+
+export const getTokenFromEndpointParams = ( params: {context:{req:any}, query:{token:string}}) => {
+  return params?.context?.req ? getTokenFromHeader( params.context.req ) : params?.query?.token;
+};

package/src/ports/eventsourcing/__tests__/eventhandlers.test.ts

@@ -0,0 +1,30 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { formatFilter } from '../eventHandlers';
+
+describe( 'Readmodels helper functions', () => {
+  describe( 'formatFilter', () => {
+    const schema = S.shape({
+      id: S.string(),
+      string: S.string(),
+      number: S.number(),
+      boolean: S.boolean()
+    });
+    it.each([
+      [ 'EQ','string,eq,someString', [{ field: 'string', op: 'eq', value: 'someString' }]],
+      [ 'NEQ','boolean,neq,true', [{ field: 'boolean', op: 'neq', value: true }]],
+      [ 'LT','number,lt,3', [{ field: 'number', op: 'lt', value: 3 }]],
+      [ 'GT','string,gt,someString,fdsa', [{ field: 'string', op: 'gt', value: 'someString' }]],
+      [ 'LTE','string,lte,someString', [{ field: 'string', op: 'lte', value: 'someString' }]],
+      [ 'GTE','string,gte,someString', [{ field: 'string', op: 'gte', value: 'someString' }]],
+      [ 'IN','string,in,someString,maria', [{ field: 'string', op: 'in', value: [ 'someString', 'maria' ]}]],
+      [ 'IN','number,in,5,8', [{ field: 'number', op: 'in', value: [ 5, 8 ]}]],
+      [ 'NIN','string,nin,someString,maria', [{ field: 'string', op: 'nin', value: [ 'someString', 'maria' ]}]],
+      [ 'NIN','boolean,nin,true,false', [{ field: 'boolean', op: 'nin', value: [ true, false ]}]],
+      [ 'EXISTS','string,exists', [{ field: 'string', op: 'exists', value: undefined }]],
+      [ 'NOTEXISTS','string,notExists,asdf', [{ field: 'string', op: 'notExists', value: undefined }]],
+    ])( 'transforms the query params of a %s filter', ( name, query, expected ) => {
+      const filter = formatFilter([query], schema );
+      expect( filter ).toEqual( expected );
+    });
+  });
+});

package/src/ports/eventsourcing/__tests__/invariants.test.ts

@@ -0,0 +1,213 @@
+import { Command, System } from '@bett3r-dev/pv3-types';
+import {
+  stateExists,
+  stateNotExists,
+  comparePaths,
+  compareWithValue,
+  compareWithReadmodel,
+  and,
+  or,
+} from '../invariants';
+
+const mockState = {
+  commandHandler: { name: 'SomeAggregate' } as System,
+  command: {} as Command,
+  query: {},
+  stream: '',
+  context: {},
+  events: [],
+  params: {},
+  state: null,
+  data: null
+};
+
+describe( 'invariants', () => {
+  describe( 'StateExists', () => {
+    test( 'returns the commandHandlerState when state exists', async () => {
+      const result = await stateExists().check({
+        ...mockState,
+        state: { name: 'lucas' },
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: { name: 'lucas' },
+      });
+    });
+    test( 'returns an error when state does not exists', async () => {
+      try{
+        await stateExists().check( mockState );
+      } catch( err ) {
+        expect( err.name ).toEqual( 'State Does Not Exists' );
+        expect( err.type ).toEqual( 'BadRequestError' );
+        expect( err.description ).toEqual( 'Expected State in aggregate SomeAggregate' );
+      }
+    });
+  });
+  describe( 'StateNotExists', () => {
+    test( 'returns an Error when state exists', async () => {
+      const result = await stateNotExists().check( mockState );
+      expect( result ).toEqual( mockState );
+    });
+    test( 'returns the commandHandlerState when state does not exists', async () => {
+      try{
+        await stateNotExists().check({
+          ...mockState,
+          state: { name: 'lucas' },
+        });
+      } catch( err ) {
+        expect( err.name ).toEqual( 'Unexpected State' );
+        expect( err.type ).toEqual( 'BadRequestError' );
+        expect( err.description ).toEqual( 'Unexpected State in aggregate SomeAggregate' );
+      }
+    });
+  });
+  describe( 'ComparePaths', () => {
+    test.each([
+      { op:'eq', state: { prop:'john' }, data: { prop: 'john' }, path1:'' },
+      { op:'neq', state: { prop:'john' }, data: { prop: 'tom' }, path1:'' },
+      { op:'lt', state: { prop:3 }, data: { prop: 5 }, path1:'' },
+      { op:'gt', state: { prop:5 }, data: { prop: 3 }, path1:'' },
+      { op:'lte', state: { prop:3 }, data: { prop: 3 }, path1:'' },
+      { op:'gte', state: { prop:5 }, data: { prop: 3 }, path1:'' },
+      { op:'in', state: { prop:5 }, data: { prop: [ 3, 5 ]}, path1:'' },
+      { op:'nin', state: { prop:2 }, data: { prop: [ 3, 5 ]}, path1:'' },
+      { op:'contains', state: { prop:[ 3, 5 ]}, data: { prop: 5 }, path1:'' },
+      { op:'containsKey', state: { prop:[ 3, 5 ]}, data: { prop: 'prop' }, path1:'state' },
+      { op:'notContains', state: { prop:[ 3, 5 ]}, data: { prop: 6 }, path1:'' },
+      { op:'notContainsKey', state: { prop:[ 3, 5 ]}, data: { prop: 'propNot' }, path1:'state' },
+      { op:'some', state: { prop:[ 3, 5 ]}, data: { prop: [ 6, 3 ]}, path1:'' },
+      { op:'every', state: { prop:[ 3, 5 ]}, data: { prop: [ 5, 3, 2 ]}, path1:'' },
+      { op:'exists', state: { prop:'john' }, data: { prop: undefined }, path1:'' },
+      { op:'notExists', state: { prop:'john' }, data: {}, path1: 'state.name' }
+    ])( 'returns the commandHandlerState when path comparison is ok for operation $op', async ( values ) => {
+      const result = await comparePaths({ path1: values.path1 || 'state.prop', path2: 'data.prop', op: values.op as any }).check({
+        ...mockState,
+        state: values.state,
+        data: values.data
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: values.state,
+        data: values.data
+      });
+    });
+    test( 'returns an error when ComparePath is not ok', async () => {
+      try{
+        await comparePaths({ path1: 'state.name', path2: 'data.name', op: 'eq' }).check({
+          ...mockState,
+          state: { name: 'lucas' },
+          data: { name: 'tomas' },
+        });
+      } catch( err ) {
+        expect( err.name ).toEqual( 'Invariant Error' );
+        expect( err.type ).toEqual( 'BadRequestError' );
+        expect( err.description ).toEqual( 'Comparison failed on paths for operation eq' );
+        expect( err.details ).toEqual({ path1: 'state.name', path2: 'data.name' });
+      }
+    });
+  });
+  describe( 'CompareWithValue', () => {
+    test.each([
+      { op:'eq', state: { prop:'john' }, data: 'john', path1:'' },
+      { op:'neq', state: { prop:'john' }, data: 'tom', path1:'' },
+      { op:'lt', state: { prop:3 }, data: 5, path1:'' },
+      { op:'gt', state: { prop:5 }, data: 3, path1:'' },
+      { op:'lte', state: { prop:3 }, data: 3, path1:'' },
+      { op:'gte', state: { prop:5 }, data: 3, path1:'' },
+      { op:'in', state: { prop:5 }, data: [ 3, 5 ], path1:'' },
+      { op:'nin', state: { prop:2 }, data: [ 3, 5 ], path1:'' },
+      { op:'contains', state: { prop:[ 3, 5 ]}, data: 5, path1:'' },
+      { op:'notContains', state: { prop:[ 3, 5 ]}, data: 6, path1:'' },
+      { op:'some', state: { prop:[ 3, 5 ]}, data: [ 6, 3 ], path1:'' },
+      { op:'every', state: { prop:[ 3, 5 ]}, data: [ 5, 3 ], path1:'' },
+      { op:'exists', state: { prop:'john' }, data: undefined, path1:'' },
+      { op:'notExists', state: { prop:'john' }, data: {}, path1: 'state.name' }
+    ])( 'returns the commandHandlerState when path comparison is ok for operation $op', async ( values ) => {
+      const result = await compareWithValue({ path: values.path1 || 'state.prop', value: values.data, op: values.op as any }).check({
+        ...mockState,
+        state: values.state,
+        data: values.data
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: values.state,
+        data: values.data
+      });
+    });
+    test( 'returns an error when CompareValue is not ok', async () => {
+      try{
+        await compareWithValue({ path: 'state.name', value: 'tomas', op: 'eq' }).check({
+          ...mockState,
+          state: { name: 'lucas' },
+        });
+      } catch( err ) {
+        expect( err.name ).toEqual( 'Invariant Error' );
+        expect( err.type ).toEqual( 'BadRequestError' );
+        expect( err.description ).toEqual( 'Comparison failed with value tomas for operation eq' );
+        expect( err.details ).toEqual({ path: 'state.name' });
+      }
+    });
+  });
+  describe( 'CompareWithReadmodel', () => {
+    const mockGet = jest.fn().mockResolvedValue([{ name: 'lucas' }]);
+    const mockEndpoints = {
+      get: mockGet,
+    };
+    test( 'returns the commandHandlerState when readmodel comparison is ok for operation eq', async () => {
+      const result = await compareWithReadmodel({ endpoints: mockEndpoints as any, readmodelBaseUrl:'baseUrl',
+        url: () => '/someUrl?query=1',
+        comparisons:[
+          { path: 'state.name', readmodelPath:'name', op: 'eq' }
+        ]}).check({
+        ...mockState,
+        state: { name: 'lucas' }
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: { name: 'lucas' }
+      });
+      expect( mockGet ).toHaveBeenCalledWith( 'baseUrl/someUrl?query=1' );
+    });
+    test( 'returns an error when CompareWithReadmodel is not ok', async () => {
+      try{
+        await compareWithReadmodel({ endpoints: mockEndpoints as any, readmodelBaseUrl:'baseUrl',
+          url: () => 'someUrl',
+          comparisons:[
+            { path: 'state.name', readmodelPath:'name', op: 'eq' }
+          ]}).check({
+          ...mockState,
+          state: { name: 'tomas' }
+        });
+      } catch( err ) {
+        expect( err.name ).toEqual( 'Invariant Error' );
+        expect( err.type ).toEqual( 'BadRequestError' );
+        expect( err.description ).toEqual( 'Comparison failed with readmodel baseUrlsomeUrl' );
+        expect( err.details ).toEqual({ readmodelUrl: 'baseUrlsomeUrl' });
+      }
+    });
+  });
+  describe( 'OR', () => {
+    test( 'returns true when any of the conditions is ok', async () => {
+      const result = await or( compareWithValue({ path: 'state.name', value: 'lucas', op:'eq' }), compareWithValue({ path: 'state.name', value: 'tomas', op: 'eq' })).check({
+        ...mockState,
+        state: { name: 'lucas' },
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: { name: 'lucas' },
+      });
+    });
+  });
+  describe( 'AND', () => {
+    test( 'returns true when any of the conditions is ok', async () => {
+      const result = await and( compareWithValue({ path: 'state.name', value: 'lucas', op:'eq' }), compareWithValue({ path: 'state.lastName', value: 'ruiz', op: 'eq' })).check({
+        ...mockState,
+        state: { name: 'lucas', lastName: 'ruiz' },
+      });
+      expect( result ).toEqual({
+        ...mockState,
+        state: { name: 'lucas', lastName: 'ruiz' },
+      });
+    });
+  });
+});