@bett3r-dev/pv3-types 1.0.0

package/src/database.ts

@@ -0,0 +1,157 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { AdapterBase, PortEmitter } from './ports';
+
+export type Document = {
+  id: string|number,
+  [key: string]: any
+}
+
+export type IndexOptions = {
+  isUnique: boolean
+}
+
+export type DatabaseOps =
+  | 'eq'
+  | 'neq'
+  | 'lt'
+  | 'gt'
+  | 'lte'
+  | 'gte'
+  | 'in'
+  | 'nin'
+  | 'contains'
+  | 'notContains'
+  | 'some'
+  | 'none'
+  | 'every'
+  | 'exists'
+  | 'notExists';
+
+export const filterOpMap = {
+  eq: <T>( a: T, b: T ) => a === b,
+  neq: <T>( a: T, b: T ) => a !== b,
+  lt: <T>( a: T, b: T ) => a < b,
+  gt: <T>( a: T, b: T ) => a > b,
+  lte: <T>( a: T, b: T ) => a <= b,
+  gte: <T>( a: T, b: T ) => a >= b,
+  in: <T>( a: T, b: T[]) => b.includes( a ),
+  nin: <T>( a: T, b: T[]) => !b.includes( a ),
+  contains: <T>( a: T[], b: T ) => a.includes( b ),
+  notContains: <T>( a: T[], b: T ) => !a.includes( b ),
+  some: <T>( a: T[], b: T[]) => a.some( x=> b.includes( x )),
+  none: <T>( a: T[], b: T[]) => !a.some( x=> b.includes( x )),
+  every: <T>( a: T[], b: T[]) => a.every( x=> b.includes( x )),
+  exists: <T>( a:T ) => !!a,
+  notExists: <T>( a:T ) => !a
+};
+
+export const CollectionFilterSchema = S.shape({
+  field: S.string(),
+  op: S.enum([ 'eq', 'neq', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'contains', 'notContains', 'some', 'every', 'exists', 'notExists' ]),
+  value: S.any()
+});
+
+export type CollectionFilterOR<T extends Document = any> = {
+  OR: CollectionFilter<T>[]
+}
+
+export type CollectionFilterAND<T extends Document = any> = {
+  AND: CollectionFilter<T>[]
+}
+
+export type CollectionFilterInstance<Model extends Document> = {
+  field: keyof Model;
+  op: DatabaseOps;
+  value: any;
+};
+
+export type CollectionFilter<T extends Document = any> = Partial<
+& CollectionFilterOR<T>
+& CollectionFilterAND<T>
+& CollectionFilterInstance<T>
+>
+
+export const CollectionSortSchema = S.shape({
+  field: S.string(),
+  direction: S.enum([ 'asc', 'desc' ])
+});
+
+export type CollectionSort<Model extends Document> = {
+  field: keyof Model;
+  direction?: 'asc' | 'desc';
+};
+
+export const CollectionQueryParamsSchema = S.shape({
+  sort: S.array().items( CollectionSortSchema ).optional(),
+  filter: S.array().items( CollectionFilterSchema ).optional(),
+  limit: S.number().optional(),
+  after: S.string().optional(),
+  select: S.array().items( S.string()).optional()
+});
+
+export type CollectionQueryParams<Model extends Document> = {
+  id?: string | number;
+  limit?: number;
+  after?: string | number;
+  sort?: CollectionSort<Model>[];
+  filter?: CollectionFilter<Model>[];
+  select?: keyof Model | ( keyof Model )[]
+};
+
+export type CollectionOperations<Model extends Document> = {
+  readById: ( id: string|number ) => Promise<Model|null>
+  query: ( params: CollectionQueryParams<Model> ) => Promise<Model[]>,
+  forEach: ( params: CollectionQueryParams<Model>, callback: ( record: Model, stop: () => void ) => void | Promise<void> ) => Promise<void>,
+  upsert: ( id: string | number, data: Partial<Model> ) => Promise<Model>,
+  destroyById: ( id:string | number ) => Promise<void>,
+  createMany: ( documents: Model[]) => Promise<Model[]>,
+  updateMany: ( filter: CollectionFilter<Model>[], data: Partial<Model> ) => Promise<Model[]>,
+  destroyMany: ( filter: CollectionFilter<Model>[]) => Promise<number>,
+  atomicIncrement: ( name: string, filter?: CollectionFilter<Model>, amount?: number ) => Promise<number>,
+}
+
+export type DatabaseChange<Model extends Document = any> = {
+  changeType: 'insert'|'update'|'delete',
+  data?: Model,
+  previous?: Model,
+}
+
+export type Collection<Model extends Document> = CollectionOperations<Model> & {
+  ensureIndex: ( properties: string[], options?: Partial<IndexOptions> ) => Promise<void>,
+  destroyIndex: ( properties: string[]) => Promise<void>,
+  watch: ( changeTypes: ( 'insert'|'update'|'delete' )[], onData: ( data: DatabaseChange<Model> ) => void, onError?: ( e: Error ) => void ) => Promise<{
+    close: () => void
+  }>;
+}
+
+// export type DatabaseTransaction = {
+//   commitTransaction: <Model extends Document>( docs?: Model[]) => Promise<Model[] | void>,
+//   rollbackTransaction: ( error: Error ) => Promise<void>,
+//   getCollection: <Model extends Document>( collection:string ) => CollectionOperations<Model>
+//   _transaction: () => any
+// }
+
+
+/**
+ * @category Main Types
+*/
+export type DatabaseTransaction = {
+  getCollection: <Model extends Document>( collection: string ) => CollectionOperations<Model>
+}
+/**
+ * @category Main Types
+*/
+export type DatabaseType = {
+  getCollection: <Model extends Document>( name:string ) => Collection<Model>
+  initTransaction: <Result = any>( operations: ( getCollection: <Model extends Document>( collection: string ) => CollectionOperations<Model> ) => Promise<Result | undefined>, retryBackoff?: number, options?: any ) => Promise<Result>;
+}
+/**
+ * @category Main Types
+*/
+export type DatabasePort = PortEmitter & DatabaseType & {
+  _adapter: DatabaseAdapter
+};
+/**
+ * @category Main Types
+*/
+export type DatabaseAdapter<T = any> = DatabaseType & AdapterBase<T>;

