@symbo.ls/sdk 2.34.32 → 2.34.33

package/dist/cjs/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   createBranchService: () => import_services3.createBranchService,
   createCollabService: () => import_services3.createCollabService,
   createDnsService: () => import_services3.createDnsService,
+  createFeatureFlagService: () => import_services3.createFeatureFlagService,
   createFileService: () => import_services3.createFileService,
   createIntegrationService: () => import_services3.createIntegrationService,
   createMetricsService: () => import_services3.createMetricsService,
@@ -190,6 +191,13 @@ class SDK {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        "featureFlag",
+        (0, import_services.createFeatureFlagService)({
+          context: this._context,
+          options: this._options
+        })
       )
     ]);
     return this;

package/dist/cjs/services/FeatureFlagService.js

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FeatureFlagService_exports = {};
+__export(FeatureFlagService_exports, {
+  FeatureFlagService: () => FeatureFlagService
+});
+module.exports = __toCommonJS(FeatureFlagService_exports);
+var import_BaseService = require("./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 import_BaseService.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 });
+    }
+  }
+}

package/dist/cjs/services/index.js

@@ -22,6 +22,7 @@ __export(services_exports, {
   BranchService: () => import_BranchService.BranchService,
   CollabService: () => import_CollabService.CollabService,
   DnsService: () => import_DnsService.DnsService,
+  FeatureFlagService: () => import_FeatureFlagService.FeatureFlagService,
   FileService: () => import_FileService.FileService,
   IntegrationService: () => import_IntegrationService.IntegrationService,
   MetricsService: () => import_MetricsService.MetricsService,
@@ -38,6 +39,7 @@ __export(services_exports, {
   createBranchService: () => createBranchService,
   createCollabService: () => createCollabService,
   createDnsService: () => createDnsService,
+  createFeatureFlagService: () => createFeatureFlagService,
   createFileService: () => createFileService,
   createIntegrationService: () => createIntegrationService,
   createMetricsService: () => createMetricsService,
@@ -67,6 +69,7 @@ var import_TrackingService = require("./TrackingService.js");
 var import_WaitlistService = require("./WaitlistService.js");
 var import_MetricsService = require("./MetricsService.js");
 var import_IntegrationService = require("./IntegrationService.js");
+var import_FeatureFlagService = require("./FeatureFlagService.js");
 const createService = (ServiceClass, config) => new ServiceClass(config);
 const createAuthService = (config) => createService(import_AuthService.AuthService, config);
 const createCollabService = (config) => createService(import_CollabService.CollabService, config);
@@ -84,3 +87,4 @@ const createTrackingService = (config) => createService(import_TrackingService.T
 const createWaitlistService = (config) => createService(import_WaitlistService.WaitlistService, config);
 const createMetricsService = (config) => createService(import_MetricsService.MetricsService, config);
 const createIntegrationService = (config) => createService(import_IntegrationService.IntegrationService, config);
+const createFeatureFlagService = (config) => createService(import_FeatureFlagService.FeatureFlagService, config);

package/dist/cjs/utils/services.js

@@ -319,5 +319,12 @@ 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"
 };

package/dist/esm/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,6 +50503,7 @@ 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);
 
 // src/utils/services.js
 var SERVICE_METHODS = {
@@ -50650,7 +50805,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"
 };
 
 // src/index.js
@@ -50790,6 +50952,13 @@ var SDK = class {
           context: this._context,
           options: this._options
         })
+      ),
+      this._initService(
+        "featureFlag",
+        createFeatureFlagService({
+          context: this._context,
+          options: this._options
+        })
       )
     ]);
     return this;
@@ -50913,6 +51082,7 @@ export {
   createBranchService,
   createCollabService,
   createDnsService,
+  createFeatureFlagService,
   createFileService,
   createIntegrationService,
   createMetricsService,