zen-desktop/src/browser/base/zen-components/ZenWorkspacesSync.mjs

var { Tracker, Store, SyncEngine } = ChromeUtils.importESModule('resource://services-sync/engines.sys.mjs');
var { CryptoWrapper } = ChromeUtils.importESModule('resource://services-sync/record.sys.mjs');
var { Utils } = ChromeUtils.importESModule('resource://services-sync/util.sys.mjs');
var { SCORE_INCREMENT_XLARGE } = ChromeUtils.importESModule('resource://services-sync/constants.sys.mjs');

// Define ZenWorkspaceRecord
function ZenWorkspaceRecord(collection, id) {
  CryptoWrapper.call(this, collection, id);
}

ZenWorkspaceRecord.prototype = Object.create(CryptoWrapper.prototype);
ZenWorkspaceRecord.prototype.constructor = ZenWorkspaceRecord;

ZenWorkspaceRecord.prototype._logName = 'Sync.Record.ZenWorkspace';

Utils.deferGetSet(ZenWorkspaceRecord, 'cleartext', [
  'name',
  'icon',
  'default',
  'containerTabId',
  'position',
  'theme_type',
  'theme_colors',
  'theme_opacity',
  'theme_rotation',
  'theme_texture',
]);

// Define ZenWorkspacesStore
function ZenWorkspacesStore(name, engine) {
  Store.call(this, name, engine);
}

ZenWorkspacesStore.prototype = Object.create(Store.prototype);
ZenWorkspacesStore.prototype.constructor = ZenWorkspacesStore;

/**
 * Initializes the store by loading the current changeset.
 */
ZenWorkspacesStore.prototype.initialize = async function () {
  await Store.prototype.initialize.call(this);
  // Additional initialization if needed
};

/**
 * Retrieves all workspace IDs from the storage.
 * @returns {Object} An object mapping workspace UUIDs to true.
 */
ZenWorkspacesStore.prototype.getAllIDs = async function () {
  try {
    const workspaces = await ZenWorkspacesStorage.getWorkspaces();
    const ids = {};
    for (const workspace of workspaces) {
      ids[workspace.uuid] = true;
    }
    return ids;
  } catch (error) {
    this._log.error('Error fetching all workspace IDs', error);
    throw error;
  }
};

/**
 * Handles changing the ID of a workspace.
 * @param {String} oldID - The old UUID.
 * @param {String} newID - The new UUID.
 */
ZenWorkspacesStore.prototype.changeItemID = async function (oldID, newID) {
  try {
    const workspaces = await ZenWorkspacesStorage.getWorkspaces();
    const workspace = workspaces.find((ws) => ws.uuid === oldID);
    if (workspace) {
      workspace.uuid = newID;
      await ZenWorkspacesStorage.saveWorkspace(workspace, false);
      // Mark the new ID as changed for sync
      await ZenWorkspacesStorage.markChanged(newID);
    }
  } catch (error) {
    this._log.error(`Error changing workspace ID from ${oldID} to ${newID}`, error);
    throw error;
  }
};

/**
 * Checks if a workspace exists.
 * @param {String} id - The UUID of the workspace.
 * @returns {Boolean} True if the workspace exists, false otherwise.
 */
ZenWorkspacesStore.prototype.itemExists = async function (id) {
  try {
    const workspaces = await ZenWorkspacesStorage.getWorkspaces();
    return workspaces.some((ws) => ws.uuid === id);
  } catch (error) {
    this._log.error(`Error checking if workspace exists with ID ${id}`, error);
    throw error;
  }
};

/**
 * Creates a record for a workspace.
 * @param {String} id - The UUID of the workspace.
 * @param {String} collection - The collection name.
 * @returns {ZenWorkspaceRecord} The workspace record.
 */
ZenWorkspacesStore.prototype.createRecord = async function (id, collection) {
  try {
    const workspaces = await ZenWorkspacesStorage.getWorkspaces();
    const workspace = workspaces.find((ws) => ws.uuid === id);
    const record = new ZenWorkspaceRecord(collection, id);

    if (workspace) {
      record.name = workspace.name;
      record.icon = workspace.icon;
      record.default = workspace.default;
      record.containerTabId = workspace.containerTabId;
      record.position = workspace.position;
      if (workspace.theme) {
        record.theme_type = workspace.theme.type;
        record.theme_colors = JSON.stringify(workspace.theme.gradientColors);
        record.theme_opacity = workspace.theme.opacity;
        record.theme_rotation = workspace.theme.rotation;
        record.theme_texture = workspace.theme.texture;
      }
      record.deleted = false;
    } else {
      record.deleted = true;
    }

    return record;
  } catch (error) {
    this._log.error(`Error creating record for workspace ID ${id}`, error);
    throw error;
  }
};

/**
 * Creates a new workspace.
 * @param {ZenWorkspaceRecord} record - The workspace record to create.
 */
