b23-lib 1.1.0

package/dist/index.js

@@ -0,0 +1,569 @@
+"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 src_exports = {};
+__export(src_exports, {
+  Auth: () => Auth_default,
+  DynamoDB: () => Dynamodb_default,
+  Fetch: () => fetch_default,
+  Logger: () => Logger_default,
+  ResponseUtility: () => response_default,
+  Schema: () => Schema_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Dynamodb/index.ts
+var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+var import_util_dynamodb = require("@aws-sdk/util-dynamodb");
+var DynamoDBUtility = class {
+  client;
+  returnItemCollectionMetrics;
+  logCapacity;
+  region;
+  marshall = import_util_dynamodb.marshall;
+  unmarshall = import_util_dynamodb.unmarshall;
+  ReturnValue = import_client_dynamodb.ReturnValue;
+  ReturnItemCollectionMetrics = import_client_dynamodb.ReturnItemCollectionMetrics;
+  ReturnValuesOnConditionCheckFailure = import_client_dynamodb.ReturnValuesOnConditionCheckFailure;
+  constructor({ region, returnItemCollectionMetrics = import_client_dynamodb.ReturnItemCollectionMetrics.NONE, logCapacity = false }) {
+    this.region = region;
+    this.returnItemCollectionMetrics = returnItemCollectionMetrics;
+    this.logCapacity = logCapacity;
+    this.client = new import_client_dynamodb.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 = import_client_dynamodb.ReturnValue.NONE, ReturnValuesOnFailure = import_client_dynamodb.ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Item: (0, import_util_dynamodb.marshall)(item, {
+        removeUndefinedValues: true,
+        convertClassInstanceToMap: true
+      }),
+      ConditionExpression: condition,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new import_client_dynamodb.PutItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Put", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return (0, import_util_dynamodb.unmarshall)(result.Attributes || {});
+  }
+  async transactWriteItems(transactItems) {
+    const input = {
+      TransactItems: transactItems.map((item) => {
+        if (item.Put) {
+          item.Put.Item = (0, import_util_dynamodb.marshall)(item.Put.Item, {
+            removeUndefinedValues: true,
+            convertClassInstanceToMap: true
+          });
+        }
+        if (item.Update) {
+          item.Update.Key = (0, import_util_dynamodb.marshall)(item.Update.Key);
+        }
+        if (item.Delete) {
+          item.Delete.Key = (0, import_util_dynamodb.marshall)(item.Delete.Key);
+        }
+        return item;
+      }),
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.INDEXES,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new import_client_dynamodb.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: (0, import_util_dynamodb.marshall)(key),
+      ConsistentRead: consistent,
+      ProjectionExpression: projection,
+      ExpressionAttributeNames: attributeName,
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.TOTAL
+    };
+    const command = new import_client_dynamodb.GetItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Read", result.ConsumedCapacity);
+    return (0, import_util_dynamodb.unmarshall)(result.Item || {});
+  }
+  async batchGetItem(TableName, keys, consistent = false, projection, attributeName) {
+    const input = {
+      RequestItems: {
+        [TableName]: {
+          Keys: keys.map((key) => (0, import_util_dynamodb.marshall)(key)),
+          ConsistentRead: consistent,
+          ProjectionExpression: projection,
+          ExpressionAttributeNames: attributeName
+        }
+      },
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.TOTAL
+    };
+    const command = new import_client_dynamodb.BatchGetItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("BatchRead", result.ConsumedCapacity);
+    return result.Responses?.[TableName]?.map((item) => (0, import_util_dynamodb.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: import_client_dynamodb.ReturnConsumedCapacity.TOTAL
+    };
+    const command = new import_client_dynamodb.QueryCommand(input);
+    const result = await this.client.send(command);
+    this.log("Query", result.ConsumedCapacity);
+    return {
+      items: result.Items?.map((item) => (0, import_util_dynamodb.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: import_client_dynamodb.ReturnConsumedCapacity.TOTAL
+    };
+    const command = new import_client_dynamodb.ScanCommand(input);
+    const result = await this.client.send(command);
+    this.log("Scan", result.ConsumedCapacity);
+    return {
+      items: result.Items?.map((item) => (0, import_util_dynamodb.unmarshall)(item)) || [],
+      lastEvaluatedKey: result.LastEvaluatedKey
+    };
+  }
+  async partiQL(statement, parameter = [], nextToken, consistent = false) {
+    const input = {
+      Statement: statement,
+      Parameters: parameter,
+      ConsistentRead: consistent,
+      NextToken: nextToken,
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.INDEXES
+    };
+    const command = new import_client_dynamodb.ExecuteStatementCommand(input);
+    const result = await this.client.send(command);
+    this.log("PartiQL", result.ConsumedCapacity);
+    return {
+      Items: result.Items?.map((item) => (0, import_util_dynamodb.unmarshall)(item)) || [],
+      nextToken: result.NextToken,
+      lastEvaluatedKey: result.LastEvaluatedKey
+    };
+  }
+  async updateItem(TableName, key, condition, update, attributeName, attributeValue, ReturnValues = import_client_dynamodb.ReturnValue.UPDATED_NEW, ReturnValuesOnFailure = import_client_dynamodb.ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Key: (0, import_util_dynamodb.marshall)(key),
+      ConditionExpression: condition,
+      UpdateExpression: update,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new import_client_dynamodb.UpdateItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Update", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return (0, import_util_dynamodb.unmarshall)(result.Attributes || {});
+  }
+  async deleteItem(TableName, key, condition, attributeName, attributeValue, ReturnValues = import_client_dynamodb.ReturnValue.ALL_OLD, ReturnValuesOnFailure = import_client_dynamodb.ReturnValuesOnConditionCheckFailure.ALL_OLD) {
+    const input = {
+      TableName,
+      Key: (0, import_util_dynamodb.marshall)(key),
+      ConditionExpression: condition,
+      ExpressionAttributeNames: attributeName,
+      ExpressionAttributeValues: attributeValue,
+      ReturnValues,
+      ReturnConsumedCapacity: import_client_dynamodb.ReturnConsumedCapacity.INDEXES,
+      ReturnValuesOnConditionCheckFailure: ReturnValuesOnFailure,
+      ReturnItemCollectionMetrics: this.returnItemCollectionMetrics
+    };
+    const command = new import_client_dynamodb.DeleteItemCommand(input);
+    const result = await this.client.send(command);
+    this.log("Delete", result.ConsumedCapacity, result.ItemCollectionMetrics);
+    return (0, import_util_dynamodb.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: import_client_dynamodb.ReturnConsumedCapacity.INDEXES
+    };
+    const command = new import_client_dynamodb.QueryCommand(input);
+    const result = await this.client.send(command);
+    this.log("Query", result.ConsumedCapacity);
+    return { Items: result.Items?.map((item) => (0, import_util_dynamodb.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
+var import_jose = require("jose");
+var import_util2 = __toESM(require("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
+var import_util = __toESM(require("util"));
+var Logger = {
+  logException: (functionName, error) => {
+    console.log(`Exception Occurred in Function: ${functionName}, Error: ${import_util.default.inspect(error)}`);
+  },
+  logError: (functionName, errorMessage) => {
+    console.log(`Error Occurred in Function: ${functionName}, Error: ${import_util.default.inspect(errorMessage)}`);
+  },
+  logMessage: (functionName, message) => {
+    console.log(`Message in Function: ${functionName}, Error: ${import_util.default.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 import_jose.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 (0, import_jose.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", import_util2.default.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Auth,
+  DynamoDB,
+  Fetch,
+  Logger,
+  ResponseUtility,
+  Schema
+});