@symbo.ls/sdk 2.33.14 → 2.33.17

package/dist/cjs/services/AuthService.js

@@ -810,7 +810,7 @@ class AuthService extends import_BaseService.BaseService {
     try {
       const permissionResults = await Promise.all(
         permissions.map(
-          (permission) => this.hasProjectPermission(projectId, permission)
+          (permission) => this.checkProjectPermission(projectId, permission)
         )
       );
       const hasPermissions = requireAll ? permissionResults.every(Boolean) : permissionResults.some(Boolean);

package/dist/cjs/services/DnsService.js

@@ -96,32 +96,8 @@ class DnsService extends import_BaseService.BaseService {
       throw new Error(`Failed to remove DNS record: ${error.message}`, { cause: error });
     }
   }
-  // Deprecated, use addProjectCustomDomains instead
-  async setProjectDomains(projectKey, customDomain, hasCustomDomainAccess = false) {
-    this._requireReady("setProjectDomains");
-    if (!projectKey) {
-      throw new Error("Project key is required");
-    }
-    try {
-      const response = await this._request("/dns/project-domains", {
-        method: "POST",
-        body: JSON.stringify({
-          projectKey,
-          customDomain,
-          hasCustomDomainAccess
-        }),
-        methodName: "setProjectDomains"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to set project domains: ${error.message}`, { cause: error });
-    }
-  }
   // customDomains could be a string or an array of strings
-  async addProjectCustomDomains(projectId, customDomains) {
+  async addProjectCustomDomains(projectId, customDomains, options = {}) {
     this._requireReady("addProjectCustomDomains");
     if (!projectId) {
       throw new Error("Project ID is required");
@@ -131,10 +107,15 @@ class DnsService extends import_BaseService.BaseService {
         "customDomains is required and must be a non-empty string or array"
       );
     }
+    const { envKey, headers } = options;
     try {
       const response = await this._request(`/projects/${projectId}/domains`, {
         method: "PATCH",
-        body: JSON.stringify({ customDomains }),
+        body: JSON.stringify({
+          customDomains,
+          ...envKey ? { envKey } : {}
+        }),
+        ...headers ? { headers } : {},
         methodName: "addProjectCustomDomains"
       });
       if (response.success) {
@@ -208,25 +189,10 @@ class DnsService extends import_BaseService.BaseService {
     }
     return await this.removeDnsRecord(domain);
   }
-  /**
-   * Helper method to set project domains with validation
-   */
-  async setProjectDomainsWithValidation(projectKey, customDomain, hasCustomDomainAccess = false) {
-    if (!projectKey || typeof projectKey !== "string") {
-      throw new Error("Project key must be a valid string");
-    }
-    if (customDomain) {
-      const validation = this.validateDomain(customDomain);
-      if (!validation.isValid) {
-        throw new Error(validation.error);
-      }
-    }
-    return await this.setProjectDomains(projectKey, customDomain, hasCustomDomainAccess);
-  }
   /**
    * Helper method to add project custom domains with validation
    */
-  async addProjectCustomDomainsWithValidation(projectId, customDomains) {
+  async addProjectCustomDomainsWithValidation(projectId, customDomains, options = {}) {
     if (!projectId || typeof projectId !== "string") {
       throw new Error("Project ID must be a valid string");
     }
@@ -243,7 +209,7 @@ class DnsService extends import_BaseService.BaseService {
         throw new Error(`Invalid domain '${domain}': ${validation.error}`);
       }
     }
-    return await this.addProjectCustomDomains(projectId, customDomains);
+    return await this.addProjectCustomDomains(projectId, customDomains, options);
   }
   /**
    * Helper method to check if domain is available

package/dist/cjs/services/ProjectService.js

@@ -280,6 +280,62 @@ class ProjectService extends import_BaseService.BaseService {
       throw new Error(`Failed to update project name: ${error.message}`, { cause: error });
     }
   }
+  async setProjectAccess(projectId, access) {
+    this._requireReady("setProjectAccess");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!access) {
+      throw new Error("Access level is required");
+    }
+    const allowedAccessValues = ["account", "team", "organization", "public"];
+    if (!allowedAccessValues.includes(access)) {
+      throw new Error(
+        `Invalid access value: ${access}. Must be one of: ${allowedAccessValues.join(", ")}`
+      );
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ access }),
+        methodName: "setProjectAccess"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to set project access: ${error.message}`, { cause: error });
+    }
+  }
+  async setProjectVisibility(projectId, visibility) {
+    this._requireReady("setProjectVisibility");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!visibility) {
+      throw new Error("Visibility is required");
+    }
+    const allowedVisibilityValues = ["public", "private", "password-protected"];
+    if (!allowedVisibilityValues.includes(visibility)) {
+      throw new Error(
+        `Invalid visibility value: ${visibility}. Must be one of: ${allowedVisibilityValues.join(", ")}`
+      );
+    }
+    try {
+      const response = await this._request(`/projects/${projectId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ visibility }),
+        methodName: "setProjectVisibility"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to set project visibility: ${error.message}`, { cause: error });
+    }
+  }
   async updateProjectPackage(projectId, pkg) {
     this._requireReady("updateProjectPackage");
     if (!projectId) {
@@ -357,6 +413,65 @@ class ProjectService extends import_BaseService.BaseService {
       );
     }
   }
+  // ==================== PROJECT PERMISSION CONFIG METHODS ====================
+  /**
+   * Fetch effective role → permissions configuration for a project.
+   * Mirrors ProjectController.getProjectRolePermissionsConfig.
+   */
+  async getProjectRolePermissionsConfig(projectId, options = {}) {
+    this._requireReady("getProjectRolePermissionsConfig");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/permissions`, {
+        method: "GET",
+        ...headers ? { headers } : {},
+        methodName: "getProjectRolePermissionsConfig"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to get project role permissions config: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Update project-level role → permissions overrides.
+   * Mirrors ProjectController.updateProjectRolePermissionsConfig.
+   */
+  async updateProjectRolePermissionsConfig(projectId, rolePermissions, options = {}) {
+    this._requireReady("updateProjectRolePermissionsConfig");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!rolePermissions || typeof rolePermissions !== "object") {
+      throw new Error("rolePermissions object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/permissions`, {
+        method: "PATCH",
+        body: JSON.stringify({ rolePermissions }),
+        ...headers ? { headers } : {},
+        methodName: "updateProjectRolePermissionsConfig"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to update project role permissions config: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
   // ==================== PROJECT MEMBER METHODS ====================
   async getProjectMembers(projectId) {
     this._requireReady("getProjectMembers");
@@ -406,6 +521,30 @@ class ProjectService extends import_BaseService.BaseService {
       throw new Error(`Failed to invite member: ${error.message}`, { cause: error });
     }
   }
+  /**
+   * Create a magic invite link for a project.
+   * The backend returns a token and URL that can be shared directly.
+   */
+  async createMagicInviteLink(projectId, options = {}) {
+    this._requireReady("createMagicInviteLink");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/invite-link`, {
+        method: "POST",
+        ...headers ? { headers } : {},
+        methodName: "createMagicInviteLink"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create magic invite link: ${error.message}`, { cause: error });
+    }
+  }
   async acceptInvite(token) {
     this._requireReady("acceptInvite");
     if (!token) {
@@ -652,6 +791,220 @@ class ProjectService extends import_BaseService.BaseService {
       throw new Error(`Failed to get project versions: ${error.message}`, { cause: error });
     }
   }
+  // ==================== PROJECT ENVIRONMENT METHODS ====================
+  /**
+   * List all environments for a project along with plan limits and activation state.
+   * Mirrors ProjectController.listEnvironments.
+   */
+  async listEnvironments(projectId, options = {}) {
+    this._requireReady("listEnvironments");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments`, {
+        method: "GET",
+        ...headers ? { headers } : {},
+        methodName: "listEnvironments"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list environments: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Activate multi-environment support for a project.
+   * Optional `force` will reconfigure DNS/TLS even if already active.
+   * Mirrors ProjectController.activateMultipleEnvironments.
+   */
+  async activateMultipleEnvironments(projectId, options = {}) {
+    this._requireReady("activateMultipleEnvironments");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { force = false, headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments/activate`, {
+        method: "POST",
+        body: JSON.stringify({ ...force ? { force: true } : {} }),
+        ...headers ? { headers } : {},
+        methodName: "activateMultipleEnvironments"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(
+        `Failed to activate multiple environments: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Create or update (upsert) an environment config for a project.
+   * Mirrors ProjectController.upsertEnvironment.
+   */
+  async upsertEnvironment(projectId, envKey, config, options = {}) {
+    this._requireReady("upsertEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!config || typeof config !== "object") {
+      throw new Error("Environment config object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/environments`, {
+        method: "POST",
+        body: JSON.stringify({ envKey, config }),
+        ...headers ? { headers } : {},
+        methodName: "upsertEnvironment"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to upsert environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update an existing environment config.
+   * Mirrors ProjectController.updateEnvironment.
+   */
+  async updateEnvironment(projectId, envKey, updates, options = {}) {
+    this._requireReady("updateEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!updates || typeof updates !== "object") {
+      throw new Error("Environment updates object is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(updates),
+          ...headers ? { headers } : {},
+          methodName: "updateEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Publish a project to a specific environment (set its effective mode/version/branch).
+   * Mirrors ProjectController.publishToEnvironment.
+   */
+  async publishToEnvironment(projectId, envKey, payload, options = {}) {
+    this._requireReady("publishToEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    if (!payload || typeof payload !== "object") {
+      throw new Error("Publish payload is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}/publish`,
+        {
+          method: "POST",
+          body: JSON.stringify(payload),
+          ...headers ? { headers } : {},
+          methodName: "publishToEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to publish to environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Delete an environment from a project.
+   * Mirrors ProjectController.deleteEnvironment.
+   */
+  async deleteEnvironment(projectId, envKey, options = {}) {
+    this._requireReady("deleteEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!envKey) {
+      throw new Error("Environment key is required");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/environments/${encodeURIComponent(envKey)}`,
+        {
+          method: "DELETE",
+          ...headers ? { headers } : {},
+          methodName: "deleteEnvironment"
+        }
+      );
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to delete environment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Promote content between environments (simple pipeline).
+   * Mirrors ProjectController.promoteEnvironment.
+   */
+  async promoteEnvironment(projectId, fromEnvKey, toEnvKey, options = {}) {
+    this._requireReady("promoteEnvironment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!fromEnvKey || !toEnvKey) {
+      throw new Error("Both fromEnvKey and toEnvKey are required");
+    }
+    if (fromEnvKey === toEnvKey) {
+      throw new Error("fromEnvKey and toEnvKey must be different");
+    }
+    const { headers } = options;
+    try {
+      const response = await this._request(`/projects/${projectId}/pipeline/promote`, {
+        method: "POST",
+        body: JSON.stringify({ from: fromEnvKey, to: toEnvKey }),
+        ...headers ? { headers } : {},
+        methodName: "promoteEnvironment"
+      });
+      if (response && response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to promote environment: ${error.message}`, { cause: error });
+    }
+  }
   /**
    * Restore project to a previous version
    * Replaces: SymstoryService.restoreVersion()

package/dist/cjs/utils/services.js

@@ -83,10 +83,20 @@ const SERVICE_METHODS = {
   duplicateProject: "project",
   removeProject: "project",
   checkProjectKeyAvailability: "project",
+  getProjectRolePermissionsConfig: "project",
+  updateProjectRolePermissionsConfig: "project",
+  listEnvironments: "project",
+  activateMultipleEnvironments: "project",
+  upsertEnvironment: "project",
+  updateEnvironment: "project",
+  publishToEnvironment: "project",
+  deleteEnvironment: "project",
+  promoteEnvironment: "project",
   // Project member methods (moved to project service)
   getProjectMembers: "project",
   inviteMember: "project",
   acceptInvite: "project",
+  createMagicInviteLink: "project",
   updateMemberRole: "project",
   removeMember: "project",
   // Project library methods (moved to project service)
@@ -104,6 +114,8 @@ const SERVICE_METHODS = {
   setProjectValue: "project",
   addProjectItems: "project",
   getProjectItemByPath: "project",
+  setProjectAccess: "project",
+  setProjectVisibility: "project",
   // Favorite project methods (moved to project service)
   getFavoriteProjects: "project",
   addFavoriteProject: "project",
@@ -169,7 +181,6 @@ const SERVICE_METHODS = {
   getDnsRecord: "dns",
   removeDnsRecord: "dns",
   getCustomHost: "dns",
-  setProjectDomains: "dns",
   addProjectCustomDomains: "dns",
   validateDomain: "dns",
   createDnsRecordWithValidation: "dns",