@kravc/dos 1.9.3 → 1.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kravc/dos",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "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"
@@ -25,7 +26,7 @@
   "author": "Alexander Kravets <a@kra.vc>",
   "license": "ISC",
   "dependencies": {
-    "@kravc/schema": "^2.7.1",
+    "@kravc/schema": "^2.7.2",
     "cookie": "^1.0.1",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",

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)
 
@@ -127,6 +136,8 @@ class Document extends Component {
   }
 
   static async read(context, query, options) {
+    this._extendWithPartition(context, query)
+
     const item = await this._read(query, options)
 
     if (!item) {
@@ -188,6 +199,8 @@ class Document extends Component {
       originalDocument = await this.read(context, query)
     }
 
+    this._extendWithPartition(context, query)
+
     const updatedItem = await this._update(query, mutation)
 
     const document = new this(context, updatedItem)
@@ -223,6 +236,8 @@ class Document extends Component {
              context so can be referenced in the after action helper */
     const originalDocument = await this.read(context, query)
 
+    this._extendWithPartition(context, query)
+
     await this._delete(query)
 
     if (this.afterDelete) {

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>;
+}