@symbo.ls/sdk 3.2.3 → 3.2.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,16 +1,90 @@
-
 import { AuthService } from './AuthService.js'
-import { CoreService } from './CoreService.js'
 import { CollabService } from './CollabService.js'
+import { ProjectService } from './ProjectService.js'
+import { PlanService } from './PlanService.js'
+import { SubscriptionService } from './SubscriptionService.js'
+import { FileService } from './FileService.js'
+import { PaymentService } from './PaymentService.js'
+import { DnsService } from './DnsService.js'
+import { BranchService } from './BranchService.js'
+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'
+import { FeatureFlagService } from './FeatureFlagService.js'
 
 const createService = (ServiceClass, config) => new ServiceClass(config)
 
 // Export service creators
 export const createAuthService = config => createService(AuthService, config)
 
-export const createCoreService = config => createService(CoreService, config)
-
 export const createCollabService = config =>
   createService(CollabService, config)
 
-export { AuthService, CoreService, CollabService }
+export const createProjectService = config =>
+  createService(ProjectService, config)
+
+export const createPlanService = config =>
+  createService(PlanService, config)
+
+export const createSubscriptionService = config =>
+  createService(SubscriptionService, config)
+
+export const createFileService = config =>
+  createService(FileService, config)
+
+export const createPaymentService = config =>
+  createService(PaymentService, config)
+
+export const createDnsService = config =>
+  createService(DnsService, config)
+
+export const createBranchService = config =>
+  createService(BranchService, config)
+
+export const createPullRequestService = config =>
+  createService(PullRequestService, config)
+
+export const createAdminService = config =>
+  createService(AdminService, config)
+
+export const createScreenshotService = config =>
+  createService(ScreenshotService, 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 const createFeatureFlagService = config =>
+  createService(FeatureFlagService, config)
+
+export {
+  AuthService,
+  CollabService,
+  ProjectService,
+  PlanService,
+  SubscriptionService,
+  FileService,
+  PaymentService,
+  DnsService,
+  BranchService,
+  PullRequestService,
+  AdminService,
+  ScreenshotService,
+  TrackingService,
+  WaitlistService,
+  MetricsService,
+  IntegrationService,
+  FeatureFlagService
+}

package/src/services/tests/BranchService/createBranch.test.js

@@ -0,0 +1,153 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { BranchService } from '../../BranchService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('createBranch should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name',
+    source: 'main'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.createBranch(
+    testProjectId,
+    branchDataMock
+  )
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+function checkProjectIdValidation () {
+  const badData = [
+    {
+      testName: 'No Project ID'
+    },
+    {
+      testName: 'Empty string',
+      projectId: ''
+    },
+    {
+      testName: 'False boolean value',
+      projectId: false
+    },
+    {
+      testName: 'Undefined value',
+      projectId: undefined
+    },
+    {
+      testName: 'Null value',
+      projectId: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Project ID validation should throw an error when: ${badData[ii].testName} is passed in`, async t => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const branchDataMock = {
+        name: 'Test_Branch_Name',
+        source: 'main'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.createBranch(testProjectId, branchDataMock)
+        t.fail('Project ID validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Project ID is required',
+          `Project ID validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkBranchDataNameValidation () {
+  const badData = [
+    {
+      testName: 'No name'
+    },
+    {
+      testName: 'Empty string',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Undefined value',
+      name: undefined
+    },
+    {
+      testName: 'Null value',
+      name: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Branch name validation should throw an error when: ${badData[ii].testName} is passed in`, async t => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const branchName = {
+        name: badData[ii].name,
+        source: 'main'
+      }
+      const testProjectId = 'Test Project ID'
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.createBranch(testProjectId, branchName)
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/BranchService/deleteBranch.test.js

@@ -0,0 +1,173 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { BranchService } from '../../BranchService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('deleteBranch should return response data', async t => {
+  t.plan(2)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name',
+    branch: 'not_main'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.deleteBranch(
+    testProjectId,
+    branchDataMock.branch
+  )
+  t.ok(response.success, 'Response successfully returned')
+  t.equal(
+    response.data,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+test('Branch name validation should throw an error when the branch is main', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  try {
+    await branchServiceStub.deleteBranch('Test Project ID', 'main')
+    t.fail('Branch name validation threw an error with an invalid value')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Cannot delete main branch',
+      'deleteBranch successfully threw an error when the main branch is deleted'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function checkProjectIdValidation () {
+  const badData = [
+    {
+      testName: 'No Project ID'
+    },
+    {
+      testName: 'Empty string',
+      projectId: ''
+    },
+    {
+      testName: 'False boolean value',
+      projectId: false
+    },
+    {
+      testName: 'Undefined value',
+      projectId: undefined
+    },
+    {
+      testName: 'Null value',
+      projectId: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Project ID validation should throw an error when: ${badData[ii].testName} is passed in`, async t => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const branchDataMock = {
+        name: 'Test_Branch_Name',
+        branch: 'not_main'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.deleteBranch(testProjectId, branchDataMock)
+        t.fail('Project ID validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Project ID is required',
+          `Project ID validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkBranchDataNameValidation () {
+  const badData = [
+    {
+      testName: 'No name'
+    },
+    {
+      testName: 'Empty string',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Undefined value',
+      name: undefined
+    },
+    {
+      testName: 'Null value',
+      name: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Branch name validation should throw an error when: ${badData[ii].testName} is passed in`, async t => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const testProjectId = 'Test Project ID'
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.deleteBranch(testProjectId, badData[ii].name)
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

package/src/services/tests/BranchService/getBranchChanges.test.js

@@ -0,0 +1,146 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { BranchService } from '../../BranchService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getBranchChanges should return response data', async (t) => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: 'Test data response'
+  }
+  const branchDataMock = {
+    name: 'Test_Branch_Name'
+  }
+  const testProjectId = 'Test Project ID'
+  const branchServiceStub = new BranchService()
+  sandbox.stub(branchServiceStub, '_requireReady').resolves()
+  sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+  const response = await branchServiceStub.getBranchChanges(
+    testProjectId,
+    branchDataMock.name
+  )
+  t.equal(
+    response,
+    responseStub.data,
+    'Actual response matches expected response'
+  )
+  sandbox.restore()
+  t.end()
+})
+
+function checkProjectIdValidation () {
+  const badData = [
+    {
+      testName: 'No Project ID'
+    },
+    {
+      testName: 'Empty string',
+      projectId: ''
+    },
+    {
+      testName: 'False boolean value',
+      projectId: false
+    },
+    {
+      testName: 'Undefined value',
+      projectId: undefined
+    },
+    {
+      testName: 'Null value',
+      projectId: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Project ID validation should throw an error when: ${badData[ii].testName} is passed in`, async (t) => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const branchDataMock = {
+        name: 'Test_Branch_Name'
+      }
+      const testProjectId = badData[ii].projectId
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.getBranchChanges(
+          testProjectId,
+          branchDataMock.name
+        )
+        t.fail('Project ID validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Project ID is required',
+          `Project ID validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function checkBranchDataNameValidation () {
+  const badData = [
+    {
+      testName: 'Empty string',
+      name: ''
+    },
+    {
+      testName: 'False boolean value',
+      name: false
+    },
+    {
+      testName: 'Null value',
+      name: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`Branch name validation should throw an error when: ${badData[ii].testName} is passed in`, async (t) => {
+      t.plan(1)
+      const responseStub = {
+        success: true,
+        data: 'Test data response'
+      }
+      const testProjectId = 'Test Project ID'
+      const branchServiceStub = new BranchService()
+      sandbox.stub(branchServiceStub, '_requireReady').resolves()
+      sandbox.stub(branchServiceStub, '_request').resolves(responseStub)
+      try {
+        await branchServiceStub.getBranchChanges(
+          testProjectId,
+          badData[ii].name
+        )
+        t.fail('Branch name validation threw an error with an invalid value')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Branch name is required',
+          `Branch name validation successfully threw an error with: ${badData[ii].testName}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+checkBranchDataNameValidation()
+checkProjectIdValidation()
+// #endregion
+
+// #region Cleanup
+test('teardown', (t) => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion