@symbo.ls/sdk 3.1.1 → 3.1.2

package/dist/esm/utils/TokenManager.js

@@ -0,0 +1,360 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/utils/TokenManager.js
+var TokenManager = class {
+  constructor(options = {}) {
+    /**
+     * Memory storage fallback for server-side rendering
+     */
+    __publicField(this, "_memoryStorage", {
+      _data: {},
+      getItem: (key) => this._memoryStorage._data[key] || null,
+      setItem: (key, value) => {
+        this._memoryStorage._data[key] = value;
+      },
+      removeItem: (key) => {
+        delete this._memoryStorage._data[key];
+      },
+      clear: () => {
+        this._memoryStorage._data = {};
+      }
+    });
+    this.config = {
+      storagePrefix: "symbols_",
+      storageType: "localStorage",
+      // 'localStorage' | 'sessionStorage' | 'memory'
+      refreshBuffer: 60 * 1e3,
+      // Refresh 1 minute before expiry
+      maxRetries: 3,
+      apiUrl: options.apiUrl || "/api",
+      onTokenRefresh: options.onTokenRefresh || null,
+      onTokenExpired: options.onTokenExpired || null,
+      onTokenError: options.onTokenError || null,
+      ...options
+    };
+    this.tokens = {
+      accessToken: null,
+      refreshToken: null,
+      expiresAt: null,
+      expiresIn: null
+    };
+    this.refreshPromise = null;
+    this.refreshTimeout = null;
+    this.retryCount = 0;
+    this.loadTokens();
+  }
+  /**
+   * Storage keys
+   */
+  get storageKeys() {
+    return {
+      accessToken: `${this.config.storagePrefix}access_token`,
+      refreshToken: `${this.config.storagePrefix}refresh_token`,
+      expiresAt: `${this.config.storagePrefix}expires_at`,
+      expiresIn: `${this.config.storagePrefix}expires_in`
+    };
+  }
+  /**
+   * Get storage instance based on configuration
+   */
+  get storage() {
+    if (typeof window === "undefined") {
+      return this._memoryStorage;
+    }
+    switch (this.config.storageType) {
+      case "sessionStorage":
+        return window.sessionStorage;
+      case "memory":
+        return this._memoryStorage;
+      default:
+        return window.localStorage;
+    }
+  }
+  /**
+   * Set tokens and persist to storage
+   */
+  setTokens(tokenData) {
+    const {
+      access_token: accessToken,
+      refresh_token: refreshToken,
+      expires_in: expiresIn,
+      token_type: tokenType = "Bearer"
+    } = tokenData;
+    if (!accessToken) {
+      throw new Error("Access token is required");
+    }
+    const now = Date.now();
+    const expiresAt = expiresIn ? now + expiresIn * 1e3 : null;
+    this.tokens = {
+      accessToken,
+      refreshToken: refreshToken || this.tokens.refreshToken,
+      expiresAt,
+      expiresIn,
+      tokenType
+    };
+    this.saveTokens();
+    this.scheduleRefresh();
+    if (this.config.onTokenRefresh) {
+      this.config.onTokenRefresh(this.tokens);
+    }
+    return this.tokens;
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.tokens.accessToken;
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.tokens.refreshToken;
+  }
+  /**
+   * Get authorization header value
+   */
+  getAuthHeader() {
+    const token = this.getAccessToken();
+    if (!token) {
+      return null;
+    }
+    return `${this.tokens.tokenType || "Bearer"} ${token}`;
+  }
+  /**
+   * Check if access token is valid and not expired
+   */
+  isAccessTokenValid() {
+    if (!this.tokens.accessToken) {
+      return false;
+    }
+    if (!this.tokens.expiresAt) {
+      return true;
+    }
+    const now = Date.now();
+    return now < this.tokens.expiresAt - this.config.refreshBuffer;
+  }
+  /**
+   * Check if tokens exist (regardless of expiry)
+   */
+  hasTokens() {
+    return Boolean(this.tokens.accessToken);
+  }
+  /**
+   * Check if refresh token exists
+   */
+  hasRefreshToken() {
+    return Boolean(this.tokens.refreshToken);
+  }
+  /**
+   * Automatically refresh tokens if needed
+   */
+  async ensureValidToken() {
+    if (!this.hasTokens()) {
+      return null;
+    }
+    if (this.isAccessTokenValid()) {
+      return this.getAccessToken();
+    }
+    if (!this.hasRefreshToken()) {
+      this.clearTokens();
+      if (this.config.onTokenExpired) {
+        this.config.onTokenExpired();
+      }
+      return null;
+    }
+    try {
+      await this.refreshTokens();
+      return this.getAccessToken();
+    } catch (error) {
+      this.clearTokens();
+      if (this.config.onTokenError) {
+        this.config.onTokenError(error);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Refresh access token using refresh token
+   */
+  async refreshTokens() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    if (!this.hasRefreshToken()) {
+      throw new Error("No refresh token available");
+    }
+    if (this.retryCount >= this.config.maxRetries) {
+      throw new Error("Max refresh retries exceeded");
+    }
+    this.refreshPromise = this._performRefresh();
+    try {
+      const result = await this.refreshPromise;
+      this.retryCount = 0;
+      return result;
+    } catch (error) {
+      this.retryCount++;
+      throw error;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Perform the actual token refresh request
+   */
+  async _performRefresh() {
+    var _a;
+    const refreshToken = this.getRefreshToken();
+    const response = await fetch(`${this.config.apiUrl}/core/auth/refresh`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ refreshToken })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.message || `Token refresh failed: ${response.status}`);
+    }
+    const responseData = await response.json();
+    if (responseData.success && responseData.data && responseData.data.tokens) {
+      const { tokens } = responseData.data;
+      const tokenData = {
+        access_token: tokens.accessToken,
+        refresh_token: tokens.refreshToken,
+        expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
+        token_type: "Bearer"
+      };
+      return this.setTokens(tokenData);
+    }
+    return this.setTokens(responseData);
+  }
+  /**
+   * Schedule automatic token refresh
+   */
+  scheduleRefresh() {
+    if (this.refreshTimeout) {
+      clearTimeout(this.refreshTimeout);
+      this.refreshTimeout = null;
+    }
+    if (!this.tokens.expiresAt || !this.hasRefreshToken()) {
+      return;
+    }
+    const now = Date.now();
+    const refreshTime = this.tokens.expiresAt - this.config.refreshBuffer;
+    const delay = Math.max(0, refreshTime - now);
+    this.refreshTimeout = setTimeout(async () => {
+      try {
+        await this.refreshTokens();
+      } catch (error) {
+        console.error("Automatic token refresh failed:", error);
+        if (this.config.onTokenError) {
+          this.config.onTokenError(error);
+        }
+      }
+    }, delay);
+  }
+  /**
+   * Save tokens to storage
+   */
+  saveTokens() {
+    const { storage } = this;
+    const keys = this.storageKeys;
+    if (this.tokens.accessToken) {
+      storage.setItem(keys.accessToken, this.tokens.accessToken);
+    }
+    if (this.tokens.refreshToken) {
+      storage.setItem(keys.refreshToken, this.tokens.refreshToken);
+    }
+    if (this.tokens.expiresAt) {
+      storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
+    }
+    if (this.tokens.expiresIn) {
+      storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
+    }
+  }
+  /**
+   * Load tokens from storage
+   */
+  loadTokens() {
+    const { storage } = this;
+    const keys = this.storageKeys;
+    const accessToken = storage.getItem(keys.accessToken);
+    const refreshToken = storage.getItem(keys.refreshToken);
+    const expiresAt = storage.getItem(keys.expiresAt);
+    const expiresIn = storage.getItem(keys.expiresIn);
+    if (accessToken) {
+      this.tokens = {
+        accessToken,
+        refreshToken,
+        expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
+        expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
+        tokenType: "Bearer"
+      };
+      this.scheduleRefresh();
+    }
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this.tokens = {
+      accessToken: null,
+      refreshToken: null,
+      expiresAt: null,
+      expiresIn: null
+    };
+    const { storage } = this;
+    const keys = this.storageKeys;
+    Object.values(keys).forEach((key) => {
+      storage.removeItem(key);
+    });
+    if (this.refreshTimeout) {
+      clearTimeout(this.refreshTimeout);
+      this.refreshTimeout = null;
+    }
+    this.retryCount = 0;
+  }
+  /**
+   * Get token status information
+   */
+  getTokenStatus() {
+    const hasTokens = this.hasTokens();
+    const isValid = this.isAccessTokenValid();
+    const { expiresAt } = this.tokens;
+    const timeToExpiry = expiresAt ? expiresAt - Date.now() : null;
+    return {
+      hasTokens,
+      isValid,
+      hasRefreshToken: this.hasRefreshToken(),
+      expiresAt,
+      timeToExpiry,
+      willExpireSoon: timeToExpiry ? timeToExpiry < this.config.refreshBuffer : false
+    };
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    if (this.refreshTimeout) {
+      clearTimeout(this.refreshTimeout);
+      this.refreshTimeout = null;
+    }
+    this.refreshPromise = null;
+  }
+};
+var defaultTokenManager = null;
+var getTokenManager = (options) => {
+  if (!defaultTokenManager) {
+    defaultTokenManager = new TokenManager(options);
+  }
+  return defaultTokenManager;
+};
+var createTokenManager = (options) => new TokenManager(options);
+export {
+  TokenManager,
+  createTokenManager,
+  getTokenManager
+};

package/dist/esm/utils/basedQuerys.js

@@ -37,7 +37,127 @@ var buildUserQuery = (userId) => ({
     $all: true
   }
 });
