psdev-task-manager 1.4.6 → 1.7.1

package/.github/workflows/update-sites.yml

@@ -1,21 +1,30 @@
 name: Update Sites After Release Main
 
 on:
+  push:
+    branches:
+      - main
   workflow_dispatch:
-        
+      
 permissions:
-  contents: write
-  packages: write
-  
+ contents: write
+ packages: write
+
 jobs:
   update-sites:
-    uses: psdevteamenterprise/ci-workflows/.github/workflows/publish-and-notify.yml@main
+    uses: psdevteamenterprise/ci-workflows/.github/workflows/update-and-notify.yml@main
     with:
-      sites_to_update: "['psdevteamenterprise/tests-site']"
-
+      npm_packages_to_update: "[{repo: 'Hisense-Wix/velo-npm'}]"
+      sites_to_update: "[{repo: 'psdevteamenterprise/external-template', secret: 'WIX_SR_API_KEY'},
+                          {repo: 'psdevteamenterprise/internal', secret: 'WIX_SR_API_KEY'},
+                          {repo: 'psdevteamenterprise/tests-site', secret: 'WIX_PS_API_KEY'},
+                          {repo: 'psdevteamenterprise/hisense_mexico', secret: 'WIX_HM_API_KEY'},
+                          ]"
     secrets:
       GH_TOKEN: ${{ secrets.MY_GITHUB_TOKEN }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN_PUBLISH }}
       GH_APP_ID: ${{ secrets.GH_APP_ID }}
       GH_APP_PRIVATE_KEY: ${{ secrets.GH_APP_PRIVATE_KEY }}
-      WIX_CLI_API_KEY: ${{ secrets.PS_WIX_ACCOUNT_TOKEN }}
+      WIX_SR_API_KEY: ${{secrets.WIX_SR_API_KEY}}
+      WIX_PS_API_KEY: ${{secrets.WIX_PS_API_KEY}}
+      WIX_HM_API_KEY: ${{secrets.WIX_HM_API_KEY}}

package/.prettierignore

@@ -0,0 +1,7 @@
+node_modules
+dist
+build
+coverage
+*.min.js
+package-lock.json
+

package/.prettierrc.json

@@ -0,0 +1,16 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": false,
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "preserve"
+}

package/README.md

@@ -1,2 +1,3 @@
 # task-manager
+
 Task manager library

package/backend/tasks/index.js

@@ -7,5 +7,4 @@ module.exports = {
   ...require('./taskManager'),
   ...require('./utils'),
   ...require('./tasks'),
-  
 };

package/backend/tasks/parentChildTasks/index.js

@@ -2,5 +2,5 @@ module.exports = {
   ...require('./handler'),
   ...require('./childScheduler'),
   ...require('./parentStatusManager'),
-  ...require('./utils')
+  ...require('./utils'),
 };

package/backend/tasks/taskManager.js

@@ -1,6 +1,6 @@
-const { withDuration } = require('psdev-utils');
+const { withDuration, withSuccessRateLogs } = require('psdev-utils');
 
