@bett3r-dev/pv3 1.0.0 → 2.5.1

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

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

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

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