@kravc/dos 1.9.2 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kravc/dos",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "Convention-based, easy-to-use library for building API-driven serverless services.",
   "keywords": [
     "Service",
@@ -12,6 +12,7 @@
     "Lambda Function"
   ],
   "main": "src/index.js",
+  "types": "src/index.d.ts",
   "repository": {
     "type": "git",
     "url": "http://github.com/alexkravets/dos.git"

package/src/Document.js

@@ -61,6 +61,14 @@ class Document extends Component {
     this._bodySchema = schema
   }
 
+  static _extendWithPartition(context, parameters) {
+    if (!this.getPartition) {
+      return
+    }
+
+    parameters.partition = this.getPartition(context, parameters)
+  }
+
   static async create(context, query, mutation) {
     /* NOTE: existing document in the context allows to return document without
              duplicate been created */
@@ -96,6 +104,7 @@ class Document extends Component {
     }
 
     mutation[this.idKey] = this.createId(mutation)
+    this._extendWithPartition(context, mutation)
 
     const isCreated = await this._create(mutation)
 

package/src/Service.js

@@ -12,15 +12,27 @@ const OperationNotFoundError = require('./errors/OperationNotFoundError')
 const { get, uniq, compact } = require('lodash')
 
 const ROOT_PATH = process.cwd()
+const DEFAULT_URL = 'http://localhost:3000/'
+const DEFAULT_SERVICE_PATH = `${ROOT_PATH}/src`
+const DEFAULT_SKIP_OPERATIONS = []
 
 class Service {
-  constructor(modules, url = 'http://localhost:3000/', path = `${ROOT_PATH}/src`) {
+  constructor(modules, options = {}) {
+    let {
+      url = DEFAULT_URL,
+      path = DEFAULT_SERVICE_PATH,
+      skipOperations = DEFAULT_SKIP_OPERATIONS,
+    } = options
+
     if (!url.endsWith('/')) { url = url + '/' }
 
     const schemasMap = createSchemasMap(path)
 
     let components = modules.filter(Component => !Component.types)
-    let operations = modules.filter(Component => !!Component.types)
+
+    let operations = modules
+      .filter(Component => !!Component.types)
+      .filter(({ id }) => !skipOperations.includes(id))
 
     const operationComponents = compact(operations.map(({ Component }) => Component))
     components = uniq([ ...components, ...operationComponents ])

package/src/Service.spec.js

@@ -35,7 +35,11 @@ describe('Service', () => {
 
   describe('Service.constructor(modules, url, path = \'/src\')', () => {
     it('initializes service', () => {
-      const service = new Service(modules, 'https://example.com/api', `${ROOT_PATH}/examples`)
+      const service = new Service(modules, {
+        url: 'https://example.com/api',
+        path: `${ROOT_PATH}/examples`
+      })
+
       expect(service).to.exist
     })
 
@@ -71,8 +75,12 @@ describe('Service', () => {
   })
 
   describe('.handler(request)', () => {
-    const service = new Service(modules, 'https://example.com/api/', `${ROOT_PATH}/examples`)
-    const exec    = test.execute(service)
+    const service = new Service(modules, {
+      url: 'https://example.com/api/',
+      path: `${ROOT_PATH}/examples`
+    })
+
+    const exec = test.execute(service)
 
     const authorization = test.createAccessToken({}, { group: 'Administrators' })
 

package/src/index.d.ts

@@ -0,0 +1,126 @@
+
+export declare function getOrFail(object: Record<string, any>, path: string): any;
+
+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 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 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 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 afterCreate<T, D extends Document<T> = Document<T>>(
+    context: Context,
+    query: QueryMap,
+    mutation: CreateMutationMap,
+    originalDocument: D
+  ): Promise<void>;
+
+  static beforeUpdate(
+    context: Context,
+    query: QueryMap,
+    mutation: UpdateMutationMap,
+  ): Promise<void>;
+
+  static afterUpdate<T, D extends Document<T> = Document<T>>(
+    context: Context,
+    query: QueryMap,
+    mutation: UpdateMutationMap,
+    originalDocument: D
+  ): Promise<void>;
+
+  static beforeDelete(
+    context: Context,
+    query: QueryMap,
+  ): 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>;
+}