[DRAFT] Workspace layer refactor

localtypings/projectheader.d.ts

@@ -28,7 +28,8 @@ declare namespace pxt.workspace {
         tutorialCompleted?: pxt.tutorial.TutorialCompletionInfo;
         // workspace guid of the extension under test
         extensionUnderTest?: string;
-        cloudSync?: boolean; // Mark a header for syncing with a cloud provider
+        // id of cloud user who created this project
+        cloudUserId?: string;
     }
 
     export interface Header extends InstallHeader {
@@ -41,10 +42,14 @@ declare namespace pxt.workspace {
         isDeleted: boolean; // mark whether or not a header has been deleted
         saveId?: any; // used to determine whether a project has been edited while we're saving to cloud
 
-        // For cloud providers
-        blobId: string;       // id of the cloud blob holding this script
-        blobVersion: string;  // version of the cloud blob
-        blobCurrent: boolean; // has the current version of the script been pushed to cloud
+        // For cloud providers -- DEPRECATED
+        blobId_: string;       // id of the cloud blob holding this script
+        blobVersion_: string;  // version of the cloud blob
+        blobCurrent_: boolean; // has the current version of the script been pushed to cloud
+
+        cloudVersion: string;     // The cloud-assigned version number (e.g. etag)
+        // TODO @darzu: "cloudCurrent" seems very bad. This is a stateful notation and it is hard to reason about whether or not this is true.
+        cloudCurrent: boolean;    // Has the current version of the project been pushed to cloud
 
         // Used for Updating projects
         backupRef?: string; // guid of backed-up project (present if an update was interrupted)

localtypings/pxtpackage.d.ts

@@ -2,6 +2,7 @@ declare namespace pxt {
 
     type CodeCardType = "file" | "example" | "codeExample" | "tutorial" | "side" | "template" | "package" | "hw" | "forumUrl" | "forumExample" | "sharedExample";
     type CodeCardEditorType = "blocks" | "js" | "py";
+    type CodeCardCloudState = "local" | "cloud";
 
     interface Map<T> {
         [index: string]: T;
@@ -159,6 +160,7 @@ declare namespace pxt {
         cardType?: CodeCardType;
         editor?: CodeCardEditorType;
         otherActions?: CodeCardAction[];
+        cloudState?: CodeCardCloudState;
 
         header?: string;
 

pxteditor/editor.ts

@@ -215,12 +215,11 @@ namespace pxt.editor {
         importExampleAsync(options: ExampleImportOptions): Promise<void>;
         showScriptManager(): void;
         importProjectDialog(): void;
-        cloudSync(): boolean;
-        cloudSignInDialog(): void;
-        cloudSignOut(): void;
         removeProject(): void;
         editText(): void;
 
+        hasCloudSync(): boolean;
+
         getPreferredEditor(): string;
         saveAndCompile(): void;
         updateHeaderName(name: string): void;

pxteditor/workspace.ts

@@ -54,9 +54,12 @@ namespace pxt.workspace {
             id: U.guidGen(),
             recentUse: modTime,
             modificationTime: modTime,
-            blobId: null,
-            blobVersion: null,
-            blobCurrent: false,
+            blobId_: null,
+            blobVersion_: null,
+            blobCurrent_: false,
+            cloudUserId: null,
+            cloudCurrent: false,
+            cloudVersion: null,
             isDeleted: false,
         }
         return header

webapp/src/app.tsx

@@ -95,7 +95,7 @@ function setEditor(editor: ProjectView) {
 }
 
 export class ProjectView
-    extends data.Component<IAppProps, IAppState>
+    extends auth.Component<IAppProps, IAppState>
     implements IProjectView {
     editor: srceditor.Editor;
     editorFile: pkg.File;
@@ -173,7 +173,6 @@ export class ProjectView
         this.openDeviceSerial = this.openDeviceSerial.bind(this);
         this.toggleGreenScreen = this.toggleGreenScreen.bind(this);
         this.toggleSimulatorFullscreen = this.toggleSimulatorFullscreen.bind(this);
-        this.cloudSignInComplete = this.cloudSignInComplete.bind(this);
         this.toggleSimulatorCollapse = this.toggleSimulatorCollapse.bind(this);
         this.showKeymap = this.showKeymap.bind(this);
         this.toggleKeymap = this.toggleKeymap.bind(this);
@@ -1335,7 +1334,10 @@ export class ProjectView
             if (editorState.searchBar === undefined) editorState.searchBar = oldEditorState.searchBar;
         }
 
-        if (!h.cloudSync && this.cloudSync()) h.cloudSync = true;
+        // If user is signed in, sync this project to the cloud.
+        if (this.hasCloudSync()) {
+            h.cloudUserId = this.getUser()?.id;
+        }
 
         return compiler.newProjectAsync()
             .then(() => h.backupRef ? workspace.restoreFromBackupAsync(h) : Promise.resolve())
@@ -2006,62 +2008,6 @@ export class ProjectView
             })
     }
 
-    ///////////////////////////////////////////////////////////
-    ////////////             Cloud                 ////////////
-    ///////////////////////////////////////////////////////////
-
-    cloudSync() {
-        return this.hasSync();
-    }
-
-    cloudSignInDialog() {
-        const providers = cloudsync.providers();
-        if (providers.length == 0)
-            return;
-        if (providers.length == 1)
-            providers[0].loginAsync().then(() => {
-                this.cloudSignInComplete();
-            })
-        else {
-            // TODO: Revisit in new cloud sync
-            //this.signInDialog.show();
-        }
-    }
-
-    cloudSignOut() {
-        core.confirmAsync({
-            header: lf("Sign out"),
-            body: lf("You are signing out. Make sure that you commited all your changes, local projects will be deleted."),
-            agreeClass: "red",
-            agreeIcon: "sign out",
-            agreeLbl: lf("Sign out"),
-        }).then(r => {
-            if (r) {
-                const inEditor = !!this.state.header;
-                // Reset the cloud workspace
-                return workspace.resetCloudAsync()
-                    .then(() => {
-                        if (inEditor) {
-                            this.openHome();
-                        }
-                        if (this.home) {
-                            this.home.forceUpdate();
-                        }
-                    })
-            }
-            return Promise.resolve();
-        });
-    }
-
-    cloudSignInComplete() {
-        pxt.log('cloud sign in complete');
-        initLogin();
-        cloudsync.syncAsync()
-            .then(() => {
-                this.forceUpdate();
-            }).done();
-    }
-
     ///////////////////////////////////////////////////////////
     ////////////             Home                 /////////////
     ///////////////////////////////////////////////////////////
@@ -2251,7 +2197,7 @@ export class ProjectView
             pubCurrent: false,
             target: pxt.appTarget.id,
             targetVersion: pxt.appTarget.versions.target,
-            cloudSync: this.cloudSync(),
+            cloudUserId: this.getUser()?.id,
             temporary: options.temporary,
             tutorial: options.tutorial,
             extensionUnderTest: options.extensionUnderTest
@@ -3090,6 +3036,10 @@ export class ProjectView
         }
     }
 
+    hasCloudSync() {
+        return this.isLoggedIn();
+    }
+
     showScriptManager() {
         this.scriptManagerDialog.show();
     }
@@ -4545,7 +4495,9 @@ document.addEventListener("DOMContentLoaded", () => {
     else if (isSandbox) workspace.setupWorkspace("mem");
     else if (pxt.winrt.isWinRT()) workspace.setupWorkspace("uwp");
     else if (pxt.BrowserUtils.isIpcRenderer()) workspace.setupWorkspace("idb");
-    else if (pxt.BrowserUtils.isLocalHost() || pxt.BrowserUtils.isPxtElectron()) workspace.setupWorkspace("fs");
+    // TODO @darzu: uncomment. this disables filesystem workspace
+    //else if (pxt.BrowserUtils.isLocalHost() || pxt.BrowserUtils.isPxtElectron()) workspace.setupWorkspace("fs");
+    else workspace.setupWorkspace("browser");
     Promise.resolve()
         .then(async () => {
             const href = window.location.href;

webapp/src/auth.ts

@@ -465,12 +465,18 @@ export async function initialUserPreferences(): Promise<UserPreferences | undefi
     return initialUserPreferences_;
 }
 
-function loggedInSync(): boolean {
+export function loggedInSync(): boolean {
     if (!hasIdentity()) { return false; }
     const state = getState();
     return !!state.profile?.id;
 }
 
+export function user(): UserProfile {
+    if (!hasIdentity()) { return null; }
+    const state = getState();
+    return { ...state.profile };
+}
+
 async function fetchUserAsync(): Promise<UserProfile | undefined> {
     const state = getState();
 
@@ -637,5 +643,5 @@ data.mountVirtualApi(MODULE, { getSync: authApiHandler });
 
 
 // ClouddWorkspace must be included after we mount our virtual APIs.
-import * as cloudWorkspace from "./cloudworkspace";
+import * as cloudWorkspace from "./cloud";
 cloudWorkspace.init();

webapp/src/browserdbworkspace.ts

@@ -0,0 +1,62 @@
+import * as db from "./db";
+
+type Header = pxt.workspace.Header;
+type ScriptText = pxt.workspace.ScriptText;
+
+type TextDbEntry = {
+    id: string,
+    files?: ScriptText,
+    _rev: any
+}
+
+export interface BrowserDbWorkspaceProvider extends pxt.workspace.WorkspaceProvider {
+    prefix: string;
+}
+
+export function createBrowserDbWorkspace(namespace: string): BrowserDbWorkspaceProvider {
+    const prefix = namespace ? namespace + "-" : ""
+    const headerDb = new db.Table(`${prefix}header`);
+    const textDb = new db.Table(`${prefix}text`);
+
+    async function listAsync(): Promise<pxt.workspace.Header[]> {
+        return headerDb.getAllAsync()
+    }
+    async function getAsync(h: Header): Promise<pxt.workspace.File> {
+        const resp: TextDbEntry = await textDb.getAsync(h.id)
+        return {
+            header: h,
+            text: resp.files,
+            version: resp._rev
+        }
+    }
+    async function setAsync(h: Header, prevVer: any, text?: ScriptText): Promise<string> {
+        const textEnt: TextDbEntry = { 
+            id: h.id,
+            files: text,
+            _rev: prevVer
+        }
+        const retrev = await textDb.setAsync(textEnt)
+        const rev = await headerDb.setAsync(h)
+        h._rev = rev
+        return retrev
+    }
+    async function deleteAsync(h: Header, prevVer: any): Promise<void> {
+        await headerDb.deleteAsync(h)
+        await textDb.deleteAsync({ id: h.id, _rev: h._rev })
+    }
+    async function resetAsync() {
+        // workspace.resetAsync already clears all tables
+        // TODO @darzu: I don't like that worksapce reset does that....
+        return Promise.resolve();
+    }
+
+    const provider: BrowserDbWorkspaceProvider = {
+        prefix,
+        getAsync,
+        setAsync,
+        deleteAsync,
+        listAsync,
+        resetAsync,
+    }
+    return provider;
+}