@bett3r-dev/pv3 1.0.0 → 2.5.1

package/src/ports/endpoints/openApi.ts

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

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

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

@@ -1,213 +0,0 @@
-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' },
-      });
-    });
-  });
-});