@symbo.ls/sdk 2.33.27 → 2.33.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.33.27",
+  "version": "2.33.28",
   "type": "module",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",
@@ -46,12 +46,12 @@
     "test:user": "cross-env NODE_ENV=$NODE_ENV npx tape integration-tests/index.js integration-tests/user/*.test.js | tap-spec"
   },
   "dependencies": {
-    "@domql/element": "^2.33.27",
-    "@domql/utils": "^2.33.27",
+    "@domql/element": "^2.33.28",
+    "@domql/utils": "^2.33.28",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.33.27",
-    "@symbo.ls/socket": "^2.33.27",
+    "@symbo.ls/router": "^2.33.28",
+    "@symbo.ls/socket": "^2.33.28",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -74,5 +74,5 @@
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "305c78c0cd824b365d3e464dc3ede6b250c8baf1"
+  "gitHead": "58b2f9f34b228712ccc4352e15913c52d6007afb"
 }

package/src/services/CollabService.js

@@ -765,15 +765,7 @@ export class CollabService extends BaseService {
     const root = this._stateManager?.root
     if (root && typeof root.replace === 'function') {
       root.clients = data
-      // root.replace(
-      //   { clients: data },
-      //   {
-      //     fromSocket: true,
-      //     preventUpdate: true
-      //   }
-      // )
     }
-
     rootBus.emit('clients:updated', data)
   }
 

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-undefined */
 import test from 'tape'
 import sinon from 'sinon'
 import { PlanService } from '../../PlanService.js'
@@ -24,24 +25,33 @@ test('createPlan should return response data', async t => {
   t.end()
 })
 
