@bett3r-dev/pv3 1.0.0

package/src/ports/endpoints/__tests__/test-client-library/services/service.ts

@@ -0,0 +1,181 @@
+
+import { BackendConfig, CommandExecutionResponse, CommandParams, parseQueryParams, QueryParams, ReadModelChange, Requests, ReadModelQueryBase } from '../base';
+
+//*******************************************
+// Schemas
+//*******************************************
+
+export type UpsertApplication = {
+  [key: string]: unknown | undefined;
+};
+export type ApplicationUpserted = {
+  name: string;
+  description?: string;
+  [key: string]: unknown | undefined;
+};
+export type ApplicationsState = {
+  [key: string]: unknown | undefined;
+};
+export type ApplicationsReadmodel = {
+  id: string;
+  [key: string]: unknown | undefined;
+};
+export type UpsertFlow = {
+  [key: string]: unknown | undefined;
+};
+export type FlowUpserted = {
+  [key: string]: unknown | undefined;
+};
+export type FlowGroupsState = {
+  [key: string]: unknown | undefined;
+};
+export type UpsertFlowGroup = {
+  [key: string]: unknown | undefined;
+};
+export type FlowGroupUpserted = {
+  [key: string]: unknown | undefined;
+};
+export type UpsertFlowArtifacts = {
+  [key: string]: unknown | undefined;
+};
+export type FlowArtifactsUpserted = {
+  [key: string]: unknown | undefined;
+};
+export type InitFlowTransfer = {
+  [key: string]: unknown | undefined;
+};
+export type FlowTransferInitiated = {
+  [key: string]: unknown | undefined;
+};
+export type AssignFlowGroup = {
+  [key: string]: unknown | undefined;
+};
+export type FlowGroupAssigned = {
+  [key: string]: unknown | undefined;
+};
+export type FlowGroupsReadmodel = {
+  id: string;
+  [key: string]: unknown | undefined;
+};
+export type GenerateFlowCompletion = {
+  prompt: string;
+};
+export type FlowCompletionGenerated = {
+  prompt: string;
+  response: Record<string, never>;
+};
+export type FlowCompletionsState = ({
+  prompt: string;
+  response: Record<string, never>;
+})[];
+export type FlowsReadmodel = {
+  id: string;
+  [key: string]: unknown | undefined;
+};
+
+export type ApplicationsReadmodelParams = {
+  id: string;
+};
+export type ApplicationsReadmodelQuery = ReadModelQueryBase<ApplicationsReadmodel> & {
+
+};
+export type FlowGroupsReadmodelParams = {
+  id: string;
+};
+export type FlowGroupsReadmodelQuery = ReadModelQueryBase<FlowGroupsReadmodel> & {
+
+};
+export type FlowsReadmodelParams = {
+  id: string;
+};
+export type FlowsReadmodelQuery = ReadModelQueryBase<FlowsReadmodel> & {
+
+};
+
+//*******************************************
+// Operations
+//*******************************************
+
+export type Commands = {
+  UpsertApplication: ({ id, query, body }: CommandParams<UpsertApplication> ) => Promise<CommandExecutionResponse<ApplicationsState, ApplicationUpserted>>;
+  UpsertFlow: ({ id, query, body }: CommandParams<UpsertFlow> ) => Promise<CommandExecutionResponse<FlowGroupsState, FlowUpserted>>;
+  UpsertFlowGroup: ({ id, query, body }: CommandParams<UpsertFlowGroup> ) => Promise<CommandExecutionResponse<FlowGroupsState, FlowGroupUpserted>>;
+  UpsertFlowArtifacts: ({ id, query, body }: CommandParams<UpsertFlowArtifacts> ) => Promise<CommandExecutionResponse<FlowGroupsState, FlowArtifactsUpserted>>;
+  InitFlowTransfer: ({ id, query, body }: CommandParams<InitFlowTransfer> ) => Promise<CommandExecutionResponse<FlowGroupsState, FlowTransferInitiated>>;
+  AssignFlowGroup: ({ id, query, body }: CommandParams<AssignFlowGroup> ) => Promise<CommandExecutionResponse<FlowGroupsState, FlowGroupAssigned>>;
+  GenerateFlowCompletion: ({ id, query, body }: CommandParams<GenerateFlowCompletion> ) => Promise<CommandExecutionResponse<FlowCompletionsState, FlowCompletionGenerated>>;
+};
+export type Queries = {
+  ApplicationsReadmodelById: ( id: string ) => Promise<ApplicationsReadmodel>;
+  ApplicationsReadmodel: ({ query }: QueryParams<ApplicationsReadmodelQuery,ApplicationsReadmodelParams> ) => Promise<ApplicationsReadmodel[]>;
+  FlowGroupsReadmodelById: ( id: string ) => Promise<FlowGroupsReadmodel>;
+  FlowGroupsReadmodel: ({ query }: QueryParams<FlowGroupsReadmodelQuery,FlowGroupsReadmodelParams> ) => Promise<FlowGroupsReadmodel[]>;
+  FlowsReadmodelById: ( id: string ) => Promise<FlowsReadmodel>;
+  FlowsReadmodel: ({ query }: QueryParams<FlowsReadmodelQuery,FlowsReadmodelParams> ) => Promise<FlowsReadmodel[]>;
+};
+export type Subscriptions = {
+  ApplicationsReadmodel: ({ query }: QueryParams<ApplicationsReadmodelQuery,ApplicationsReadmodelParams>, onChange: ( change: ReadModelChange<ApplicationsReadmodel> )=>void ) => void;
+  FlowGroupsReadmodel: ({ query }: QueryParams<FlowGroupsReadmodelQuery,FlowGroupsReadmodelParams>, onChange: ( change: ReadModelChange<FlowGroupsReadmodel> )=>void ) => void;
+  FlowsReadmodel: ({ query }: QueryParams<FlowsReadmodelQuery,FlowsReadmodelParams>, onChange: ( change: ReadModelChange<FlowsReadmodel> )=>void ) => void;
+};
+export const commands = ( requests: Requests, { token }: BackendConfig ): Commands => ({
+
+  UpsertApplication: ({ id, query, body }) => {
+    return requests.post( `/applications/${id}/upsert-application${parseQueryParams( query )}`, body );
+  },
+  UpsertFlow: ({ id, query, body }) => {
+    return requests.post( `/flow-groups/${id}/upsert-flow${parseQueryParams( query )}`, body );
+  },
+  UpsertFlowGroup: ({ id, query, body }) => {
+    return requests.post( `/flow-groups/${id}/upsert-flow-group${parseQueryParams( query )}`, body );
+  },
+  UpsertFlowArtifacts: ({ id, query, body }) => {
+    return requests.post( `/flow-groups/${id}/upsert-flow-artifacts${parseQueryParams( query )}`, body );
+  },
+  InitFlowTransfer: ({ id, query, body }) => {
+    return requests.post( `/flow-groups/${id}/init-flow-transfer${parseQueryParams( query )}`, body );
+  },
+  AssignFlowGroup: ({ id, query, body }) => {
+    return requests.post( `/flow-groups/${id}/assign-flow-group${parseQueryParams( query )}`, body );
+  },
+  GenerateFlowCompletion: ({ id, query, body }) => {
+    return requests.post( `/flow-completions/${id}/generate-flow-completion${parseQueryParams( query )}`, body );
+  }
+});
+
+export const queries = ( requests: Requests, { token }: BackendConfig ): Queries => ({
+
+  ApplicationsReadmodelById: ( id ) => {
+    return requests.get( `/applications-readmodel/${id}?` );
+  },
+  ApplicationsReadmodel: ({ query }) => {
+    return requests.get( `/applications-readmodel/?${parseQueryParams( query )}` );
+  },
+  FlowGroupsReadmodelById: ( id ) => {
+    return requests.get( `/flow-groups-readmodel/${id}?` );
+  },
+  FlowGroupsReadmodel: ({ query }) => {
+    return requests.get( `/flow-groups-readmodel/?${parseQueryParams( query )}` );
+  },
+  FlowsReadmodelById: ( id ) => {
+    return requests.get( `/flows-readmodel/${id}?` );
+  },
+  FlowsReadmodel: ({ query }) => {
+    return requests.get( `/flows-readmodel/?${parseQueryParams( query )}` );
+  }
+});
+
+export const subscriptions = ( requests: Requests, { token }: BackendConfig ): Subscriptions => ({
+
+  ApplicationsReadmodel: ({ query }, onChange ) => {
+    return requests.subscribe( `/applications-readmodel/?${parseQueryParams( Object.assign( query || {}, token ? { access_token: token } : {}))}`, 'ApplicationsReadmodel', onChange );
+  },
+  FlowGroupsReadmodel: ({ query }, onChange ) => {
+    return requests.subscribe( `/flow-groups-readmodel/?${parseQueryParams( Object.assign( query || {}, token ? { access_token: token } : {}))}`, 'FlowGroupsReadmodel', onChange );
+  },
+  FlowsReadmodel: ({ query }, onChange ) => {
+    return requests.subscribe( `/flows-readmodel/?${parseQueryParams( Object.assign( query || {}, token ? { access_token: token } : {}))}`, 'FlowsReadmodel', onChange );
+  }
+});
+
+

