@blazedpath/commons 0.0.8 → 0.0.9

package/blz-json-schema/index.js

@@ -1,11 +1,13 @@
 const validate = require('jsonschema').validate;
 
 module.exports = {
-    jsonSchemaValidate: function (data, schema) {
-        if (schema === undefined || schema === null)
-            throw new Error('schema undefined')
-        let result = validate(data, schema)
-        result.valid = (result.errors.length === 0)
-        return result   
+    Backend: {
+        jsonSchemaValidate: function (data, schema) {
+            if (schema === undefined || schema === null)
+                throw new Error('schema undefined')
+            let result = validate(data, schema)
+            result.valid = (result.errors.length === 0)
+            return result
+        }
     }
 };

package/blz-jwt/index.js

@@ -1,4 +1,5 @@
 const jwt = require('jsonwebtoken');
+const { Backend } = require('../blz-json-schema');
 
 class JwtSecretKeyNotDefined extends Error {
     constructor() {
@@ -17,105 +18,107 @@ function getJwtSecretKey() {
 }
 
 module.exports = {
-    JwtSecretKeyNotDefined,
+    Backend: {
+        JwtSecretKeyNotDefined,
 
-    jwtSign: function (payload, secret, algorithm) {
-        try {
-            switch (algorithm) {
-                case 'HMAC-SHA256':
-                    return jwt.sign(payload, secret, { algorithm: 'HS256' });
-                case 'HMAC-SHA384':
-                    return jwt.sign(payload, secret, { algorithm: 'HS384' });
-                case 'HMAC-SHA512':
-                    return jwt.sign(payload, secret, { algorithm: 'HS512' });
-                default:
-                    throw new Error('Invalid encryption algorithm');
-            }
-        } catch (jwterr) {
-            if (jwterr.name === 'TokenExpiredError') {
-                let err = new Error();
-                err.code = 'JwtExpired';
-                err.data = { expiredAt: jwterr.expiredAt };
-                throw err;
-            } else {
-                throw jwterr;
+        jwtSign: function (payload, secret, algorithm) {
+            try {
+                switch (algorithm) {
+                    case 'HMAC-SHA256':
+                        return jwt.sign(payload, secret, { algorithm: 'HS256' });
+                    case 'HMAC-SHA384':
+                        return jwt.sign(payload, secret, { algorithm: 'HS384' });
+                    case 'HMAC-SHA512':
+                        return jwt.sign(payload, secret, { algorithm: 'HS512' });
+                    default:
+                        throw new Error('Invalid encryption algorithm');
+                }
+            } catch (jwterr) {
+                if (jwterr.name === 'TokenExpiredError') {
+                    let err = new Error();
+                    err.code = 'JwtExpired';
+                    err.data = { expiredAt: jwterr.expiredAt };
+                    throw err;
+                } else {
+                    throw jwterr;
+                }
             }
-        }
-    },
+        },
 
-    jwtVerify: function (token, secret) {
-        try {
-            return jwt.verify(token, secret);
-        } catch (jwterr) {
-            if (jwterr.name === 'TokenExpiredError') {
-                let err = new Error();
-                err.code = 'JwtExpired';
-                err.data = { expiredAt: jwterr.expiredAt };
-                throw err;
-            } else {
-                let err = new Error();
-                err.code = 'JwtError';
-                err.data = {};
-                throw err;
+        jwtVerify: function (token, secret) {
+            try {
+                return jwt.verify(token, secret);
+            } catch (jwterr) {
+                if (jwterr.name === 'TokenExpiredError') {
+                    let err = new Error();
+                    err.code = 'JwtExpired';
+                    err.data = { expiredAt: jwterr.expiredAt };
+                    throw err;
+                } else {
+                    let err = new Error();
+                    err.code = 'JwtError';
+                    err.data = {};
+                    throw err;
+                }
             }
-        }
-    },
+        },
 
-    jwtDecode: function (token) {
-        try {
-            return jwt.decode(token);
-        } catch (jwterr) {
-            if (jwterr.name === 'TokenExpiredError') {
-                let err = new Error();
-                err.code = 'JwtExpired';
-                err.data = { expiredAt: jwterr.expiredAt };
-                throw err;
-            } else {
-                let err = new Error();
-                err.code = 'JwtError';
-                err.data = {};
-                throw err;
+        jwtDecode: function (token) {
+            try {
+                return jwt.decode(token);
+            } catch (jwterr) {
+                if (jwterr.name === 'TokenExpiredError') {
+                    let err = new Error();
+                    err.code = 'JwtExpired';
+                    err.data = { expiredAt: jwterr.expiredAt };
+                    throw err;
+                } else {
+                    let err = new Error();
+                    err.code = 'JwtError';
+                    err.data = {};
+                    throw err;
+                }
             }
-        }
-    },
+        },
 
-    jwtCreateToken: function (id, expiresIn = '10s') {
-        return jwt.sign({ id }, getJwtSecretKey(), { expiresIn });
-    },
+        jwtCreateToken: function (id, expiresIn = '10s') {
+            return jwt.sign({ id }, getJwtSecretKey(), { expiresIn });
+        },
 
-    jwtGetId: function (token) {
-        try {
-            const decoded = jwt.verify(token, getJwtSecretKey());
-            return decoded.id;
-        } catch (err) {
-            const error = new Error('Invalid or expired token');
-            error.code = 'JwtInvalid';
-            error.data = err.message;
-            throw error;
-        }
-    },
-
-    jwtEncodeUrl: function (url, expiresIn = '10s') {
-        const [path, query] = url.split('?');
-        const parts = path.split('/').map(part => {
-            if (/^\d+$/.test(part)) {
-                return jwt.sign({ id: parseInt(part) }, getJwtSecretKey(), { expiresIn });
+        jwtGetId: function (token) {
+            try {
+                const decoded = jwt.verify(token, getJwtSecretKey());
+                return decoded.id;
+            } catch (err) {
+                const error = new Error('Invalid or expired token');
+                error.code = 'JwtInvalid';
+                error.data = err.message;
+                throw error;
             }
-            return part;
-        });
-        return parts.join('/') + (query ? `?${query}` : '');
-    },
+        },
 
-    jwtDecodeUrl: function (url) {
-        const [path, query] = url.split('?');
-        const parts = path.split('/').map(part => {
-            try {
-                const decoded = jwt.verify(part, getJwtSecretKey());
-                return decoded.id?.toString() ?? part;
-            } catch {
+        jwtEncodeUrl: function (url, expiresIn = '10s') {
+            const [path, query] = url.split('?');
+            const parts = path.split('/').map(part => {
+                if (/^\d+$/.test(part)) {
+                    return jwt.sign({ id: parseInt(part) }, getJwtSecretKey(), { expiresIn });
+                }
                 return part;
-            }
-        });
-        return parts.join('/') + (query ? `?${query}` : '');
+            });
+            return parts.join('/') + (query ? `?${query}` : '');
+        },
+
+        jwtDecodeUrl: function (url) {
+            const [path, query] = url.split('?');
+            const parts = path.split('/').map(part => {
+                try {
+                    const decoded = jwt.verify(part, getJwtSecretKey());
+                    return decoded.id?.toString() ?? part;
+                } catch {
+                    return part;
+                }
+            });
+            return parts.join('/') + (query ? `?${query}` : '');
+        }
     }
 };

package/blz-kafka/index.js

@@ -31,11 +31,11 @@ const getConfig = async function (connection) {
     if (connection.brokers)
         kafkaConfig.brokers = connection.brokers.split(',');
     kafkaConfig.connectionTimeout = connection.connectionTimeout || 3000;
-    kafkaConfig.authenticationTimeout= connection.authenticationTimeout  || 1000;
+    kafkaConfig.authenticationTimeout = connection.authenticationTimeout || 1000;
     kafkaConfig.reauthenticationThreshold = connection.reauthenticationThreshold || 10000;
     if (connection.requestTimeout)
         kafkaConfig.requestTimeout = connection.requestTimeout;
-    if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor){
+    if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor) {
         kafkaConfig.retry = {};
         if (connection.connectionRetries)
             kafkaConfig.retry.retries = connection.connectionRetries;
@@ -81,16 +81,16 @@ let getOrCreateProducer = async function (connection) {
     if (producer) {
         return producer;
     }
-    let kafkaConfig = await getConfig(connection);    
+    let kafkaConfig = await getConfig(connection);
     let kafka = new Kafkajs.Kafka(kafkaConfig);
-    producer = kafka.producer({createPartitioner: Kafkajs.Partitioners.LegacyPartitioner});
+    producer = kafka.producer({ createPartitioner: Kafkajs.Partitioners.LegacyPartitioner });
     await producer.connect();
     producers[connection.name] = producer;
     return producer;
 };
 
 let getOrCreateAdmin = async function (connection, config) {
-    let kafkaConfig = await getConfig(connection);    
+    let kafkaConfig = await getConfig(connection);
     let kafka = new Kafkajs.Kafka(kafkaConfig);
     admin = kafka.admin();
     await admin.connect();
@@ -134,7 +134,7 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
             continue
         }
 
-        let connection = connections[buildKafkaConsumer.systemName]; 
+        let connection = connections[buildKafkaConsumer.systemName];
         // Check if kafka connection info is undefined
         if (!connection) {
             const kafkaBuildSystemConfig = buildConfigItems[buildKafkaConsumer.systemName]
@@ -153,11 +153,11 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
             if (connection.brokers)
                 kafkaConfig.brokers = connection.brokers.split(',');
             kafkaConfig.connectionTimeout = connection.connectionTimeout || 3000;
-            kafkaConfig.authenticationTimeout= connection.authenticationTimeout  || 1000;
+            kafkaConfig.authenticationTimeout = connection.authenticationTimeout || 1000;
             kafkaConfig.reauthenticationThreshold = connection.reauthenticationThreshold || 10000;
             if (connection.requestTimeout)
                 kafkaConfig.requestTimeout = connection.requestTimeout;
-            if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor){
+            if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor) {
                 kafkaConfig.retry = {};
                 if (connection.connectionRetries)
                     kafkaConfig.retry.retries = connection.connectionRetries;
@@ -195,16 +195,16 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
                 }
             }
             kafkaConfig.logLevel = Kafkajs.logLevel.ERROR;
-            kafkaConfig.logCreator = ()=> {
+            kafkaConfig.logCreator = () => {
                 return ({ namespace, level, label, log }) => {
                     if (level === 1 && log.message && log.message.includes('The group is rebalancing')) {
                         // Do nothing or log at a different level for rebalancing errors
                         return;
-                    } else if (level === 1 ) {
+                    } else if (level === 1) {
                         runHelper.logError(`[${namespace}] : ${JSON.stringify(log.message)}`, namespace, log);
                     } else {
                         runHelper.log(`[${namespace}] : ${log.message}`);
-                    }                   
+                    }
                 }
             };
             kafka = new Kafkajs.Kafka(kafkaConfig);
@@ -219,7 +219,7 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
 //           en blz-builder es ... TODO
 // - kafkaConsumers: objeto con todos los consumers. Cada property del objeto es consumer
 // - connections: objeto con todas las conneciones con key
-async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections, runHelper) {
+async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper) {
 
     for (let kafkaConsumerName in kafkaConsumers) {
         let buildKafkaConsumer = kafkaConsumers[kafkaConsumerName];
@@ -232,21 +232,21 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
         let kafkaErrorOptions = {};
         kafkaErrorOptions.errorOptions = connection.errorOptions ?? false;
         kafkaErrorOptions.manualCommit = connection.messageManualCommit ?? false;
-        kafkaErrorOptions.retries =  connection.messageRetryCount ?? 5;
+        kafkaErrorOptions.retries = connection.messageRetryCount ?? 5;
         kafkaErrorOptions.initialRetryTime = connection.initialRetryTime ?? 300;
         kafkaErrorOptions.factor = connection.messageRetryFactor ?? 2;
         kafkaErrorOptions.multiplier = connection.messageRetryMultiplier ?? 2;
         kafkaErrorOptions.traceAll = connection.traceAll ?? false;
-        kafkaErrorOptions.retryTopic = (buildKafkaConsumer.useErrorTopic && buildKafkaConsumer.parameterizedErrorTopic)? config.parameters[ buildKafkaConsumer.parameterizedErrorTopic.configParameterName ] : '';
+        kafkaErrorOptions.retryTopic = (buildKafkaConsumer.useErrorTopic && buildKafkaConsumer.parameterizedErrorTopic) ? config.parameters[buildKafkaConsumer.parameterizedErrorTopic.configParameterName] : '';
 
         let topics = [];
-        if (buildKafkaConsumer.topics){
+        if (buildKafkaConsumer.topics) {
             for (let i = 0; i < buildKafkaConsumer.topics.length; i++) {
                 let topic = buildKafkaConsumer.topics[i];
                 topics.push(topic);
             }
         }
-        if (buildKafkaConsumer.parameterizedTopics){
+        if (buildKafkaConsumer.parameterizedTopics) {
             for (let i = 0; i < buildKafkaConsumer.parameterizedTopics.length; i++) {
                 let parameterizedTopic = buildKafkaConsumer.parameterizedTopics[i];
                 const topic = config.parameters[parameterizedTopic.configParameterName];
@@ -263,13 +263,13 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
             continue
         }
         const groupId = buildKafkaConsumer.isParameterizedGroupId
-            ? config.parameters[ buildKafkaConsumer.parameterizedGroupId.configParameterName ]
+            ? config.parameters[buildKafkaConsumer.parameterizedGroupId.configParameterName]
             : buildKafkaConsumer.groupId
-        
+
         if (groupId === undefined || groupId === null || groupId.trim() === '') {
             console.error(`Kafka: ${kafkaConsumerName} consumer not had groupId defined`)
             continue
-        }        
+        }
         if (topics.length === 0) {
             console.error(`Kafka: ${kafkaConsumerName} consumer not had topics defined`)
             continue
@@ -296,7 +296,7 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
                             message: { key: consumeData.message.key, value: consumeData.message.value, headers: consumeData.message.headers }
                         };
                         await runHelper.runAlgorithm(callContext, { elementType: 'KafkaConsumer', elementName: kafkaConsumerName, path: buildKafkaConsumer.path, aliasesMatches: buildKafkaConsumer.aliasesMatches }, null, buildKafkaConsumer.algorithm, ctx0);
-						if (kafkaErrorOptions.manualCommit) {
+                        if (kafkaErrorOptions.manualCommit) {
                             await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
                         }
                     }
@@ -310,7 +310,7 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
         }
         // If Kafka is an actual server (!= mock). Use this section
         else {
-            try{
+            try {
                 let consumerOptions = {}
                 let consumerOptionsDefault = {
                     sessionTimeout: 60000,                // 60 seconds
@@ -327,7 +327,7 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
                         multiplier: 2                     // Backoff multiplier
                     }
                 };
-                if (connection.consumerOptions){
+                if (connection.consumerOptions) {
                     consumerOptions = { ...consumerOptionsDefault, ...connection.consumerOptions };
                 }
                 let consumer = kafka.consumer({ groupId: groupId });
@@ -340,8 +340,8 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
                     }
                     try {
                         await consumer.subscribe({ topic: topic, fromBeginning: buildKafkaConsumer.fromBeginning });
-                    } catch(err) {
-                        runHelper.logError(new Error(`Kafka: error whit topic ${topic}: ${err.message} `,err));                
+                    } catch (err) {
+                        runHelper.logError(new Error(`Kafka: error whit topic ${topic}: ${err.message} `, err));
                     }
                 }
                 // Handle group join and leave events
@@ -399,18 +399,18 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
                                 await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
                             }
                         } catch (err) {
-                            if(kafkaErrorOptions.traceAll) {
+                            if (kafkaErrorOptions.traceAll) {
                                 console.error(err);
                             }
-                            if(kafkaErrorOptions.retryTopic && kafkaErrorOptions.retryTopic !== '') {
+                            if (kafkaErrorOptions.retryTopic && kafkaErrorOptions.retryTopic !== '') {
                                 // sends message with error to retry topic
                                 await module.exports.kafkaSend(connection, kafkaErrorOptions.retryTopic, [message]);
                                 // marks the message as read on original topic
                                 await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
-                           }
+                            }
                         }
                         await runHelper.terminateCallContext(callContext);
-                    }, 
+                    },
                     retry: {
                         retries: kafkaErrorOptions.retries,
                         initialRetryTime: kafkaErrorOptions.initialRetryTime,
@@ -429,94 +429,96 @@ async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections,
             } catch (err) {
                 runHelper.logError(err);
             }
-        }        
+        }
         if (process.env.blz_traceAll === 'true' || process.env.blz_traceKafkaConsumers === 'true') {
             console.log('KAFKA CONSUMER | ' + kafkaConsumerName + ' | Start');
         }
-        
+
     }
 }
 // END: functions to initialize kafka consumers
 
 module.exports = {
-    kafkaConfig: async function (connection, config) {
-        if(!config || !config.topicsConfig || !config.topicsConfig.topics || !config.topicsConfig.topics.length || config.topicsConfig.topics.length === 0) {
-            throw new Error('Invalid config');
-        }
-        for (let i = 0; i < config.topicsConfig.topics.length; i++) {
-            let topic = config.topicsConfig.topics[i];
-            if (!topic.topic || topic.topic.trim().length === 0) {
-                throw new Error(`Invalid topic ${i+1} config`);
+    Backend: {
+        kafkaConfig: async function (connection, config) {
+            if (!config || !config.topicsConfig || !config.topicsConfig.topics || !config.topicsConfig.topics.length || config.topicsConfig.topics.length === 0) {
+                throw new Error('Invalid config');
             }
-        }
-        let result = false
-        let error = null;
-        let admin = null;  
-        try {
-            let kafkaConfig = await getConfig(connection);    
-            let kafka = new Kafkajs.Kafka(kafkaConfig);            
-            admin = kafka.admin();
-            await admin.connect();
-            const currentTopics = await admin.listTopics();
-            let newsTopics = config.topicsConfig.topics.filter(topic => !currentTopics.includes(topic.topic));            
-            if(newsTopics && newsTopics.length > 0) {
-                config.topicsConfig.topics = newsTopics;
-                result = await admin.createTopics(config.topicsConfig);
-            } 
-        }catch(e) {
-            error = e;
-        } finally {
-            if(admin) {
-                await admin.disconnect();
-            }  
-        }
-        if(error) {
-            throw error;
-        }
-        return result;                
-    },
-    kafkaGetTopics: async function (connection) {
-        let kafkaConfig = await getConfig(connection);    
-        let kafka = new Kafkajs.Kafka(kafkaConfig);
-        const admin = kafka.admin();
-        await admin.connect();
-        const topics = await admin.listTopics();
-        await admin.disconnect();
-        return topics;
-    },
-    kafkaSend: async function (connection, topic, messages) {
-        if (connection.provider) {
-            await connection.provider.produce(connection, topic, messages);
-            return null;
-        }
-        let producer = await getOrCreateProducer(connection);
-        await producer.send({ topic: topic, messages: messages });
-        return null;
-    },
-    kafkaConnections: async function(kafkaConsumers, connections, buildConfigItems, runHelper){
-        return createKafkaInstances(kafkaConsumers, connections, buildConfigItems, runHelper);
-    },
-    startKafkaConsumers: async function(kafkas,config, kafkaConsumers, connections, runHelper){
-        startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper); 
-    },
-    kafkaConnectionHealthCheck: async function (connection) {
-        if (!connection.brokers) {
-            return { status: "error", message: "Kafka broker list not defined" }
-        }
-        const kafka = new Kafkajs.Kafka({ brokers: [connection.brokers] });
-        try {
-            // Try to get metadata from Kafka to check the connection
+            for (let i = 0; i < config.topicsConfig.topics.length; i++) {
+                let topic = config.topicsConfig.topics[i];
+                if (!topic.topic || topic.topic.trim().length === 0) {
+                    throw new Error(`Invalid topic ${i + 1} config`);
+                }
+            }
+            let result = false
+            let error = null;
+            let admin = null;
+            try {
+                let kafkaConfig = await getConfig(connection);
+                let kafka = new Kafkajs.Kafka(kafkaConfig);
+                admin = kafka.admin();
+                await admin.connect();
+                const currentTopics = await admin.listTopics();
+                let newsTopics = config.topicsConfig.topics.filter(topic => !currentTopics.includes(topic.topic));
+                if (newsTopics && newsTopics.length > 0) {
+                    config.topicsConfig.topics = newsTopics;
+                    result = await admin.createTopics(config.topicsConfig);
+                }
+            } catch (e) {
+                error = e;
+            } finally {
+                if (admin) {
+                    await admin.disconnect();
+                }
+            }
+            if (error) {
+                throw error;
+            }
+            return result;
+        },
+        kafkaGetTopics: async function (connection) {
+            let kafkaConfig = await getConfig(connection);
+            let kafka = new Kafkajs.Kafka(kafkaConfig);
             const admin = kafka.admin();
             await admin.connect();
-            // Fetch metadata (this will trigger a request to Kafka to see if it's reachable)
-            const metadata = await admin.fetchTopicMetadata({ topics: [] });
-            logger.info({message: "Kafka is reachable!", metadata:metadata});
-            await admin.disconnect();  // Disconnect after metadata check
-            return { status: "ok", message: "Kafka connected, metadata vissible" };
-        } catch (error) {
-            logger.info({ message: "Kafka is not reachable", error: error });
-            return { status: "error", message: error.message };
-        }
+            const topics = await admin.listTopics();
+            await admin.disconnect();
+            return topics;
+        },
+        kafkaSend: async function (connection, topic, messages) {
+            if (connection.provider) {
+                await connection.provider.produce(connection, topic, messages);
+                return null;
+            }
+            let producer = await getOrCreateProducer(connection);
+            await producer.send({ topic: topic, messages: messages });
+            return null;
+        },
+        kafkaConnections: async function (kafkaConsumers, connections, buildConfigItems, runHelper) {
+            return createKafkaInstances(kafkaConsumers, connections, buildConfigItems, runHelper);
+        },
+        startKafkaConsumers: async function (kafkas, config, kafkaConsumers, connections, runHelper) {
+            startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper);
+        },
+        kafkaConnectionHealthCheck: async function (connection) {
+            if (!connection.brokers) {
+                return { status: "error", message: "Kafka broker list not defined" }
+            }
+            const kafka = new Kafkajs.Kafka({ brokers: [connection.brokers] });
+            try {
+                // Try to get metadata from Kafka to check the connection
+                const admin = kafka.admin();
+                await admin.connect();
+                // Fetch metadata (this will trigger a request to Kafka to see if it's reachable)
+                const metadata = await admin.fetchTopicMetadata({ topics: [] });
+                logger.info({ message: "Kafka is reachable!", metadata: metadata });
+                await admin.disconnect();  // Disconnect after metadata check
+                return { status: "ok", message: "Kafka connected, metadata vissible" };
+            } catch (error) {
+                logger.info({ message: "Kafka is not reachable", error: error });
+                return { status: "error", message: error.message };
+            }
 
+        }
     }
 };