package/src/endpoints.ts

@@ -0,0 +1,198 @@
+import S, { BaseSchema, ObjectSchema, mergeSchemas } from '@bett3r-dev/jsonschema-definer';
+import { METHODS } from 'http';
+import { JSONSchema7 } from 'json-schema';
+import { AddressInfo } from 'net';
+import { OpenAPIV3_1 } from 'openapi-types';
+import { AdapterBase, PortEmitter } from './ports';
+
+const CorsOptions = S.shape({
+  origin: S.string().optional(),
+  methods: S.string().enum( ...METHODS ).optional(),
+  allowedHeaders: S.anyOf( S.string(), S.array().items( S.string())).optional(),
+  exposedHeaders: S.anyOf( S.string(), S.array().items( S.string())).optional(),
+  credentials: S.boolean().optional(),
+  maxAge: S.number().optional(),
+  preflightContinue: S.boolean().optional(),
+  optionsSuccessStatus: S.number().optional(),
+});
+
+const CompressionOptions = S.shape({
+  chunkSize: S.number().optional(),
+  level: S.number().optional(),
+  memLevel: S.number().optional(),
+  strategy: S.number().optional(),
+  threshold: S.number().optional(),
+  windowBits: S.number().optional(),
+});
+
+export const HttpConfigSchema = S.shape({
+  port: S.number().optional(),
+  cookie: S.shape({
+    enabled: S.boolean()
+  }).additionalProperties( true ).optional(),
+  listeningEnabled: S.boolean().optional(),
+  cors: mergeSchemas( CorsOptions, S.shape({
+    enabled: S.boolean()
+  })).additionalProperties( true ).optional(),
+  compression: mergeSchemas( CompressionOptions, S.shape({
+    enabled: S.boolean()
+  })).additionalProperties( true ).optional(),
+  metrics: S.shape({
+    enabled: S.boolean().optional(),
+    httpRequestDurations: S.shape({
+      enabled: S.boolean().optional(),
+      buckets: S.array().items( S.number()).optional()
+    }).optional()
+  }).optional()
+}).optional();
+
+export type HttpConfig = typeof HttpConfigSchema.type
+
+
+export type EndpointsFetchInterfaceResponse<T = any> = Pick<Response, 'ok'> & {
+  json: () => Promise<T>;
+  text: () => Promise<T>;
+}
+
+export type RequestObject<RAW extends ReadableStream = any> = {
+  type: 'string',
+  raw?: RAW,
+  body: unknown,
+  query: unknown,
+  params: unknown,
+  method: string,
+  route: string,
+  filePaths: Record<string, string>,
+  headers: Record<string,string | string[]>
+}
+
+export type ResponseObject<RAW extends WritableStream = any> = {
+  raw?: RAW,
+  send: ( payload: unknown ) => unknown
+  header: ( key: string, value: any ) => ResponseObject
+}
+
+export type EndpointActionParamsContext<USER=any> = {
+  res:ResponseObject
+  req:RequestObject,
+  endpoint: Endpoint,
+  user: USER,
+  token?: string;
+  [key:string]: any
+}
+
+export type EndpointActionParams<BODY=any, QUERY=any, PARAMS=any, USER=any> = {
+  query: QUERY
+  params: PARAMS
+  body: BODY
+  context: Partial<EndpointActionParamsContext<USER>>
+}
+
+export type EndpointSchemas<BODY, QUERY, PARAMS> = {
+  body?: BaseSchema<BODY>,
+  query?: BaseSchema<QUERY>,
+  params?: BaseSchema<PARAMS>,
+  headers?: ObjectSchema,
+  responses?: Record<number, {schema: BaseSchema , name: string}[]>,
+  errors?: Record<number, {schema: BaseSchema, name: string}[]>,
+};
+
+export type EndpointAction<BODY=any, RETURN=any, QUERY=any, PARAMS=any> = ( params: EndpointActionParams<BODY, QUERY, PARAMS> ) => Promise<RETURN>
+
+export type Endpoint<BODY=any, RETURN=any, QUERY=any, PARAMS=any> = {
+  route: string;
+  action: EndpointAction<BODY, RETURN, QUERY, PARAMS>,
+  module: string;
+  name?: string;
+  description?: string;
+  schemas?: EndpointSchemas<BODY, QUERY, PARAMS>;
+  shouldValidate?: boolean;
+  responseContentType?: string;
+  tags?: string[]
+  //REVIEW: Protocol Specific
+  method?: 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS';
+  //REVIEW: Protocol Specific
+  multipartProperties?: string[],
+}
+
+export const EndpointSchema = S.shape({
+  route: S.string().pattern( /^\/.*/ ),
+  action: S.any(),
+  module: S.string().optional(),
+  name: S.string().optional(),
+  description: S.string().optional(),
+  schemas: S.any().optional(),
+  tags: S.array().items( S.string()).optional(),
+  multipartProperties: S.array().items( S.string()).optional(),
+  method: S.string().enum( 'DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS' ).optional(),
+});
+
+export type InjectHandlerContext<REQ = any, RES = any> = {
+  request: REQ,
+  response: RES,
+  callInactiveEvent: () => void
+  callStartEvent: () => void
+}
+
+export type CloudFunctionsAdapter = {
+  /**
+   * Function used when working on a cloud function environment. Internal function.
+   * @param context {InjectHandlerContext}
+   * @returns {Promise<void>}
+   */
+  injectHandler: ( context: InjectHandlerContext )=> Promise<void>,
+  /**
+   * This method is called when the server is starting a new Events Related connection. Things like SSE, WS, TCP, etc.
+   * It is used internally in cloud function environments to keep the function alive.
+   * @returns {void}
+   */
+  callEventConnectionsActive: () => void,
+  /**
+   * This method is called when the server has no more Events Related connection. Things like SSE, WS, TCP, etc.
+   * It is used internally in cloud function environments to mark the function as idle so it can be killed.
+   * @returns {void}
+   */
+  callEventConnectionsInactive: () => void,
+}
+
+export type MetricBaseType = {
+  name: string,
+  help: string,
+  labelNames: string[],
+}
+export type CounterMetricsType = MetricBaseType & {}
+export type GaugeMetricsType = MetricBaseType & {}
+
+export type EndpointsAdapter<T = any> = AdapterBase<T> & Partial<CloudFunctionsAdapter> & {
+  adapterType?: 'httpHandler',
+  getServerAddress?: () => AddressInfo;
+  registerOpenApi?: ( openapi: Record<string, any> ) => void;
+  registerOpenApiDocument?: () => void;
+  registerEndpoint: ( endpoint: Endpoint ) => Endpoint;
+  serveStaticDirectory?: ( path: string, endpoint?: string ) => void;
+  onServicesDirectorySet?: ( callback: ( serviceDirectory: Record<string, string> ) => void ) => void;
+  metrics?: {
+    addCounter: ( metric: CounterMetricsType ) => ( labels: string[]) => void
+    addGauge: ( metric: CounterMetricsType ) => ( labels: string[], value: number ) => void
+  }
+}
+
+export type EndpointsType = CloudFunctionsAdapter & {
+  getEndpoints?(): Endpoint[],
+  setServiceSupportedModules: ( modules: Record<string, string[]> ) => void;
+  getOpenApiSpec: () => OpenAPIV3_1.Document,
+  generateOpenApiSpec: ( servicePath?: string ) => Promise<OpenAPIV3_1.Document>,
+  registerEndpoint<BODY, RETURN, QUERY, PARAMS>( endpoint: Endpoint<BODY, RETURN, QUERY, PARAMS> ): void;
+  registerSchema( name:string, schema: JSONSchema7, tags: string[]): void;
+  addOpenApiTag( name: string ): void;
+  call<Type, R=Type>( route: string, method?:string, params?: Partial<Pick<EndpointActionParams<Type>, 'body'|'context'>> ): Promise<R>
+  fetch( route: string, params: {method: 'get'| 'post', headers: Record<string,any>, body: string}): Promise<EndpointsFetchInterfaceResponse>
+  get<Type, R=Type>( route: string, params?: Partial<Pick<EndpointActionParams<Type>, 'body'|'context'>> ): Promise<R>
+  post<Type, R=Type>( route: string, params?: Partial<Pick<EndpointActionParams<Type>, 'body'|'context'>> ): Promise<R>,
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+}
+
+export type EndpointsPort = PortEmitter & EndpointsType & {
+  _adapters: () => EndpointsAdapter[]
+}