package/src/ports/endpoints/__tests__/utils.test.ts

@@ -0,0 +1,54 @@
+// import { FetchResponse, processFetchResponse } from './utils';
+
+// import { AddressInfo } from 'net';
+// import fetch from 'node-fetch';
+// import { createFakeServer } from './tests';
+
+// describe( 'http', function() {
+//   describe('processFetchJsonResponse', function() {
+//     it('process the response from a fetch request when request is ok', done => {
+//       const server = createFakeServer({body:{ name:'tomas' }});
+//       fetch( `http://localhost:${(server.address() as AddressInfo).port}` )
+//         .then(processFetchResponse)
+//         .then((response: FetchResponse) => {
+//           assert.deepEqual( response.body, { name:'tomas' });
+//           server.close(() => {
+//             done();
+//           });
+//         },  done);
+//     });
+//     it('process the response from a fetch request when request is not ok and body is object', done => {
+//       const server = createFakeServer({code:400, body:{ name:'tomas' }});
+//       fetch( `http://localhost:${(server.address() as AddressInfo).port}` )
+//         .then(processFetchResponse)
+//         .then((response: FetchResponse) => {
+//           assert.deepEqual( response.body, { name:'tomas' });
+//           server.close(() => {
+//             done();
+//           });
+//         }, done);
+//     });
+//     it('process the response from a fetch request when request is not ok and body is text', done => {
+//       const server = createFakeServer({code:400, body:"Error"});
+//       fetch( `http://localhost:${(server.address() as AddressInfo).port}` )
+//         .then(processFetchResponse<string>)
+//         .then((response) => {
+//           assert.equal( response.body, "Error");
+//           server.close(() => {
+//             done();
+//           });
+//         }, done);
+//     });
+//     it('process the response from a fetch request when request is not ok and body is number', done => {
+//       const server = createFakeServer({code:400, body:234});
+//       fetch( `http://localhost:${(server.address() as AddressInfo).port}` )
+//         .then(processFetchResponse<number>)
+//         .then((response: FetchResponse<number>) => {
+//           assert.equal( response.body, 234);
+//           server.close(() => {
+//             done();
+//           });
+//         }, done);
+//     });
+//   });
+// });

