@webiny/db-dynamodb 5.23.0 → 5.24.0-beta.0

package/BatchProcess.d.ts

@@ -2,18 +2,30 @@ import { DocumentClient } from "aws-sdk/clients/dynamodb";
 import { Batch } from "@webiny/db";
 declare type BatchType = "batchWrite" | "batchGet";
 export declare type AddBatchOperationResponse = () => any | null;
+interface RejectBuildCallable {
+    ({ message }: {
+        message: string;
+    }): void;
+}
+interface RejectExecutionCallable {
+    ({ message }: {
+        message: string;
+    }): void;
+}
+interface AddBatchOperationArgs {
+    /**
+     * TODO: determine correct type.
+     */
+    [key: string]: any;
+}
 declare class BatchProcess {
     documentClient: DocumentClient;
     batch: Batch;
     resolveBuild: () => void;
-    rejectBuild: ({ message: string }: {
-        message: any;
-    }) => void;
+    rejectBuild: RejectBuildCallable;
     queryBuild: Promise<void>;
     resolveExecution: () => void;
-    rejectExecution: ({ message: string }: {
-        message: any;
-    }) => void;
+    rejectExecution: RejectExecutionCallable;
     queryExecution: Promise<void>;
     operations: [Record<string, any>, Record<string, any>][];
     batchType: BatchType;
@@ -22,11 +34,11 @@ declare class BatchProcess {
     constructor(batch: Batch, documentClient: DocumentClient);
     waitStartExecution(): Promise<void>;
     waitExecution(): Promise<void>;
-    addBatchOperation(type: BatchType, args: any, meta?: {}): AddBatchOperationResponse;
-    addBatchWrite(args: any): AddBatchOperationResponse;
-    addBatchDelete(args: any): AddBatchOperationResponse;
-    addBatchGet(args: any): AddBatchOperationResponse;
+    addBatchOperation(type: BatchType, args: AddBatchOperationArgs, meta?: {}): AddBatchOperationResponse;
+    addBatchWrite(args: AddBatchOperationArgs): AddBatchOperationResponse;
+    addBatchDelete(args: AddBatchOperationArgs): AddBatchOperationResponse;
+    addBatchGet(args: AddBatchOperationArgs): AddBatchOperationResponse;
     allOperationsAdded(): boolean;
-    startExecution(): import("aws-sdk/lib/request").Request<DocumentClient.BatchGetItemOutput, import("aws-sdk/lib/error").AWSError> | import("aws-sdk/lib/request").Request<DocumentClient.BatchWriteItemOutput, import("aws-sdk/lib/error").AWSError>;
+    startExecution(): import("aws-sdk/lib/request").Request<DocumentClient.BatchWriteItemOutput, import("aws-sdk/lib/error").AWSError> | import("aws-sdk/lib/request").Request<DocumentClient.BatchGetItemOutput, import("aws-sdk/lib/error").AWSError>;
 }
 export default BatchProcess;

package/DynamoDbDriver.d.ts

@@ -1,9 +1,21 @@
 import { DocumentClient } from "aws-sdk/clients/dynamodb";
 import BatchProcess from "./BatchProcess";
-import { DbDriver, Args, Result } from "@webiny/db";
+import { DbDriver, Args, Result, ArgsBatch } from "@webiny/db";
 declare type ConstructorArgs = {
     documentClient?: DocumentClient;
 };
+interface ReadLogsParams {
+    table: string;
+}
+interface CreateLogParams {
+    id: string;
+    operation: string;
+    /**
+     * TODO: determine the data type.
+     */
+    data: any;
+    table: string;
+}
 declare class DynamoDbDriver implements DbDriver {
     batchProcesses: Record<string, BatchProcess>;
     documentClient: DocumentClient;
@@ -13,15 +25,8 @@ declare class DynamoDbDriver implements DbDriver {
     update({ query, data, table, meta, __batch: batch }: Args): Promise<Result>;
     delete({ query, table, meta, __batch: batch }: Args): Promise<Result>;
     read<T>({ table, query, sort, limit, keys, meta, __batch: batch }: Args): Promise<Result<T[]>>;
-    createLog({ id, operation, data, table }: {
-        id: any;
-        operation: any;
-        data: any;
-        table: any;
-    }): Promise<Result>;
-    readLogs<T>({ table }: {
-        table: any;
-    }): Promise<Result<T[]>>;
-    getBatchProcess(__batch: any): BatchProcess;
+    createLog({ id, operation, data, table }: CreateLogParams): Promise<Result>;
+    readLogs<T>({ table }: ReadLogsParams): Promise<Result<T[]>>;
+    getBatchProcess(__batch: ArgsBatch): BatchProcess;
 }
 export default DynamoDbDriver;

package/QueryGenerator.d.ts

@@ -1,19 +1,21 @@
+import { Query, QueryKey, QueryKeys, QuerySort } from "./types";
+interface GenerateParams {
+    query: Query;
+    keys: QueryKeys;
+    sort: QuerySort;
+    limit: number;
+    tableName: string;
+}
 declare class QueryGenerator {
-    generate({ query, keys, sort, limit, tableName }: {
-        query: any;
-        keys: any;
-        sort: any;
-        limit: any;
-        tableName: any;
-    }): {
-        TableName: any;
-        Limit: any;
+    generate(params: GenerateParams): {
+        TableName: string;
+        Limit: number;
         KeyConditionExpression: string;
-        ExpressionAttributeNames: {};
-        ExpressionAttributeValues: {};
+        ExpressionAttributeNames: Record<string, any>;
+        ExpressionAttributeValues: Record<string, any>;
         ScanIndexForward: boolean;
-        IndexName: any;
+        IndexName: string;
     };
-    findQueryKey(query?: {}, keys?: any[]): any;
+    findQueryKey(query?: Query, keys?: QueryKeys): QueryKey | null;
 }
 export default QueryGenerator;

package/QueryGenerator.js

@@ -16,14 +16,15 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 class QueryGenerator {
-  generate({
-    query,
-    keys,
-    sort,
-    limit,
-    tableName
-  }) {
-    // 1. Which key can we use in this query operation?
+  generate(params) {
+    const {
+      query,
+      keys,
+      sort,
+      limit,
+      tableName
+    } = params; // 1. Which key can we use in this query operation?
+
     const key = this.findQueryKey(query, keys);
 
     if (!key) {
@@ -31,8 +32,8 @@ class QueryGenerator {
     } // 2. Now that we know the key, let's separate the key attributes from the rest.
 
 
-    const keyAttributesValues = {},
-          nonKeyAttributesValues = {};
+    const keyAttributesValues = {};
+    const nonKeyAttributesValues = {};
 
     for (const queryKey in query) {
       if (key.fields.find(item => item.name === queryKey)) {
@@ -71,6 +72,8 @@ class QueryGenerator {
         return key;
       }
     }
+
+    return null;
   }
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/db-dynamodb",
-	"version": "5.23.0",
+	"version": "5.24.0-beta.0",
 	"main": "index.js",
 	"repository": {
 		"type": "git",
@@ -10,11 +10,11 @@
 	"author": "Webiny Ltd",
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/db": "5.23.0",
-		"@webiny/error": "5.23.0",
-		"@webiny/handler": "5.23.0",
-		"@webiny/handler-db": "5.23.0",
-		"@webiny/plugins": "5.23.0",
+		"@webiny/db": "5.24.0-beta.0",
+		"@webiny/error": "5.24.0-beta.0",
+		"@webiny/handler": "5.24.0-beta.0",
+		"@webiny/handler-db": "5.24.0-beta.0",
+		"@webiny/plugins": "5.24.0-beta.0",
 		"date-fns": "2.28.0",
 		"dot-prop": "6.0.1",
 		"fuse.js": "6.5.3",
@@ -24,8 +24,9 @@
 	"devDependencies": {
 		"@babel/cli": "^7.16.0",
 		"@babel/core": "^7.16.0",
-		"@webiny/cli": "^5.23.0",
-		"@webiny/project-utils": "^5.23.0",
+		"@types/is-number": "^7.0.2",
+		"@webiny/cli": "^5.24.0-beta.0",
+		"@webiny/project-utils": "^5.24.0-beta.0",
 		"dynamodb-toolbox": "^0.3.4",
 		"jest": "^26.6.3",
 		"jest-dynalite": "^3.2.0",
@@ -41,5 +42,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "eaa0003e39194d687ab5397c08eeccdb3557fb28"
+	"gitHead": "05b90b92bbaf2ef3adf275d008c4641580cf5f42"
 }

package/statements/createKeyConditionExpressionArgs.d.ts

@@ -1,12 +1,15 @@
-declare const _default: ({ query, sort, key }: {
-    query: any;
-    sort: any;
-    key: any;
-}) => {
+import { Query, QueryKey, QuerySort } from "../types";
+interface Output {
     KeyConditionExpression: string;
-    ExpressionAttributeNames: {};
-    ExpressionAttributeValues: {};
+    ExpressionAttributeNames: Record<string, any>;
+    ExpressionAttributeValues: Record<string, any>;
     ScanIndexForward: boolean;
-    IndexName: any;
-};
+    IndexName: string;
+}
+interface Params {
+    query: Query;
+    sort: QuerySort;
+    key: QueryKey;
+}
+declare const _default: ({ query, sort, key }: Params) => Output;
 export default _default;

package/statements/processStatement.d.ts

@@ -1,4 +1,3 @@
-export default function processStatement({ args, query }: {
-    args: any;
-    query: any;
-}): void;
+import { ProcessStatementCallable } from "../types";
+declare const processStatement: ProcessStatementCallable;
+export default processStatement;

package/statements/processStatement.js

@@ -5,14 +5,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = processStatement;
+exports.default = void 0;
 
 var _operators = _interopRequireDefault(require("./../operators"));
 
-function processStatement({
+const processStatement = ({
   args,
   query
-}) {
+}) => {
   outerLoop: for (const [key, value] of Object.entries(query)) {
     const operators = Object.values(_operators.default);
 
@@ -36,4 +36,7 @@ function processStatement({
 
     throw new Error(`Invalid operator {${key} : ${value}}.`);
   }
-}
+};
+
+var _default = processStatement;
+exports.default = _default;

package/types.d.ts

@@ -1,23 +1,23 @@
-export declare type OperatorArgs = {
+export interface OperatorArgs {
     expression: string;
     attributeNames: Record<string, any>;
     attributeValues: Record<string, any>;
-};
-declare type CanProcessArgs = {
+}
+interface CanProcessArgs {
     key: string;
     value: any;
     args: OperatorArgs;
-};
-declare type ProcessArgs = {
+}
+interface ProcessArgs {
     key: string;
     value: any;
     args: OperatorArgs;
     processStatement: any;
-};
-export declare type Operator = {
+}
+export interface Operator {
     canProcess: ({ key }: CanProcessArgs) => boolean;
     process: ({ key, value, args }: ProcessArgs) => void;
-};
+}
 /**
  * We use this definition to search for a value in any given field that was passed.
  * It works as an "OR" condition.
@@ -26,4 +26,33 @@ export interface DynamoDbContainsFilter {
     fields: string[];
     value: string;
 }
+export interface ProcessStatementArgsParam {
+    expression: string;
+    attributeNames: Record<string, any>;
+    attributeValues: Record<string, any>;
+}
+export interface ProcessStatementQueryParam {
+    [key: string]: any;
+}
+export interface ProcessStatementParams {
+    args: ProcessStatementArgsParam;
+    query: ProcessStatementQueryParam;
+}
+export interface ProcessStatementCallable {
+    (params: ProcessStatementParams): void;
+}
+export interface Query {
+    [key: string]: string;
+}
+export interface QueryKeyField {
+    name: string;
+}
+export interface QueryKey {
+    fields: QueryKeyField[];
+    primary?: boolean;
+    unique?: boolean;
+    name: string;
+}
+export declare type QueryKeys = QueryKey[];
+export declare type QuerySort = Record<string, -1 | 1>;
 export {};

package/utils/cursor.d.ts

@@ -1,2 +1,2 @@
-export declare const encodeCursor: (cursor?: any) => string;
-export declare const decodeCursor: (cursor?: string) => any;
+export declare const encodeCursor: (cursor?: any) => string | null;
+export declare const decodeCursor: (cursor?: string) => string | null;

package/utils/filter.js

@@ -15,6 +15,9 @@ var _ValueFilterPlugin = require("../plugins/definitions/ValueFilterPlugin");
 
 const getMappedPlugins = params => {
   return params.plugins.byType(params.type).reduce((plugins, plugin) => {
+    /**
+     * We expect op to be a string, that is why we cast.
+     */
     const op = plugin[params.property];
     plugins[op] = plugin;
     return plugins;

package/utils/listResponse.js

@@ -14,7 +14,12 @@ const createListResponse = params => {
     totalCount,
     limit
   } = params;
-  const start = (0, _cursor.decodeCursor)(after) || 0;
+  let start = Number((0, _cursor.decodeCursor)(after));
+
+  if (isNaN(start) === true) {
+    start = 0;
+  }
+
   const hasMoreItems = totalCount > start + limit;
   const end = limit > totalCount + start + limit ? undefined : start + limit;
   const items = end ? initialItems.slice(start, end) : initialItems;