@symbo.ls/sdk 2.34.32 → 2.34.34

package/src/services/index.js

@@ -14,6 +14,7 @@ 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)
 
@@ -65,6 +66,9 @@ export const createMetricsService = config =>
 export const createIntegrationService = config =>
   createService(IntegrationService, config)
 
+export const createFeatureFlagService = config =>
+  createService(FeatureFlagService, config)
+
 export {
   AuthService,
   CollabService,
@@ -81,5 +85,6 @@ export {
   TrackingService,
   WaitlistService,
   MetricsService,
-  IntegrationService
+  IntegrationService,
+  FeatureFlagService
 }

package/src/services/tests/FeatureFlagService/adminFeatureFlags.test.js

@@ -0,0 +1,67 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FeatureFlagService } from '../../FeatureFlagService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getAdminFeatureFlags should pass includeArchived=false', async t => {
+  t.plan(1)
+  const responseStub = { success: true, data: [] }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  const requestStub = sandbox.stub(service, '_request').resolves(responseStub)
+
+  await service.getAdminFeatureFlags({ includeArchived: false })
+  t.equal(
+    requestStub.firstCall.args[0],
+    '/admin/feature-flags?includeArchived=false',
+    'includeArchived=false included'
+  )
+
+  sandbox.restore()
+  t.end()
+})
+
+test('createFeatureFlag should require key', async t => {
+  t.plan(1)
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+
+  try {
+    await service.createFeatureFlag({ enabled: true })
+    t.fail('Expected createFeatureFlag to throw without key')
+  } catch (err) {
+    t.equal(err.toString(), 'Error: Feature flag key is required', 'Key validation works')
+  }
+
+  sandbox.restore()
+  t.end()
+})
+
+test('updateFeatureFlag should require id', async t => {
+  t.plan(1)
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+
+  try {
+    await service.updateFeatureFlag(null, { enabled: false })
+    t.fail('Expected updateFeatureFlag to throw without id')
+  } catch (err) {
+    t.equal(err.toString(), 'Error: Feature flag id is required', 'Id validation works')
+  }
+
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+

package/src/services/tests/FeatureFlagService/getFeatureFlags.test.js

@@ -0,0 +1,75 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { FeatureFlagService } from '../../FeatureFlagService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getFeatureFlags should return response data', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: true,
+    data: { flags: { new_ui: { enabled: true, variant: null, payload: null } } }
+  }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  sandbox.stub(service, '_request').resolves(responseStub)
+
+  const response = await service.getFeatureFlags()
+  t.equal(response, responseStub.data, 'Response data returned')
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getFeatureFlags should pass keys query param', async t => {
+  t.plan(1)
+  const responseStub = { success: true, data: { flags: {} } }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  const requestStub = sandbox.stub(service, '_request').resolves(responseStub)
+
+  await service.getFeatureFlags({ keys: ['new_ui', 'checkout_experiment'] })
+  t.ok(
+    requestStub.firstCall.args[0].includes('/feature-flags?keys=new_ui%2Ccheckout_experiment'),
+    'Keys query param included'
+  )
+
+  sandbox.restore()
+  t.end()
+})
+
+test('getFeatureFlags should return an error', async t => {
+  t.plan(1)
+  const responseStub = {
+    success: false,
+    data: {},
+    message: 'Negative getFeatureFlags Test'
+  }
+  const service = new FeatureFlagService()
+  sandbox.stub(service, '_requireReady').resolves()
+  sandbox.stub(service, '_request').resolves(responseStub)
+
+  try {
+    await service.getFeatureFlags()
+  } catch (err) {
+    t.ok(
+      err.toString().includes(`Failed to get feature flags: ${responseStub.message}`),
+      'Error correctly returned'
+    )
+  }
+
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+

package/src/utils/services.js

@@ -321,5 +321,13 @@ export const SERVICE_METHODS = {
   listGitHubConnectors: 'integration',
   createGitHubConnector: 'integration',
   updateGitHubConnector: 'integration',
-  deleteGitHubConnector: 'integration'
+  deleteGitHubConnector: 'integration',
+
+  // Feature flag methods (system-level + experiments)
+  getFeatureFlags: 'featureFlag',
+  getFeatureFlag: 'featureFlag',
+  getAdminFeatureFlags: 'featureFlag',
+  createFeatureFlag: 'featureFlag',
+  updateFeatureFlag: 'featureFlag',
+  archiveFeatureFlag: 'featureFlag'
 }