ZenWorkspacesStore.prototype.create = async function (record) {
  try {
    this._validateRecord(record);
    const workspace = {
      uuid: record.id,
      name: record.name,
      icon: record.icon,
      default: record.default,
      containerTabId: record.containerTabId,
      position: record.position,
      theme: record.theme_type
        ? {
            type: record.theme_type,
            gradientColors: JSON.parse(record.theme_colors),
            opacity: record.theme_opacity,
            rotation: record.theme_rotation,
            texture: record.theme_texture,
          }
        : null,
    };
    await ZenWorkspacesStorage.saveWorkspace(workspace, false);
  } catch (error) {
    this._log.error(`Error creating workspace with ID ${record.id}`, error);
    throw error;
  }
};

/**
 * Updates an existing workspace.
 * @param {ZenWorkspaceRecord} record - The workspace record to update.
 */
ZenWorkspacesStore.prototype.update = async function (record) {
  try {
    this._validateRecord(record);
    await this.create(record); // Reuse create for update
  } catch (error) {
    this._log.error(`Error updating workspace with ID ${record.id}`, error);
    throw error;
  }
};

/**
 * Removes a workspace.
 * @param {ZenWorkspaceRecord} record - The workspace record to remove.
 */
ZenWorkspacesStore.prototype.remove = async function (record) {
  try {
    await ZenWorkspacesStorage.removeWorkspace(record.id, false);
  } catch (error) {
    this._log.error(`Error removing workspace with ID ${record.id}`, error);
    throw error;
  }
};

/**
 * Wipes all workspaces from the storage.
 */
ZenWorkspacesStore.prototype.wipe = async function () {
  try {
    await ZenWorkspacesStorage.wipeAllWorkspaces();
  } catch (error) {
    this._log.error('Error wiping all workspaces', error);
    throw error;
  }
};

/**
 * Validates a workspace record.
 * @param {ZenWorkspaceRecord} record - The workspace record to validate.
 */
ZenWorkspacesStore.prototype._validateRecord = function (record) {
  if (!record.id || typeof record.id !== 'string') {
    throw new Error('Invalid workspace ID');
  }
  if (!record.name || typeof record.name !== 'string') {
    throw new Error(`Invalid workspace name for ID ${record.id}`);
  }
  if (typeof record.default !== 'boolean') {
    record.default = false;
  }
  if (record.icon != null && typeof record.icon !== 'string') {
    throw new Error(`Invalid icon for workspace ID ${record.id}`);
  }
  if (record.containerTabId != null && typeof record.containerTabId !== 'number') {
    throw new Error(`Invalid containerTabId for workspace ID ${record.id}`);
  }
  if (record.position != null && typeof record.position !== 'number') {
    throw new Error(`Invalid position for workspace ID ${record.id}`);
  }

  // Validate theme properties if they exist
  if (record.theme_type) {
    if (typeof record.theme_type !== 'string') {
      throw new Error(`Invalid theme_type for workspace ID ${record.id}`);
    }
    if (!record.theme_colors || typeof record.theme_colors !== 'string') {
      throw new Error(`Invalid theme_colors for workspace ID ${record.id}`);
    }
    try {
      JSON.parse(record.theme_colors);
    } catch (e) {
      throw new Error(`Invalid theme_colors JSON for workspace ID ${record.id}`);
    }
    if (record.theme_opacity != null && typeof record.theme_opacity !== 'number') {
      throw new Error(`Invalid theme_opacity for workspace ID ${record.id}`);
    }
    if (record.theme_rotation != null && typeof record.theme_rotation !== 'number') {
      throw new Error(`Invalid theme_rotation for workspace ID ${record.id}`);
    }
    if (record.theme_texture != null && typeof record.theme_texture !== 'number') {
      throw new Error(`Invalid theme_texture for workspace ID ${record.id}`);
    }
  }
};

/**
 * Retrieves changed workspace IDs since the last sync.
 * @returns {Object} An object mapping workspace UUIDs to their change timestamps.
 */
ZenWorkspacesStore.prototype.getChangedIDs = async function () {
  try {
    return await ZenWorkspacesStorage.getChangedIDs();
  } catch (error) {
    this._log.error('Error retrieving changed IDs from storage', error);
    throw error;
  }
};

/**
 * Clears all recorded changes after a successful sync.
 */
ZenWorkspacesStore.prototype.clearChangedIDs = async function () {
  try {
    await ZenWorkspacesStorage.clearChangedIDs();
  } catch (error) {
    this._log.error('Error clearing changed IDs in storage', error);
    throw error;
  }
};

/**
 * Marks a workspace as changed.
 * @param {String} uuid - The UUID of the workspace that changed.
 */
ZenWorkspacesStore.prototype.markChanged = async function (uuid) {
  try {
    await ZenWorkspacesStorage.markChanged(uuid);
  } catch (error) {
    this._log.error(`Error marking workspace ${uuid} as changed`, error);
    throw error;
  }
};

/**
 * Finalizes the store by ensuring all pending operations are completed.
 */
ZenWorkspacesStore.prototype.finalize = async function () {
  await Store.prototype.finalize.call(this);
};

