@kravc/dos 1.12.6 → 2.0.0-alpha.0

package/src/helpers/specMiddleware.js

@@ -1,81 +0,0 @@
-'use strict'
-
-const { resolve } = require('path')
-const readYamlFile = require('read-yaml-file')
-const { readFileSync } = require('fs')
-
-const SWAGGER_UI_TEMPLATE_PATH = resolve(__dirname, '../../assets/index.html')
-const SWAGGER_UI_TEMPLATE = readFileSync(SWAGGER_UI_TEMPLATE_PATH, { encoding: 'utf8' })
-
-const ROOT_PATH = process.cwd()
-const { name: title, version } = require(`${ROOT_PATH}/package.json`)
-
-const SWAGGER_UI_HTML = SWAGGER_UI_TEMPLATE.replace('$TITLE', title)
-
-const isDevelopment = () => process.env.NODE_APP_INSTANCE === 'dev' || !process.env.NODE_APP_INSTANCE
-
-const _getHomeBody = () => isDevelopment() ? SWAGGER_UI_HTML : 'healthy'
-
-const _getSpecBody = (service) => isDevelopment() ? service.spec : { info: { title, version } }
-
-const specMiddleware = (service, context) => {
-  const { httpPath, httpMethod } = context
-
-  if (httpMethod !== 'get') { return null }
-
-  if (httpPath === '/') {
-    const bodyText = _getHomeBody()
-
-    return {
-      headers: {
-        'Content-Type': 'text/html; charset=UTF-8'
-      },
-      statusCode: 200,
-      body: bodyText,
-    }
-  }
-
-  if (httpPath === '/Spec') {
-    const bodyJson = JSON.stringify(_getSpecBody(service), null, 2)
-
-    return {
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8'
-      },
-      statusCode: 200,
-      body: bodyJson,
-    }
-  }
-
-  const readFileJson = httpPath => {
-    const fileName = httpPath.replace('/', '')
-    const source = readYamlFile.sync(`${ROOT_PATH}/specs/${fileName}`)
-
-    return JSON.stringify(source, null, 2)
-  }
-
-  const isComposer = [
-    '/Enums.yaml',
-    '/Schemas.yaml',
-    '/Documents.yaml',
-    '/Scenarios.yaml',
-    '/Operations.yaml',
-    '/Parameters.yaml'
-  ].includes(httpPath)
-
-  const shouldReturnComposerSpecs = isComposer && isDevelopment()
-
-  if (shouldReturnComposerSpecs) {
-    return {
-      headers: {
-        'Content-Type': 'application/json; charset=utf-8'
-      },
-      statusCode: 200,
-      body: readFileJson(httpPath),
-    }
-  }
-
-  return null
-}
-
-module.exports = specMiddleware

package/src/index.d.ts