+var buildGetUserDataQuery = (userId) => ({
+  $id: userId,
+  id: true,
+  name: true,
+  email: true,
+  username: true,
+  globalRole: true,
+  updatedAt: true,
+  createdAt: true,
+  memberProjects: {
+    $list: true,
+    id: true,
+    role: true,
+    createdAt: true,
+    updatedAt: true,
+    project: {
+      id: true,
+      key: true,
+      name: true,
+      thumbnail: true,
+      icon: true,
+      tier: true,
+      visibility: true,
+      access: true,
+      members: {
+        $list: true,
+        user: {
+          id: true,
+          name: true,
+          email: true,
+          globalRole: true
+        },
+        role: true,
+        updatedAt: true,
+        createdAt: true
+      }
+    }
+  }
+});
+var buildGetProjectsByKeysQuery = (keys) => ({
+  projects: {
+    id: true,
+    key: true,
+    name: true,
+    thumbnail: true,
+    icon: true,
+    tier: true,
+    visibility: true,
+    access: true,
+    members: {
+      $list: true,
+      user: {
+        id: true,
+        name: true,
+        email: true,
+        globalRole: true
+      },
+      role: true,
+      updatedAt: true,
+      createdAt: true
+    },
+    $list: {
+      $find: {
+        $traverse: "children",
+        $filter: [
+          { $field: "type", $operator: "=", $value: "project" },
+          { $field: "key", $operator: "=", $value: keys }
+        ]
+      }
+    }
+  }
+});
+var GetProjectFields = {
+  id: true,
+  name: true,
+  key: true,
+  tier: true,
+  projectType: true,
+  icon: true,
+  package: true,
+  seats: true,
+  projectPassword: true,
+  stripe: true,
+  payments: {
+    $list: true,
+    id: true,
+    name: true
+  },
+  access: true,
+  isSharedLibrary: true,
+  framework: true,
+  designTool: true,
+  language: true,
+  visibility: true,
+  domains: true,
+  subscription: { id: true },
+  members: {
+    $list: true,
+    user: { id: true, name: true, email: true },
+    role: true
+  }
+};
+var buildGetProjectDataQuery = (projectId) => ({
+  $id: projectId,
+  ...GetProjectFields
+});
+var buildGetProjectByKeyDataQuery = (key) => ({
+  ...GetProjectFields,
+  $find: {
+    $traverse: "children",
+    $filter: [
+      { $field: "type", $operator: "=", $value: "project" },
+      { $field: "key", $operator: "=", $value: key }
+    ]
+  }
+});
 export {
+  buildGetProjectByKeyDataQuery,
+  buildGetProjectDataQuery,
+  buildGetProjectsByKeysQuery,
+  buildGetUserDataQuery,
   buildProjectQuery,
   buildUserQuery
 };

