@symbo.ls/sdk 3.1.1 → 3.2.3

package/src/utils/services.js

@@ -1,91 +1,166 @@
 export const 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',
+  // Collab service methods
+  connect: 'collab',
+  disconnect: 'collab',
+  isConnected: 'collab',
+  updateData: 'collab',
+  addItem: 'collab',
+  addMultipleItems: 'collab',
+  updateItem: 'collab',
+  deleteItem: 'collab',
+  undo: 'collab',
+  redo: 'collab',
+  checkpoint: 'collab',
 
-  // Based service methods
-  query: 'based',
-  setProject: 'based',
-  setUser: 'based',
-  subscribe: 'based',
-  call: 'based',
-  getProject: 'based',
-  getProjectByKey: 'based',
-  createProject: 'based',
-  fetchUser: 'based',
-  fetchProject: 'based',
-  setBucket: 'based',
-  getUser: 'based',
-  getUserByEmail: 'based',
-  setProjectDomains: 'based',
-  checkProjectKeyAvailability: 'based',
-  removeProject: 'based',
-  getAvailableLibraries: 'based',
-  addProjectLibraries: 'based',
-  removeProjectLibraries: 'based',
-  getProjectLibraries: 'based',
-  checkout: 'based',
-  uploadFile: 'based',
-  updateProjectIcon: 'based',
-  updateProject: 'based',
-  updateProjectSettings: 'based',
-  updateProjectComponents: 'based',
-  updateProjectName: 'based',
-  updateProjectPackage: 'based',
-  createDnsRecord: 'based',
-  getDnsRecord: 'based',
-  removeDnsRecord: 'based',
-  createStorageBucket: 'based',
-  getStorageBucket: 'based',
-  removeStorageBucket: 'based',
-  requestPasswordChange: 'based',
-  confirmPasswordChange: 'based',
-  updateUserProfile: 'based',
-  duplicateProject: 'based',
+  // Realtime collaboration helper methods
+  sendCursor: 'collab',
+  sendPresence: 'collab',
+  toggleLive: 'collab',
 
-  // 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',
-  updateItem: 'symstory',
-  deleteItem: 'symstory',
-  switchVersion: 'symstory',
-  switchBranch: 'symstory',
-  undo: 'symstory',
-  redo: 'symstory',
+  // Core service methods (new - replaces most based/auth functionality)
+  // Auth methods
+  register: 'core',
+  login: 'core',
+  logout: 'core',
+  refreshToken: 'core',
+  googleAuth: 'core',
+  googleAuthCallback: 'core',
+  githubAuth: 'core',
+  requestPasswordReset: 'core',
+  confirmPasswordReset: 'core',
+  confirmRegistration: 'core',
+  requestPasswordChange: 'core',
+  confirmPasswordChange: 'core',
+  getMe: 'core',
 
