@aravinthan_p/appnest-sdk-core 1.0.0

package/appnestBackendLayer/backendLayer.js

@@ -0,0 +1,27 @@
+const { patchLogging } = require('./loggerInterceptor');
+const { requestHandler } = require('./requestWrapper');
+
+console.log("[backendLayer.js] Module loaded");
+
+
+const handleServerStart = () => {
+    patchLogging(); // ✅ Patch once per cold start
+}
+
+const handleServerRequest = async ({ requestEvent, requestContext, appBackendServerFile, appBackendServerFolder }) => {
+  console.log('🚀 ~ handleServerRequest ~ requestEvent:', requestEvent);
+  console.log('🚀 ~ handleServerRequest ~ requestContext:', requestContext);
+    try {
+      return await requestHandler({ requestEvent, requestContext, appBackendServerFile, appBackendServerFolder });
+    } catch (error) {
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: 'Internal server error occurred', errorMessage: error.message, errorStack: error.stack }),
+      };
+    }
+}
+
+module.exports = {
+    handleServerStart,
+    handleServerRequest
+};

package/appnestBackendLayer/loggerInterceptor.js

@@ -0,0 +1,62 @@
+// loggerInterceptor.js
+const { getRequestContext } = require('./requestContext');
+
+console.log("[loggerInterceptor.js] Module loaded");
+
+let isPatched = false;
+
+const patchLogging = () => {
+  if (isPatched) return; // avoid re-patching during warm starts
+  console.log('Patching the log started');
+  isPatched = true;
+
+  const buildMdcPrefix = () => {
+    const { mdc } = getRequestContext() || {};
+    if (!mdc || typeof mdc !== 'object') return '';
+    const parts = Object.entries(mdc)
+      .map(([key, value]) => `${key}:${value ?? '-'}`)
+      .join(' ');
+    return parts ? `[${parts}]` : '';
+  };
+  const buildPrefix = (level) => {
+    const ts = new Date().toISOString();
+    const levelTag = `[${level.toUpperCase()}]`;
+    const mdcTag = buildMdcPrefix();
+    return `[${ts}] ${levelTag} | MDC: ${mdcTag} | `.trim();
+  };
+
+  // ---- Patch console methods ----
+  const levelMap = {
+    log: 'info',
+    info: 'info',
+    warn: 'warn',
+    error: 'error',
+    debug: 'debug',
+  };
+  Object.entries(levelMap).forEach(([method, level]) => {
+    const original = console[method];
+    console[method] = (...args) => {
+      const prefix = buildPrefix(level);
+      original(prefix, ...args);
+    };
+  });
+
+  // --- Patch stdout/stderr for third-party logs ---
+  const wrapStream = (stream, level) => {
+    const originalWrite = stream.write.bind(stream);
+    stream.write = (chunk, encoding, cb) => {
+      const prefix = buildPrefix(level);
+      const text = chunk.toString();
+      const formatted = text.startsWith('[')
+        ? text
+        : `${prefix} ${text}`;
+      return originalWrite(formatted, encoding, cb);
+    };
+  };
+
+  wrapStream(process.stdout, 'info');
+  wrapStream(process.stderr, 'error');
+  console.log('Patching the log completed');
+}
+
+module.exports = { patchLogging }

package/appnestBackendLayer/requestContext.js

@@ -0,0 +1,18 @@
+// context.js
+const { AsyncLocalStorage } = require('node:async_hooks');
+
+const asyncContext = new AsyncLocalStorage();
+
+const withRequestContext = ( context, handler) => {
+  return asyncContext.run(context, handler);
+}
+
+const getRequestContext = () => {
+  const requestContext = asyncContext.getStore();
+  return requestContext || {};
+}
+
+module.exports = {
+  withRequestContext,
+  getRequestContext
+}

package/appnestBackendLayer/requestWrapper.js

