codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/shared/scopedPersistenceQueuePolicy.js

@@ -0,0 +1,200 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafScopedPersistenceQueuePolicy = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function createQueueClaim(input) {
+    return Object.freeze({
+      itemId: cleanPart(input && input.itemId),
+      ownerId: cleanPart(input && input.ownerId),
+      queueRevision: normalizeRevision(input && input.queueRevision),
+      claimedAt: cleanPart(input && input.claimedAt) || new Date().toISOString()
+    });
+  }
+
+  function isClaimCurrent(claim, queueState) {
+    return Boolean(claim && queueState
+      && cleanPart(claim.itemId) === cleanPart(queueState.itemId)
+      && cleanPart(claim.ownerId) === cleanPart(queueState.ownerId)
+      && normalizeRevision(claim.queueRevision) === normalizeRevision(queueState.queueRevision));
+  }
+
+  function mergeTombstones(existing, additions, limit) {
+    var result = Object.assign({}, existing && typeof existing === 'object' ? existing : {});
+    var now = new Date().toISOString();
+    (Array.isArray(additions) ? additions : []).forEach(function (id) {
+      var cleanId = cleanPart(id);
+      if (cleanId) result[cleanId] = now;
+    });
+    var max = Number.isFinite(Number(limit)) ? Math.max(1, Number(limit)) : 100;
+    return Object.fromEntries(Object.entries(result)
+      .sort(function (left, right) { return String(right[1]).localeCompare(String(left[1])); })
+      .slice(0, max));
+  }
+
+  function normalizeMeta(value) {
+    var revision = normalizeRevision(value && value.revision);
+    var hasDurableRevision = Boolean(value
+      && Object.prototype.hasOwnProperty.call(value, 'durableRevision'));
+    var durableRevision = hasDurableRevision
+      ? Math.min(normalizeRevision(value.durableRevision), revision)
+      : revision;
+    var pendingValue = value && value.pendingCommit;
+    var pendingRevision = normalizeRevision(pendingValue && pendingValue.revision);
+    var pendingCommit = pendingValue && typeof pendingValue === 'object'
+      && pendingRevision > durableRevision
+      && pendingRevision <= revision
+      ? {
+          revision: pendingRevision,
+          writerId: cleanPart(pendingValue.writerId),
+          startedAt: cleanPart(pendingValue.startedAt)
+        }
+      : null;
+    return {
+      revision: revision,
+      durableRevision: durableRevision,
+      pendingCommit: pendingCommit,
+      queueRevision: normalizeRevision(value && value.queueRevision),
+      writerId: cleanPart(value && value.writerId),
+      updatedAt: cleanPart(value && value.updatedAt),
+      queueClaims: normalizeQueueClaims(value && value.queueClaims),
+      queueTombstones: normalizeTombstoneMap(value && value.queueTombstones),
+      sessionTombstones: normalizeTombstoneMap(value && value.sessionTombstones)
+    };
+  }
+
+  function normalizeQueueMutations(options) {
+    var values = [];
+    if (options && options.queueMutation) values.push(options.queueMutation);
+    if (options && Array.isArray(options.queueMutations)) values.push.apply(values, options.queueMutations);
+    return values.filter(function (value) {
+      return value && typeof value === 'object' && cleanPart(value.type);
+    });
+  }
+
+  function applyQueueMutations(meta, mutations, writerId) {
+    var next = normalizeMeta(meta);
+    for (var mutation of mutations) {
+      var type = cleanPart(mutation.type);
+      var itemId = cleanPart(mutation.itemId);
+      var sessionId = cleanPart(mutation.sessionId);
+      if (!itemId && type !== 'transition') {
+        return { ok: false, reason: 'invalid_queue_mutation' };
+      }
+      if (type === 'remove' || type === 'release' || type === 'restore') {
+        var claimed = next.queueClaims[itemId];
+        var mutationToken = cleanPart(mutation.claimToken);
+        if (claimed && !isExpiredClaim(claimed)
+          && (claimed.ownerId !== writerId
+            || !mutationToken
+            || claimed.claimToken !== mutationToken)) {
+          return {
+            ok: false,
+            reason: 'queue_claim_conflict',
+            ownerId: claimed.ownerId,
+            itemId: itemId
+          };
+        }
+      }
+      if (type === 'claim') {
+        var existing = next.queueClaims[itemId];
+        if (existing && existing.ownerId !== writerId && !isExpiredClaim(existing)) {
+          return {
+            ok: false,
+            reason: 'queue_claim_conflict',
+            ownerId: existing.ownerId,
+            itemId: itemId
+          };
+        }
+        next.queueRevision += 1;
+        next.queueClaims[itemId] = {
+          ...createQueueClaim({
+            itemId: itemId,
+            ownerId: writerId,
+            queueRevision: next.queueRevision
+          }),
+          sessionId: sessionId,
+          claimToken: cleanPart(mutation.claimToken)
+        };
+        continue;
+      }
+      if (type === 'remove') {
+        next.queueRevision += 1;
+        next.queueTombstones = mergeTombstones(next.queueTombstones, [itemId], 500);
+        delete next.queueClaims[itemId];
+        continue;
+      }
+      if (type === 'release') {
+        next.queueRevision += 1;
+        delete next.queueClaims[itemId];
+        continue;
+      }
+      if (type === 'restore') {
+        next.queueRevision += 1;
+        delete next.queueClaims[itemId];
+        delete next.queueTombstones[itemId];
+        continue;
+      }
+      if (type === 'enqueue' || type === 'transition') {
+        next.queueRevision += 1;
+        continue;
+      }
+      return { ok: false, reason: 'invalid_queue_mutation' };
+    }
+    return { ok: true, meta: next };
+  }
+
+  function normalizeQueueClaims(value) {
+    var source = value && typeof value === 'object' ? value : {};
+    var result = {};
+    Object.entries(source).forEach(function (entry) {
+      var itemId = cleanPart(entry[0]);
+      var claim = entry[1] && typeof entry[1] === 'object' ? entry[1] : {};
+      var ownerId = cleanPart(claim.ownerId);
+      if (!itemId || !ownerId) return;
+      result[itemId] = {
+        itemId: itemId,
+        ownerId: ownerId,
+        sessionId: cleanPart(claim.sessionId),
+        claimToken: cleanPart(claim.claimToken),
+        queueRevision: normalizeRevision(claim.queueRevision),
+        claimedAt: cleanPart(claim.claimedAt)
+      };
+    });
+    return result;
+  }
+
+  function normalizeTombstoneMap(value) {
+    var source = value && typeof value === 'object' ? value : {};
+    return Object.fromEntries(Object.entries(source)
+      .map(function (entry) { return [cleanPart(entry[0]), cleanPart(entry[1])]; })
+      .filter(function (entry) { return entry[0] && entry[1]; }));
+  }
+
+  function isExpiredClaim(claim, now) {
+    var claimedAt = Date.parse(claim && claim.claimedAt || '');
+    return !claimedAt || (Number(now || Date.now()) - claimedAt) > 60 * 1000;
+  }
+
+  function normalizeRevision(value) {
+    var number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+  }
+
+  function cleanPart(value) {
+    return typeof value === 'string' ? value.trim() : '';
+  }
+
+  return Object.freeze({
+    applyQueueMutations: applyQueueMutations,
+    cleanPart: cleanPart,
+    createQueueClaim: createQueueClaim,
+    isClaimCurrent: isClaimCurrent,
+    mergeTombstones: mergeTombstones,
+    normalizeMeta: normalizeMeta,
+    normalizeQueueMutations: normalizeQueueMutations,
+    normalizeRevision: normalizeRevision
+  });
+});

package/extension/src/shared/scopedPersistenceReceipt.js

@@ -0,0 +1,60 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafModuleRegistry.define('ScopedPersistenceReceipt', [], factory);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  'use strict';
+
+  function createFenceMeta(meta, currentMeta, writerId) {
+    var startedAt = new Date().toISOString();
+    var revision = currentMeta.revision + 1;
+    return {
+      ...meta,
+      revision: revision,
+      durableRevision: currentMeta.durableRevision,
+      pendingCommit: { revision: revision, writerId: writerId, startedAt: startedAt },
+      writerId: writerId,
+      updatedAt: startedAt
+    };
+  }
+
+  function createCommittedMeta(fenceMeta) {
+    return {
+      ...fenceMeta,
+      durableRevision: fenceMeta.revision,
+      pendingCommit: null,
+      updatedAt: new Date().toISOString()
+    };
+  }
+
+  function createRecoveredMeta(currentMeta, fenceMeta, writerId) {
+    var revision = fenceMeta.revision + 1;
+    return {
+      ...currentMeta,
+      revision: revision,
+      durableRevision: revision,
+      pendingCommit: null,
+      queueRevision: fenceMeta.queueRevision + 1,
+      writerId: writerId,
+      updatedAt: new Date().toISOString()
+    };
+  }
+
+  function decorateReceiptError(error, revision) {
+    if (error && typeof error === 'object') {
+      error.code = error.code || 'persistence_receipt_write_failed';
+      error.persistenceActionCommitted = true;
+      error.persistenceRevision = revision;
+    }
+    return error;
+  }
+
+  return Object.freeze({
+    createFenceMeta: createFenceMeta,
+    createCommittedMeta: createCommittedMeta,
+    createRecoveredMeta: createRecoveredMeta,
+    decorateReceiptError: decorateReceiptError
+  });
+});