// Define ZenWorkspacesTracker
function ZenWorkspacesTracker(name, engine) {
  Tracker.call(this, name, engine);
  this._ignoreAll = false;

  // Observe profile-before-change to stop the tracker gracefully
  Services.obs.addObserver(this.asyncObserver, 'profile-before-change');
}

ZenWorkspacesTracker.prototype = Object.create(Tracker.prototype);
ZenWorkspacesTracker.prototype.constructor = ZenWorkspacesTracker;

/**
 * Retrieves changed workspace IDs by delegating to the store.
 * @returns {Object} An object mapping workspace UUIDs to their change timestamps.
 */
ZenWorkspacesTracker.prototype.getChangedIDs = async function () {
  try {
    return await this.engine._store.getChangedIDs();
  } catch (error) {
    this._log.error('Error retrieving changed IDs from store', error);
    throw error;
  }
};

/**
 * Clears all recorded changes after a successful sync.
 */
ZenWorkspacesTracker.prototype.clearChangedIDs = async function () {
  try {
    await this.engine._store.clearChangedIDs();
  } catch (error) {
    this._log.error('Error clearing changed IDs in store', error);
    throw error;
  }
};

/**
 * Called when the tracker starts. Registers observers to listen for workspace changes.
 */
ZenWorkspacesTracker.prototype.onStart = function () {
  if (this._started) {
    return;
  }
  this._log.trace('Starting tracker');
  // Register observers for workspace changes
  Services.obs.addObserver(this.asyncObserver, 'zen-workspace-added');
  Services.obs.addObserver(this.asyncObserver, 'zen-workspace-removed');
  Services.obs.addObserver(this.asyncObserver, 'zen-workspace-updated');
  this._started = true;
};

/**
 * Called when the tracker stops. Unregisters observers.
 */
ZenWorkspacesTracker.prototype.onStop = function () {
  if (!this._started) {
    return;
  }
  this._log.trace('Stopping tracker');
  // Unregister observers for workspace changes
  Services.obs.removeObserver(this.asyncObserver, 'zen-workspace-added');
  Services.obs.removeObserver(this.asyncObserver, 'zen-workspace-removed');
  Services.obs.removeObserver(this.asyncObserver, 'zen-workspace-updated');
  this._started = false;
};

/**
 * Handles observed events and marks workspaces as changed accordingly.
 * @param {nsISupports} subject - The subject of the notification.
 * @param {String} topic - The topic of the notification.
 * @param {String} data - Additional data (JSON stringified array of UUIDs).
 */
ZenWorkspacesTracker.prototype.observe = async function (subject, topic, data) {
  if (this.ignoreAll) {
    return;
  }

  try {
    switch (topic) {
      case 'profile-before-change':
        await this.stop();
        break;
      case 'zen-workspace-removed':
      case 'zen-workspace-updated':
      case 'zen-workspace-added':
        let workspaceIDs;
        if (data) {
          try {
            workspaceIDs = JSON.parse(data);
            if (!Array.isArray(workspaceIDs)) {
              throw new Error('Parsed data is not an array');
            }
          } catch (parseError) {
            this._log.error(`Failed to parse workspace UUIDs from data: ${data}`, parseError);
            return;
          }
        } else {
          this._log.error(`No data received for event ${topic}`);
          return;
        }

        this._log.trace(`Observed ${topic} for UUIDs: ${workspaceIDs.join(', ')}`);

        // Process each UUID
        for (const workspaceID of workspaceIDs) {
          if (typeof workspaceID === 'string') {
            // Inform the store about the change
            await this.engine._store.markChanged(workspaceID);
          } else {
            this._log.warn(`Invalid workspace ID encountered: ${workspaceID}`);
          }
        }

        // Bump the score once after processing all changes
        if (workspaceIDs.length > 0) {
          this.score += SCORE_INCREMENT_XLARGE;
        }
        break;
    }
  } catch (error) {
    this._log.error(`Error handling ${topic} in observe method`, error);
  }
};

/**
 * Finalizes the tracker by ensuring all pending operations are completed.
 */
ZenWorkspacesTracker.prototype.finalize = async function () {
  await Tracker.prototype.finalize.call(this);
};

// Define ZenWorkspacesEngine
function ZenWorkspacesEngine(service) {
  SyncEngine.call(this, 'Workspaces', service);
}

ZenWorkspacesEngine.prototype = Object.create(SyncEngine.prototype);
ZenWorkspacesEngine.prototype.constructor = ZenWorkspacesEngine;

ZenWorkspacesEngine.prototype._storeObj = ZenWorkspacesStore;
ZenWorkspacesEngine.prototype._trackerObj = ZenWorkspacesTracker;
ZenWorkspacesEngine.prototype._recordObj = ZenWorkspaceRecord;
ZenWorkspacesEngine.prototype.version = 2;

ZenWorkspacesEngine.prototype.syncPriority = 10;
ZenWorkspacesEngine.prototype.allowSkippedRecord = false;

Object.setPrototypeOf(ZenWorkspacesEngine.prototype, SyncEngine.prototype);