zudello-integration-sdk 1.0.0

package/src/utils/logger.js

@@ -0,0 +1,122 @@
+'use strict'
+
+class Logger {
+  /**
+   * Constructor.
+   */
+  constructor(mode = 'PRODUCTION') {
+    this.mode = mode
+    this.productionMode = 'PRODUCTION'
+    this.logs = []
+  }
+
+  /**
+   * Base logging function.
+   * @param {string} status - The status level of the log (e.g., 'warn', 'info').
+   * @param {string} title - The title or summary of the log.
+   * @param {any} content - The detailed content of the log.
+   */
+  _log(status, title, content) {
+    let formattedContent = content
+
+    // If content is an Error (exception), format it into an object
+    if (content instanceof Error) {
+      formattedContent = {
+        name: content.name,
+        message: content.message,
+        stack: content.stack,
+      }
+    }
+
+    // Create the log entry object
+    const logEntry = { status, title, content: formattedContent }
+
+    if (this.mode === this.productionMode) {
+      this.logs.push(logEntry)
+    }
+
+    // Output the log message
+    if (content instanceof Error) {
+      console.log(`[${status.toUpperCase()}] ${title}:`)
+      console.error(content.stack)
+    } else if (Array.isArray(content) || (typeof content === 'object' && content !== null)) {
+      console.log(`[${status.toUpperCase()}] ${title}:`)
+      console.log(JSON.stringify(content, null, 2))
+    } else {
+      console.log(`[${status.toUpperCase()}] ${title}: ${content}`)
+    }
+  }
+
+  /**
+   * Log a warning message.
+   * @param {string} title
+   * @param {any} content
+   */
+  warn(title, content) {
+    this._log('warn', title, content)
+  }
+
+  /**
+   * Log an informational message.
+   * @param {string} title
+   * @param {any} content
+   */
+  info(title, content) {
+    this._log('info', title, content)
+  }
+
+  /**
+   * Log a debug message.
+   * @param {string} title
+   * @param {any} content
+   */
+  debug(title, content) {
+    this._log('debug', title, content)
+  }
+
+  /**
+   * Log a general message.
+   * @param {string} title
+   * @param {any} content
+   */
+  log(content, title = 'Script Log') {
+    this._log('log', title, content)
+  }
+
+  /**
+   * Log an error message.
+   * @param {string} title
+   * @param {any} content
+   */
+  error(title, content) {
+    this._log('error', title, content)
+  }
+
+  /**
+   * Log a success message.
+   * @param {string} title
+   * @param {any} content
+   */
+  success(title, content) {
+    this._log('success', title, content)
+  }
+
+  /**
+   * Log a request message.
+   * @param {string} title
+   * @param {any} content
+   */
+  request(title, content) {
+    this._log('request', title, content)
+  }
+
+  /**
+   * Retrieve all logs.
+   * @return {Array} Array of log objects.
+   */
+  getLogs() {
+    return this.logs
+  }
+}
+
+module.exports = Logger

package/src/utils/metadata.js