package/src/ports/endpoints/index.ts

@@ -0,0 +1,272 @@
+import { noop } from '@bett3r-dev/bett3r-utils';
+import S, { BaseSchema } from '@bett3r-dev/jsonschema-definer';
+import { ConfigurationPort, Endpoint, EndpointActionParams, EndpointsAdapter, EndpointsFetchInterfaceResponse, EndpointsPort, InjectHandlerContext, errorStatusCodeMap } from '@bett3r-dev/pv3-types';
+import fs from 'fs/promises';
+import { JSONSchema7 } from 'json-schema';
+import { match } from 'node-match-path';
+import { OpenAPIV3_1 } from 'openapi-types';
+import path from 'path';
+import querystring from 'querystring';
+import { createPort } from '../base';
+import { generateOpenApiDocument, registerCommandSchema, registerConsumerEventsSchemas, registerOpenApiEndpoint, registerOpenApiSchema, registerProducerEventSchemas, registerReadmodelSchema } from './openApi';
+export * from './utils';
+
+export const optionalParamRegexp = /(\/:[^/()]*?)\?(\/?)/;
+export const pathRegex = /\/(.+?)($|\/$|\/?\??|\/(.+?)\/?)($|\?(.+))/;
+
+export const getPathInfo = ( path: string ) =>{
+  const r = pathRegex.exec( path );
+  return r && {
+    original: r[0],
+    base: r[1],
+    path: r[3],
+    query: r[5] && querystring.parse( r[5])
+  };
+};
+
+export const PackageJsonSchema = S.shape({
+  name: S.string(),
+  version: S.string(),
+  host: S.string().optional()
+});
+export type PackageJsonType = typeof PackageJsonSchema.type;
+
+export const EndpointsConfigSchema = S.shape({
+  outOpenApiFileFilePath: S.string().optional(),
+  serviceDiscoveryUrl: S.string().optional(),
+});
+export type EndpointsConfigType = typeof EndpointsConfigSchema.type;
+
+export const Endpoints = ( params: {packageJson: PackageJsonType, configuration: ConfigurationPort, supportedModules?: Record<string,string[]>}, ...adapters: EndpointsAdapter[]): EndpointsPort => {
+  const { packageJson, configuration } = params;
+  const { config: { outOpenApiFileFilePath, serviceDiscoveryUrl }} = configuration.getModuleConfig( 'endpoints', EndpointsConfigSchema.optional());
+  const openApiTags = new Set<string>();
+  let servicesDirectory: Record<string, string> = {};
+  let openApiDocument: OpenAPIV3_1.Document;
+  let paths: OpenAPIV3_1.PathsObject = {};
+  let schemas: Record<string, OpenAPIV3_1.SchemaObject> = {};
+  let endpoints: Record<string, Endpoint> = {};
+  let supportedModules = params.supportedModules;
+
+  configuration.configureCliCommand({
+    name: 'generateDocumentation [servicePath]',
+    description: 'Generates OpenApi documentation for the endpoints and stores it in the .openapi.json file',
+    arguments: [{
+      name: 'servicePath',
+      type: 'string',
+      description: 'The service path to generate the documentation for'
+    }],
+    handler: ({ servicePath }) => {
+      const rootFolder = path.resolve();
+      const stackServiceFilePath = !servicePath || rootFolder.endsWith( servicePath ) ? rootFolder : path.resolve( servicePath );
+      const openApiDocument = generateOpenApiDocument( paths, schemas, packageJson );
+      return generateOpenApiSpec( stackServiceFilePath, openApiDocument )
+        .then(() => {
+          console.log( 'OpenApi documentation generated' );
+          process.exit( 0 );
+        })
+        .catch(( err ) => {
+          console.error( err );
+          process.exit( 1 );
+        });
+    }
+  });
+
+  const fetchServiceDiscovery = async () => {
+    if ( serviceDiscoveryUrl ){
+      const response = await fetch( serviceDiscoveryUrl );
+      const json = await response.json();
+      return json;
+    }
+  };
+
+  const injectHandler = ( context: InjectHandlerContext ) => {
+    return Promise.all(
+      adapters
+        .filter( a=> a.adapterType === 'httpHandler' )
+        .map(( a ) => a.injectHandler && a.injectHandler( context ))
+    )
+      .then( noop );
+  };
+  const callEventConnectionsActive = () => {
+    adapters
+      .forEach(( a ) => a.callEventConnectionsActive && a.callEventConnectionsActive());
+  };
+  const callEventConnectionsInactive = () => {
+    adapters
+      .forEach(( a ) => a.callEventConnectionsInactive && a.callEventConnectionsInactive());
+  };
+
+  const getEndpoints = () => Object.values( endpoints );
+
+  const registerSchema = ( name:string, schema: JSONSchema7, tags: string[]) => {
+    schemas = registerOpenApiSchema( schemas, name, schema, tags );
+  };
+
+  function registerEndpoint( endpoint: Endpoint ) {
+    const optionalParamMatch = endpoint.route.match( optionalParamRegexp );
+    if ( optionalParamMatch ) {
+      const pathFull = endpoint.route.replace( optionalParamRegexp, '$1$2' );
+      const pathOptional = endpoint.route.replace( optionalParamRegexp, '$2' );
+      endpoints[`${endpoint.method}:${pathFull}`] = endpoint;
+      endpoints[`${endpoint.method}:${pathOptional}`] = endpoint;
+    } else {
+      endpoints[`${endpoint.method}:${endpoint.route}`] = endpoint;
+    }
+
+    if ( endpoint.method === 'POST' && endpoint.tags?.some( t=> [ 'aggregate', 'system' ].includes( t ))){
+      registerCommandSchema( schemas, endpoint.name as string, endpoint.schemas?.body as BaseSchema );
+      ( Object.values(( endpoint?.schemas?.responses || {})['200']) || []).forEach(( response ) => {
+        registerProducerEventSchemas( schemas, response.schema as BaseSchema );
+      });
+    }
+    if ( endpoint.method === 'POST' && endpoint.tags?.some( t=> [ 'readmodel', 'policy' ].includes( t ))){
+      registerConsumerEventsSchemas( schemas, endpoint.schemas?.body as BaseSchema );
+    }
+
+    if ( endpoint.method === 'GET' && endpoint.tags?.some( t=> t === 'readmodel' )){
+      registerReadmodelSchema( schemas, ( endpoint.schemas as any ).responses['200'][0].schema.plain.oneOf[0]);
+    }
+
+    paths = registerOpenApiEndpoint( paths, endpoint );
+    adapters.forEach( a => a.registerEndpoint( endpoint ));
+  }
+
+  const call = async <Type, R=Type>( route: string, method: string = 'GET', params?: Pick<EndpointActionParams<Type>, 'body'|'context'> ): Promise<R> =>{
+    const p = getPathInfo( route );
+    let routeParams: Record<string, string> | null = {};
+    const path = Object.keys( endpoints ).find( k => {
+      if ( k.startsWith( `${method}:/${p?.base}` )){
+        const m = match( k.replace( `${method}:`, '' ), route.replace( /\?.+?$/, '' ));
+        if ( m.matches ){
+          routeParams = m.params;
+          return true;
+        }
+      }
+    });
+    if ( !path ){
+      if ( !servicesDirectory ){
+        servicesDirectory = await fetchServiceDiscovery();
+      }
+      if ( servicesDirectory[`${method}:${route}`]){
+        return fetch( servicesDirectory[`${method}:${route}`], {
+          method: method.toUpperCase(),
+          headers: params?.context?.headers,
+          body: JSON.stringify( params?.body )
+        })
+          .then( r => r.json());
+      }
+      return Promise.reject( Error( `Endpoint not identified for ${method}:${route}` ));
+    }
+    return endpoints[path].action({ ...params, params: routeParams, query: p?.query } as EndpointActionParams<Type> )
+      .catch( e => {
+        e.status = e.status || errorStatusCodeMap[e.type];
+        return Promise.reject( e );
+      });
+  };
+
+  const _fetch = async ( route: string, params: {method: 'get'| 'post', headers: Record<string,any>, body: string}): Promise<EndpointsFetchInterfaceResponse> =>{
+    const response = call ( route, params.method.toUpperCase(), { body: JSON.parse( params.body ), context: { headers: params.headers }});
+    return {
+      ok: true,
+      json: async () => response,
+      text: async () => ''
+    };
+  };
+
+  const get = <Type, R=Type>( route: string, params?: Pick<EndpointActionParams<Type>, 'body'|'context'> ): Promise<R> =>{
+    return call( route, 'GET', params );
+  };
+  const post = <Type, R=Type>( route: string, params?: Pick<EndpointActionParams<Type>, 'body'|'context'> ): Promise<R> =>{
+    return call( route, 'POST', params );
+  };
+
+  const getServiceFilePath = () => {
+    const slashRegex = new RegExp( '(/|\\\\)','mig' );
+    const errorStack = new Error().stack?.split( '\n' ) as string[];
+    const stackRow = ( errorStack[5] || '' ).replace( slashRegex, '/' );
+    return stackRow.slice( stackRow.indexOf( '/' ), stackRow.lastIndexOf( '/' ));
+  };
+
+  const addOpenApiTag = ( tag: string ) => {
+    openApiTags.add( tag );
+    openApiDocument = generateOpenApiDocument( paths, schemas, packageJson, Array.from( openApiTags ));
+  };
+
+  const generateOpenApiSpec = async ( servicePath?:string, document?: OpenAPIV3_1.Document ) => {
+    document = document || generateOpenApiDocument( paths, schemas, packageJson, Array.from( openApiTags ));
+    const path = servicePath || outOpenApiFileFilePath || getServiceFilePath();
+    await fs.writeFile( `${path}/.openapi.json`, JSON.stringify( document, null, 2 ));
+    return document;
+  };
+
+  const setServiceSupportedModules = ( modules: Record<string, string[]> ) => {
+    supportedModules = modules;
+  };
+
+  const start = async (): Promise<void> => {
+    // const args = await configuration.getArgs();
+    // args.admin && args.outbox && openApiTags.add( 'pv3.outbox' );
+    if ( supportedModules ){
+      openApiTags.add( 'pv3.service' );
+      openApiTags.add( `modules=${JSON.stringify( supportedModules )}` );
+    }
+
+    return new Promise(( resolve, reject ) => {
+      const stackServiceFilePath = getServiceFilePath();
+      setImmediate(() => {
+        openApiDocument = generateOpenApiDocument( paths, schemas, packageJson, Array.from( openApiTags ));
+        // TODO: Tener un config para que determinar si se crea el archivo o no.
+        if ( process.env.NODE_ENV !== 'production' ){
+          generateOpenApiSpec( stackServiceFilePath, openApiDocument )
+            .catch( reject );
+        }
+
+        return Promise.all( adapters.map( a => {
+          if ( a.onServicesDirectorySet ){
+            a.onServicesDirectorySet(( services ) => {
+              servicesDirectory = services;
+            });
+          }
+          a.registerOpenApi && a.registerOpenApi( openApiDocument );
+          return a.start && a.start();
+        }))
+          .then(() => {
+            endpointsPort.emitter.emit( 'started' );
+            endpointsPort.isStarted = true;
+          })
+          .then( noop )
+          .then( resolve );
+      });
+    });
+  };
+
+  const stop = async () => {
+    return Promise.all( adapters.map( a => {
+      a.stop && a.stop();
+    }))
+      .then( noop );
+  };
+
+  const endpointsPort = createPort({
+    _adapters: () => adapters,
+    getEndpoints,
+    addOpenApiTag,
+    setServiceSupportedModules,
+    generateOpenApiSpec,
+    getOpenApiSpec: () => openApiDocument,
+    registerSchema,
+    registerEndpoint,
+    injectHandler,
+    callEventConnectionsActive,
+    callEventConnectionsInactive,
+    call,
+    fetch: _fetch,
+    get,
+    post,
+    start,
+    stop
+  });
+
+  return endpointsPort;
+};