@bett3r-dev/pv3-types 1.0.0

package/src/eventsourcing/eventHandlers.ts

@@ -0,0 +1,118 @@
+import S, { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { AppErrorInstance } from '../validation';
+import { Collection, CollectionQueryParams, DatabaseChange, DatabasePort, Document } from '../database';
+import { EndpointActionParams, RequestObject, ResponseObject } from '../endpoints';
+import { CommittedEvent, EventFactory, GetMessageType } from '../eventsourcing';
+import { LoggerType } from '../logger';
+import { System } from './commandHandlers';
+import { TypedEventEmitter } from '../typedEventEmitter';
+
+const SortStringSchema = S.string().pattern( /^(\w+),?(asc|desc)?$/ );
+const FilterStringSchema = S
+  .string()
+  .pattern( /^([\w\d._]+),(eq|neq|lt|gt|lte|gte|in|nin|contains|notContains|some|every|exists|notExists),(.+?)$/ );
+
+export const ReadModelDefaultParamsSchema = S.shape({
+  id: S.string().optional()
+});
+
+export const ReadModelDefaultQuerySchema = S.shape({
+  access_token: S.string().optional(),
+  apikey: S.string().optional(),
+  limit: S.string().optional(),
+  after: S.string().optional(),
+  sort: S.oneOf( SortStringSchema, S.array().items( SortStringSchema )).optional(),
+  select: S.array().items( S.string()).optional(),
+  //TODO: scape , for when the value has commas.
+  filter: S
+    .oneOf( FilterStringSchema, S.array().items( FilterStringSchema ))
+    .optional()
+});
+
+export type ReadModelDefaultQuery = typeof ReadModelDefaultQuerySchema.type
+
+export type ReadModelDefaultParams = typeof ReadModelDefaultParamsSchema.type;
+
+
+export const defaultParamsSchemas = {
+  params: ReadModelDefaultParamsSchema
+};
+
+export const defaultQuerySchemas = {
+  query: ReadModelDefaultQuerySchema
+};
+
+export type EventHandler<EVENTS extends Record<string, EventFactory>=any> = {
+  name: string;
+  events: EVENTS;
+  concurrency?: number;
+  errorHandlers?: {
+    [Name in keyof EVENTS]?: HandlerExecutionErrorType<CommittedEvent<GetMessageType<EVENTS[Name]>>>
+  },
+}
+
+export type PolicyResponse = {name: string, id?: string, data?: any};
+export type HandlerExecutionErrorType<EVENT extends CommittedEvent = CommittedEvent> = ( error: AppErrorInstance, event: EVENT ) => Promise<unknown>;
+
+//*******************************************
+// Policies
+//*******************************************
+
+export type Policy<CommandHandler extends System=any, Events extends Record<string, EventFactory>=any> = EventHandler<Events> & {
+  commandHandler?: CommandHandler,
+  eventHandlers: {
+    [Name in keyof Events]: ( event: CommittedEvent<GetMessageType<Events[Name]>> ) => Promise<PolicyResponse | void>
+  }
+}
+
+//*******************************************
+// Readmodels
+//*******************************************
+
+export type QueryParamsTranslator<Model extends Document, Params, Query> = ( schema: ObjectSchema<Model>, params: Pick<EndpointActionParams<any, Query, Params>, 'params' | 'query'> ) => CollectionQueryParams<Model>;
+
+export type QueryHandler<MODEL extends Document=any,PARAMS=any,QUERY=any> = ( repository: Collection<MODEL>, params: CollectionQueryParams<MODEL> & {params: EndpointActionParams<any, QUERY, PARAMS>}) => Promise<MODEL | MODEL[]>;
+
+export type QueryTransformer<MODEL extends Document=any,PARAMS=any,QUERY=any> = ( projectionParams: CollectionQueryParams<MODEL>, params: EndpointActionParams<any, QUERY, PARAMS> ) => Promise<CollectionQueryParams<MODEL>> | CollectionQueryParams<MODEL>;
+
+export type ReadModelSubscriptionCloseEmitterEvents = {close: string};
+
+export type ReadmodelSubscriptionManagerType<Model extends Document = any> = {
+  type: string,
+  startSubscription: ( projectionParams: CollectionQueryParams<Model>, req: RequestObject, res: ResponseObject ) => string | void;
+  notifySubscriptions: ( logger: LoggerType, collection: string ) => <T extends Document>( change: DatabaseChange<T>, subscriptionId?: string ) => void;
+  readModelSubscriptionCloseEmitter: TypedEventEmitter<ReadModelSubscriptionCloseEmitterEvents>
+  send: ( logger:LoggerType, id: string, change:DatabaseChange,collection: string, res: ResponseObject, data: string ) => void;
+};
+
+export type Query<MODEL extends Document=any, PARAMS extends Record<string, any>=any, QUERY extends Record<string, any>=any> = {
+  route?: string;
+  protocol?: 'http',
+  description?: string;
+  schemas?: {
+    query?: ObjectSchema<QUERY>
+    params?: ObjectSchema<PARAMS>
+  };
+  translator?: QueryParamsTranslator<MODEL, PARAMS, QUERY>;
+  subscriptions?: ReadmodelSubscriptionManagerType[];
+  transformers?: QueryTransformer<MODEL,PARAMS, QUERY>[],
+  queryHandler?: QueryHandler<MODEL, PARAMS, QUERY>;
+};
+
+export type EventProjectors<EVENTS extends Record<string, EventFactory>=any> = {
+  [Name in keyof EVENTS]: ( event: CommittedEvent<GetMessageType<EVENTS[Name]>> ) => Promise<any>
+};
+
+export type ReadModel<Model extends Document =any, EVENTS extends Record<string, EventFactory>=any> = EventHandler<EVENTS> & {
+  isReadModel: true;
+  schema: ObjectSchema<Model>;
+  queries: Query<Model>[];
+  eventProjectors?:EventProjectors<EVENTS>;
+  database?: DatabasePort;
+  collection?:string
+}
+
+export type ReadmodelChange<Model extends Document> = {
+  type: 'insert' | 'update' | 'delete',
+  data: Model
+}

package/src/eventsourcing/eventHandlersBuilder.ts

@@ -0,0 +1,42 @@
+import { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { A, O } from 'ts-toolbelt';
+import { Builder, CommittedEvent, EventFactory, EventHandler, EventMetadata, EventProjectors, GetBuilderType, GetMessageType, Message, Policy, PolicyResponse, Query, ReadModel, System } from '.';
+import { AppErrorInstance, DatabasePort, Document } from '..';
+
+export type GetCommandType<SYSTEM extends System | EventHandler, Name extends A.Key> = SYSTEM extends System
+  ? O.Path<SYSTEM, ['commands', Name]> extends ( Builder<infer T extends Object> ) ? O.Path<T, ['schema', 'type']> : O.Path<SYSTEM, ['commands', Name, 'schema', 'type']>
+  : O.Path<SYSTEM, ['commandHandler','commands', Name]> extends ( Builder<infer T extends Object> ) ? O.Path<T, ['schema', 'type']> : O.Path<SYSTEM, ['commandHandler','commands', Name, 'schema', 'type']>
+
+export type CommandInstance<Payload=any> = Message<Payload> & {
+  name: string;
+  id?: string;
+  metadata?: EventMetadata
+}
+
+export const createCommand = <Handler extends System | EventHandler> ( handler: Handler )=> <COMMAND extends keyof ( Handler extends System ? Handler['commands'] : O.Path<GetBuilderType<Handler>,['commandHandler','commands']> )>( command: COMMAND, id?: string, data?: GetCommandType<Handler, COMMAND>, metadata?: EventMetadata ): CommandInstance => {
+  return {
+    name: command as string,
+    ...( id ? { id } : {}),
+    ...( data ? { data } : {}),
+    ...( metadata ? { metadata } : {})
+  };
+};
+
+export type EventHandlerBuilderType<EVENTS extends Record<string, EventFactory>, T extends Policy | ReadModel> = Builder<EventHandler<EVENTS>> & {
+  eventHandler: EventHandler<EVENTS>,
+  withErrorHandlers: ( errorHandlers: {
+    [Name in keyof EVENTS]?: ( error: AppErrorInstance, event: CommittedEvent<GetMessageType<EVENTS[Name]>> ) => Promise<unknown>
+  }) => { build: () => T extends Policy ? Policy<T['commandHandler'], EVENTS> : T extends ReadModel ? ReadModel<T['schema'] extends ObjectSchema<infer MODEL extends Document> ? MODEL: Document, EVENTS> : any},
+};
+
+export type PolicyBuilderType<CommandHandler extends System, EVENTS extends Record<string, EventFactory>> = Builder<Policy<CommandHandler, EVENTS>> & EventHandlerBuilderType<EVENTS, Policy<CommandHandler, EVENTS>> & {
+  withEventHandlers: ( handlers: ( params: {createCommand: ReturnType<typeof createCommand<CommandHandler>>}) => {
+    [Name in keyof EVENTS]: ( event: CommittedEvent<GetMessageType<EVENTS[Name]>> ) => Promise<PolicyResponse|void>
+  }) => Pick<PolicyBuilderType<CommandHandler, EVENTS>, 'build' | 'withErrorHandlers'>,
+}
+
+export type ReadmodelBuilderType<Model extends Document, EVENTS extends Record<string, EventFactory>> = Builder<ReadModel<Model, EVENTS>> & EventHandlerBuilderType<EVENTS, ReadModel<Model, EVENTS>> & {
+  withDatabase: ( database: DatabasePort, collection?:string ) => ReadmodelBuilderType<Model, EVENTS>
+  withProjector: ( eventProjectors?: ( params: {database: DatabasePort, collection:string}) => EventProjectors<EVENTS> ) => ReadmodelBuilderType<Model, EVENTS>
+  withQuery: <PARAMS extends Record<string, any>, QUERY extends Record<string, any>>( query?: Query<Model, PARAMS, QUERY> ) => ReadmodelBuilderType<Model, EVENTS>
+}

package/src/eventsourcing/externalSystemBuilder.ts

@@ -0,0 +1,20 @@
+import { Builder, Command, CommandBuilderType, EventFactory, System } from '.';
+import { CreateEventType } from './utils';
+
+export type ExternalSystemBuilderType<Model, EVENTS extends Record<string, EventFactory>> = {
+
+  withCommandTemplate: ( command: Command ) => ExternalSystemBuilderType<Model, EVENTS>
+
+
+  /**
+   * This is the last function that builds the aggregate, the last function you'll call
+   */
+  withCommands: <
+    EVENT extends keyof EVENTS,
+    Commands extends Record<string, Command<EVENTS, EVENT, Model> | Builder<Command<EVENTS, EVENT, Model>>>
+  > ( commands: ( params: {
+    commandBuilder: CommandBuilderType<Model, EVENTS>,
+    createEvent: CreateEventType<System< any, EVENTS >>,
+  }) => Commands ) => System<Commands, EVENTS>
+  system: System<any, EVENTS>
+}

package/src/eventsourcing/index.ts

@@ -0,0 +1,111 @@
+import S, { BaseSchema, ObjectSchema } from '@bett3r-dev/jsonschema-definer';
+import { CollectionFilter, Document } from '../database';
+import { ResponseObject } from '../endpoints';
+import { PortEmitter } from '../ports';
+import { EventSourcingCommandHandlers, ExecuteCommandFunction, System } from './commandHandlers';
+import { EventHandler } from './eventHandlers';
+
+export * from './commandHandlers';
+export * from './eventHandlers';
+export * from './invariants';
+export * from './aggregateBuilder';
+export * from './commandBuilder';
+export * from './eventHandlersBuilder';
+export * from './externalSystemBuilder';
+
+export type Message<Payload, Name = string> = {
+  name?: Name,
+  data?: Payload,
+  description?: string
+}
+
+export type MessageSchema<Payload> = {
+  schema?: BaseSchema<Payload> | BaseSchema<Payload, false> | ObjectSchema | BaseSchema | null
+}
+
+export type EventInstance<Payload=any, Name=any> = Message<Payload, Name> & MessageSchema<Payload>
+
+export const Event = <Payload>( eventInstance: EventInstance<Payload> ): EventInstance<Payload> => eventInstance;
+
+export type EventFactory<Name=any, EventPayload = any> = () => EventInstance<EventPayload, Name>
+
+export const EventMetadataSchema = S.shape({
+  causationId: S.string().optional(),
+  correlationId: S.string().optional(),
+  user: S.any().optional()
+});
+
+export type EventMetadata = typeof EventMetadataSchema.type;
+
+export type EventToCommit<Payload = any> = {
+  name: string,
+  data?: Payload,
+  stream: string
+  metadata: EventMetadata
+};
+
+export type CommittedEvent<Payload = any> = EventToCommit<Payload> & {
+  id: number
+  timestamp: string
+  version: number
+}
+
+const ensureArray = ( maybeArray: any ) => Array.isArray( maybeArray ) ? maybeArray : [maybeArray];
+
+export const CommittedEventSchema = <T>( payloadSchema: BaseSchema<T>, names?: string | string[]) => S.shape({
+  id: S.number(),
+  name: ( names ? S.string().enum( ...ensureArray( names )) : S.string()),
+  timestamp: S.string().format( 'date-time' ),
+  data: payloadSchema,
+  version: S.number(),
+  stream: S.string(),
+  metadata: EventMetadataSchema,
+});
+
+export type GetMessageType<Payload> = Payload extends (()=> EventInstance<infer T> ) ? T : unknown
+
+export type Builder<T = any> = {
+  build:() => T
+}
+
+export type GetBuilderType<T> = T extends ( Builder<infer InnerT> ) ? InnerT : T
+
+//*******************************************
+// Readmodels
+//*******************************************
+// export type GetEventType<SYSTEM extends System, Name extends A.Key> = GetMessageType<O.Path<SYSTEM, ['events', Name]>>
+
+// export type GetErrorDataType<Payload> = Payload extends (()=> AppErrorType<infer T>) ? T : unknown
+// export type CreateErrorType<ERRORS extends Record<string, AppErrorFactory>> = (errors: ERRORS)=> <ERROR extends keyof ERRORS>(error: ERROR, params: Pick<AppErrorInstance<GetErrorDataType<ERRORS[ERROR]>>, 'details' | 'description'> ) => AppErrorInstance<GetErrorDataType<ERRORS[ERROR]>>;
+
+export type ReadModelSubscription<Model extends Document = any> = {
+  id: string;
+  res: ResponseObject;
+  filter: CollectionFilter<Model>[];
+};
+
+
+export type ReadStreamOptions = {
+  stream?: string,
+  direction?: 'forwards' | 'backwards',
+  from?: number,
+  fromVersion?: number,
+  limit?: number,
+  events?: string[],
+  before?: string,
+  after?: string,
+}
+
+export type ReadMultipleStreamOptions = Omit<ReadStreamOptions, 'stream'> & {
+  streams: string[],
+}
+
+export type EventSourcingType = Pick<EventSourcingCommandHandlers, 'executeCommand' | 'loadAggregateState' | 'loadStream'> & {
+  routeEventHandler: ( eventHandler: EventHandler | Builder<EventHandler> ) => void,
+  routeCommandHandler: ( commandHandler: System ) => void,
+
+  handleEvent: ( eventHandler: EventHandler, executeCommand: ExecuteCommandFunction ) => ( event: CommittedEvent ) => Promise<any>,
+  logEventsourcingRoutes: () => void
+}
+
+export type EventSourcingPort = PortEmitter & EventSourcingType;

package/src/eventsourcing/invariants.ts

@@ -0,0 +1,27 @@
+import { DatabaseOps, ErrorTypes, LoggerType } from '..';
+
+export type InvariantParams = {
+  errorName?: string;
+  errorType?: ErrorTypes
+  logger?: LoggerType;
+};
+
+export type ReadmodelInvariantComparisonOR = {
+  OR: ReadmodelInvariantComparison[]
+}
+
+export type ReadmodelInvariantComparisonAND = {
+  AND: ReadmodelInvariantComparison[]
+}
+
+export type ReadmodelInvariantComparisonInstance = {
+  path: string;
+  readmodelPath: string;
+  op: DatabaseOps;
+};
+
+export type ReadmodelInvariantComparison = Partial<
+& ReadmodelInvariantComparisonOR
+& ReadmodelInvariantComparisonAND
+& ReadmodelInvariantComparisonInstance
+>

package/src/eventsourcing/utils.ts

@@ -0,0 +1,4 @@
+import { CommittedEvent, EventFactory, EventHandler, GetMessageType, System } from '.';
+import { O } from 'ts-toolbelt';
+
+export type CreateEventType<Handler extends System | EventHandler> = <EVENT extends keyof O.Path<Handler, ['events']>>( event: EVENT, data?: GetMessageType<Handler['events'][EVENT]>, committedEvent?: Partial<Omit<CommittedEvent, 'data' | 'name'>> ) => EventFactory<EVENT, GetMessageType<Handler['events'][EVENT]>>;

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './authentication';
+export * from './cache';
+export * from './clusterAdministration';
+export * from './configuration';
+export * from './database';
+export * from './endpoints';
+export * from './evenstore';
+export * from './eventsourcing';
+export * from './infrastructure';
+export * from './logger';
+export * from './outboxManager';
+export * from './ports';
+export * from './routesAuth';
+export * from './typedEventEmitter';
+export * from './validation';

package/src/infrastructure.ts

@@ -0,0 +1,41 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { OpenAPIV3_1 } from 'openapi-types';
+import { StructureServiceType } from './clusterAdministration';
+import { AdapterBase } from './ports';
+
+export const InfrastructureConfigSchema = S.shape({
+  infrastructureLeaderRandomBackoff: S.number().default( 1000 ).optional()
+});
+export type InfrastructureConfigType = typeof InfrastructureConfigSchema.type;
+
+export type EnvironmentServiceType = {
+  openApi: OpenAPIV3_1.Document,
+  service: string,
+  openApiEndpoint?: string,
+  instances: {host: string, timeRunning: number}[],
+  port: number,
+}
+
+export type InfrastructureServiceType = Omit<StructureServiceType, 'hosts'> & {
+  instances: {host: string, timeRunning: number}[],
+  service: string,
+}
+export type InfrastructureThisServiceType = InfrastructureServiceType & {
+  leadershipRank: number;
+  host: string;
+}
+
+export type InfrastructureAdapterType = AdapterBase & {
+  getServices: () => Promise<EnvironmentServiceType[]>;
+  // addService: (baseService: string, modules: string[]) => Promise<void>;
+  // removeService: (service: string) => Promise<void>;
+  scaleService: ( service: string, replicasCount: number ) => Promise<void>;
+  listenForInfrastructureChanges: ( callback: ( event: 'destroy' | 'create', service: EnvironmentServiceType ) => void ) => void;
+  reloadLoadBalancer: () => Promise<void>;
+};
+
+export type InfrastructurePortType = InfrastructureAdapterType & {
+  getServicesOpenApiDocumentation: () => Record<string, OpenAPIV3_1.Document>;
+  getThisServiceInfo: () => InfrastructureThisServiceType;
+  start: InfrastructureAdapterType['start'];
+}

package/src/logger.ts

@@ -0,0 +1,45 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { AdapterBase } from './ports';
+
+export const LoggerConfigSchema = S.shape({
+  logLevel: S.string().enum( 'silly', 'debug', 'log', 'info', 'warn', 'error' ).optional(),
+  modulesWhitelist: S.array().items( S.string()).optional(),
+  modulesBlacklist: S.array().items( S.string()).optional()
+}).optional();
+export type LoggerConfig = typeof LoggerConfigSchema.type;
+
+export type LogLevels = 'silly'| 'debug'| 'log'| 'info'| 'warn'| 'error';
+
+export const LogLevelMap = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  log: 3,
+  debug: 4,
+  silly: 5,
+};
+export const LevelLogMap: Record<number, LogLevels> = {
+  0: 'error',
+  1: 'warn',
+  2: 'info',
+  3: 'log',
+  4: 'debug',
+  5: 'silly',
+};
+
+export type LoggerAdapter = AdapterBase & {
+  log: ( originalArgs: any[], level: LogLevels , module: string ) => void
+}
+
+export type LoggerPort = {
+  createLoggerInstance: ( module: string ) => LoggerType
+}
+
+export type LoggerType = {
+  silly: ( ...args: any[])=>void
+  debug: ( ...args: any[])=>void
+  log: ( ...args: any[])=>void
+  info: ( ...args: any[])=>void
+  warn: ( ...args: any[])=>void
+  error: ( ...args: any[])=>void
+}

package/src/outboxManager.ts

@@ -0,0 +1,36 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { InfrastructureConfigSchema } from '@bett3r-dev/pv3-types';
+import { CommittedEvent } from '@bett3r-dev/pv3-types';
+import { ClusterStructureConfigSchema } from '@bett3r-dev/pv3-types';
+
+export const UdpConfigSchema = S.shape({
+  port: S.number().default( 16706 ).optional(),
+  multicastAddress: S.string().default( '224.0.1.50' ).optional(),
+  ttl: S.number().optional()
+});
+export type UdpConfigType = typeof UdpConfigSchema.type;
+
+
+export const AdminServicesConfigSchema = S.shape({
+  udp: UdpConfigSchema.optional().default({}),
+  structure: ClusterStructureConfigSchema.optional().default({}),
+  infrastructure: InfrastructureConfigSchema.optional().default({}),
+  metricsInterval: S.number().optional().default( 1000 )
+});
+export type AdminServicesConfigType = typeof AdminServicesConfigSchema.type;
+
+export type OutboxManagerType = {
+  start: ( activateDiscoveredSubscriptions?: boolean ) => Promise<void>,
+  stop: () => Promise<void>
+}
+
+export type TcpEventMessageRequest = {
+  endpoint: string,
+  event: CommittedEvent
+}
+export type TcpEventMessageResponse = {
+  id: number,
+  status: number,
+  error?: string
+}
+

package/src/ports.ts

@@ -0,0 +1,42 @@
+import { AuthenticationPort } from './authentication';
+import { CachePort } from './cache';
+import { ConfigurationPort } from './configuration';
+import { DatabasePort } from './database';
+import { EndpointsPort } from './endpoints';
+import { EventStorePort } from './evenstore';
+import { EventSourcingPort } from './eventsourcing';
+import { InfrastructurePortType } from './infrastructure';
+import { LoggerPort } from './logger';
+import { TypedEventEmitter } from './typedEventEmitter';
+
+export type PortEmitterEvents = {
+  started: void,
+}
+
+/**
+ * Base type for Porst that exposes an EventEmitter interface for handling the 'started' event.
+ */
+export type PortEmitter = {
+  isStarted: boolean,
+  emitter: TypedEventEmitter<PortEmitterEvents>,
+  onStarted: ( fn: () => void ) => void
+};
+
+export type AdapterBase<T = any> = {
+  name: string,
+  _adapter: () => T,
+  start: () => Promise<void>,
+  stop: () => Promise<void>,
+}
+
+export type Ports = {
+  configuration: ConfigurationPort,
+  logger: LoggerPort,
+  cache: CachePort,
+  endpoints: EndpointsPort,
+  database: DatabasePort,
+  eventstore: EventStorePort,
+  eventsourcing: EventSourcingPort,
+  authentication: AuthenticationPort,
+  infrastructure: InfrastructurePortType
+}

package/src/routesAuth.ts

@@ -0,0 +1,58 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { METHODS } from 'http';
+import { Event } from './eventsourcing';
+import { Ports } from './ports';
+import { ClusterRoutesConfigType } from './clusterAdministration';
+
+export const ClusterRoutesAggregateSchema = S.shape({
+  method: S.string().enum( ...METHODS.map( m=>m.toLocaleLowerCase())),
+  id: S.string(),
+  isPublic: S.boolean().optional(),
+  roles: S.array().items( S.string()).optional(),
+});
+export type ClusterRoutesAggregateType = typeof ClusterRoutesAggregateSchema.type;
+
+export type RouteManagerEndpointAuth = ClusterRoutesAggregateType;
+
+export const UpsertRouteCommandSchema = S.shape({}).additionalProperties( ClusterRoutesAggregateSchema );
+export const DeleteRouteCommandSchema = S.array().items( S.string());
+
+export const ClusterManagerEvents = {
+  RoutesUpserted: () => Event({
+    schema: UpsertRouteCommandSchema
+  }),
+  RouteDeleted: () => Event({
+    schema: DeleteRouteCommandSchema
+  })
+};
+
+
+/**
+ * Represents the place where the routes are stored and consumed by an authorization server.
+ * Usually this store will live in a Cache and holds all the endpoints of the application
+ * and their access requirements. That means if the resource is public, or what roles can have access.
+ */
+export type RoutesAuthManagerType = {
+  getAllRoutes: () => Promise<RouteManagerEndpointAuth[]>;
+  getRoute: ( method:string, route: string ) => Promise<Pick<RouteManagerEndpointAuth, 'isPublic'|'roles'> | false>
+  upsertRoute: ( endpoint: RouteManagerEndpointAuth ) => Promise<RouteManagerEndpointAuth>;
+  subscribeToRoutesAuthChanges: ( onStructureChanges: ( change: ClusterRoutesAggregateType ) => void ) => Promise<{ unsubscribe: () => void }>;
+  stop: () => Promise<void>;
+}
+
+export type RouteAuthManagerFactory = ( ports: Pick<Ports, 'database'|'eventstore'>, config: ClusterRoutesConfigType, eventstore?: Ports['eventstore']) => RoutesAuthManagerType
+
+// Endpoints Schemas
+export const EndpointMarkedAsPublicSchema = S.shape({
+  method: S.string().enum( ...METHODS.map( m=>m.toLocaleLowerCase())),
+  id: S.string(),
+  isPublic: S.boolean().optional()
+});
+export type EndpointMarkedAsPublic = typeof EndpointMarkedAsPublicSchema.type
+
+export const EndpointRolesUpsertedSchema = S.shape({
+  method: S.string().enum( ...METHODS.map( m=>m.toLocaleLowerCase())),
+  id: S.string(),
+  roles: S.array().items( S.string()),
+});
+export type EndpointRolesUpserted = typeof EndpointRolesUpsertedSchema.type

package/src/typedEventEmitter.ts

@@ -0,0 +1,73 @@
+import { EventEmitter as NativeEventEmitter } from 'events';
+
+declare module 'events' {
+  interface EventEmitter {
+    on<K extends keyof any>( event: K, listener: ( ...args: any[]) => void ): this;
+    emit<K extends keyof any>( event: K, ...args: any[]): boolean;
+  }
+}
+
+export class TypedEventEmitter<T> {
+
+  private emitter = new NativeEventEmitter();
+
+  on<K extends keyof T>( event: K, listener: ( arg: T[K]) => void ): this {
+    this.emitter.on( event as string, listener );
+    return this;
+  }
+
+  emit<K extends keyof T>( event: K, arg?: T[K]): boolean {
+    return this.emitter.emit( event as string, arg );
+  }
+
+  off<K extends keyof T>( event: K, listener: ( arg: T[K]) => void ): this {
+    this.emitter.off( event as string, listener );
+    return this;
+  }
+
+  once<K extends keyof T>( event: K, listener: ( arg: T[K]) => void ): this {
+    this.emitter.once( event as string, listener );
+    return this;
+  }
+
+  removeAllListeners<K extends keyof T>( event?: K ): this {
+    this.emitter.removeAllListeners( event as string );
+    return this;
+  }
+
+  listeners<K extends keyof T>( event: K ): Function[] {
+    return this.emitter.listeners( event as string );
+  }
+
+  rawListeners<K extends keyof T>( event: K ): Function[] {
+    return this.emitter.rawListeners( event as string );
+  }
+
+  listenerCount<K extends keyof T>( event: K ): number {
+    return this.emitter.listenerCount( event as string );
+  }
+
+  prependListener<K extends keyof T>( event: K, listener: ( arg: T[K]) => void ): this {
+    this.emitter.prependListener( event as string, listener );
+    return this;
+  }
+
+  prependOnceListener<K extends keyof T>( event: K, listener: ( arg: T[K]) => void ): this {
+    this.emitter.prependOnceListener( event as string, listener );
+    return this;
+  }
+
+  eventNames(): ( keyof T )[] {
+    return this.emitter.eventNames() as ( keyof T )[];
+  }
+
+  getMaxListeners(): number {
+    return this.emitter.getMaxListeners();
+  }
+
+  setMaxListeners( n: number ): this {
+    this.emitter.setMaxListeners( n );
+    return this;
+  }
+
+}