(core) read document as owner in pre-fork mode, if have sufficient access to it

Summary:
This tweaks pre-fork mode to make the user's experience a bit more seamless.
Pre-fork mode is where the user has opened a document with intent to
fork it, but actual forking (with allocation of a new document id)
is postponed until they make their first change.

The tweak makes the user an owner for granular access purposes, if
forking is permitted.  So data visible only to owners because of
access rules will be visible to them.  As always, any edits would
go to a separate new copy.

A remaining tricky corner is what to do about "View As" functionality
on forks.  Fork sharing cannot be controlled, so the "Users -> View As"
functionality isn't available.  Perhaps the "Users" button on a fork
could encourage doing a save-copy and inviting users, or offer some
dummy users?  In any case, this diff doesn't change anything with
that corner.

Test Plan: added test

Reviewers: dsagal

Reviewed By: dsagal

Differential Revision: https://phab.getgrist.com/D2931

app/server/lib/DocManager.ts

@@ -288,11 +288,38 @@ export class DocManager extends EventEmitter {
       throw new Error(`document ${docId} cannot be opened right now`);
     }
 
+    // Get a fresh DocSession object.
     const docSession = activeDoc.addClient(client, auth);
+
+    // If opening in (pre-)fork mode, check if it is appropriate to treat the user as
+    // an owner for granular access purposes.
+    if (mode === 'fork') {
+      if (await activeDoc.canForkAsOwner(docSession)) {
+        // Mark the session specially and flush any cached access
+        // information.  It is easier to make this a property of the
+        // session than to try computing it later in the heat of
+        // battle, since it introduces a loop where a user property
+        // (user.Access) depends on evaluating rules, but rules need
+        // the user properties in order to be evaluated.  It is also
+        // somewhat justifiable even if permissions change later on
+        // the theory that the fork is theoretically happening at this
+        // instance).
+        docSession.forkingAsOwner = true;
+        activeDoc.flushAccess(docSession);
+      } else {
+        // TODO: it would be kind to pass on a message to the client
+        // to let them know they won't be able to fork.  They'll get
+        // an error when they make their first change.  But currently
+        // we only have the blunt instrument of throwing an error,
+        // which would prevent access to the document entirely.
+      }
+    }
+
     const [metaTables, recentActions] = await Promise.all([
       activeDoc.fetchMetaTables(docSession),
       activeDoc.getRecentActions(docSession, false)
     ]);
+
     this.emit('open-doc', this.storageManager.getPath(activeDoc.docName));
 
     return {