@symbo.ls/sdk 2.33.41 → 2.34.0

package/dist/node/services/PlanService.js

@@ -270,6 +270,9 @@ class PlanService extends BaseService {
         }
       });
     }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         "Plan key must contain only lowercase letters, numbers, and hyphens"
@@ -324,7 +327,7 @@ class PlanService extends BaseService {
             `Pricing option '${key}' must have a non-negative numeric 'amount'`
           );
         }
-        if (interval != null && !allowedIntervals.has(interval)) {
+        if (interval !== null && !allowedIntervals.has(interval)) {
           throw new Error(
             `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
           );
@@ -336,6 +339,9 @@ class PlanService extends BaseService {
         }
       });
     }
+    if (Object.hasOwn(planData, "key") && planData.key == null) {
+      throw new Error("Plan key must be a valid string");
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         "Plan key must contain only lowercase letters, numbers, and hyphens"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.33.41",
+  "version": "2.34.0",
   "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.41",
-    "@domql/utils": "^2.33.41",
+    "@domql/element": "^2.34.0",
+    "@domql/utils": "^2.34.0",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.33.41",
-    "@symbo.ls/socket": "^2.33.41",
+    "@symbo.ls/router": "^2.34.0",
+    "@symbo.ls/socket": "^2.34.0",
     "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": "1dffcfb13a8308462abc598b71292a2f58dc58f5"
+  "gitHead": "36ad7eff7cf19c4b684e754e04fa80c88448c3aa"
 }

package/src/services/PlanService.js

@@ -305,6 +305,9 @@ export class PlanService extends BaseService {
     }
 
     // Optional: validate top-level key if provided (legacy support)
+    if (Object.hasOwn(planData, 'key') && planData.key == null) {
+      throw new Error('Plan key must be a valid string')
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         'Plan key must contain only lowercase letters, numbers, and hyphens'
@@ -376,7 +379,7 @@ export class PlanService extends BaseService {
           )
         }
 
-        if (interval != null && !allowedIntervals.has(interval)) {
+        if (interval !== null && !allowedIntervals.has(interval)) {
           throw new Error(
             `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
           )
@@ -391,6 +394,9 @@ export class PlanService extends BaseService {
     }
 
     // Validate key format if provided
+    if (Object.hasOwn(planData, 'key') && planData.key == null) {
+      throw new Error('Plan key must be a valid string')
+    }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error(
         'Plan key must contain only lowercase letters, numbers, and hyphens'

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

@@ -84,7 +84,7 @@ function requiredFieldsMissing () {
         t.equal(
           err.toString(),
           `Error: Required field \'${field}\' is missing`,
-          `Validation failed on required field: ${field} successfully`
+          `Required field validation failed on required field: ${field} successfully`
         )
       }
       sandbox.restore()
@@ -110,7 +110,7 @@ test('Price validation should throw an error when price field is present', async
     t.equal(
       err.toString(),
       'Error: Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.',
-      'planData validation detected unsupported price field'
+      'Price validation detected unsupported price field'
     )
   }
   sandbox.restore()
@@ -145,7 +145,7 @@ function pricingOptionsValidation () {
         t.equal(
           err.toString(),
           'Error: pricingOptions must be a non-empty array when provided',
-          `Validation failed successfully on bad pricingOptions data: ${field}`
+          `pricingOptions validation failed successfully on bad pricingOptions data: ${field}`
         )
       }
       sandbox.restore()
@@ -163,7 +163,7 @@ function keyTypeValidation () {
     { 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 => {
+    test(`Key type validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
@@ -201,7 +201,7 @@ function keyFormatValidation () {
     { name: 'punctuation', key: 'syntax!' }
   ]
   for (let ii = 0; ii < badKeyData.length; ii++) {
-    test(`Key validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
+    test(`Key format validation should throw an error checking for: ${badKeyData[ii].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
@@ -240,7 +240,7 @@ function displayNameValidation () {
     { 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 => {
+    test(`displayName validation should throw an error checking for: ${badDisplayNameData[ii].name}`, async t => {
       t.plan(1)
       const planData = {
         name: 'testName',
@@ -313,7 +313,7 @@ function amountValidation () {
         t.equal(
           err.toString(),
           `Error: Pricing option \'${badAmountData[ii].key}\' must have a non-negative numeric \'amount\'`,
-          `displayName validation detected bad data: ${badAmountData[ii].name}`
+          `amount validation detected bad data: ${badAmountData[ii].name}`
         )
       }
       sandbox.restore()
@@ -365,8 +365,8 @@ function intervalValidation () {
         t.equal(
           err.toString(),
           `Error: Pricing option \'${badAmountData[ii].key}\' has invalid interval \'${badAmountData[ii].interval}\'. Allowed: month, year, week, day or null`,
-          `displayName validation detected bad data: ${badAmountData[ii].name}`
-        ) // `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          `interval validation detected bad data: ${badAmountData[ii].name}`
+        )
       }
       sandbox.restore()
       t.end()
@@ -375,7 +375,132 @@ function intervalValidation () {
 }
 
 function lookupKeyValidation () {
-  // TODO interval unit tests line 268
+  const badData = [
+    {
+      name: 'number value',
+      displayName: 'test displayname',
+      key: 'number-amount-value',
+      amount: 0,
+      interval: null,
+      lookupKey: 123
+    },
+    {
+      name: 'false boolean value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 0,
+      interval: null,
+      lookupKey: false
+    },
+    {
+      name: 'true boolean value',
+      displayName: 'test displayname',
+      key: 'letter-value',
+      amount: 0,
+      interval: null,
+      lookupKey: true
+    },
+    {
+      name: 'object value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: {}
+    },
+    {
+      name: 'undefined value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: undefined
+    },
+    {
+      name: 'null value',
+      displayName: 'test displayname',
+      key: 'undefined-value',
+      amount: 0,
+      interval: null,
+      lookupKey: null
+    }
+  ]
+  for (let ii = 0; ii < badData.length; ii++) {
+    test(`lookup key validation should throw an error checking for: ${badData[ii].name}`, async t => {
+      t.plan(1)
+      const planData = {
+        name: 'testName',
+        description: 'test description',
+        pricingOptions: []
+      }
+      planData.pricingOptions.push(badData[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 \'${badData[ii].key}\' is missing required field \'lookupKey\'`,
+          `lookup key validation detected bad data: ${badData[ii].name}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function topLevelKeyValidation () {
+  const planData = [
+    {
+      name: 'Uppercase letters',
+      description: 'test description',
+      key: 'ALLCAPS'
+    },
+    {
+      name: 'Underscore character',
+      description: 'test description',
+      key: '_'
+    },
+    {
+      name: 'Special characters',
+      description: 'test description',
+      key: '!@#$%'
+    },
+    {
+      name: 'Object type',
+      description: 'test description',
+      key: {}
+    },
+    {
+      name: 'Null value',
+      description: 'test description',
+      key: null
+    }
+  ]
+  for (let ii = 0; ii < planData.length; ii++) {
+    test(`top-level key validation should throw an error checking for: ${planData[ii].name}`, async t => {
+      t.plan(1)
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+      try {
+        await planServiceStub.createPlanWithValidation(planData[ii])
+        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',
+          `displayName validation detected bad data: ${planData[ii].name} with ${err}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
 }
 
 amountValidation()
@@ -383,9 +508,11 @@ displayNameValidation()
 intervalValidation()
 keyFormatValidation()
 keyTypeValidation()
+lookupKeyValidation()
 planDataEmptyOrNotAnObject()
 pricingOptionsValidation()
 requiredFieldsMissing()
+topLevelKeyValidation()
 // #endregion
 
 // #region Cleanup

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

@@ -0,0 +1,125 @@
+/* eslint-disable no-undefined */
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('getActivePlans should return active plans', async t => {
+  t.plan(3)
+  const numActivePlans = 2
+  const plansStub = [
+    {
+      plan: 'plan1',
+      status: 'active',
+      isVisible: true
+    },
+    {
+      plan: 'plan2',
+      status: 'inactive',
+      isVisible: false
+    },
+    {
+      plan: 'plan3',
+      status: 'active',
+      isVisible: 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'
+  )
+})
+
+function planFilter () {
+  const badPlans = [
+    {
+      plan: 'status is inactive and isVisible is false',
+      status: 'inactive',
+      isVisible: false
+    },
+    {
+      plan: 'status is active and isVisible is false',
+      status: 'active',
+      isVisible: false
+    },
+    {
+      plan: 'status is undefined and isVisible is true',
+      status: undefined,
+      isVisible: true
+    },
+    {
+      plan: 'status is undefined and isVisible is false',
+      status: undefined,
+      isVisible: false
+    },
+    {
+      plan: 'status is null and isVisible is true',
+      status: null,
+      isVisible: true
+    },
+    {
+      plan: 'status is null and isVisible is false',
+      status: null,
+      isVisible: false
+    },
+    {
+      plan: 'status is active and isVisible is undefined',
+      status: 'active',
+      isVisible: undefined
+    },
+    {
+      plan: 'status is active and isVisible is null',
+      status: 'active',
+      isVisible: null
+    },
+    {
+      plan: 'status is a number and isVisible is true',
+      status: 123,
+      isVisible: true
+    }
+  ]
+  for (let ii = 0; ii < badPlans.length; ii++) {
+    test(`getActivePlans should return no plans using ${badPlans[ii].plan}`, async t => {
+      t.plan(1)
+      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,
+        `No active plans returned when ${badPlans[ii].plan}`
+      )
+    })
+  }
+}
+
+planFilter()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion