@symbo.ls/sdk 2.34.6 → 2.34.7

package/src/services/WaitlistService.js

@@ -0,0 +1,130 @@
+import { BaseService } from './BaseService.js'
+
+export class WaitlistService extends BaseService {
+  // ==================== WAITLIST METHODS ====================
+
+  /**
+   * Join a waitlist campaign (public).
+   *
+   * Mirrors: POST /waitlist (WaitlistController.join)
+   */
+  async joinWaitlist (data = {}) {
+    this._requireReady('joinWaitlist')
+    if (!data || typeof data !== 'object') {
+      throw new Error('Waitlist join payload is required')
+    }
+    if (!data.email) {
+      throw new Error('Email is required')
+    }
+
+    try {
+      const response = await this._request('/waitlist', {
+        method: 'POST',
+        body: JSON.stringify(data),
+        methodName: 'joinWaitlist'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to join waitlist: ${error.message}`, { cause: error })
+    }
+  }
+
+  /**
+   * List waitlist entries (admin).
+   *
+   * Mirrors: GET /waitlist (WaitlistController.list)
+   */
+  async listWaitlistEntries (options = {}) {
+    this._requireReady('listWaitlistEntries')
+
+    const {
+      campaignKey,
+      status,
+      search,
+      page,
+      limit
+    } = options || {}
+
+    const queryParams = new URLSearchParams()
+    if (campaignKey != null) { queryParams.append('campaignKey', String(campaignKey)) }
+    if (status != null) { queryParams.append('status', String(status)) }
+    if (search != null) { queryParams.append('search', String(search)) }
+    if (page != null) { queryParams.append('page', String(page)) }
+    if (limit != null) { queryParams.append('limit', String(limit)) }
+
+    const queryString = queryParams.toString()
+    const url = `/waitlist${queryString ? `?${queryString}` : ''}`
+
+    try {
+      const response = await this._request(url, {
+        method: 'GET',
+        methodName: 'listWaitlistEntries'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to list waitlist entries: ${error.message}`, { cause: error })
+    }
+  }
+
+  /**
+   * Update a waitlist entry (admin).
+   *
+   * Mirrors: PATCH /waitlist/:id (WaitlistController.update)
+   */
+  async updateWaitlistEntry (id, update = {}) {
+    this._requireReady('updateWaitlistEntry')
+    if (!id) {
+      throw new Error('Waitlist entry ID is required')
+    }
+    if (!update || typeof update !== 'object') {
+      throw new Error('Update payload is required')
+    }
+
+    try {
+      const response = await this._request(`/waitlist/${id}`, {
+        method: 'PATCH',
+        body: JSON.stringify(update),
+        methodName: 'updateWaitlistEntry'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to update waitlist entry: ${error.message}`, { cause: error })
+    }
+  }
+
+  /**
+   * Send an invitation email for a waitlist entry (admin).
+   *
+   * Mirrors: POST /waitlist/:id/invite (WaitlistController.invite)
+   */
+  async inviteWaitlistEntry (id) {
+    this._requireReady('inviteWaitlistEntry')
+    if (!id) {
+      throw new Error('Waitlist entry ID is required')
+    }
+
+    try {
+      const response = await this._request(`/waitlist/${id}/invite`, {
+        method: 'POST',
+        methodName: 'inviteWaitlistEntry'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to invite waitlist entry: ${error.message}`, { cause: error })
+    }
+  }
+}
+
+// End

package/src/services/index.js

@@ -1,4 +1,3 @@
-
 import { AuthService } from './AuthService.js'
 import { CollabService } from './CollabService.js'
 import { ProjectService } from './ProjectService.js'
@@ -12,6 +11,9 @@ import { PullRequestService } from './PullRequestService.js'
 import { AdminService } from './AdminService.js'
 import { ScreenshotService } from './ScreenshotService.js'
 import { TrackingService } from './TrackingService.js'
+import { WaitlistService } from './WaitlistService.js'
+import { MetricsService } from './MetricsService.js'
+import { IntegrationService } from './IntegrationService.js'
 
 const createService = (ServiceClass, config) => new ServiceClass(config)
 
@@ -54,6 +56,15 @@ export const createScreenshotService = config =>
 export const createTrackingService = config =>
   createService(TrackingService, config)
 
+export const createWaitlistService = config =>
+  createService(WaitlistService, config)
+
+export const createMetricsService = config =>
+  createService(MetricsService, config)
+
+export const createIntegrationService = config =>
+  createService(IntegrationService, config)
+
 export {
   AuthService,
   CollabService,
@@ -67,5 +78,8 @@ export {
   PullRequestService,
   AdminService,
   ScreenshotService,
-  TrackingService
+  TrackingService,
+  WaitlistService,
+  MetricsService,
+  IntegrationService
 }

package/src/services/tests/FileService/createFileFormData.test.js

@@ -0,0 +1,74 @@
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+
+// #region Tests
+test('createFileFormData should return a basic formData object', t => {
+  t.plan(3)
+  const mockFileData = {
+    size: 13,
+    type: 'text/*',
+    name: 'filename.txt'
+  }
+  const mockFile = new File(['file contents'], mockFileData.name, {
+    type: mockFileData.type
+  })
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.createFileFormData(mockFile)
+  t.equal(
+    Array.from(response)[0][1].size,
+    mockFileData.size,
+    'Actual file size matches expected file size'
+  )
+  t.equal(
+    Array.from(response)[0][1].type,
+    mockFileData.type,
+    'Actual file type matches expected file type'
+  )
+  t.equal(
+    Array.from(response)[0][1].name,
+    mockFileData.name,
+    'Actual file name matches expected file name'
+  )
+  t.end()
+})
+
+test('createFileFormData should return a formData object with metadata', t => {
+  t.plan(4)
+  const mockFileData = {
+    size: 13,
+    type: 'text/*',
+    name: 'filename.txt'
+  }
+  const mockFile = new File(['file contents'], mockFileData.name, {
+    type: mockFileData.type
+  })
+  const mockMetaData = {
+    name: 'Test Name',
+    description: 'Test Description',
+    key: 'Test Key'
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.createFileFormData(mockFile, mockMetaData)
+  t.equal(
+    Array.from(response)[0][1].size,
+    mockFileData.size,
+    'Actual file size matches expected file size'
+  )
+  t.equal(
+    Array.from(response)[0][1].type,
+    mockFileData.type,
+    'Actual file type matches expected file type'
+  )
+  t.equal(
+    Array.from(response)[0][1].name,
+    mockFileData.name,
+    'Actual file name matches expected file name'
+  )
+  t.equal(
+    Array.from(response)[1][1],
+    JSON.stringify(mockMetaData),
+    'Actual metadata matches expected metadata'
+  )
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/getFileUrl.test.js

@@ -0,0 +1,69 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+import { BaseService } from '../../BaseService.js'
+
+// #region Tests
+test('getFileUrl should return a good file url', t => {
+  t.plan(1)
+  const mockFileId = 'testFileId'
+  const fileServiceStub = new FileService()
+  const baseServiceStub = new BaseService()
+  const response = fileServiceStub.getFileUrl(mockFileId)
+  t.equal(
+    response,
+    `${baseServiceStub._apiUrl}/core/files/public/${mockFileId}/download`,
+    'Actual file url matches expected file url'
+  )
+  t.end()
+})
+
+function testFileIdValidation () {
+  const badData = [
+    {
+      name: 'Empty String',
+      fileId: ''
+    },
+    {
+      name: 'Undefined',
+      fileId: undefined
+    },
+    {
+      name: 'Null',
+      fileId: null
+    },
+    {
+      name: 'False boolean value',
+      fileId: false
+    },
+    {
+      name: 'True boolean value',
+      fileId: true
+    },
+    {
+      name: 'Object',
+      fileId: {}
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`fileId validation should throw an error when fileId value is: ${badData[ii].name}`, t => {
+      t.plan(1)
+      const mockFileId = null
+      const fileServiceStub = new FileService()
+      try {
+        fileServiceStub.getFileUrl(mockFileId)
+        t.fail('file ID successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: File ID is required',
+          `file ID validation successfully threw an error when fileId is: ${badData[ii].name}`
+        )
+      }
+      t.end()
+    })
+  }
+}
+
+testFileIdValidation()
+// #endregion

package/src/services/tests/FileService/uploadMultipleFiles.test.js

@@ -0,0 +1,111 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadMultipleFiles should return response data', async t => {
+  t.plan(3)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const firstMockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const secondMockFile = new File(['file contents'], 'filename1.txt', {
+    type: 'text/*'
+  })
+  const files = [firstMockFile, secondMockFile]
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadMultipleFiles(files)
+  t.equal(
+    response.length,
+    2,
+    'Actual number of uploaded files matches expected number of files'
+  )
+  t.ok(
+    response[0].success,
+    'response for first file uploaded successfully returned'
+  )
+  t.ok(
+    response[1].success,
+    'response for second file uploaded successfully returned'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('file validation should throw an error when no file is uploaded', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadMultipleFiles()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Files array is required and must not be empty',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function checkFileTypeValidation () {
+  const badData = [
+    { name: 'Number value', value: 123 },
+    { name: 'False boolean value', value: false },
+    { name: 'True boolean value', value: true },
+    { name: 'Empty String value', value: '' },
+    { name: 'Object value', value: {} },
+    { name: 'Null value', value: null },
+    { name: 'Undefined value', value: undefined }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`file validation should throw an error when: ${badData[ii].name} is uploaded`, async t => {
+      t.plan(1)
+      const uploadFileResponseStub = {
+        success: true,
+        data: 'test data response'
+      }
+      const fileServiceStub = new FileService()
+      sandbox
+        .stub(fileServiceStub, 'uploadFile')
+        .resolves(uploadFileResponseStub)
+      try {
+        await fileServiceStub.uploadMultipleFiles(badData[ii].value)
+        t.fail('file validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Files array is required and must not be empty',
+          `file validation successfully threw an error when: ${badData[ii].name} was uploaded.`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkFileTypeValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/FileService/validateFile.test.js

@@ -0,0 +1,63 @@
+import test from 'tape'
+import { FileService } from '../../FileService.js'
+
+// #region Tests
+test('validateFile should return a good file url', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile)
+  t.ok(response.length === 0, 'Empty array of errors is succesfully returned')
+  t.end()
+})
+
+test('file validation should return an error', t => {
+  t.plan(1)
+  const mockFile = false
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile)
+  t.equal(
+    response[0],
+    'File is required',
+    'File validation successfully threw an error'
+  )
+  t.end()
+})
+
+test('size validation should return an error', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const mockOptions = {
+    maxSize: 1
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile, mockOptions)
+  t.ok(
+    response[0].includes('File size (0.00MB) exceeds maximum allowed size of '),
+    'Size validation successfully threw an error'
+  )
+  t.end()
+})
+
+test('allowedTypes validation should return an error', t => {
+  t.plan(1)
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const mockOptions = {
+    allowedTypes: ['test123']
+  }
+  const fileServiceStub = new FileService()
+  const response = fileServiceStub.validateFile(mockFile, mockOptions)
+  t.equal(
+    response[0],
+    "File type 'text/*' is not allowed. Allowed types: test123",
+    'allowedTypes validation should return an error'
+  )
+  t.end()
+})
+// #endregion

package/src/services/tests/PlanService/getActivePlans.test.js

@@ -103,8 +103,6 @@ function planFilter () {
       const planServiceStub = new PlanService()
       sandbox.stub(planServiceStub, 'getPlans').resolves([badPlans[ii]])
       const response = await planServiceStub.getActivePlans()
-      console.log('&&& response: ', response)
-
       t.equal(
         response.length,
         0,

package/src/utils/services.js

@@ -293,5 +293,33 @@ export const SERVICE_METHODS = {
   flushQueue: 'tracking',
   getClient: 'tracking',
   isEnabled: 'tracking',
-  isInitialized: 'tracking'
+  isInitialized: 'tracking',
+
+  // Waitlist methods
+  joinWaitlist: 'waitlist',
+  listWaitlistEntries: 'waitlist',
+  updateWaitlistEntry: 'waitlist',
+  inviteWaitlistEntry: 'waitlist',
+
+  // Metrics methods
+  getContributions: 'metrics',
+
+  // Integration methods
+  integrationWhoami: 'integration',
+  listIntegrations: 'integration',
+  createIntegration: 'integration',
+  updateIntegration: 'integration',
+  createIntegrationApiKey: 'integration',
+  listIntegrationApiKeys: 'integration',
+  revokeIntegrationApiKey: 'integration',
+  createIntegrationWebhook: 'integration',
+  listIntegrationWebhooks: 'integration',
+  updateIntegrationWebhook: 'integration',
+  deleteIntegrationWebhook: 'integration',
+  listIntegrationWebhookDeliveries: 'integration',
+  replayIntegrationWebhookDelivery: 'integration',
+  listGitHubConnectors: 'integration',
+  createGitHubConnector: 'integration',
+  updateGitHubConnector: 'integration',
+  deleteGitHubConnector: 'integration'
 }