package/extension/src/shared/scopedPersistenceTransaction.js

@@ -0,0 +1,241 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(
+      require('./scopedPersistenceQueuePolicy'),
+      require('./scopedPersistenceBrowserAdapter'),
+      require('./scopedPersistenceReceipt')
+    );
+  } else {
+    root.CodexOverleafModuleRegistry.define('ScopedPersistenceTransaction', [
+      'ScopedPersistenceQueuePolicy',
+      'ScopedPersistenceBrowserAdapter',
+      'ScopedPersistenceReceipt'
+    ], factory);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy, BrowserAdapter, Receipt) {
+  'use strict';
+
+  var applyQueueMutations = QueuePolicy.applyQueueMutations;
+  var cleanPart = QueuePolicy.cleanPart;
+  var createQueueClaim = QueuePolicy.createQueueClaim;
+  var isClaimCurrent = QueuePolicy.isClaimCurrent;
+  var mergeTombstones = QueuePolicy.mergeTombstones;
+  var normalizeMeta = QueuePolicy.normalizeMeta;
+  var normalizeQueueMutations = QueuePolicy.normalizeQueueMutations;
+  var normalizeRevision = QueuePolicy.normalizeRevision;
+  var createBrowserAdapter = BrowserAdapter.createBrowserAdapter;
+  var normalizeScope = BrowserAdapter.normalizeScope;
+  var scopeKey = BrowserAdapter.scopeKey;
+
+  function sameScope(left, right) {
+    return Boolean(left && right
+      && left.accountScopeId === right.accountScopeId
+      && left.projectId === right.projectId);
+  }
+
+
+  function createCoordinator(options) {
+    options = options || {};
+    var adapter = options.adapter || createBrowserAdapter(options);
+    var writerId = cleanPart(options.writerId) || randomId();
+    var generation = 0;
+    var active = null;
+
+    async function beginHydration(inputScope) {
+      var scope = normalizeScope(inputScope);
+      generation += 1;
+      var tokenGeneration = generation;
+      active = tokenFromMeta(scope, tokenGeneration, false, {});
+      var meta = await strictRead(adapter, scope);
+      var token = tokenFromMeta(scope, tokenGeneration, false, meta);
+      if (active && active.generation === tokenGeneration && sameScope(active, token)) active = token;
+      return token;
+    }
+
+    async function captureCommitView(inputScope, captureOptions) {
+      var scope = normalizeScope(inputScope);
+      var detached = Boolean(captureOptions && captureOptions.detached);
+      if (!detached && active && active.projectId === scope.projectId) {
+        scope = normalizeScope({
+          accountScopeId: active.accountScopeId,
+          projectId: scope.projectId
+        });
+      }
+      if (!detached && active && sameScope(active, scope)) {
+        return tokenFromMeta(scope, active.generation, false, active);
+      }
+      var meta = await strictRead(adapter, scope);
+      return tokenFromMeta(scope, detached ? 0 : generation, detached, meta);
+    }
+
+    function isCurrent(token) {
+      return Boolean(token && active && token.detached !== true
+        && token.generation === active.generation && sameScope(token, active));
+    }
+
+    async function commit(token, action, commitOptions) {
+      if (!token || typeof action !== 'function' || !token.projectId) {
+        return { ok: false, reason: 'invalid_commit' };
+      }
+      var scope = normalizeScope(token);
+      if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+      return adapter.withLock(scope, async function () {
+        if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+        var currentMeta = await strictRead(adapter, scope);
+        if (!token.detached && !isCurrent(token)) return { ok: false, reason: 'stale_view' };
+        var conflict = currentMeta.revision !== normalizeRevision(token.revision);
+        if (conflict && !(commitOptions && commitOptions.rebase === true)) {
+          return {
+            ok: false,
+            reason: 'revision_conflict',
+            expectedRevision: token.revision,
+            actualRevision: currentMeta.revision
+          };
+        }
+        var queueMutations = normalizeQueueMutations(commitOptions);
+        if (queueMutations.length
+          && currentMeta.queueRevision !== normalizeRevision(token.queueRevision)) {
+          if (!token.detached && isCurrent(token)) {
+            active = tokenFromMeta(scope, token.generation, false, currentMeta);
+          }
+          return {
+            ok: false,
+            reason: 'queue_revision_conflict',
+            expectedRevision: token.queueRevision,
+            actualRevision: currentMeta.queueRevision,
+            actualStateRevision: currentMeta.revision
+          };
+        }
+        var projected = applyQueueMutations(currentMeta, queueMutations, writerId);
+        if (!projected.ok) return projected;
+        var nextMeta = Receipt.createFenceMeta({
+          ...projected.meta,
+          sessionTombstones: mergeTombstones(
+            projected.meta.sessionTombstones,
+            commitOptions && commitOptions.sessionTombstones,
+            200
+          )
+        }, currentMeta, writerId);
+        await adapter.write(scope, nextMeta);
+        if (!token.detached && isCurrent(token)) {
+          active = tokenFromMeta(scope, token.generation, false, nextMeta);
+        }
+        var value;
+        try {
+          value = await action({
+            scope: scope,
+            baseRevision: currentMeta.revision,
+            durableRevision: currentMeta.durableRevision,
+            conflict: conflict,
+            previousCommitIncomplete: Boolean(currentMeta.pendingCommit),
+            writerId: writerId,
+            currentMeta: currentMeta,
+            nextMeta: nextMeta
+          });
+        } catch (error) {
+          if (queueMutations.some(function (mutation) {
+            return ['remove', 'release', 'restore'].includes(cleanPart(mutation.type));
+          })) {
+            var recoveredMeta = Receipt.createRecoveredMeta(currentMeta, nextMeta, writerId);
+            try {
+              await adapter.write(scope, recoveredMeta);
+              if (!token.detached && isCurrent(token)) {
+                active = tokenFromMeta(scope, token.generation, false, recoveredMeta);
+              }
+            } catch (recoveryError) {
+              if (error && typeof error === 'object') {
+                error.persistenceRecoveryError = recoveryError.message || String(recoveryError);
+              }
+            }
+          }
+          throw error;
+        }
+        var committedMeta = Receipt.createCommittedMeta(nextMeta);
+        try {
+          await adapter.write(scope, committedMeta);
+        } catch (error) {
+          throw Receipt.decorateReceiptError(error, nextMeta.revision);
+        }
+        if (!token.detached && isCurrent(token)) {
+          active = tokenFromMeta(scope, token.generation, false, committedMeta);
+        }
+        return {
+          ok: true,
+          value: value,
+          revision: committedMeta.revision,
+          durableRevision: committedMeta.durableRevision,
+          queueRevision: committedMeta.queueRevision,
+          queueClaims: committedMeta.queueClaims,
+          rebased: conflict,
+          recoveredIncompleteCommit: Boolean(currentMeta.pendingCommit),
+          superseded: !token.detached && !isCurrent(token)
+        };
+      });
+    }
+
+    return Object.freeze({
+      beginHydration: beginHydration,
+      captureCommitView: captureCommitView,
+      commit: commit,
+      getActiveView: function () {
+        return active ? tokenFromMeta(active, active.generation, false, active) : null;
+      },
+      getWriterId: function () { return writerId; },
+      invalidate: function () {
+        generation += 1;
+        active = null;
+      },
+      isCurrent: isCurrent
+    });
+  }
+
+  function makeToken(
+    scope,
+    tokenGeneration,
+    revision,
+    detached,
+    queueRevision,
+    durableRevision,
+    pendingCommit
+  ) {
+    return Object.freeze({
+      accountScopeId: scope.accountScopeId,
+      projectId: scope.projectId,
+      generation: normalizeRevision(tokenGeneration),
+      revision: normalizeRevision(revision),
+      durableRevision: normalizeRevision(durableRevision),
+      pendingCommit: pendingCommit && typeof pendingCommit === 'object'
+        ? Object.freeze({ ...pendingCommit })
+        : null,
+      queueRevision: normalizeRevision(queueRevision),
+      detached: detached === true
+    });
+  }
+
+  function tokenFromMeta(scope, tokenGeneration, detached, meta) {
+    return makeToken(scope, tokenGeneration, meta.revision, detached, meta.queueRevision,
+      meta.durableRevision, meta.pendingCommit);
+  }
+
+  async function strictRead(adapter, scope) {
+    return normalizeMeta(await adapter.read(scope));
+  }
+
+  function randomId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+      return crypto.randomUUID();
+    }
+    return 'writer-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+  }
+
+  return Object.freeze({
+    createBrowserAdapter: createBrowserAdapter,
+    createCoordinator: createCoordinator,
+    createQueueClaim: createQueueClaim,
+    isClaimCurrent: isClaimCurrent,
+    mergeTombstones: mergeTombstones,
+    normalizeScope: normalizeScope,
+    sameScope: sameScope,
+    scopeKey: scopeKey
+  });
+});