-  // Socket service methods
-  send: 'socket',
-  subscribeChannel: 'socket',
-  connect: 'socket',
-  reconnect: 'socket',
-  destroy: 'socket'
+  // User methods
+  getUserProfile: 'core',
+  updateUserProfile: 'core',
+  getUserProjects: 'core',
+  getUser: 'core',
+  getUserByEmail: 'core',
+
+  // Project methods
+  createProject: 'core',
+  getProjects: 'core',
+  getProject: 'core',
+  getProjectByKey: 'core',
+  getPublicProject: 'core',
+  listPublicProjects: 'core',
+  listProjects: 'core',
+  updateProject: 'core',
+  updateProjectComponents: 'core',
+  updateProjectSettings: 'core',
+  updateProjectName: 'core',
+  updateProjectPackage: 'core',
+  duplicateProject: 'core',
+  removeProject: 'core',
+  checkProjectKeyAvailability: 'core',
+
+  // Project member methods
+  getProjectMembers: 'core',
+  inviteMember: 'core',
+  acceptInvite: 'core',
+  updateMemberRole: 'core',
+  removeMember: 'core',
+
+  // Project library methods
+  getAvailableLibraries: 'core',
+  getProjectLibraries: 'core',
+  addProjectLibraries: 'core',
+  removeProjectLibraries: 'core',
+
+  // File methods
+  uploadFile: 'core',
+  updateProjectIcon: 'core',
+
+  // Payment methods
+  checkout: 'core',
+  getSubscriptionStatus: 'core',
+
+  // DNS methods
+  createDnsRecord: 'core',
+  getDnsRecord: 'core',
+  removeDnsRecord: 'core',
+  setProjectDomains: 'core',
+
+  // Utility methods
+  getHealthStatus: 'core',
+  getTokenDebugInfo: 'core',
+
+  // Project Data methods (Symstory replacement)
+  applyProjectChanges: 'core',
+  getProjectData: 'core',
+  getProjectVersions: 'core',
+  restoreProjectVersion: 'core',
+  updateProjectItem: 'core',
+  deleteProjectItem: 'core',
+  setProjectValue: 'core',
+  addProjectItems: 'core',
+  getProjectItemByPath: 'core',
+
+  // Pull Request methods
+  createPullRequest: 'core',
+  listPullRequests: 'core',
+  getPullRequest: 'core',
+  reviewPullRequest: 'core',
+  addPullRequestComment: 'core',
+  mergePullRequest: 'core',
+  getPullRequestDiff: 'core',
+  createPullRequestWithValidation: 'core',
+  approvePullRequest: 'core',
+  requestPullRequestChanges: 'core',
+  getOpenPullRequests: 'core',
+  getClosedPullRequests: 'core',
+  getMergedPullRequests: 'core',
+  isPullRequestMergeable: 'core',
+  getPullRequestStatusSummary: 'core',
+
+  // Branch Management methods
+  listBranches: 'core',
+  createBranch: 'core',
+  deleteBranch: 'core',
+  renameBranch: 'core',
+  getBranchChanges: 'core',
+  mergeBranch: 'core',
+  resetBranch: 'core',
+  publishVersion: 'core',
+  createBranchWithValidation: 'core',
+  branchExists: 'core',
+  previewMerge: 'core',
+  commitMerge: 'core',
+  createFeatureBranch: 'core',
+  createHotfixBranch: 'core',
+  getBranchStatus: 'core',
+  deleteBranchSafely: 'core',
+
+  // Admin methods
+  getAdminUsers: 'core',
+  assignProjectsToUser: 'core',
+  searchAdminUsers: 'core',
+  getAdminUsersByEmails: 'core',
+  getAdminUsersByIds: 'core',
+  assignSpecificProjectsToUser: 'core',
+  assignAllProjectsToUser: 'core'
 }

package/src/utils/symstoryClient.js

