musora-content-services 1.3.19 → 2.0.2

package/src/services/user/sessions.js

@@ -0,0 +1,67 @@
+/**
+ * @module Session-Management
+ */
+import { globalConfig } from '../config'
+import './types'
+
+/**
+ * Exported functions that are excluded from index generation.
+ *
+ * @type {string[]}
+ */
+const excludeFromGeneratedIndex = []
+
+const baseUrl = `${globalConfig.railcontentConfig.baseUrl}/api/user-management-system`
+
+/**
+ * Authenticates the User.
+ *
+ * @param {string} email - User's email
+ * @param {string} password - User's password
+ * @param {string|null} deviceName -  Device name for the user
+ * @param {string|null} deviceToken - Firebase token for the device
+ * @param {string|null} platform - Device platform
+ *
+ * @returns {Promise<AuthResponse>} - User data and authentication token
+ *
+ * @example
+ * login('john@doe.com', 'music123')
+ *   .then(content => console.log(content))
+ *   .catch(error => console.error(error));
+ */
+export async function login(email, password, deviceName, deviceToken, platform) {
+  return fetch(`${baseUrl}/v1/sessions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: null,
+    },
+    body: JSON.stringify({
+      email: email,
+      password: password,
+      device_name: deviceName,
+      device_token: deviceToken,
+      platform: platform,
+    }),
+  })
+}
+
+/**
+ * Logs the user out of the current session.
+ *
+ * @returns {Promise<void>}
+ *
+ * @example
+ * logout()
+ *   .then()
+ *   .catch(error => console.error(error));
+ */
+export async function logout() {
+  await fetch(`${baseUrl}/v1/sessions`, {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${globalConfig.railcontentConfig.authToken}`,
+      'Content-Type': 'application/json',
+    },
+  })
+}

package/src/services/user/types.js

@@ -0,0 +1,116 @@
+/**
+ * @typedef {object} BrandMethodLevels
+ * @property {string} drumeo
+ * @property {string} pianote
+ * @property {string} guitareo
+ * @property {string} singeo
+ */
+
+/**
+ * @typedef {object} BrandTotalXp
+ * @property {string} drumeo
+ * @property {string} pianote
+ * @property {string} guitareo
+ * @property {string} singeo
+ */
+
+/**
+ * @typedef {object} BrandTimePracticed
+ * @property {number} drumeo
+ * @property {number} pianote
+ * @property {number} guitareo
+ * @property {number} singeo
+ */
+
+/**
+ * @typedef {Object} User
+ * @property {number} id
+ * @property {string} email
+ * @property {string} display_name
+ * @property {string} first_name
+ * @property {string} last_name
+ * @property {string|null} gender
+ * @property {string} country
+ * @property {string|null} region
+ * @property {string|null} city
+ * @property {string} birthday
+ * @property {string|null} phone_number
+ * @property {string} profile_picture_url
+ * @property {string} timezone
+ * @property {string} permission_level
+ * @property {string} last_used_brand
+ * @property {string} membership_level
+ * @property {string|null} membership_start_date
+ * @property {string} membership_expiration_date
+ * @property {number} is_lifetime_member
+ * @property {string|null} revenuecat_origin_app_user_id
+ * @property {number} is_drumeo_lifetime_member
+ * @property {string} access_level
+ * @property {number} total_xp
+ * @property {BrandMethodLevels} brand_method_levels
+ * @property {BrandTotalXp} brand_total_xp
+ * @property {BrandTimePracticed} brand_minutes_practiced
+ * @property {BrandTimePracticed} brand_seconds_practiced
+ * @property {number|null} guitar_playing_since_year
+ * @property {number} drumeo_onboarding_skip_setup
+ * @property {number} pianote_onboarding_skip_setup
+ * @property {number} guitareo_onboarding_skip_setup
+ * @property {number} singeo_onboarding_skip_setup
+ * @property {number} drumeo_trial_section_hide
+ * @property {number} pianote_trial_section_hide
+ * @property {number} guitareo_trial_section_hide
+ * @property {number} singeo_trial_section_hide
+ * @property {number} notify_on_lesson_comment_like
+ * @property {number|null} notifications_summary_frequency_minutes
+ * @property {number} notify_on_forum_post_reply
+ * @property {number} notify_on_forum_followed_thread_reply
+ * @property {number} notify_on_forum_post_like
+ * @property {number} notify_weekly_update
+ * @property {number} notify_on_lesson_comment_reply
+ * @property {number|null} challenges_enrollment_notifications
+ * @property {number|null} challenges_community_notifications
+ * @property {number|null} challenges_solo_notifications
+ * @property {number} send_mobile_app_push_notifications
+ * @property {number} send_email_notifications
+ * @property {number} use_legacy_video_player
+ * @property {number} drumeo_ship_magazine
+ * @property {string|null} magazine_shipping_address_id
+ * @property {string|null} ios_latest_review_display_date
+ * @property {number} ios_count_review_display
+ * @property {string|null} google_latest_review_display_date
+ * @property {number} google_count_review_display
+ * @property {string|null} biography
+ * @property {string|null} support_note
+ * @property {string} created_at
+ * @property {string} updated_at
+ * @property {number} is_pack_owner
+ * @property {number} has_recharge_subscription
+ * @property {string|null} recharge_interval
+ * @property {number} has_apple_subscription
+ * @property {number} has_google_subscription
+ * @property {number} requires_password_update
+ * @property {number} cio_synced_workspaces
+ * @property {string|null} recharge_renewal_date
+ * @property {string|null} trial_expiration_date
+ * @property {number} is_trial
+ * @property {string|null} legacy_expiration_date
+ * @property {boolean} needs_logout
+ * @property {string} primary_brand
+ * @property {string} first_access_at
+ * @property {number} is_challenge_owner
+ * @property {boolean} login_as_users
+ */
+
+/**
+ * @typedef {Object} AuthResponse
+ * @property {string} token
+ * @property {User} user
+ */
+
+/**
+ * @typedef {Object} UserPermissions
+ *
+ * @property {string[]} permissions
+ * @property {boolean} isAdmin
+ * @property {boolean} isABasicMember
+ */

