corebasic 1.0.240 → 1.0.242

package/dist/libs/dip.js

@@ -60,7 +60,7 @@ export const IdempotentDip = () => {
     };
     return idip;
 };
-export const idip = async (message, callback, cleanup) => {
+export const idip = async (meta, txn, callback, cleanup) => {
     if (!callback)
         throw new Error("Dip.idip() callback argument undefined");
     if (!cleanup)
@@ -73,9 +73,9 @@ export const idip = async (message, callback, cleanup) => {
         else
             await cleanup(IDip);
     }
-    let IDip = await IdempotentDip().new(message.meta, message.txn);
+    let IDip = await IdempotentDip().new(meta, txn);
     if (!IDip) {
-        IDip = await IdempotentDip().new(message.meta, message.txn, { blank: true });
+        IDip = await IdempotentDip().new(meta, txn, { blank: true });
         await doCleanup(IDip);
         return;
     }
@@ -87,7 +87,7 @@ export const insertKeys = (message, meta) => {
     if (!isDipMeta(meta))
         throw new Error('Error: Provided meta is not an instance of DipMeta in Dip.insertKeys()');
     return {
-        "created": message.date, "updated": message.date,
+        "created": message.meta.date, "updated": message.meta.date,
         "createdBy": message.meta.staff,
         "updatedBy": message.meta.staff,
         "createdByUser": message.meta.user,
@@ -98,7 +98,7 @@ export const insertKeys = (message, meta) => {
 };
 export const updateKeys = (message) => {
     return {
-        "updated": message.date,
+        "updated": message.meta.date,
         "updatedBy": message.meta.staff,
         "updatedByUser": message.meta.user,
     };

package/dist/libs/features.js

@@ -93,16 +93,17 @@ export const send = async (meta, feature, data, params) => {
             writableEnded: false,
         };
         await apiHandler(req, res);
-        return response; // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.
+        return response.data; // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.
     }
     // Workaround: https://stackoverflow.com/questions/72343387/axios-not-sending-headers-request-failing-getting-401-error
-    return (await axios({
+    const response = (await axios({
         method,
         url: `${service}${url}`,
         headers: { jwt: SERVICE_ACCESS_TOKEN, service: true, NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN },
         data: payload,
         timeout: 30000 // 30 secs
-    })).data; // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.;
+    })).data;
+    return response.data; // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.;
 };
 let appids = {};
 async function announce() {
@@ -146,12 +147,11 @@ const apiHandler = async (req, res) => {
             throw { status: 404, message: `Resource not found. Feature ${req.body.feature} not available.` };
         }
         feature = feature; // typescript validation with !
-        let topic = feature.topic;
         let params = getFeatureUrl(feature.api).split("/").filter((item) => item.startsWith(":")).map((item) => item.replace(":", ""));
         for (let param of params)
             if (!req.params[param])
                 throw { status: 404, message: "Resource not found. One or more url parameter not specified." };
-        let meta = { ...req.body, data: undefined }; // TODO: Must also include invoiceTxn
+        let meta = { ...req.body, data: undefined, topic: feature.topic, date: new Date().getTime() }; // TODO: Must also include invoiceTxn
         if (process.env.USE_DEFAULT_COMPANY) {
             meta.company = 'DEFAULT_COMPANY';
             meta.outlet = 'DEFAULT_OUTLET';
@@ -161,13 +161,6 @@ const apiHandler = async (req, res) => {
             meta,
             data: req.body.data,
             params: req.params,
-            // To be removed 1
-            date: new Date().getTime(),
-            // To be removed 2
-            topic,
-            feature: req.body.feature,
-            user: req.body.user,
-            txn: meta.txn,
         };
         const appReq = {
             meta: message.meta,
@@ -183,34 +176,36 @@ const apiHandler = async (req, res) => {
         const appRes = res;
         if (method === "get") {
             try {
-                // await feature.handler({...req, headers: req.headers, body: {...req.body, topic} }, res)
-                // req.body = {...req.body, topic}
-                await feature.handler(appReq, appRes);
+                const data = await feature.handler(message, appReq, appRes);
+                if (!appRes.headersSent)
+                    res.json({ data });
             }
             catch (err) {
                 if (process.env.DEBUG_MODE)
-                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
+                    console.error('Error: Feature: ', message.meta.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
                 throw { status: 500, message: "Failed to GET feature", ...err };
             }
         }
         else if (method !== "get" && feature.bypass) {
             try {
-                await feature.handler(topic, message, appReq, appRes);
+                const data = await feature.handler(message, appReq, appRes);
+                if (!appRes.headersSent)
+                    res.json({ data, event: message.meta.feature, txn: message.meta.txn, bypass: true });
             }
             catch (err) {
                 if (process.env.DEBUG_MODE)
-                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
+                    console.error('Error: Feature: ', message.meta.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
                 throw { status: 500, message: "Failed to POST feature", ...err };
             }
         }
         else {
             try {
-                await Kafka.send(`Features.${topic}`, message, message.user, { compression: Kafka.CompressionTypes.GZIP });
+                await Kafka.send(`Features.${message.meta.topic}`, message, message.meta.user, { compression: Kafka.CompressionTypes.GZIP });
             }
             catch {
                 throw { status: 500, message: "Failed to queue the transaction" };
             }
-            appRes.json({ data: { txn: message.txn, success: true, status: "Queued", featureQueued: true } });
+            appRes.json({ data: { txn: message.meta.txn, success: true, status: "Queued", featureQueued: true } });
         }
     }
     catch (err) {
@@ -243,9 +238,9 @@ async function registerHandler(features) {
         if (featurePath === 'src/transactions/query')
             continue;
         if (featureName.startsWith("flows.") && !featureName.startsWith("flows.query.") && !featureName.startsWith("flows.command.") && !featureName.startsWith("flows.designs."))
-            feature.handler = (await import(__rewriteRelativeImportExtension(`${new URL(`src/flows/query.js`, PROJECT_ROOT_URL).toString().replace('file://', '')}`))).FEATURE_HANDLERS[handler];
+            feature.handler = (await import(__rewriteRelativeImportExtension(`${new URL(`src/flows/query.ts`, PROJECT_ROOT_URL).toString().replace('file://', '')}`))).FEATURE_HANDLERS[handler];
         else
-            feature.handler = (await import(__rewriteRelativeImportExtension(`${new URL(`${featurePath}.js`, PROJECT_ROOT_URL).toString().replace('file://', '')}`)))[handler];
+            feature.handler = (await import(__rewriteRelativeImportExtension(`${new URL(`${featurePath}.ts`, PROJECT_ROOT_URL).toString().replace('file://', '')}`)))[handler];
     }
 }
 function registerApi() {
@@ -291,31 +286,31 @@ export const start = async (app, url, file) => {
     for (let topic of kafkaTopics) {
         const groupId = '';
         Kafka.receive(`Features.${topic}`, groupId, async (topic, message) => {
+            topic = topic.replace(/^.*Features./, '');
             if (Utils.isEmpty(message.meta?.company))
                 message.meta = { ...message.meta, company: "GLOBAL", outlet: "GLOBAL" };
-            if (!message?.feature)
+            if (!message.meta.feature)
                 return;
             const timer = (ms) => new Promise(res => setTimeout(res, ms)); // A promise that resolves after "ms" Milliseconds
-            topic = topic.replace(/^.*Features./, '');
             while (true) {
                 try {
-                    // const iso_date = new Date(message.date).toISOString()
+                    // const iso_date = new Date(message.meta.date).toISOString()
                     // // TODO: use $useChunks: [] once support is added in dip insert
-                    // await Dip.insert(globalMeta, `users.txns`, { _id: `${message.user}_${iso_date}_${message.txn}`, user: message.user, feature: message.feature, date: message.date, created: message.date, updated: message.date, status: "Queued" }, {idempotent: true}) // Can always update the status later
+                    // await Dip.insert(globalMeta, `users.txns`, { _id: `${message.meta.user}_${iso_date}_${message.meta.txn}`, user: message.meta.user, feature: message.meta.feature, date: message.meta.date, created: message.meta.date, updated: message.meta.date, status: "Queued" }, {idempotent: true}) // Can always update the status later
                     // TODO: Avoid duplicate processing
-                    const feature = features[message.feature];
+                    const feature = features[message.meta.feature];
                     if (!feature) {
-                        console.warn(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`);
-                        throw new Error(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`);
+                        console.warn(`Feature ${message.meta.feature} missing, in executing handler during Kafka.receive(topic: ${message.meta.topic})`);
+                        throw new Error(`Feature ${message.meta.feature} missing, in executing handler during Kafka.receive(topic: ${message.meta.topic})`);
                     }
-                    await feature.handler(topic, message);
-                    await Dip.insert(globalMeta, "Features.txns", { _id: message.txn, status: "Processed" }, { idempotent: true });
+                    await feature.handler(message);
+                    await Dip.insert(globalMeta, "Features.txns", { _id: message.meta.txn, status: "Processed" }, { idempotent: true });
                     break;
                 }
                 catch (err) {
                     if (process.env.DEBUG_MODE)
-                        console.log('Error: Feature: ', message.feature, err);
-                    console.warn(`Feature: ${message.feature}, error in executing handler during Kafka.receive(topic: ${topic})`);
+                        console.log('Error: Feature: ', message.meta.feature, err);
+                    console.warn(`Feature: ${message.meta.feature}, error in executing handler during Kafka.receive(topic: ${message.meta.topic})`);
                 }
                 await timer(10000);
             }

package/libs/dip.ts

@@ -90,10 +90,10 @@ export const IdempotentDip = (): IdempotentDip => {
     return idip
 }
 
-type DipMessage = { meta: {staff: string; user: string}; txn: string; date: number }
+type DipMessage = { meta: {staff: string; user: string; date: number } }
 type IdipCleanup = Record<string, string[]> | ((idip: IdempotentDip) => Promise<void>)
 
-export const idip = async (message: {meta: Elabase.DipMeta, txn: string}, callback: (idip: IdempotentDip) => Promise<void>, cleanup: IdipCleanup) => {
+export const idip = async (meta: Elabase.DipMeta, txn: string, callback: (idip: IdempotentDip) => Promise<void>, cleanup: IdipCleanup) => {
     if (!callback)
         throw new Error("Dip.idip() callback argument undefined")
     if (!cleanup)
@@ -106,9 +106,9 @@ export const idip = async (message: {meta: Elabase.DipMeta, txn: string}, callba
             await cleanup(IDip)
     }
 
-    let IDip = await IdempotentDip().new(message.meta, message.txn)
+    let IDip = await IdempotentDip().new(meta, txn)
     if (!IDip) {
-        IDip = await IdempotentDip().new(message.meta, message.txn, {blank: true})
+        IDip = await IdempotentDip().new(meta, txn, {blank: true})
         await doCleanup(IDip as IdempotentDip)
         return
     }
@@ -121,7 +121,7 @@ export const idip = async (message: {meta: Elabase.DipMeta, txn: string}, callba
 export const insertKeys = (message: DipMessage, meta: Elabase.DipMeta) => {
     if (!isDipMeta(meta)) throw new Error('Error: Provided meta is not an instance of DipMeta in Dip.insertKeys()')
     return {
-        "created": message.date, "updated": message.date,
+        "created": message.meta.date, "updated": message.meta.date,
         "createdBy": message.meta.staff,
         "updatedBy": message.meta.staff,
         "createdByUser": message.meta.user,
@@ -132,7 +132,7 @@ export const insertKeys = (message: DipMessage, meta: Elabase.DipMeta) => {
 }
 export const updateKeys = (message: DipMessage) => {
     return {
-        "updated": message.date,
+        "updated": message.meta.date,
         "updatedBy": message.meta.staff,
         "updatedByUser": message.meta.user,
     }

package/libs/features.ts

@@ -25,21 +25,16 @@ type FeatureMeta = {
     version: string,
     txn: string,
     // invoiceTxn?: string // TODO: Must also include invoiceTxn
+    topic: string,
+    date: number,
 }
 export type FeatureParams = Record<string, string>
-type FeatureMessage = {
+type FeatureMessage<I = unknown> = {
     meta: FeatureMeta
-    data: unknown
+    data: I
     params: FeatureParams
-    // To be removed 1
-    date: number // used as message.date
-    // To be removed 2
-    topic: string // used as req.body.topic
-    feature: string // used as req.body.feature or message.feature
-    user: string    // used as req.body.user or message.user
-    txn: string     // used as message.txn
-
 
+    // feature // Only used as req.body.feature in features.ts, session.ts
     // client  // Only used as req.body.client in auth.ts, session.ts and messaging.ts
     // version // Only used as req.body.version in auth.ts and session.ts
     // outlet, company // Only used as req.body.outlet, req.body.company in session.ts
@@ -90,9 +85,19 @@ type ExpressApplication = { [Method in HttpMethod]: (path: string, handler: Expr
 
 // export type Req = unknown
 // export type Res = unknown
-export type Query = (req: Req, res: Res) => Promise<void>
-export type Command = (topic: string, message: FeatureMessage, req?: Req, res?: Res) => Promise<void>
-type Handler = Query | Command
+// export type Query = (req: Req, res: Res) => Promise<void>
+// export type Command = (message: FeatureMessage, req?: Req, res?: Res) => Promise<void>
+// type Handler = Query | Command
+
+declare global {
+    type Handler<I, O> = (input: FeatureMessage<I>, req?: Req, res?: Res) => Promise<O>
+
+    interface FeatureTypes {
+        //     "privileges.query.check": Handler<{feature: string}, {data: {granted: boolean} }>
+        //     "products.query.get": typeof import("./src/products/query.ts").get;
+        //     "products.brands.query.get": typeof import("./src/products/brands/query.ts").get;
+    }
+}
 
 
 type RemoteFeatureEntry = {
@@ -103,7 +108,7 @@ type RemoteFeatureEntry = {
     headers?: {JWT?: string, service?: boolean, NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN?: string}
 }
 
-type FeatureEntry = { api: string, topic: string, bypass: boolean, featureless: boolean, subscribe: string, handler: Handler }
+type FeatureEntry = { api: string, topic: string, bypass: boolean, featureless: boolean, subscribe: string, handler: Handler<unknown, unknown> }
 
 
 let features: Record<string, FeatureEntry> = {}
@@ -151,15 +156,7 @@ export const get = (feature: string) => {
     return {api, service, topic}
 }
 
-declare global {
-    type Handler<I, O> = (input: I) => Promise<O>
 
-    interface FeatureTypes {
-    //     "privileges.query.check": Handler<{feature: string}, {data: {granted: boolean} }>
-    //     "products.query.get": typeof import("./src/products/query.ts").get;
-    //     "products.brands.query.get": typeof import("./src/products/brands/query.ts").get;
-    }
-}
 
 export const send = async <K extends keyof FeatureTypes> (meta: Partial<FeatureMeta>, feature: K, data?: Parameters<FeatureTypes[K]>[0], params?: FeatureParams): Promise<Awaited<ReturnType<FeatureTypes[K]>>> => {
     const throwError = () => {throw new Error(`Feature ${feature} not found in internal or external list during inter feature call`)}
@@ -199,16 +196,17 @@ export const send = async <K extends keyof FeatureTypes> (meta: Partial<FeatureM
             writableEnded: false,
         }
         await apiHandler(req, res);
-        return response as Awaited<ReturnType<FeatureTypes[K]>> // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.
+        return (response as unknown as {data: unknown}).data as Awaited<ReturnType<FeatureTypes[K]>> // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.
     }
     // Workaround: https://stackoverflow.com/questions/72343387/axios-not-sending-headers-request-failing-getting-401-error
-    return (await axios({
+    const response = (await axios({
         method,
         url: `${service}${url}`,
         headers: { jwt: SERVICE_ACCESS_TOKEN, service: true, NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN },
         data: payload,
         timeout: 30000 // 30 secs
-      })).data as Awaited<ReturnType<FeatureTypes[K]>> // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.;
+      })).data;
+    return (response as {data: unknown}).data as Awaited<ReturnType<FeatureTypes[K]>> // tsc already checked that the feature returned proper types at the handler site. Cast here due to ts limitations. So no guarantees lost.;
 }
 
 let appids: Record<string, boolean> = {}
@@ -261,13 +259,12 @@ const apiHandler = async (req: ExpressRequest, res: ExpressResponse) => {
 
         feature = feature! // typescript validation with !
 
-        let topic = feature.topic
         let params = getFeatureUrl(feature.api).split("/").filter((item: string) => item.startsWith(":")).map((item: string) => item.replace(":", ""))
         for (let param of params)
             if (!req.params[param])
                 throw { status: 404, message: "Resource not found. One or more url parameter not specified." }
 
-        let meta = {...req.body, data: undefined} as FeatureMeta // TODO: Must also include invoiceTxn
+        let meta = {...req.body, data: undefined, topic: feature.topic, date: new Date().getTime()} as FeatureMeta // TODO: Must also include invoiceTxn
 
         if (process.env.USE_DEFAULT_COMPANY) {
             meta.company = 'DEFAULT_COMPANY'
@@ -280,15 +277,6 @@ const apiHandler = async (req: ExpressRequest, res: ExpressResponse) => {
             meta,
             data: req.body.data,
             params: req.params,
-
-            // To be removed 1
-            date: new Date().getTime(),
-
-            // To be removed 2
-            topic,
-            feature: req.body.feature,
-            user: req.body.user,
-            txn: meta.txn,
         }
 
         const appReq: Req = {
@@ -306,29 +294,31 @@ const apiHandler = async (req: ExpressRequest, res: ExpressResponse) => {
 
         if (method === "get") {
             try {
-                // await feature.handler({...req, headers: req.headers, body: {...req.body, topic} }, res)
-                // req.body = {...req.body, topic}
-                await (feature.handler as Query)(appReq, appRes)
+                const data = await feature.handler(message, appReq, appRes)
+                if (!appRes.headersSent)
+                    res.json({ data })
             } catch (err: any) {
                 if (process.env.DEBUG_MODE)
-                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err)
+                    console.error('Error: Feature: ', message.meta.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err)
                 throw {status: 500, message: "Failed to GET feature", ...err}
             }
         } else if (method !== "get" && feature.bypass) {
             try {
-                await (feature.handler as Command)(topic, message, appReq, appRes)
+                const data = await feature.handler(message, appReq, appRes)
+                if (!appRes.headersSent)
+                    res.json({ data, event: message.meta.feature, txn: message.meta.txn, bypass: true })
             } catch (err: any) {
                 if (process.env.DEBUG_MODE)
-                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err)
+                    console.error('Error: Feature: ', message.meta.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err)
                 throw {status: 500, message: "Failed to POST feature", ...err}
             }
         } else {
             try {
-                await Kafka.send(`Features.${topic}`, message, message.user, { compression: Kafka.CompressionTypes.GZIP })
+                await Kafka.send(`Features.${message.meta.topic}`, message, message.meta.user, { compression: Kafka.CompressionTypes.GZIP })
             } catch {
                 throw {status: 500, message: "Failed to queue the transaction"}
             }
-            appRes.json({ data: { txn: message.txn, success: true, status: "Queued", featureQueued: true } })
+            appRes.json({ data: { txn: message.meta.txn, success: true, status: "Queued", featureQueued: true } })
         }
     } catch (err: any) {
         if (process.env.DEBUG_MODE)
@@ -365,9 +355,9 @@ async function registerHandler(features: Record<string, FeatureEntry>) {
             continue
 
         if (featureName.startsWith("flows.") && !featureName.startsWith("flows.query.") && !featureName.startsWith("flows.command.") && !featureName.startsWith("flows.designs."))
-            feature.handler = (await import(`${new URL(`src/flows/query.js`, PROJECT_ROOT_URL).toString().replace('file://', '')}`)).FEATURE_HANDLERS[handler]
+            feature.handler = (await import(`${new URL(`src/flows/query.ts`, PROJECT_ROOT_URL).toString().replace('file://', '')}`)).FEATURE_HANDLERS[handler]
         else
-            feature.handler = (await import(`${new URL(`${featurePath}.js`, PROJECT_ROOT_URL).toString().replace('file://', '')}`))[handler]
+            feature.handler = (await import(`${new URL(`${featurePath}.ts`, PROJECT_ROOT_URL).toString().replace('file://', '')}`))[handler]
     }
 }
 function registerApi() {
@@ -419,31 +409,31 @@ export const start = async (app: ExpressApplication, url: URL, file: string) =>
     for (let topic of kafkaTopics) {
         const groupId = ''
         Kafka.receive<FeatureMessage>(`Features.${topic}`, groupId, async (topic: string, message: FeatureMessage) => {
+            topic = topic.replace(/^.*Features./,'')
             if (Utils.isEmpty(message.meta?.company))
                 message.meta = { ...message.meta, company: "GLOBAL", outlet: "GLOBAL" }
-            if (!message?.feature)
+            if (!message.meta.feature)
                 return
 
             const timer = (ms: number) => new Promise(res => setTimeout(res, ms)) // A promise that resolves after "ms" Milliseconds
-            topic = topic.replace(/^.*Features./,'')
             while (true) {
                 try {
-                    // const iso_date = new Date(message.date).toISOString()
+                    // const iso_date = new Date(message.meta.date).toISOString()
                     // // TODO: use $useChunks: [] once support is added in dip insert
-                    // await Dip.insert(globalMeta, `users.txns`, { _id: `${message.user}_${iso_date}_${message.txn}`, user: message.user, feature: message.feature, date: message.date, created: message.date, updated: message.date, status: "Queued" }, {idempotent: true}) // Can always update the status later
+                    // await Dip.insert(globalMeta, `users.txns`, { _id: `${message.meta.user}_${iso_date}_${message.meta.txn}`, user: message.meta.user, feature: message.meta.feature, date: message.meta.date, created: message.meta.date, updated: message.meta.date, status: "Queued" }, {idempotent: true}) // Can always update the status later
                     // TODO: Avoid duplicate processing
-                    const feature = features[message.feature]
+                    const feature = features[message.meta.feature]
                     if (!feature) {
-                        console.warn(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`)
-                        throw new Error(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`)
+                        console.warn(`Feature ${message.meta.feature} missing, in executing handler during Kafka.receive(topic: ${message.meta.topic})`)
+                        throw new Error(`Feature ${message.meta.feature} missing, in executing handler during Kafka.receive(topic: ${message.meta.topic})`)
                     }
-                    await (feature.handler as Command)(topic, message)
-                    await Dip.insert(globalMeta, "Features.txns", {_id: message.txn, status: "Processed"}, {idempotent: true})
+                    await feature.handler(message)
+                    await Dip.insert(globalMeta, "Features.txns", {_id: message.meta.txn, status: "Processed"}, {idempotent: true})
                     break
                 } catch(err) {
                     if (process.env.DEBUG_MODE)
-                        console.log('Error: Feature: ', message.feature, err)
-                    console.warn(`Feature: ${message.feature}, error in executing handler during Kafka.receive(topic: ${topic})`)
+                        console.log('Error: Feature: ', message.meta.feature, err)
+                    console.warn(`Feature: ${message.meta.feature}, error in executing handler during Kafka.receive(topic: ${message.meta.topic})`)
                 }
                 await timer(10000);
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "corebasic",
   "type": "module",
-  "version": "1.0.240",
+  "version": "1.0.242",
   "description": "",
   "main": "dist/index.js",
   "types": "./index.ts",