@aravinthan_p/appnest-app-sdk-utils 0.0.1

package/appnestFunctions/scheduleFunction/schedule.js

@@ -0,0 +1,212 @@
+const { getParentLayerConfigObject, getTraceId } = require('../utils/contextWrapper');
+const { makeSparrowAppAPICall } = require('../utils/axiosWrapper');
+const { SCHEDULE_API } = require('../utils/apiConstants');
+
+const { cronValidate } = require('cron-validate');
+
+const validateScheduleTypeConfiguration = ({ type, cronExpression, repeat, runAt }) => {
+    validateScheduleType(type);
+    if (type === "ONE_TIME") {
+        if (!runAt) throw new Error("runAt is required for type ONE_TIME");
+        if (cronExpression) throw new Error("cronExpression is not allowed for type ONE_TIME");
+        if (repeat) throw new Error("repeat is not allowed for type ONE_TIME");
+        validateRunAt(runAt);
+    }
+    if (type === "CRON") {
+        if (!cronExpression) throw new Error("cronExpression is required for type CRON");
+        if (repeat) throw new Error("repeat is not allowed for type CRON");
+        if (runAt) throw new Error("runAt is not allowed for type CRON");
+        validCronExpression(cronExpression);
+    }
+    if (type === "RECURRING") {
+        if (!repeat) throw new Error("repeat is required for type RECURRING");
+        if (cronExpression) throw new Error("cronExpression is not allowed for type RECURRING");
+        if (runAt) throw new Error("runAt is not allowed for type RECURRING");
+        validateRepeat(repeat);
+        paramsData.repeat = transformRepeatConfig(repeat);
+    }
+    return true;
+}
+
+const validateRepeat = (repeat) => {
+    const { frequency, timeUnit } = repeat;
+    if (!frequency) throw new Error("repeat.frequency is required");
+    if (typeof frequency !== "number") throw new Error("repeat.frequency must be a number");
+    if (!Number.isInteger(frequency)) throw new Error("repeat.frequency must be an integer");
+    if (frequency <= 0) throw new Error("repeat.frequency must be greater than or equal to 1");
+
+    if (!timeUnit) throw new Error("repeat.timeUnit is required");
+    if (typeof timeUnit !== "string" || !["MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS"].includes(timeUnit)) {
+        throw new Error("repeat.timeUnit must be either MINUTES or HOURS or DAYS or WEEKS or MONTHS or YEARS");
+    }
+    if (timeUnit === "MINUTES" && frequency < 10) throw new Error("repeat.frequency must be greater than or equal to 10 for timeUnit MINUTES");
+    if (timeUnit === "HOURS" && frequency < 1) throw new Error("repeat.frequency must be greater than or equal to 1 for timeUnit HOURS");
+    if (timeUnit === "DAYS" && frequency < 1) throw new Error("repeat.frequency must be greater than or equal to 1 for timeUnit DAYS");
+    if (timeUnit === "WEEKS" && frequency < 1) throw new Error("repeat.frequency must be greater than or equal to 1 for timeUnit WEEKS");
+    if (timeUnit === "MONTHS" && frequency < 1) throw new Error("repeat.frequency must be greater than or equal to 1 for timeUnit MONTHS");
+    if (timeUnit === "YEARS" && frequency < 1) throw new Error("repeat.frequency must be greater than or equal to 1 for timeUnit YEARS");
+}
+
+const transformRepeatConfig = (repeat) => {
+    const { frequency, timeUnit } = repeat;
+    return {
+        every: frequency,
+        unit: timeUnit
+    }
+}
+
+const validateScheduleName = (name) => {
+    if (!name || typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("name is required");
+    }
+    if (name.length > 30) throw new Error("name must be at most 30 characters");
+}
+
+const validateScheduleType = (type) => {
+    if (typeof type !== "string" || !["ONE_TIME", "RECURRING", "CRON"].includes(type)) {
+        throw new Error("type must be either ONE_TIME or RECURRING or CRON");
+    }
+}
+
+const validateScheduleData = (data) => {
+    if (!data) throw new Error("data is required");
+    if (typeof data !== "object") throw new Error("data must be an object");
+    if (Object.keys(data).length === 0) throw new Error("data must be an object with at least one key");
+}
+
+const validCronExpression = (expr) => {
+    const result = cronValidate(expr);
+    const isValid = result.isValid();
+    if (!isValid) throw new Error("cronExpression is not valid");
+};
+
+const validateRunAt = (runAt) => {
+    if (!runAt) throw new Error("runAt is required");
+    if (typeof runAt !== "string" || runAt.trim().length === 0) throw new Error("runAt must be a non-empty string");
+    const date = new Date(runAt);
+    if (isNaN(date.getTime())) throw new Error("runAt must be a valid date of format YYYY-MM-DD HH:MM:SS ISO 8601");
+}
+
+const create = async ({ data, name, runAt, cronExpression, repeat, type }) => {
+    try {
+        validateScheduleName(name);
+        validateScheduleTypeConfiguration({ type, cronExpression, repeat, runAt });
+        validateScheduleData(data);
+        const scheduleRequest = { method: "POST", data, runAt, name, type, cronExpression, repeat };
+        console.log("$Schedule - create - storagePayload:", JSON.stringify(scheduleRequest));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.CREATE.method, apiUrl: SCHEDULE_API.CREATE.endpoint, schedulePayload: scheduleRequest });
+    } catch (error) {
+        console.error("$Schedule - create - error:", error);
+        throw error;
+    }
+};
+
+const get = async ({ name, type }) => {
+    try {
+        validateScheduleName(name);
+        validateScheduleType(type);
+        const schedulePayload = { method: "GET", name, type };
+        console.log("$Schedule - get - storagePayload:", JSON.stringify(schedulePayload));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.GET.method, apiUrl: SCHEDULE_API.GET.endpoint, schedulePayload });
+    } catch (error) {
+        console.error("$Schedule - get - error:", error);
+        throw error;
+    }
+
+}
+
+const update = async ({ data, name, runAt, cronExpression, repeat, type }) => {
+    try {
+        validateScheduleName(name);
+        validateScheduleTypeConfiguration({ type, cronExpression, repeat, runAt });
+        validateScheduleData(data);
+        const request = { method: "PUT", data, runAt, name, type, cronExpression, repeat }
+        console.log("$Schedule - update - storagePayload:", JSON.stringify(request));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.UPDATE.method, apiUrl: SCHEDULE_API.UPDATE.endpoint, schedulePayload: request });
+    } catch (error) {
+        console.error("$Schedule - update - error:", error);
+        throw error;
+    }
+
+}
+
+const pause = async ({ name, type }) => {
+    try {
+        validateScheduleType(type);
+        validateScheduleName(name);
+        const request = { method: "PAUSE", name, type }
+        console.log("$Schedule - pause - storagePayload:", JSON.stringify(request));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.PAUSE.method, apiUrl: SCHEDULE_API.PAUSE.endpoint, schedulePayload: request });
+    } catch (error) {
+        console.error("$Schedule - pause - error:", error);
+        throw error;
+    }
+}
+
+
+const resume = async ({ name, type }) => {
+    try {
+        validateScheduleType(type);
+        validateScheduleName(name);
+        const request = { method: "RESUME", name, type }
+        console.log("$Schedule - resume - storagePayload:", JSON.stringify(request));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.RESUME.method, apiUrl: SCHEDULE_API.RESUME.endpoint, schedulePayload: request });
+    } catch (error) {
+        console.error("$Schedule - resume - error:", error);
+        throw error;
+    }
+}
+
+const deleteOperation = async ({ name, type }) => {
+    try {
+        validateScheduleName(name);
+        const schedulePayload = { method: "DELETE", name, type };
+        console.log("$Schedule - deleteOperation - storagePayload:", JSON.stringify(schedulePayload));
+        return await scheduleAPIWrapper({ apiMethod: SCHEDULE_API.DELETE.method, apiUrl: SCHEDULE_API.DELETE.endpoint, schedulePayload });
+    } catch (error) {
+        console.error("$Schedule - deleteOperation - error:", error);
+        throw error;
+    }
+
+}
+
+
+const scheduleAPIWrapper = async ({ apiMethod, apiUrl, schedulePayload }) => {
+    try {
+        const parentLayerConfigObject = getParentLayerConfigObject();
+        const requestBody = {
+            accountId: parentLayerConfigObject.accountId,
+            productId: parentLayerConfigObject.productId,
+            appId: parentLayerConfigObject.appId,
+            appVersionId: parentLayerConfigObject.userInstalledId,
+            userInstalledId: parentLayerConfigObject.userInstalledId,
+            ...schedulePayload
+        };
+        console.log("$Schedule - scheduleAPIWrapper - requestBody:", JSON.stringify(requestBody));
+        const response = await makeSparrowAppAPICall({
+            method: apiMethod,
+            endpoint: apiUrl,
+            requestBody
+        });
+        console.log("$Schedule - scheduleAPIWrapper - response:", JSON.stringify(response));
+        return { data: response?.data, status: response?.status };
+    } catch (error) {
+        console.error("$Schedule - scheduleAPIWrapper - error:", JSON.stringify(error));
+        throw error;
+    }
+};
+
+
+
+const $schedule = {
+    create,
+    delete: deleteOperation,
+    get,
+    update,
+    pause,
+    resume
+};
+
+module.exports = {
+    $schedule
+};

