@bett3r-dev/pv3-types 1.0.0 → 1.4.0

package/src/eventsourcing/commandBuilder.ts

@@ -1,64 +0,0 @@
-//*******************************************
-// Command Builder
-//*******************************************
-
-import { BaseSchema } from '@bett3r-dev/jsonschema-definer';
-import { Command, CommandCommitFunction, CommandErrorHandlerFunction, CommandFormatFunction, CommandHandlerFunction, CommandLoadFunction, EventFactory, InvariantType } from '.';
-
-export type CommandBuilderFromSchemaType<Model, EVENTS extends Record<string, EventFactory>, EVENT extends keyof EVENTS, CommandPayload> = {
-  /**
-   * Loads the streams from the aggregate. If the Command Handler is an Aggregate the fuction will be ignored.
-   * Default Implementation:
-   * ```ts
-   *  loadAggregateState(state.commandHandler, (state.streams || []), options)
-   *    .then(u.ensureArray)
-   *    .then((aggregateState) => ({...state, aggregateState} as CommandHandlerState));
-   * ```
-   */
-  withLoadFunction: ( loadFunction: CommandLoadFunction<Model, CommandPayload> ) => CommandBuilderFromSchemaType<Model, EVENTS, EVENT, CommandPayload>
-  /**
-   * Commits the new event/events to the store
-   * DefaultImplementation:
-   * ```ts
-   * const defaultCommit = (state: CommandHandlerState) =>
-   *   commitCommands(state);
-   * ```
-   */
-  withCommitFunction: ( commitFunction: CommandCommitFunction<Model, CommandPayload> ) => CommandBuilderFromSchemaType<Model, EVENTS, EVENT, CommandPayload>
-  withResultFormatFunction: ( resultFormatFunction: CommandFormatFunction<Model, CommandPayload> ) => CommandBuilderFromSchemaType<Model, EVENTS, EVENT, CommandPayload>
-  withInvariant: ( invariant: InvariantType<Model, CommandPayload> | (( state: Model, data: CommandPayload ) => Promise<void> )) => CommandBuilderFromSchemaType<Model, EVENTS, EVENT, CommandPayload>,
-  produces: <EVENT extends keyof EVENTS>( events: EVENT[]) => {
-    withHandler: <USER, StateModel = Model>( handler: CommandHandlerFunction<StateModel, CommandPayload, EVENTS, EVENT, USER> ) => {
-      build: () => Command<EVENTS, EVENT, Model, CommandPayload>,
-      withErrorHandler: ( errorHandler: CommandErrorHandlerFunction<CommandPayload> ) => {
-        build: () => Command<EVENTS, EVENT, Model, CommandPayload>
-      }
-    },
-    withErrorHandler: ( errorHandler: CommandErrorHandlerFunction<CommandPayload> ) => {
-      build: () => Command<EVENTS, EVENT, Model, CommandPayload>
-    },
-    build: () => Command<EVENTS, EVENT, Model, CommandPayload>
-  }
-}
-
-export type CommandBuilderInstance<Model, EVENTS extends Record<string, EventFactory>, EVENT extends keyof EVENTS, CommandPayload> = {
-  withDescription: ( description: string ) => CommandBuilderInstance<Model, EVENTS, EVENT, CommandPayload>
-  /** Specify where to find the id of the aggregate when the command has no Id in the Params of the request
-   *
-   * suppose a structure of
-   * ```ts
-   * {
-   *    ISC: 'QWERASDFZXCV',
-   *    marketing: { promoId: '1q2w3e'}
-   *    products: [{id: 1}, {id:2}]
-   * }
-   * ```
-   * Some examples are: `ISC`, `warehouse.id`.
-   * In the case of an array use a Dollar sign `$`.
-   * `products.$.id`
-   */
-  withDataPropertyId: ( dataPath: string ) => CommandBuilderInstance<Model, EVENTS, EVENT, CommandPayload>
-  withSchema: <CommandPayload>( schema: BaseSchema<CommandPayload> ) => CommandBuilderFromSchemaType<Model, EVENTS, EVENT, CommandPayload>,
-}
-
-export type CommandBuilderType<Model = any, EVENTS extends Record<string, EventFactory>=any, EVENT extends keyof EVENTS=any, CommandPayload=any> = ( init?: Omit<Command<EVENTS, EVENT, CommandPayload, Model>, 'handler' | 'events' | 'schema'> ) => CommandBuilderInstance<Model, EVENTS, EVENT, CommandPayload>

package/src/eventsourcing/commandHandlers.ts

@@ -1,137 +0,0 @@
-import S, { BaseSchema } from '@bett3r-dev/jsonschema-definer';
-import { Builder, CommittedEvent, EventFactory, EventMetadata, GetMessageType, ReadStreamOptions } from '.';
-import { AppErrorInstance, AppErrorType } from '../validation';
-import { DatabasePort } from '../database';
-import { EndpointActionParams, EndpointActionParamsContext } from '../endpoints';
-
-export type CommandHandlerState<Events = Record<string, EventFactory>, Payload=any, Model = any, USER=any> = {
-  commandHandler: Aggregate | System,
-  command: Command,
-  stream: string,
-  data: Payload,
-  query: {id?: string},
-  params: Record<string, any>,
-  context: Partial<EndpointActionParamsContext<USER>>
-  events: Events[keyof Events][],
-  state: Model,
-  committedEvents?: Array<CommittedEvent>,
-  metadata?: EventMetadata
-  expectedVersion?: number
-}
-
-export type CommandExecutionResponse<Model = unknown> = {
-  state?: Model,
-  events: CommittedEvent[]
-}
-
-export type ExecuteCommandFunction = <SYSTEM extends System, COMMAND extends keyof SYSTEM['commands']>( commandHandler:SYSTEM, commandName: COMMAND ) => ( params: Partial<EndpointActionParams> ) => Promise<unknown>;
-export type CommandLoadFunction<Model=any, Payload=any> = ( state: CommandHandlerState<Model,Payload>, options?: ReadStreamOptions, initialState?: Model ) => Promise<CommandHandlerState<Model, Payload>>
-export type CommandCommitFunction<Model=any, Payload=any> = ( state: CommandHandlerState<Model,Payload> ) => Promise<CommandHandlerState<Model, Payload>>
-export type CommandFormatFunction<Model=any, Payload=any> = ( handlerState: CommandHandlerState<Model, Payload> ) => Promise<CommandExecutionResponse<Model>>
-
-export type CommandHandlerFunction<Model=any, CommandPayload=unknown, Events extends Record<string, EventFactory<EVENT>>=any, EVENT extends keyof Events=any, USER = any> = ( state: Model extends undefined ? null : Model, data: CommandPayload, aggregateState: CommandHandlerState<Events, CommandPayload, any, USER> ) => Promise<EventFactory<EVENT, GetMessageType<Events[EVENT]>>[]> | EventFactory<EVENT, GetMessageType<Events[EVENT]>>[]
-
-export type CommandErrorHandlerFunction<CommandPayload=unknown> = ( error: AppErrorInstance, data: CommandPayload ) => Promise<any>
-
-export type Command<EVENTS extends Record<string, EventFactory<EVENT>>=any, EVENT extends keyof EVENTS=any, SystemModel=any, CommandPayload=any> = {
-  schema: BaseSchema<CommandPayload>
-  handler: CommandHandlerFunction<SystemModel, CommandPayload, EVENTS, EVENT>
-  onErrorHandler?: CommandErrorHandlerFunction<CommandPayload>,
-  dataPropertyId?: string,
-  name?: string,
-  actors?: string[]
-  description?: string
-  multipartProperties?: string[],
-  events?: EVENT[],
-  invariants?: InvariantType[]
-  load?: CommandLoadFunction,
-  commit?: CommandCommitFunction,
-  format?: CommandFormatFunction
-}
-
-export type InvariantType<Model=any, Payload=any> = {
-  events?: string[],
-  rejects: AppErrorType[],
-  beforeLoad?: ( state: CommandHandlerState<any, Payload, Model> ) => Promise<CommandHandlerState<any, Payload, Model>>
-  check: ( commandHandlerState: CommandHandlerState<any, Payload, Model> ) => Promise<CommandHandlerState<any, Payload, Model> | void> | void | CommandHandlerState<any, Payload, Model>
-}
-
-//*******************************************
-// Systems
-//*******************************************
-
-export const SystemGetQuerySchema = S.shape({
-  stream: S.string(),
-  names: S.array().items( S.string()).optional(),
-  from: S.number().optional(),
-  limit: S.number().optional(),
-  backward: S.boolean().optional(),
-  after: S.string().format( 'date-time' ).optional(),
-  before: S.string().format( 'date-time' ).optional(),
-});
-export type SystemGetQueryType = typeof SystemGetQuerySchema.type;
-export const SystemEndpointParamsSchema = S.shape({
-  id: S.string().description( 'id for the aggregate' )
-});
-export const CommandEndpointQuerySchema = S.shape({
-  expectedVersion: S.string().optional(),
-  causationId: S.string().optional(),
-  correlationId: S.string().optional(),
-});
-
-export type OnValidationErrorFunctionType = Function;
-
-export type System<Commands extends Record<string, Command | Builder<Command>>=any, EVENTS extends Record<string, EventFactory>=any> = {
-  name: string,
-  events: EVENTS,
-  isStreamable?: boolean,
-  isAggregate?: boolean,
-  isEventsourced?: boolean,
-  commands: Commands,
-  templateCommand: Command
-}
-
-//*******************************************
-// Aggregates
-//*******************************************
-
-export type AggregateReducedState<Model = any> = {state: Model, lastEvent?: Partial<Pick<CommittedEvent, 'id'|'version'>>}
-
-export type EventReducers<EVENTS extends Record<string, EventFactory>=any, Model=any> = {
-  [Name in keyof EVENTS]: ( state: Model, data: GetMessageType<EVENTS[Name]>, metadata: EventMetadata ) => Partial<Model>
-}
-
-export type Aggregate<Commands extends Record<string, Command | Builder<Command>>=any, EVENTS extends Record<string, EventFactory>=any, Model=any> = System<Commands, EVENTS> & {
-  schema: BaseSchema<Model>
-  outboxDatabase?: DatabasePort,
-  outboxCollection?: string,
-  initialValue: () => Partial<Model> | null | undefined,
-  eventReducers: EventReducers<EVENTS, Model>
-}
-
-//*******************************************
-// Command Handlers
-//*******************************************
-
-export type EventSourcingCommandHandlers = {
-  loadStream: (
-    stream: string,
-    options?: ReadStreamOptions
-  ) => Promise<CommittedEvent[] | undefined>;
-  loadAggregateState: (
-    system: System,
-    stream?: string,
-    options?: ReadStreamOptions
-  ) => Promise<Record<string, any> | null>;
-  executeCommand: ExecuteCommandFunction;
-  registerCommandHandlerGetEndpoints: (
-    aggregateOrSystem: Aggregate | System,
-    name?: string
-  ) => string[];
-  registerCommandHandlerPostEndpoints: (
-    aggregateOrSystem: ( Aggregate | System ) & {
-      events: Record<string, EventFactory>;
-    },
-    name?: string
-  ) => Record<string, string>;
-};

package/src/eventsourcing/eventHandlers.ts

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

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

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

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

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

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

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

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

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

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