tango-app-api-trax 3.9.33 → 3.9.34

package/src/services/locus.service.js

@@ -1,34 +1,41 @@
 import locusOrderModel from 'tango-api-schema/schema/locusOrder.model.js';
 import lenskartemployeemapping from 'tango-api-schema/schema/lenskartEmployeeMapping.model.js';
 import locusorderuser from 'tango-api-schema/schema/locusOrderUser.model.js';
-
-
-export async function getMany( query = {}, fields = {} ) {
-  return await locusOrderModel.find( query, fields ).sort( { createdAt: -1 } );
-};
-
-export async function getOne( query = {}, fields = { } ) {
-  return await locusOrderModel.findOne( query, fields );
-};
-
-export async function upsertOne( query = {}, fields = { } ) {
-  return await locusOrderModel.updateOne( query, fields, { upsert: true } );
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+
+const _methods = {
+  async getMany( query = {}, fields = {} ) {
+    return await locusOrderModel.find( query, fields ).sort( { createdAt: -1 } );
+  },
+  async getOne( query = {}, fields = { } ) {
+    return await locusOrderModel.findOne( query, fields );
+  },
+  async upsertOne( query = {}, fields = { } ) {
+    return await locusOrderModel.updateOne( query, fields, { upsert: true } );
+  },
+  async getOneEmployeeMapping( query = {}, fields = { } ) {
+    return await lenskartemployeemapping.findOne( query, fields );
+  },
+  async insert( record ) {
+    // eslint-disable-next-line new-cap
+    const document = new locusOrderModel( record );
+    return await document.save();
+  },
+  async deleteOne( query = {} ) {
+    return await locusOrderModel.deleteOne( query );
+  },
+  async locusUserGetOne( query = {}, fields = { } ) {
+    return await locusorderuser.findOne( query, fields );
+  },
 };
 
-export async function getOneEmployeeMapping( query = {}, fields = { } ) {
-  return await lenskartemployeemapping.findOne( query, fields );
-};
-
-export async function insert( record ) {
-  // eslint-disable-next-line new-cap
-  const document = new locusOrderModel( record );
-  return await document.save();
-};
+const _svc = createLoggableService( _methods, 'locusorders' );
 
-export async function deleteOne( query = {} ) {
-  return await locusOrderModel.deleteOne( query );
-};
-
-export async function locusUserGetOne( query = {}, fields = { } ) {
-  return await locusorderuser.findOne( query, fields );
-};
+export const getMany = ( ...args ) => _svc.getMany( ...args );
+export const getOne = ( ...args ) => _svc.getOne( ...args );
+export const upsertOne = ( ...args ) => _svc.upsertOne( ...args );
+export const getOneEmployeeMapping = ( ...args ) => _svc.getOneEmployeeMapping( ...args );
+export const insert = ( ...args ) => _svc.insert( ...args );
+export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
+export const locusUserGetOne = ( ...args ) => _svc.locusUserGetOne( ...args );

package/src/services/notification.service.js

@@ -1,31 +1,40 @@
 import notificationModel from 'tango-api-schema/schema/notification.model.js';
+import { createLoggableService } from '../logging/createLoggableService.js';
 
-export async function updateOnenotification( query, record ) {
-  return await notificationModel.updateOne( query, { $set: record } );
+const _methods = {
+  async updateOnenotification( query, record ) {
+    return await notificationModel.updateOne( query, { $set: record } );
+  },
+  async updatenotification( query, record ) {
+    return await notificationModel.updateOne( query, record );
+  },
+  async updateManynotification( query, record ) {
+    return await notificationModel.updateMany( query, record );
+  },
+  async aggregatenotification( query ) {
+    return await notificationModel.aggregate( query );
+  },
+  async findOnenotification( query ={}, field={} ) {
+    return await notificationModel.findOne( query, field );
+  },
+  async findnotification( query ={}, field={} ) {
+    return await notificationModel.find( query, field );
+  },
+  async createnotificationModel( query ={}, field={} ) {
+    return await notificationModel.create( query, field );
+  },
+  async insertManynotificationModel( query ={}, field={} ) {
+    return await notificationModel.insertMany( query, field );
+  },
 };
 
-export async function updatenotification( query, record ) {
-  return await notificationModel.updateOne( query, record );
-};
-export async function updateManynotification( query, record ) {
-  return await notificationModel.updateMany( query, record );
-};
-
-export async function aggregatenotification( query ) {
-  return await notificationModel.aggregate( query );
-};
-
-export async function findOnenotification( query ={}, field={} ) {
-  return await notificationModel.findOne( query, field );
-};
-export async function findnotification( query ={}, field={} ) {
-  return await notificationModel.find( query, field );
-};
-
-export async function createnotificationModel( query ={}, field={} ) {
-  return await notificationModel.create( query, field );
-};
-export async function insertManynotificationModel( query ={}, field={} ) {
-  return await notificationModel.insertMany( query, field );
-};
+const _svc = createLoggableService( _methods, 'notifications' );
 
+export const updateOnenotification = ( ...args ) => _svc.updateOnenotification( ...args );
+export const updatenotification = ( ...args ) => _svc.updatenotification( ...args );
+export const updateManynotification = ( ...args ) => _svc.updateManynotification( ...args );
+export const aggregatenotification = ( ...args ) => _svc.aggregatenotification( ...args );
+export const findOnenotification = ( ...args ) => _svc.findOnenotification( ...args );
+export const findnotification = ( ...args ) => _svc.findnotification( ...args );
+export const createnotificationModel = ( ...args ) => _svc.createnotificationModel( ...args );
+export const insertManynotificationModel = ( ...args ) => _svc.insertManynotificationModel( ...args );

package/src/services/otp.service.js

@@ -1,17 +1,24 @@
 import otpModel from 'tango-api-schema/schema/otp.model.js';
+import { createLoggableService } from '../logging/createLoggableService.js';
 
-export async function findOTP( query, fields ) {
-  try {
-    return otpModel.find( query, fields );
-  } catch ( error ) {
-    return error;
-  }
-}
+const _methods = {
+  async findOTP( query, fields ) {
+    try {
+      return otpModel.find( query, fields );
+    } catch ( error ) {
+      return error;
+    }
+  },
+  async updateOneOTP( query, record ) {
+    return otpModel.updateOne( query, record, { upsert: true } );
+  },
+  async aggregate( query = {} ) {
+    return otpModel.aggregate( query );
+  },
+};
 
-export async function updateOneOTP( query, record ) {
-  return otpModel.updateOne( query, record, { upsert: true } );
-}
+const _svc = createLoggableService( _methods, 'otps' );
 
-export const aggregate = async ( query = {} ) => {
-  return otpModel.aggregate( query );
-};
+export const findOTP = ( ...args ) => _svc.findOTP( ...args );
+export const updateOneOTP = ( ...args ) => _svc.updateOneOTP( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );

package/src/services/planogram.service.js

@@ -1,5 +1,12 @@
 import model from 'tango-api-schema';
+import { createLoggableService } from '../logging/createLoggableService.js';
 
-export const findOne = async ( query ={}, field={} ) => {
-  return model.planogramModel.findOne( query, field );
+const _methods = {
+  async findOne( query ={}, field={} ) {
+    return model.planogramModel.findOne( query, field );
+  },
 };
+
+const _svc = createLoggableService( _methods, 'planograms' );
+
+export const findOne = ( ...args ) => _svc.findOne( ...args );

package/src/services/processedTaskConfig.service.js

@@ -1,32 +1,40 @@
 import model from 'tango-api-schema';
+import { createLoggableService } from '../logging/createLoggableService.js';
 
-export const find = async ( query = {}, field={} ) => {
-  return model.taskProcessedConfigModel.find( query, field );
+const _methods = {
+  async find( query = {}, field={} ) {
+    return model.taskProcessedConfigModel.find( query, field );
+  },
+  async findOne( query = {}, field={} ) {
+    return model.taskProcessedConfigModel.findOne( query, field );
+  },
+  async updateMany( query = {}, record={} ) {
+    return model.taskProcessedConfigModel.updateMany( query, { $set: record } );
+  },
+  async updateOne( query = {}, record={} ) {
+    return model.taskProcessedConfigModel.updateOne( query, { $set: record } );
+  },
+  async insertMany( data = [] ) {
+    return model.taskProcessedConfigModel.insertMany( data );
+  },
+  async deleteMany( query = [] ) {
+    return model.taskProcessedConfigModel.deleteMany( query );
+  },
+  async aggregate( query = [] ) {
+    return model.taskProcessedConfigModel.aggregate( query );
+  },
+  async insert( data = [] ) {
+    return model.taskProcessedConfigModel.create( data );
+  },
 };
 
-export const findOne = async ( query = {}, field={} ) => {
-  return model.taskProcessedConfigModel.findOne( query, field );
-};
-
-export const updateMany = async ( query = {}, record={} ) => {
-  return model.taskProcessedConfigModel.updateMany( query, { $set: record } );
-};
-export const updateOne = async ( query = {}, record={} ) => {
-  return model.taskProcessedConfigModel.updateOne( query, { $set: record } );
-};
-
-export const insertMany = async ( data = [] ) => {
-  return model.taskProcessedConfigModel.insertMany( data );
-};
+const _svc = createLoggableService( _methods, 'processedtaskconfigs' );
 
-export const deleteMany = async ( query = [] ) => {
-  return model.taskProcessedConfigModel.deleteMany( query );
-};
-
-export const aggregate = async ( query = [] ) => {
-  return model.taskProcessedConfigModel.aggregate( query );
-};
-
-export const insert = async ( data = [] ) => {
-  return model.taskProcessedConfigModel.create( data );
-};
+export const find = ( ...args ) => _svc.find( ...args );
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const updateMany = ( ...args ) => _svc.updateMany( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+export const insertMany = ( ...args ) => _svc.insertMany( ...args );
+export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const insert = ( ...args ) => _svc.insert( ...args );

package/src/services/processedTaskList.service.js

@@ -1,30 +1,36 @@
 import model from 'tango-api-schema';
-
-export const find = async ( query = {}, field={} ) => {
-  return model.taskProcessedModel.find( query, field );
-};
-
-export const findOne = async ( query = {}, field={} ) => {
-  return model.taskProcessedModel.findOne( query, field );
-};
-
-export const updateMany = async ( query = {}, record={} ) => {
-  return model.taskProcessedModel.updateMany( query, { $set: record } );
-};
-
-export const insertMany = async ( data = [] ) => {
-  return model.taskProcessedModel.insertMany( data );
-};
-
-export const deleteMany = async ( query = [] ) => {
-  return model.taskProcessedModel.deleteMany( query );
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+const _methods = {
+  async find( query = {}, field={} ) {
+    return model.taskProcessedModel.find( query, field );
+  },
+  async findOne( query = {}, field={} ) {
+    return model.taskProcessedModel.findOne( query, field );
+  },
+  async updateMany( query = {}, record={} ) {
+    return model.taskProcessedModel.updateMany( query, { $set: record } );
+  },
+  async insertMany( data = [] ) {
+    return model.taskProcessedModel.insertMany( data );
+  },
+  async deleteMany( query = [] ) {
+    return model.taskProcessedModel.deleteMany( query );
+  },
+  async aggregate( query = [] ) {
+    return model.taskProcessedModel.aggregate( query );
+  },
+  updateOne( query = {}, record = {} ) {
+    return model.taskProcessedModel.updateOne( query, { $set: record } );
+  },
 };
 
-export const aggregate = async ( query = [] ) => {
-  return model.taskProcessedModel.aggregate( query );
-};
-
-export const updateOne = ( query = {}, record = {} ) => {
-  return model.taskProcessedModel.updateOne( query, { $set: record } );
-};
+const _svc = createLoggableService( _methods, 'processedtasks' );
 
+export const find = ( ...args ) => _svc.find( ...args );
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const updateMany = ( ...args ) => _svc.updateMany( ...args );
+export const insertMany = ( ...args ) => _svc.insertMany( ...args );
+export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );

package/src/services/processedchecklist.services.js

@@ -1,48 +1,56 @@
 import model from 'tango-api-schema';
-
-export const find = ( query = {}, record = {} ) => {
-  return model.processedchecklistModel.find( query, record );
-};
-export const deleteMany = ( query = {} ) => {
-  return model.processedchecklistModel.deleteMany( query );
-};
-
-export const findOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistModel.findOne( query, record ).sort( { date_iso: -1 } );
-};
-
-export const updateOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const insertMany = ( data ) => {
-  return model.processedchecklistModel.insertMany( data );
-};
-
-export const updateMany = ( query = {}, record = {} ) => {
-  return model.processedchecklistModel.updateMany( query, { $set: record } );
-};
-
-export const aggregate = ( query = [] ) => {
-  return model.processedchecklistModel.aggregate( query );
-};
-
-export const getClientCount = ( query = {} ) => {
-  return model.processedchecklistModel.count( query );
-};
-
-export const create = ( data = {} ) => {
-  return model.processedchecklistModel.create( data );
-};
-
-export const findLimit = ( query = {}, record = {}, offset, limit ) => {
-  return model.processedchecklistModel.find( query, record ).skip( offset ).limit( limit ).sort( { updatedAt: -1 } );
-};
-
-export const getCount = ( query = {} ) => {
-  return model.processedchecklistModel.count( query );
-};
-
-export const updateArrayKey = ( query = {}, record = {}, arrayFilter={} ) => {
-  return model.processedchecklistModel.updateOne( query, record, arrayFilter );
-};
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+const _methods = {
+  find( query = {}, record = {} ) {
+    return model.processedchecklistModel.find( query, record );
+  },
+  deleteMany( query = {} ) {
+    return model.processedchecklistModel.deleteMany( query );
+  },
+  findOne( query = {}, record = {} ) {
+    return model.processedchecklistModel.findOne( query, record ).sort( { date_iso: -1 } );
+  },
+  updateOne( query = {}, record = {} ) {
+    return model.processedchecklistModel.updateOne( query, { $set: record }, { upsert: true } );
+  },
+  insertMany( data ) {
+    return model.processedchecklistModel.insertMany( data );
+  },
+  updateMany( query = {}, record = {} ) {
+    return model.processedchecklistModel.updateMany( query, { $set: record } );
+  },
+  aggregate( query = [] ) {
+    return model.processedchecklistModel.aggregate( query );
+  },
+  getClientCount( query = {} ) {
+    return model.processedchecklistModel.count( query );
+  },
+  create( data = {} ) {
+    return model.processedchecklistModel.create( data );
+  },
+  findLimit( query = {}, record = {}, offset, limit ) {
+    return model.processedchecklistModel.find( query, record ).skip( offset ).limit( limit ).sort( { updatedAt: -1 } );
+  },
+  getCount( query = {} ) {
+    return model.processedchecklistModel.count( query );
+  },
+  updateArrayKey( query = {}, record = {}, arrayFilter = {} ) {
+    return model.processedchecklistModel.updateOne( query, record, arrayFilter );
+  },
+};
+
+const _svc = createLoggableService( _methods, 'processedchecklists' );
+
+export const find = ( ...args ) => _svc.find( ...args );
+export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+export const insertMany = ( ...args ) => _svc.insertMany( ...args );
+export const updateMany = ( ...args ) => _svc.updateMany( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const getClientCount = ( ...args ) => _svc.getClientCount( ...args );
+export const create = ( ...args ) => _svc.create( ...args );
+export const findLimit = ( ...args ) => _svc.findLimit( ...args );
+export const getCount = ( ...args ) => _svc.getCount( ...args );
+export const updateArrayKey = ( ...args ) => _svc.updateArrayKey( ...args );

package/src/services/processedchecklistconfig.services.js

@@ -1,35 +1,40 @@
 import model from 'tango-api-schema';
-
-export const find = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.find( query, record );
-};
-
-export const findOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.findOne( query, record ).sort( { updatedAt: -1 } );
-};
-
-export const updateOne = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const updateMany = ( query = {}, record = {} ) => {
-  return model.processedchecklistconfigModel.updateMany( query, { $set: record } );
-};
-
-export const deleteMany = ( query = {} ) => {
-  return model.processedchecklistconfigModel.deleteMany( query );
-};
-
-export const aggregate = ( query = [] ) => {
-  return model.processedchecklistconfigModel.aggregate( query );
-};
-
-export const getClientCount = ( query = {} ) => {
-  return model.processedchecklistconfigModel.count( query );
-};
-
-export const insert = ( document={} ) => {
-  return model.processedchecklistconfigModel.create( document );
-};
-
-
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+const _methods = {
+  async find( query = {}, record = {} ) {
+    return model.processedchecklistconfigModel.find( query, record );
+  },
+  async findOne( query = {}, record = {} ) {
+    return model.processedchecklistconfigModel.findOne( query, record ).sort( { updatedAt: -1 } );
+  },
+  async updateOne( query = {}, record = {} ) {
+    return model.processedchecklistconfigModel.updateOne( query, { $set: record }, { upsert: true } );
+  },
+  async updateMany( query = {}, record = {} ) {
+    return model.processedchecklistconfigModel.updateMany( query, { $set: record } );
+  },
+  async deleteMany( query = {} ) {
+    return model.processedchecklistconfigModel.deleteMany( query );
+  },
+  async aggregate( query = [] ) {
+    return model.processedchecklistconfigModel.aggregate( query );
+  },
+  async getClientCount( query = {} ) {
+    return model.processedchecklistconfigModel.count( query );
+  },
+  async insert( document = {} ) {
+    return model.processedchecklistconfigModel.create( document );
+  },
+};
+
+const _svc = createLoggableService( _methods, 'processedchecklistconfigs' );
+
+export const find = ( ...args ) => _svc.find( ...args );
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+export const updateMany = ( ...args ) => _svc.updateMany( ...args );
+export const deleteMany = ( ...args ) => _svc.deleteMany( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const getClientCount = ( ...args ) => _svc.getClientCount( ...args );
+export const insert = ( ...args ) => _svc.insert( ...args );

package/src/services/recurringFlagTracker.service.js

@@ -1,33 +1,40 @@
 import model from 'tango-api-schema';
-
-export const findOne = async ( query={}, field={} ) => {
-  return model.recurringFlagTrackerModel.findOne( query, field );
-};
-
-export const find = async ( query={}, field={} ) => {
-  return model.recurringFlagTrackerModel.find( query, field );
-};
-
-export const create = async ( document = {} ) => {
-  return model.recurringFlagTrackerModel.create( document );
-};
-
-export const updateOne = async ( query = {}, record={} ) => {
-  return model.recurringFlagTrackerModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const updateMany = async ( query = {}, record={} ) => {
-  return model.recurringFlagTrackerModel.updateMany( query, { $set: record } );
-};
-
-export const deleteOne = async ( query = {} ) => {
-  return model.recurringFlagTrackerModel.deleteOne( query );
-};
-
-export const aggregate = async ( query = [] ) => {
-  return model.recurringFlagTrackerModel.aggregate( query );
-};
-
-export const bulkWrite = async ( ops = [] ) => {
-  return model.recurringFlagTrackerModel.bulkWrite( ops );
-};
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+const _methods = {
+  async findOne( query={}, field={} ) {
+    return model.recurringFlagTrackerModel.findOne( query, field );
+  },
+  async find( query={}, field={} ) {
+    return model.recurringFlagTrackerModel.find( query, field );
+  },
+  async create( document = {} ) {
+    return model.recurringFlagTrackerModel.create( document );
+  },
+  async updateOne( query = {}, record={} ) {
+    return model.recurringFlagTrackerModel.updateOne( query, { $set: record }, { upsert: true } );
+  },
+  async updateMany( query = {}, record={} ) {
+    return model.recurringFlagTrackerModel.updateMany( query, { $set: record } );
+  },
+  async deleteOne( query = {} ) {
+    return model.recurringFlagTrackerModel.deleteOne( query );
+  },
+  async aggregate( query = [] ) {
+    return model.recurringFlagTrackerModel.aggregate( query );
+  },
+  async bulkWrite( ops = [] ) {
+    return model.recurringFlagTrackerModel.bulkWrite( ops );
+  },
+};
+
+const _svc = createLoggableService( _methods, 'recurringflagtrackers' );
+
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const find = ( ...args ) => _svc.find( ...args );
+export const create = ( ...args ) => _svc.create( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+export const updateMany = ( ...args ) => _svc.updateMany( ...args );
+export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const bulkWrite = ( ...args ) => _svc.bulkWrite( ...args );

package/src/services/runAIFeatures.services.js

@@ -1,31 +1,36 @@
 import model from 'tango-api-schema';
-
-export const findOne = async ( query={}, field={} ) => {
-  return model.runAIFeaturesModel.findOne( query, field );
-};
-
-export const find = async ( query={}, field={} ) => {
-  return model.runAIFeaturesModel.find( query, field );
-};
-
-export const create = async ( document = {} ) => {
-  return model.runAIFeaturesModel.create( document );
-};
-
-export const deleteOne = async ( query = {} ) => {
-  return model.runAIFeaturesModel.deleteOne( query );
-};
-
-export const updateOne = async ( query = {}, record={} ) => {
-  return model.runAIFeaturesModel.updateOne( query, { $set: record }, { upsert: true } );
-};
-
-export const aggregate = async ( query = {} ) => {
-  return model.runAIFeaturesModel.aggregate( query );
-};
-
-export const count = async ( query = {} ) => {
-  return model.runAIFeaturesModel.countDocuments( query );
+import { createLoggableService } from '../logging/createLoggableService.js';
+
+const _methods = {
+  async findOne( query={}, field={} ) {
+    return model.runAIFeaturesModel.findOne( query, field );
+  },
+  async find( query={}, field={} ) {
+    return model.runAIFeaturesModel.find( query, field );
+  },
+  async create( document = {} ) {
+    return model.runAIFeaturesModel.create( document );
+  },
+  async deleteOne( query = {} ) {
+    return model.runAIFeaturesModel.deleteOne( query );
+  },
+  async updateOne( query = {}, record={} ) {
+    return model.runAIFeaturesModel.updateOne( query, { $set: record }, { upsert: true } );
+  },
+  async aggregate( query = {} ) {
+    return model.runAIFeaturesModel.aggregate( query );
+  },
+  async count( query = {} ) {
+    return model.runAIFeaturesModel.countDocuments( query );
+  },
 };
 
+const _svc = createLoggableService( _methods, 'runaifeatures' );
 
+export const findOne = ( ...args ) => _svc.findOne( ...args );
+export const find = ( ...args ) => _svc.find( ...args );
+export const create = ( ...args ) => _svc.create( ...args );
+export const deleteOne = ( ...args ) => _svc.deleteOne( ...args );
+export const updateOne = ( ...args ) => _svc.updateOne( ...args );
+export const aggregate = ( ...args ) => _svc.aggregate( ...args );
+export const count = ( ...args ) => _svc.count( ...args );