-test('createPlan should return an error - Plan data is required', async t => {
-  t.plan(1)
-  const planServiceStub = new PlanService()
-  sandbox.stub(planServiceStub, '_requireReady').resolves()
-
-  try {
-    await planServiceStub.createPlan(false)
-    t.fail('createPlan should have failed')
-  } catch (err) {
-    t.equal(
-      err.toString(),
-      'Error: Plan data is required',
-      'Error correctly returned'
-    )
+function planDataValidation () {
+  const badData = {
+    falseValue: false,
+    undefinedValue: undefined,
+    stringValue: 'testString'
   }
-  sandbox.restore()
-  t.end()
-})
+  Object.keys(badData).forEach(key => {
+    test(`createPlan should return an error for ${key} - Plan data is required`, async t => {
+      t.plan(1)
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+      try {
+        await planServiceStub.createPlan(badData[key])
+        t.fail('createPlan should have failed')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Plan data is required',
+          'Error correctly returned'
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
 
 test('createPlan should return an error - Failed to parse URL', async t => {
   t.plan(1)
@@ -82,6 +92,8 @@ test('createPlan should fail the requireReady', async t => {
   sandbox.restore()
   t.end()
 })
+
+planDataValidation()
 // #endregion
 
 // #region Cleanup

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

@@ -14,8 +14,7 @@ test('createPlanWithValidation should return response data', async t => {
   const responseStub = [sandbox.stub()]
   const planData = {
     name: 'testName',
-    key: 'testkey',
-    price: 1.0
+    description: 'test description'
   }
   const planServiceStub = new PlanService()
   sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
@@ -33,6 +32,10 @@ function planDataEmptyOrNotAnObject () {
       name: 'planData is undefined',
       testValue: undefined
     },
+    planDataIsFalse: {
+      name: 'planData is false',
+      testValue: false
+    },
     planDataNotAnObject: {
       name: 'planData is not an object',
       testValue: 'Not An Object'
@@ -64,11 +67,10 @@ function requiredFieldsMissing () {
   // Data test object
   const planData = {
     name: 'testName',
-    key: 'testkey',
-    price: 1.0
+    description: 'test description'
   }
   Object.keys(planData).forEach(field => {
-    test('Basic validation for required fields should return an error - string causes Invalid plan data received', async t => {
+    test(`Required field validation for missing ${field} should return an error`, async t => {
       t.plan(1)
       const { ...testData } = planData
       delete testData[field]
@@ -91,36 +93,99 @@ function requiredFieldsMissing () {
   })
 }
 
-function priceValidation () {
-  const badPriceData = [null, undefined, 'A string', -10, {}]
-  for (let ii = 0; ii < badPriceData.length; ii++) {
-    test(`Price validation should throw an error checking for: ${badPriceData[ii]}`, async t => {
+test('Price validation should throw an error when price field is present', async t => {
+  t.plan(1)
+  const planData = {
+    name: 'testName',
+    description: 'test description',
+    price: 1.0
+  }
+  const responseStub = [sandbox.stub()]
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+  try {
+    await planServiceStub.createPlanWithValidation(planData)
+    t.fail('Price validation successfully threw an error')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.',
+      'planData validation detected unsupported price field'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+function pricingOptionsValidation () {
+  // Data test object
+  const planData = {
+    name: 'testName',
+    description: 'test description'
+  }
+
+  const badPricingOptions = {
+    stringValue: 'test string',
+    numberValue: 123,
+    booleanValue: false,
+    emptyArray: []
+  }
+  Object.keys(badPricingOptions).forEach(field => {
+    test(`pricingOptions validation throws error for ${field}`, async t => {
+      t.plan(1)
+      const { ...testData } = planData
+      testData.pricingOptions = badPricingOptions[field]
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+      try {
+        await planServiceStub.createPlanWithValidation(testData)
+        t.fail('createPlanWithValidation failed - bad pricingOptions detected')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: pricingOptions must be a non-empty array when provided',
+          `Validation failed successfully on bad pricingOptions data: ${field}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
+
+function keyTypeValidation () {
+  const badKeyData = [
+    { name: 'array value', key: [] },
+    { name: 'number value', key: 123 },
+    { name: 'null value', key: null },
+    { name: 'undefined value', key: undefined },
+    { name: 'false boolean value', key: false }
+  ]
+  for (let ii = 0; ii < badKeyData.length; ii++) {
+    test(`Key validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
-        key: 'test-key'
+        description: 'test description',
+        pricingOptions: []
       }
-      planData.price = badPriceData[ii]
+      planData.pricingOptions.push(badKeyData[ii])
       const responseStub = [sandbox.stub()]
       const planServiceStub = new PlanService()
       sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
       try {
         await planServiceStub.createPlanWithValidation(planData)
-        t.fail('Price validation successfully threw an error')
+        t.fail('Key type validation successfully threw an error')
       } catch (err) {
-        if (planData.price !== null && planData.price !== undefined) {
-          t.equal(
-            err.toString(),
-            'Error: Price must be a positive number',
-            `Price validation detected bad price data: ${planData.price}`
-          )
-        } else {
-          t.equal(
-            err.toString(),
-            "Error: Required field 'price' is missing",
-            `Price validation detected bad price data: ${planData.price}`
-          )
-        }
+        t.ok(
+          err
+            .toString()
+            .includes(
+              "Error: Pricing option at index 0 is missing required field 'key'"
+            ),
+          `Key type validation detected bad data: ${badKeyData[ii].name}`
+        )
       }
       sandbox.restore()
       t.end()
@@ -128,33 +193,72 @@ function priceValidation () {
   }
 }
 
-function keyValidation () {
+function keyFormatValidation () {
   const badKeyData = [
-    'CAPITALLETTERS',
-    'Special @ Character',
-    'under_score',
-    'syntax!'
+    { name: 'capital letters', key: 'CAPITALLETTERS' },
+    { name: 'special character', key: 'Special @ Character' },
+    { name: 'under score', key: 'under_score' },
+    { name: 'punctuation', key: 'syntax!' }
   ]
   for (let ii = 0; ii < badKeyData.length; ii++) {
-    test(`Key validation should throw an error checking for: ${badKeyData[ii]}`, async t => {
+    test(`Key validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
+      t.plan(1)
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badKeyData[ii])
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+      try {
+        await planServiceStub.createPlanWithValidation(planData)
+        t.fail('Key type validation successfully threw an error')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          `Error: Pricing option key '${badKeyData[ii].key}' must contain only lowercase letters, numbers, and hyphens`,
+          `Key format validation detected bad data: ${badKeyData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function displayNameValidation () {
+  const badDisplayNameData = [
+    {
+      name: 'false boolean value',
+      displayName: false,
+      key: 'false-boolean-value'
+    },
+    { name: 'number value', displayName: 123, key: 'number-value' },
+    { name: 'undefined value', displayName: undefined, key: 'undefined-value' },
+    { name: 'null value', displayName: null, key: 'null-value' }
+  ]
+  for (let ii = 0; ii < badDisplayNameData.length; ii++) {
+    test(`Key validation should throw an error checking for: ${badDisplayNameData[ii].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
-        key: '',
-        price: 1.0
+        description: 'test description',
+        pricingOptions: []
       }
-      planData.key += badKeyData[ii]
+      planData.pricingOptions.push(badDisplayNameData[ii])
       const responseStub = [sandbox.stub()]
       const planServiceStub = new PlanService()
       sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
       try {
         await planServiceStub.createPlanWithValidation(planData)
-        t.fail('Key validation successfully threw an error')
+        t.fail('Key type validation successfully threw an error')
       } catch (err) {
         t.equal(
           err.toString(),
-          'Error: Plan key must contain only lowercase letters, numbers, and hyphens',
-          `Key validation detected bad price data: ${planData.key}`
+          `Error: Pricing option \'${badDisplayNameData[ii].key}\' is missing required field \'displayName\'`,
+          `displayName validation detected bad data: ${badDisplayNameData[ii].name}`
         )
       }
       sandbox.restore()
@@ -163,9 +267,11 @@ function keyValidation () {
   }
 }
 
-keyValidation()
-priceValidation()
+displayNameValidation()
+keyFormatValidation()
+keyTypeValidation()
 planDataEmptyOrNotAnObject()
+pricingOptionsValidation()
 requiredFieldsMissing()
 // #endregion
 

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

@@ -8,7 +8,7 @@ const sandbox = sinon.createSandbox()
 // #endregion
 
 // #region Tests
-test.skip('updatePlanWithValidation should return response data', async t => {
+test('updatePlanWithValidation should return response data', async t => {
   t.plan(1)
   const responseStub = [sandbox.stub()]
   const testData = {
@@ -49,7 +49,7 @@ function planIdEmptyOrNotAString () {
   }
 
   Object.keys(badData).forEach(key => {
-    test.skip(`updatePlanWithValidation should return an error - ${badData[key].name}`, async t => {
+    test(`updatePlanWithValidation should return an error - ${badData[key].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
@@ -88,7 +88,7 @@ function planDataEmptyOrNotAnObject () {
   }
 
   Object.keys(badData).forEach(key => {
-    test.skip(`updatePlanWithValidation should return an error - ${badData[key].name}`, async t => {
+    test(`updatePlanWithValidation should return an error - ${badData[key].name}`, async t => {
       t.plan(1)
       const planId = 'testString'
       const planData = badData[key].testValue
@@ -112,7 +112,7 @@ function planDataEmptyOrNotAnObject () {
 function priceValidation () {
   const badPriceData = ['A string', -10, {}]
   for (let ii = 0; ii < badPriceData.length; ii++) {
-    test.skip(`Price validation should throw an error checking for: ${badPriceData[ii]}`, async t => {
+    test(`Price validation should throw an error checking for: ${badPriceData[ii]}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
@@ -174,6 +174,43 @@ function keyValidation () {
   }
 }
 
+test('getActivePlans should return active plans', async t => {
+  t.plan(3)
+  const numActivePlans = 2
+  const plansStub = [
+    {
+      plan: 'plan1',
+      active: true
+    },
+    {
+      plan: 'plan2',
+      active: false
+    },
+    {
+      plan: 'plan3',
+      active: true
+    }
+  ]
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'getPlans').resolves(plansStub)
+  const response = await planServiceStub.getActivePlans()
+  t.equal(
+    response.length,
+    numActivePlans,
+    'Correct number of active plans returned'
+  )
+  t.equal(
+    response[0].plan,
+    plansStub[0].plan,
+    'First plan successfully returned'
+  )
+  t.equal(
+    response[1].plan,
+    plansStub[2].plan,
+    'Third plan successfully returned'
+  )
+})
+
 keyValidation()
 priceValidation()
 planIdEmptyOrNotAString()