@ikonintegration/ikapi 4.0.1 → 5.0.0

package/src/API/Response.ts

@@ -0,0 +1,370 @@
+import type { Context } from 'aws-lambda'
+
+import Transaction from '../BaseEvent/Transaction.js'
+import Globals from '../Globals.js'
+
+/**
+ * CustomError class that extends the built-in Error class.
+ * @class
+ * @extends Error
+ * @param {any} body - The body of the error, which can be an object or a string.
+ * @constructor
+ * @property {string} name - The name of the error.
+ */
+class CustomError extends Error {
+  constructor(body: any) {
+    super(body.message || 'Unknown error!')
+    this.name = body.error || 'UnknownError'
+  }
+}
+
+/**
+ * Represents an error response from an API.
+ * @typedef {Object} ResponseErrorType
+ * @property {string} err - The error message.
+ * @property {string} [errCode] - The error code, if available.
+ */
+export type ResponseErrorType = {
+  err: string
+  errCode?: string
+}
+
+/**
+ * Represents a response object with various methods for building and manipulating the response.
+ * @template BodyType - The type of the response body.
+ */
+export default class Response<BodyType = null> {
+  /**
+   * The private property that stores the status code.
+   * @type {number}
+   * @private
+   */
+  private statusCode: number
+  /**
+   * Private property representing the body of an object.
+   * @type {any}
+   * @private
+   */
+  private body: any
+  /**
+   * Indicates whether the object is currently piping out.
+   * @type {boolean}
+   */
+  private isPipingOut: boolean
+  /**
+   * Private property that stores the headers as an object.
+   */
+  private headers: object
+  /**
+   * Determines whether streaming is enabled or not.
+   * @returns {boolean} - True if streaming is enabled, false otherwise.
+   */
+  public readonly shouldStream: boolean
+  /**
+   * Indicates whether the request body should be treated as raw data.
+   * @type {boolean}
+   */
+  public readonly rawBody: boolean
+  /**
+   * A boolean flag indicating whether to throw an error when encountering errors.
+   * If set to true, any errors encountered will result in an exception being thrown.
+   * If set to false, errors will be logged but the program will continue execution.
+   */
+  public readonly throwOnErrors: boolean
+  /**
+   * Indicates whether the transaction ID is disabled.
+   * @type {boolean}
+   */
+  public readonly disableTransactionID: boolean
+
+  /**
+   * Constructs a new Response object with the given status code, body, and optional behavior.
+   * @param {number} statusCode - The HTTP status code of the response.
+   * @param {BodyType} body - The body of the response.
+   * @param {Object} [optBehaviour] - Optional behavior configuration for the response.
+   * @param {boolean} [optBehaviour.shouldStream] - Indicates whether the response should be streamed.
+   * @param {boolean} [optBehaviour.rawBody] - Indicates whether the response body should be treated as raw data.
+   * @param {boolean} [optBehaviour.throwOnErrors] - Indicates whether errors should be thrown for non-successful status codes.
+   * @param {boolean} [optBehaviour
+   */
+  constructor(
+    statusCode: number,
+    body: BodyType,
+    optBehaviour?:
+      | {
+          shouldStream?: boolean
+          rawBody?: boolean
+          throwOnErrors?: boolean
+          disableTransactionID?: boolean
+        }
+      | undefined
+  ) {
+    // response
+    this.statusCode = statusCode
+    this.body = body
+    this.headers = {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Credentials': true,
+      'Content-Type': 'application/json',
+    }
+    // behaviour
+    this.isPipingOut = false //internal -- flag to indicate streaming out has started and avoid double stream call
+    // options
+    this.shouldStream = !!optBehaviour?.shouldStream //
+    this.rawBody = !!optBehaviour?.rawBody
+    this.throwOnErrors = !!optBehaviour?.throwOnErrors
+    this.disableTransactionID = !!optBehaviour?.disableTransactionID
+  }
+
+  /**
+   * Get the status code of the response.
+   * @returns {number} The status code.
+   */
+  public getCode(): number {
+    return this.statusCode
+  }
+
+  /**
+   * Get the body of the object.
+   * @returns {BodyType} The body of the object.
+   */
+  public getBody(): BodyType {
+    return this.body
+  }
+
+  /**
+   * Appends a key-value pair into the body object.
+   * @param {string} key - The key to append.
+   * @param {any} value - The value to append.
+   * @returns None
+   */
+  public appendIntoBody(key: string, value: any): void {
+    this.body[key] = value
+  }
+
+  /**
+   * Appends a header to the existing headers object.
+   * @param {string} key - The key of the header.
+   * @param {any} value - The value of the header.
+   * @returns None
+   */
+  public appendHeader(key: string, value: any): void {
+    this.headers[key] = value
+  }
+
+  /**
+   * Builds the response for the given context and transaction.
+   * @param {Context} context - The context object.
+   * @param {Transaction<any, any, any>} transaction - The transaction object.
+   * @param {boolean} optDoNotCallContext - Optional flag to indicate whether to call the context or not.
+   * @returns {Promise<void>} - A promise that resolves when the response is built.
+   */
+  public async build(
+    context: Context,
+    transaction: Transaction<any, any, any, any, any>,
+    optDoNotCallContext: boolean
+  ): Promise<void> {
+    //Stream support
+    if (this.isPipingOut) return
+    if (this.shouldStream) return this.pipe(context)
+
+    //append default fields
+    if (transaction.request.getRequestID() && this.body && !this.disableTransactionID)
+      this.appendIntoBody('transactionID', transaction.request.getRequestID()) //append transaction ID
+    //Raw response support
+    if (this.rawBody) return this.rawContext(context, transaction)
+
+    //build response
+    const b = {
+      statusCode: this.statusCode,
+      headers: this.headers,
+      ...(this.body ? { body: JSON.stringify(this.body) } : {}),
+    }
+    //log response and respond to context
+    transaction.logger.debug(b)
+    //Check for transaction response proxy
+    if (transaction.responseProxy) await transaction.responseProxy(this)
+    //Batch does not succeed directly just on upper transaction (which will should be a batch)
+    if (!optDoNotCallContext) context.succeed(b)
+  }
+
+  /**
+   * Private method that pipes the response to the given context.
+   * @param {Context} context - The context object provided by AWS Lambda.
+   * @returns None
+   */
+  private pipe(context: Context): void {
+    //Check if not streaming
+    this.isPipingOut = true
+    //build response
+    const b = {
+      statusCode: this.statusCode,
+      body: this.body,
+      headers: this.headers,
+    }
+    //log response and respond to context
+    context.succeed(b)
+  }
+
+  /**
+   * Private method that handles the raw context of a transaction.
+   * @param {Context} context - The context object.
+   * @param {Transaction<null, BodyType>} transaction - The transaction object.
+   * @returns None
+   */
+  private rawContext(context: Context, transaction: Transaction<null, BodyType, any>): void {
+    //log response and respond to context
+    transaction.logger.debug(this.body)
+    if (this.getCode() <= 200 && this.getCode() <= 299) context.succeed(this.body)
+    else {
+      if (!this.throwOnErrors) context.fail(new CustomError(this.body))
+      else throw new CustomError(this.body)
+    }
+  }
+
+  /**
+   * Generates a response object for a missing path parameter error.
+   * @param {string} paramName - The name of the missing path parameter.
+   * @returns {Response<ResponseErrorType>} - The response object with error details.
+   */
+  public static MissingParamResponse(paramName: string): Response<ResponseErrorType> {
+    console.warn(`Invalid request - Path parameter ${paramName} is missing.`)
+    return new Response<ResponseErrorType>(400, {
+      err: `Invalid request. Path parameter ${paramName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  }
+
+  /**
+   * Creates a response object for a missing query parameter error.
+   * @param {string} paramName - The name of the missing query parameter.
+   * @returns {Response<ResponseErrorType>} - The response object with error details.
+   */
+  public static MissingQueryResponse(paramName: string): Response<ResponseErrorType> {
+    console.warn(`Invalid request - Query parameter ${paramName} is missing.`)
+    return new Response<ResponseErrorType>(400, {
+      err: `Invalid request. Query parameter ${paramName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  }
+
+  /**
+   * Creates a BadRequestResponse object with the given parameters.
+   * @param {string} [msg] - The error message.
+   * @param {string} [errCode] - The error code.
+   * @param {any} [optBody] - Optional additional body data.
+   * @returns {Response<ResponseErrorType>} - The BadRequestResponse object.
+   */
+  public static BadRequestResponse(
+    msg?: string,
+    errCode?: string,
+    optBody?: any
+  ): Response<ResponseErrorType> {
+    console.warn(`Bad request - ${msg}`)
+    return new Response<ResponseErrorType>(400, {
+      err: msg,
+      ...(errCode ? { errCode: errCode } : {}),
+      ...(optBody || {}),
+    })
+  }
+
+  /**
+   * Creates a BadRequestResponse object with rollback option.
+   * @param {string} msg - The error message.
+   * @param {string} [errCode] - The error code.
+   * @param {any} [optBody] - Optional body to include in the response.
+   * @returns {Response<ResponseErrorType>} - The BadRequestResponse object.
+   */
+  public static BadRequestResponseWithRollback(
+    msg: string,
+    errCode?: string,
+    optBody?: any
+  ): Response<ResponseErrorType> {
+    console.warn(`Bad request - ${msg}`)
+    return new Response<ResponseErrorType>(400, {
+      err: msg,
+      rollback: true,
+      ...(errCode ? { errCode: errCode } : {}),
+      ...(optBody || {}),
+    })
+  }
+
+  /**
+   * Creates an unauthorized response with the given error message and error code.
+   * @param {string} msg - The error message.
+   * @param {string} [errCode] - The error code (optional).
+   * @returns {Response<ResponseErrorType>} - The unauthorized response.
+   */
+  public static UnauthorizedResponse(msg: string, errCode?: string): Response<ResponseErrorType> {
+    console.warn(`Denying request - ${msg}`)
+    return new Response<ResponseErrorType>(401, {
+      err: msg,
+      ...(errCode ? { errCode: errCode } : {}),
+    })
+  }
+
+  /**
+   * Creates a success response object with the given body.
+   * @param {BodyType} body - The body of the response.
+   * @returns {Response<BodyType>} - The success response object.
+   */
+  public static SuccessResponse<BodyType>(body: BodyType): Response<BodyType> {
+    return new Response<BodyType>(200, (body ? body : {}) as BodyType)
+  }
+
+  /**
+   * Creates a redirect response with the specified URL.
+   * @param {string} url - The URL to redirect to.
+   * @returns {Response<null>} - The redirect response.
+   */
+  public static RedirectResponse(url: string): Response<null> {
+    const resp = new Response<null>(302, null)
+    resp.appendHeader('Location', url)
+    return resp
+  }
+
+  /**
+   * Creates a success response with no content.
+   * @returns {Response<null>} A response object with a status code of 204 and no content.
+   */
+  public static SuccessNoContentResponse(): Response<null> {
+    return new Response<null>(204, null)
+  }
+
+  /**
+   * Creates a success response object with a streaming body and specified content type.
+   * @param {any} stream - The stream object to be used as the response body.
+   * @param {string} contentType - The content type of the response.
+   * @returns {Response} - The success response object.
+   */
+  public static SuccessStreamResponse(stream: any, contentType: string): Response {
+    const resp = new Response(200, stream, {
+      shouldStream: true,
+    })
+    resp.appendHeader('Connection', 'keep-alive')
+    if (contentType) resp.appendHeader('Content-Type', contentType)
+    return resp
+  }
+
+  /**
+   * Creates a simple HTTP response with the given body and optional status code.
+   * @param {BodyType} body - The body of the response.
+   * @param {number} [optionalCode] - The optional status code of the response. Defaults to 200.
+   * @returns {Response<BodyType>} - The created response object.
+   */
+  public static SimpleResponse<BodyType>(
+    body: BodyType,
+    optionalCode?: number
+  ): Response<BodyType> {
+    const resp = new Response<BodyType>(optionalCode || 200, body)
+    return resp
+  }
+
+  public static StepFunctionResponse<BodyType>(body: BodyType, optionalCode?: number) {
+    const resp = new Response<BodyType>(optionalCode || 200, body, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    return resp
+  }
+}

package/src/BaseEvent/DynamoTransaction.ts

@@ -0,0 +1,175 @@
+import type {
+  Context,
+  DynamoDBBatchResponse,
+  DynamoDBRecord,
+  DynamoDBStreamEvent,
+} from 'aws-lambda'
+
+import Transaction, { TransactionConfig } from './Transaction.js'
+import Response, { ResponseErrorType } from '../API/Response.js'
+import Globals from '../Globals.js'
+import Utils from '../Util/Utils.js'
+
+/**
+ * Interface representing a DynamoDB record with marshalled data.
+ * Extends the DynamoDBRecord interface.
+ * @property {object} Keys - The keys of the record.
+ * @property {object} OldImage - The old image of the record.
+ * @property {object} NewImage - The new image of the record.
+ */
+export interface DynamoDBMarshalledRecord extends DynamoDBRecord {
+  marshalled: {
+    Keys?: object
+    OldImage?: object
+    NewImage?: object
+  }
+}
+
+/**
+ * Defines a type for executing a transaction on DynamoDB.
+ * @param {Transaction<null, ResponseInnerType | ResponseErrorType, DynamoDBBatchResponse | null>} transaction - The transaction to execute.
+ * @param {DynamoDBMarshalledRecord} recordContent - The content of the DynamoDB record.
+ * @returns A promise that resolves to a response or a DynamoDB batch response.
+ */
+export type DynamoTransactionExecution<ResponseInnerType> = (
+  transaction: Transaction<
+    null,
+    ResponseInnerType | ResponseErrorType,
+    DynamoDBBatchResponse | null
+  >,
+  recordContent: DynamoDBMarshalledRecord
+) => Promise<Response<ResponseInnerType | ResponseErrorType> | DynamoDBBatchResponse | null>
+
+/**
+ * Represents a DynamoDB transaction handler that processes events from a DynamoDB stream.
+ * @template ResponseInnerType - The inner type of the response.
+ */
+export default class DynamoTransaction<ResponseInnerType> {
+  /**
+   * A boolean flag indicating whether failures are allowed.
+   */
+  private readonly allowFailure: boolean
+
+  /**
+   * Readonly property that holds the transaction configuration.
+   */
+  private readonly config: TransactionConfig
+
+  /**
+   * The context object that provides information about the current execution context.
+   * @type {Context}
+   */
+  private readonly context: Context
+
+  /**
+   * Represents an event from a DynamoDB stream.
+   * @type {DynamoDBStreamEvent}
+   */
+  private readonly event: DynamoDBStreamEvent
+
+  /**
+   * Constructor for a TransactionHandler object.
+   * @param {DynamoDBStreamEvent} event - The DynamoDB stream event that triggered the transaction.
+   * @param {Context} context - The AWS Lambda context object.
+   * @param {TransactionConfig} [config] - Optional configuration for the transaction.
+   * @param {boolean} [allowFailure] - Flag to indicate whether to allow transaction failure.
+   * @returns None
+   */
+  constructor(
+    event: DynamoDBStreamEvent,
+    context: Context,
+    config?: TransactionConfig,
+    allowFailure?: boolean
+  ) {
+    this.event = event
+    this.context = context
+    this.config = config || {}
+    this.allowFailure = !!allowFailure
+  }
+
+  /**
+   * Processes the event execution and returns a response based on the outcome.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The execution object to process.
+   * @returns {Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse>} A promise that resolves to a response object or null.
+   * @throws {Error} If the response code is not within the success range and failure is not allowed.
+   */
+  public async processEvent(
+    execution: DynamoTransactionExecution<ResponseInnerType>
+  ): Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse> {
+    const resp = await this.processRawEvent(execution)
+    if (
+      !this.allowFailure &&
+      resp &&
+      resp instanceof Response &&
+      !(resp.getCode() >= 200 && resp.getCode() < 300)
+    )
+      throw new Error(JSON.stringify(resp.getBody() || {}))
+    else if (resp) return resp
+    return null
+  }
+
+  /**
+   * Processes a raw event by executing a transaction on each record in the event.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The transaction execution function.
+   * @returns {Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse>} A promise that resolves to a response object, null, or a DynamoDB batch response.
+   */
+  private async processRawEvent(
+    execution: DynamoTransactionExecution<ResponseInnerType>
+  ): Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse> {
+    // safe check for empty events?
+    if (this.event.Records && this.event.Records.length > 0) {
+      // Regular cleanup of tmp disk to avoid tmp overflow on reused lambdas
+      if (!this.config?.skipCleanTmp) await Utils.cleanTemporaryFolder()
+      // init transaction for all records
+      return await new Transaction<null, any, DynamoDBBatchResponse | null>(
+        this.event,
+        this.context,
+        {
+          ...this.config,
+          syncReturn: true,
+        }
+      ).execute(async transaction => {
+        // for each available event
+        const failureIDs: Array<string> = []
+        for (const eventRecordIdx in this.event.Records) {
+          const eventRecord = this.event.Records[eventRecordIdx]
+          const record = {
+            ...eventRecord,
+            marshalled: {
+              ...(eventRecord.dynamodb?.Keys
+                ? { Keys: Utils.ddbUnmarshall(eventRecord.dynamodb?.Keys) }
+                : {}),
+              ...(eventRecord.dynamodb?.OldImage
+                ? { OldImage: Utils.ddbUnmarshall(eventRecord.dynamodb?.OldImage) }
+                : {}),
+              ...(eventRecord.dynamodb?.NewImage
+                ? { NewImage: Utils.ddbUnmarshall(eventRecord.dynamodb?.NewImage) }
+                : {}),
+            },
+          }
+          // Call execution with marshalled item
+          const resp = await execution(transaction, record)
+          // check for failure
+          if (
+            !resp ||
+            (resp instanceof Response && !(resp?.getCode() >= 200 && resp?.getCode() < 300))
+          ) {
+            // response with failures or fail hard at first
+            if (this.allowFailure) failureIDs.push(eventRecord.eventID!)
+            else return resp
+          }
+        }
+        // not errored and loop ended - succeeded (might have failures)
+        if (this.allowFailure)
+          return {
+            batchItemFailures: failureIDs.map(id => ({ itemIdentifier: id })),
+          }
+        return Response.SuccessResponse(null)
+      })
+    } else
+      return Response.BadRequestResponse(
+        Globals.ErrorResponseNoRecords,
+        Globals.ErrorCode_NoRecords
+      )
+  }
+}

package/src/BaseEvent/EventProcessor.ts

@@ -0,0 +1,140 @@
+import type { Context, SQSBatchResponse, SQSEvent } from 'aws-lambda'
+
+import Transaction, { TransactionConfig } from './Transaction.js'
+import Response, { ResponseErrorType } from '../API/Response.js'
+import Globals from '../Globals.js'
+import Utils from '../Util/Utils.js'
+
+/**
+ * Type definition for an event processor execution function.
+ * @param {Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>} transaction - The transaction object.
+ * @param {string | object} recordContent - The content of the record being processed.
+ * @returns {Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>} - A promise that resolves to the response or batch response.
+ */
+export type EventProcessorExecution<ResponseInnerType> = (
+  transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse | null>,
+  recordContent: string | object
+) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse | null>
+
+/**
+ * EventProcessor class that processes events from an SQS queue.
+ * @template ResponseInnerType - The type of the inner response object.
+ */
+export default class EventProcessor<ResponseInnerType> {
+  /**
+   * A boolean flag indicating whether failures are allowed or not.
+   * @readonly
+   */
+  private readonly allowFailure: boolean
+  /**
+   * The configuration object for the API transaction.
+   */
+  private readonly config: TransactionConfig
+  /**
+   * The private readonly context property of the class.
+   * @type {Context}
+   */
+  private readonly context: Context
+  /**
+   * The SQS event object that triggered the Lambda function.
+   */
+  private readonly event: SQSEvent
+
+  /**
+   * Constructs a new instance of the class.
+   * @param {SQSEvent} event - The event object representing the incoming SQS message.
+   * @param {Context} context - The context object representing the AWS Lambda execution context.
+   * @param {TransactionConfig} [config] - Optional configuration object for the transaction.
+   * @param {boolean} [allowFailure] - Optional flag indicating whether to allow failure for the transaction.
+   * @returns None
+   */
+  constructor(
+    event: SQSEvent,
+    context: Context,
+    config?: TransactionConfig,
+    allowFailure?: boolean
+  ) {
+    this.event = event
+    this.context = context
+    this.config = config || {}
+    this.allowFailure = !!allowFailure
+  }
+
+  /**
+   * Processes an event using the provided execution object and returns a response.
+   * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution object containing the event to process.
+   * @param {boolean} [doNotDecodeMessage] - Optional flag indicating whether to decode the message.
+   * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to the response object, or null if no response is available.
+   * @throws {Error} - Throws an error if the response code is not within the range of 200 to 299 and failure is not allowed.
+   */
+  public async processEvent(
+    execution: EventProcessorExecution<ResponseInnerType>,
+    doNotDecodeMessage?: boolean
+  ): Promise<Response<ResponseErrorType | null> | null | SQSBatchResponse> {
+    const resp = await this.processRawEvent(execution, !!doNotDecodeMessage)
+    if (
+      !this.allowFailure &&
+      resp &&
+      resp instanceof Response &&
+      !(resp.getCode() >= 200 && resp.getCode() < 300)
+    )
+      throw new Error(JSON.stringify(resp.getBody() || {}))
+    else if (resp) return resp
+    return null
+  }
+
+  /**
+   * Processes a raw event by executing the provided execution function and handling any errors or failures.
+   * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution function to process the event.
+   * @param {boolean} doNotDecodeMessage - Flag indicating whether to decode the message or not.
+   * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to a response object, null, or a SQS batch response.
+   */
+  private async processRawEvent(
+    execution: EventProcessorExecution<ResponseInnerType>,
+    doNotDecodeMessage: boolean
+  ): Promise<Response<ResponseErrorType | any> | null | SQSBatchResponse> {
+    // safe check for empty events?
+    if (this.event.Records && this.event.Records.length > 0) {
+      // Regular cleanup of tmp disk to avoid tmp overflow on reused lambdas
+      if (!this.config?.skipCleanTmp) await Utils.cleanTemporaryFolder()
+      // init transaction for all records
+      return await new Transaction<null, any, SQSBatchResponse | null>(this.event, this.context, {
+        ...this.config,
+        syncReturn: true,
+      }).execute(async transaction => {
+        // Map records with decoded message when required
+        const decodedRecords: string[] | object[] = this.event.Records.map(eventRecord =>
+          doNotDecodeMessage ? eventRecord.body : JSON.parse(eventRecord.body)
+        )
+
+        // for each available event
+        const failureIDs: Array<string> = []
+        for (const eventRecordIdx in decodedRecords) {
+          const eventRecord = decodedRecords[eventRecordIdx]
+          const message = this.event.Records[eventRecordIdx]
+          // Call execution
+          const resp = await execution(transaction, eventRecord)
+          // check for failure
+          if (
+            !resp ||
+            (resp instanceof Response && !(resp?.getCode() >= 200 && resp?.getCode() < 300))
+          ) {
+            // response with failures or fail hard at first
+            if (this.allowFailure) failureIDs.push(message.messageId)
+            else return resp
+          }
+        }
+        // not errored and loop ended - succeeded (might have failures)
+        if (this.allowFailure)
+          return {
+            batchItemFailures: failureIDs.map(id => ({ itemIdentifier: id })),
+          }
+        return Response.SuccessResponse(null)
+      })
+    } else
+      return Response.BadRequestResponse(
+        Globals.ErrorResponseNoRecords,
+        Globals.ErrorCode_NoRecords
+      ) // no event to be processed?
+  }
+}