package/src/services/userActivity.js

@@ -0,0 +1,32 @@
+/**
+ * @module User-Activity
+ */
+
+import {fetchHandler} from "./railcontent";
+const userActivityStats = {
+    user: {
+      id: 1,
+      fullName: 'John Doe',
+      profilePictureUrl: 'https://i.pravatar.cc/300',
+    },
+    dailyActiveStats: [
+      { label: 'M', isActive: false, inStreak: false, type: 'none' },
+      { label: 'T', isActive: false, inStreak: false, type: 'none' },
+      { label: 'W', isActive: true, inStreak: true, type: 'tracked' },
+      { label: 'T', isActive: true, inStreak: true,  type: 'tracked' },
+      { label: 'F', isActive: false, inStreak: false,  type: 'none' },
+      { label: 'S', isActive: true, inStreak: false,  type: 'active' },
+      { label: 'S', isActive: false, inStreak: false, type: 'none' }
+    ],
+  currentDailyStreak: 3,
+  currentWeeklyStreak: 2,
+  streakMessage: "That's 8 weeks in a row! Way to keep your streak going.",
+};
+
+export async function getUserActivityStats(brand) {
+  return userActivityStats;
+  //return await fetchHandler(`/api/user-activity/v1/stats`);
+}
+
+
+

package/test/content.test.js

