sr-npm 1.7.65 → 1.7.66

package/.prettierrc

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

package/backend/collectionConsts.js

@@ -1,10 +1,35 @@
 const COLLECTIONS = {
-    AMOUNT_OF_JOBS_PER_DEPARTMENT: 'AmountOfJobsPerDepartment',
-    CITIES: 'cities',
-    JOBS: 'Jobs',
+    AMOUNT_OF_JOBS_PER_DEPARTMENT: 'AmountOfJobsPerDepartment1',
+    CITIES: 'cities1',
+    JOBS: 'Jobs1',
     API_KEY: 'ApiKey',
 }
-
+const JOBS_COLLECTION_FIELDS = {
+  LOCATION: 'location',
+  TITLE: 'title',
+  LOCATION_ADDRESS: 'locationAddress',
+  POSTING_STATUS: 'postingStatus',
+  COUNTRY: 'country',
+  DEPARTMENT: 'department',
+  LANGUAGE: 'language',
+  REMOTE: 'remote',
+  JOB_DESCRIPTION: 'jobDescription',
+  DEPARTMENT_REF: 'departmentRef',
+  CITY: 'city',
+  CITY_TEXT: 'cityText',
+}
+const AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION_FIELDS = {
+  TITLE: 'title',
+  COUNT: 'count',
+  IMAGE: 'image',
+}
+const CITIES_COLLECTION_FIELDS = {
+  TITLE: 'title',
+  CITY: 'city',
+  LOCATION_ADDRESS: 'locationAddress',
+  COUNT: 'count',
+  COUNTRY: 'country',
+}
 const COLLECTIONS_FIELDS = {
     AMOUNT_OF_JOBS_PER_DEPARTMENT: [
       {key:'title', type: 'TEXT'},
@@ -28,10 +53,9 @@ const COLLECTIONS_FIELDS = {
         {key:'language', type: 'TEXT'},
         {key:'remote', type: 'BOOLEAN'},
         {key:'jobDescription', type: 'OBJECT'},  
-        {key:'cityText', type: 'TEXT'},
-        {key:'applyLink', type: 'URL'},         
-        {key:'departmentref', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'AmountOfJobsPerDepartment' } } },
-        {key:'city', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'cities' } } },
+        {key:'cityText', type: 'TEXT'},         
+        {key:'departmentRef', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'AmountOfJobsPerDepartment1' } } },
+        {key:'city', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'cities1' } } },
     ],  
     API_KEY: [
       {key:'token', type: 'TEXT'},
@@ -39,8 +63,10 @@ const COLLECTIONS_FIELDS = {
   };
 
 
-
   module.exports = {
     COLLECTIONS,
     COLLECTIONS_FIELDS,
+    JOBS_COLLECTION_FIELDS,
+    AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION_FIELDS,
+    CITIES_COLLECTION_FIELDS,
 };

package/backend/consts.js

@@ -1,10 +1,19 @@
-const {saveDataJobsToCMS,saveJobsDescriptionsAndLocationApplyUrlToCMS,aggregateJobsByFieldToCMS,referenceJobsToField,createApiKeyCollectionAndFillIt} = require('./data');
+const {
+  saveJobsDataToCMS,
+  saveJobsDescriptionsAndLocationToCMS,
+  aggregateJobsByFieldToCMS,
+  referenceJobsToField,
+  createApiKeyCollectionAndFillIt,
+} = require('./data');
 const { createCollectionIfMissing } = require('@hisense-staging/velo-npm/backend');
-const { COLLECTIONS, COLLECTIONS_FIELDS } = require('./collectionConsts');
+const { COLLECTIONS, COLLECTIONS_FIELDS, JOBS_COLLECTION_FIELDS } = require('./collectionConsts');
+
+const QUERY_MAX_LIMIT = 1000;
+
 const TASKS_NAMES = {
     SYNC_JOBS: 'syncJobsFromSRAPIToCMS',
     INSERT_JOBS_TO_CMS: 'insertJobsToCMS',
-    INSERT_JOBS_DESCRIPTIONS_LOCATION_APPLY_URL_TO_CMS: 'insertJobsDescriptionsLocationApplyUrlToCMS',
+    INSERT_JOBS_DESCRIPTIONS_TO_CMS: 'insertJobsDescriptionsToCMS',
     FILL_JOBS_PER_CITY_COLLECTION: 'fillJobsPerCityCollection',
     FILL_JOBS_PER_DEPARTMENT_COLLECTION: 'fillJobsPerDepartmentCollection',
     REFERENCE_JOBS_TO_LOCATIONS: 'referenceJobsToLocations',
@@ -17,103 +26,126 @@ const TASKS_NAMES = {
 
 
 const TASKS = {
-    [TASKS_NAMES.SYNC_JOBS]: {
-      name: TASKS_NAMES.SYNC_JOBS,
-      childTasks: [
-        { name: TASKS_NAMES.CREATE_JOBS_COLLECTION },
-        { name: TASKS_NAMES.CREATE_CITIES_COLLECTION },
-        {name:  TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION},
-        { name: TASKS_NAMES.INSERT_JOBS_TO_CMS },
-        { name: TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_LOCATION_APPLY_URL_TO_CMS },
-        { name: TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION },
-        { name: TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION },
-        { name: TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS },
-        { name: TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT },
-      ],
-      scheduleChildrenSequentially: true,
-      estimatedDurationSec: 30,
-    },
-    [TASKS_NAMES.CREATE_JOBS_COLLECTION]: {
-      name: TASKS_NAMES.CREATE_JOBS_COLLECTION,
-      getIdentifier:()=> "SHOULD_NEVER_SKIP",
-      process:()=>createCollectionIfMissing(COLLECTIONS.JOBS, COLLECTIONS_FIELDS.JOBS,{ insert: 'ADMIN', update: 'ADMIN', remove: 'ADMIN', read: 'ANYONE' }),
-      shouldSkipCheck:()=>false,
-      estimatedDurationSec:3
-    },
-    [TASKS_NAMES.CREATE_CITIES_COLLECTION]: {
-      name: TASKS_NAMES.CREATE_CITIES_COLLECTION,
-      getIdentifier:()=> "SHOULD_NEVER_SKIP",
-      process:()=>createCollectionIfMissing(COLLECTIONS.CITIES, COLLECTIONS_FIELDS.CITIES),
-      shouldSkipCheck:()=>false,
-      estimatedDurationSec:3
-    },
-    [TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION]: {
-      name: TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION,
-      getIdentifier:()=> "SHOULD_NEVER_SKIP",
-      process:()=>createCollectionIfMissing(COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT, COLLECTIONS_FIELDS.AMOUNT_OF_JOBS_PER_DEPARTMENT),
-      shouldSkipCheck:()=>false,
-      estimatedDurationSec:3
-    },
-    [TASKS_NAMES.INSERT_JOBS_TO_CMS]: {
-      name: TASKS_NAMES.INSERT_JOBS_TO_CMS,
-      getIdentifier:()=> "SHOULD_NEVER_SKIP",
-      process:saveDataJobsToCMS,
-      shouldSkipCheck:()=>false,
-      estimatedDurationSec:20
-    },
-    [TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_LOCATION_APPLY_URL_TO_CMS]: {
-      name: TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_LOCATION_APPLY_URL_TO_CMS,
-      getIdentifier:()=> "SHOULD_NEVER_SKIP",
-      process:saveJobsDescriptionsAndLocationApplyUrlToCMS,
-      shouldSkipCheck:()=>false,
-      estimatedDurationSec:20
-    },
-    [TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION]: {
-        name: TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION,
-        getIdentifier:()=> "SHOULD_NEVER_SKIP",
-        process:()=>aggregateJobsByFieldToCMS({ field: 'cityText', collection: COLLECTIONS.CITIES }),
-        shouldSkipCheck:()=>false,
-        estimatedDurationSec:3
-      },
-      [TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION]: {
-        name: TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION,
-        getIdentifier:()=> "SHOULD_NEVER_SKIP",
-        process:()=>aggregateJobsByFieldToCMS({ field: 'department', collection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT }),
-        shouldSkipCheck:()=>false,
-        estimatedDurationSec:3
-      },
-      [TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS]: {
-        name: TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS,
-        getIdentifier:()=> "SHOULD_NEVER_SKIP",
-        process:()=>referenceJobsToField({ referenceField: 'city', sourceCollection: COLLECTIONS.CITIES, jobField: 'cityText' }),
-        shouldSkipCheck:()=>false,
-        estimatedDurationSec:3
-      },
-      [TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT]: {
-        name: TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT,
-        getIdentifier:()=> "SHOULD_NEVER_SKIP",
-        process:()=>referenceJobsToField({ referenceField: 'departmentref', sourceCollection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT, jobField: 'department' }),
-        shouldSkipCheck:()=>false,
-        estimatedDurationSec:3
-      },
-      [TASKS_NAMES.CREATE_API_KEY_COLLECTION_AND_FILL_IT]: {
-        name: TASKS_NAMES.CREATE_API_KEY_COLLECTION_AND_FILL_IT,
-        getIdentifier:()=> "SHOULD_NEVER_SKIP",
-        process:()=>createApiKeyCollectionAndFillIt(),
-        shouldSkipCheck:()=>false,
-        estimatedDurationSec:3
-      }
-}
+  [TASKS_NAMES.SYNC_JOBS]: {
+    name: TASKS_NAMES.SYNC_JOBS,
+    childTasks: [
+      { name: TASKS_NAMES.CREATE_JOBS_COLLECTION },
+      { name: TASKS_NAMES.CREATE_CITIES_COLLECTION },
+      { name: TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION },
+      { name: TASKS_NAMES.INSERT_JOBS_TO_CMS },
+      { name: TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_TO_CMS },
+      { name: TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION },
+      { name: TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION },
+      { name: TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS },
+      { name: TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT },
+    ],
+    scheduleChildrenSequentially: true,
+    estimatedDurationSec: 30,
+  },
+  [TASKS_NAMES.CREATE_JOBS_COLLECTION]: {
+    name: TASKS_NAMES.CREATE_JOBS_COLLECTION,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () => createCollectionIfMissing(COLLECTIONS.JOBS, COLLECTIONS_FIELDS.JOBS,{ insert: 'ADMIN', update: 'ADMIN', remove: 'ADMIN', read: 'ANYONE' }),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.CREATE_CITIES_COLLECTION]: {
+    name: TASKS_NAMES.CREATE_CITIES_COLLECTION,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () => createCollectionIfMissing(COLLECTIONS.CITIES, COLLECTIONS_FIELDS.CITIES),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION]: {
+    name: TASKS_NAMES.CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () =>
+      createCollectionIfMissing(
+        COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT,
+        COLLECTIONS_FIELDS.AMOUNT_OF_JOBS_PER_DEPARTMENT
+      ),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.INSERT_JOBS_TO_CMS]: {
+    name: TASKS_NAMES.INSERT_JOBS_TO_CMS,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: saveJobsDataToCMS,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 20,
+  },
+  [TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_TO_CMS]: {
+    name: TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_TO_CMS,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: saveJobsDescriptionsAndLocationToCMS,
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 20,
+  },
+  [TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION]: {
+    name: TASKS_NAMES.FILL_JOBS_PER_CITY_COLLECTION,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () =>
+      aggregateJobsByFieldToCMS({
+        field: JOBS_COLLECTION_FIELDS.CITY_TEXT,
+        collection: COLLECTIONS.CITIES,
+      }),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION]: {
+    name: TASKS_NAMES.FILL_JOBS_PER_DEPARTMENT_COLLECTION,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () =>
+      aggregateJobsByFieldToCMS({
+        field: JOBS_COLLECTION_FIELDS.DEPARTMENT,
+        collection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT,
+      }),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS]: {
+    name: TASKS_NAMES.REFERENCE_JOBS_TO_LOCATIONS,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () =>
+      referenceJobsToField({
+        referenceField: JOBS_COLLECTION_FIELDS.CITY,
+        sourceCollection: COLLECTIONS.CITIES,
+        jobField: JOBS_COLLECTION_FIELDS.CITY_TEXT,
+      }),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT]: {
+    name: TASKS_NAMES.REFERENCE_JOBS_TO_DEPARTMENT,
+    getIdentifier: () => 'SHOULD_NEVER_SKIP',
+    process: () =>
+      referenceJobsToField({
+        referenceField: JOBS_COLLECTION_FIELDS.DEPARTMENT_REF,
+        sourceCollection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT,
+        jobField: JOBS_COLLECTION_FIELDS.DEPARTMENT,
+      }),
+    shouldSkipCheck: () => false,
+    estimatedDurationSec: 3,
+  },
+  [TASKS_NAMES.CREATE_API_KEY_COLLECTION_AND_FILL_IT]: {
+    name: TASKS_NAMES.CREATE_API_KEY_COLLECTION_AND_FILL_IT,
+    getIdentifier:()=> "SHOULD_NEVER_SKIP",
+    process:()=>createApiKeyCollectionAndFillIt(),
+    shouldSkipCheck:()=>false,
+    estimatedDurationSec:3
+  }
+};
 
 
 
 const TASK_TYPE = {
-    SCHEDULED: 'scheduled',
-    EVENT: 'event',
-  };
+  SCHEDULED: 'scheduled',
+  EVENT: 'event',
+};
 
   module.exports = {
     TASKS_NAMES,
     TASK_TYPE,
     TASKS,
+    QUERY_MAX_LIMIT
 };

package/backend/data.js

@@ -1,321 +1,272 @@
 const { items: wixData } = require('@wix/data');
 const { fetchPositionsFromSRAPI, fetchJobDescription } = require('./fetchPositionsFromSRAPI');
-const { chunkedBulkOperation } = require('./utils');
 const { createCollectionIfMissing } = require('@hisense-staging/velo-npm/backend');
 const { COLLECTIONS, COLLECTIONS_FIELDS } = require('./collectionConsts');
 const { secrets } = require("@wix/secrets");
 const { auth } = require('@wix/essentials');
+const { chunkedBulkOperation, delay, countJobsPerGivenField, fillCityLocationAndLocationAddress ,prepareToSaveArray,normalizeCityName} = require('./utils');
+const { getAllPositions } = require('./queries');
+
+
+function validatePosition(position) {
+  if (!position.id) {
+    throw new Error('Position id is required');
+  }
+  if (!position.title) {
+    throw new Error('Position title is required');
+  }
+  if (!position.department || !position.department.label) {
+    throw new Error('Position department is required and must have a label');
+  }
+  if (!position.location || !position.location.city || !position.location.remote) {
+    throw new Error('Position location is required and must have a city and remote');
+  }
 
-// Utility function to normalize city names
-function normalizeCityName(city) {
-    if (!city) return city;
-    // Remove accents/diacritics, trim whitespace
-    return city.normalize('NFD').replace(/\p{Diacritic}/gu, '').trim();
 }
 
-async function saveDataJobsToCMS() {
-    const positions = await fetchPositionsFromSRAPI();
-    // bulk insert to jobs collection without descriptions first
-    const jobsData = positions.content.map((position) => {
-        const basicJob = {
-            _id: position.id,
-            title: position.title,
-            department: position.department.label,
-            cityText: normalizeCityName(position.location.city),
-            location: position.location,
-            country: position.location.country,
-            remote: position.location.remote,
-            language: position.language.label,
-            postingStatus: position.postingStatus,
-            jobDescription: null // Will be filled later
-        }
-        return basicJob;
-    });
-    
-    const chunkSize = 1000;
-    let totalSaved = 0;
-    const totalChunks = Math.ceil(jobsData.length / chunkSize);
-    
-    console.log(`Processing ${jobsData.length} jobs in ${totalChunks} chunks of max ${chunkSize} items each`);
+async function saveJobsDataToCMS() {
+  const positions = await fetchPositionsFromSRAPI();
+  // bulk insert to jobs collection without descriptions first
+  const jobsData = positions.content.map(position => {
+    validatePosition(position);
+    const basicJob = {
+      _id: position.id,
+      title: position.title,
+      department: position.department.label,
+      cityText: normalizeCityName(position.location.city),
+      location: position.location,
+      country: position.location.country,
+      remote: position.location.remote,
+      language: position.language.label,
+      postingStatus: position.postingStatus,
+      jobDescription: null, // Will be filled later
+    };
+    return basicJob;
+  });
+
+  const chunkSize = 1000;
+  let totalSaved = 0;
+  const totalChunks = Math.ceil(jobsData.length / chunkSize);
+
+  console.log(
+    `Processing ${jobsData.length} jobs in ${totalChunks} chunks of max ${chunkSize} items each`
+  );
+
+  await chunkedBulkOperation({
+    items: jobsData,
+    chunkSize,
+    processChunk: async (chunk, chunkNumber) => {
+      console.log(`Saving chunk ${chunkNumber}/${totalChunks}: ${chunk.length} jobs`);
+      try {
+        const result = await wixData.bulkSave('Jobs1', chunk);
+        const saved = result.inserted + result.updated || chunk.length;
+        totalSaved += saved;
+        console.log(
+          `✓ Chunk ${chunkNumber} saved successfully. Inserted: ${result.inserted}, Updated: ${result.updated}`
+        );
+      } catch (error) {
+        console.error(`✗ Error saving chunk ${chunkNumber}:`, error);
+        throw error;
+      }
+    },
+  });
+
+  console.log(`✓ All chunks processed. Total jobs saved: ${totalSaved}/${jobsData.length}`);
+}
+
+async function saveJobsDescriptionsAndLocationToCMS() {
+  console.log('🚀 Starting job descriptions update process for ALL jobs');
+
+  try {
+    let jobsWithNoDescriptions = await getJobsWithNoDescriptions();
+    let totalUpdated = 0;
+    let totalFailed = 0;
+    let totalProcessed = 0;
+
+    console.log(
+      `Total jobs in database without descriptions:  ${jobsWithNoDescriptions?.items?.length}`
+    );
+
+    if (jobsWithNoDescriptions.items.length === 0) {
+      console.log('No jobs found in database');
+      return { success: true, message: 'No jobs found' };
+    }
+
+
+    const API_CHUNK_SIZE = 80;
+    const pageChunks = Math.ceil(jobsWithNoDescriptions.items.length / API_CHUNK_SIZE);
 
     await chunkedBulkOperation({
-        items: jobsData,
-        chunkSize,
-        processChunk: async (chunk, chunkNumber) => {
-            console.log(`Saving chunk ${chunkNumber}/${totalChunks}: ${chunk.length} jobs`);
-            try {
-                const result = await wixData.bulkSave(COLLECTIONS.JOBS, chunk);
-                const saved = result.inserted + result.updated || chunk.length;
-                totalSaved += saved;
-                console.log(`✓ Chunk ${chunkNumber} saved successfully. Inserted: ${result.inserted}, Updated: ${result.updated}`);
-            } catch (error) {
-                console.error(`✗ Error saving chunk ${chunkNumber}:`, error);
-                throw error;
-            }
+      items: jobsWithNoDescriptions.items,
+      chunkSize: API_CHUNK_SIZE,
+      processChunk: async (chunk, chunkNumber) => {
+        console.log(`  Processing API chunk ${chunkNumber}/${pageChunks} (${chunk.length} jobs)`);
+        const chunkPromises = chunk.map(async job => {
+          try {
+            const jobDetails = await fetchJobDescription(job._id);
+            const jobLocation = fetchJobLocation(jobDetails);
+
+            const updatedJob = {
+              ...job,
+              locationAddress: jobLocation,
+              jobDescription: jobDetails.jobAd.sections,
+            };
+            await wixData.update('Jobs1', updatedJob);
+            return { success: true, jobId: job._id, title: job.title };
+          } catch (error) {
+            console.error(`    ❌ Failed to update ${job.title} (${job._id}):`, error);
+            return { success: false, jobId: job._id, title: job.title, error: error.message };
+          }
+        });
+        const chunkResults = await Promise.all(chunkPromises);
+        const chunkSuccesses = chunkResults.filter(r => r.success).length;
+        const chunkFailures = chunkResults.filter(r => !r.success).length;
+        totalUpdated += chunkSuccesses;
+        totalFailed += chunkFailures;
+        totalProcessed += chunk.length;
+        console.log(
+          `  API chunk ${chunkNumber} completed: ${chunkSuccesses} success, ${chunkFailures} failed`
+        );
+        if (chunkNumber * API_CHUNK_SIZE < jobsWithNoDescriptions.items.length) {
+          console.log('  Waiting 2 seconds before next API chunk...');
+          await delay(2000);
         }
+      },
     });
-    
-    console.log(`✓ All chunks processed. Total jobs saved: ${totalSaved}/${jobsData.length}`);
 
-}
 
-async function saveJobsDescriptionsAndLocationApplyUrlToCMS() {
-    
-   console.log('🚀 Starting job descriptions update process for ALL jobs using pagination...');
-    
-    try {
-        let jobsWithNoDescriptions = await getJobsWithNoDescriptions();
-        let totalUpdated = 0;
-        let totalFailed = 0;
-        let totalProcessed = 0;
-        let pageNumber = 1;
-        
-        // Start with the first page query - limit to 100 jobs per page
-       // let jobsQuery = await wixData.query("Jobs").limit(300).find();
-        
-        console.log(`Total jobs in database without descriptions:  ${jobsWithNoDescriptions.totalCount}`);
-        
-        if (jobsWithNoDescriptions.totalCount === 0) {
-            console.log('No jobs found in database');
-            return { success: true, message: 'No jobs found' };
-        }
 
-        // Process all pages using hasNext() pagination
-        do {
-            const currentPageJobs = jobsWithNoDescriptions.items;
-            console.log(`\n📄 Processing page ${pageNumber} with ${currentPageJobs.length} jobs...`);
-            
-            // Process jobs in smaller chunks of 5 for API calls within each page
-            const API_CHUNK_SIZE = 80;
-            const pageChunks = Math.ceil(currentPageJobs.length / API_CHUNK_SIZE);
-            
-            await chunkedBulkOperation({
-                items: currentPageJobs,
-                chunkSize: API_CHUNK_SIZE,
-                processChunk: async (chunk, chunkNumber) => {
-                    console.log(`  Processing API chunk ${chunkNumber}/${pageChunks} (${chunk.length} jobs)`);
-                    const chunkPromises = chunk.map(async (job) => {
-                        try {
-                            //   console.log(`    Fetching description for: ${job.title} (${job._id})`);
-                            const jobDetails = await fetchJobDescription(job._id);
-                            const jobLocation = fetchJobLocation(jobDetails)
-                            const applyLink = fetchApplyLink(jobDetails);
-                            
-                            const updatedJob = {
-                                ...job,
-                                locationAddress: jobLocation,
-                                jobDescription: jobDetails.jobAd.sections,
-                                applyLink: applyLink
-                            };
-                            await wixData.update(COLLECTIONS.JOBS, updatedJob);
-                            // console.log(`    ✅ Updated description for: ${job.title}`);
-                            return { success: true, jobId: job._id, title: job.title };
-                        } catch (error) {
-                            console.error(`    ❌ Failed to update ${job.title} (${job._id}):`, error);
-                            return { success: false, jobId: job._id, title: job.title, error: error.message };
-                        }
-                    });
-                    const chunkResults = await Promise.all(chunkPromises);
-                    const chunkSuccesses = chunkResults.filter(r => r.success).length;
-                    const chunkFailures = chunkResults.filter(r => !r.success).length;
-                    totalUpdated += chunkSuccesses;
-                    totalFailed += chunkFailures;
-                    totalProcessed += chunk.length;
-                    console.log(`  API chunk ${chunkNumber} completed: ${chunkSuccesses} success, ${chunkFailures} failed`);
-                    if (chunkNumber * API_CHUNK_SIZE < currentPageJobs.length) {
-                        console.log('  Waiting 2 seconds before next API chunk...');
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                    }
-                }
-            });
-            
-            console.log(`📄 Page ${pageNumber} completed. Updated: ${totalUpdated}, Failed: ${totalFailed}, Total processed: ${totalProcessed}/${jobsWithNoDescriptions.totalCount}`);
-            
-            // Check if there are more pages and get the next page
-            if (jobsWithNoDescriptions.hasNext()) {
-                console.log('🔄 Moving to next page...');
-                jobsWithNoDescriptions = await jobsWithNoDescriptions.next();
-                pageNumber++;
-                
-                // Add a delay between pages
-                console.log('Waiting 3 seconds before next page...');
-                await new Promise(resolve => setTimeout(resolve, 3000));
-            }
-            
-        } while (jobsWithNoDescriptions.hasNext());
-        
-        console.log(`\n✅ Finished updating ALL job descriptions using pagination!`);
-        console.log(`📊 Final Results:`);
-        console.log(`   Total pages processed: ${pageNumber}`);
-        console.log(`   Total jobs processed: ${totalProcessed}`);
-        console.log(`   Total updated: ${totalUpdated}`);
-        console.log(`   Total failed: ${totalFailed}`);
-        
-        return {
-            success: true,
-            totalPages: pageNumber,
-            totalProcessed: totalProcessed,
-            totalUpdated: totalUpdated,
-            totalFailed: totalFailed,
-            message: `Successfully updated ${totalUpdated} job descriptions out of ${totalProcessed} total jobs across ${pageNumber} pages`
-        };
-        
-    } catch (error) {
-        console.error('❌ Error in updateJobDescriptions:', error);
-        throw error;
-    }
+    console.log(`\n✅ Finished updating ALL job descriptions`);
+    console.log(`📊 Final Results:`);
+    console.log(`   Total jobs processed: ${totalProcessed}`);
+    console.log(`   Total updated: ${totalUpdated}`);
+    console.log(`   Total failed: ${totalFailed}`);
+
+    return {
+      success: true,
+      totalProcessed: totalProcessed,
+      totalUpdated: totalUpdated,
+      totalFailed: totalFailed,
+      message: `Successfully updated ${totalUpdated} job descriptions out of ${totalProcessed} total jobs`,
+    };
+  } catch (error) {
+    console.error('❌ Error in updateJobDescriptions:', error);
+    throw error;
+  }
 }
 
-async function aggregateJobsByFieldToCMS({ field, collection }) {
-    console.log(`counting jobs per ${field}.`);
-    let jobsPerField = {};
-    let cityLocations = {};
-    let query = wixData.query(COLLECTIONS.JOBS).limit(1000);
-    let results = await query.find();
-    const cityLocationAddress={}
-    let page = 1;
-    do {
-        console.log(`Page ${page}: ${results.items.length} jobs.`);
-        for (const job of results.items) {
-            if (!job[field])
-                {
-                    throw new Error(`Job ${job._id} has no ${field} field`);
-                } 
-            jobsPerField[job[field]] = (jobsPerField[job[field]] || 0) + 1;
-            if (field === 'cityText' && !cityLocationAddress[job[field]] && !cityLocations[job[field]]) {
-                cityLocationAddress[job[field]] = job.locationAddress;
-                cityLocations[job[field]] = job.location;
-            }
-        }
-        if (results.hasNext()) {
-            results = await results.next();
-            page++;
-        }
-    } while (results.hasNext());
-    let toSave = [];
+
+function iterateOverAllJobs(results, field) {
+  const jobsPerField = {};
+  const cityLocations = {};
+  const citylocationAddress = {};
+    countJobsPerGivenField(results, field, jobsPerField);
     if (field === 'cityText') {
-         toSave = Object.entries(jobsPerField).map(([value, amount]) => {
-            const locAddress = cityLocationAddress[value] || {};
-            const loc = cityLocations[value] || {};
-            value = normalizeCityName(value);
-
-            return {
-                title: value,
-                _id: value.replace(/\s+/g, ''),
-                count: amount,
-                locationAddress: locAddress,
-                country: loc.country,
-                city: loc.city,
-            };
-        });
-    }
-    else{
-    // Prepare array for bulkSave
-     toSave = Object.entries(jobsPerField).map(([value, amount]) => ({
-        title: value,
-        _id: value.replace(/\s+/g, ''),
-        count: amount
-    }));
-    }
-    if (toSave.length === 0) {
-        console.log('No jobs found.');
-        return { success: true, message: 'No jobs to save.' };
+      fillCityLocationAndLocationAddress(results, cityLocations,citylocationAddress);
     }
+    return { jobsPerField, cityLocations,citylocationAddress };
+}
 
-    try {
-        const saveResult = await wixData.bulkSave(collection, toSave);
-        console.log(`Saved ${toSave.length} ${field} counts to ${collection}.`);
-        return { success: true, saved: toSave.length, result: saveResult };
-    } catch (err) {
-        console.error(`Error saving jobs per ${field}:`, err);
-        return { success: false, error: err.message };
-    }
+async function aggregateJobsByFieldToCMS({ field, collection }) {
+  console.log(`counting jobs per ${field}.`);
+  let results = await getAllPositions();
+  const { jobsPerField, cityLocations,citylocationAddress } = iterateOverAllJobs(results, field);
+  const toSave = prepareToSaveArray(jobsPerField, cityLocations, field,citylocationAddress);
+  if (toSave.length === 0) {
+    console.log('No jobs found.');
+    return { success: true, message: 'No jobs to save.' };
+  }
+  try {
+    const saveResult = await wixData.bulkSave(collection, toSave);
+    console.log(`Saved ${toSave.length} ${field} counts to ${collection}.`);
+    return { success: true, saved: toSave.length, result: saveResult };
+  } catch (err) {
+    console.error(`Error saving jobs per ${field}:`, err);
+    return { success: false, error: err.message };
+  }
 }
 
 async function getJobsWithNoDescriptions() {
-    
-   let jobswithoutdescriptionsQuery = await wixData.query(COLLECTIONS.JOBS).limit(1000).isEmpty("jobDescription").find(); // with 900 as the limit, 429 error won't happen
-    return jobswithoutdescriptionsQuery;
+  let jobswithoutdescriptionsQuery = await wixData
+    .query('Jobs1')
+    .limit(1000)
+    .isEmpty('jobDescription')
+    .find();
+  return jobswithoutdescriptionsQuery;
 }
 
-async function referenceJobsToField({
-    referenceField,      // e.g., "city" or "department"
-    sourceCollection,    // e.g., "cities" or "departments"
-    jobField,            // e.g., "cityText" or "department"
-    
-}) {
-    // Fetch all source items (cities or departments)
-    const sources = await wixData.query(sourceCollection).limit(1000).find();
-    const sourceMap = {};
-    for (const item of sources.items) {
-        sourceMap[item.title] = item._id;
-    }
-
-    // Fetch all jobs
-    let jobsResults = await wixData.query(COLLECTIONS.JOBS).limit(1000).find();
-    let jobsToUpdate = [];
-    console.log('jobsResults',jobsResults.items);
-
-    do {
-        for (const job of jobsResults.items) {
-            const refId = sourceMap[job[jobField]];
-            if (refId) {
-                jobsToUpdate.push({
-                    ...job,
-                    [referenceField]: refId
-                });
-            }
-        }
-        if (jobsResults.hasNext()) {
-            jobsResults = await jobsResults.next();
-        } else {
-            break;
-        }
-    } while (true);
+/**
+ * @param {Object} params
+ * @param {"city"|"departmentRef"} params.referenceField
+ * @param {"cities1"|"AmountOfJobsPerDepartment1"} params.sourceCollection
+ * @param {"cityText"|"department"} params.jobField
+ */
+async function referenceJobsToField({ referenceField, sourceCollection, jobField }) {
+  // Fetch all source items (cities or departments)
+  const sources = await wixData.query(sourceCollection).limit(1000).find();
+  const sourceMap = {};
+  for (const item of sources.items) {
+    sourceMap[item.title] = item._id;
+  }
 
-    // Remove system fields that cannot be updated
-    jobsToUpdate = jobsToUpdate.map(job => {
-        const { _createdDate, _updatedDate, ...rest } = job;
-        return rest;
-    });
+  // Fetch all jobs
+  let jobsResults = await getAllPositions();
+  let jobsToUpdate = [];
+  
+  for (const job of jobsResults) {
+    const refId = sourceMap[job[jobField]];
+    if (refId) {
+      jobsToUpdate.push({
+        ...job,
+        [referenceField]: refId,
+      });
+    }
+  }
 
-    // Bulk update in chunks of 1000
-    const chunkSize = 1000;
-    await chunkedBulkOperation({
-        items: jobsToUpdate,
-        chunkSize,
-        processChunk: async (chunk) => {
-            await wixData.bulkUpdate(COLLECTIONS.JOBS, chunk);
-        }
-    });
+  // Remove system fields that cannot be updated
+  jobsToUpdate = jobsToUpdate.map(job => {
+    const { _createdDate, _updatedDate, ...rest } = job;
+    return rest;
+  });
 
-    return { success: true, updated: jobsToUpdate.length };
-}
+  // Bulk update in chunks of 1000
+  const chunkSize = 1000;
+  await chunkedBulkOperation({
+    items: jobsToUpdate,
+    chunkSize,
+    processChunk: async chunk => {
+      await wixData.bulkUpdate('Jobs1', chunk);
+    },
+  });
 
-function fetchApplyLink(jobDetails) {
-    return jobDetails.actions.applyOnWeb.url;
+  return { success: true, updated: jobsToUpdate.length };
 }
 
 function fetchJobLocation(jobDetails) {
-    const jobLocation = {
-        location:  {
-            latitude: parseFloat(jobDetails.location.latitude),
-            longitude: parseFloat(jobDetails.location.longitude)
+  const isZeroLocation =
+    jobDetails.location.latitude === '0.0000' && jobDetails.location.longitude === '0.0000';
+  const jobLocation = {
+    location: isZeroLocation
+      ? {}
+      : {
+          latitude: parseFloat(jobDetails.location.latitude),
+          longitude: parseFloat(jobDetails.location.longitude),
         },
-        city: jobDetails.location.city,
-        country: jobDetails.location.country,
-        formatted: [
-            jobDetails.location.city,
-            jobDetails.location.region,
-            jobDetails.location.regionCode,
-            jobDetails.location.country
-        ].filter(Boolean).join(', '),
-        streetAddress: {},
-        subdivision: "",
-        postalCode: ""
-    };
-    return jobLocation;
-
+    city: jobDetails.location.city,
+    country: jobDetails.location.country,
+    formatted: [
+      jobDetails.location.city,
+      jobDetails.location.region,
+      jobDetails.location.regionCode,
+      jobDetails.location.country,
+    ]
+      .filter(Boolean)
+      .join(', '),
+    streetAddress: {},
+    subdivision: '',
+    postalCode: '',
+  };
+  return jobLocation;
 }
 
 
@@ -327,13 +278,14 @@ function getSmartToken() {
     })
     .catch((error) => {
       console.error(error);
+      throw error;
     });
 }
 
 
 async function createApiKeyCollectionAndFillIt() {
     console.log("Creating ApiKey collection and filling it with the smart token");
-    await createCollectionIfMissing(COLLECTIONS.API_KEY, COLLECTIONS_FIELDS.API_KEY);
+    await createCollectionIfMissing(COLLECTIONS.API_KEY, COLLECTIONS_FIELDS.API_KEY,null,'singleItem');
     console.log("Getting the smart token");
     const token = await getSmartToken();
     console.log("token is :  ", token);
@@ -347,9 +299,9 @@ async function createApiKeyCollectionAndFillIt() {
 
 
 module.exports = {
-    saveDataJobsToCMS,
-    saveJobsDescriptionsAndLocationApplyUrlToCMS,
+    saveJobsDataToCMS,
+    saveJobsDescriptionsAndLocationToCMS,
     aggregateJobsByFieldToCMS,
     referenceJobsToField,
     createApiKeyCollectionAndFillIt,
-};
+};

package/backend/fetchPositionsFromSRAPI.js

@@ -1,6 +1,7 @@
 const { fetch } = require('wix-fetch');
 const { items: wixData } = require('@wix/data');
 const { COLLECTIONS } = require('./collectionConsts');
+
 async function makeSmartRecruitersRequest(path,token) {
   // const baseUrl = 'https://api.smartrecruiters.com'; // PROD
   const baseUrl = 'https://aoxley54.wixstudio.com/external-template/_functions'; // TEST
@@ -34,7 +35,7 @@ async function fetchPositionsFromSRAPI() {
   let allPositions = [];
   let totalFound = 0;
   let nextPageId = null; // Start with no page ID for the first request
-  let pageCount = 0;
+  let page = 0;
   const MAX_PAGES = 30 // Safety limit to prevent infinite loops
   const token = await getSmartTokenFromCMS();
 
@@ -42,45 +43,44 @@ async function fetchPositionsFromSRAPI() {
 
   do {
     try {
-      pageCount++;
-      
+      page++;
+
       // Build the API path - first request has no page parameter, subsequent use nextPageId
       let apiPath = '/jobs?limit=50';
       if (nextPageId) {
         apiPath += `&nextPageId=${nextPageId}`;
       }
       
-      console.log(`Fetching page ${pageCount} with path: ${apiPath}`);
+      console.log(`Fetching page ${page} with path: ${apiPath}`);
       const response = await makeSmartRecruitersRequest(apiPath,token);
       
       // Add positions from this page to our collection
       if (response.content && Array.isArray(response.content)) {
         allPositions = allPositions.concat(response.content);
-        console.log(`Page ${pageCount}: Found ${response.content.length} positions`);
+        console.log(`Page ${page}: Found ${response.content.length} positions`);
       }
-      
+
       // Update total count from first response
-      if (pageCount === 1) {
+      if (page === 1) {
         totalFound = response.totalFound || 0;
         console.log(`Total positions available: ${totalFound}`);
       }
-      
+
       // Get the nextPageId for the next iteration
-      nextPageId = response.nextPageId && response.nextPageId !== "" ? response.nextPageId : null;
-      
+      nextPageId = response.nextPageId && response.nextPageId !== '' ? response.nextPageId : null;
+
       if (nextPageId) {
         console.log(`Next page ID: ${nextPageId}`);
       } else {
         console.log('No more pages to fetch');
       }
-      
     } catch (error) {
-      console.error(`Error fetching page ${pageCount}:`, error);
+      console.error(`Error fetching page ${page}:`, error);
       throw error;
     }
-    
+
     // Safety check to prevent infinite loops
-    if (pageCount >= MAX_PAGES) {
+    if (page >= MAX_PAGES) {
       console.warn(`Reached maximum page limit of ${MAX_PAGES}. Stopping pagination.`);
       break;
     }
@@ -89,12 +89,12 @@ async function fetchPositionsFromSRAPI() {
   console.log(`Finished fetching all pages. Total positions collected: ${allPositions.length}`);
 
   // Return response in the same format as before, but with all positions
-  const result =  {
+  const result = {
     totalFound: totalFound,
     offset: 0,
     limit: allPositions.length,
-    nextPageId: "", // Always empty since we've fetched everything
-    content: allPositions
+    nextPageId: '', // Always empty since we've fetched everything
+    content: allPositions,
   };
 
   const amountOfUniqueJobs = new Set(allPositions.map(job => job.id)).size;
@@ -108,8 +108,7 @@ async function fetchPositionsFromSRAPI() {
 }
 
 async function fetchJobDescription(jobId) {
-  const token = await getSmartTokenFromCMS();
-  return await makeSmartRecruitersRequest(`/jobs/${jobId}`,token);
+  return await makeSmartRecruitersRequest(`/jobs/${jobId}`);
 }
 
 async function getSmartTokenFromCMS() {
@@ -117,12 +116,12 @@ async function getSmartTokenFromCMS() {
   if (result.items.length > 0) {
       return result.items[0].token; // This is your string token
   } else {
-      return null; // No token found
+      throw new Error('[getSmartTokenFromCMS], No token found');
   }
 }
 
 
 module.exports = {
-    fetchPositionsFromSRAPI,
-    fetchJobDescription,
+  fetchPositionsFromSRAPI,
+  fetchJobDescription,
 };

package/backend/index.js

@@ -1,7 +1,6 @@
 module.exports = {
-    ...require('./utils'),
-    ...require('./queries'),
-    ...require('./fetchPositionsFromSRAPI'),
-    ...require('./consts'),
-  };
-  
+  ...require('./utils'),
+  ...require('./queries'),
+  ...require('./fetchPositionsFromSRAPI'),
+  ...require('./consts'),
+};

package/backend/queries.js

@@ -1,19 +1,22 @@
-const { COLLECTIONS } = require('./collectionConsts');
-const { items } = require('@wix/data');
-
+const { items: wixData } = require('@wix/data');
 
 async function getAllPositions() {
-    return await items.query(COLLECTIONS.JOBS).find().items;
-    
+  return wixData
+    .query('Jobs1')
+    .limit(1000)
+    .find()
+    .then(result => result.items);
 }
 
 async function getPositionsByField(field, value) {
-    return await items.query(COLLECTIONS.JOBS).where(field, value).find().items;
-    
+  return wixData
+    .query('Jobs1')
+    .eq(field, value)
+    .find()
+    .then(result => result.items);
 }
 
-
 module.exports = {
-    getAllPositions,
-    getPositionsByField,
-};
+  getAllPositions,
+  getPositionsByField,
+};

package/backend/utils.js

@@ -1,11 +1,70 @@
 async function chunkedBulkOperation({ items, chunkSize, processChunk }) {
-    for (let i = 0; i < items.length; i += chunkSize) {
-        const chunk = items.slice(i, i + chunkSize);
-        await processChunk(chunk, Math.floor(i / chunkSize) + 1);
+  for (let i = 0; i < items.length; i += chunkSize) {
+    const chunk = items.slice(i, i + chunkSize);
+    await processChunk(chunk, Math.floor(i / chunkSize) + 1);
+  }
+}
+
+async function delay(ms) {
+  await new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function countJobsPerGivenField(jobs, field,jobsPerField) {
+  for (const job of jobs) {
+    if (!job[field]) {
+      throw new Error(`Job ${job._id} has no ${field} field`);
+    }
+    jobsPerField[job[field]] = (jobsPerField[job[field]] || 0) + 1;
+  }
+}
+
+function fillCityLocationAndLocationAddress(jobs, cityLocations,citylocationAddress) {
+  for (const job of jobs) {
+    if (!cityLocations[job.cityText] && !citylocationAddress[job.cityText]) {
+      cityLocations[job.cityText] = job.location;
+      citylocationAddress[job.cityText] = job.locationAddress;
     }
+  }
 }
 
+function prepareToSaveArray(jobsPerField, cityLocations, field,citylocationAddress) {
+  if (field === 'cityText') {
+    return Object.entries(jobsPerField).map(([value, amount]) => {
+      const loc = cityLocations[value] || {};
+      const locAddress = citylocationAddress[value] || {};
+      value = normalizeCityName(value);
+      return {
+        title: value,
+        _id: value.replace(/\s+/g, ''),
+        count: amount,
+        locationAddress: locAddress,
+        country: loc.country,
+        city: loc.city,
+    };
+    });
+  } else {
+    return Object.entries(jobsPerField).map(([value, amount]) => ({
+      title: value,
+      _id: value.replace(/\s+/g, ''),
+      count: amount,
+    }));
+  }
+}
+
+function normalizeCityName(city) {
+  if (!city) return city;
+  // Remove accents/diacritics, trim whitespace
+  return city
+    .normalize('NFD')
+    .replace(/\p{Diacritic}/gu, '')
+    .trim();
+}
 
 module.exports = {
-    chunkedBulkOperation,
-};
+  chunkedBulkOperation,
+  delay,
+  countJobsPerGivenField,
+  fillCityLocationAndLocationAddress,
+  prepareToSaveArray,
+  normalizeCityName,
+};

package/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sr-npm",
-  "version": "1.7.65",
+  "version": "1.7.66",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -17,9 +17,12 @@
   },
   "homepage": "https://github.com/psdevteamenterprise/sr-npm#readme",
   "dependencies": {
-    "@hisense-staging/velo-npm": "1.7.251",
+    "@hisense-staging/velo-npm": "3.0.19",
     "@wix/data": "^1.0.211",
     "@wix/essentials": "^0.1.24",
-    "@wix/secrets": "1.0.53"
+    "@wix/secrets": "^1.0.53"
+  },
+  "devDependencies": {
+    "prettier": "^3.6.2"
   }
 }

package/pages/index.js

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

package/pages/positionPage.js

@@ -0,0 +1,34 @@
+const {
+    htmlToText,
+  } = require('../public/utils');
+
+  async function positionPageOnReady(_$w) {
+    
+    bind(_$w);
+  }
+
+  async function bind(_$w) {
+    _$w('#datasetJobsItem').onReady(async () => {
+
+        const item = await _$w('#datasetJobsItem').getCurrentItem();
+
+        _$w('#companyDescriptionText').text = htmlToText(item.jobDescription.companyDescription.text);        
+        _$w('#responsibilitiesText').text = htmlToText(item.jobDescription.jobDescription.text);
+        _$w('#qualificationsText').text = htmlToText(item.jobDescription.qualifications.text);
+        _$w('#relatedJobsTitleText').text = `More ${item.department} Positions`;
+    });
+
+    _$w('#relatedJobsDataset').onReady(async () => {
+        const count = await _$w('#relatedJobsDataset').getTotalCount();
+       if(!count){
+            _$w('#relatedJobsSection').collapse();
+       }
+    });
+}
+
+  
+  
+  module.exports = {
+    positionPageOnReady,
+  };
+  

package/public/index.js

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

package/public/utils.js

@@ -0,0 +1,28 @@
+
+
+function htmlToText(html) {
+  if (!html) return '';
+
+  // Remove HTML tags and decode entities
+  let text = html
+      .replace(/<br\s*\/?>/gi, '\n')
+      .replace(/<\/?(p|div|h[1-6])\s*\/?>/gi, '\n')
+      .replace(/<li[^>]*>/gi, '• ')
+      .replace(/<\/li>/gi, '\n')
+      .replace(/<[^>]*>/g, '')
+      .replace(/&amp;/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/&nbsp;/g, ' ');
+
+  console.log(text);
+  // Clean up whitespace
+  return text.replace(/\n\s*\n+/g, '\n\n').replace(/[ \t]+\n/g, '\n').trim();
+}
+
+
+  module.exports = {
+    htmlToText
+  };