@@ -0,0 +1,102 @@
+'use strict'
+
+/**
+ * Metadata class to handle operations on metadata and global metadata.
+ * This class provides methods to get, set, and delete metadata properties.
+ */
+class Metadata {
+  /**
+   * Constructor to initialize the Metadata instance.
+   * 
+   * @param {Array} metadata - Array of metadata objects (each object should have `property` and `value`).
+   * @param {Array} globalMetadata - Array of global metadata objects (each object should have `property` and `value`).
+   */
+  constructor(metadata = [], globalMetadata = []) {
+    this.metadata = metadata
+    this.globalMetadata = globalMetadata
+  }
+
+  /**
+   * Retrieves the value associated with the specified key.
+   * 
+   * The method first checks the instance's metadata for the key.
+   * If not found, it checks the global metadata.
+   * If the key is not found in either, it returns the specified default value.
+   * 
+   * @param {string} key - The property key to search for.
+   * @param {*} defaultValue - The default value to return if the key is not found (default is `null`).
+   * @returns {*} The value associated with the key, or the default value if not found.
+   */
+  get(key, defaultValue = null) {
+    const item = this.metadata.find(obj => obj.property === key)
+
+    if (item) {
+      return item.value
+    }
+
+    const globalItem = this.globalMetadata.find(obj => obj.property === key)
+
+    if (globalItem) {
+      return globalItem.value
+    }
+
+    return defaultValue
+  }
+
+  /**
+   * Retrieves all metadata and global metadata.
+   * 
+   * @returns {Object} An object containing both metadata and globalMetadata arrays.
+   */
+  getAll() {
+    return {
+      metadata: this.metadata,
+      globalMetadata: this.globalMetadata
+    }
+  }
+
+  /**
+   * Sets the value for a specified key in either metadata or global metadata.
+   * 
+   * If the key already exists, it updates the value. Otherwise, it adds a new key-value pair.
+   * 
+   * @param {string} key - The property key to set or update.
+   * @param {*} value - The value to associate with the key.
+   * @param {boolean} isGlobal - Flag indicating whether to set the key in global metadata (default is `false`).
+   */
+  set(key, value, isGlobal = false) {
+    const index = isGlobal
+      ? this.globalMetadata.findIndex(obj => obj.property === key)
+      : this.metadata.findIndex(obj => obj.property === key)
+
+    if (isGlobal) {
+      if (index !== -1) {
+        this.globalMetadata[index].value = value
+      } else {
+        this.globalMetadata.push({ property: key, value })
+      }
+    } else {
+      if (index !== -1) {
+        this.metadata[index].value = value
+      } else {
+        this.metadata.push({ property: key, value })
+      }
+    }
+  }
+
+  /**
+   * Deletes a specified key from either metadata or global metadata.
+   * 
+   * @param {string} key - The property key to delete.
+   * @param {boolean} isGlobal - Flag indicating whether to delete the key from global metadata (default is `false`).
+   */
+  delete(key, isGlobal = false) {
+    if (isGlobal) {
+      this.globalMetadata = this.globalMetadata.filter(obj => obj.property !== key)
+    } else {
+      this.metadata = this.metadata.filter(obj => obj.property !== key)
+    }
+  }
+}
+
+module.exports = Metadata

