@symbo.ls/sdk 2.34.4 → 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/updateProjectIcon.test.js

@@ -0,0 +1,109 @@
+/* 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('updateProjectIcon should return response data', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const projectIdStub = sandbox.stub()
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  const response = await fileServiceStub.updateProjectIcon(
+    projectIdStub,
+    iconStub
+  )
+  t.equal(
+    response,
+    uploadFileResponseStub.data,
+    'Response data matches stubbed data'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('projectId validation should throw an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.updateProjectIcon(undefined, iconStub)
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Project ID and icon file are required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('iconFile validation should throw an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const projectIdStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.updateProjectIcon(projectIdStub)
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Project ID and icon file are required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('updateProjectIcon error handling catches and returns an error', async t => {
+  t.plan(1)
+  const projectIdStub = sandbox.stub()
+  const iconStub = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  sandbox.stub(fileServiceStub, '_request').throws('Test Error')
+  try {
+    await fileServiceStub.updateProjectIcon(projectIdStub, iconStub)
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to update project icon: Sinon-provided Test Error',
+      'Error handling caught and returned the correct error.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,36 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadDocument should return response data', async t => {
+  t.plan(2)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'application/pdf'
+  })
+  const fileServiceStub = new FileService()
+  const uploadFileStub = sandbox
+    .stub(fileServiceStub, 'uploadFileWithValidation')
+    .resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadImage(mockFile)
+  t.ok(response.success, 'response successfully returned')
+  t.ok(uploadFileStub.calledOnce, 'uploadFileStub called once')
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,78 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadFile should return response data', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const file = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  const response = await fileServiceStub.uploadFile(file)
+  t.equal(
+    response,
+    uploadFileResponseStub.data,
+    'Response data matches stubbed data'
+  )
+  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, '_request').resolves(uploadFileResponseStub)
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  try {
+    await fileServiceStub.uploadFile()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File is required for upload',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('uploadFile error handling catches and returns an error', async t => {
+  t.plan(1)
+  const file = sandbox.stub()
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, '_requireReady').resolves()
+  sandbox.stub(fileServiceStub, '_request').throws('Test Error')
+  try {
+    await fileServiceStub.uploadFile(file)
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File upload failed: Sinon-provided Test Error',
+      'Error handling caught and returned the correct error.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,114 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadFileWithValidation should return response data', async t => {
+  t.plan(2)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const fileServiceStub = new FileService()
+  const uploadFileStub = sandbox
+    .stub(fileServiceStub, 'uploadFile')
+    .resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadFileWithValidation(mockFile)
+  t.ok(response.success, 'response successfully returned')
+  t.ok(uploadFileStub.calledOnce, 'uploadFileStub called once')
+  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.uploadFileWithValidation()
+    t.fail('file validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: File is required',
+      'file validation successfully threw an error when no file was uploaded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('file size validation throws an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const options = {
+    maxSize: 1
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadFileWithValidation(mockFile, options)
+    t.fail('file size validation successfully threw an error')
+  } catch (err) {
+    t.ok(
+      err
+        .toString()
+        .includes('Error: File size exceeds maximum allowed size of ')
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('isValid type check throws an error', async t => {
+  t.plan(1)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'text/*'
+  })
+  const options = {
+    allowedTypes: ['test type']
+  }
+  const fileServiceStub = new FileService()
+  sandbox.stub(fileServiceStub, 'uploadFile').resolves(uploadFileResponseStub)
+  try {
+    await fileServiceStub.uploadFileWithValidation(mockFile, options)
+    t.fail('isValid check successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      "Error: File type 'text/*' is not allowed. Allowed types: test type",
+      'isValid check succeeded.'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,36 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FileService } from '../../FileService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('uploadImage should return response data', async t => {
+  t.plan(2)
+  const uploadFileResponseStub = {
+    success: true,
+    data: 'test data response'
+  }
+  const mockFile = new File(['file contents'], 'filename.txt', {
+    type: 'image/*'
+  })
+  const fileServiceStub = new FileService()
+  const uploadFileStub = sandbox
+    .stub(fileServiceStub, 'uploadFileWithValidation')
+    .resolves(uploadFileResponseStub)
+  const response = await fileServiceStub.uploadImage(mockFile)
+  t.ok(response.success, 'response successfully returned')
+  t.ok(uploadFileStub.calledOnce, 'uploadFileStub called once')
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion