sr-npm 1.0.6 → 1.0.8

package/backend/consts.js

@@ -1,5 +1,142 @@
-export const COLLECTIONS = {
+import {saveDataJobsToCMS,saveJobsDescriptionsToCMS,aggregateJobsByFieldToCMS,referenceJobsToField} from './data';
+const { createCollectionIfMissing } = require('@hisense-staging/velo-npm/backend');
+export const TASKS_NAMES = {
+    SYNC_JOBS: 'syncJobsFromSRAPIToCMS',
+    INSERT_JOBS_TO_CMS: 'insertJobsToCMS',
+    INSERT_JOBS_DESCRIPTIONS_TO_CMS: 'insertJobsDescriptionsToCMS',
+    FILL_JOBS_PER_CITY_COLLECTION: 'fillJobsPerCityCollection',
+    FILL_JOBS_PER_DEPARTMENT_COLLECTION: 'fillJobsPerDepartmentCollection',
+    REFERENCE_JOBS_TO_LOCATIONS: 'referenceJobsToLocations',
+    REFERENCE_JOBS_TO_DEPARTMENT: 'referenceJobsToDepartment',
+    CREATE_JOBS_COLLECTION: 'createJobsCollection',
+    CREATE_CITIES_COLLECTION: 'createCitiesCollection',
+    CREATE_AMOUNT_OF_JOBS_PER_DEPARTMENT_COLLECTION: 'createAmountOfJobsPerDepartmentCollection',
+}
+
+
+export 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_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),
+      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_TO_CMS]: {
+      name: TASKS_NAMES.INSERT_JOBS_DESCRIPTIONS_TO_CMS,
+      getIdentifier:()=> "SHOULD_NEVER_SKIP",
+      process:saveJobsDescriptionsToCMS,
+      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: '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: 'AmountOfJobsPerDepartment' }),
+        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: '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: 'AmountOfJobsPerDepartment', jobField: 'department' }),
+        shouldSkipCheck:()=>false,
+        estimatedDurationSec:3
+      }
+}
+
+const COLLECTIONS = {
     AMOUNT_OF_JOBS_PER_DEPARTMENT: 'AmountOfJobsPerDepartment',
     CITIES: 'cities',
     JOBS: 'Jobs',
-}
+}
+
+const COLLECTIONS_FIELDS = {
+    AMOUNT_OF_JOBS_PER_DEPARTMENT: [
+      {key:'title', type: 'TEXT'},
+      { key: 'count', type: 'NUMBER' },
+    ],
+    CITIES: [
+      {key:'title', type: 'TEXT'},
+      { key: 'regionCode', type: 'TEXT' },
+      { key: 'city', type: 'TEXT' },
+      {key:'location', type: 'OBJECT'},
+      {key:'count', type: 'NUMBER'},
+      {key:'country', type: 'TEXT'},
+      {key:'remote', type: 'TEXT'},
+      {key:'countryCode', type: 'TEXT'},
+      {key:'manual', type: 'TEXT'},      
+      {key:'region', type: 'TEXT'},
+      {key:'latitude', type: 'NUMBER'},
+      {key:'longitude', type: 'NUMBER'},
+    ],
+    JOBS: [
+        {key:'location', type: 'OBJECT'},
+        {key:'postingStatus', type: 'TEXT'},
+        {key:'country', type: 'TEXT'},
+        {key:'department', type: 'TEXT'},
+        {key:'language', type: 'TEXT'},
+        {key:'jobDescription', type: 'OBJECT'},  
+        {key:'cityText', type: 'TEXT'},         
+        {key:'departmentref', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'AmountOfJobsPerDepartment' } } },
+        {key:'city', type: 'REFERENCE', typeMetadata: { reference: { referencedCollectionId: 'cities' } } },
+    ],  
+  
+  };
+
+
+export const TASK_TYPE = {
+    SCHEDULED: 'scheduled',
+    EVENT: 'event',
+  };

package/backend/data.js

@@ -0,0 +1,288 @@
+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();
+}
+
+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`);
+
+    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}`);
+
+}
+
+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);
+        throw error;
+    }
+}
+
+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
+            };
+        });
+    }
+    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.' };
+    }
+
+    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("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;
+    }
+
+    // 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;
+    });
+
+    // Bulk update in chunks of 1000
+    const chunkSize = 1000;
+    await chunkedBulkOperation({
+        items: jobsToUpdate,
+        chunkSize,
+        processChunk: async (chunk) => {
+            await wixData.bulkUpdate("Jobs", chunk);
+        }
+    });
+
+    return { success: true, updated: jobsToUpdate.length };
+}

package/backend/fetchPositionsFromSRAPI.js

@@ -0,0 +1,109 @@
+import { fetch } from 'wix-fetch';
+
+async function makeSmartRecruitersRequest(path) {
+  // const baseUrl = 'https://api.smartrecruiters.com'; // PROD
+  const baseUrl = 'https://aoxley54.wixstudio.com/external-template/_functions'; // TEST
+    const fullUrl = `${baseUrl}${path}`;
+    //console.log(`Making request to: ${fullUrl}`);
+  try {
+    const response = await fetch(fullUrl, {
+      method: 'GET',
+      headers: {
+        'Accept-Language': 'en',
+        'accept': 'application/json',
+        'x-smarttoken': 'DCRA1-1d30ea5fe9be42d9b9ae94ff933ebef5',
+        'Cookie': 'AWSALB=GYltFw3fLKortMxHR5vIOT1CuUROyhWNIX/qL8ZnPl1/8mhOcnIsBKYslzmNJPEzSy/jvNbO+6tXpH8yqcpQJagYt57MhbKlLqTSzoNq1G/w7TjOxPGR3UTdXW0d; AWSALBCORS=GYltFw3fLKortMxHR5vIOT1CuUROyhWNIX/qL8ZnPl1/8mhOcnIsBKYslzmNJPEzSy/jvNbO+6tXpH8yqcpQJagYt57MhbKlLqTSzoNq1G/w7TjOxPGR3UTdXW0d'
+      }
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    } else {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+  } catch (error) {
+    console.error('Error making SmartRecruiters API request:', error);
+    throw error;
+  }
+}
+
+export async function fetchPositionsFromSRAPI() {
+  let allPositions = [];
+  let totalFound = 0;
+  let nextPageId = null; // Start with no page ID for the first request
+  let pageCount = 0;
+  const MAX_PAGES = 30 // Safety limit to prevent infinite loops
+
+  console.log('Starting to fetch all positions with pagination...');
+
+  do {
+    try {
+      pageCount++;
+      
+      // 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}`);
+      const response = await makeSmartRecruitersRequest(apiPath);
+      
+      // 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`);
+      }
+      
+      // Update total count from first response
+      if (pageCount === 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;
+      
+      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);
+      throw error;
+    }
+    
+    // Safety check to prevent infinite loops
+    if (pageCount >= MAX_PAGES) {
+      console.warn(`Reached maximum page limit of ${MAX_PAGES}. Stopping pagination.`);
+      break;
+    }
+  } while (nextPageId); // Continue while there's a nextPageId
+
+  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 =  {
+    totalFound: totalFound,
+    offset: 0,
+    limit: allPositions.length,
+    nextPageId: "", // Always empty since we've fetched everything
+    content: allPositions
+  };
+
+  const amountOfUniqueJobs = new Set(allPositions.map(job => job.id)).size;
+  console.log('amountOfUniqueJobs ===');
+  console.log(amountOfUniqueJobs);
+  console.log('amountOfUniqueJobs ===');
+  console.log('result ===');
+  console.log(result);
+  console.log('result ===');
+  return result;
+}
+
+export async function fetchJobDescription(jobId) {
+  return await makeSmartRecruitersRequest(`/jobs/${jobId}`);
+}

package/backend/index.js

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

package/backend/utils.js

@@ -0,0 +1,6 @@
+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);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sr-npm",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -17,7 +17,6 @@
   },
   "homepage": "https://github.com/psdevteamenterprise/sr-npm#readme",
   "dependencies": {
-    "@wix/data": "^1.0.250",
-    "@wix/essentials": "^0.1.24"
+    "@hisense-staging/velo-npm": "^3.0.10"
   }
 }

package/public/index.js

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

package/public/utils.js

@@ -1,9 +0,0 @@
-function testing() {
-    console.log("testing");
-    return "testing";
-}
-
-module.exports = {
-        testing,
-  };
-