@bett3r-dev/pv3-types 1.0.0 → 1.4.0

package/src/clusterAdministration.ts

@@ -1,216 +0,0 @@
-import S, { mergeSchemas, omitFromSchema } from '@bett3r-dev/jsonschema-definer';
-import { CommittedEvent, Event } from '@bett3r-dev/pv3-types';
-
-export type ClusterStructureType = {
-  getCurrentState: ( id?: string ) => Promise<StructureState>,
-  getStructureRevision: ( version:number ) => Promise<StructureState | null>,
-  subscribeToStructureChanges: ( onStructureChanges: ( change: StructureState ) => void ) => Promise<{ unsubscribe: () => void }>,
-  stop: () => Promise<void>,
-} & {
-  [key in keyof CommandTypes]: ( payload: CommandTypes[key], expectedVersion?: number ) => Promise<StructureState>;
-}
-
-export type StructureState = {
-  state: StructureAggregateType,
-  version: number,
-}
-
-export type StructureCommittedEventType = CommittedEvent<StructureAggregateType & {
-  change: {
-    broker: {host: string};
-    service: {host: string};
-    subscriptions: {subscriptions: Record<string,number>};
-  }
-}>
-
-export const StructureServiceSchema = S.shape({
-  hosts: S.array().items( S.string()),
-  port: S.number().default( 1984 ).optional(),
-  channel: S.string().enum( 'tcp', 'http', 'local' ).default( 'http' ).optional(),
-  isExternal: S.boolean().default( false ).optional(),
-  possibleSubscriptions: S.array().items( S.string()).optional(),
-  possibleModules: S.shape({}).additionalProperties( S.array().items( S.string())).optional(),
-  isService: S.boolean().optional(),
-  isBroker: S.boolean().optional(),
-  endpoints: S.array().items( S.string()).optional(),
-  openApiEndpoint: S.string().optional().default( '/documentation/json' ),
-  produces: S.shape({}).additionalProperties( S.array().items( S.string())).optional(),
-  consumes: S.shape({}).additionalProperties( S.array().items( S.string())).optional(),
-});
-export type StructureServiceType = typeof StructureServiceSchema.type;
-
-export const RetryableStatuses = [ 429, 503, 504 ];
-
-export const StructureSubscriptionSchema = S.shape({
-  producers: S.array().items( S.string()),
-  module: S.string(),
-  consumer: S.string(),
-  load: S.number().optional(),
-  eventstore: S.string().optional(),
-  events: S.array().items( S.string()).optional(),
-  manualDataSplits: S.number().minimum( 1 ).optional(),
-  mirrorDataSplitsWithConsumers: S.boolean().optional().default( true ),
-  customDataSplits: S.array().items( S.array().items( S.string())).optional(),
-  streams: S.string().optional(),
-  endpoint: S.string().optional(),
-  retryAfterSecs: S.number().optional(),
-  retryableStatuses: S.array().items( S.number()).default( RetryableStatuses ).optional(),
-  dataSplits: S.shape({
-    custom: S.array().items( S.string()),
-    manual: S.array().items( S.string()),
-    automatic: S.array().items( S.string()),
-  }).partial().optional(),
-});
-export type StructureSubscriptionType = typeof StructureSubscriptionSchema.type;
-
-export const StructureBrokerSubscriptionSchema = S.shape({
-  host: S.string(),
-  index: S.number(),
-  custom: S.array().items( S.string()).optional()
-});
-export type StructureBrokerSubscriptionType = typeof StructureBrokerSubscriptionSchema.type;
-
-export const StructureBrokerSchema = S.shape({
-  host: S.string(),
-  subscriptions: S.shape({}).additionalProperties(
-    S.shape({}).additionalProperties( StructureBrokerSubscriptionSchema )
-  ),
-});
-export type StructureBrokerType = typeof StructureBrokerSchema.type;
-
-export const StructureSubscriptionsSchema = S.shape({})
-  .additionalProperties( StructureSubscriptionSchema );
-
-export const StructureServicesSchema = S.shape({})
-  .additionalProperties( StructureServiceSchema );
-export type StructureServicesType = typeof StructureServicesSchema.type;
-
-export const StructureBrokersSchema = S.shape({})
-  .additionalProperties( omitFromSchema( StructureBrokerSchema, ['host']));
-
-export const StructureAggregateSchema = S.shape({
-  subscriptions: StructureSubscriptionsSchema,
-  services: StructureServicesSchema,
-  brokers: StructureBrokersSchema,
-  clusterRevision: S.number(),
-  servicesRevisionAck: S.array().items( S.string())
-});
-export type StructureAggregateType = typeof StructureAggregateSchema.type;
-
-export const AddSubscriptionsCommandSchema = S.shape({
-  subscriptions: StructureSubscriptionsSchema, doNotRebalance: S.boolean().optional()
-});
-export const EditSubscriptionCommandSchema = S.shape({
-  id: S.string(),
-  subscription: StructureSubscriptionSchema.partial(),
-  doNotRebalance: S.boolean().optional()
-});
-export const DeleteSubscriptionCommandSchema = S.shape({
-  id: S.string(),
-  doNotRebalance: S.boolean().optional()
-});
-
-export const UpsertHostCommandSchema = mergeSchemas( omitFromSchema( StructureServiceSchema, ['hosts']), S.shape({
-  service: S.string(),
-  host: S.string(),
-  doNotRebalance: S.boolean().optional()
-}));
-export type UpsertHostCommandType = typeof UpsertHostCommandSchema.type;
-
-export const RemoveHostCommandSchema = S.shape({ host: S.string() });
-
-export const SetStructureUpsertHostCommandSchema = mergeSchemas( StructureServiceSchema, S.shape({
-  service: S.string(),
-}));
-export const SetStructureCommandSchema = S.shape({
-  upsertHosts: S.array().items( UpsertHostCommandSchema ),
-  removeHosts: S.array().items( S.string()),
-  subscriptions: StructureSubscriptionsSchema.optional()
-});
-
-export const RebalanceSubscriptionsCommandSchema = S.shape({})
-  .additionalProperties( omitFromSchema( StructureBrokerSchema, ['host']));
-export type RebalanceSubscriptionsCommandType = typeof RebalanceSubscriptionsCommandSchema.type;
-
-export const RemoveBrokerCommandSchema = S.shape({ host: S.string() });
-
-export const AckStructureSchema = S.shape({ host: S.string(), revision: S.number() });
-
-export type CommandTypes = {
-  UpsertHost: typeof UpsertHostCommandSchema.type
-  RemoveHost: typeof RemoveHostCommandSchema.type
-  RebalanceSubscriptions: typeof RebalanceSubscriptionsCommandSchema.type
-  AddSubscriptions: typeof AddSubscriptionsCommandSchema.type
-  EditSubscription: typeof EditSubscriptionCommandSchema.type
-  DeleteSubscription: typeof DeleteSubscriptionCommandSchema.type
-  SetStructure: typeof SetStructureCommandSchema.type
-  AckStructure: typeof AckStructureSchema.type
-}
-
-//*******************************************
-// EVENTS
-//*******************************************
-
-export const structureEvents = {
-  HostUpserted: () => Event({
-    schema: S.shape({
-      services: StructureServicesSchema,
-      brokers: StructureBrokersSchema.optional(),
-      doNotRebalance: S.boolean().optional(),
-    })
-  }),
-  HostRemoved: () => Event({
-    schema: S.shape({
-      brokers: StructureBrokersSchema,
-      host: S.string(),
-      service: S.string()
-    })
-  }),
-  SubscriptionsRebalanced: () => Event({
-    schema: S.shape({
-      brokers: StructureBrokersSchema,
-    })
-  }),
-  SubscriptionsAdded: () => Event({
-    schema: S.shape({
-      brokers: StructureBrokersSchema.optional(),
-      subscriptions: StructureSubscriptionsSchema,
-      doNotRebalance: S.boolean().optional(),
-    })
-  }),
-  SubscriptionEdited: () => Event({
-    schema: S.shape({
-      brokers: StructureBrokersSchema.optional(),
-      subscriptions: StructureSubscriptionsSchema,
-      doNotRebalance: S.boolean().optional(),
-    })
-  }),
-  SubscriptionDeleted: () => Event({
-    schema: S.shape({
-      id: S.string(),
-      doNotRebalance: S.boolean().optional(),
-      brokers: StructureBrokersSchema.optional(),
-    })
-  }),
-  StructureSet: () => Event({
-    schema: StructureAggregateSchema
-  }),
-  StructureAcked: () => Event({
-    schema: AckStructureSchema
-  })
-};
-
-
-export const ClusterRoutesConfigSchema = S.shape({
-  clusterRoutesAggregateCollection: S.string().optional(),
-  clusterRoutesEventstoreCollection: S.string().optional(),
-  clusterRoutesEventstoreStream: S.string().optional(),
-});
-export type ClusterRoutesConfigType = typeof ClusterRoutesConfigSchema.type;
-
-export const ClusterStructureConfigSchema = S.shape({
-  structureEventstoreStream: S.string().default( 'environment' ).optional(),
-  structureAggregateCollection: S.string().default( 'cluster_infrastructure' ).optional(),
-  structureEventstoreCollection: S.string().default( 'cluster_eventstore' ).optional(),
-});
-export type ClusterStructureConfigType = typeof ClusterStructureConfigSchema.type;