@@ -0,0 +1,149 @@
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+const { withRequestContext } = require('./requestContext');
+const { ResultData } = require('../appnestUtils/ResultData');
+
+const getRequestBody = ({ requestEvent }) => {
+  let requestBody = null;
+  if (requestEvent.body) {
+    console.log('🚀 ~ getRequestBody ~ requestEvent.body:', requestEvent.body);
+    requestBody = JSON.parse(requestEvent.body);
+  } else {
+    console.log('🚀 ~ getRequestBody ~ requestEvent:', requestEvent);
+    requestBody = requestEvent;
+  }
+  console.log(JSON.stringify(requestBody, null, 2));
+  if (!requestBody) {
+    throw new Error('Request body is missing');
+  }
+  if (!requestBody.appConfig || !requestBody.appConfig.extraPayload) {
+    throw new Error('Invalid request body: Missing appConfig.extraPayload');
+  }
+  console.log('requestBody.appConfig:', JSON.stringify(requestBody.appConfig, null, 2));
+  const parentLayerConfigObject =
+    requestBody?.appConfig?.extraPayload?.parentLayerConfigObject;
+  const eventName = parentLayerConfigObject.event;
+  if (!eventName) {
+    throw new Error('Invalid request body: Missing event name');
+  }
+  return requestBody;
+};
+
+const getRequestContextData = ({ requestBody, requestContext }) => {
+  try {
+    const parentLayerConfigObject =
+      requestBody?.appConfig?.extraPayload?.parentLayerConfigObject;
+
+    let traceId = requestBody?.traceId;
+    if (!traceId) {
+      console.error('No traceId found in request body. Generating a new one.');
+      traceId = `NoOriginTrace-${uuidv4()}`;
+    }
+
+    const appFunctionName = parentLayerConfigObject.event;
+    const executionId = uuidv4();
+    const mdc = {
+      traceId,
+      appFunctionName,
+      executionId,
+    };
+
+    const contextData = {
+      traceId,
+      appFunctionName,
+      parentLayerConfigObject,
+      requestContext,
+      mdc,
+    };
+    console.log('Extracted Context Data:', contextData);
+    return contextData;
+  } catch (error) {
+    console.error('Error extracting request context data:', error);
+    throw error;
+  }
+};
+
+const handleAppFunctionResponse = ({ appFunctionResponse }) => {
+  if (appFunctionResponse.customAppnestClassFlag) {
+    if (appFunctionResponse instanceof ResultData) {
+      return {
+        statusCode: appFunctionResponse.statusCode,
+        body: appFunctionResponse.body
+      };
+    }
+  } else {
+    return {
+      statusCode: 200,
+      body: appFunctionResponse
+    };
+  }
+}
+
+const executeAppFunction = async ({ requestBody, appBackendServerFile, appBackendServerFolder }) => {
+  console.log('🚀 ~ Current working directory:', process.cwd());
+  const serverfolderPath = appBackendServerFolder ? appBackendServerFolder : process.cwd();
+  console.log('🚀 ~ serverfolderPath:', serverfolderPath);
+  const serverPath = path.join(serverfolderPath, appBackendServerFile);
+  console.log('🚀 ~ serverPath:', serverPath);
+  const appServer = require(serverPath);
+  console.log('Loaded appServer from path :', serverPath);
+  const eventName =
+    requestBody.appConfig.extraPayload.parentLayerConfigObject.event;
+  if (typeof appServer[eventName] === 'function') {
+    try {
+      const appFunctionResponseData = await appServer[eventName]({
+        payload: requestBody.payload,
+      });
+      return appFunctionResponseData;
+    } catch (error) {
+      console.error(`Error executing app function - ${eventName}:`, error);
+      console.error(error.message);
+      console.error(error.stack);
+      return new ResultData({
+        body: { error: 'Internal server error occurred', errorMessage: error.message, errorStack: error.stack },
+        statusCode: 500,
+      });
+    }
+  } else {
+    console.error(
+      'Invalid event or handler not found:',
+      eventName
+    );
+    return new ResultData({
+      body: { error: 'Invalid event or handler not found' },
+      statusCode: 500,
+    });
+  }
+};
+
+const requestHandler = async ({ requestEvent, requestContext, appBackendServerFile, appBackendServerFolder }) => {
+  console.log('Request Event:', requestEvent);
+  console.log('RequestContext:', requestContext);
+  const requestBody = getRequestBody({ requestEvent });
+  const contextData = getRequestContextData({ requestBody, requestContext });
+  const ctx = {
+    ...contextData,
+  };
+  console.log('Final Request Context (ctx):', ctx);
+  console.log(JSON.stringify(ctx));
+  return withRequestContext(ctx, async () => {
+    try {
+      const response = await executeAppFunction({
+        requestBody,
+        appBackendServerFile,
+        appBackendServerFolder
+      });
+      return handleAppFunctionResponse({ appFunctionResponse: response });
+    } catch (error) {
+      console.error('Error executing app function:', error);
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: 'Internal server error occurred', errorMessage: error.message, errorStack: error.stack }),
+      };
+    }
+  });
+};
+
+module.exports = {
+  requestHandler,
+};

package/appnestUtils/ResultData.js

@@ -0,0 +1,3 @@
+const { ResultData } = require('appnest-sdk-common');
+
+module.exports = { ResultData }

package/index.js

@@ -0,0 +1,6 @@
+const appnestBackendLayer = require('./appnestBackendLayer/backendLayer');
+console.log('We are zipped the appnest-sdk-v2 on 2026-02-15_08-22-25_PM - Local layer');
+
+module.exports = {
+  appnestBackendLayer
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@aravinthan_p/appnest-sdk-core",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "uuid": "^9.0.0",
+    "appnest-sdk-common": "file:/Users/aravinthanp/Desktop/Appnest/Coding Worspace/sparrow-sdk/SDK-V2-CodeBase/sdk-layer/appnest-sdk-common"
+  }
+}