@autofleet/sadot 1.1.6 → 1.1.7-beta

package/dist/utils/validations/validators/status.validator.js

@@ -1,2 +1,15 @@
-import e from"joi";const t=(t,n)=>e.string().allow(null).valid(...n.map(e=>e.value)).validate(t);export{t as validateStatus};
-//# sourceMappingURL=status.validator.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStatus = void 0;
+const joi_1 = __importDefault(require("joi"));
+/**
+* Validate that the value is one of the status values
+*/
+const validateStatus = (value, statusValues) => (joi_1.default.string()
+    .allow(null)
+    .valid(...statusValues.map((statusValue) => statusValue.value))
+    .validate(value));
+exports.validateStatus = validateStatus;

package/package.json

@@ -1,27 +1,20 @@
 {
   "name": "@autofleet/sadot",
-  "version": "1.1.6",
+  "version": "1.1.7-beta",
   "description": "",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
+  "main": "dist/index.js",
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "build": "rm -rf dist && tsc",
+    "linter": "eslint .",
+    "test": "jest --runInBand",
+    "test-debug": "node --inspect-brk node_modules/.bin/jest --testTimeout=10000000",
+    "coverage": "jest --coverage --runInBand",
+    "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
+    "dev": "nodemon",
+    "watch": "npm-watch build-to-local-repo",
+    "publish-dev": "node --run build && npm publish --tag dev"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
   "watch": {
     "build-to-local-repo": {
       "extensions": [
@@ -35,27 +28,37 @@
     }
   },
   "dependencies": {
-    "@autofleet/common-types": "4.94.0",
+    "@autofleet/common-types": "^4.4.0",
+    "@autofleet/events": "^5.2.0",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^3.0.1",
     "http-status-codes": "^2.3.0",
     "joi": "^17.7.0",
-    "pg": "^8.16.3",
+    "pg": "^8.10.0",
     "reflect-metadata": "^0.1.13",
-    "sequelize": "^6.37.7",
-    "sequelize-typescript": "^2.1.6",
-    "@autofleet/events": "^5.2.27"
+    "sequelize": "^6.31.1",
+    "sequelize-typescript": "^2.1.5"
   },
   "devDependencies": {
+    "@autofleet/errors": "^3.0.1",
+    "@autofleet/logger": "^4.2.1",
+    "@autofleet/node-common": "^4.0.2",
+    "@autofleet/zehut": "^4.0.1",
     "@types/express": "^4.17.17",
+    "@types/jest": "^29.5.13",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.22.1",
     "express": "^4.21.2",
+    "jest": "^29.7.0",
     "npm-watch": "^0.11.0",
     "supertest": "^7.0.0",
-    "@autofleet/errors": "^3.1.35",
-    "@autofleet/logger": "^4.2.39",
-    "@autofleet/node-common": "^4.2.16",
-    "@autofleet/zehut": "^4.6.2"
+    "ts-jest": "^29.1.2",
+    "ts-node": "^8.6.2",
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "@autofleet/errors": "^3",
@@ -64,18 +67,14 @@
     "@autofleet/sheilta": "^2",
     "@autofleet/zehut": "^4"
   },
+  "peerDependenciesMeta": {
+    "@autofleet/zehut": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=18.0.0"
   },
   "author": "Autofleet",
-  "license": "ISC",
-  "scripts": {
-    "build": "pnpm -w tsdown -W ./packages/sadot",
-    "linter": "eslint .",
-    "test": "vitest",
-    "test-debug": "node --inspect-brk node_modules/.bin/vitest --testTimeout=10000000",
-    "coverage": "vitest --coverage",
-    "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
-    "watch": "npm-watch build-to-local-repo"
-  }
-}
+  "license": "ISC"
+}

package/src/api/index.ts

@@ -0,0 +1,10 @@
+// export the api object
+import { Router } from '@autofleet/node-common';
+import v1 from './v1';
+import logger from '../utils/logger';
+
+const router = Router({ logger });
+
+router.use('/v1', v1);
+
+export default router;

package/src/api/v1/definition/index.ts