package/src/evenstore.ts

@@ -0,0 +1,27 @@
+import S from '@bett3r-dev/jsonschema-definer';
+import { DatabaseTransaction } from './database';
+import { CommittedEvent, EventToCommit, ReadMultipleStreamOptions, ReadStreamOptions } from './eventsourcing';
+import { AdapterBase, PortEmitter } from './ports';
+
+export const EventStoreConfigSchema = S.shape({
+  enabled: S.boolean().optional(),
+  collection: S.string().optional()
+}).optional();
+export type EventStoreConfig = typeof EventStoreConfigSchema.type;
+
+export type EventStoreType = {
+  appendToStream: <Type>( stream:string, events: EventToCommit|EventToCommit[], expectedVersion?: number, transaction?: DatabaseTransaction ) => Promise<CommittedEvent<Type>[]>;
+  appendToMultipleStreams?: <Type>( streams: Record<string, { events: EventToCommit|EventToCommit[], expectedVersion?: number, }>, transaction?: DatabaseTransaction ) => Promise<CommittedEvent<Type>[]>;
+  readStream: <Model=any>( readOptions: ReadStreamOptions, callback: ( event: CommittedEvent, stop: () => void ) => Partial<Model> | Promise<Partial<Model>> ) => Promise<Model>
+  readMultipleStream?: <Model=any>( readOptions: ReadMultipleStreamOptions, callback: ( event: CommittedEvent, stop: () => void ) => Record<string,Partial<Model>> | Promise<Record<string,Partial<Model>>> ) => Promise<Record<string,Model>>
+  subscribe: ( onData: ( event: CommittedEvent ) => void, onError?: ( e: Error ) => void ) => Promise<{
+    close: () => void
+  }>
+  flush: () => Promise<void>
+}
+
+export type EventStoreAdapter = AdapterBase & EventStoreType;
+
+export type EventStorePort = PortEmitter & EventStoreType & {
+  _adapter: EventStoreAdapter
+};

package/src/eventsourcing/aggregateBuilder.ts

@@ -0,0 +1,11 @@
+import { Command, EventFactory, EventReducers } from '.';
+import { DatabasePort } from '..';
+import { ExternalSystemBuilderType } from './externalSystemBuilder';
+
+
+export type AggregateBuilderType<Model, EVENTS extends Record<string, EventFactory>> = Omit<ExternalSystemBuilderType<Model, EVENTS>, 'withCommandTemplate'> & {
+  withCommandTemplate: ( command: Command ) => AggregateBuilderType<Model, EVENTS>
+  notEventsourced: ( database: DatabasePort, collection: string ) => AggregateBuilderType<Model, EVENTS>
+  initialValue: ( init: () => ( Partial<Model> | null | undefined )) => Pick<AggregateBuilderType<Model, EVENTS>, 'withEventReducers' | 'withCommands'>
+  withEventReducers: ( eventReducers: EventReducers<EVENTS, Model> ) => Pick<AggregateBuilderType<Model, EVENTS>, 'withCommands'>
+}

package/src/eventsourcing/commandBuilder.ts

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

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