@@ -0,0 +1,116 @@
+import { initializeTestService } from './initializeTests.js'
+import {getLessonContentRows, getNewAndUpcoming, getScheduleContentRows, getTabResults} from '../src/services/content.js'
+
+describe('content', function () {
+  beforeEach(() => {
+    initializeTestService()
+  })
+
+//   test('getLessonContentRows', async () => {
+//     const results = await getLessonContentRows()
+//     console.log(results)
+//   })
+
+//   test('getTabResults-For-You', async () => {
+//     const results = await getTabResults('drumeo','lessons','For You')
+//     console.log(results)
+//     expect(results.type).toBeDefined()
+//     expect(results.type).toBe('sections')
+//     expect(results.data).toBeDefined()
+//     expect(results.meta).toBeDefined()
+//     expect(results.meta.filters).toBeDefined()
+//     expect(results.meta.sort).toBeDefined()
+//   })
+
+  test('getTabResults-Singles', async () => {
+    const results = await getTabResults('drumeo','lessons','Individuals', {selectedFilters:['difficulty,All','difficulty,Beginner'], sort:'-published_on'})
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.type).toBe('catalog')
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.meta.filters).toBeDefined()
+    expect(results.meta.sort).toBeDefined()
+  })
+
+  test('getTabResults-Courses', async () => {
+    const results = await getTabResults('pianote','lessons','Collections', {selectedFilters:['difficulty,Expert'], sort:'slug'})
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.type).toBe('catalog')
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.meta.filters).toBeDefined()
+    expect(results.meta.sort).toBeDefined()
+  })
+
+  test('getTabResults-Filters', async () => {
+    const results = await getTabResults('pianote','lessons','Explore All', {selectedFilters:['difficulty,Expert'], sort:'slug'})
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.meta.filters).toBeDefined()
+    expect(results.meta.sort).toBeDefined()
+  })
+
+  test('getTabResults-Type-Filter', async () => {
+    const results = await getTabResults('drumeo','lessons','Explore All', {selectedFilters:['type,Courses', 'type,Documentaries'], sort:'slug'})
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.meta.filters).toBeDefined()
+    expect(results.meta.sort).toBeDefined()
+  })
+
+  test('getTabResults-Type-Explore-All', async () => {
+    const results = await getTabResults('drumeo','lessons','Explore All', {selectedFilters:[], sort:'slug'})
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.meta.filters).toBeDefined()
+    expect(results.meta.sort).toBeDefined()
+  })
+
+//   test('getContentRows', async () => {
+//     const results = await getLessonContentRows('songs')
+//     console.log(results)
+//   })
+
+//   test('getTabResults-Songs-For-You', async () => {
+//     const results = await getTabResults('drumeo','songs','For You')
+//     console.log(results)
+//     expect(results.type).toBeDefined()
+//     expect(results.type).toBe('sections')
+//     expect(results.data).toBeDefined()
+//     expect(results.meta).toBeDefined()
+//     expect(results.meta.filters).toBeDefined()
+//     expect(results.meta.sort).toBeDefined()
+//   })
+  test('getNewAndUpcoming', async () => {
+    const results = await getNewAndUpcoming('drumeo')
+    console.log(results)
+    //expect(results.data).toBeDefined()
+  })
+
+  test('getScheduleContentRows', async () => {
+    const results = await getScheduleContentRows('drumeo')
+    console.log(results.data[1])
+    expect(results.type).toBeDefined()
+    expect(results.type).toBe('sections')
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+  })
+
+  test('getSpecificScheduleContentRow', async () => {
+    const results = await getScheduleContentRows('drumeo', 'Leaving-Soon')
+    console.log(results)
+    expect(results.type).toBeDefined()
+    expect(results.type).toBe('catalog')
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+  })
+
+})

package/test/contentProgress.test.js

@@ -14,9 +14,13 @@ import {
   getAllStartedOrCompleted,
 } from '../src/services/contentProgress'
 import { initializeTestService } from './initializeTests'
-import { postContentCompleted } from '../src'
+import {getLessonContentRows, postContentCompleted} from '../src'
+import {fetchRecent} from "../src/services/sanity";
+import {getRecent, getTabResults} from "../src/services/content";
+import {individualLessonsTypes, playAlongLessonTypes, transcriptionsLessonTypes, tutorialsLessonTypes} from "../src/contentTypeConfig";
 
 const railContentModule = require('../src/services/railcontent.js')
