@symbo.ls/sdk 2.34.32 → 2.34.33

package/dist/esm/services/index.js

@@ -50331,6 +50331,160 @@ var IntegrationService = class extends BaseService {
   }
 };
 
+// src/services/FeatureFlagService.js
+function normalizeKeysParam(keys2) {
+  if (!keys2) {
+    return null;
+  }
+  if (Array.isArray(keys2)) {
+    const flattened = keys2.flatMap((k3) => String(k3).split(","));
+    const cleaned2 = flattened.map((s3) => s3.trim()).filter(Boolean);
+    return cleaned2.length ? cleaned2.join(",") : null;
+  }
+  const cleaned = String(keys2).split(",").map((s3) => s3.trim()).filter(Boolean);
+  return cleaned.length ? cleaned.join(",") : null;
+}
+var FeatureFlagService = class extends BaseService {
+  // ==================== USER FEATURE FLAGS (optional auth) ====================
+  /**
+   * Evaluate feature flags for the current user (or anonymous).
+   * @param {Object} [params]
+   * @param {string[]|string} [params.keys] Optional subset of keys (array or comma-separated string)
+   * @returns {Promise<{flags: Record<string, {enabled: boolean, variant: string|null, payload: any}>}>}
+   */
+  async getFeatureFlags(params2 = {}) {
+    this._requireReady("getFeatureFlags");
+    const { keys: keys2 } = params2 || {};
+    const queryParams = new URLSearchParams();
+    const keysParam = normalizeKeysParam(keys2);
+    if (keysParam) {
+      queryParams.append("keys", keysParam);
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "getFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flags: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Evaluate a single feature flag for the current user (or anonymous).
+   */
+  async getFeatureFlag(key) {
+    this._requireReady("getFeatureFlag");
+    if (!key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request(`/feature-flags/${encodeURIComponent(String(key))}`, {
+        method: "GET",
+        methodName: "getFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== ADMIN FEATURE FLAGS (admin only) ====================
+  async getAdminFeatureFlags(params2 = {}) {
+    this._requireReady("getAdminFeatureFlags");
+    const { includeArchived = true } = params2 || {};
+    const queryParams = new URLSearchParams();
+    if (includeArchived === false) {
+      queryParams.append("includeArchived", "false");
+    }
+    const queryString = queryParams.toString();
+    const url2 = `/admin/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url2, {
+        method: "GET",
+        methodName: "getAdminFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get admin feature flags: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  async createFeatureFlag(flagData) {
+    this._requireReady("createFeatureFlag");
+    if (!flagData || typeof flagData !== "object") {
+      throw new Error("Feature flag data is required");
+    }
+    if (!flagData.key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request("/admin/feature-flags", {
+        method: "POST",
+        body: JSON.stringify(flagData),
+        methodName: "createFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async updateFeatureFlag(id2, patch) {
+    this._requireReady("updateFeatureFlag");
+    if (!id2) {
+      throw new Error("Feature flag id is required");
+    }
+    if (!patch || typeof patch !== "object") {
+      throw new Error("Feature flag patch is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id2))}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch),
+        methodName: "updateFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async archiveFeatureFlag(id2) {
+    this._requireReady("archiveFeatureFlag");
+    if (!id2) {
+      throw new Error("Feature flag id is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id2))}`, {
+        method: "DELETE",
+        methodName: "archiveFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to archive feature flag: ${error.message}`, { cause: error });
+    }
+  }
+};
+
 // src/services/index.js
 var createService = (ServiceClass, config) => new ServiceClass(config);
 var createAuthService = (config) => createService(AuthService, config);
@@ -50349,12 +50503,14 @@ var createTrackingService = (config) => createService(TrackingService, config);
 var createWaitlistService = (config) => createService(WaitlistService, config);
 var createMetricsService = (config) => createService(MetricsService, config);
 var createIntegrationService = (config) => createService(IntegrationService, config);
+var createFeatureFlagService = (config) => createService(FeatureFlagService, config);
 export {
   AdminService,
   AuthService,
   BranchService,
   CollabService,
   DnsService,
+  FeatureFlagService,
   FileService,
   IntegrationService,
   MetricsService,
@@ -50371,6 +50527,7 @@ export {
   createBranchService,
   createCollabService,
   createDnsService,
+  createFeatureFlagService,
   createFileService,
   createIntegrationService,
   createMetricsService,

package/dist/esm/utils/services.js

@@ -298,7 +298,14 @@ var 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"
 };
 export {
   SERVICE_METHODS

package/dist/node/index.js

@@ -14,7 +14,8 @@ import {
   createTrackingService,
   createWaitlistService,
   createMetricsService,
-  createIntegrationService
+  createIntegrationService,
+  createFeatureFlagService
 } from "./services/index.js";
 import { SERVICE_METHODS } from "./utils/services.js";
 import environment from "./config/environment.js";
@@ -155,6 +156,13 @@ class SDK {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        "featureFlag",
+        createFeatureFlagService({
+          context: this._context,
+          options: this._options
+        })
       )
     ]);
     return this;
@@ -286,7 +294,8 @@ import {
   createTrackingService as createTrackingService2,
   createWaitlistService as createWaitlistService2,
   createMetricsService as createMetricsService2,
-  createIntegrationService as createIntegrationService2
+  createIntegrationService as createIntegrationService2,
+  createFeatureFlagService as createFeatureFlagService2
 } from "./services/index.js";
 import { default as default2 } from "./config/environment.js";
 export {
@@ -296,6 +305,7 @@ export {
   createBranchService2 as createBranchService,
   createCollabService2 as createCollabService,
   createDnsService2 as createDnsService,
+  createFeatureFlagService2 as createFeatureFlagService,
   createFileService2 as createFileService,
   createIntegrationService2 as createIntegrationService,
   createMetricsService2 as createMetricsService,

package/dist/node/services/FeatureFlagService.js

@@ -0,0 +1,156 @@
+import { BaseService } from "./BaseService.js";
+function normalizeKeysParam(keys) {
+  if (!keys) {
+    return null;
+  }
+  if (Array.isArray(keys)) {
+    const flattened = keys.flatMap((k) => String(k).split(","));
+    const cleaned2 = flattened.map((s) => s.trim()).filter(Boolean);
+    return cleaned2.length ? cleaned2.join(",") : null;
+  }
+  const cleaned = String(keys).split(",").map((s) => s.trim()).filter(Boolean);
+  return cleaned.length ? cleaned.join(",") : null;
+}
+class FeatureFlagService extends BaseService {
+  // ==================== USER FEATURE FLAGS (optional auth) ====================
+  /**
+   * Evaluate feature flags for the current user (or anonymous).
+   * @param {Object} [params]
+   * @param {string[]|string} [params.keys] Optional subset of keys (array or comma-separated string)
+   * @returns {Promise<{flags: Record<string, {enabled: boolean, variant: string|null, payload: any}>}>}
+   */
+  async getFeatureFlags(params = {}) {
+    this._requireReady("getFeatureFlags");
+    const { keys } = params || {};
+    const queryParams = new URLSearchParams();
+    const keysParam = normalizeKeysParam(keys);
+    if (keysParam) {
+      queryParams.append("keys", keysParam);
+    }
+    const queryString = queryParams.toString();
+    const url = `/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "getFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flags: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Evaluate a single feature flag for the current user (or anonymous).
+   */
+  async getFeatureFlag(key) {
+    this._requireReady("getFeatureFlag");
+    if (!key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request(`/feature-flags/${encodeURIComponent(String(key))}`, {
+        method: "GET",
+        methodName: "getFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== ADMIN FEATURE FLAGS (admin only) ====================
+  async getAdminFeatureFlags(params = {}) {
+    this._requireReady("getAdminFeatureFlags");
+    const { includeArchived = true } = params || {};
+    const queryParams = new URLSearchParams();
+    if (includeArchived === false) {
+      queryParams.append("includeArchived", "false");
+    }
+    const queryString = queryParams.toString();
+    const url = `/admin/feature-flags${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "getAdminFeatureFlags"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get admin feature flags: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  async createFeatureFlag(flagData) {
+    this._requireReady("createFeatureFlag");
+    if (!flagData || typeof flagData !== "object") {
+      throw new Error("Feature flag data is required");
+    }
+    if (!flagData.key) {
+      throw new Error("Feature flag key is required");
+    }
+    try {
+      const response = await this._request("/admin/feature-flags", {
+        method: "POST",
+        body: JSON.stringify(flagData),
+        methodName: "createFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async updateFeatureFlag(id, patch) {
+    this._requireReady("updateFeatureFlag");
+    if (!id) {
+      throw new Error("Feature flag id is required");
+    }
+    if (!patch || typeof patch !== "object") {
+      throw new Error("Feature flag patch is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch),
+        methodName: "updateFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update feature flag: ${error.message}`, { cause: error });
+    }
+  }
+  async archiveFeatureFlag(id) {
+    this._requireReady("archiveFeatureFlag");
+    if (!id) {
+      throw new Error("Feature flag id is required");
+    }
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: "DELETE",
+        methodName: "archiveFeatureFlag"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to archive feature flag: ${error.message}`, { cause: error });
+    }
+  }
+}
+export {
+  FeatureFlagService
+};

package/dist/node/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);
 const createAuthService = (config) => createService(AuthService, config);
 const createCollabService = (config) => createService(CollabService, config);
@@ -31,12 +32,14 @@ const createTrackingService = (config) => createService(TrackingService, config)
 const createWaitlistService = (config) => createService(WaitlistService, config);
 const createMetricsService = (config) => createService(MetricsService, config);
 const createIntegrationService = (config) => createService(IntegrationService, config);
+const createFeatureFlagService = (config) => createService(FeatureFlagService, config);
 export {
   AdminService,
   AuthService,
   BranchService,
   CollabService,
   DnsService,
+  FeatureFlagService,
   FileService,
   IntegrationService,
   MetricsService,
@@ -53,6 +56,7 @@ export {
   createBranchService,
   createCollabService,
   createDnsService,
+  createFeatureFlagService,
   createFileService,
   createIntegrationService,
   createMetricsService,

package/dist/node/utils/services.js

@@ -297,7 +297,14 @@ 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"
 };
 export {
   SERVICE_METHODS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbo.ls/sdk",
-  "version": "2.34.32",
+  "version": "2.34.33",
   "type": "module",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",
@@ -47,12 +47,12 @@
     "test:unit-all": "cross-env NODE_ENV=$NODE_ENV npx tape src/services/tests/**/*.test.js | tap-spec"
   },
   "dependencies": {
-    "@domql/element": "^2.34.32",
-    "@domql/utils": "^2.34.32",
+    "@domql/element": "^2.34.33",
+    "@domql/utils": "^2.34.33",
     "@grafana/faro-web-sdk": "^1.19.0",
     "@grafana/faro-web-tracing": "^1.19.0",
-    "@symbo.ls/router": "^2.34.32",
-    "@symbo.ls/socket": "^2.34.32",
+    "@symbo.ls/router": "^2.34.33",
+    "@symbo.ls/socket": "^2.34.33",
     "acorn": "^8.14.0",
     "acorn-walk": "^8.3.4",
     "dexie": "^4.0.11",
@@ -75,5 +75,5 @@
     "tap-spec": "^5.0.0",
     "tape": "^5.9.0"
   },
-  "gitHead": "99bd991fb87c092bcfd045ad358c15064a8b8c30"
+  "gitHead": "a7ecaaa2792aea530bf0b4cef625904c63a0272a"
 }

package/src/index.js

@@ -14,7 +14,8 @@ import {
   createTrackingService,
   createWaitlistService,
   createMetricsService,
-  createIntegrationService
+  createIntegrationService,
+  createFeatureFlagService
 } from './services/index.js'
 
 import { SERVICE_METHODS } from './utils/services.js'
@@ -169,6 +170,13 @@ export class SDK {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        'featureFlag',
+        createFeatureFlagService({
+          context: this._context,
+          options: this._options
+        })
       )
     ])
 
@@ -335,7 +343,8 @@ export {
   createTrackingService,
   createWaitlistService,
   createMetricsService,
-  createIntegrationService
+  createIntegrationService,
+  createFeatureFlagService
 } from './services/index.js'
 
 // Export environment configuration

package/src/services/FeatureFlagService.js

@@ -0,0 +1,174 @@
+import { BaseService } from './BaseService.js'
+
+function normalizeKeysParam (keys) {
+  if (!keys) { return null }
+  if (Array.isArray(keys)) {
+    const flattened = keys.flatMap(k => String(k).split(','))
+    const cleaned = flattened.map(s => s.trim()).filter(Boolean)
+    return cleaned.length ? cleaned.join(',') : null
+  }
+  const cleaned = String(keys)
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean)
+  return cleaned.length ? cleaned.join(',') : null
+}
+
+export class FeatureFlagService extends BaseService {
+  // ==================== USER FEATURE FLAGS (optional auth) ====================
+
+  /**
+   * Evaluate feature flags for the current user (or anonymous).
+   * @param {Object} [params]
+   * @param {string[]|string} [params.keys] Optional subset of keys (array or comma-separated string)
+   * @returns {Promise<{flags: Record<string, {enabled: boolean, variant: string|null, payload: any}>}>}
+   */
+  async getFeatureFlags (params = {}) {
+    this._requireReady('getFeatureFlags')
+    const { keys } = params || {}
+
+    const queryParams = new URLSearchParams()
+    const keysParam = normalizeKeysParam(keys)
+    if (keysParam) {
+      queryParams.append('keys', keysParam)
+    }
+
+    const queryString = queryParams.toString()
+    const url = `/feature-flags${queryString ? `?${queryString}` : ''}`
+
+    try {
+      const response = await this._request(url, {
+        method: 'GET',
+        methodName: 'getFeatureFlags'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get feature flags: ${error.message}`, { cause: error })
+    }
+  }
+
+  /**
+   * Evaluate a single feature flag for the current user (or anonymous).
+   */
+  async getFeatureFlag (key) {
+    this._requireReady('getFeatureFlag')
+    if (!key) {
+      throw new Error('Feature flag key is required')
+    }
+
+    try {
+      const response = await this._request(`/feature-flags/${encodeURIComponent(String(key))}`, {
+        method: 'GET',
+        methodName: 'getFeatureFlag'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get feature flag: ${error.message}`, { cause: error })
+    }
+  }
+
+  // ==================== ADMIN FEATURE FLAGS (admin only) ====================
+
+  async getAdminFeatureFlags (params = {}) {
+    this._requireReady('getAdminFeatureFlags')
+    const { includeArchived = true } = params || {}
+
+    const queryParams = new URLSearchParams()
+    if (includeArchived === false) {
+      queryParams.append('includeArchived', 'false')
+    }
+
+    const queryString = queryParams.toString()
+    const url = `/admin/feature-flags${queryString ? `?${queryString}` : ''}`
+
+    try {
+      const response = await this._request(url, {
+        method: 'GET',
+        methodName: 'getAdminFeatureFlags'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get admin feature flags: ${error.message}`, {
+        cause: error
+      })
+    }
+  }
+
+  async createFeatureFlag (flagData) {
+    this._requireReady('createFeatureFlag')
+    if (!flagData || typeof flagData !== 'object') {
+      throw new Error('Feature flag data is required')
+    }
+    if (!flagData.key) {
+      throw new Error('Feature flag key is required')
+    }
+
+    try {
+      const response = await this._request('/admin/feature-flags', {
+        method: 'POST',
+        body: JSON.stringify(flagData),
+        methodName: 'createFeatureFlag'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to create feature flag: ${error.message}`, { cause: error })
+    }
+  }
+
+  async updateFeatureFlag (id, patch) {
+    this._requireReady('updateFeatureFlag')
+    if (!id) {
+      throw new Error('Feature flag id is required')
+    }
+    if (!patch || typeof patch !== 'object') {
+      throw new Error('Feature flag patch is required')
+    }
+
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: 'PATCH',
+        body: JSON.stringify(patch),
+        methodName: 'updateFeatureFlag'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to update feature flag: ${error.message}`, { cause: error })
+    }
+  }
+
+  async archiveFeatureFlag (id) {
+    this._requireReady('archiveFeatureFlag')
+    if (!id) {
+      throw new Error('Feature flag id is required')
+    }
+
+    try {
+      const response = await this._request(`/admin/feature-flags/${encodeURIComponent(String(id))}`, {
+        method: 'DELETE',
+        methodName: 'archiveFeatureFlag'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to archive feature flag: ${error.message}`, { cause: error })
+    }
+  }
+}
+