Merge branch 'master' into conat-router-peer-discovery

Author: haraldschilly

src/packages/backend/conat/test/core/services.test.ts

@@ -8,7 +8,7 @@ import {
   connect,
   delay,
 } from "@cocalc/backend/conat/test/setup";
-import { Client, type Message } from "@cocalc/conat/core/client";
+import type { Client, Message } from "@cocalc/conat/core/client";
 import { wait } from "@cocalc/backend/conat/test/util";
 
 beforeAll(before);

src/packages/conat/core/client.ts

@@ -604,10 +604,9 @@ export class Client extends EventEmitter {
       );
     }
     timeout = Math.min(timeout, MAX_INTEREST_TIMEOUT);
-    const response = await this.conn.timeout(timeout ? timeout : 10000).emitWithAck(
-      "wait-for-interest",
-      { subject, timeout },
-    );
+    const response = await this.conn
+      .timeout(timeout ? timeout : 10000)
+      .emitWithAck("wait-for-interest", { subject, timeout });
     if (response.error) {
       throw new ConatError(response.error, { code: response.code });
     }
@@ -1083,9 +1082,14 @@ export class Client extends EventEmitter {
           throw Error(`${name} not defined`);
         }
         const result = await f.apply(mesg, args);
-        mesg.respondSync(result);
+        // use await mesg.respond so waitForInterest is on, which is almost always
+        // good for services.
+        await mesg.respond(result);
       } catch (err) {
-        mesg.respondSync(null, { headers: { error: `${err}` } });
+        await mesg.respond(null, {
+          noThrow: true, // we're not catching this one
+          headers: { error: `${err}` },
+        });
       }
     };
     const loop = async () => {

src/packages/conat/files/sync.ts

@@ -20,7 +20,9 @@ OUTPUT: starts (or keeps running) the filesystem aware side of an editing sessio
 
 */
 
-// import { type Client } from "@cocalc/conat/core/client";
+import type { Client, Message, Subscription } from "@cocalc/conat/core/client";
+import { STICKY_QUEUE_GROUP } from "@cocalc/conat/core/client";
+import { isValidUUID } from "@cocalc/util/misc";
 
 interface SyncDoc {
   close: () => void;
@@ -32,7 +34,6 @@ export type SyncDocCreator = (opts: {
   doctype?: any;
 }) => SyncDoc;
 
-/*
 interface Options {
   client: Client;
 
@@ -43,28 +44,74 @@ interface Options {
   createSyncDoc: SyncDocCreator;
 }
 
-export function init(opts: Options) {
-  return new SyncServer(opts.client, opts.projects, opts.createSyncDocs);
+export async function init(opts: Options) {
+  const syncServer = new SyncServer(
+    opts.client,
+    opts.projects,
+    opts.createSyncDoc,
+  );
+  await syncServer.init();
+  return syncServer;
 }
 
 interface Api {
   open: (opts: { path: string; doctype?: any }) => Promise<void>;
 }
 
 class SyncServer {
-  constructor(client: Client, projects: string, createSyncDoc: SyncDocCreator) {
-    this.client.service = await client1.service<Api>("arith.*", {
-      add: async (a, b) => a + b,
-      mul: async (a, b) => a * b,
-      // Here we do NOT use an arrow => function and this is
-      // bound to the calling mesg, which lets us get the subject.
-      // Because user identity and permissions are done via wildcard
-      // subjects, having access to the calling message is critical
-      async open({ path, doctype }) {
-        const mesg: Message = this as any;
-        console.log(mesg.subject);
+  private service?: Subscription;
+  private syncDocs: { [key: string]: SyncDoc } = {};
+  private interest: { [key: string]: number } = {};
+
+  constructor(
+    private client: Client,
+    private projects: string,
+    private createSyncDoc: SyncDocCreator,
+  ) {}
+
+  init = async () => {
+    const self = this;
+    this.service = await this.client.service<Api>(
+      "sync.*.open",
+      {
+        async open({ path, doctype }) {
+          const mesg: Message = this as any;
+          self.open(mesg.subject, path, doctype);
+        },
       },
+      { queue: STICKY_QUEUE_GROUP },
+    );
+  };
+
+  private key = (project_id, path) => {
+    return `${project_id}/${path}`;
+  };
+
+  private open = (subject: string, path: string, doctype) => {
+    const project_id = subject.split(".")[1]?.slice("project-".length);
+    console.log("open", {
+      subject,
+      path,
+      doctype,
+      project_id,
+      projects: this.projects,
     });
-  }
+    if (!isValidUUID(project_id)) {
+      throw Error("invalid subject");
+    }
+    const key = this.key(project_id, path);
+    if (this.syncDocs[key] === undefined) {
+      this.syncDocs[key] = this.createSyncDoc({ project_id, path, doctype });
+    }
+    this.interest[key] = Date.now();
+  };
+
+  close = () => {
+    this.service?.close();
+    delete this.service;
+    for (const key in this.syncDocs) {
+      this.syncDocs[key].close();
+      delete this.syncDocs[key];
+    }
+  };
 }
-*/

src/packages/conat/hub/api/system.ts

@@ -23,6 +23,7 @@ export const system = {
   deletePassport: authFirst,
 
   adminSalesloftSync: authFirst,
+  userSalesloftSync: authFirst,
 };
 
 export interface System {
@@ -103,6 +104,8 @@ export interface System {
     account_ids: string[];
   }) => Promise<void>;
 
+  userSalesloftSync: (opts: { account_id?: string }) => Promise<void>;
+
   sendEmailVerification: (opts: {
     account_id?: string;
     only_verify?: boolean;

src/packages/conat/sync/pubsub.ts

@@ -53,7 +53,7 @@ export class PubSub extends EventEmitter {
   };
 
   set = (obj) => {
-    this.client.publish(this.subject, obj);
+    this.client.publishSync(this.subject, obj);
   };
 
   private subscribe = async () => {

src/packages/frontend/account/actions.ts

@@ -244,4 +244,43 @@ export class AccountActions extends Actions<AccountState> {
     // @ts-ignore
     this.setState({ fragment });
   };
+
+  addTag = async (tag: string) => {
+    const store = this.redux.getStore("account");
+    if (!store) return;
+    const tags = store.get("tags");
+    if (tags?.includes(tag)) {
+      // already tagged
+      return;
+    }
+    const table = this.redux.getTable("account");
+    if (!table) return;
+    const v = tags?.toJS() ?? [];
+    v.push(tag);
+    table.set({ tags: v });
+    try {
+      await webapp_client.conat_client.hub.system.userSalesloftSync({});
+    } catch (err) {
+      console.warn(
+        "WARNING: issue syncing  with salesloft after setting tag",
+        tag,
+        err,
+      );
+    }
+  };
+
+  // delete won't be visible in frontend until a browser refresh...
+  deleteTag = async (tag: string) => {
+    const store = this.redux.getStore("account");
+    if (!store) return;
+    const tags = store.get("tags");
+    if (!tags?.includes(tag)) {
+      // already tagged
+      return;
+    }
+    const table = this.redux.getTable("account");
+    if (!table) return;
+    const v = tags.toJS().filter((x) => x != tag);
+    await webapp_client.async_query({ query: { accounts: { tags: v } } });
+  };
 }

src/packages/frontend/account/table.ts

@@ -47,7 +47,7 @@ export class AccountTable extends Table {
           ssh_keys: null,
           created: null,
           unlisted: null,
-          //tags: null,
+          tags: null,
           tours: null,
           purchase_closing_day: null,
           email_daily_statements: null,

src/packages/frontend/app/query-params.ts

@@ -79,4 +79,5 @@ export function init_query_params(): void {
   // not have session in the URL, so we can share url's without infected
   // other user's session.
   QueryParams.remove("session");
+
 }

src/packages/frontend/app/sign-in-action.ts

@@ -0,0 +1,115 @@
+/*
+Do something somewhat friendly when a user signs in for the first time,
+either after creating an account or being signed out.
+
+For now:
+
+- ensure they are a collab on at least one project
+- open the most recent project they actively used and show the +New page
+
+That's it for now.
+*/
+
+import { delay } from "awaiting";
+import { redux } from "@cocalc/frontend/app-framework";
+import { once } from "@cocalc/util/async-utils";
+import { webapp_client } from "@cocalc/frontend/webapp-client";
+import { cmp } from "@cocalc/util/misc";
+import { QueryParams } from "@cocalc/frontend/misc/query-params";
+
+export default async function signInAction() {
+  const signIn = QueryParams.get("sign-in");
+  if (signIn == null) {
+    return;
+  }
+  QueryParams.remove("sign-in");
+  await delay(1); // so projects store is created (not in sync initial load loop)
+  const project_id = await getProject();
+  const actions = redux.getActions("projects");
+  actions.open_project({ project_id, switch_to: true, target: "new" });
+  await actions.start_project(project_id);
+}
+
+async function create(title = "My First Project") {
+  const project_id = await webapp_client.project_client.create({
+    title,
+    description: "",
+  });
+  const projects = redux.getStore("projects");
+  // wait until projects_map is loaded, so we know what projects the users has (probably)
+  while (projects.getIn(["project_map", project_id]) == null) {
+    await once(projects, "change");
+  }
+  return project_id;
+}
+
+async function getProject(): Promise<string> {
+  const projects = redux.getStore("projects");
+  // wait until projects_map is loaded, so we know what projects the users has (probably)
+  while (projects.get("project_map") == null) {
+    await once(projects, "change");
+  }
+  const account = redux.getStore("account");
+  while (account.get("created") == null) {
+    await once(account, "change");
+  }
+
+  const created = account.get("created");
+  let project_map = projects.get("project_map")!;
+  if (project_map.size == 0) {
+    // no known projects -- could be a new account, or could be an old account and no *recent* projects
+    if (
+      (created?.valueOf() ?? Date.now()) >=
+      Date.now() - 2 * 24 * 60 * 60 * 1000
+    ) {
+      // new account -- make a project
+      return await create("My First Project");
+    } else {
+      // old account but no projects -- try loading all.
+      const projectActions = redux.getActions("projects");
+      await projectActions.load_all_projects();
+      project_map = projects.get("project_map")!;
+      if (project_map.size == 0) {
+        // still nothing -- just create
+        return await create();
+      }
+    }
+  }
+
+  const account_id = account.get("account_id");
+
+  // now there should be at least one project in project_map.
+  // Is there a non-deleted non-hidden project?
+  const options: any[] = [];
+  for (const [_, project] of project_map) {
+    if (project.get("deleted")) {
+      continue;
+    }
+    if (project.getIn(["users", account_id, "hide"])) {
+      continue;
+    }
+    options.push(project);
+  }
+  if (options.length == 0) {
+    return await create();
+  }
+
+  // Sort the projects by when YOU were last active on the project, or if you were
+  // never active on any project, by when the projects was last_edited.
+  const usedByYou = options.filter((x) => x.getIn(["last_active", account_id]));
+
+  if (usedByYou.length == 0) {
+    //  you were never active on any project, so just return project most recently edited
+    options.sort((x, y) => -cmp(x.get("last_edited"), y.get("last_edited")));
+    return options[0].get("project_id");
+  }
+
+  usedByYou.sort(
+    (x, y) =>
+      -cmp(
+        x.getIn(["last_active", account_id]),
+        y.getIn(["last_active", account_id]),
+      ),
+  );
+  return usedByYou[0].get("project_id");
+}

src/packages/frontend/components/sortable-tabs.tsx

@@ -156,7 +156,11 @@ export function renderTabBar(tabBarProps, DefaultTabBar, styles?) {
   return (
     <DefaultTabBar {...tabBarProps}>
       {(node) => (
-        <SortableTab key={node.key} id={node.key} style={styles?.[node.key]}>
+        <SortableTab
+          key={node.key}
+          id={node.key}
+          style={styles?.[node.key] ?? styles?.[""]}
+        >
           {node}
         </SortableTab>
       )}