b23-lib 1.1.0

package/dist/index.mjs

@@ -0,0 +1,542 @@
+// src/Dynamodb/index.ts
+import {
+  BatchGetItemCommand,
+  DeleteItemCommand,
+  DynamoDBClient,
+  ExecuteStatementCommand,
+  GetItemCommand,
+  PutItemCommand,
+  QueryCommand,
+  ScanCommand,
+  TransactWriteItemsCommand,
+  UpdateItemCommand,
+  ReturnConsumedCapacity,
+  ReturnValue,
+  ReturnValuesOnConditionCheckFailure,
+  ReturnItemCollectionMetrics
+} from "@aws-sdk/client-dynamodb";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+var DynamoDBUtility = class {
+  client;
+  returnItemCollectionMetrics;
+  logCapacity;
+  region;
+  marshall = marshall;
+  unmarshall = unmarshall;
+  ReturnValue = ReturnValue;
+  ReturnItemCollectionMetrics = ReturnItemCollectionMetrics;
+  ReturnValuesOnConditionCheckFailure = ReturnValuesOnConditionCheckFailure;
+  constructor({ region, returnItemCollectionMetrics = ReturnItemCollectionMetrics.NONE, logCapacity = false }) {
+    this.region = region;
+    this.returnItemCollectionMetrics = returnItemCollectionMetrics;
+    this.logCapacity = logCapacity;
+    this.client = new DynamoDBClient({ region: this.region });
+  }
+  log(message, capacity, size) {
+    if (this.logCapacity) {
+      console.log(message, "Capacity:", capacity, "Size:", size);
+    }
+  }
+  async putItem(TableName, item, condition, attributeName, attributeValue, ReturnValues = ReturnValue.NONE, ReturnValuesOnFailure = ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Item: marshall(item, {
+        removeUndefinedValues: true,
+        convertClassInstanceToMap: true
+      }),
+      ConditionExpression: condition,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new PutItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Put", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return unmarshall(result.Attributes || {});
+  }
+  async transactWriteItems(transactItems) {
+    const input = {
+      TransactItems: transactItems.map((item) => {
+        if (item.Put) {
+          item.Put.Item = marshall(item.Put.Item, {
+            removeUndefinedValues: true,
+            convertClassInstanceToMap: true
+          });
+        }
+        if (item.Update) {
+          item.Update.Key = marshall(item.Update.Key);
+        }
+        if (item.Delete) {
+          item.Delete.Key = marshall(item.Delete.Key);
+        }
+        return item;
+      }),
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new TransactWriteItemsCommand(input);
+    const result = await this.client.send(command);
+    this.log("Transaction", result.ConsumedCapacity, result.ItemCollectionMetrics);
+  }
+  async getItem(TableName, key, consistent = false, projection, attributeName) {
+    const input = {
+      TableName,
+      Key: marshall(key),
+      ConsistentRead: consistent,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames: attributeName,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.TOTAL
+    };
+    const command = new GetItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Read", result.ConsumedCapacity);
+    return unmarshall(result.Item || {});
+  }
+  async batchGetItem(TableName, keys, consistent = false, projection, attributeName) {
+    const input = {
+      RequestItems: {
+        [TableName]: {
+          Keys: keys.map((key) => marshall(key)),
+          ConsistentRead: consistent,
+          ProjectionExpression: projection,
+          ExpressionAttributeNames: attributeName
+        }
+      },
+      ReturnConsumedCapacity: ReturnConsumedCapacity.TOTAL
+    };
+    const command = new BatchGetItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("BatchRead", result.ConsumedCapacity);
+    return result.Responses?.[TableName]?.map((item) => unmarshall(item)) || [];
+  }
+  async queryItems(TableName, keyCondition, consistent = false, projection, attributeName, attributeValue, lastEvaluatedKey) {
+    const input = {
+      TableName,
+      KeyConditionExpression: keyCondition,
+      ExpressionAttributeValues: attributeValue,
+      ConsistentRead: consistent,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames: attributeName,
+      ExclusiveStartKey: lastEvaluatedKey,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.TOTAL
+    };
+    const command = new QueryCommand(input);
+    const result = await this.client.send(command);
+    this.log("Query", result.ConsumedCapacity);
+    return {
+      items: result.Items?.map((item) => unmarshall(item)) || [],
+      lastEvaluatedKey: result.LastEvaluatedKey
+    };
+  }
+  async scanItems(TableName, filterExpression, consistent = false, projection, attributeName, attributeValue, lastEvaluatedKey) {
+    const input = {
+      TableName,
+      FilterExpression: filterExpression,
+      ExpressionAttributeValues: attributeValue,
+      ConsistentRead: consistent,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames: attributeName,
+      ExclusiveStartKey: lastEvaluatedKey,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.TOTAL
+    };
+    const command = new ScanCommand(input);
+    const result = await this.client.send(command);
+    this.log("Scan", result.ConsumedCapacity);
+    return {
+      items: result.Items?.map((item) => unmarshall(item)) || [],
+      lastEvaluatedKey: result.LastEvaluatedKey
+    };
+  }
+  async partiQL(statement, parameter = [], nextToken, consistent = false) {
+    const input = {
+      Statement: statement,
+      Parameters: parameter,
+      ConsistentRead: consistent,
+      NextToken: nextToken,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES
+    };
+    const command = new ExecuteStatementCommand(input);
+    const result = await this.client.send(command);
+    this.log("PartiQL", result.ConsumedCapacity);
+    return {
+      Items: result.Items?.map((item) => unmarshall(item)) || [],
+      nextToken: result.NextToken,
+      lastEvaluatedKey: result.LastEvaluatedKey
+    };
+  }
+  async updateItem(TableName, key, condition, update, attributeName, attributeValue, ReturnValues = ReturnValue.UPDATED_NEW, ReturnValuesOnFailure = ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Key: marshall(key),
+      ConditionExpression: condition,
+      UpdateExpression: update,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new UpdateItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Update", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return unmarshall(result.Attributes || {});
+  }
+  async deleteItem(TableName, key, condition, attributeName, attributeValue, ReturnValues = ReturnValue.ALL_OLD, ReturnValuesOnFailure = ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Key: marshall(key),
+      ConditionExpression: condition,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new DeleteItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Delete", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return unmarshall(result.Attributes || {});
+  }
+  async getItemByIndex(TableName, index, keyCondition, consistent = false, projection, attributeName, attributeValue) {
+    const input = {
+      TableName,
+      IndexName: index,
+      KeyConditionExpression: keyCondition,
+      ExpressionAttributeValues: attributeValue,
+      ConsistentRead: consistent,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames: attributeName,
+      ReturnConsumedCapacity: ReturnConsumedCapacity.INDEXES
+    };
+    const command = new QueryCommand(input);
+    const result = await this.client.send(command);
+    this.log("Query", result.ConsumedCapacity);
+    return { Items: result.Items?.map((item) => unmarshall(item)) || [] };
+  }
+};
+var Dynamodb_default = DynamoDBUtility;
+
+// src/Schema/definition.json
+var definition_default = {
+  $id: "standards",
+  definitions: {
+    lowercaseText: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]*$"
+    },
+    lowercaseText10: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]{0,10}$"
+    },
+    lowercaseText16: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]{0,16}$"
+    },
+    lowercaseText30: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]{0,30}$"
+    },
+    lowercaseText50: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]{0,50}$"
+    },
+    lowercaseText256: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[a-z]{0,256}$"
+    },
+    text: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).*$"
+    },
+    text10: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{0,10}$"
+    },
+    text16: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{0,16}$"
+    },
+    text30: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{0,30}$"
+    },
+    text50: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{0,50}$"
+    },
+    text256: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{0,256}$"
+    },
+    requiredText: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).+$"
+    },
+    requiredText10: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{1,10}$"
+    },
+    requiredText16: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{1,16}$"
+    },
+    requiredText30: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{1,30}$"
+    },
+    requiredText50: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{1,50}$"
+    },
+    requiredText256: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$).{1,256}$"
+    },
+    url: {
+      type: "string",
+      pattern: "^https://[^\\s/$.?#].[^\\s]*$",
+      maxLength: 2048
+    },
+    uuid: {
+      type: "string",
+      minLength: 1,
+      pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+    },
+    productKey: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[A-Z0-9-]{4,16}$"
+    },
+    variantId: {
+      type: "string",
+      pattern: "^(?!\\s)(?!.*\\s$)[A-Z0-9-]{4,16}$"
+    },
+    firstName: { $ref: "#/definitions/requiredText30" },
+    lastName: { $ref: "#/definitions/text30" },
+    phone: {
+      type: "string",
+      pattern: "^[0-9]{10}$"
+    },
+    email: {
+      type: "string",
+      pattern: "^[^\\s]+@[^\\s]+\\.[^\\s]+$"
+    },
+    addressLine1: { $ref: "#/definitions/requiredText50" },
+    addressLine2: { $ref: "#/definitions/text50" },
+    city: { $ref: "#/definitions/requiredText30" },
+    postalCode: { $ref: "#/definitions/requiredText16" },
+    state: {
+      type: "string",
+      enum: ["AP", "AR", "AS", "BR", "CT", "GA", "GJ", "HR", "HP", "JH", "KA", "KL", "MP", "MH", "MN", "ML", "MZ", "NL", "OR", "PB", "RJ", "SK", "TN", "TG", "TR", "UP", "UT", "WB", "AN", "CH", "DH", "LD", "DL", "PY", "LA", "JK"]
+    },
+    country: {
+      type: "string",
+      enum: [
+        "IN"
+      ]
+    },
+    currency: {
+      type: "string",
+      enum: [
+        "INR"
+      ]
+    },
+    locale: {
+      type: "string",
+      enum: [
+        "en-IN"
+      ]
+    },
+    addressType: {
+      type: "string",
+      enum: ["shipping", "billing", "shipping&billing"]
+    },
+    address: {
+      type: "object",
+      properties: {
+        firstName: { $ref: "standards#/definitions/firstName" },
+        lastName: { $ref: "standards#/definitions/lastName" },
+        phone: { $ref: "standards#/definitions/phone" },
+        email: { $ref: "standards#/definitions/email" },
+        addressLine1: { $ref: "standards#/definitions/addressLine1" },
+        addressLine2: { $ref: "standards#/definitions/addressLine2" },
+        city: { $ref: "standards#/definitions/city" },
+        postalCode: { $ref: "standards#/definitions/postalCode" },
+        state: { $ref: "standards#/definitions/state" },
+        country: { $ref: "standards#/definitions/country" }
+      },
+      required: ["firstName", "lastName", "phone", "email", "addressLine1", "postalCode", "state", "country"]
+    }
+  }
+};
+
+// src/Schema/index.ts
+var Schema = {
+  getStandardSchemaDefinition() {
+    return definition_default;
+  }
+};
+var Schema_default = Schema;
+
+// src/Auth/index.ts
+import { EncryptJWT, jwtDecrypt } from "jose";
+import util2 from "util";
+
+// src/enums/ErrorTypes.ts
+var ErrorTypes_default = Object.freeze({
+  INVALID_TOKEN: "Invalid Token",
+  TOKEN_EXPIRED: "Token Expired",
+  INTERNAL_SERVER_ERROR: "Internal Server Error"
+});
+
+// src/Logger/index.ts
+import util from "util";
+var Logger = {
+  logException: (functionName, error) => {
+    console.log(`Exception Occurred in Function: ${functionName}, Error: ${util.inspect(error)}`);
+  },
+  logError: (functionName, errorMessage) => {
+    console.log(`Error Occurred in Function: ${functionName}, Error: ${util.inspect(errorMessage)}`);
+  },
+  logMessage: (functionName, message) => {
+    console.log(`Message in Function: ${functionName}, Error: ${util.inspect(message)}`);
+  },
+  logInvalidPayload: (functionName, errorMessage) => {
+    console.log(`Invalid Payload received for Function: ${functionName}, Error: ${errorMessage}`);
+  }
+};
+var Logger_default = Logger;
+
+// src/Utils/response.ts
+var ResponseUtility = {
+  handleException: (functionName, error, res) => {
+    if (error.knownError) {
+      error.logError && Logger_default.logError(functionName, error);
+      res.status(error.status).json({
+        status: error.status,
+        error: error.error
+      });
+    } else {
+      Logger_default.logException(functionName, error);
+      res.status(500).json({
+        status: 500,
+        error: ErrorTypes_default.INTERNAL_SERVER_ERROR
+      });
+    }
+  },
+  generateResponse: (status, data, error) => {
+    return {
+      status,
+      data,
+      error
+    };
+  },
+  generateError: (status, error, knownError = true, logError = false) => {
+    return {
+      status,
+      error,
+      knownError,
+      logError
+    };
+  }
+};
+var response_default = ResponseUtility;
+
+// src/Auth/index.ts
+var AuthUtility = class {
+  secretToken;
+  maxTokenAge;
+  constructor({ secret, maxTokenAge = "30 days" }) {
+    this.secretToken = secret;
+    this.maxTokenAge = maxTokenAge;
+  }
+  async createToken(id, additionalData) {
+    const payload = {
+      id,
+      ...additionalData
+    };
+    const secretKey = Buffer.from(this.secretToken, "hex");
+    const token = await new EncryptJWT(payload).setExpirationTime(this.maxTokenAge).setIssuedAt().setProtectedHeader({ alg: "dir", enc: "A256CBC-HS512" }).encrypt(secretKey);
+    return token;
+  }
+  async verifyToken(token) {
+    const secretKey = Buffer.from(this.secretToken, "hex");
+    const jwt = await jwtDecrypt(token, secretKey, { maxTokenAge: this.maxTokenAge });
+    return jwt.payload;
+  }
+  AuthMiddleware() {
+    return async (req, res, next) => {
+      try {
+        const token = req.get("Authorization")?.split(" ")?.[1];
+        if (!token) {
+          throw new Error(ErrorTypes_default.INVALID_TOKEN);
+        }
+        const payload = await this.verifyToken(token);
+        res.locals.auth = payload;
+        next();
+      } catch (error) {
+        Logger_default.logError("AuthMiddleware", util2.inspect(error));
+        response_default.handleException("AuthMiddleware", response_default.generateError(401, ErrorTypes_default.TOKEN_EXPIRED), res);
+      }
+    };
+  }
+};
+var Auth_default = AuthUtility;
+
+// src/Utils/fetch.ts
+var Fetch = async (baseURL, endpoint, method = "GET", headers = {}, payload) => {
+  const options = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    }
+  };
+  if (method !== "GET" && payload) {
+    options.body = JSON.stringify(payload);
+  }
+  try {
+    const response = await fetch(`${baseURL}/${endpoint}`, options);
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => response.text());
+      throw {
+        status: response.status,
+        statusText: response.statusText,
+        error: errorBody ? errorBody : {
+          status: response.status,
+          error: response.statusText
+        }
+      };
+    }
+    const body = await response.json();
+    Logger_default.logMessage("Fetch", `API call successful: URL-${baseURL}/${endpoint}, Status- ${response.status}}`);
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      data: body.data
+    };
+  } catch (err) {
+    Logger_default.logError("Fetch", `API call failed: URL-${baseURL}/${endpoint}, Status- ${err.status || 500}, Error- ${JSON.stringify(err.error, null, 2)}`);
+    throw {
+      status: err.status || 500,
+      statusText: err.statusText || "Internal Server Error",
+      error: err.error || {
+        status: err.status || 500,
+        error: err.statusText || "Something went wrong"
+      }
+    };
+  }
+};
+var fetch_default = Fetch;
+export {
+  Auth_default as Auth,
+  Dynamodb_default as DynamoDB,
+  fetch_default as Fetch,
+  Logger_default as Logger,
+  response_default as ResponseUtility,
+  Schema_default as Schema
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "b23-lib",
+  "version": "1.1.0",
+  "description": "This repo hold common classes, type and util functiona",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "url": "https://github.com/MyWebsite-B23/util-lib.git"
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "keywords": [
+    "b23-lib"
+  ],
+  "author": "Bharath Gowda B",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.620.0",
+    "@aws-sdk/util-dynamodb": "^3.620.0",
+    "jose": "^5.9.6",
+    "util": "^0.12.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist"
+  ]
+}