@bett3r-dev/pv3-types 1.0.0 → 1.4.0

package/src/ports.ts

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

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

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

package/src/validation.ts

@@ -1,89 +0,0 @@
-import S, { BaseSchema } from '@bett3r-dev/jsonschema-definer';
-
-export type AppErrorInstance<ErrorPayload = unknown> = Error & AppErrorData<ErrorPayload>
-export type AppErrorData<ErrorPayload = unknown> = {
-  error?: string,
-  description?: string,
-  type: ErrorTypes,
-  details?: ErrorPayload,
-  status?:number
-}
-
-export type AppErrorType<ErrorPayload = any> = AppErrorData<ErrorPayload> & {schema?: BaseSchema<ErrorPayload>}
-
-/**
- * @hidden
- */
-export const errorStatusCodeMap = {
-  BadRequestError: 400,
-  UnauthorizedError: 401,
-  PaymentRequiredError: 402,
-  ForbiddenError: 403,
-  NotFoundError: 404,
-  MethodNotAllowedError: 405,
-  NotAcceptableError: 406,
-  ProxyAuthenticationRequiredError: 407,
-  RequestTimeoutError: 408,
-  ConflictError: 409,
-  ConcurrencyError: 409,
-  GoneError: 410,
-  LengthRequiredError: 411,
-  PreconditionFailedError: 412,
-  PayloadTooLargeError: 413,
-  TooManyRequestsError: 429,
-  InternalServerError: 500,
-  NotImplementedError: 501,
-  BadGatewayError: 502,
-  ServiceUnavailableError: 503,
-  GatewayTimeoutError: 504,
-};
-
-export const statusCodeErrorMap = {
-  400: 'BadRequestError',
-  401: 'UnauthorizedError',
-  402: 'PaymentRequiredError',
-  403: 'ForbiddenError',
-  404: 'NotFoundError',
-  405: 'MethodNotAllowedError',
-  406: 'NotAcceptableError',
-  407: 'ProxyAuthenticationRequiredError',
-  408: 'RequestTimeoutError',
-  409: 'ConcurrencyError',
-  410: 'GoneError',
-  411: 'LengthRequiredError',
-  412: 'PreconditionFailedError',
-  413: 'PayloadTooLargeError',
-  429: 'TooManyRequestsError',
-  500: 'InternalServerError',
-  501: 'NotImplementedError',
-  502: 'BadGatewayError',
-  503: 'ServiceUnavailableError',
-  504: 'GatewayTimeoutError',
-};
-
-
-const ErrorTypesSchema = S.string().enum(
-  'BadRequestError',
-  'UnauthorizedError',
-  'PaymentRequiredError',
-  'ForbiddenError',
-  'NotFoundError',
-  'MethodNotAllowedError',
-  'NotAcceptableError',
-  'ProxyAuthenticationRequiredError',
-  'RequestTimeoutError',
-  'ConflictError',
-  'ConcurrencyError',
-  'GoneError',
-  'LengthRequiredError',
-  'PreconditionFailedError',
-  'PayloadTooLargeError',
-  'TooManyRequestsError',
-  'InternalServerError',
-  'NotImplementedError',
-  'BadGatewayError',
-  'ServiceUnavailableError',
-  'GatewayTimeoutError'
-);
-
-export type ErrorTypes = typeof ErrorTypesSchema.type;

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./build",
-		"rootDir": "./src",
-    "composite": true,
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "(?:^|/)node_modules/",
-    "build",
-  ]
-}