@@ -1,7 +1,7 @@
 import config from '../config/environment.js'
 
 const DEFAULT_OPTIONS = {
-  baseUrl: config.baseUrl
+  apiUrl: config.apiUrl
 }
 
 class SymstoryClient {
@@ -30,7 +30,7 @@ class SymstoryClient {
    * @returns {Promise<any>} - The response data.
    */
   async request (path = '', options = {}) {
-    const url = `${this.options.baseUrl}/${this.appKey}${path}`
+    const url = `${this.options.apiUrl}/symstory/${this.appKey}${path}`
     const response = await fetch(url, {
       ...options,
       headers: { ...this.headers, ...options.headers }
@@ -194,6 +194,40 @@ class SymstoryClient {
       body: JSON.stringify({ branch, version, type, message })
     })
   }
+
+  /**
+   * Publishes an existing version of the project.
+   * @param {string} version - The version ID/number to publish.
+   * @param {object} [options={}] - The publishing options.
+   * @param {string} [options.branch='main'] - The branch name. (Only if version number is provided)
+   * @returns {Promise<any>} - The response data.
+   */
+  publishVersion (version) {
+    return this.request('/publish', {
+      method: 'POST',
+      body: JSON.stringify({ version })
+    })
+  }
+
+  /**
+   * Retrieves all changes after a specific version.
+   * @param {object} [options={}] - The changes options.
+   * @param {string} [options.versionId] - The version ID to publish.
+   * @param {string} [options.versionValue] - The version ID to publish. (alternative to versionId)
+   * @param {string} [options.branch] - The branch to publish (Only in combination to versionValue)
+   * @returns {Promise<any>} - The changes data.
+   */
+  getChanges ({ versionId, versionValue, branch } = {}) {
+    return this.request(
+      `/changes?${
+        new URLSearchParams({
+          ...(versionId ? { versionId } : {}),
+          ...(versionValue ? { versionValue } : {}),
+          ...(branch ? { branch } : {})
+        }).toString()}`,
+      {}
+    )
+  }
 }
 
 export default {

package/dist/cjs/services/SocketIOService.js

@@ -1,309 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var SocketIOService_exports = {};
-__export(SocketIOService_exports, {
-  SocketService: () => SocketService
-});
-module.exports = __toCommonJS(SocketIOService_exports);
-var import_client = require("@symbo.ls/socket/client.js");
-var import_BaseService = require("./BaseService.js");
-var utils = __toESM(require("@domql/utils"), 1);
-var import_router = require("@symbo.ls/router");
-var import_environment = __toESM(require("../config/environment.js"), 1);
-const { deepStringify, deepDestringify, isString } = utils.default || utils;
-class SocketService extends import_BaseService.BaseService {
-  constructor(config) {
-    super(config);
-    this._socket = null;
-    this._reconnectAttempts = 0;
-    this._maxReconnectAttempts = (config == null ? void 0 : config.maxReconnectAttempts) || 5;
-    this._reconnectDelay = (config == null ? void 0 : config.reconnectDelay) || 1e3;
-    this._handlers = /* @__PURE__ */ new Map();
-    this._sessionId = Math.random();
-    this._ignoreSync = [
-      "userId",
-      "username",
-      "usersName",
-      "email",
-      "projects",
-      "feedbacks",
-      "userRoles",
-      "loading",
-      "appKey",
-      "projectName",
-      "followingUser",
-      "activeProject",
-      "user",
-      "sessionId",
-      "clients"
-    ];
-  }
-  init() {
-    try {
-      const { _context, _options } = this;
-      const socketUrl = import_environment.default.socketUrl || _options.socketUrl || "https://socket.symbols.app/";
-      if (!socketUrl) {
-        throw new Error("Socket URL is required");
-      }
-      this._info = {
-        config: {
-          url: socketUrl,
-          hasToken: Boolean(_context.authToken),
-          status: "initializing"
-        }
-      };
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
-  }
-  connect() {
-    var _a, _b, _c, _d, _e, _f, _g;
-    try {
-      if (this._socket && ["connected", "connecting"].includes((_b = (_a = this._info) == null ? void 0 : _a.config) == null ? void 0 : _b.status)) {
-        console.warn(
-          "Socket connection already exists:",
-          (_d = (_c = this._info) == null ? void 0 : _c.config) == null ? void 0 : _d.status
-        );
-        return true;
-      }
-      const { _context } = this;
-      if (!_context.appKey) {
-        throw new Error("App key is required");
-      }
-      this._updateStatus("connecting");
-      const config = {
-        source: "platform",
-        userId: (_e = _context.user) == null ? void 0 : _e.id,
-        socketUrl: this._info.config.url,
-        location: window.location.host,
-        onChange: this._handleMessage.bind(this),
-        sessionId: this._sessionId,
-        usersName: (_f = _context.user) == null ? void 0 : _f.name,
-        route: window.location.pathname,
-        onDisconnect: this._handleDisconnect.bind(this)
-      };
-      if (this._socket) {
-        this.destroy();
-      }
-      this._socket = (0, import_client.connect)(_context.appKey, config);
-      this._updateStatus("connected");
-      if (import_environment.default.isDevelopment) {
-        console.log("Socket connection established:", {
-          appKey: _context.appKey,
-          userId: (_g = _context.user) == null ? void 0 : _g.id,
-          sessionId: this._sessionId,
-          url: this._info.config.url
-        });
-      }
-      return true;
-    } catch (error) {
-      this._updateStatus("failed");
-      console.error("Socket connection failed:", error);
-      throw new Error(`Socket connection failed: ${error.message}`);
-    }
-  }
-  send(type, data, opts = {}) {
-    var _a, _b;
-    this._requireReady();
-    if (!this._socket) {
-      throw new Error("Socket is not connected");
-    }
-    const payload = {
-      sessionId: this._sessionId,
-      userId: (_a = this._context.user) == null ? void 0 : _a.id,
-      usersName: (_b = this._context.user) == null ? void 0 : _b.name,
-      ...data
-    };
-    import_client.send.call(
-      this._socket,
-      type,
-      opts.preventDeepStringify ? payload : deepStringify(payload)
-    );
-  }
-  _handleMessage(event, data) {
-    try {
-      const d = isString(data) ? deepDestringify(JSON.parse(data)) : data;
-      if (this._sessionId === d.sessionId) {
-        return;
-      }
-      const handlers = this._handlers.get(event);
-      if (handlers) {
-        handlers.forEach((handler) => handler(d));
-      }
-      switch (event) {
-        case "change":
-          this._handleChangeEvent(d);
-          break;
-        case "clients":
-          this._handleClientsEvent(d);
-          break;
-        case "route":
-          this._handleRouteEvent(d);
-          break;
-        default:
-          break;
-      }
-    } catch (error) {
-      this._setError(new Error(`Failed to handle message: ${error.message}`));
-    }
-  }
-  _handleChangeEvent(data) {
-    var _a, _b, _c;
-    if (data.canvas) {
-      const { clients } = data.canvas;
-      const [firstClientKey] = Object.keys(clients);
-      const monaco = clients && clients[firstClientKey] && clients[firstClientKey].monaco;
-      if (monaco) {
-        const Canvas = this._context.element && this._context.element.getCanvas();
-        if (Canvas) {
-          Canvas.Chosen.EditorPanels.update({}, { forceMonacoUpdate: true });
-        }
-      }
-      return;
-    }
-    const componentUpdates = ((_a = data.schema) == null ? void 0 : _a.components) || ((_b = data.schema) == null ? void 0 : _b.pages);
-    if (window.location.pathname.includes("/canvas") && componentUpdates) {
-      for (const updatedComponent in componentUpdates) {
-        if (Object.hasOwn(componentUpdates, updatedComponent)) {
-          (_c = this._context.element) == null ? void 0 : _c.updateComponentOnCanvas(updatedComponent);
-        }
-      }
-    }
-  }
-  _handleClientsEvent(data) {
-    const { root } = Object.getPrototypeOf(this._context.state);
-    root.replace(
-      { clients: data },
-      {
-        fromSync: true,
-        preventUpdate: ["Iframe"],
-        preventModalUpdate: true,
-        preventStateUpdateListener: true,
-        execStateFunction: true
-      }
-    );
-  }
-  _handleRouteEvent(data) {
-    const { element } = this._context;
-    const { state } = this._context;
-    if (data.userId && data.type === "routeChanged") {
-      const isModalOpen = this.getWindow("modal");
-      const isFollowing = state.followingUser === data.userId;
-      const isRouteSyncEnabled = element.getUserSettings("presentMode") && data.userId === state.userId;
-      if ((isFollowing || isRouteSyncEnabled) && !isModalOpen) {
-        (0, import_router.router)(
-          data.route,
-          element.__ref.root,
-          {},
-          {
-            fromSync: true,
-            updateStateOptions: {
-              fromSync: true,
-              preventStateUpdateListener: 1
-              // !isModalRoute(data.route, element)
-            }
-          }
-        );
-      }
-    } else if (data.reload) {
-      window.location.reload();
-    } else if (data.route && data.type === "routeForced") {
-      (0, import_router.router)(
-        data.route,
-        element.__ref.root,
-        {},
-        {
-          fromSync: true,
-          updateStateOptions: {
-            fromSync: true
-          }
-        }
-      );
-    } else if (data.componentKey) {
-      if (!element.getData("components")[data.componentKey]) {
-        return;
-      }
-      element.activateSelected(data.componentKey);
-    }
-  }
-  _handleDisconnect() {
-    this._updateStatus("disconnected");
-    this._handleReconnect();
-  }
-  _handleReconnect() {
-    if (this._reconnectAttempts < this._maxReconnectAttempts) {
-      this._reconnectAttempts++;
-      this._updateStatus("reconnecting");
-      setTimeout(() => {
-        this.connect().then(() => {
-          this._reconnectAttempts = 0;
-        }).catch(() => {
-          this._handleReconnect();
-        });
-      }, this._reconnectDelay * this._reconnectAttempts);
-    } else {
-      this._updateStatus("failed");
-      this._setError(new Error("Max reconnection attempts reached"));
-    }
-  }
-  _updateStatus(status) {
-    this._info = {
-      ...this._info,
-      config: {
-        ...this._info.config,
-        status
-      }
-    };
-  }
-  destroy() {
-    if (this._socket) {
-      import_client.disconnect.call(this._socket);
-      this._socket = null;
-    }
-    this._handlers.clear();
-    this._setReady(false);
-  }
-  reconnect() {
-    this.destroy();
-    this.connect();
-  }
-  _checkRequiredContext() {
-    var _a, _b;
-    return Boolean(
-      ((_a = this._context) == null ? void 0 : _a.appKey) && ((_b = this._context) == null ? void 0 : _b.authToken) && this._socket
-    );
-  }
-  isReady() {
-    if (this._checkRequiredContext()) {
-      this._setReady(true);
-    }
-    return this._ready;
-  }
-}