@symbo.ls/sdk 2.33.26 → 2.33.27

package/dist/node/services/PlanService.js

@@ -18,6 +18,23 @@ class PlanService extends BaseService {
       throw new Error(`Failed to get plans: ${error.message}`, { cause: error });
     }
   }
+  /**
+   * Get list of public plans with enhanced pricing information (no authentication required)
+   */
+  async getPlansWithPricing() {
+    try {
+      const response = await this._request("/plans/pricing", {
+        method: "GET",
+        methodName: "getPlansWithPricing"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get plans with pricing: ${error.message}`, { cause: error });
+    }
+  }
   /**
    * Get a specific plan by ID (no authentication required)
    */
@@ -182,16 +199,48 @@ class PlanService extends BaseService {
     if (!planData || typeof planData !== "object") {
       throw new Error("Plan data must be a valid object");
     }
-    const requiredFields = ["name", "key", "price"];
+    const requiredFields = ["name", "description"];
     for (const field of requiredFields) {
       if (!planData[field]) {
         throw new Error(`Required field '${field}' is missing`);
       }
     }
-    if (typeof planData.price !== "number" || planData.price < 0) {
-      throw new Error("Price must be a positive number");
+    if (Object.hasOwn(planData, "price")) {
+      throw new Error('Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.');
+    }
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error("pricingOptions must be a non-empty array when provided");
+      }
+      const allowedIntervals = /* @__PURE__ */ new Set(["month", "year", "week", "day", null]);
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== "object") {
+          throw new Error(`Pricing option at index ${index} must be an object`);
+        }
+        const { key, displayName, amount, interval, lookupKey } = option;
+        if (!key || typeof key !== "string") {
+          throw new Error(`Pricing option at index ${index} is missing required field 'key'`);
+        }
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(`Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`);
+        }
+        if (!displayName || typeof displayName !== "string") {
+          throw new Error(`Pricing option '${key}' is missing required field 'displayName'`);
+        }
+        if (typeof amount !== "number" || amount < 0) {
+          throw new Error(`Pricing option '${key}' must have a non-negative numeric 'amount'`);
+        }
+        if (interval != null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          );
+        }
+        if (!lookupKey || typeof lookupKey !== "string") {
+          throw new Error(`Pricing option '${key}' is missing required field 'lookupKey'`);
+        }
+      });
     }
-    if (!/^[a-z0-9-]+$/u.test(planData.key)) {
+    if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error("Plan key must contain only lowercase letters, numbers, and hyphens");
     }
     return await this.createPlan(planData);
@@ -206,10 +255,40 @@ class PlanService extends BaseService {
     if (!planData || typeof planData !== "object") {
       throw new Error("Plan data must be a valid object");
     }
-    if (planData.price != null) {
-      if (typeof planData.price !== "number" || planData.price < 0) {
-        throw new Error("Price must be a positive number");
+    if (Object.hasOwn(planData, "price")) {
+      throw new Error('Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.');
+    }
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error("pricingOptions must be a non-empty array when provided");
       }
+      const allowedIntervals = /* @__PURE__ */ new Set(["month", "year", "week", "day", null]);
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== "object") {
+          throw new Error(`Pricing option at index ${index} must be an object`);
+        }
+        const { key, displayName, amount, interval, lookupKey } = option;
+        if (!key || typeof key !== "string") {
+          throw new Error(`Pricing option at index ${index} is missing required field 'key'`);
+        }
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(`Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`);
+        }
+        if (!displayName || typeof displayName !== "string") {
+          throw new Error(`Pricing option '${key}' is missing required field 'displayName'`);
+        }
+        if (typeof amount !== "number" || amount < 0) {
+          throw new Error(`Pricing option '${key}' must have a non-negative numeric 'amount'`);
+        }
+        if (interval != null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          );
+        }
+        if (!lookupKey || typeof lookupKey !== "string") {
+          throw new Error(`Pricing option '${key}' is missing required field 'lookupKey'`);
+        }
+      });
     }
     if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error("Plan key must contain only lowercase letters, numbers, and hyphens");
@@ -222,7 +301,7 @@ class PlanService extends BaseService {
   async getActivePlans() {
     try {
       const plans = await this.getPlans();
-      return plans.filter((plan) => plan.active !== false);
+      return plans.filter((plan) => plan.status === "active" && plan.isVisible !== false);
     } catch (error) {
       throw new Error(`Failed to get active plans: ${error.message}`, { cause: error });
     }
@@ -232,9 +311,10 @@ class PlanService extends BaseService {
    */
   async getPlansByPriceRange(minPrice = 0, maxPrice = Infinity) {
     try {
-      const plans = await this.getPlans();
+      const plans = await this.getPlansWithPricing();
       return plans.filter((plan) => {
-        const price = plan.price || 0;
+        var _a, _b;
+        const price = ((_b = (_a = plan == null ? void 0 : plan.pricing) == null ? void 0 : _a.bestPrice) == null ? void 0 : _b.amount) ?? 0;
         return price >= minPrice && price <= maxPrice;
       });
     } catch (error) {

package/dist/node/utils/services.js

@@ -115,6 +115,7 @@ const SERVICE_METHODS = {
   getActivePlans: "plan",
   getPlansByPriceRange: "plan",
   getPlanByKey: "plan",
+  getPlansWithPricing: "plan",
   // Subscription methods (moved to subscription service)
   createSubscription: "subscription",
   getProjectStatus: "subscription",
@@ -164,7 +165,6 @@ const SERVICE_METHODS = {
   createDnsRecordWithValidation: "dns",
   getDnsRecordWithValidation: "dns",
   removeDnsRecordWithValidation: "dns",
-  setProjectDomainsWithValidation: "dns",
   addProjectCustomDomainsWithValidation: "dns",
   isDomainAvailable: "dns",
   getDomainStatus: "dns",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.33.26",
+  "version": "2.33.27",
   "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.26",
-    "@domql/utils": "^2.33.26",
+    "@domql/element": "^2.33.27",
+    "@domql/utils": "^2.33.27",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.33.26",
-    "@symbo.ls/socket": "^2.33.26",
+    "@symbo.ls/router": "^2.33.27",
+    "@symbo.ls/socket": "^2.33.27",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -69,9 +69,10 @@
     "esbuild-plugins-node-modules-polyfill": "^1.6.8",
     "glob": "^11.0.0",
     "jsdom": "^26.1.0",
+    "sinon": "^21.0.0",
     "tap-parser": "^18.0.0",
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "60d701cca225200ddb1e15d6a3a31da25dfc3bc0"
+  "gitHead": "305c78c0cd824b365d3e464dc3ede6b250c8baf1"
 }

package/src/services/PlanService.js

@@ -21,6 +21,24 @@ export class PlanService extends BaseService {
     }
   }
 
+  /**
+   * Get list of public plans with enhanced pricing information (no authentication required)
+   */
+  async getPlansWithPricing () {
+    try {
+      const response = await this._request('/plans/pricing', {
+        method: 'GET',
+        methodName: 'getPlansWithPricing'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get plans with pricing: ${error.message}`, { cause: error })
+    }
+  }
+
   /**
    * Get a specific plan by ID (no authentication required)
    */
@@ -197,21 +215,64 @@ export class PlanService extends BaseService {
       throw new Error('Plan data must be a valid object')
     }
 
-    // Basic validation for required fields
-    const requiredFields = ['name', 'key', 'price']
+    // Basic validation for required fields to match server model
+    const requiredFields = ['name', 'description']
     for (const field of requiredFields) {
       if (!planData[field]) {
         throw new Error(`Required field '${field}' is missing`)
       }
     }
 
-    // Validate price is a positive number
-    if (typeof planData.price !== 'number' || planData.price < 0) {
-      throw new Error('Price must be a positive number')
+    // Legacy field guard: bare "price" is no longer supported on the server
+    if (Object.hasOwn(planData, 'price')) {
+      throw new Error('Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.')
+    }
+
+    // Validate unified pricingOptions structure if provided
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error('pricingOptions must be a non-empty array when provided')
+      }
+
+      const allowedIntervals = new Set(['month', 'year', 'week', 'day', null])
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== 'object') {
+          throw new Error(`Pricing option at index ${index} must be an object`)
+        }
+
+        const { key, displayName, amount, interval, lookupKey } = option
+
+        if (!key || typeof key !== 'string') {
+          throw new Error(`Pricing option at index ${index} is missing required field 'key'`)
+        }
+
+        // Validate key format (alphanumeric and hyphens only)
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(`Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`)
+        }
+
+        if (!displayName || typeof displayName !== 'string') {
+          throw new Error(`Pricing option '${key}' is missing required field 'displayName'`)
+        }
+
+        if (typeof amount !== 'number' || amount < 0) {
+          throw new Error(`Pricing option '${key}' must have a non-negative numeric 'amount'`)
+        }
+
+        if (interval != null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          )
+        }
+
+        if (!lookupKey || typeof lookupKey !== 'string') {
+          throw new Error(`Pricing option '${key}' is missing required field 'lookupKey'`)
+        }
+      })
     }
 