package/dist/esm/utils/permission.js

@@ -78,12 +78,11 @@ var PERMISSION_MAP = {
 };
 var ROLE_PERMISSIONS = {
   guest: ["viewPublicProjects"],
-  user: ["viewPublicProjects", "createProject"],
-  admin: ["viewPublicProjects", "createProject", "manageUsers"],
+  user: ["viewPublicProjects"],
+  admin: ["viewPublicProjects", "governance"],
   superAdmin: [
     "viewPublicProjects",
-    "createProject",
-    "manageUsers",
+    "governance",
     "managePlatform"
   ]
 };
@@ -179,6 +178,7 @@ var TIER_FEATURES = {
   ]
 };
 var PROJECT_ROLE_PERMISSIONS = {
+  unauthenticated: ["platformSettings", "showContent"],
   guest: ["platformSettings", "showContent"],
   editor: [
     "platformSettings",

package/dist/esm/utils/services.js

@@ -1,31 +1,32 @@
 // src/utils/services.js
 var SERVICE_METHODS = {
-  // Auth service methods
+  // Auth service methods (legacy - keeping for backward compatibility)
   auth: "auth",
   login: "auth",
   register: "auth",
   googleAuth: "auth",
+  googleAuthCallback: "auth",
   githubAuth: "auth",
   confirmRegistration: "auth",
   logout: "auth",
   updateUserRole: "auth",
   hasPermission: "auth",
+  hasGlobalPermission: "auth",
   getProjectMembers: "auth",
   inviteMember: "auth",
   acceptInvite: "auth",
   updateMemberRole: "auth",
   removeMember: "auth",
   updateProjectTier: "auth",
-  requestPasswordReset: "auth",
-  confirmPasswordReset: "auth",
   subscribeToAuthChanges: "auth",
-  getStoredAuthState: "auth",
+  getStoredAuthState: "core",
   // AI service methods
   prompt: "ai",
   // Based service methods
   query: "based",
   setProject: "based",
   setUser: "based",
+  setUserForced: "based",
   subscribe: "based",
   call: "based",
   getProject: "based",
@@ -61,30 +62,52 @@ var SERVICE_METHODS = {
   confirmPasswordChange: "based",
   updateUserProfile: "based",
   duplicateProject: "based",
+  listPlans: "based",
+  subscribeToPlan: "based",
+  getSubscriptionDetails: "based",
+  checkSubscriptionStatus: "based",
+  upgradeSubscription: "based",
+  downgradeSubscription: "based",
+  cancelSubscription: "based",
+  reactivateSubscription: "based",
+  generateInvoice: "based",
+  getUsageReport: "based",
+  inviteAccountOwner: "based",
+  acceptOwnerInvitation: "based",
+  removeAccountOwner: "based",
+  checkResourceLimit: "based",
+  checkFeatureAccess: "based",
+  getUserFeatures: "based",
+  getAvailableFeatures: "based",
+  listFeatureFlags: "based",
+  updateFeatureFlag: "based",
+  removeFeatureFlag: "based",
+  batchUpdateFeatureFlags: "based",
+  updatePlanDetails: "based",
+  updatePlanStatus: "based",
   // Symstory service methods
   set: "symstory",
   getData: "symstory",
   updateData: "symstory",
   getBranches: "symstory",
-  createBranch: "symstory",
   editBranch: "symstory",
-  deleteBranch: "symstory",
-  mergeBranch: "symstory",
   restoreVersion: "symstory",
   getItem: "symstory",
   addItem: "symstory",
+  addMultipleItems: "symstory",
   updateItem: "symstory",
   deleteItem: "symstory",
   switchVersion: "symstory",
   switchBranch: "symstory",
   undo: "symstory",
   redo: "symstory",
+  publish: "symstory",
+  getChanges: "symstory",
   // Socket service methods
   send: "socket",
   subscribeChannel: "socket",
   connect: "socket",
-  reconnect: "socket",
-  destroy: "socket"
+  reconnect: "socket"
 };
 export {
   SERVICE_METHODS