@bett3r-dev/pv3 1.0.0

package/src/ports/base.ts

@@ -0,0 +1,20 @@
+import { PortEmitter, PortEmitterEvents, TypedEventEmitter } from '@bett3r-dev/pv3-types';
+
+/**
+ * Factory wrapper to create Ports, Extends the port definition with the PortEmitter Interface.
+ * @param port The Port to instanciate.
+ */
+export const createPort = <PORT>( port: PORT ): PORT & PortEmitter => {
+  const emitter = new TypedEventEmitter<PortEmitterEvents>();
+  emitter.setMaxListeners( 100 );
+  const instance = {
+    emitter,
+    isStarted: false,
+    onStarted: ( fn: () => void ) => {
+      if ( instance.isStarted ) fn();
+      emitter.once( 'started', fn );
+    },
+    ...port
+  };
+  return instance;
+};

package/src/ports/cache/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * Provides the abstraction For Caching data on Memory, Redis, Memcached, etc.
+ */
+import { createPort } from '../base';
+import { CacheAdapter, CachePort } from '@bett3r-dev/pv3-types';
+
+export const Cache = ( adapter: CacheAdapter ): CachePort => {
+  const cache = createPort( adapter );
+  adapter.start()
+    .then(() => {
+      cache.isStarted = true;
+      cache.emitter.emit( 'started' );
+    });
+
+  return cache;
+};

package/src/ports/configuration/__tests__/configurationPort.test.ts

@@ -0,0 +1,47 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { Configuration } from '../index';
+
+describe( 'configuration', function() {
+  const getAdapter = ( config: any ) => ({
+    applyConfig: async () => config,
+    name:'test',
+    _adapter:() => {},
+    start: async () =>{},
+    stop:async () => {}
+  });
+
+  describe( 'getModuleConfig', function() {
+    it( 'returns all the config', async () => {
+      const config = { module1:{ prop1: 'prop1' }, module2:{ prop2: 'prop2' }};
+      const configuration = await Configuration( getAdapter( config ));
+      expect( configuration._getConfig()).toEqual({ module1: { prop1: 'prop1' }, module2: { prop2: 'prop2' }});
+    });
+    it( 'returns a partial of the configuration object', async () => {
+      const config = { module1:{ prop1: 'prop1' }, module2:{ prop2: 'prop2' }};
+      const configuration = await Configuration( getAdapter( config ));
+      expect( configuration.getModuleConfig( 'module1', S.shape({ prop1: S.string() }))).toEqual({ prop1: 'prop1' });
+      expect( configuration.getModuleConfig( 'module2', S.shape({ prop2: S.string() }))).toEqual({ prop2: 'prop2' });
+    });
+    it( 'throws when module not found', done => {
+      const config = { module1:{ prop1: 'prop1' }, module2:{ prop2: 'prop2' }};
+      Configuration( getAdapter( config ))
+        .then( configuration=>{
+          expect( configuration.getModuleConfig( 'module3', S.shape({ prop1: S.string() }))).toThrow( /Configuration not available/ );
+        })
+        .catch(() => done());
+    });
+    it( 'returns {} when optional module not found', async () => {
+      const config = { module1:{ prop1: 'prop1' }, module2:{ prop2: 'prop2' }};
+      const configuration = await Configuration( getAdapter( config ));
+      expect( configuration.getModuleConfig( 'module3', S.shape({ prop1: S.string() }).optional())).toEqual({});
+    });
+    it( 'throws when schema does not match', done => {
+      const config = { module1:{ prop1: 'prop1' }, module2:{ prop2: 'prop2' }};
+      Configuration( getAdapter( config ))
+        .then( configuration=>{
+          expect( configuration.getModuleConfig( 'module1', S.shape({ prop2: S.string() }))).toThrow( /should have required property/ );
+        })
+        .catch(() => done());
+    });
+  });
+});

package/src/ports/configuration/args.ts