-const { TASK_STATUS, CRON_JOB_MAX_DURATION_SEC } = require('./consts');
+const { TASK_STATUS, CRON_JOB_MAX_DURATION_SEC, TASK_MAX_TRIES } = require('./consts');
 const { scheduleChildTasksAndUpdateParent } = require('./parentChildTasks/handler');
 const {
   saveTaskResultToAdditionalCollection,
@@ -17,7 +17,7 @@ const {
 } = require('./utils');
 
 function taskManager() {
-  const processTask = (task, tasksConfig) =>
+  const processTaskWithDuration = (task, tasksConfig) =>
     withDuration(
       'processTask',
       async () => {
@@ -73,24 +73,33 @@ function taskManager() {
           if (saveResults) {
             await saveTaskResultToAdditionalCollection(task, TASK_STATUS.FAILED, { error });
           }
-          throw new Error(errMsg);
+          const isFailedAfterAllRetries = amountOfRetries >= TASK_MAX_TRIES;
+          if (isFailedAfterAllRetries) {
+
+            //Only throw error if task is permanently failed, otherwise we have retry mechanism
+            throw new Error("task failed after all retries: " + errMsg);
+          }
         }
       },
       console
     );
+  const processTask = (...args) => {
+    const requestName = `processTask_${args[0].name}`; //To get success rate analysis per task
+    return withSuccessRateLogs(requestName, () => processTaskWithDuration(...args));
+  };
   /**
    * @description Processing tasks based on how many the cron job tick can handle and running them sequentially to be as safe as possible
    * */
   const processTasksBasedOnVeloLimit = async (scheduledTasks, tasksConfig) => {
     console.log(
-      `processTasksBasedOnVeloLimit: ${JSON.stringify(scheduledTasks)} ${JSON.stringify(tasksConfig)}`
+      `processTasksBasedOnVeloLimit: scheduledTasks count: ${scheduledTasks.length} tasksConfig: ${JSON.stringify(tasksConfig)}`
     );
     const toProcessTasks = getTasksToProcess({
       scheduledTasks,
       tasksConfig,
       maxDuration: CRON_JOB_MAX_DURATION_SEC,
     });
-    console.log(`processTasksBasedOnVeloLimit: toProcessTasks: ${JSON.stringify(toProcessTasks)}`);
+    console.log(`processTasksBasedOnVeloLimit: toProcessTasks count: ${toProcessTasks.length}`);
     console.log(
       `[processTasksBasedOnVeloLimit] started processing: ${toProcessTasks.length} tasks`
     );
@@ -113,8 +122,7 @@ function taskManager() {
   const runScheduledTasks = async tasksConfig => {
     try {
       const scheduledTasks = await getScheduledTasks();
-      console.log(`runScheduledTasks: scheduledTasks: ${JSON.stringify(scheduledTasks)}`);
-      console.log(`runScheduledTasks: tasksConfig: ${JSON.stringify(tasksConfig)}`);
+      console.log(`runScheduledTasks: scheduledTasks count: ${scheduledTasks.length}`);
       if (scheduledTasks.length) {
         await processTasksBasedOnVeloLimit(scheduledTasks, tasksConfig);
       } else {

package/backend/tasks/tasks.js

@@ -1,29 +1,29 @@
 const TASKS = {
-    TEST_TASK: {
-      name: 'TestTask',
-      getIdentifier: (task) => (task),
-      process: (task) => {
-        const data = task.data || {};
-        let error;
-        if (data.retries){
-          error = task.error ? Number(task.error) - 1 : data.retries - 1;
-        }
-        if (data.shouldFail && (!error || error > 0)){
-            throw new Error(error?.toString() || 'Test error'); 
-        }
-        return 'test';
-      },
-      shouldSkipCheck: (task) => task.data.shouldSkip,
-      estimatedDurationSec:2,
+  TEST_TASK: {
+    name: 'TestTask',
+    getIdentifier: task => task,
+    process: task => {
+      const data = task.data || {};
+      let error;
+      if (data.retries) {
+        error = task.error ? Number(task.error) - 1 : data.retries - 1;
+      }
+      if (data.shouldFail && (!error || error > 0)) {
+        throw new Error(error?.toString() || 'Test error');
+      }
+      return 'test';
     },
-    BAD_TASK: {
-      name: 'BadTask',
-      getIdentifier: () => true,
-      process: () => 'test',
-      shouldSkipCheck: () => false,
-    },
-  };
+    shouldSkipCheck: task => task.data.shouldSkip,
+    estimatedDurationSec: 2,
+  },
+  BAD_TASK: {
+    name: 'BadTask',
+    getIdentifier: () => true,
+    process: () => 'test',
+    shouldSkipCheck: () => false,
+  },
+};
 
-  module.exports = {
-    TASKS,
-  };
+module.exports = {
+  TASKS,
+};

package/backend/tasks/utils.js

@@ -44,7 +44,7 @@ async function createCollectionIfMissing(
       if (collectionType === 'singleItem') {
         createDataCollectionOptions.plugins = [
           {
-            type: "SINGLE_ITEM",
+            type: 'SINGLE_ITEM',
             singleItemOptions: {},
           },
         ];
@@ -168,19 +168,29 @@ const isParentTask = (task, taskConfig) => {
   return true;
 };
 const filterScheduledTasksByStatus = (tasks, tasksConfig) => {
-  console.log(
-    `filterScheduledTasksByStatus: ${JSON.stringify(tasks)} ${JSON.stringify(tasksConfig)}`
-  );
-  const filtered = tasks.filter(task => {
-    if (task.status === TASK_STATUS.IN_PROGRESS) {
-      //Only include parent tasks that are in progress
-      console.log(`filterScheduledTasksByStatus: task: ${JSON.stringify(task)}`);
-      console.log(`filterScheduledTasksByStatus: tasksConfig: ${JSON.stringify(tasksConfig)}`);
-      return isParentTask(task, tasksConfig[task.name]);
+
+  const shouldIncludeTask = (task, taskConfig) => {
+    console.log(`filterScheduledTasksByStatus: task: ${JSON.stringify(task)}`);
+    console.log(`filterScheduledTasksByStatus: taskConfig: ${JSON.stringify(taskConfig)}`);
+    const { status } = task;
+    if (status === TASK_STATUS.IN_PROGRESS) {
+      //Only include parent tasks that are in progress, to continue running next children
+      return isParentTask(task, taskConfig);
     }
+    //TODO: need to rethink of this as some parent tasks we use only to schedule children,
+    // if (status === TASK_STATUS.FAILED) {
+    //   // Exclude if it's a parent task, if parent task failed, we don't retry it anymore
+    //   return !isParentTask(task, taskConfig);
+    // }
+    // // Include if status is PENDING
+    // return status === TASK_STATUS.PENDING;
     return [TASK_STATUS.PENDING, TASK_STATUS.FAILED].includes(task.status);
+  };
+  const filtered = tasks.filter(task => {
+    const taskConfig = tasksConfig[task.name];
+    return shouldIncludeTask(task, taskConfig);
   });
-  console.log(`filterScheduledTasksByStatus: filtered: ${JSON.stringify(filtered)}`);
+  console.log(`filterScheduledTasksByStatus: filtered count: ${filtered.length}`);
   return filtered;
 };
 const getScheduledTasks = async () => {
@@ -221,16 +231,18 @@ const getTaskScheduledChildren = async parentTaskId => {
 };
 
 const getTasksToProcess = ({ scheduledTasks, tasksConfig, maxDuration }) => {
-  console.log('getTasksToProcess:', { scheduledTasks, tasksConfig, maxDuration });
+  console.log('getTasksToProcess:', {
+    scheduledTasksCount: scheduledTasks.length,
+    tasksConfig,
+    maxDuration,
+  });
   const tasksToProcess = [];
   let totalDuration = 0;
-  console.log(`tasksConfig is : ${JSON.stringify(tasksConfig)}`);
   const filteredScheduledTasks = filterScheduledTasksByStatus(scheduledTasks, tasksConfig);
-  console.log(`filteredScheduledTasks is  : ${JSON.stringify(filteredScheduledTasks)}`);
+  console.log(`filteredScheduledTasks count  : ${filteredScheduledTasks.length}`);
   for (const task of filteredScheduledTasks) {
     console.log(`task is : ${JSON.stringify(task)}`);
     const taskConfig = getTaskConfig(task.name, tasksConfig);
-    console.log(`taskConfig is : ${JSON.stringify(taskConfig)}`);
     const estimated = taskConfig?.estimatedDurationSec;
     if (!estimated) {
       const errMsg = `[getTasksToProcess] estimatedDurationSec is not defined for task ${task.name}`;
@@ -243,7 +255,7 @@ const getTasksToProcess = ({ scheduledTasks, tasksConfig, maxDuration }) => {
     totalDuration += buffered;
     tasksToProcess.push(task);
   }
-  console.log('getTasksToProcess: tasksToProcess:', tasksToProcess);
+  console.log('getTasksToProcess: tasksToProcess count:', tasksToProcess.length);
   return tasksToProcess;
 };
 

package/eslint.config.js

@@ -0,0 +1,113 @@
+const js = require('@eslint/js');
+const prettierConfig = require('eslint-config-prettier');
+const importPlugin = require('eslint-plugin-import');
+const prettier = require('eslint-plugin-prettier');
+const promisePlugin = require('eslint-plugin-promise');
+const globals = require('globals');
+
+module.exports = [
+  // Recommended base configurations
+  js.configs.recommended,
+  prettierConfig,
+
+  // Main configuration
+  {
+    files: ['**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2021,
+      sourceType: 'commonjs',
+      globals: {
+        ...globals.node,
+        ...globals.es2021,
+        ...globals.jest,
+      },
+    },
+    plugins: {
+      prettier,
+      import: importPlugin,
+      promise: promisePlugin,
+    },
+    rules: {
+      // Error prevention
+      'no-var': 'error',
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
+      'no-console': ['warn', { allow: ['warn', 'error', 'log', 'info'] }],
+      'no-debugger': 'warn',
+      'no-duplicate-imports': 'error',
+      'no-unused-expressions': ['error', { allowShortCircuit: true, allowTernary: true }],
+      'no-use-before-define': ['error', { functions: false }],
+
+      // Best practices
+      'prefer-const': 'error',
+      'no-const-assign': 'error',
+      'prefer-arrow-callback': 'error',
+      'arrow-body-style': ['error', 'as-needed'],
+      'no-return-await': 'off',
+      'require-await': 'warn',
+
+      // Import rules
+      'import/order': [
+        'error',
+        {
+          groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+          'newlines-between': 'always',
+          alphabetize: { order: 'asc', caseInsensitive: true },
+        },
+      ],
+      'import/no-unresolved': 'error',
+      'import/no-duplicates': 'error',
+      'import/no-commonjs': 'off',
+      'import/no-dynamic-require': 'off',
+
+      // Promise rules
+      'promise/always-return': 'off',
+      'promise/no-return-wrap': 'error',
+      'promise/param-names': 'error',
+      'promise/catch-or-return': 'error',
+      'promise/no-native': 'off',
+      'promise/no-callback-in-promise': 'warn',
+      'promise/no-promise-in-callback': 'warn',
+      'promise/no-nesting': 'warn',
+
+      // Prettier rules
+      'prettier/prettier': [
+        'error',
+        {
+          singleQuote: true,
+          trailingComma: 'es5',
+          printWidth: 100,
+          tabWidth: 2,
+          semi: true,
+          bracketSpacing: true,
+          arrowParens: 'avoid',
+          endOfLine: 'lf',
+        },
+      ],
+    },
+    settings: {
+      'import/resolver': {
+        node: {
+          extensions: ['.js', '.jsx', '.ts', '.tsx'],
+        },
+      },
+    },
+  },
+
+  // Test files override
+  {
+    files: ['**/*.test.js', '**/*.spec.js'],
+    languageOptions: {
+      globals: {
+        ...globals.jest,
+      },
+    },
+    rules: {
+      'no-console': 'off',
+    },
+  },
+
+  // Ignore patterns
+  {
+    ignores: ['node_modules/**', 'dist/**', 'build/**', 'coverage/**', '*.min.js'],
+  },
+];

package/index.js

@@ -1,4 +1,4 @@
 module.exports = {
   ...require('./backend'),
-  ...require('./public')
+  ...require('./public'),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psdev-task-manager",
-  "version": "1.4.6",
+  "version": "1.7.1",
   "description": "Task manager library",
   "keywords": [
     "task-manager"
@@ -18,11 +18,27 @@
   "type": "commonjs",
   "main": "index.js",
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"**/*.{js,json,md}\"",
+    "format:check": "prettier --check \"**/*.{js,json,md}\"",
+    "prepare": "husky"
   },
   "dependencies": {
     "@wix/data": "^1.0.273",
     "@wix/essentials": "^0.1.27",
-    "psdev-utils": "1.0.2"
+    "psdev-utils": "1.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.12.0",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-promise": "^7.1.0",
+    "globals": "^15.10.0",
+    "husky": "^9.1.6",
+    "prettier": "^3.3.3"
   }
 }

package/public/consts.js

@@ -26,4 +26,4 @@ const COLLECTIONS_FIELDS = {
 module.exports = {
   COLLECTIONS,
   COLLECTIONS_FIELDS,
-};
+};