package/src/utils/miscHelper.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const moment = require('moment-timezone')
+
+class MiscHelper {
+  constructor() {}
+
+  getFileNameFromUrl(url) {
+    const regex = /[^/?#]+(?=\?|$)/
+    const matches = url.match(regex)
+
+    return matches
+      ? matches[0]
+      : null
+  }
+
+  formatDate(date, format = 'MM/DD/YYYY') {
+    return date && format
+      ? moment(date).format(format)
+      : null 
+  }
+}
+
+module.exports = MiscHelper

package/src/utils/modelHelper.js

@@ -0,0 +1,140 @@
+'use strict'
+
+const _ = require('lodash')
+
+class ModelHelper {
+  constructor(zudello, logger, data = null, model = null, uuid = null) {
+    this.zudello = zudello
+    this.logger = logger
+
+    this.modelData = data
+    this.model = model
+    this.uuid = uuid
+  }
+
+  async load(payload = {}, failCallback) {
+    failCallback = failCallback || ((data) => this.defaultFailCallback(data))
+
+    const model = payload?.model || null
+    const uuid = payload?.uuid || null
+
+    this.logger.info('payload', payload)
+
+    return await this.get(model, uuid, failCallback)
+  }
+
+  async get(model, uuid, failCallback) {
+    failCallback = failCallback || ((data) => this.defaultFailCallback(data))
+
+    if (!model || !uuid) {
+      return failCallback({ model, uuid })
+    }
+
+    this.logger.info('model', model)
+    this.logger.info('uuid', uuid)
+
+    const fetchedModel = await this.zudello.fetch({ model, uuid })
+
+    this.logger.debug('Fetched Model', fetchedModel)
+
+    if (fetchedModel && fetchedModel.data) {
+      const data = fetchedModel.data?.data || null
+
+      if (data) {
+        return new ModelHelper(this.zudello, this.logger, data, model, uuid)
+      }
+    }
+
+    return failCallback({ model, uuid })
+  }
+
+  data() {
+    return this.modelData
+  }
+
+  lines(mapping = null, filter = null) {
+    const data = this.data()
+
+    if (!data) {
+      return []
+    }
+
+    let lines = _.get(data, 'lines') ?? []
+
+    if (filter) {
+      lines = _.filter(lines, filter)
+    }
+
+    if (mapping) {
+      lines = _.map(lines, mapping)
+    }
+
+    return lines
+  }
+
+  async response({ status = 'COMPLETE', message = '', external_id = null, properties = {}, exit = false }) {
+    if (!this.modelData || !this.model || !this.uuid) {
+      return
+    }
+
+    const responsePayload = {
+      model: this.model,
+      module: this.modelData.module,
+      submodule: this.modelData.submodule,
+      data: {
+        uuid: this.uuid,
+        status,
+        external_id,
+        ...properties,
+        log_messages: message.length > 0 ? {
+          replace: true,
+          items: [{
+            create: true,
+            data: {
+              status_code: status === 'UNABLE' ? 400 : 200,
+              body: JSON.stringify({ message }),
+              parse_as: 'SENTENCE_ERROR'
+            }
+          }]
+        } : null
+      }
+    }
+
+    this.logger.debug('Response Payload', responsePayload)
+
+    const zudelloUpdateResponse = await this.zudello.update(responsePayload)
+
+    this.logger.debug('Zudello Update Response', zudelloUpdateResponse)
+
+    if (exit) {
+      throw new Error('Script Exit')
+    }
+  }
+
+  async complete({ message = '', external_id = null, properties = {}, exit = false }) {
+    await this.response({ status: 'COMPLETE', message, external_id, properties, exit })
+  }
+
+  async fail({ message = '', external_id = null, properties = {}, exit = false }) {
+    await this.response({ status: 'UNABLE', message, external_id, properties, exit })
+  }
+
+  async completeIf(condition, { message = '', external_id = null, properties = {}, exit = false }) {
+    if (condition) {
+      await this.complete({ message, external_id, properties, exit })
+    }
+  }
+
+  async failIf(condition, { message = '', external_id = null, properties = {}, exit = false }) {
+    if (condition) {
+      await this.fail({ message, external_id, properties, exit })
+    }
+  }
+
+  defaultFailCallback(data) {
+    this.logger.error('Unable to find Model', data)
+    throw new Error('Unable to find Model')
+  }
+}
+
+module.exports = ModelHelper

package/src/utils/properties.js

@@ -0,0 +1,32 @@
+'use strict'
+
+/**
+ * A class representing a collection of properties.
+ */
+class Properties {
+  /**
+   * Constructor for the Properties class.
+   * @param {Array} properties - An array of property objects. Each object is expected to have a `payload` property, which itself contains a `name` and `value`.
+   */
+  constructor(properties = []) {
+    this.properties = properties
+  }
+
+  /**
+   * Retrieve the value associated with a given key.
+   * @param {string} key - The name of the property to retrieve.
+   * @param {*} defaultValue - The value to return if the key is not found. Defaults to null.
+   * @returns {*} The value associated with the key, or the defaultValue if the key is not found.
+   */
+  get(key, defaultValue = null) {
+    const item = this.properties.find(obj => obj.payload?.name === key)
+
+    if (item) {
+      return item.payload?.value?.value
+    }
+
+    return defaultValue
+  }
+}
+
+module.exports = Properties

package/src/utils/responseHandler.js

@@ -0,0 +1,28 @@
+'use strict'
+
+class ResponseHandler {
+  /**
+   * Handle success response.
+   * @param {any} data Data to return.
+   * @returns {object} Response Data.
+   */
+  success (data) {
+    return { success: true, data }
+  }
+
+  /**
+   * Handle error response.
+   * @param {array} errors Errors to return.
+   * @returns {object} Response Data.
+   */
+  error (errors) {
+    return {
+      success: false,
+      error: {
+        messages: errors
+      }
+    }
+  }
+}
+
+module.exports = ResponseHandler

package/src/utils/s3Client.js

@@ -0,0 +1,128 @@
+const {
+  S3Client,
+  GetObjectCommand,
+  PutObjectCommand,
+  ListObjectsV2Command,
+  DeleteObjectCommand,
+  DeleteObjectsCommand
+} = require('@aws-sdk/client-s3')
+
+const s3 = new S3Client({
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  },
+  region: process.env.AWS_REGION
+})
+
+/**
+ * Retrieves the content of a file from an S3 bucket.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string} key - The key of the file to retrieve.
+ * @returns {Promise<Buffer>} A promise that resolves to the content of the file.
+ * @throws Will throw an error if the S3 getObject operation fails.
+ */
+const getFileContent = async (bucketName, key) => {
+  const params = {
+    Bucket: bucketName,
+    Key: key
+  }
+
+  const data = await s3.send(new GetObjectCommand(params))
+  return data.Body.transformToString()
+}
+
+/**
+ * Uploads a file to an S3 bucket.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string} key - The key of the file to upload.
+ * @param {Buffer|string} body - The content of the file to upload.
+ * @param {string|null} contentType - The Content Type.
+ * @returns {Promise<Object>} A promise that resolves to the data returned by S3.
+ * @throws Will throw an error if the S3 upload operation fails.
+ */
+const uploadFile = async (bucketName, key, body, contentType = null) => {
+  const params = {
+    Bucket: bucketName,
+    Key: key,
+    Body: body
+  }
+
+  if (contentType) {
+    params.ContentType = contentType
+  }
+
+  return await s3.send(new PutObjectCommand(params))
+}
+
+/**
+ * Lists the files in an S3 bucket under a specific prefix.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string} prefix - The prefix (directory path) to list files from.
+ * @param {string} continuationToken - Token for paginated results.
+ * @returns {Promise<Object>} A promise that resolves to an object containing file keys and pagination info.
+ * @throws Will throw an error if the S3 listObjectsV2 operation fails.
+ */
+const listFiles = async (bucketName, prefix = '', continuationToken = undefined) => {
+  const params = {
+    Bucket: bucketName,
+    Prefix: prefix,
+    ContinuationToken: continuationToken
+  }
+
+  const data = await s3.send(new ListObjectsV2Command(params))
+
+  return {
+    keys: data.Contents ? data.Contents.map((item) => item.Key) : [],
+    isTruncated: data.IsTruncated,
+    nextContinuationToken: data.NextContinuationToken
+  }
+}
+
+/**
+ * Deletes a file from an S3 bucket.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string} key - The key of the file to delete.
+ * @returns {Promise<Object>} A promise that resolves to the data returned by S3.
+ * @throws Will throw an error if the S3 deleteObject operation fails.
+ */
+const deleteFile = async (bucketName, key) => {
+  const params = {
+    Bucket: bucketName,
+    Key: key
+  }
+
+  return await s3.send(new DeleteObjectCommand(params))
+}
+
+/**
+ * Deletes multiple files from an S3 bucket.
+ *
+ * @param {string} bucketName - The name of the S3 bucket.
+ * @param {string[]} keys - The keys of the files to delete.
+ * @returns {Promise<Object>} A promise that resolves to the data returned by S3.
+ * @throws Will throw an error if the S3 deleteObjects operation fails.
+ */
+const deleteFiles = async (bucketName, keys) => {
+  const params = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: keys.map((key) => ({ Key: key })),
+      Quiet: true
+    }
+  }
+
+  return await s3.send(new DeleteObjectsCommand(params))
+}
+
+module.exports = {
+  getFileContent,
+  uploadFile,
+  listFiles,
+  deleteFile,
+  deleteFiles
+}

