sr-npm 1.0.11 → 1.0.13

package/backend/data.js

@@ -1,288 +1,378 @@
 const { items: wixData } = require('@wix/data');
-import { fetchPositionsFromSRAPI, fetchJobDescription } from './fetchPositionsFromSRAPI';
-import { chunkedBulkOperation } from './utils';
-
-// 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();
+const { fetchPositionsFromSRAPI, fetchJobDescription } = require('./fetchPositionsFromSRAPI');
+const { createCollectionIfMissing } = require('@hisense-staging/velo-npm/backend');
+const { COLLECTIONS, COLLECTIONS_FIELDS,JOBS_COLLECTION_FIELDS } = require('./collectionConsts');
+const { chunkedBulkOperation, countJobsPerGivenField, fillCityLocationAndLocationAddress ,prepareToSaveArray,normalizeCityName} = require('./utils');
+const { getAllPositions } = require('./queries');
+const { getCompanyId } = require('./secretsData');
+
+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 ||  typeof position.location.remote !== 'boolean') {
+    throw new Error('Position location is required and must have a city and remote');
+  }
+
 }
 
-export 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 => {
+    const basicJob = {
+      _id: position.id,
+      title: position.name || '',
+      department: position.department?.label || 'Other',
+      cityText: normalizeCityName(position.location?.city),
+      location: position.location && Object.keys(position.location).length > 0
+        ? position.location
+        : {
+            countryCode: "",
+            country: "",
+            city: "",
+            postalCode: "",
+            address: "",
+            manual: false,
+            remote: false,
+            regionCode: ""
+          },
+      country: position.location?.country || '',
+      remote: position.location?.remote || false,
+      language: position.language?.label || '',
+      jobDescription: null, // Will be filled later
+    };
+    return basicJob;
+  });
 
-    await chunkedBulkOperation({
-        items: jobsData,
-        chunkSize,
-        processChunk: async (chunk, chunkNumber) => {
-            console.log(`Saving chunk ${chunkNumber}/${totalChunks}: ${chunk.length} jobs`);
-            try {
-                const result = await wixData.bulkSave("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;
-            }
-        }
-    });
-    
-    console.log(`✓ All chunks processed. Total jobs saved: ${totalSaved}/${jobsData.length}`);
+  // Sort jobs by title (ascending, case-insensitive, numeric-aware)
+  jobsData.sort((a, b) => {
+    const titleA = a.title || '';
+    const titleB = b.title || '';
+    return titleA.localeCompare(titleB, undefined, { sensitivity: 'base', numeric: true });
+  });
 
-}
+  const chunkSize = 1000;
+  let totalSaved = 0;
+  const totalChunks = Math.ceil(jobsData.length / chunkSize);
 
-export async function saveJobsDescriptionsToCMS() {
-    
-    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 updatedJob = {
-                                ...job,
-                                jobDescription: jobDetails.jobAd.sections
-                            };
-                            await wixData.update("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);
+  console.log(
+    `Processing ${jobsData.length} jobs in ${totalChunks} chunks of max ${chunkSize} items each`
+  );
+  console.log("truncating jobs collection");
+  await wixData.truncate(COLLECTIONS.JOBS);
+  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;
-    }
+      }
+    },
+  });
+
+  console.log(`✓ All chunks processed. Total jobs saved: ${totalSaved}/${jobsData.length}`);
 }
 
-export async function aggregateJobsByFieldToCMS({ field, collection }) {
-    console.log(`counting jobs per ${field}.`);
-    let jobsPerField = {};
-    let cityLocations = {};
-    let query = wixData.query("Jobs").limit(1000);
-    let results = await query.find();
-    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' && !cityLocations[job[field]]) {
-                cityLocations[job[field]] = job.location;
-            }
-        }
-        if (results.hasNext()) {
-            results = await results.next();
-            page++;
-        }
-    } while (results.hasNext());
-    let toSave = [];
-    if (field === 'cityText') {
-         toSave = Object.entries(jobsPerField).map(([value, amount]) => {
-            const loc = cityLocations[value] || {};
-            value = normalizeCityName(value);
-
-            return {
-                title: value,
-                _id: value.replace(/\s+/g, ''),
-                count: amount,
-                location: loc,
-                countryCode: loc.countryCode,
-                country: loc.country,
-                region: loc.region,
-                city: loc.city,
-                manual: loc.manual.toString(),
-                remote: loc.remote.toString(),
-                regionCode: loc.regionCode,
-                latitude: loc.latitude,
-                longitude: loc.longitude
+async function saveJobsDescriptionsAndLocationApplyUrlToCMS() {
+  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: 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 {applyLink , referFriendLink} = fetchApplyAndReferFriendLink(jobDetails);
+
+
+            const updatedJob = {
+              ...job,
+              locationAddress: jobLocation,
+              jobDescription: jobDetails.jobAd.sections,
+              applyLink: applyLink,
+              referFriendLink: referFriendLink,
             };
+            await wixData.update(COLLECTIONS.JOBS, 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`
+        );
+      },
+    });
+
+
+
+    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;
+  }
+}
+
+
+function iterateOverAllJobs(results, field) {
+  const jobsPerField = {};
+  const cityLocations = {};
+  const citylocationAddress = {};
+    countJobsPerGivenField(results, field, jobsPerField);
+    if (field === 'cityText') {
+      fillCityLocationAndLocationAddress(results, cityLocations,citylocationAddress);
     }
-    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.' };
+    return { jobsPerField, cityLocations,citylocationAddress };
+}
+
+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 {
+    console.log("saving to collection: ", collection);
+    console.log("toSave: ", toSave);
+    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();
+  return jobswithoutdescriptionsQuery;
+}
+
+/**
+ * @param {Object} params
+ * @param {JOBS_COLLECTION_FIELDS.CITY|JOBS_COLLECTION_FIELDS.DEPARTMENT_REF} params.referenceField
+ * @param {COLLECTIONS.CITIES|COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT} params.sourceCollection
+ * @param {JOBS_COLLECTION_FIELDS.CITY_TEXT|JOBS_COLLECTION_FIELDS.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;
+  }
+
+  // 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,
+      });
     }
+  }
+
+  // Remove system fields that cannot be updated
+  jobsToUpdate = jobsToUpdate.map(job => {
+    const { _createdDate, _updatedDate, ...rest } = job;
+    return rest;
+  });
+
+  // Bulk update in chunks of 1000
+  const chunkSize = 1000;
+  await chunkedBulkOperation({
+    items: jobsToUpdate,
+    chunkSize,
+    processChunk: async chunk => {
+      await wixData.bulkUpdate(COLLECTIONS.JOBS, chunk);
+    },
+  });
+
+  return { success: true, updated: jobsToUpdate.length };
+}
+
+function fetchApplyAndReferFriendLink(jobDetails) {
+    return {applyLink: jobDetails.applyUrl, referFriendLink: jobDetails.referralUrl};
+}
+
+function fetchJobLocation(jobDetails) {
+    const jobLocation = {
+        location:  {
+            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;
+}
+
 
+
+
+async function createCompanyIdCollectionAndFillIt() {
+    console.log("Creating CompanyId collection and filling it with the company ID");
+    await createCollectionIfMissing(COLLECTIONS.COMPANY_ID, COLLECTIONS_FIELDS.COMPANY_ID,null,'singleItem');
+    console.log("Getting the company ID ");
+    const companyId = await getCompanyId();
+    console.log("companyId is :  ", companyId);
+    console.log("Inserting the company ID into the CompanyId collection");
     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 };
+      await wixData.insert(COLLECTIONS.COMPANY_ID, {
+        companyId: companyId.value
+      });
+      console.log("company ID inserted into the CompanyId collection");
+    } catch (error) {
+      if (error.message.includes("WDE0074: An item with _id [SINGLE_ITEM_ID] already exists")) {
+        console.log("company ID already exists in the CompanyId collection");
+      }
+      else {
+        throw error;
+      }
     }
-}
 
-async function getJobsWithNoDescriptions() {
     
-    let jobswithoutdescriptionsQuery = await wixData.query("Jobs").limit(1000).isEmpty("jobDescription").find(); // with 900 as the limit, 429 error won't happen
-    return jobswithoutdescriptionsQuery;
 }
 
-export 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;
-    }
+async function createCollections() {
+  console.log("Creating collections");
+  await Promise.all(
+  [createCollectionIfMissing(COLLECTIONS.JOBS, JOBS_COLLECTION_FIELDS.JOBS,{ insert: 'ADMIN', update: 'ADMIN', remove: 'ADMIN', read: 'ANYONE' }),
+  createCollectionIfMissing(COLLECTIONS.CITIES, COLLECTIONS_FIELDS.CITIES),
+  createCollectionIfMissing(COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT, COLLECTIONS_FIELDS.AMOUNT_OF_JOBS_PER_DEPARTMENT)
+]);
+  console.log("finished creating Collections");
+}
 
-    // Fetch all jobs
-    let jobsResults = await wixData.query("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);
-
-    // Remove system fields that cannot be updated
-    jobsToUpdate = jobsToUpdate.map(job => {
-        const { _createdDate, _updatedDate, ...rest } = job;
-        return rest;
-    });
+async function aggregateJobs() {
+  console.log("Aggregating jobs");
+  await Promise.all([
+    aggregateJobsByFieldToCMS({ field: JOBS_COLLECTION_FIELDS.DEPARTMENT, collection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT }),
+    aggregateJobsByFieldToCMS({ field: JOBS_COLLECTION_FIELDS.CITY_TEXT, collection: COLLECTIONS.CITIES })
+  ]);
+  console.log("finished aggregating jobs");
+}
 
-    // Bulk update in chunks of 1000
-    const chunkSize = 1000;
-    await chunkedBulkOperation({
-        items: jobsToUpdate,
-        chunkSize,
-        processChunk: async (chunk) => {
-            await wixData.bulkUpdate("Jobs", chunk);
-        }
-    });
+async function referenceJobs() {
+  console.log("Reference jobs");
+  await referenceJobsToField({ referenceField: JOBS_COLLECTION_FIELDS.DEPARTMENT_REF, sourceCollection: COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT, jobField: JOBS_COLLECTION_FIELDS.DEPARTMENT });
+  await referenceJobsToField({ referenceField: JOBS_COLLECTION_FIELDS.CITY, sourceCollection: COLLECTIONS.CITIES, jobField: JOBS_COLLECTION_FIELDS.CITY_TEXT });
+  console.log("finished referencing jobs");
+}
+
+async function syncJobsFast() {
+  console.log("Syncing jobs fast");
+  await createCompanyIdCollectionAndFillIt();
+  await createCollections();
+  await clearCollections();
+  console.log("saving jobs data to CMS");
+  await saveJobsDataToCMS();
+  console.log("saved jobs data to CMS successfully");
+  console.log("saving jobs descriptions and location apply url to CMS");
+  await saveJobsDescriptionsAndLocationApplyUrlToCMS();
+  console.log("saved jobs descriptions and location apply url to CMS successfully");
+  await aggregateJobs();
+  await referenceJobs();
+  console.log("syncing jobs fast finished successfully");
+}
 
-    return { success: true, updated: jobsToUpdate.length };
+async function clearCollections() {
+  console.log("clearing collections");
+  await Promise.all([
+    wixData.truncate(COLLECTIONS.CITIES),
+    wixData.truncate(COLLECTIONS.AMOUNT_OF_JOBS_PER_DEPARTMENT),
+    wixData.truncate(COLLECTIONS.JOBS)
+  ]);
+  console.log("cleared collections successfully");
 }
+
+module.exports = {
+  syncJobsFast,
+  referenceJobs,
+  aggregateJobs,
+  createCollections,
+    saveJobsDataToCMS,
+    saveJobsDescriptionsAndLocationApplyUrlToCMS,
+    aggregateJobsByFieldToCMS,
+    referenceJobsToField,
+    createCompanyIdCollectionAndFillIt,
+};