+const contentModule = require('../src/services/content.js')
 
 describe('contentProgressDataContext', function () {
   let mock = null
@@ -27,7 +31,9 @@ describe('contentProgressDataContext', function () {
     initializeTestService()
     mock = jest.spyOn(dataContext, 'fetchData')
     var json = JSON.parse(
-      `{"version":${testVersion},"config":{"key":1,"enabled":1,"checkInterval":1,"refreshInterval":2},"data":{"234191":{"s":"started","p":6,"t":20,"u":1731108082},"233955":{"s":"started","p":1,"u":1731108083},"259426":{"s":"completed","p":100,"u":1731108085}}}`
+      `{"version":${testVersion},"config":{"key":1,"enabled":1,"checkInterval":1,"refreshInterval":2},"data":{"234191":{"s":"started","p":6,"t":20,"u":1731108082},"233955":{"s":"started","p":1,"u":1731108083},
+      "259426":{"s":"completed","p":100,"u":1731108085},"190417":{"s":"started","p":6,"t":20,"u":1731108082},
+      "407665":{"s":"started","p":6,"t":20,"u":1740120139},"412986":{"s":"completed","p":100,"u":1731108085}}}`
     )
     mock.mockImplementation(() => json)
 
@@ -39,6 +45,26 @@ describe('contentProgressDataContext', function () {
 
     let mock4 = jest.spyOn(railContentModule, 'postContentReset')
     mock4.mockImplementation(() => JSON.parse(`{"version": ${serverVersion}}`))
+
+    let mock5 = jest.spyOn(contentModule, 'getContentRows')
+    let testData = [
+      {
+        id: 'recent',
+        title: 'Recent Lessons',
+        content: ['lesson1', 'lesson2', 'lesson3'],
+      },
+      {
+        id: 'popular',
+        title: 'Popular Lessons',
+        content: ['lesson4', 'lesson5', 'lesson6'],
+      },
+      {
+        id: 'new-arrivals',
+        title: 'New Arrivals',
+        content: ['lesson7', 'lesson8', 'lesson9'],
+      }
+    ];
+    mock5.mockImplementation(() => Promise.resolve(testData));
   })
 
   test('getProgressPercentage', async () => {
@@ -70,15 +96,15 @@ describe('contentProgressDataContext', function () {
 
   test('getAllStarted', async () => {
     let result = await getAllStarted()
-    expect(result).toStrictEqual([233955, 234191])
+    expect(result).toStrictEqual([407665, 233955,190417, 234191])
 
     result = await getAllStarted(1)
-    expect(result).toStrictEqual([233955])
+    expect(result).toStrictEqual([407665])
   })
 
   test('getAllStartedOrCompleted', async () => {
     let result = await getAllStartedOrCompleted()
-    expect(result).toStrictEqual([259426, 233955, 234191])
+    expect(result).toStrictEqual([407665, 259426, 412986, 233955, 190417,234191])
   })
 
   // test('getAllStartedWithUpdate', async () => {
@@ -231,4 +257,56 @@ describe('contentProgressDataContext', function () {
   //     expect(state).toBe("");
   //
   // });
+  test('getRecentLessons', async () => {
+    let result = await getRecent('drumeo','lessons', 'all',{page:1, limit:10})
+    console.log(result);
+    expect(result.data[0].id).toStrictEqual(412986)
+    expect(individualLessonsTypes).toContain(result.data[0].type)
+  })
+
+  test('getRecentLessons-Incomplete', async () => {
+    let result = await getRecent('drumeo','lessons','Incomplete')
+    console.log(result);
+    expect(result.data[0].id).toStrictEqual(407665)
+    expect(individualLessonsTypes).toContain(result.data[0].type)
+  })
+
+  test('getRecentLessons-Completed', async () => {
+    let result = await getRecent('drumeo','lessons','Completed')
+    console.log(result);
+    expect(result.data[0].id).toStrictEqual(412986)
+    expect(individualLessonsTypes).toContain(result.data[0].type)
+  })
+
+  test('get-Songs-For-You', async () => {
+    let result = await getTabResults('drumeo','songs','For You')
+    console.log(result);
+    expect(result.type).toStrictEqual('sections')
+    expect(result.data).toBeDefined()
+    expect(result.meta).toBeDefined()
+  })
+
+  test('get-Songs-Tutorials', async () => {
+    let result = await getTabResults('pianote','songs','Tutorials')
+    console.log(result);
+    expect(result.type).toStrictEqual('catalog')
+    expect(result.data).toBeDefined()
+    expect(tutorialsLessonTypes).toContain(result.data[0].type)
+  })
+
+  test('get-Songs-Transcriptions', async () => {
+    let result = await getTabResults('pianote','songs','Transcriptions')
+    console.log(result);
+    expect(result.type).toStrictEqual('catalog')
+    expect(result.data).toBeDefined()
+    expect(transcriptionsLessonTypes).toContain(result.data[0].type)
+  })
+
+  test('get-Songs-Play-Alongs', async () => {
+    let result = await getTabResults('drumeo','songs','Play-Alongs',{selectedFilters:['difficulty,Expert']})
+    console.log(result);
+    expect(playAlongLessonTypes).toContain(result.data[0].type)
+    expect(result.data[0].difficulty_string).toStrictEqual('Expert')
+  })
+
 })

package/test/forum.test.js

@@ -0,0 +1,18 @@
+import { initializeTestService } from './initializeTests.js'
+import { getLessonContentRows, getTabResults } from '../src/services/content.js'
+import {getActiveDiscussions} from "../src/services/forum";
+
+describe('forum', function () {
+  beforeEach(() => {
+    initializeTestService()
+  })
+
+  test('getActiveDiscussions', async () => {
+    const results = await getActiveDiscussions('drumeo')
+    console.log(results)
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+  })
+
+
+})

package/test/initializeTests.js

@@ -3,7 +3,7 @@ import { LocalStorageMock } from './localStorageMock'
 
 const railContentModule = require('../src/services/railcontent.js')
 let token = null
-let userId = null
+let userId = process.env.RAILCONTENT_USER_ID ?? null
 
 export async function initializeTestService(useLive = false) {
   if (useLive && !token && process.env.RAILCONTENT_BASE_URL) {
@@ -30,6 +30,11 @@ export async function initializeTestService(useLive = false) {
       authToken: token,
     },
     localStorage: new LocalStorageMock(),
+    isMA: true,
+    recommendationsConfig: {
+      token: process.env.HUGGINGFACE_TOKEN,
+      baseUrl: process.env.HUGGINGFACE_URL
+    }
   }
   initializeService(config)
 

package/test/{lastUpdated.test.js → lib/lastUpdated.test.js}

@@ -1,8 +1,5 @@
-const {
-  setLastUpdatedTime,
-  wasLastUpdateOlderThanXSeconds,
-} = require('../src/services/lastUpdated')
-const { initializeTestService } = require('./initializeTests')
+const { setLastUpdatedTime, wasLastUpdateOlderThanXSeconds } = require('../../src/lib/lastUpdated')
+const { initializeTestService } = require('../initializeTests')
 
 describe('lastUpdated', function () {
   beforeEach(() => {

package/test/sanityQueryService.test.js

@@ -1,4 +1,4 @@
-import { getFieldsForContentType } from '../src/contentTypeConfig'
+import { getFieldsForContentType} from '../src/contentTypeConfig'
 const railContentModule = require('../src/services/railcontent.js')
 
 import {
@@ -9,7 +9,7 @@ import {
 import { log } from './log.js'
 import { initializeTestService } from './initializeTests'
 import { dataContext } from '../src/services/contentProgress'
-import { fetchOwnedChallenges } from '../src'
+import {fetchOwnedChallenges, getRecommendedForYou, globalConfig, recommendations} from '../src'
 
 const {
   fetchSongById,
@@ -869,25 +869,73 @@ describe('MetaData', function () {
     drumeoMetaData.url = ''
     expect(guitareoMetaData).toStrictEqual(drumeoMetaData)
   })
+})
 
-  test('withWithoutFilters', async () => {
-    let metaData = processMetadata('singeo', 'student-review', true)
-    expect(metaData.type).toBeDefined()
-    expect(metaData.name).toBeDefined()
-    expect(metaData.description).toBeDefined()
-    expect(metaData.thumbnailUrl).toBeDefined()
+describe('v2', function () {
+  beforeEach(() => {
+    initializeTestService()
+  })
+  test('metaDataForLessons', async () => {
+    const metaData = await fetchMetadata('drumeo', 'lessons')
+    log(metaData)
+    expect(metaData.filters).toBeDefined()
+    expect(metaData.sort).toBeDefined()
     expect(metaData.tabs).toBeDefined()
-    metaData = processMetadata('singeo', 'student-review', false)
-    expect(metaData.type).toBeDefined()
-    expect(metaData.name).toBeDefined()
-    expect(metaData.description).toBeDefined()
-    expect(metaData.tabs).not.toBeDefined()
   })
 
-  test('nulled', async () => {
-    let metaData = processMetadata('drumeo', 'student-review')
-    expect(metaData).toBeNull()
-    metaData = processMetadata('singeo', 'student-review')
-    expect(metaData).not.toBeNull()
+  test('metaDataForSongs', async () => {
+    const metaData = await fetchMetadata('drumeo', 'songs')
+    log(metaData)
+    expect(metaData.filters).toBeDefined()
+    expect(metaData.sort).toBeDefined()
+    expect(metaData.tabs).toBeDefined()
+  })
+
+  test('fetchAllFilterOptionsLessons', async () => {
+    const response = await fetchAllFilterOptions(
+      'pianote',
+      [],null,null,'lessons'
+    )
+    log(response)
+    expect(response.meta.filters).toBeDefined()
+  })
+
+  test('fetchAllFilterOptionsSongs', async () => {
+    const response = await fetchAllFilterOptions(
+      'pianote',
+      [],null,null,'songs'
+    )
+    log(response)
+    expect(response.meta.filters).toBeDefined()
+  })
+
+  test('fetchLiveEvent', async () => {
+    const liveEvent = await fetchLiveEvent('drumeo', 410881)
+    log(liveEvent)
+    //expect(metaData).toBeNull()
+  })
+})
+
+describe('Recommended System', function () {
+  beforeEach(() => {
+    initializeTestService()
+  })
+
+  test('getRecommendedForYou', async () => {
+    const results = await getRecommendedForYou('drumeo')
+    log(results)
+    expect(results.id).toBeDefined()
+    expect(results.title).toBeDefined()
+    expect(results.items).toBeDefined()
+    expect(results.items.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test('getRecommendedForYou-SeeAll', async () => {
+    const results = await getRecommendedForYou('drumeo', 'recommended', {page: 1, limit:20})
+    log(results)
+    expect(results.type).toBeDefined()
+    expect(results.data).toBeDefined()
+    expect(results.meta).toBeDefined()
+    expect(results.data.length).toBeGreaterThanOrEqual(1)
   })
 })

package/test/{userPermissions.test.js → user/permissions.test.js}

@@ -1,7 +1,7 @@
-const { fetchUserPermissions } = require('../src/services/userPermissions')
-const { initializeTestService } = require('./initializeTests')
+const { fetchUserPermissions } = require('../../src/services/user/permissions')
+const { initializeTestService } = require('../initializeTests')
 
-describe('userPermissions', function () {
+describe('user.permissions', function () {
   beforeEach(() => {
     initializeTestService()
   })

package/tools/generate-index.cjs

@@ -57,15 +57,28 @@ function getExclusionList(fileContent) {
 
 // get all files in the services directory
 const servicesDir = path.join(__dirname, '../src/services')
-const files = fs.readdirSync(servicesDir)
+const treeElements = fs.readdirSync(servicesDir)
 
-files.forEach((file) => {
-  const filePath = path.join(servicesDir, file)
+function addFunctionsToFileExports(filePath, file) {
   const functionNames = extractExportedFunctions(filePath)
 
   if (functionNames.length > 0) {
     fileExports[file] = functionNames
   }
+}
+
+treeElements.forEach((treeNode) => {
+  const filePath = path.join(servicesDir, treeNode)
+
+  if (fs.lstatSync(filePath).isFile()) {
+    addFunctionsToFileExports(filePath, treeNode)
+  } else if (fs.lstatSync(filePath).isDirectory()) {
+    const subDir = fs.readdirSync(filePath)
+    subDir.forEach((subFile) => {
+      const filePath = path.join(servicesDir, treeNode, subFile)
+      addFunctionsToFileExports(filePath, treeNode + '/' + subFile)
+    })
+  }
 })
 
 // populate the index.js content string with the import/export of all functions