@@ -0,0 +1,39 @@
+import { omit } from 'ramda';
+import yargs from 'yargs';
+import { mergeConfigProperty } from './common';
+
+export const getYargs = () => yargs;
+
+export const getYargsInit = () =>
+  yargs
+    .config()
+    .usage( 'Usage: $0 [Commands | Options]' )
+    .help( 'h' )
+    .alias( 'h', 'help' )
+    .array( 'modules' )
+    .alias( 'modules', 'm' )
+    .boolean( 'admin' )
+    .alias( 'admin', 's' )
+    .boolean( 'infrastructure' )
+    .alias( 'infrastructure', 'i' )
+    .boolean( 'requestAuthorization' )
+    .alias( 'requestAuthorization', 'r' )
+    .boolean( 'outbox' )
+    .alias( 'outbox', 'o' )
+    .describe( 'modules', 'Modules to load' )
+    .epilog( `copyright bett3r.dev ${new Date().getFullYear()}` );
+
+
+export const formatArgs = async( config:Record<string,any> ) => {
+  const y = getYargsInit();
+  const args = await y.parseAsync();
+  return omit([ 'm', '$0', '_' ], args );
+};
+
+export const applyArgs = async ( config: Record<string, any> = {}) => {
+  const args = await formatArgs( config );
+  return {
+    config: mergeConfigProperty( config, args ),
+    args
+  };
+};

package/src/ports/configuration/common.ts

@@ -0,0 +1,12 @@
+export function mergeConfigProperty( configObj:any, newConfig:any ) {
+  if ( !newConfig ) return configObj;
+  Object.getOwnPropertyNames( newConfig ).forEach(( prop ) => {
+    if ( newConfig[prop] && typeof newConfig[prop] === 'object' && !Array.isArray( newConfig[prop])) {
+      configObj[prop] = configObj[prop] || {};
+      mergeConfigProperty( configObj[prop], newConfig[prop]);
+    } else{
+      configObj[prop] = newConfig[prop];
+    }
+  });
+  return configObj;
+}

package/src/ports/configuration/index.ts

@@ -0,0 +1,110 @@
+import { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { CliArgDefinition, CliCommandDefinition, ConfigurationAdapter, ConfigurationPort, ConfigurationPortEmitterEvents, TypedEventEmitter } from '@bett3r-dev/pv3-types';
+import path from 'path';
+import R from 'ramda';
+import { Argv } from 'yargs';
+import { validateSchema } from '../../libraries/validation';
+import { createPort } from '../base';
+import { applyArgs, getYargs } from './args';
+import { getLocalConfig, getProjectRootConfig } from './localConfig';
+
+declare global {
+  namespace globalThis {
+    interface global{
+      appRoot: string
+    }
+  }
+}
+
+const appRoot = process.env.APP_ROOT_DIR || global.appRoot || process.cwd() || path.dirname( require.main?.filename || '' );
+
+//*******************************************
+// Public interface
+//*******************************************
+
+type AppConfig = Record<string, any>;
+
+export const Configuration = ( ...adapters: ConfigurationAdapter[]): Promise<ConfigurationPort> => {
+  let _config: AppConfig;
+  let _args: Record<string, any> = {};
+
+  const applyAdapters = ( config: AppConfig ): Promise<AppConfig> => {
+    return ( adapters || []).reduce(
+      ( success, adapter ) => success.then( adapter.applyConfig ), Promise.resolve( config )
+    );
+  };
+
+  const _getConfig = () : Promise<AppConfig> =>
+    _config
+      ? Promise.resolve( _config )
+      : getProjectRootConfig( appRoot )
+        .then(( rootConfig ) => getLocalConfig( appRoot, './config', rootConfig ))
+        .then( applyAdapters )
+        .then( config=> _config = config );
+
+  const getModuleConfig = <T extends Record<string,any>>( configPath:string, schema: ObjectSchema<T> ) =>{
+    const moduleConfig = R.path( configPath.split( '.' ), _config ) as T;
+    if ( !moduleConfig ) {
+      if ( schema.isRequired )
+        throw Error( `Configuration not available for ${configPath}` );
+      // return { config: {} as T, onArgsApplied: () => {} };
+    }
+    return {
+      config: validateSchema( schema, true )( moduleConfig || {}),
+      onArgsApplied: ( callback: ( config: T ) => void ) => {
+        config.emitter.on( 'argsApplied', ({ config }) => {
+          callback( R.path( configPath.split( '.' ), config ) as T );
+        });
+      }
+    };
+  };
+
+  const applyCLIArgs = async () => {
+    const appliedArgs = await applyArgs( _config );
+    config.emitter.emit( 'argsApplied', appliedArgs );
+    _config = appliedArgs.config;
+    _args = appliedArgs.args;
+    return config;
+  };
+
+  const getArgs = async () => {
+    await applyCLIArgs();
+    return _args;
+  };
+
+  const configureCliArg = ( options: CliArgDefinition, yargs?: Argv ) => {
+    const args = yargs || getYargs();
+    args[options['type'] as any]( options['name']);
+    options.alias && args.alias( options['name'], options['alias']);
+    options.default && args.default( options['name'], options['default']);
+    options.description && args.describe( options['name'], options['description']);
+  };
+
+  const configureCliCommand = ( options: CliCommandDefinition ) => {
+    const args = getYargs();
+    args.command([ options.name, options.alias || '' ].filter( n => !!n ), options.description || '', ( yargs ) => {
+      options.arguments && options.arguments.forEach(( arg ) => {
+        yargs.positional( arg.name, arg );
+      });
+      return yargs;
+    }, options.handler );
+  };
+
+  const config: ConfigurationPort = createPort({
+    _getConfig: () => _config,
+    getModules: () => _config.modules,
+    getArgs,
+    applyArgs: applyCLIArgs,
+    getModuleConfig,
+    configureCliArg,
+    configureCliCommand,
+    emitter: new TypedEventEmitter<ConfigurationPortEmitterEvents>()
+  });
+
+  return _getConfig()
+    .then(( _config ) => {
+      config.isStarted = true;
+      config.emitter.emit( 'started' );
+      return config;
+    });
+};

package/src/ports/configuration/localConfig.ts

@@ -0,0 +1,117 @@
+import fs from 'fs';
+import * as glob from 'glob';
+import yaml from 'js-yaml';
+import path from 'path';
+import { always } from 'ramda';
+import { promisify } from 'util';
+import { mergeConfigProperty } from './common';
+
+type LocalConfigOptions = {
+  configFolder: string
+  configFilePattern: string
+}
+
+const environment = process.env.NODE_ENV || 'development';
+
+const readFile = promisify( fs.readFile );
+function searchFile( folder: string, pattern: string ) {
+  const files = glob.globSync( pattern, { cwd: folder });
+  if ( files && files.length && files[0]) return files[0];
+}
+
+const createDefaultConfigFile = ( folder:string ) => ( content: any ) => {
+  Promise.resolve();
+  return promisify( fs.writeFile )( path.join( folder, 'default.yaml' ), yaml.dump( content, {
+    indent: 2,
+    sortKeys: true,
+  }))
+    .then( always( content ));
+};
+
+function getFileContent( fileName: string ) {
+  if ([ '.js', '.json' ].includes( path.extname( fileName ))) {
+    return import( fileName );
+  } else if ([ '.yaml', '.yml' ].includes( path.extname( fileName ))) {
+    return readFile( fileName, 'utf8' ).then(
+      ( file ) => yaml.load( file, { json: true })
+    );
+  } else {
+    return Promise.reject(
+      Error( `Unkown config file type for file ${fileName}.` )
+    );
+  }
+}
+
+export const getProjectRootConfig = ( appRoot: string ) => {
+  do {
+    appRoot = path.dirname( appRoot );
+    const rootProjectFolder = path.join( appRoot, '.esas.config.json' );
+    if ( fs.existsSync( rootProjectFolder )) {
+      return getLocalConfig( appRoot );
+    }
+  } while ( appRoot !== '/' );
+  return Promise.resolve({});
+};
+
+export function getLocalConfig( appRoot: string, configFolder = './config', initialConfig = {}, forceCreateDefaultConfigFile = false ) {
+  const options: LocalConfigOptions = {
+    configFolder: path.join( appRoot, configFolder ),
+    configFilePattern: '*+(c|C)onfig.+(js|json|yaml|yml)',
+  };
+  let defaultConfigFile = searchFile(
+    options.configFolder,
+    'default.+(js|json|yaml|yml)'
+  );
+  let defaultConfigPromise: Promise<any> = Promise.resolve();
+  return (
+    !defaultConfigFile && forceCreateDefaultConfigFile
+      ? defaultConfigPromise
+        .then( createDefaultConfigFile( path.join( appRoot, '/config' )))
+      :
+      defaultConfigPromise
+        .then(() => !defaultConfigFile ? {} : getFileContent( path.join( options.configFolder, defaultConfigFile as string )))
+        .then(( defaultConfig ) => mergeConfigProperty( initialConfig, defaultConfig ))
+  )
+    .then( async ( configObj ) => {
+      let localConfigFile = searchFile(
+        options.configFolder,
+        'local.+(js|json|yaml|yml)'
+      );
+      if ( localConfigFile ) {
+        localConfigFile = path.join( options.configFolder, localConfigFile );
+        configObj = mergeConfigProperty(
+          configObj,
+          await getFileContent( localConfigFile )
+        );
+      }
+      let environmentFileName = searchFile(
+        options.configFolder,
+        `${environment}.+(js|json|yaml|yml)`
+      );
+      if ( environmentFileName ) {
+        environmentFileName = path.join(
+          options.configFolder,
+          environmentFileName
+        );
+        configObj = mergeConfigProperty(
+          configObj,
+          await getFileContent( environmentFileName )
+        );
+      }
+      let environmentFileLocalName = searchFile(
+        options.configFolder,
+        `local-${environment}.+(js|json|yaml|yml)`
+      );
+      if ( environmentFileLocalName ) {
+        environmentFileLocalName = path.join(
+          options.configFolder,
+          environmentFileLocalName
+        );
+        configObj = mergeConfigProperty(
+          configObj,
+          await getFileContent( environmentFileLocalName )
+        );
+      }
+      return configObj;
+    });
+}

package/src/ports/database/index.ts

@@ -0,0 +1,25 @@
+import { AppError } from '../../utils';
+import { createPort } from '../base';
+import { DatabaseAdapter, DatabasePort } from '@bett3r-dev/pv3-types';
+import S from '@bett3r-dev/jsonschema-definer';
+
+export const DuplicatedValueInIndex = () => AppError({
+  error: 'NotUniqueError',
+  description: 'Duplicated values for Index marked as Unique',
+  schema: S.shape({}).additionalProperties( true ),
+  type: 'ConflictError',
+});
+
+export const Database = ( adapter: DatabaseAdapter ): DatabasePort => {
+  const database = Object.assign(
+    createPort( adapter ),
+    { _adapter: adapter },
+  );
+  adapter.start()
+    .then(() => {
+      database.isStarted = true;
+      database.emitter.emit( 'started' );
+    });
+
+  return database;
+};

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

@@ -0,0 +1,20 @@
+import { Configuration } from '@bett3r-dev/pv3';
+import { ConfigurationPort } from '@bett3r-dev/pv3-types';
+import { Endpoints } from '../index';
+import { create } from './test-client-library';
+
+describe( 'Endpoints', () => {
+  let configuration: ConfigurationPort;
+  beforeAll( async() => {
+    configuration = await Configuration();
+  });
+  it( 'should be defined', async () => {
+    const endpoints = Endpoints({ packageJson:{ name: 'test', version: '3' }, configuration });
+    const clientLibrary = create({ baseUrl: '' }, endpoints.fetch );
+    const response = await clientLibrary.commands.AssignFlowGroup({
+      id: 'asdf',
+      body: {},
+      query: {}
+    });
+  });
+});

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

@@ -0,0 +1,167 @@
+/** OneOf type helpers */
+export type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+export type XOR<T, U> = ( T | U ) extends object ? ( Without<T, U> & U ) | ( Without<U, T> & T ) : T | U;
+export type OneOf<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? OneOf<[XOR<A, B>, ...Rest]> : never;
+
+export type BackendConfig = {
+  baseUrl: string,
+  token?: string
+}
+
+export type EventMetadata = {
+  causationId?: string | undefined;
+  correlationId?: string | undefined;
+  user?: any;
+}
+
+export type CommittedEvent<Payload = any> = {
+  name: string,
+  data?: Payload,
+  stream: string
+  metadata: EventMetadata
+  id: number
+  timestamp: string
+  version: number
+}
+
+export type CommandParams<Body=any> = {
+  id: string,
+  query?: {
+    expectedVersion?: string
+    correlationId?: string
+  },
+  body?: Body
+}
+
+export type CommandExecutionResponse<Model = any, Event = any> = {
+  state?: Model,
+  events: CommittedEvent<Event>[]
+}
+
+export type ReadModelChange<T = any> = {
+  type: 'insert' | 'update' | 'delete',
+  data: T
+};
+
+export type QueryParams<Query=any,Params=any> = {
+  // params?: Partial<Params>,
+  query?: Partial<Query>
+}
+
+export type FetchResponse<T = any> = Response & {
+  bodyParsed: T
+}
+
+export type Document = {
+  id: string | number;
+};
+
+export type QueryFilter<Model extends Document = any> = {
+  field: keyof Model;
+  op: 'eq' | 'neq' | 'lt' | 'gt' | 'lte' | 'gte' | 'in' | 'nin' | 'contains' | 'notContains' | 'some' | 'every' | 'exists'| 'notExists';
+  value: any;
+};
+
+export type QuerySort<Model extends Document = any> = {
+  field: keyof Model;
+  direction?: 'asc' | 'desc';
+};
+
+export type ReadModelQueryBase<Model extends Document = any> = {
+  access_token?: string;
+  apikey?: string;
+  limit?: number;
+  after?: string | number;
+  sort?: QuerySort<Model>[];
+  filter?: QueryFilter<Model>[];
+  select?: keyof Model | ( keyof Model )[]
+};
+
+export const parseResponseBody = ( type:'json'|'text' ,response: Response, method: 'reject'| 'resolve' ): Promise<void|FetchResponse> =>{
+  return response[type]()
+    .then(( bodyParsed ) => {
+      return Promise[method]( Object.assign( response, {
+        bodyParsed
+      }) as FetchResponse );
+    });
+};
+export const processFetchResponse = <T = any>( response: Response ): Promise<void|FetchResponse<T>> =>{
+  if ( response.ok === true )
+    return parseResponseBody( 'json', response, 'resolve' );
+  else
+    return parseResponseBody( 'json', response, 'reject' );
+};
+
+const processQueryPropertyMap = {
+  filter: ( filter: QueryFilter[], params: URLSearchParams )=>{
+    return filter.reduce(( acc, filterItem ) => {
+      acc.append( 'filter', `${filterItem.field as string},${filterItem.op},${filterItem.value}` );
+      return acc;
+    }, params );
+  },
+  sort: ( sort: QuerySort[], params: URLSearchParams )=>{
+    return sort.reduce(( acc, sortItem ) => {
+      acc.append( 'sort', `${sortItem.field as string},${sortItem.direction || 'asc'}` );
+      return acc;
+    }, params );
+  }
+};
+
+export const parseQueryParams = ( query?: Record<string, any> ) =>{
+  if ( query && Object.keys( query ).length ){
+    return Object.keys( query ).reduce(( acc, key ) => {
+      if ([ 'filter', 'sort' ].includes( key )){
+        return processQueryPropertyMap[key as keyof typeof processQueryPropertyMap]( query[key], acc );
+      } else if ( Array.isArray( query[key])){
+        ( query[key] as string[]).forEach(( value ) => acc.append( key, value ));
+        return acc;
+      } else {
+        acc.append( key, query[key]);
+      }
+      return acc;
+    }, new URLSearchParams());
+  }
+  return '';
+};
+
+export type Requests = ReturnType<typeof requests>;
+export const requests = ( params: BackendConfig, _fetch = fetch ) => {
+  const defaultHeaders = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${params.token}`
+  };
+
+  const post = ( path: string, body?: any, headers: Record<string, string> = {}) => {
+    return _fetch( `${params.baseUrl}${path}`, { method: 'post',
+      headers: { ...defaultHeaders, ...headers }, ...( body
+        ? { body: JSON.stringify( body ) }
+        : {}),
+    })
+      .then( processFetchResponse )
+      .then(( response: FetchResponse | void ) => { return response?.bodyParsed; });
+  };
+
+  const get = ( path: string, headers: Record<string, string> = {}) => {
+    return _fetch( `${params.baseUrl}${path}`, { method: 'get',
+      headers: { ...defaultHeaders, ...headers }, })
+      .then( processFetchResponse )
+      .then(( response: FetchResponse | void ) => { return response?.bodyParsed; });
+  };
+
+  const subscribe = ( path:string, name: string, onChange: ( change: ReadModelChange )=>void ) => {
+    console.log( `Stablishing connection with subscription ${name}...` );
+    const source = new EventSource( `${params.baseUrl}${path}` );
+    source.addEventListener( 'open', ( e ) => console.log( `Connections to the server established for subscription ${name}` ), false );
+    source.onmessage = ( e ) => {
+      if ( e.data === 'Connected' ) return;
+      onChange( JSON.parse( e.data ));
+    };
+    return source.close.bind( source );
+  };
+
+  return {
+    post,
+    get,
+    subscribe
+  };
+};

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

@@ -0,0 +1,23 @@
+import { BackendConfig, requests, CommandParams } from './base';
+import * as service from './services/service';
+export * as service from './services/service';
+// TODO: Export service as service
+
+export { CommandParams, BackendConfig };
+
+export const create = ( params: BackendConfig, fetch?: any ) => {
+  const req = requests( params, fetch );
+
+  return {
+    commands: {
+      ...service.commands( req, params ),
+
+    },queries: {
+      ...service.queries( req, params ),
+
+    },subscriptions: {
+      ...service.subscriptions( req, params ),
+
+    }
+  };
+};