package/src/configuration.ts

@@ -1,71 +0,0 @@
-import { ObjectSchema } from '@bett3r-dev/jsonschema-definer';
-import { AdapterBase, PortEmitter, PortEmitterEvents } from './ports';
-import { TypedEventEmitter } from './typedEventEmitter';
-
-export type ConfigurationPortEmitterEvents = PortEmitterEvents & {
-  argsApplied: {config: any},
-}
-
-/**
- * Patches the configuration of the system with a specified object
- * @param config The object to patch the configuration with
- */
-export declare function applyConfig( config: Record<string, any> ): Promise<Record<string, any>>
-
-/**
- * @category Main Types
-*/
-export type ConfigurationAdapter = AdapterBase & {
-  applyConfig: typeof applyConfig
-}
-
-/**
- * Returns a configuration for an specific module in the system
- * @category Configuration Port
- * @param name The name of the key in the config file structure
- * @param schema The schema of the specific configuration piece
- */
-export declare function getModuleConfig <CONFIG extends object>( name:string, schema: ObjectSchema<CONFIG, true> | ObjectSchema<CONFIG, false> ): {
-  config: CONFIG,
-  onArgsApplied: ( callback: ( config: CONFIG ) => void ) => void
-}
-
-export type CliArgDefinition = {
-  type: 'string' | 'number' | 'boolean',
-  name: string,
-  alias?: string,
-  description?: string,
-  default?: any
-}
-
-export type CliCommandDefinition = {
-  /** The name of the command, accepts positional arguments. Use <> for required and [] for optionals. Optionals might optionally accept and array like [optional..]
-   * @example
-   * 'test <required|requiredAlias> [optional1] [optional2..]'
-  */
-  name: string,
-  alias?: string,
-  description?: string,
-  /** The descriptions for the positional arguements of the command. MUST BE SPECIFIED IN THE NAME FIRST */
-  arguments?: CliArgDefinition[],
-  handler: ( args: Record<string, any> ) => void;
-}
-
-/**
- * @category Main Types
-*/
-export type ConfigurationType = {
-  _getConfig: () => Record<string, any>,
-  getModuleConfig: typeof getModuleConfig,
-  getModules: () => string[],
-  getArgs: () => Promise<Record<string, any>>,
-  applyArgs: () => Promise<Record<string, any>>,
-  emitter: TypedEventEmitter<ConfigurationPortEmitterEvents>,
-  configureCliArg: ( options: CliArgDefinition ) => void,
-  configureCliCommand: ( options: CliCommandDefinition ) => void,
-}
-
-/**
- * @category Main Types
-*/
-export type ConfigurationPort = Omit<PortEmitter, 'emitter'> & ConfigurationType

package/src/database.ts

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

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

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

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