@@ -1,352 +0,0 @@
-import type { Schema, SchemaAttributes } from '@kravc/schema';
-
-export declare type SortOrder = 'asc' | 'desc';
-export declare type Context = Record<string, any>;
-export declare type QueryMap = Record<string, any>;
-export declare type CreateMutationMap = Record<string, any>;
-export declare type UpdateMutationMap = Record<string, any>;
-export declare type AttributesMap = Record<string, any>;
-export declare type OperationParameters = Record<string, unknown>;
-export declare type Headers = Record<string, string>;
-
-export declare interface IndexOptions {
-  sort?: SortOrder;
-  limit?: number;
-  index?: string;
-  exclusiveStartKey?: string;
-}
-
-export declare interface IndexAllOptions {
-  sort?: SortOrder;
-  index?: string;
-}
-
-export declare type DocumentConstructor<T, D extends Document<T> = Document<T>> = {
-  new(context: Context, attributes: T): D;
-};
-
-export declare class Document<T> {
-  constructor(context: Context, attributes: T);
-
-  static get idKey(): string;
-  static get sortBy(): string;
-  static get idKeyPrefix(): string;
-  static get documentName(): string;
-
-  static set schema(schema: Schema);
-  static get schema(): Schema;
-
-  static get _defaultSchemaAttributes(): SchemaAttributes;
-
-  static _read(query: QueryMap): Promise<AttributesMap>;
-  static _extendWithCreatedStamps(context: Context, mutation: CreateMutationMap): void;
-  static _create(attributes: AttributesMap): Promise<Boolean>;
-  static _extendWithUpdatedStamps(context: Context, mutation: UpdateMutationMap): void;
-  static _update(query: QueryMap, mutation: UpdateMutationMap): Promise<AttributesMap>;
-
-  static createId(attributes: AttributesMap): string;
-
-  static getPartition(
-    context: Context,
-    parameters: Record<string, any>
-  ): string;
-
-  static index<T, D extends Document<T> = Document<T>>(
-    this: DocumentConstructor<T, D>,
-    context: Context,
-    query?: QueryMap,
-    options?: IndexOptions,
-  ): Promise<{
-    count: number;
-    objects: D[];
-    lastEvaluatedKey: string;
-  }>;
-
-  static indexAll<T, D extends Document<T> = Document<T>>(
-    this: DocumentConstructor<T, D>,
-    context: Context,
-    query?: QueryMap,
-    options?: IndexOptions,
-  ): Promise<{
-    count: number;
-    objects: D[];
-  }>;
-
-  static read<T, D extends Document<T> = Document<T>>(
-    this: DocumentConstructor<T, D>,
-    context: Context,
-    query: QueryMap,
-  ): Promise<D>;
-
-  static create<T, D extends Document<T> = Document<T>>(
-    this: DocumentConstructor<T, D>,
-    context: Context,
-    query: QueryMap | CreateMutationMap,
-    mutation?: CreateMutationMap
-  ): Promise<D>;
-
-  static update<T, D extends Document<T> = Document<T>>(
-    this: DocumentConstructor<T, D>,
-    context: Context,
-    query: QueryMap,
-    mutation: UpdateMutationMap,
-    originalDocument?: D
-  ): Promise<D>;
-
-  static delete(
-    context: Context,
-    query: QueryMap
-  ): Promise<void>;
-
-  static beforeCreate(
-    context: Context,
-    query: QueryMap,
-    mutation: CreateMutationMap
-  ): Promise<void>;
-
-  static beforeUpdate(
-    context: Context,
-    query: QueryMap,
-    mutation: UpdateMutationMap,
-  ): Promise<void>;
-
-  // static beforeDelete<T, D extends Document<T> = Document<T>>(
-  //   context: Context,
-  //   query: QueryMap,
-  //   originalDocument: D
-  // ): Promise<void>;
-
-  // static afterCreate<T, D extends Document<T> = Document<T>>(
-  //   context: Context,
-  //   query: QueryMap,
-  //   mutation: CreateMutationMap,
-  //   originalDocument: D
-  // ): Promise<void>;
-
-  // static afterUpdate<T, D extends Document<T> = Document<T>>(
-  //   context: Context,
-  //   query: QueryMap,
-  //   mutation: UpdateMutationMap,
-  //   originalDocument: D
-  // ): Promise<void>;
-
-  // static afterDelete<T, D extends Document<T> = Document<T>>(
-  //   context: Context,
-  //   query: QueryMap,
-  //   originalDocument: D
-  // ): Promise<void>;
-
-  get id(): string;
-  get context(): Context;
-  get attributes(): T;
-  get componentId(): string;
-  get originalDocument(): this;
-  get _query(): Record<string, any>;
-
-  _attributes: Record<string, any>;
-
-  update(mutation: UpdateMutationMap, shouldMutate?: boolean): Promise<this>;
-  delete(): Promise<void>;
-  hasAttributeChanged(attributePath: string): boolean;
-  toJSON(): Record<string, any>;
-}
-
-export declare function getOrFail(
-  object: Record<string, any>,
-  path: string
-): any;
-
-export declare function verifyToken(
-  context: Context,
-  token: string,
-  publicKey: string,
-  algorithm: string,
-): Promise<[ boolean, string | undefined ]>;
-
-export declare class JwtAuthorization {
-  static createRequirement(options: {
-    publicKey: string;
-    name?: string;
-    algorithm?: string;
-    cookieName?: string;
-    description?: string;
-    requirementName?: string;
-    normalizePayload?: Function;
-    tokenVerificationMethod?: Function;
-    accessVerificationMethod?: (context: Context, payload: Record<string, unknown>) => [boolean, string?];
-  }): Record<string, any>
-}
-
-export declare class SystemAuthorization {
-  static createRequirement(options?: {
-    name?: string;
-    description?: string;
-    requirementName?: string;
-    accessVerificationMethod?: (context: Context) => [boolean, string?];
-  }): Record<string, any>
-}
-
-export type ComponentConstructor = new (...args: any[]) => any;
-type OperationConstructor = new (...args: any[]) => any;
-
-export declare class Operation {
-  constructor(context: Context);
-
-  public context: Context;
-  static get query(): SchemaAttributes | null;
-  static get mutation(): Schema | SchemaAttributes | null;
-  static get output(): Schema | SchemaAttributes | null;
-
-  exec(parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
-}
-
-export declare function Read(
-  Component: ComponentConstructor,
-  componentAction?: string
-): typeof Operation;
-
-export declare function Create(
-  Component: ComponentConstructor,
-  componentAction?: string
-): typeof Operation;
-
-export declare function Update(
-  Component: ComponentConstructor,
-  componentAction?: string
-): typeof Operation;
-
-export declare function Delete(
-  Component: ComponentConstructor,
-  componentAction?: string
-): typeof Operation;
-
-export declare function Index(
-  Component: ComponentConstructor,
-  componentAction?: string
-): typeof Operation;
-
-declare type Module = Operation | Schema | ComponentConstructor;
-
-interface ISpec {
-  paths: Record<string, unknown>;
-}
-
-interface HttpRequest {
-  url: string;
-  path?: string;
-  body?: string | Record<string, unknown>;
-  method: string;
-  headers?: Headers;
-  requestContext?: {
-    requestId?: string;
-  };
-}
-
-interface SystemRequest {
-  body?: string | Record<string, unknown>;
-  headers?: Headers;
-  operationId: string;
-  queryStringParameters?: Record<string, unknown>;
-  requestContext?: {
-    requestId?: string;
-  };
-}
-
-type IRequest = HttpRequest | SystemRequest;
-
-interface IResponse {
-  body?: string,
-  headers: Headers,
-  statusCode: number,
-}
-
-export declare class Service {
-  constructor(modules: Module[], options: {
-    url?: string;
-    path?: string;
-    skipOperations?: string[];
-  });
-
-  get spec(): ISpec;
-  get baseUrl(): string;
-
-  handler(request: IRequest, Context): Promise<IResponse>;
-}
-
-export declare function createAccessToken(
-  options: Record<string, string>,
-  payload: Record<string, unknown>
-): string;
-
-export declare function wait(ms: number): Promise<void>;
-
-export type Data = Record<string, unknown>[] | Record<string, unknown>;
-
-export type OperationError = {
-  code: string;
-  message: string;
-  statusCode: string;
-};
-
-interface ExecutionResult {
-  error?: OperationError,
-  data?: Data,
-}
-
-export declare function execute(service: Service, extraContext?: Record<string, unknown>):
-  {
-    request: (
-      operationId: string,
-      parameters: OperationParameters,
-      headers: Headers
-    ) => Promise<Data>;
-    expectError: (
-      operationId: string,
-      parameters: OperationParameters,
-      headers: Headers,
-      errorName: string
-    ) => Promise<OperationError>;
-  }
-
-export declare class CommonError extends Error {
-  constructor(code: string, message: string);
-  get code(): string;
-  get isCommonError(): boolean;
-}
-
-export declare class UnauthorizedError extends CommonError {
-  constructor(message: string);
-}
-
-export declare class AccessDeniedError extends CommonError {
-  constructor(message: string);
-}
-
-export declare class InvalidParametersError extends CommonError {
-  constructor(message: string)
-}
-
-export declare class UnprocessibleConditionError extends CommonError {
-  constructor(message: string)
-}
-
-export declare class DocumentExistsError extends CommonError {
-  constructor(Document: { name: string }, parameters: Record<string, unknown>);
-}
-
-export declare class DocumentNotFoundError extends CommonError {
-  constructor(Document: { name: string }, parameters: Record<string, unknown>);
-}
-
-interface Identity {
-  sub: string;
-  email: string;
-}
-
-export declare function authorize(Operation, Context): Promise<Identity>;
-
-export declare function maskSecrets(object: Record<string, unknown>): Record<string, unknown>;
-
-export declare function getComponentTitle(Component, isCapitalized?: boolean, isPlural?: boolean): string;
-
-export declare function getDefaultSchemaAttributes(Component): SchemaAttributes;

package/src/index.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const { wait, execute, createAccessToken } = require('./test')
-
-module.exports = {
-  Document:                    require('./Document'),
-  Operation:                   require('./Operation'),
-  Service:                     require('./Service'),
-  Read:                        require('./operations/Read'),
-  Index:                       require('./operations/Index'),
-  Create:                      require('./operations/Create'),
-  Update:                      require('./operations/Update'),
-  Delete:                      require('./operations/Delete'),
-  Component:                   require('./Component'),
-  handler:                     require('./helpers/handler'),
-  getOrFail:                   require('./helpers/getOrFail'),
-  authorize:                   require('./helpers/authorize'),
-  maskSecrets:                 require('./helpers/maskSecrets'),
-  getComponentTitle:           require('./helpers/getComponentTitle'),
-  getDefaultSchemaAttributes:  require('./helpers/getDefaultSchemaAttributes'),
-  security:                    require('./security'),
-  verifyToken:                 require('./security/verifyToken'),
-  JwtAuthorization:            require('./security/JwtAuthorization'),
-  SystemAuthorization:         require('./security/SystemAuthorization'),
-  CommonError:                 require('./errors/CommonError'),
-  UnauthorizedError:           require('./errors/UnauthorizedError'),
-  AccessDeniedError:           require('./errors/AccessDeniedError'),
-  DocumentExistsError:         require('./errors/DocumentExistsError'),
-  DocumentNotFoundError:       require('./errors/DocumentNotFoundError'),
-  InvalidParametersError:      require('./errors/InvalidParametersError'),
-  UnprocessibleConditionError: require('./errors/UnprocessibleConditionError'),
-  wait,
-  execute,
-  createAccessToken,
-}

package/src/operations/Create.js

@@ -1,39 +0,0 @@
-'use strict'
-
-const Operation       = require('../Operation')
-const getComponentTitle = require('../helpers/getComponentTitle')
-
-const Create = (Component, componentAction = 'create') => {
-  if (!Component) {
-    throw new Error('Argument "Component" is undefined for "Create" operation' +
-      ' function')
-  }
-
-  return class extends Operation {
-    static get Component() {
-      return Component
-    }
-
-    static get componentAction() {
-      return componentAction
-    }
-
-    static get type() {
-      return Operation.types.CREATE
-    }
-
-    static get errors() {
-      const documentTitle = getComponentTitle(this.Component)
-
-      return {
-        ...super.errors,
-        DocumentExistsError: {
-          statusCode:  422,
-          description: `${documentTitle} could not be created, it already exists`
-        }
-      }
-    }
-  }
-}
-
-module.exports = Create

package/src/operations/Delete.js

@@ -1,54 +0,0 @@
-'use strict'
-
-const Operation         = require('../Operation')
-const getComponentTitle = require('../helpers/getComponentTitle')
-
-const Delete = (Component, componentAction = 'delete') => {
-  if (!Component) {
-    throw new Error('Argument "Component" is undefined for "Delete" operation' +
-      ' function')
-  }
-
-  return class extends Operation {
-    static get Component() {
-      return Component
-    }
-
-    static get componentAction() {
-      return componentAction
-    }
-
-    static get type() {
-      return Operation.types.DELETE
-    }
-
-    static get errors() {
-      const documentTitle = getComponentTitle(this.Component)
-
-      return {
-        ...super.errors,
-        DocumentNotFoundError: {
-          statusCode:  404,
-          description: `${documentTitle} is not found`
-        }
-      }
-    }
-
-    static get query() {
-      const documentTitle = getComponentTitle(this.Component)
-
-      return {
-        id: {
-          description: `${documentTitle} ID`,
-          required:    true
-        }
-      }
-    }
-
-    static get output() {
-      return null
-    }
-  }
-}
-
-module.exports = Delete

package/src/operations/Index.js

@@ -1,107 +0,0 @@
-'use strict'
-
-const { capitalize }    = require('lodash')
-const Operation         = require('../Operation')
-const getComponentTitle = require('../helpers/getComponentTitle')
-
-const Index = (Component, componentAction = 'index') => {
-  if (!Component) {
-    throw new Error('Argument "Component" is undefined for "Index" operation' +
-      ' function')
-  }
-
-  return class extends Operation {
-    static get Component() {
-      return Component
-    }
-
-    static get summary() {
-      const { Component, componentAction } = this
-      const documentTitle = getComponentTitle(Component, false, true)
-
-      return capitalize(`${componentAction} ${documentTitle}`)
-    }
-
-    static get componentAction() {
-      return componentAction
-    }
-
-    static get defaultLimit() {
-      return 20
-    }
-
-    static get defaultSort() {
-      return 'desc'
-    }
-
-    static get query() {
-      const { Component, defaultSort, defaultLimit } = this
-      const documentTitle = getComponentTitle(Component, false, true)
-
-      return {
-        limit: {
-          description: `Limit number of ${documentTitle} to be returned`,
-          type:        'integer',
-          default:     defaultLimit
-        },
-        sort: {
-          description: 'Sort direction',
-          enum:        [ 'asc', 'desc' ],
-          default:     defaultSort
-        },
-        exclusiveStartKey: {
-          description: `Return ${documentTitle} starting from specific key`
-        }
-      }
-    }
-
-    static get output() {
-      return {
-        data: {
-          items: { $ref: this.Component.schema.id },
-          required: true
-        },
-        pageInfo: {
-          required: true,
-          properties: {
-            exclusiveStartKey: {
-              description: 'Exclusive start key specified in the request'
-            },
-            lastEvaluatedKey: {
-              description: 'Last evaluated key to get next portion of results'
-            },
-            limit: {
-              description: 'Limit value specified in the request',
-              type:        'integer'
-            },
-            count: {
-              description: 'Number of results',
-              type:        'integer'
-            },
-            sort: {
-              description: 'Sort direction',
-              enum:        [ 'asc', 'desc' ]
-            }
-          }
-        }
-      }
-    }
-
-    async action(parameters) {
-      const { exclusiveStartKey, limit, sort, index, ...query } = parameters
-      const options = { exclusiveStartKey, limit, sort, index }
-
-      const { componentActionMethod } = this.constructor
-      const result = await componentActionMethod(this.context, query, options)
-
-      const { objects: data, count, lastEvaluatedKey } = result
-
-      return {
-        pageInfo: { sort, count, limit, lastEvaluatedKey, exclusiveStartKey },
-        data
-      }
-    }
-  }
-}
-
-module.exports = Index