package/appnestFunctions/utils/apiConstants.js

@@ -0,0 +1,75 @@
+const FILE_STORAGE_API = {
+    GET_SIGNED_URL: {
+        endpoint: '/get-signed-url',
+        method: 'POST',
+    },
+    OBJECT_EXISTS: {
+        endpoint: '/object-exists',
+        method: 'POST',
+    },
+    GET_OBJECTS: {
+        endpoint: '/get-objects',
+        method: 'POST',
+    },
+    DELETE_OBJECT: {
+        endpoint: '/delete-object',
+        method: 'POST',
+    },
+}
+
+
+const SCHEDULE_API = {
+    CREATE: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'POST',
+    },
+    GET: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'GET',
+    },
+    UPDATE: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'POST',
+    },
+    PAUSE: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'POST',
+    },
+    RESUME: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'POST',
+    },
+    DELETE: {
+        endpoint: '/api/sparrow-apps/schedule',
+        method: 'POST',
+    },
+}
+
+const DB_API = {
+    COMMON: {
+        endpoint: '/api/sparrow-apps/db',
+        method: 'POST',
+    }
+}
+
+const HTTP_API = {
+    COMMON: {
+        endpoint: '/v2/api/sparrow-apps/request',
+        method: 'POST',
+    }
+}
+
+const NEXT_API = {
+    COMMON: {
+        endpoint: '/api/sparrow-apps/next',
+        method: 'POST',
+    }
+}
+
+module.exports = {
+    FILE_STORAGE_API,
+    SCHEDULE_API,
+    DB_API,
+    HTTP_API,
+    NEXT_API
+}

package/appnestFunctions/utils/axiosWrapper.js

@@ -0,0 +1,80 @@
+const axios = require('axios');
+const { getParentLayerConfigObject, getTraceId } = require('./contextWrapper');
+
+const C = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+};
+
+const makeSparrowAppAPICall = async ({
+  method,
+  endpoint,
+  requestBody,
+  headers = {},
+  params = {},
+}) => {
+  const parentLayerConfigObject = getParentLayerConfigObject();
+  const baseURL = parentLayerConfigObject.sparrowAppsDomain;
+  const token = parentLayerConfigObject.authToken;
+  if (!token) {
+    throw new Error('Auth token not found in request context.');
+  }
+  if (!baseURL) {
+    throw new Error('Sparrow App API base URL is not configured.');
+  }
+  const traceId = getTraceId();
+  if (traceId) {
+    headers['traceId'] = traceId;
+  }
+  try {
+    console.log(`${C.cyan}━━━ $AxiosWrapper │ makeSparrowAppAPICall ━━━${C.reset}`);
+    console.log(`${C.dim}📤 Request${C.reset}  ${C.cyan}method${C.reset}:`, method, ` ${C.cyan}endpoint${C.reset}:`, endpoint);
+    console.log(`${C.dim}🔗 baseURL${C.reset}:`, baseURL);
+    console.log(`${C.dim}📋 requestBody${C.reset}:`, JSON.stringify(requestBody));
+    console.log(`${C.dim}📋 headers${C.reset}:`, JSON.stringify(headers));
+    console.log(`${C.dim}📋 params${C.reset}:`, JSON.stringify(params));
+
+    const response = await axios({
+      method,
+      url: `${baseURL}${endpoint}`,
+      headers: {
+        'Content-Type': 'application/json',
+        auth: parentLayerConfigObject.authToken,
+        ...headers,
+      },
+      params: params,
+      data: requestBody,
+    });
+
+    console.log(`${C.green}━━━ $AxiosWrapper │ ✅ Response ${response.status} ${response.statusText} ━━━${C.reset}`);
+    console.log(`${C.dim}$AxiosWrapper │ 📥 status${C.reset}:`, response.status, response.statusText);
+    console.log(`${C.dim}$AxiosWrapper │ 📥 data${C.reset}:`, JSON.stringify(response.data));
+    console.log(`${C.dim}$AxiosWrapper │ 📥 headers${C.reset}:`, JSON.stringify(response.headers));
+    return response;
+  } catch (error) {
+    const res = error.response;
+    console.error(`${C.red}━━━ $AxiosWrapper │ ❌ Error makeSparrowAppAPICall ━━━${C.reset}`);
+    console.error(`${C.red} $AxiosWrapper │ 💬 error message${C.reset}:`, error.message);
+    console.error(`${C.dim}$AxiosWrapper │ 📍 stack${C.reset}:`, error.stack);
+    if (error.config) {
+      console.error(`${C.dim}$AxiosWrapper │ ⚙️ error config${C.reset}:`, error.config);
+    }
+    if (error.request) {
+      console.error(`${C.dim}$AxiosWrapper │ 📤 request${C.reset}:`, error.request);
+    }
+    if (res) {
+      console.error(`${C.yellow}$AxiosWrapper │ 📥 entire error response ${C.reset}:`, res);
+      console.error(`${C.yellow}$AxiosWrapper │ 📥 error response${C.reset} ${res.status} ${res.statusText}:`, res.data);
+      console.error(`${C.dim}$AxiosWrapper │   error headers${C.reset}:`, res.headers);
+    }
+    throw error;
+  }
+};
+
+module.exports = {
+  makeSparrowAppAPICall,
+};

package/appnestFunctions/utils/contextWrapper.js

@@ -0,0 +1,12 @@
+const {
+  getParentLayerConfigObject,
+  getTraceId,
+  getServerContext
+} = require('@aravinthan_p/appnest-app-sdk-common');
+
+
+module.exports = {
+  getParentLayerConfigObject,
+  getTraceId,
+  getServerContext
+};

package/appnestUtils/ResultData.js

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

package/index.js

@@ -0,0 +1,7 @@
+const AppnestFunctions = require('./appnestFunctions/index');
+const ResultData = require('./appnestUtils/ResultData');
+
+module.exports = {
+  AppnestFunctions,
+  ResultData
+};

package/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "@aravinthan_p/appnest-app-sdk-utils",
+    "version": "0.0.1",
+    "main": "index.js",
+    "dependencies": {
+        "axios": "^1.2.1",
+        "cron-validate": "^1.5.3",
+        "@aravinthan_p/appnest-app-sdk-common": "^0.0.1"
+    }
+}