-    // Validate key format (alphanumeric and hyphens only)
-    if (!/^[a-z0-9-]+$/u.test(planData.key)) {
+    // Optional: validate top-level key if provided (legacy support)
+    if (planData.key && !/^[a-z0-9-]+$/u.test(planData.key)) {
       throw new Error('Plan key must contain only lowercase letters, numbers, and hyphens')
     }
 
@@ -229,11 +290,52 @@ export class PlanService extends BaseService {
       throw new Error('Plan data must be a valid object')
     }
 
-    // Validate price if provided
-    if (planData.price != null) {
-      if (typeof planData.price !== 'number' || planData.price < 0) {
-        throw new Error('Price must be a positive number')
+    // Legacy field guard: bare "price" is no longer supported on the server
+    if (Object.hasOwn(planData, 'price')) {
+      throw new Error('Field "price" is no longer supported. Use unified "pricingOptions" with "amount" instead.')
+    }
+
+    // Validate unified pricingOptions structure if provided
+    if (planData.pricingOptions != null) {
+      if (!Array.isArray(planData.pricingOptions) || planData.pricingOptions.length === 0) {
+        throw new Error('pricingOptions must be a non-empty array when provided')
       }
+
+      const allowedIntervals = new Set(['month', 'year', 'week', 'day', null])
+      planData.pricingOptions.forEach((option, index) => {
+        if (!option || typeof option !== 'object') {
+          throw new Error(`Pricing option at index ${index} must be an object`)
+        }
+
+        const { key, displayName, amount, interval, lookupKey } = option
+
+        if (!key || typeof key !== 'string') {
+          throw new Error(`Pricing option at index ${index} is missing required field 'key'`)
+        }
+
+        // Validate key format (alphanumeric and hyphens only)
+        if (!/^[a-z0-9-]+$/u.test(key)) {
+          throw new Error(`Pricing option key '${key}' must contain only lowercase letters, numbers, and hyphens`)
+        }
+
+        if (!displayName || typeof displayName !== 'string') {
+          throw new Error(`Pricing option '${key}' is missing required field 'displayName'`)
+        }
+
+        if (typeof amount !== 'number' || amount < 0) {
+          throw new Error(`Pricing option '${key}' must have a non-negative numeric 'amount'`)
+        }
+
+        if (interval != null && !allowedIntervals.has(interval)) {
+          throw new Error(
+            `Pricing option '${key}' has invalid interval '${interval}'. Allowed: month, year, week, day or null`
+          )
+        }
+
+        if (!lookupKey || typeof lookupKey !== 'string') {
+          throw new Error(`Pricing option '${key}' is missing required field 'lookupKey'`)
+        }
+      })
     }
 
     // Validate key format if provided
@@ -250,7 +352,9 @@ export class PlanService extends BaseService {
   async getActivePlans () {
     try {
       const plans = await this.getPlans()
-      return plans.filter(plan => plan.active !== false)
+      // Server already returns only active & visible plans for /plans,
+      // but we keep this helper aligned with the model fields.
+      return plans.filter(plan => plan.status === 'active' && plan.isVisible !== false)
     } catch (error) {
       throw new Error(`Failed to get active plans: ${error.message}`, { cause: error })
     }
@@ -261,9 +365,10 @@ export class PlanService extends BaseService {
    */
   async getPlansByPriceRange (minPrice = 0, maxPrice = Infinity) {
     try {
-      const plans = await this.getPlans()
+      // Use enhanced pricing information from /plans/pricing
+      const plans = await this.getPlansWithPricing()
       return plans.filter(plan => {
-        const price = plan.price || 0
+        const price = plan?.pricing?.bestPrice?.amount ?? 0
         return price >= minPrice && price <= maxPrice
       })
     } catch (error) {

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

@@ -0,0 +1,92 @@
+import test from 'tape'
+import sinon from 'sinon'
+import { PlanService } from '../../PlanService.js'
+
+// #region Setup
+const sandbox = sinon.createSandbox()
+// #endregion
+
+// #region Tests
+test('createPlan should return response data', async t => {
+  t.plan(1)
+
+  const planDataStub = {
+    success: true,
+    data: sandbox.stub()
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_request').resolves(planDataStub)
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+  const response = await planServiceStub.createPlan([])
+  t.equal(response, planDataStub.data, 'Response data returned')
+
+  sandbox.restore()
+  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'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('createPlan should return an error - Failed to parse URL', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, '_requireReady').resolves()
+
+  try {
+    await planServiceStub.createPlan([])
+    t.fail('createPlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Failed to create plan: Request failed: Failed to parse URL from null/core/admin/plans',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+
+test('createPlan should fail the requireReady', async t => {
+  t.plan(1)
+  const planServiceStub = new PlanService()
+  sandbox
+    .stub(planServiceStub, '_requireReady')
+    .throws(() => new Error('Service not initialized for method: createPlan'))
+
+  try {
+    await planServiceStub.createPlan()
+    t.fail('createPlan should have failed')
+  } catch (err) {
+    t.equal(
+      err.toString(),
+      'Error: Service not initialized for method: createPlan',
+      'Error correctly returned'
+    )
+  }
+  sandbox.restore()
+  t.end()
+})
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion

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

@@ -0,0 +1,177 @@
+/* eslint-disable no-useless-escape */
+/* 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('createPlanWithValidation should return response data', async t => {
+  t.plan(1)
+  const responseStub = [sandbox.stub()]
+  const planData = {
+    name: 'testName',
+    key: 'testkey',
+    price: 1.0
+  }
+  const planServiceStub = new PlanService()
+  sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+  const response = await planServiceStub.createPlanWithValidation(planData)
+  t.ok(response, 'Response returned successfully')
+
+  sandbox.restore()
+  t.end()
+})
+
+function planDataEmptyOrNotAnObject () {
+  // Data test object
+  const badData = {
+    planDataUndefined: {
+      name: 'planData is undefined',
+      testValue: undefined
+    },
+    planDataNotAnObject: {
+      name: 'planData is not an object',
+      testValue: 'Not An Object'
+    }
+  }
+
+  Object.keys(badData).forEach(key => {
+    test(`createPlanWithValidation should return an error - ${badData[key].name}`, async t => {
+      t.plan(1)
+      const planData = badData[key].testValue
+      const planServiceStub = new PlanService()
+      try {
+        await planServiceStub.createPlanWithValidation(planData)
+        t.fail('createPlanWithValidation should have failed')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          'Error: Plan data must be a valid object',
+          `${badData[key].name} successfully caused an error`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
+
+function requiredFieldsMissing () {
+  // Data test object
+  const planData = {
+    name: 'testName',
+    key: 'testkey',
+    price: 1.0
+  }
+  Object.keys(planData).forEach(field => {
+    test('Basic validation for required fields should return an error - string causes Invalid plan data received', async t => {
+      t.plan(1)
+      const { ...testData } = planData
+      delete testData[field]
+      const responseStub = [sandbox.stub()]
+      const planServiceStub = new PlanService()
+      sandbox.stub(planServiceStub, 'createPlan').resolves(responseStub)
+      try {
+        await planServiceStub.createPlanWithValidation(testData)
+        t.fail('createPlanWithValidation failed - missing required field')
+      } catch (err) {
+        t.equal(
+          err.toString(),
+          `Error: Required field \'${field}\' is missing`,
+          `Validation failed on required field: ${field} successfully`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  })
+}
+
+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 => {
+      t.plan(1)
+      const planData = {
+        name: 'testName',
+        key: 'test-key'
+      }
+      planData.price = badPriceData[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')
+      } 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}`
+          )
+        }
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+function keyValidation () {
+  const badKeyData = [
+    'CAPITALLETTERS',
+    'Special @ Character',
+    'under_score',
+    'syntax!'
+  ]
+  for (let ii = 0; ii < badKeyData.length; ii++) {
+    test(`Key validation should throw an error checking for: ${badKeyData[ii]}`, async t => {
+      t.plan(1)
+      const planData = {
+        name: 'testName',
+        key: '',
+        price: 1.0
+      }
+      planData.key += badKeyData[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')
+      } 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}`
+        )
+      }
+      sandbox.restore()
+      t.end()
+    })
+  }
+}
+
+keyValidation()
+priceValidation()
+planDataEmptyOrNotAnObject()
+requiredFieldsMissing()
+// #endregion
+
+// #region Cleanup
+test('teardown', t => {
+  sandbox.restore()
+  t.end()
+})
+// #endregion