@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/node/index.js

@@ -1,18 +1,40 @@
 import {
-  createSymstoryService,
   createAuthService,
-  createAIService,
-  createSocketService,
-  createCoreService
+  createCollabService,
+  createProjectService,
+  createPlanService,
+  createFileService,
+  createPaymentService,
+  createDnsService,
+  createBranchService,
+  createPullRequestService,
+  createAdminService,
+  createSubscriptionService,
+  createScreenshotService,
+  createTrackingService,
+  createWaitlistService,
+  createMetricsService,
+  createIntegrationService,
+  createFeatureFlagService
 } from "./services/index.js";
 import { SERVICE_METHODS } from "./utils/services.js";
-import { SymstoryService } from "./services/SymstoryService.js";
 import environment from "./config/environment.js";
+import { rootBus } from "./state/rootEventBus.js";
+const isBrowserEnvironment = () => typeof window !== "undefined";
+const isLocalhost = () => {
+  if (!isBrowserEnvironment()) {
+    return false;
+  }
+  const host = window.location && window.location.hostname;
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "" || !host;
+};
 class SDK {
   constructor(options = {}) {
     this._services = /* @__PURE__ */ new Map();
     this._context = {};
     this._options = this._validateOptions(options);
+    this.environment = environment;
+    this.rootBus = rootBus;
     this._createServiceProxies();
   }
   // Initialize SDK with context
@@ -30,29 +52,114 @@ class SDK {
         })
       ),
       this._initService(
-        "socket",
-        createSocketService({
+        "collab",
+        createCollabService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      // Initialize new modular services
+      this._initService(
+        "project",
+        createProjectService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "plan",
+        createPlanService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "subscription",
+        createSubscriptionService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "symstory",
-        createSymstoryService({
+        "file",
+        createFileService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "ai",
-        createAIService({
+        "payment",
+        createPaymentService({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "core",
-        createCoreService({
+        "dns",
+        createDnsService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "branch",
+        createBranchService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "pullRequest",
+        createPullRequestService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "admin",
+        createAdminService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "screenshot",
+        createScreenshotService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "tracking",
+        createTrackingService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "waitlist",
+        createWaitlistService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "metrics",
+        createMetricsService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "integration",
+        createIntegrationService({
+          context: this._context,
+          options: this._options
+        })
+      ),
+      this._initService(
+        "featureFlag",
+        createFeatureFlagService({
           context: this._context,
           options: this._options
         })
@@ -73,16 +180,33 @@ class SDK {
     this._services.set(name, service);
   }
   _validateOptions(options) {
+    const onLocalhost = isLocalhost();
+    const hasGrafanaUrl = Boolean(environment.grafanaUrl);
     const defaults = {
       useNewServices: true,
       // Use new service implementations by default
-      baseUrl: environment.baseUrl,
+      apiUrl: environment.apiUrl,
       socketUrl: environment.socketUrl,
       timeout: 3e4,
       retryAttempts: 3,
-      debug: false
+      debug: false,
+      tracking: {
+        // Force-disabled on localhost or when no Grafana URL is configured
+        enabled: onLocalhost ? false : hasGrafanaUrl ? environment.features.trackingEnabled : false
+      }
     };
-    return { ...defaults, ...options };
+    const merged = {
+      ...defaults,
+      ...options,
+      tracking: {
+        ...defaults.tracking,
+        ...options.tracking || {}
+      }
+    };
+    if (onLocalhost || !hasGrafanaUrl) {
+      merged.tracking.enabled = false;
+    }
+    return merged;
   }
   // Get service instance
   getService(name) {
@@ -93,23 +217,19 @@ class SDK {
   }
   // Update context
   updateContext(newContext) {
+    const { ...sanitized } = newContext || {};
     this._context = {
       ...this._context,
-      ...newContext
+      ...sanitized
     };
     for (const service of this._services.values()) {
       service.updateContext(this._context);
-      if (service instanceof SymstoryService) {
-        service.init();
-      }
     }
   }
   // Check if SDK is ready
   isReady() {
     const sdkServices = Array.from(this._services.values());
-    return sdkServices.length > 0 && sdkServices.every(
-      (service) => service.isReady()
-    );
+    return sdkServices.length > 0 && sdkServices.every((service) => service.isReady());
   }
   // Get SDK status
   getStatus() {
@@ -160,20 +280,43 @@ class SDK {
 }
 var index_default = SDK;
 import {
-  createSymstoryService as createSymstoryService2,
   createAuthService as createAuthService2,
-  createAIService as createAIService2,
-  createSocketService as createSocketService2,
-  createCoreService as createCoreService2
+  createCollabService as createCollabService2,
+  createProjectService as createProjectService2,
+  createPlanService as createPlanService2,
+  createFileService as createFileService2,
+  createPaymentService as createPaymentService2,
+  createDnsService as createDnsService2,
+  createBranchService as createBranchService2,
+  createPullRequestService as createPullRequestService2,
+  createAdminService as createAdminService2,
+  createSubscriptionService as createSubscriptionService2,
+  createTrackingService as createTrackingService2,
+  createWaitlistService as createWaitlistService2,
+  createMetricsService as createMetricsService2,
+  createIntegrationService as createIntegrationService2,
+  createFeatureFlagService as createFeatureFlagService2
 } from "./services/index.js";
 import { default as default2 } from "./config/environment.js";
 export {
   SDK,
-  createAIService2 as createAIService,
+  createAdminService2 as createAdminService,
   createAuthService2 as createAuthService,
-  createCoreService2 as createCoreService,
-  createSocketService2 as createSocketService,
-  createSymstoryService2 as createSymstoryService,
+  createBranchService2 as createBranchService,
+  createCollabService2 as createCollabService,
+  createDnsService2 as createDnsService,
+  createFeatureFlagService2 as createFeatureFlagService,
+  createFileService2 as createFileService,
+  createIntegrationService2 as createIntegrationService,
+  createMetricsService2 as createMetricsService,
+  createPaymentService2 as createPaymentService,
+  createPlanService2 as createPlanService,
+  createProjectService2 as createProjectService,
+  createPullRequestService2 as createPullRequestService,
+  createSubscriptionService2 as createSubscriptionService,
+  createTrackingService2 as createTrackingService,
+  createWaitlistService2 as createWaitlistService,
   index_default as default,
-  default2 as environment
+  default2 as environment,
+  isLocalhost
 };

package/dist/node/services/AdminService.js

@@ -0,0 +1,332 @@
+import { BaseService } from "./BaseService.js";
+class AdminService extends BaseService {
+  // ==================== ADMIN METHODS ====================
+  /**
+   * Get admin users list with comprehensive filtering and search capabilities
+   * Requires admin or super_admin global role
+   */
+  async getAdminUsers(params = {}) {
+    this._requireReady("getAdminUsers");
+    const {
+      emails,
+      ids,
+      query,
+      status,
+      page = 1,
+      limit = 50,
+      sort = { field: "createdAt", order: "desc" }
+    } = params;
+    const queryParams = new URLSearchParams();
+    if (emails) {
+      queryParams.append("emails", emails);
+    }
+    if (ids) {
+      queryParams.append("ids", ids);
+    }
+    if (query) {
+      queryParams.append("query", query);
+    }
+    if (status) {
+      queryParams.append("status", status);
+    }
+    if (page) {
+      queryParams.append("page", page.toString());
+    }
+    if (limit) {
+      queryParams.append("limit", limit.toString());
+    }
+    if (sort && sort.field) {
+      queryParams.append("sort[field]", sort.field);
+      queryParams.append("sort[order]", sort.order || "desc");
+    }
+    const queryString = queryParams.toString();
+    const url = `/users/admin/users${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "getAdminUsers"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get admin users: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Assign projects to a specific user
+   * Requires admin or super_admin global role
+   */
+  async assignProjectsToUser(userId, options = {}) {
+    this._requireReady("assignProjectsToUser");
+    if (!userId) {
+      throw new Error("User ID is required");
+    }
+    const { projectIds, role = "guest" } = options;
+    const requestBody = {
+      userId,
+      role
+    };
+    if (projectIds && Array.isArray(projectIds)) {
+      requestBody.projectIds = projectIds;
+    }
+    try {
+      const response = await this._request("/assign-projects", {
+        method: "POST",
+        body: JSON.stringify(requestBody),
+        methodName: "assignProjectsToUser"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to assign projects to user: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update user information (admin only)
+   */
+  async updateUser(userId, userData) {
+    var _a;
+    this._requireReady("updateUser");
+    if (!userId) {
+      throw new Error("User ID is required");
+    }
+    if (!userData || typeof userData !== "object" || Object.keys(userData).length === 0) {
+      throw new Error("userData must be a non-empty object");
+    }
+    try {
+      const response = await this._request(`/users/${userId}`, {
+        method: "PATCH",
+        body: JSON.stringify(userData),
+        methodName: "updateUser"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      if ((_a = error.message) == null ? void 0 : _a.includes("Duplicate")) {
+        throw new Error("Username already exists");
+      }
+      throw new Error(`Failed to update user: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== ADMIN HELPER METHODS ====================
+  /**
+   * Helper method for admin users search
+   */
+  async searchAdminUsers(searchQuery, options = {}) {
+    return await this.getAdminUsers({
+      query: searchQuery,
+      ...options
+    });
+  }
+  /**
+   * Helper method to get admin users by email list
+   */
+  async getAdminUsersByEmails(emails, options = {}) {
+    const emailList = Array.isArray(emails) ? emails.join(",") : emails;
+    return await this.getAdminUsers({
+      emails: emailList,
+      ...options
+    });
+  }
+  /**
+   * Helper method to get admin users by ID list
+   */
+  async getAdminUsersByIds(ids, options = {}) {
+    const idList = Array.isArray(ids) ? ids.join(",") : ids;
+    return await this.getAdminUsers({
+      ids: idList,
+      ...options
+    });
+  }
+  /**
+   * Helper method to assign specific projects to a user with a specific role
+   */
+  async assignSpecificProjectsToUser(userId, projectIds, role = "guest") {
+    if (!Array.isArray(projectIds) || projectIds.length === 0) {
+      throw new Error("Project IDs must be a non-empty array");
+    }
+    return await this.assignProjectsToUser(userId, {
+      projectIds,
+      role
+    });
+  }
+  /**
+   * Helper method to assign all projects to a user with a specific role
+   */
+  async assignAllProjectsToUser(userId, role = "guest") {
+    return await this.assignProjectsToUser(userId, {
+      role
+    });
+  }
+  /**
+   * Helper method to validate user data for updates
+   */
+  validateUserData(userData) {
+    const errors = [];
+    if (!userData || typeof userData !== "object") {
+      errors.push("User data must be an object");
+      return { isValid: false, errors };
+    }
+    if (userData.email && typeof userData.email !== "string") {
+      errors.push("Email must be a string");
+    } else if (userData.email && !this._isValidEmail(userData.email)) {
+      errors.push("Email must be a valid email address");
+    }
+    if (userData.username && typeof userData.username !== "string") {
+      errors.push("Username must be a string");
+    } else if (userData.username && userData.username.length < 3) {
+      errors.push("Username must be at least 3 characters long");
+    }
+    if (userData.role && !["admin", "user", "guest"].includes(userData.role)) {
+      errors.push("Role must be one of: admin, user, guest");
+    }
+    if (userData.status && !["active", "inactive", "suspended"].includes(userData.status)) {
+      errors.push("Status must be one of: active, inactive, suspended");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Helper method to update user with validation
+   */
+  async updateUserWithValidation(userId, userData) {
+    const validation = this.validateUserData(userData);
+    if (!validation.isValid) {
+      throw new Error(`Validation failed: ${validation.errors.join(", ")}`);
+    }
+    return await this.updateUser(userId, userData);
+  }
+  /**
+   * Helper method to get user statistics
+   */
+  async getUserStats() {
+    try {
+      const users = await this.getAdminUsers({ limit: 1e3 });
+      const stats = {
+        total: users.length,
+        active: 0,
+        inactive: 0,
+        suspended: 0,
+        admins: 0,
+        users: 0,
+        guests: 0
+      };
+      users.forEach((user) => {
+        if (user.status === "active") {
+          stats.active++;
+        }
+        if (user.status === "inactive") {
+          stats.inactive++;
+        }
+        if (user.status === "suspended") {
+          stats.suspended++;
+        }
+        if (user.role === "admin") {
+          stats.admins++;
+        }
+        if (user.role === "user") {
+          stats.users++;
+        }
+        if (user.role === "guest") {
+          stats.guests++;
+        }
+      });
+      return stats;
+    } catch (error) {
+      throw new Error(`Failed to get user stats: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to bulk update users
+   */
+  async bulkUpdateUsers(userUpdates) {
+    if (!Array.isArray(userUpdates) || userUpdates.length === 0) {
+      throw new Error("User updates must be a non-empty array");
+    }
+    const updatePromises = userUpdates.map(async (update) => {
+      try {
+        const result = await this.updateUser(update.userId, update.userData);
+        return {
+          userId: update.userId,
+          success: true,
+          data: result
+        };
+      } catch (error) {
+        return {
+          userId: update.userId,
+          success: false,
+          error: error.message
+        };
+      }
+    });
+    const results = await Promise.all(updatePromises);
+    return {
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      results
+    };
+  }
+  /**
+   * Helper method to get users by role
+   */
+  async getUsersByRole(role, options = {}) {
+    const users = await this.getAdminUsers(options);
+    return users.filter((user) => user.role === role);
+  }
+  /**
+   * Helper method to get users by status
+   */
+  async getUsersByStatus(status, options = {}) {
+    const users = await this.getAdminUsers(options);
+    return users.filter((user) => user.status === status);
+  }
+  /**
+   * Helper method to activate a user
+   */
+  async activateUser(userId) {
+    return await this.updateUser(userId, { status: "active" });
+  }
+  /**
+   * Helper method to deactivate a user
+   */
+  async deactivateUser(userId) {
+    return await this.updateUser(userId, { status: "inactive" });
+  }
+  /**
+   * Helper method to suspend a user
+   */
+  async suspendUser(userId) {
+    return await this.updateUser(userId, { status: "suspended" });
+  }
+  /**
+   * Helper method to promote user to admin
+   */
+  async promoteToAdmin(userId) {
+    return await this.updateUser(userId, { role: "admin" });
+  }
+  /**
+   * Helper method to demote user from admin
+   */
+  async demoteFromAdmin(userId) {
+    return await this.updateUser(userId, { role: "user" });
+  }
+  /**
+   * Private helper to validate email format
+   */
+  _isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+    return emailRegex.test(email);
+  }
+}
+export {
+  AdminService
+};