@bett3r-dev/pv3 1.0.0 → 1.1.7

package/src/ports/base.ts

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

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

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

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

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

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

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

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

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

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

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