@symbo.ls/sdk 2.34.34 → 3.1.1

package/dist/esm/utils/ordering.js

@@ -1,291 +0,0 @@
-// src/utils/ordering.js
-function isObjectLike(val) {
-  return val && typeof val === "object" && !Array.isArray(val);
-}
-function normalizePath(path) {
-  if (Array.isArray(path)) {
-    return path;
-  }
-  if (typeof path === "string") {
-    return [path];
-  }
-  return [];
-}
-function getParentPathsFromTuples(tuples = []) {
-  const seen = /* @__PURE__ */ new Set();
-  const parents = [];
-  const META_KEYS = /* @__PURE__ */ new Set([
-    "style",
-    "class",
-    "text",
-    "html",
-    "content",
-    "data",
-    "attr",
-    "state",
-    "scope",
-    "define",
-    "on",
-    "extend",
-    "extends",
-    "childExtend",
-    "childExtends",
-    "children",
-    "component",
-    "context",
-    "tag",
-    "key",
-    "__order",
-    "if"
-  ]);
-  for (let i = 0; i < tuples.length; i++) {
-    const tuple = tuples[i];
-    if (!Array.isArray(tuple) || tuple.length < 2) {
-      continue;
-    }
-    const path = normalizePath(tuple[1]);
-    if (!path.length) {
-      continue;
-    }
-    if (path[0] === "schema") {
-      continue;
-    }
-    const immediateParent = path.slice(0, -1);
-    if (immediateParent.length) {
-      const key = JSON.stringify(immediateParent);
-      if (!seen.has(key)) {
-        seen.add(key);
-        parents.push(immediateParent);
-      }
-    }
-    const last = path[path.length - 1];
-    if (META_KEYS.has(last) && path.length >= 2) {
-      const containerParent = path.slice(0, -2);
-      if (containerParent.length) {
-        const key2 = JSON.stringify(containerParent);
-        if (!seen.has(key2)) {
-          seen.add(key2);
-          parents.push(containerParent);
-        }
-      }
-    }
-    for (let j = 0; j < path.length; j++) {
-      const seg = path[j];
-      if (!META_KEYS.has(seg)) {
-        continue;
-      }
-      const containerParent2 = path.slice(0, j);
-      if (!containerParent2.length) {
-        continue;
-      }
-      const key3 = JSON.stringify(containerParent2);
-      if (!seen.has(key3)) {
-        seen.add(key3);
-        parents.push(containerParent2);
-      }
-    }
-  }
-  return parents;
-}
-function computeOrdersFromState(root, parentPaths = []) {
-  if (!root || typeof root.getByPath !== "function") {
-    return [];
-  }
-  const orders = [];
-  const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
-  for (let i = 0; i < parentPaths.length; i++) {
-    const parentPath = parentPaths[i];
-    const obj = (() => {
-      try {
-        return root.getByPath(parentPath);
-      } catch {
-        return null;
-      }
-    })();
-    if (!isObjectLike(obj)) {
-      continue;
-    }
-    const keys = Object.keys(obj).filter((k) => !EXCLUDE_KEYS.has(k));
-    orders.push({ path: parentPath, keys });
-  }
-  return orders;
-}
-function normaliseSchemaCode(code) {
-  if (typeof code !== "string" || !code.length) {
-    return "";
-  }
-  return code.replaceAll("/////n", "\n").replaceAll("/////tilde", "`");
-}
-function parseExportedObject(code) {
-  const src = normaliseSchemaCode(code);
-  if (!src) {
-    return null;
-  }
-  const body = src.replace(/^\s*export\s+default\s*/u, "return ");
-  try {
-    return new Function(body)();
-  } catch {
-    return null;
-  }
-}
-function extractTopLevelKeysFromCode(code) {
-  const obj = parseExportedObject(code);
-  if (!obj || typeof obj !== "object") {
-    return [];
-  }
-  return Object.keys(obj);
-}
-function computeOrdersForTuples(root, tuples = []) {
-  const pendingChildrenByContainer = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tuples.length; i++) {
-    const t = tuples[i];
-    if (!Array.isArray(t)) {
-      continue;
-    }
-    const [action, path] = t;
-    const p = normalizePath(path);
-    if (!Array.isArray(p) || p.length < 2) {
-      continue;
-    }
-    if (p[0] === "schema") {
-      continue;
-    }
-    const containerPath = p.slice(0, -1);
-    const childKey = p[p.length - 1];
-    const key = JSON.stringify(containerPath);
-    if (!pendingChildrenByContainer.has(key)) {
-      pendingChildrenByContainer.set(key, /* @__PURE__ */ new Set());
-    }
-    if (action === "update" || action === "set") {
-      pendingChildrenByContainer.get(key).add(childKey);
-    }
-  }
-  const preferredOrderMap = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tuples.length; i++) {
-    const t = tuples[i];
-    if (!Array.isArray(t)) {
-      continue;
-    }
-    const [action, path, value] = t;
-    const p = normalizePath(path);
-    if (action !== "update" || !Array.isArray(p) || p.length < 3) {
-      continue;
-    }
-    if (p[0] !== "schema") {
-      continue;
-    }
-    const [, type, key] = p;
-    const containerPath = [type, key];
-    const uses = value && Array.isArray(value.uses) ? value.uses : null;
-    const code = value && value.code;
-    const obj = (() => {
-      try {
-        return root && typeof root.getByPath === "function" ? root.getByPath(containerPath) : null;
-      } catch {
-        return null;
-      }
-    })();
-    if (!obj) {
-      continue;
-    }
-    const present = new Set(Object.keys(obj));
-    const EXCLUDE_KEYS = /* @__PURE__ */ new Set(["__order"]);
-    const codeKeys = extractTopLevelKeysFromCode(code);
-    let resolved = [];
-    const pendingKey = JSON.stringify(containerPath);
-    const pendingChildren = pendingChildrenByContainer.get(pendingKey) || /* @__PURE__ */ new Set();
-    const eligible = /* @__PURE__ */ new Set([...present, ...pendingChildren]);
-    if (Array.isArray(codeKeys) && codeKeys.length) {
-      resolved = codeKeys.filter((k) => eligible.has(k) && !EXCLUDE_KEYS.has(k));
-    }
-    if (Array.isArray(uses) && uses.length) {
-      for (let u = 0; u < uses.length; u++) {
-        const keyName = uses[u];
-        if (eligible.has(keyName) && !EXCLUDE_KEYS.has(keyName) && !resolved.includes(keyName)) {
-          resolved.push(keyName);
-        }
-      }
-    }
-    if (pendingChildren.size) {
-      for (const child of pendingChildren) {
-        if (!EXCLUDE_KEYS.has(child) && !resolved.includes(child)) {
-          resolved.push(child);
-        }
-      }
-    }
-    if (resolved.length) {
-      preferredOrderMap.set(JSON.stringify(containerPath), { path: containerPath, keys: resolved });
-    }
-  }
-  const parents = getParentPathsFromTuples(tuples);
-  const orders = [];
-  const seen = /* @__PURE__ */ new Set();
-  preferredOrderMap.forEach((v) => {
-    const k = JSON.stringify(v.path);
-    if (!seen.has(k)) {
-      seen.add(k);
-      orders.push(v);
-    }
-  });
-  const fallbackOrders = computeOrdersFromState(root, parents);
-  for (let i = 0; i < fallbackOrders.length; i++) {
-    const v = fallbackOrders[i];
-    const k = JSON.stringify(v.path);
-    if (seen.has(k)) {
-      continue;
-    }
-    const pending = pendingChildrenByContainer.get(k);
-    if (pending && pending.size) {
-      const existingKeys = v.keys;
-      const existingSet = new Set(existingKeys);
-      const META_KEYS = /* @__PURE__ */ new Set([
-        "style",
-        "class",
-        "text",
-        "html",
-        "content",
-        "data",
-        "attr",
-        "state",
-        "scope",
-        "define",
-        "on",
-        "extend",
-        "extends",
-        "childExtend",
-        "childExtends",
-        "children",
-        "component",
-        "context",
-        "tag",
-        "key",
-        "__order",
-        "if"
-      ]);
-      let firstMetaIndex = existingKeys.length;
-      for (let j = 0; j < existingKeys.length; j++) {
-        if (META_KEYS.has(existingKeys[j])) {
-          firstMetaIndex = j;
-          break;
-        }
-      }
-      for (const child of pending) {
-        if (existingSet.has(child)) {
-          continue;
-        }
-        const insertIndex = firstMetaIndex;
-        existingKeys.splice(insertIndex, 0, child);
-        existingSet.add(child);
-        firstMetaIndex++;
-      }
-    }
-    seen.add(k);
-    orders.push(v);
-  }
-  return orders;
-}
-export {
-  computeOrdersForTuples,
-  computeOrdersFromState,
-  getParentPathsFromTuples
-};

package/dist/node/services/AdminService.js

@@ -1,332 +0,0 @@
-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
-};