@baadal-sdk/dapi 0.31.1 → 0.31.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baadal-sdk/dapi",
-  "version": "0.31.1",
+  "version": "0.31.4",
   "description": "Dead-simple API wrappers",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/src/aws/db.ts

@@ -33,7 +33,7 @@ import { dbClient } from './client';
 import { StringIndexable } from '../common/common.model';
 import { CustomError } from '../common/error';
 import { warn, error } from '../common/logger';
-import { BATCH_SIZE, CHUNK_SIZE } from '../common/const';
+import { BATCH_SIZE, CHUNK_SIZE, MAX_RETRY_ATTEMPTS } from '../common/const';
 
 const DynamoDBError = (msg: string) => new CustomError(msg, { name: 'DynamoDBError' });
 
@@ -70,7 +70,13 @@ const tryInit = (silent = false) => {
 // auto-initialize on load
 tryInit(true);
 
-const writeItemForceHelper = async <T = any>(table: string, item: T, key: string, i: number): Promise<T | null> => {
+const writeItemForceHelper = async <T = any>(
+  table: string,
+  item: T,
+  key: string,
+  i: number,
+  imax?: number
+): Promise<T | null> => {
   if (!dbClient.client) tryInit();
   if (!dbClient.client) return null;
   if (!table || !item) return null;
@@ -80,7 +86,7 @@ const writeItemForceHelper = async <T = any>(table: string, item: T, key: string
   }
   const cmdParams: PutCommandInput = { TableName: table, Item: item, ConditionExpression: `attribute_not_exists(${key})` };
   const command = new PutCommand(cmdParams);
-  const numberOfAttempts = 3;
+  const numberOfAttempts = imax ?? MAX_RETRY_ATTEMPTS;
 
   try {
     await dbClient.client.send(command);
@@ -88,11 +94,15 @@ const writeItemForceHelper = async <T = any>(table: string, item: T, key: string
     if (err.name === 'ConditionalCheckFailedException') {
       if (i < numberOfAttempts - 1) {
         (item as any)[key] = short.uuid(); // new primary key
-        const ret: T | null = await writeItemForceHelper(table, item, key, i + 1);
+        const ret: T | null = await writeItemForceHelper(table, item, key, i + 1, imax);
         return ret;
       }
       console.error('PutCommandInput:', cmdParams);
-      error('[ERROR] Maximum attempts overflow!');
+      if (numberOfAttempts === 1) {
+        error(`[ERROR] An item with the same key(${(item as any)[key]}) already exists!`);
+      } else {
+        error('[ERROR] Maximum attempts overflow!');
+      }
     }
     return null;
   }
@@ -106,6 +116,8 @@ export interface WriteItemForceInput<T = any> {
   key?: string;
 }
 
+export type WriteItemUniqueInput<T = any> = WriteItemForceInput<T>;
+
 /**
  * Write an item to a DynamoDB table, retry in case of key conflict
  * @param input input command object
@@ -130,6 +142,32 @@ export const writeItemForce = async <T = any>(input: WriteItemForceInput<T>): Pr
   return writeItemForceHelper<T>(input.table, input.item, key, 0);
 };
 
+/**
+ * Write an item (uniquely) to a DynamoDB table.
+ * Unlike `writeItemForce`, it does not retry in case of key conflict
+ * Unlike `writeItem`, it does not overwrite an item with the same key (if it exists)
+ * @param input input command object
+ * @returns the created item, null in case of error or key conflict (i.e., if item with same key already exists)
+ *
+ * ```js
+ * writeItemUnique({
+ *   table: 'lesson_list',
+ *   item: { id: 'id_001', title: 'My Lesson' },
+ *   key: 'id',
+ * });
+ *
+ * interface WriteItemUniqueInput<T = any> {
+ *   table: string;
+ *   item: T;
+ *   key?: string; // default: `id`
+ * }
+ * ```
+ */
+export const writeItemUnique = async <T = any>(input: WriteItemUniqueInput<T>): Promise<T | null> => {
+  const key = input.key || 'id';
+  return writeItemForceHelper<T>(input.table, input.item, key, 0, 1);
+};
+
 export interface WriteItemInput {
   table: string;
   item: StringIndexable;
@@ -177,7 +215,7 @@ const batchWriteItems = async (table: string, items: StringIndexable[]) => {
   if (!dbClient.client) tryInit();
   if (!dbClient.client) return null;
   if (!table || !items || !Array.isArray(items)) return null;
-  if (!items.length) return false;
+  if (!items.length) return true;
 
   const reqList = items.map(item => ({ PutRequest: { Item: item } }));
   const cmdParams: BatchWriteCommandInput = {
@@ -206,7 +244,7 @@ export interface WriteItemsAllInput {
 }
 
 /**
- * Write an list of items to a DynamoDB table
+ * Write a list of items to a DynamoDB table
  * @param input input command object
  * @returns true if successful, null in case of error
  *
@@ -226,7 +264,7 @@ export const writeItemsAll = async (input: WriteItemsAllInput) => {
   if (!dbClient.client) tryInit();
   if (!dbClient.client) return null;
   if (!input.table || !input.items || !Array.isArray(input.items)) return null;
-  if (!input.items.length) return false;
+  if (!input.items.length) return true;
 
   let errFlag = false;
 
@@ -308,6 +346,7 @@ export interface ReadItemInput {
   key: StringIndexable;
   projection?: string;
   attrNames?: StringIndexable;
+  loud?: boolean;
 }
 
 /**
@@ -354,8 +393,11 @@ export const readItem = async <T = any>(input: ReadItemInput) => {
   } catch (err) {
     console.error('GetCommandInput:', cmdParams);
     console.error(err);
-    return null;
-    // throw err;
+    if (input.loud) {
+      throw err;
+    } else {
+      return null;
+    }
   }
 
   return contents;
@@ -652,7 +694,7 @@ const batchDeleteItems = async (table: string, keys: StringIndexable[]) => {
   if (!dbClient.client) tryInit();
   if (!dbClient.client) return null;
   if (!table || !keys || !Array.isArray(keys)) return null;
-  if (!keys.length) return false;
+  if (!keys.length) return true;
 
   const reqList = keys.map(key => ({ DeleteRequest: { Key: key } }));
   const cmdParams: BatchWriteCommandInput = {
@@ -701,7 +743,7 @@ export const deleteItemsAll = async (input: DeleteItemsAllInput) => {
   if (!dbClient.client) tryInit();
   if (!dbClient.client) return null;
   if (!input.table || !input.keys || !Array.isArray(input.keys)) return null;
-  if (!input.keys.length) return false;
+  if (!input.keys.length) return true;
 
   let errFlag = false;
 

package/src/aws/s3.ts

@@ -170,13 +170,13 @@ export const uploadFile = async (bucket: string, file: string, s3path?: string)
  * @param bucket S3 bucket name
  * @param files (local) list of file paths to upload
  * @param s3paths [optional] S3 path to be created, if not provided then derived from `file` path
- * @returns true if the write is successful, null in case of error
+ * @returns true if all uploads are successful, null in case of error
  */
 export const uploadFilesAll = async (bucket: string, files: string[], s3paths?: string[]) => {
   if (!s3Client.client) tryInit();
   if (!s3Client.client) return null;
   if (!bucket || !files || !Array.isArray(files)) return null;
-  if (!files.length) return false;
+  if (!files.length) return true;
   if (s3paths && (!Array.isArray(s3paths) || !s3paths.length || files.length !== s3paths.length)) return null;
 
   let errFlag = false;
@@ -383,7 +383,7 @@ export const getObjectHeadsAll = async (bucket: string, s3paths: string[]) => {
     contents = contents.filter(e => !!e);
   }
 
-  return contents;
+  return contents as HeadObject[];
 };
 
 /**
@@ -416,7 +416,7 @@ const batchDeleteObjects = async (bucket: string, s3paths: string[]) => {
   if (!s3Client.client) tryInit();
   if (!s3Client.client) return null;
   if (!bucket || !s3paths || !Array.isArray(s3paths)) return null;
-  if (!s3paths.length) return false;
+  if (!s3paths.length) return true;
 
   const keys = s3paths.map(key => ({ Key: key }));
   const cmdParams: DeleteObjectsCommandInput = { Bucket: bucket, Delete: { Objects: keys } };
@@ -444,7 +444,7 @@ export const deleteObjectsAll = async (bucket: string, s3paths: string[]) => {
   if (!s3Client.client) tryInit();
   if (!s3Client.client) return null;
   if (!bucket || !s3paths || !Array.isArray(s3paths)) return null;
-  if (!s3paths.length) return false;
+  if (!s3paths.length) return true;
 
   let errFlag = false;
 

package/src/common/const.ts

@@ -1,2 +1,3 @@
 export const BATCH_SIZE = 20; // (max) number of items in a batch request
 export const CHUNK_SIZE = 10; // (max) number of parallel requests at a time
+export const MAX_RETRY_ATTEMPTS = 3; // (max) number of retry attempts in case of key conflict