@baadal-sdk/dapi 0.31.5 → 1.0.0

package/dist/index.js

@@ -0,0 +1,1118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  aws: () => aws_exports,
+  default: () => index_default,
+  fs: () => fs_exports,
+  gh: () => gh_exports,
+  utils: () => utils_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/fs/index.ts
+var fs_exports = {};
+__export(fs_exports, {
+  appendToFile: () => appendToFile,
+  createDir: () => createDir,
+  deleteDir: () => deleteDir,
+  deleteFile: () => deleteFile,
+  existsDirSync: () => existsDirSync,
+  existsFileSync: () => existsFileSync,
+  readDir: () => readDir,
+  readDirDirs: () => readDirDirs,
+  readDirFiles: () => readDirFiles,
+  readDirFilesRec: () => readDirFilesRec,
+  readFile: () => readFile,
+  readFileSync: () => readFileSync,
+  renameFile: () => renameFile,
+  writeFile: () => writeFile
+});
+var import_node_util = __toESM(require("util"));
+var import_node_fs = __toESM(require("fs"));
+var import_promises2 = __toESM(require("fs/promises"));
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  arrayToMap: () => arrayToMap,
+  assertPath: () => assertPath,
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  chunkifyArray: () => chunkifyArray,
+  fileHash: () => fileHash,
+  sha1Hash: () => sha1Hash,
+  sha256Hash: () => sha256Hash
+});
+
+// src/utils/crypto.ts
+var import_node_crypto = __toESM(require("crypto"));
+function sha1Hash(input) {
+  const hash = import_node_crypto.default.createHash("sha1").update(input, "utf8").digest("hex");
+  return hash;
+}
+function sha256Hash(input) {
+  if (!input) return null;
+  const hashSum = import_node_crypto.default.createHash("sha256");
+  hashSum.update(input);
+  return hashSum.digest("hex");
+}
+
+// src/utils/utils.ts
+var import_node_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_js_base64 = require("js-base64");
+
+// src/common/logger.ts
+var warn = console.warn;
+var error = console.error;
+
+// src/utils/utils.ts
+var assertPath = (p) => {
+  if (!p || p.startsWith("/")) return p;
+  return import_node_path.default.resolve(process.cwd(), p);
+};
+var fileHash = async (file) => {
+  if (!file) return null;
+  let contents = null;
+  try {
+    contents = await import_promises.default.readFile(file);
+  } catch (e) {
+    error(e);
+    return null;
+  }
+  return sha256Hash(contents);
+};
+var base64Encode = (data) => {
+  return (0, import_js_base64.encode)(data);
+};
+var base64Decode = (base64) => {
+  return (0, import_js_base64.decode)(base64);
+};
+var arrayToMap = (arr, key) => {
+  if (!arr || !Array.isArray(arr)) return null;
+  const map = /* @__PURE__ */ new Map();
+  if (!arr.length) return map;
+  if (!key && typeof arr[0] !== "string" && typeof arr[0] !== "number") return null;
+  arr.forEach((item) => {
+    if (!key) {
+      map.set(`${item}`, true);
+    } else if (typeof item === "object") {
+      const itemKey = item[key];
+      if (itemKey && typeof itemKey === "string") {
+        map.set(itemKey, item);
+      }
+    }
+  });
+  return map.size ? map : null;
+};
+var chunkifyArray = (arr, chunkSize) => {
+  const chunkedItems = [];
+  for (let i = 0; i < arr.length; i += chunkSize) {
+    const chunk = arr.slice(i, i + chunkSize);
+    chunkedItems.push(chunk);
+  }
+  return chunkedItems;
+};
+
+// src/common/error.ts
+var CustomError = class _CustomError extends Error {
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CustomError);
+    }
+    this.name = options.name || "CustomError";
+  }
+};
+
+// src/fs/index.ts
+var existsFileSync = (file, loud = false) => {
+  if (!file) return null;
+  file = assertPath(file);
+  try {
+    if (!import_node_fs.default.existsSync(file)) {
+      if (!loud) return false;
+      throw new CustomError(`File does not exist: ${file}`);
+    }
+  } catch (e) {
+    if (!loud) return null;
+    if (e instanceof CustomError) {
+      throw e;
+    } else {
+      throw new CustomError(`Error while accessing file: ${file}`);
+    }
+  }
+  return true;
+};
+var existsDirSync = (dir, loud = false) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  try {
+    if (!import_node_fs.default.existsSync(dir)) {
+      if (!loud) return false;
+      throw new CustomError(`Directory does not exist: ${dir}`);
+    }
+  } catch (e) {
+    if (!loud) return null;
+    if (e instanceof CustomError) {
+      throw e;
+    } else {
+      throw new CustomError(`Error while accessing directory: ${dir}`);
+    }
+  }
+  return true;
+};
+var readFile = async (file, warn2 = false) => {
+  if (!file) return null;
+  file = assertPath(file);
+  let contents = null;
+  try {
+    contents = await import_promises2.default.readFile(file, "utf8");
+  } catch (e) {
+    if (warn2) warn(`Cannot read file: ${file}`);
+  }
+  return contents;
+};
+var readFileSync = (file, warn2 = false) => {
+  if (!file) return null;
+  file = assertPath(file);
+  let contents = null;
+  try {
+    contents = import_node_fs.default.readFileSync(file, "utf8");
+  } catch (e) {
+    if (warn2) warn(`Cannot read file: ${file}`);
+  }
+  return contents;
+};
+var readDir = async (dir, warn2 = false, hiddenItems = false) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  let dirs = [];
+  let files = [];
+  try {
+    const items = await import_promises2.default.readdir(dir, { withFileTypes: true });
+    items.forEach((item) => {
+      if (item.isDirectory()) {
+        dirs.push(item.name);
+      } else if (item.isFile()) {
+        files.push(item.name);
+      }
+    });
+  } catch (e) {
+    if (warn2) warn(`Cannot read dir: ${dir}`);
+    return null;
+  }
+  if (!hiddenItems) {
+    dirs = dirs.filter((d) => !d.startsWith("."));
+    files = files.filter((f) => !f.startsWith("."));
+  }
+  return { dirs, files };
+};
+var readDirFiles = async (dir, warn2 = false, hiddenItems = false) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  return (await readDir(dir, warn2, hiddenItems))?.files || null;
+};
+var readDirDirs = async (dir, warn2 = false, hiddenItems = false) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  return (await readDir(dir, warn2, hiddenItems))?.dirs || null;
+};
+var readDirFilesRecHelper = async (dir, basePath = "") => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  const dirPath = basePath ? `${dir}/${basePath}` : dir;
+  const readDirObj = await readDir(dirPath);
+  if (!readDirObj) return null;
+  const { dirs, files } = readDirObj;
+  let allFiles = files || [];
+  allFiles = allFiles.map((file) => basePath ? `${basePath}/${file}` : file);
+  const absDirs = (dirs || []).map((d) => basePath ? `${basePath}/${d}` : d);
+  const pList = absDirs.map((dirx) => readDirFilesRecHelper(dir, dirx));
+  const filesxList = await Promise.all(pList);
+  filesxList.forEach((filesx) => {
+    if (filesx) {
+      allFiles = [...allFiles, ...filesx];
+    }
+  });
+  return allFiles;
+};
+var readDirFilesRec = async (dir, hiddenItems = false) => {
+  let allFiles = await readDirFilesRecHelper(dir);
+  if (!hiddenItems) {
+    if (allFiles) allFiles = allFiles.filter((f) => !f.startsWith("."));
+  }
+  return allFiles;
+};
+var writeFile = async (file, contents) => {
+  if (!file || !contents) return null;
+  file = assertPath(file);
+  try {
+    const dir = file.substring(0, file.lastIndexOf("/"));
+    await import_promises2.default.mkdir(dir, { recursive: true });
+    await import_promises2.default.writeFile(file, contents);
+  } catch (e) {
+    console.error(`Error while writing to ${file}`, e);
+    return null;
+  }
+  return true;
+};
+var appendToFile = async (file, contents) => {
+  if (!file || !contents) return null;
+  file = assertPath(file);
+  try {
+    const dir = file.substring(0, file.lastIndexOf("/"));
+    await import_promises2.default.mkdir(dir, { recursive: true });
+    await import_promises2.default.appendFile(file, contents + "\n");
+  } catch (e) {
+    console.error(`Error while appending to ${file}`, e);
+    return null;
+  }
+  return true;
+};
+var renameFile = async (oldpath, newpath) => {
+  if (!oldpath || !newpath) return null;
+  oldpath = assertPath(oldpath);
+  newpath = assertPath(newpath);
+  try {
+    await import_promises2.default.rename(oldpath, newpath);
+  } catch (e) {
+    console.error(`Error while renaming file ${oldpath} to ${newpath}`, e);
+    return null;
+  }
+  return true;
+};
+var createDir = async (dir) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  try {
+    if (!existsDirSync(dir)) {
+      await import_promises2.default.mkdir(dir, { recursive: true });
+    }
+  } catch (e) {
+    console.error(`Error while creating directory: ${dir}`, e);
+    return null;
+  }
+  return true;
+};
+var deleteFile = async (file) => {
+  if (!file) return null;
+  file = assertPath(file);
+  try {
+    await import_promises2.default.unlink(file);
+  } catch (e) {
+    console.error(`Error while deleting file ${file}`, e);
+    return null;
+  }
+  return true;
+};
+var deleteDir = async (dir) => {
+  if (!dir) return null;
+  dir = assertPath(dir);
+  try {
+    const rimraf = require("rimraf");
+    const rimrafPr = import_node_util.default.promisify(rimraf);
+    await rimrafPr(dir);
+  } catch (e) {
+    console.error(`Error while deleting dir ${dir}`, e);
+    return null;
+  }
+  return true;
+};
+
+// src/aws/index.ts
+var aws_exports = {};
+__export(aws_exports, {
+  db: () => db_exports,
+  init: () => init3,
+  s3: () => s3_exports,
+  status: () => status3
+});
+
+// src/aws/db.ts
+var db_exports = {};
+__export(db_exports, {
+  deleteItem: () => deleteItem,
+  deleteItemsAll: () => deleteItemsAll,
+  init: () => init,
+  queryItems: () => queryItems,
+  readItem: () => readItem,
+  readItemsAll: () => readItemsAll,
+  scanItems: () => scanItems,
+  status: () => status,
+  updateItem: () => updateItem,
+  writeItem: () => writeItem,
+  writeItemForce: () => writeItemForce,
+  writeItemUnique: () => writeItemUnique,
+  writeItemsAll: () => writeItemsAll
+});
+var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+var import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+var short = __toESM(require("short-uuid"));
+
+// src/aws/client.ts
+var dbDocClient = null;
+var awsS3Client = null;
+var dbClient = { client: dbDocClient, id: null };
+var s3Client = { client: awsS3Client, id: null };
+
+// src/common/const.ts
+var BATCH_SIZE = 20;
+var CHUNK_SIZE = 10;
+var MAX_RETRY_ATTEMPTS = 3;
+
+// src/aws/db.ts
+var DynamoDBError = (msg) => new CustomError(msg, { name: "DynamoDBError" });
+var init = async (_region) => {
+  let region = _region ?? process.env.AWS_REGION;
+  if (!region) {
+    const client = new import_client_dynamodb.DynamoDBClient({});
+    region = await client.config.region();
+  }
+  if (region && !dbClient.client) {
+    const dydbClient = new import_client_dynamodb.DynamoDBClient({ region });
+    dbClient.client = import_lib_dynamodb.DynamoDBDocumentClient.from(dydbClient);
+    dbClient.id = short.generate();
+    return true;
+  }
+  return !!dbClient.client;
+};
+var status = () => dbClient.id;
+var tryInit = async (silent = false) => {
+  if (dbClient.client) return;
+  if (await init()) {
+    return;
+  }
+  if (!silent) {
+    throw DynamoDBError("Could not auto-initialize DynamoDB!");
+  }
+};
+(async () => {
+  await tryInit(true);
+})();
+var writeItemForceHelper = async (table, item, key, i, imax) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!table || !item) return null;
+  if (!item[key]) {
+    item[key] = short.generate();
+  }
+  const cmdParams = { TableName: table, Item: item, ConditionExpression: `attribute_not_exists(${key})` };
+  const command = new import_lib_dynamodb.PutCommand(cmdParams);
+  const numberOfAttempts = imax ?? MAX_RETRY_ATTEMPTS;
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    if (err.name === "ConditionalCheckFailedException") {
+      if (i < numberOfAttempts - 1) {
+        item[key] = short.generate();
+        const ret = await writeItemForceHelper(table, item, key, i + 1, imax);
+        return ret;
+      }
+      console.error("PutCommandInput:", cmdParams);
+      if (numberOfAttempts === 1) {
+        error(`[ERROR] An item with the same key(${item[key]}) already exists!`);
+      } else {
+        error("[ERROR] Maximum attempts overflow!");
+      }
+    }
+    return null;
+  }
+  return item;
+};
+var writeItemForce = async (input) => {
+  const key = input.key || "id";
+  return writeItemForceHelper(input.table, input.item, key, 0);
+};
+var writeItemUnique = async (input) => {
+  const key = input.key || "id";
+  return writeItemForceHelper(input.table, input.item, key, 0, 1);
+};
+var writeItem = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.item) return null;
+  const cmdParams = { TableName: input.table, Item: input.item };
+  const command = new import_lib_dynamodb.PutCommand(cmdParams);
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    console.error("PutCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var batchWriteItems = async (table, items) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!table || !items || !Array.isArray(items)) return null;
+  if (!items.length) return true;
+  const reqList = items.map((item) => ({ PutRequest: { Item: item } }));
+  const cmdParams = {
+    RequestItems: {
+      [table]: reqList
+    }
+  };
+  const command = new import_lib_dynamodb.BatchWriteCommand(cmdParams);
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    console.error("BatchWriteCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var writeItemsAll = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.items || !Array.isArray(input.items)) return null;
+  if (!input.items.length) return true;
+  let errFlag = false;
+  const batchedItems = chunkifyArray(input.items, BATCH_SIZE);
+  const chunkedItems = chunkifyArray(batchedItems, CHUNK_SIZE);
+  for (let i = 0; i < chunkedItems.length; i += 1) {
+    const bchunks = chunkedItems[i] ?? [];
+    const brlist = bchunks.map((iItems) => batchWriteItems(input.table, iItems));
+    const bslist = await Promise.all(brlist);
+    const isSuccess = bslist.every((e) => e === true);
+    if (!isSuccess) errFlag = true;
+  }
+  return errFlag ? null : true;
+};
+var updateItem = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.key || !input.update || !input.attr) return null;
+  let cmdParams = {
+    TableName: input.table,
+    Key: input.key,
+    UpdateExpression: input.update,
+    ExpressionAttributeValues: input.attr
+  };
+  if (input.attrNames) cmdParams = { ...cmdParams, ExpressionAttributeNames: input.attrNames };
+  const command = new import_lib_dynamodb.UpdateCommand(cmdParams);
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    console.error("UpdateCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var readItem = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.key) return null;
+  let contents = null;
+  let cmdParams = { TableName: input.table, Key: input.key, ConsistentRead: true };
+  if (input.projection) cmdParams = { ...cmdParams, ProjectionExpression: input.projection };
+  if (input.attrNames) cmdParams = { ...cmdParams, ExpressionAttributeNames: input.attrNames };
+  const command = new import_lib_dynamodb.GetCommand(cmdParams);
+  try {
+    const results = await dbClient.client.send(command);
+    const item = results.Item;
+    if (item) {
+      contents = item;
+    }
+  } catch (err) {
+    console.error("GetCommandInput:", cmdParams);
+    console.error(err);
+    if (input.loud) {
+      throw err;
+    } else {
+      return null;
+    }
+  }
+  return contents;
+};
+var batchReadItems = async (table, keys, projection, attrNames) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!table || !keys || !Array.isArray(keys)) return null;
+  if (!keys.length) return [];
+  let contents = [];
+  let reqParams = { Keys: keys };
+  if (projection) reqParams = { ...reqParams, ProjectionExpression: projection };
+  if (attrNames) reqParams = { ...reqParams, ExpressionAttributeNames: attrNames };
+  const cmdParams = {
+    RequestItems: {
+      [table]: reqParams
+    }
+  };
+  const command = new import_lib_dynamodb.BatchGetCommand(cmdParams);
+  try {
+    const results = await dbClient.client.send(command);
+    const items = results.Responses;
+    if (items && items[table]) {
+      contents = items[table];
+    }
+  } catch (err) {
+    console.error("BatchGetCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return contents;
+};
+var readItemsAll = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.keys || !Array.isArray(input.keys)) return null;
+  if (!input.keys.length) return [];
+  let contents = [];
+  let errFlag = false;
+  const batchedKeys = chunkifyArray(input.keys, BATCH_SIZE);
+  const chunkedKeys = chunkifyArray(batchedKeys, CHUNK_SIZE);
+  for (let i = 0; i < chunkedKeys.length; i += 1) {
+    const bchunks = chunkedKeys[i] ?? [];
+    const brlist = bchunks.map((ikeys) => batchReadItems(input.table, ikeys, input.projection, input.attrNames));
+    const bslist = await Promise.all(brlist);
+    const icontents = bslist.flat();
+    const isError = icontents.find((e) => e === null) === null;
+    if (isError) {
+      errFlag = true;
+      return null;
+    }
+    if (!errFlag) {
+      contents = contents.concat(icontents);
+    }
+  }
+  return contents;
+};
+var queryItems = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.cond || !input.attr) return null;
+  let contents = [];
+  const desc = input.desc || false;
+  let cmdParams = {
+    TableName: input.table,
+    KeyConditionExpression: input.cond,
+    ExpressionAttributeValues: input.attr
+    // FilterExpression: "contains (category_id, :cid)",
+  };
+  if (input.indexName) cmdParams = { ...cmdParams, IndexName: input.indexName };
+  if (input.attrNames) cmdParams = { ...cmdParams, ExpressionAttributeNames: input.attrNames };
+  if (input.projection) cmdParams = { ...cmdParams, ProjectionExpression: input.projection };
+  if (desc) cmdParams = { ...cmdParams, ScanIndexForward: false };
+  const command = new import_lib_dynamodb.QueryCommand(cmdParams);
+  try {
+    const results = await dbClient.client.send(command);
+    const items = results.Items;
+    if (items) {
+      contents = items;
+    }
+  } catch (err) {
+    console.error("QueryCommandInput:", command.input);
+    console.error(err);
+    return null;
+  }
+  return contents;
+};
+var scanItems = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table) return null;
+  let contents = [];
+  let cmdParams = {
+    TableName: input.table
+  };
+  if (input.projection) cmdParams = { ...cmdParams, ProjectionExpression: input.projection };
+  const command = new import_lib_dynamodb.ScanCommand(cmdParams);
+  try {
+    const results = await dbClient.client.send(command);
+    const items = results.Items;
+    if (results.LastEvaluatedKey) {
+      warn("[scanItems] Partial results obtained! Consider pagination.");
+    }
+    if (items) {
+      contents = items;
+    }
+  } catch (err) {
+    console.error("ScanCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return contents;
+};
+var deleteItem = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.key) return null;
+  const cmdParams = { TableName: input.table, Key: input.key };
+  const command = new import_lib_dynamodb.DeleteCommand(cmdParams);
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    console.error("DeleteCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var batchDeleteItems = async (table, keys) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!table || !keys || !Array.isArray(keys)) return null;
+  if (!keys.length) return true;
+  const reqList = keys.map((key) => ({ DeleteRequest: { Key: key } }));
+  const cmdParams = {
+    RequestItems: {
+      [table]: reqList
+    }
+  };
+  const command = new import_lib_dynamodb.BatchWriteCommand(cmdParams);
+  try {
+    await dbClient.client.send(command);
+  } catch (err) {
+    console.error("BatchWriteCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var deleteItemsAll = async (input) => {
+  if (!dbClient.client) await tryInit();
+  if (!dbClient.client) return null;
+  if (!input.table || !input.keys || !Array.isArray(input.keys)) return null;
+  if (!input.keys.length) return true;
+  let errFlag = false;
+  const batchedItems = chunkifyArray(input.keys, BATCH_SIZE);
+  const chunkedItems = chunkifyArray(batchedItems, CHUNK_SIZE);
+  for (let i = 0; i < chunkedItems.length; i += 1) {
+    const bchunks = chunkedItems[i] ?? [];
+    const brlist = bchunks.map((ikeys) => batchDeleteItems(input.table, ikeys));
+    const bslist = await Promise.all(brlist);
+    const isSuccess = bslist.every((e) => e === true);
+    if (!isSuccess) errFlag = true;
+  }
+  return errFlag ? null : true;
+};
+
+// src/aws/s3.ts
+var s3_exports = {};
+__export(s3_exports, {
+  deleteObject: () => deleteObject,
+  deleteObjectsAll: () => deleteObjectsAll,
+  downloadFile: () => downloadFile,
+  getObject: () => getObject,
+  getObjectHead: () => getObjectHead,
+  getObjectHeadsAll: () => getObjectHeadsAll,
+  init: () => init2,
+  listObjects: () => listObjects,
+  putObject: () => putObject,
+  status: () => status2,
+  uploadFile: () => uploadFile,
+  uploadFilesAll: () => uploadFilesAll
+});
+var import_node_path2 = __toESM(require("path"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_client_s3 = require("@aws-sdk/client-s3");
+var short2 = __toESM(require("short-uuid"));
+var import_mime_types = __toESM(require("mime-types"));
+var AWSS3Error = (msg) => new CustomError(msg, { name: "AWSS3Error" });
+var init2 = async (_region) => {
+  let region = _region ?? process.env.AWS_REGION;
+  if (!region) {
+    const client = new import_client_s3.S3Client({});
+    region = await client.config.region();
+  }
+  if (region && !s3Client.client) {
+    const awsS3Client2 = new import_client_s3.S3Client({ region });
+    s3Client.client = awsS3Client2;
+    s3Client.id = short2.generate();
+    return true;
+  }
+  return !!s3Client.client;
+};
+var status2 = () => s3Client.id;
+var tryInit2 = async (silent = false) => {
+  if (s3Client.client) return;
+  if (await init2()) {
+    return;
+  }
+  if (!silent) {
+    throw AWSS3Error("Could not auto-initialize AWS S3!");
+  }
+};
+(async () => {
+  await tryInit2(true);
+})();
+var putObject = async (bucket, s3path, contents) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3path || !contents) return null;
+  let baseParams = null;
+  try {
+    baseParams = {
+      Bucket: bucket,
+      Key: s3path,
+      Body: "<contents>",
+      ContentType: "text/plain; charset=utf-8"
+      // CacheControl: 'max-age=86400,public',
+    };
+    const cmdParams = { ...baseParams, Body: contents };
+    const command = new import_client_s3.PutObjectCommand(cmdParams);
+    await s3Client.client.send(command);
+  } catch (err) {
+    console.error("PutObjectCommandInput:", baseParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var uploadFile = async (bucket, file, s3path) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !file) return null;
+  const filepath = assertPath(file);
+  const basename = import_node_path2.default.basename(filepath);
+  const ext = basename.substr(basename.lastIndexOf("."));
+  const contentType = import_mime_types.default.lookup(ext);
+  if (!contentType) {
+    error(`Could not detect file type for: ${basename} [${filepath}]`);
+    return null;
+  }
+  if (!s3path) {
+    if (file !== filepath) {
+      s3path = file;
+    } else {
+      s3path = basename;
+    }
+  }
+  let baseParams = null;
+  try {
+    const hash = await fileHash(filepath) || "";
+    const fileStream = import_node_fs2.default.createReadStream(filepath);
+    baseParams = {
+      Bucket: bucket,
+      Key: s3path,
+      Body: "<fileStream>",
+      ContentType: contentType,
+      // CacheControl: 'max-age=86400,public',
+      Metadata: { hash }
+    };
+    const cmdParams = { ...baseParams, Body: fileStream };
+    const command = new import_client_s3.PutObjectCommand(cmdParams);
+    await s3Client.client.send(command);
+  } catch (err) {
+    console.error("PutObjectCommandInput:", baseParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var uploadFilesAll = async (bucket, files, s3paths) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !files || !Array.isArray(files)) return null;
+  if (!files.length) return true;
+  if (s3paths && (!Array.isArray(s3paths) || !s3paths.length || files.length !== s3paths.length)) return null;
+  let errFlag = false;
+  const chunkedFiles = chunkifyArray(files, CHUNK_SIZE);
+  const chunkedPaths = s3paths ? chunkifyArray(s3paths, CHUNK_SIZE) : chunkedFiles;
+  for (let i = 0; i < chunkedFiles.length; i += 1) {
+    const filesChunk = chunkedFiles[i] ?? [];
+    const pathsChunk = chunkedPaths[i] ?? [];
+    const pList = filesChunk.map((item, j) => uploadFile(bucket, item, pathsChunk[j]));
+    const rList = await Promise.all(pList);
+    const isSuccess = rList.every((e) => e === true);
+    if (!isSuccess) errFlag = true;
+  }
+  return errFlag ? null : true;
+};
+var getObject = async (bucket, s3path) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3path) return null;
+  let contents = null;
+  const cmdParams = { Bucket: bucket, Key: s3path };
+  const command = new import_client_s3.GetObjectCommand(cmdParams);
+  try {
+    const streamToString = (stream) => new Promise((resolve, reject) => {
+      const chunks = [];
+      stream.on("data", (chunk) => chunks.push(chunk));
+      stream.on("error", reject);
+      stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    });
+    const data = await s3Client.client.send(command);
+    const bodyContents = await streamToString(data.Body);
+    if (bodyContents) {
+      contents = bodyContents;
+    }
+  } catch (err) {
+    console.error("GetObjectCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return contents;
+};
+var downloadFile = async (bucket, s3path, outPath) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3path) return null;
+  if (!outPath) outPath = s3path;
+  outPath = assertPath(outPath);
+  const cmdParams = { Bucket: bucket, Key: s3path };
+  const command = new import_client_s3.GetObjectCommand(cmdParams);
+  try {
+    const writeStreamToFile = (stream) => new Promise((resolve, reject) => {
+      const writeStream = import_node_fs2.default.createWriteStream(outPath);
+      stream.on("data", (chunk) => writeStream.write(chunk));
+      stream.on("error", reject);
+      stream.on("end", () => resolve(writeStream.close()));
+    });
+    const data = await s3Client.client.send(command);
+    await writeStreamToFile(data.Body);
+  } catch (err) {
+    if (err.name !== "NoSuchKey") {
+      console.error("GetObjectCommandInput:", cmdParams);
+      console.error(err);
+    }
+    return null;
+  }
+  return true;
+};
+var listObjects = async (bucket, prefix) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket) return null;
+  let filesList = [];
+  let cmdParams = { Bucket: bucket };
+  if (prefix) cmdParams = { ...cmdParams, Prefix: prefix };
+  const command = new import_client_s3.ListObjectsV2Command(cmdParams);
+  try {
+    const results = await s3Client.client.send(command);
+    const items = results.Contents;
+    if (results.IsTruncated) {
+      warn("[listObjects] Partial results obtained! Consider pagination.");
+    }
+    if (items) {
+      filesList = items.map((t) => t.Key).filter((e) => !!e);
+    }
+  } catch (err) {
+    console.error("ListObjectsV2CommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return filesList;
+};
+var getObjectHead = async (bucket, s3path) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3path) return null;
+  let contents = null;
+  const cmdParams = { Bucket: bucket, Key: s3path };
+  const command = new import_client_s3.HeadObjectCommand(cmdParams);
+  try {
+    const data = await s3Client.client.send(command);
+    if (data) {
+      const { ContentLength, ContentType, ETag, CacheControl, Expires, LastModified, Metadata } = data;
+      contents = { Key: s3path, ContentLength, ContentType, ETag, CacheControl, Expires, LastModified, Metadata };
+    }
+  } catch (err) {
+    if (err.name !== "NotFound") {
+      console.error("HeadObjectCommandInput:", cmdParams);
+      console.error(err);
+    }
+    return null;
+  }
+  return contents;
+};
+var getObjectHeadsAll = async (bucket, s3paths) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3paths || !Array.isArray(s3paths)) return null;
+  if (!s3paths.length) return [];
+  let contents = [];
+  const chunkedItems = chunkifyArray(s3paths, CHUNK_SIZE);
+  for (let i = 0; i < chunkedItems.length; i += 1) {
+    const chunk = chunkedItems[i] ?? [];
+    const pList = chunk.map((item) => getObjectHead(bucket, item));
+    const rList = await Promise.all(pList);
+    contents = contents.concat(rList);
+  }
+  if (contents.length) {
+    contents = contents.filter((e) => !!e);
+  }
+  return contents;
+};
+var deleteObject = async (bucket, s3path) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3path) return null;
+  const cmdParams = { Bucket: bucket, Key: s3path };
+  const command = new import_client_s3.DeleteObjectCommand(cmdParams);
+  try {
+    await s3Client.client.send(command);
+  } catch (err) {
+    console.error("DeleteObjectCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var batchDeleteObjects = async (bucket, s3paths) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3paths || !Array.isArray(s3paths)) return null;
+  if (!s3paths.length) return true;
+  const keys = s3paths.map((key) => ({ Key: key }));
+  const cmdParams = { Bucket: bucket, Delete: { Objects: keys } };
+  const command = new import_client_s3.DeleteObjectsCommand(cmdParams);
+  try {
+    await s3Client.client.send(command);
+  } catch (err) {
+    console.error("DeleteObjectsCommandInput:", cmdParams);
+    console.error(err);
+    return null;
+  }
+  return true;
+};
+var deleteObjectsAll = async (bucket, s3paths) => {
+  if (!s3Client.client) await tryInit2();
+  if (!s3Client.client) return null;
+  if (!bucket || !s3paths || !Array.isArray(s3paths)) return null;
+  if (!s3paths.length) return true;
+  let errFlag = false;
+  const batchedFiles = chunkifyArray(s3paths, BATCH_SIZE);
+  const chunkedFiles = chunkifyArray(batchedFiles, CHUNK_SIZE);
+  for (let i = 0; i < chunkedFiles.length; i += 1) {
+    const batchFiles = chunkedFiles[i] ?? [];
+    const brlist = batchFiles.map((paths) => batchDeleteObjects(bucket, paths));
+    const bslist = await Promise.all(brlist);
+    const isSuccess = bslist.every((e) => e === true);
+    if (!isSuccess) errFlag = true;
+  }
+  return errFlag ? null : true;
+};
+
+// src/aws/index.ts
+var { init: dbInit, status: dbStatus } = db_exports;
+var { init: s3Init, status: s3Status } = s3_exports;
+var init3 = async (region) => {
+  warn("[@baadal-sdk/dapi] aws explicit init deprecated!");
+  if (!region) {
+    error(`AWS initialization error! Missing region: ${region}`);
+    return false;
+  }
+  const cond1 = await dbInit(region);
+  const cond2 = await s3Init(region);
+  return cond1 && cond2;
+};
+var status3 = () => {
+  return {
+    db: dbStatus(),
+    s3: s3Status()
+  };
+};
+
+// src/gh/index.ts
+var gh_exports = {};
+__export(gh_exports, {
+  GitHubClient: () => GitHubClient,
+  getInstance: () => getInstance
+});
+var import_octokit = require("octokit");
+var GitHubError = (msg, cause) => new CustomError(msg, { name: "GitHubError", cause });
+function getInstance(authToken, owner) {
+  return new GitHubClient(authToken, owner);
+}
+var GitHubClient = class {
+  client;
+  owner;
+  constructor(authToken, owner) {
+    if (!authToken) {
+      throw GitHubError("Missing GitHub auth token");
+    }
+    if (!owner) {
+      throw GitHubError("Missing GitHub owner");
+    }
+    this.client = new import_octokit.Octokit({ auth: authToken });
+    this.owner = owner;
+  }
+  /**
+   * Get contents of a particular file in a repo
+   * @param repo name of the repo
+   * @param path path of a file in the repo
+   * @returns an object {data, headers} containing normalized file content and response headers
+   * @throws {GitHubError} in case of failure or invalid response
+   */
+  async getContent(repo, path3) {
+    if (!repo || !path3) {
+      throw GitHubError("Missing required parameters: repo or path");
+    }
+    try {
+      const response = await this.client.rest.repos.getContent({
+        owner: this.owner,
+        repo,
+        path: path3
+      });
+      if (Array.isArray(response.data)) {
+        throw GitHubError("Expected a file but received a directory");
+      }
+      if (!("content" in response.data)) {
+        throw GitHubError("Invalid response: missing file content");
+      }
+      const decodedContent = Buffer.from(
+        response.data.content,
+        "base64"
+      ).toString("utf-8");
+      return {
+        data: {
+          path: response.data.path,
+          content: decodedContent,
+          sha: response.data.sha
+        },
+        headers: response.headers
+      };
+    } catch (err) {
+      throw GitHubError(
+        `[GitHub:getContent] Failed to fetch ${this.owner}/${repo}/${path3}`,
+        err
+      );
+    }
+  }
+};
+
+// src/index.ts
+var index_default = { fs: fs_exports, aws: aws_exports, gh: gh_exports, utils: utils_exports };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aws,
+  fs,
+  gh,
+  utils
+});
+//# sourceMappingURL=index.js.map