package/src/utils/tags.js

@@ -0,0 +1,32 @@
+'use strict'
+
+/**
+ * Class representing a collection of tags.
+ */
+class Tags {
+  /**
+   * Create a new Tags instance.
+   * @param {Array} tags - An optional array of initial tags.
+   */
+  constructor(tags = []) {
+    this.tags = tags
+  }
+
+  /**
+   * Add a new tag to the tags array.
+   * @param {string} tag - The tag to add.
+   */
+  set(tag) {
+    this.tags.push(tag)
+  }
+
+  /**
+   * Retrieve all tags.
+   * @returns {Array} An array of all tags.
+   */
+  getAll() {
+    return this.tags
+  }
+}
+
+module.exports = Tags

package/src/utils/validator.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const _ = require('lodash')
+
+class Validator {
+  /**
+   * Validate is some of object params are empty.
+   * @param {object} params Object with params.
+   * @returns {object} Validate result.
+   */
+  isEmpty (params) {
+    const emptyParams = []
+
+    _.keys(params).forEach(key => {
+      const value = params[key]
+
+      if ((value == null || _.isEmpty(value)) && !_.isNumber(value) && !_.isBoolean(value)) {
+        emptyParams.push(key)
+      }
+    })
+
+    if (emptyParams.length) {
+      return {
+        valid: false,
+        errors: _.map(emptyParams, param => {
+          return `The following param are missed or empty: ${param}.`
+        })
+      }
+    }
+
+    return { valid: true }
+  }
+
+  /**
+   * Validate is parameter has type array.
+   * @param {array} param Parameter to validate.
+   * @param {string} paramName Name of parameter.
+   * @returns {object} Validate result.
+   */
+  isArray (param, paramName = 'Param') {
+    const isArray = _.isArray(param)
+
+    if (!isArray) {
+      return {
+        valid: false,
+        errors: [`${paramName} must be an array.`]
+      }
+    }
+
+    return { valid: true }
+  }
+
+  /**
+   * Validate is array or object includes value.
+   * @param {array|object} entities Array or Object with entities.
+   * @param {number|string} value What we are searching for.
+   * @returns {object} Validate result.
+   */
+  includes (entities, value) {
+    const includes = _.includes(entities, value)
+
+    if (!includes) {
+      return {
+        valid: false,
+        errors: [`${value} is missed in allowed properties.`]
+      }
+    }
+
+    return { valid: true }
+  }
+}
+
+module.exports = Validator