@@ -0,0 +1,104 @@
+import { ResourceNotFoundError } from '@autofleet/errors';
+import { Router } from '@autofleet/node-common';
+import handleError from '../errors';
+import * as DefinitionRepo from '../../../repository/definition';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
+import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
+import logger from '../../../utils/logger';
+import type { CustomFieldDefinition } from '../../../models';
+
+const router = Router({ logger });
+const ENTITY = 'CustomFieldDefinition';
+
+const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
+
+/**
+ * Create
+ */
+router.post<{ modelName: string; }>('/', async (req, res) => {
+  const { modelName } = req.params;
+  const modelType = toPascalCase(modelName);
+  try {
+    const validatedPayload: CreateCustomFieldDefinition = await validateCustomFieldDefinitionCreation(req.body);
+
+    const customFieldDefinition = await DefinitionRepo.create({
+      ...validatedPayload,
+      modelType,
+    });
+    return res.status(201).json(customFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to create custom field definition', err);
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get by id
+ */
+router.get<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
+  const { customFieldDefinitionId } = req.params;
+  try {
+    const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
+
+    if (!customFieldDefinition) {
+      throw new ResourceNotFoundError();
+    }
+
+    return res.json(customFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to fetch custom field definition', err);
+    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get all
+ */
+router.get<{ modelName: string; }, CustomFieldDefinition[], never, { entityIds?: string[]; }>('/', async (req, res) => {
+  const { params: { modelName }, query: { entityIds } } = req;
+
+  const modelType = toPascalCase(modelName);
+  try {
+    const where = {
+      modelType,
+      ...(entityIds?.length > 0 && { entityId: entityIds }),
+    };
+    const customFieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true });
+    return res.json(customFieldDefinitions);
+  } catch (err) {
+    logger.error('Failed to fetch custom field definitions', err);
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
+  }
+});
+
+/**
+ * Update
+ */
+router.patch<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
+  const { customFieldDefinitionId, modelName } = req.params;
+  const modelType = toPascalCase(modelName);
+  try {
+    const validatedPayload: UpdateCustomFieldDefinition = await validateCustomFieldDefinitionUpdate(req.body);
+
+    const customFieldDefinition = await DefinitionRepo.findByWhere({
+      id: customFieldDefinitionId,
+      modelType,
+    });
+
+    if (!customFieldDefinition) {
+      throw new ResourceNotFoundError();
+    }
+
+    const updatedCustomFieldDefinition = await DefinitionRepo.update(
+      customFieldDefinitionId,
+      { ...validatedPayload, modelType },
+    );
+
+    return res.status(200).json(updatedCustomFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to patch custom field definition', err);
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
+  }
+});
+
+export default router;

package/src/api/v1/definition/validations.ts

@@ -0,0 +1,75 @@
+/* eslint-disable newline-per-chained-call */
+import Joi from 'joi';
+import { CustomFieldDefinitionType } from '../../../utils/constants';
+
+const FileValidationSchema = Joi.object({
+  name: Joi.string().required(),
+  type: Joi.string(),
+  size: Joi.string(),
+  addedBy: Joi.string().uuid(),
+});
+const statusValidationObject = Joi.object({
+  value: Joi.string().required(),
+  color: Joi.string().required(),
+});
+/**
+ * Schema for the validation of custom field definition
+ * The only custom validation is for
+ * {@link CustomFieldDefinitionType.SELECT SELECT}
+ * and
+ * {@link CustomFieldDefinitionType.STATUS STATUS}
+ * field types.
+ * The rest of the field types are validated by Joi
+ */
+const ValidationSchema = Joi.when('fieldType', {
+  is: CustomFieldDefinitionType.SELECT,
+  then: Joi.array().required().items(Joi.string()).min(1).unique(),
+  otherwise: Joi.when('fieldType', {
+    is: CustomFieldDefinitionType.STATUS,
+    then: Joi.array().required().items(statusValidationObject).min(1).unique('value'),
+    otherwise: Joi.forbidden(),
+  }),
+});
+
+const DefaultValueSchema = Joi.when('fieldType', {
+  switch: [
+    { is: CustomFieldDefinitionType.BOOLEAN, then: Joi.boolean().allow(null) },
+    { is: CustomFieldDefinitionType.DATE, then: Joi.date().allow(null) },
+    { is: CustomFieldDefinitionType.DATETIME, then: Joi.date().allow(null) },
+    { is: CustomFieldDefinitionType.FILE, then: Joi.array().items(FileValidationSchema).allow(null) },
+    { is: CustomFieldDefinitionType.IMAGE, then: Joi.array().items(Joi.string().uri()).allow(null) },
+    { is: CustomFieldDefinitionType.NUMBER, then: Joi.number().allow(null) },
+    { is: CustomFieldDefinitionType.SELECT, then: Joi.string().allow(null) },
+    { is: CustomFieldDefinitionType.STATUS, then: Joi.string().allow(null) },
+    { is: CustomFieldDefinitionType.TEXT, then: Joi.string().allow(null) },
+  ],
+});
+
+const CustomFieldDefinitionCreationSchema = Joi.object({
+  name: Joi.string().required(),
+  displayName: Joi.string().required(),
+  validation: ValidationSchema,
+  defaultValue: DefaultValueSchema,
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
+  entityId: Joi.string().guid().required(),
+  entityType: Joi.string().required(),
+  description: Joi.string(),
+  required: Joi.boolean(),
+  disabled: Joi.boolean(),
+  blockEditingFromUI: Joi.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
+
+const CustomFieldDefinitionUpdateSchema = Joi.object({
+  displayName: Joi.string(),
+  validation: ValidationSchema,
+  defaultValue: DefaultValueSchema,
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
+  description: Joi.string().allow(null),
+  required: Joi.boolean(),
+  disabled: Joi.boolean(),
+  blockEditingFromUI: Joi.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
+
+export const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+
+export const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/src/api/v1/errors.ts

@@ -0,0 +1,13 @@
+import type { Response } from 'express';
+import { handleError, BadRequest, type LogPayload } from '@autofleet/errors';
+import { ValidationError as InputValidationError } from 'joi';
+import { ValidationError as DatabaseValidationError } from 'sequelize';
+
+export default (err, res: Response, additionalData: LogPayload = undefined) => {
+  let error = err;
+  if ([InputValidationError, DatabaseValidationError].some((ErrClass) => err instanceof ErrClass)) {
+    error = new BadRequest([err], null);
+  }
+
+  return handleError(error, res, additionalData);
+};

package/src/api/v1/index.ts

@@ -0,0 +1,11 @@
+import { Router } from '@autofleet/node-common';
+import logger from '../../utils/logger';
+import definitionRouter from './definition';
+import validatorRouter from './validator';
+
+const router = Router({ logger });
+
+router.use('/custom-field-definitions/:modelName', definitionRouter);
+router.use('/custom-validators/:modelName', validatorRouter);
+
+export default router;

package/src/api/v1/validator/index.ts

@@ -0,0 +1,141 @@
+import { ResourceNotFoundError } from '@autofleet/errors';
+import { Router } from '@autofleet/node-common';
+import { StatusCodes } from 'http-status-codes';
+import handleError from '../errors';
+import * as ValidatorRepo from '../../../repository/validator';
+import validations from './validations';
+import logger from '../../../utils/logger';
+import { validateValidatorSchema } from '../../../utils/validations/schema/validator-schema';
+import type { CustomValidator } from '../../../models';
+
+const router = Router({ logger });
+const ENTITY = 'CustomValidator';
+
+/**
+ * Create
+ */
+router.post<{ modelName: string }>('/', async (req, res) => {
+  const { modelName } = req.params;
+  try {
+    // Validate the request body
+    const validatedPayload = await validations.create.validateAsync(req.body);
+
+    // Validate that the schema is a valid AJV schema
+    validateValidatorSchema(validatedPayload.schema);
+
+    const validator = await ValidatorRepo.create({
+      ...validatedPayload,
+      modelType: modelName,
+    });
+
+    return res.status(StatusCodes.CREATED).json(validator);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get all
+ */
+router.get<
+  { modelName: string },
+  { validators: CustomValidator[] },
+  never,
+  { entityId?: string; entityType?: string }
+>('/', async (req, res) => {
+  try {
+    const { modelName } = req.params;
+    const { entityId, entityType } = req.query;
+
+    const where = {
+      modelType: modelName,
+      ...(entityId && { entityId }),
+      ...(entityType && { entityType }),
+    };
+
+    const validators = await ValidatorRepo.findAll(where);
+
+    return res.status(StatusCodes.OK).json({ validators });
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get by id
+ */
+router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId, modelName } = req.params;
+    // Include disabled validators when fetching by ID
+    const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
+
+    if (!validators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
+  }
+});
+
+/**
+ * Update
+ */
+router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+
+    // Validate the request body
+    const validatedPayload = await validations.update.validateAsync(req.body);
+
+    // If schema is included in the update, validate that it's a valid AJV schema
+    if (validatedPayload.schema) {
+      validateValidatorSchema(validatedPayload.schema);
+    }
+
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
+  }
+});
+
+/**
+ * Delete (disable)
+ */
+router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    const [count] = await ValidatorRepo.disable(validatorId);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator failed to be disabled');
+    }
+
+    return res.status(StatusCodes.NO_CONTENT).send();
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in delete ${ENTITY} request` });
+  }
+});
+
+export default router;

package/src/api/v1/validator/validations.ts

@@ -0,0 +1,38 @@
+import Joi from 'joi';
+
+const jsonSchemaValidation = Joi.object().unknown(true);
+
+const schemaObject = Joi.object({
+  type: Joi.string().valid('object'),
+  properties: Joi.object({
+    before: jsonSchemaValidation,
+    after: jsonSchemaValidation,
+  }).required(),
+  required: Joi.array().items(Joi.string()),
+  allOf: Joi.array().items(Joi.object()),
+  anyOf: Joi.array().items(Joi.object()),
+  oneOf: Joi.array().items(Joi.object()),
+  additionalProperties: Joi.alternatives().try(Joi.boolean(), Joi.object()),
+  $id: Joi.string(),
+  $schema: Joi.string(),
+  if: Joi.object(),
+  then: Joi.object(),
+  else: Joi.object(),
+});
+
+const validationSchemas = {
+  create: Joi.object({
+    entityId: Joi.string().uuid().required(),
+    entityType: Joi.string().required(),
+    schema: schemaObject.required(),
+  }),
+
+  update: Joi.object({
+    entityId: Joi.string().uuid(),
+    entityType: Joi.string(),
+    schema: schemaObject,
+    disabled: Joi.boolean(),
+  }).min(1),
+};
+
+export default validationSchemas;

package/src/errors/index.ts

@@ -0,0 +1,70 @@
+/* eslint-disable max-classes-per-file */
+import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
+
+export class MissingRequiredCustomFieldError extends BadRequest {
+  constructor(missingFields: string[]) {
+    const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
+    super([err], null, missingFields);
+    this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
+  }
+}
+
+export class UnsupportedCustomFieldTypeError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Type "${fieldType}" is not supported`);
+    super([err], null, null);
+    this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
+  }
+}
+
+export class UnsupportedCustomValidationError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Validation for "${fieldType}" is not supported`);
+    super([err], null, null);
+    this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
+  }
+}
+
+export class InvalidFieldTypeError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Invalid field type ${fieldType}`);
+    super([err], null, null);
+    this.message = 'INVALID_FIELD_TYPE';
+  }
+}
+
+export class InvalidValueError extends BadRequest {
+  constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError) {
+    const formattedErrorMessage = joiValidationError.message
+      .replace(/"/g, '')
+      .replace('value', `'${fieldDefinitionName}'`);
+
+    const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+
+    const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+
+    const err = new Error(invalidValueMessage);
+    super([err], null, null);
+    this.message = invalidValueMessage;
+  }
+}
+
+export class InvalidEntriesError extends BadRequest {
+  constructor(modelId: string, validationErrors: EntriesValidationError[]) {
+    const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+    super(errors, null, null);
+    this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (
+      `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`
+    )).join('\n')}`;
+  }
+}
+
+export class MissingDefinitionError extends BadRequest {
+  constructor(fieldNames: string[]) {
+    const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
+    super([err], null, null);
+    this.message = 'MISSING_DEFINITION';
+  }
+}

package/src/events/index.ts

@@ -0,0 +1,63 @@
+import Events from '@autofleet/events';
+import { getUser } from '@autofleet/zehut';
+import logger from '../utils/logger';
+import type {
+  CustomFieldDefinition,
+  CustomFieldEntries,
+  CustomFieldValue,
+  CustomValidator,
+} from '../models';
+
+const events = new Events({
+  logger,
+  getUserId: (payload) => payload?.user_id ?? getUser()?.id ?? null,
+});
+
+const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
+
+const stringifyBooleans = (savedObject: any, keysToConvert: string[]) => {
+  const savedObjectKeySet = new Set(Object.keys(savedObject));
+  if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
+    return savedObject;
+  }
+  return {
+    ...savedObject,
+    ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
+  };
+};
+
+const modelTableMapping = {
+  CustomFieldDefinition: {
+    tableName: 'dim_custom_field_definition',
+    eventVersion: '1',
+  },
+  CustomFieldValue: {
+    tableName: 'dim_custom_field_value',
+    eventVersion: '1',
+  },
+  CustomFieldEntries: {
+    tableName: 'dim_custom_field_entries',
+    eventVersion: '1',
+  },
+};
+
+export const sendDimEvent = (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator): void => {
+  const mapping = modelTableMapping[instance.constructor.name];
+  if (!mapping) {
+    return;
+  }
+  let objectToSend = instance.get();
+  try {
+    objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
+  } catch (err) {
+    logger.error('Failed to convert booleans in dim event payload', err);
+  }
+
+  events.sendObject(
+    mapping.tableName,
+    mapping.eventVersion,
+    objectToSend,
+  ).catch(() => {});
+};
+
+export default events;