UBERF-9747

Signed-off-by: Andrey Sobolev <[email protected]>

Author: haiodo

.vscode/launch.json

@@ -103,7 +103,8 @@
         "UPLOAD_URL": "/files",
         "AI_BOT_URL": "http://localhost:4010",
         "STATS_URL": "http://huly.local:4900",
-        "QUEUE_CONFIG": "localhost:19092"
+        "QUEUE_CONFIG": "localhost:19092",
+        "RATE_LIMIT_MAX": "25000"
       },
       "runtimeArgs": ["--nolazy", "-r", "ts-node/register"],
       "runtimeVersion": "20",

models/core/src/tx.ts

@@ -49,9 +49,6 @@ export class TTx extends TDoc implements Tx {
     objectSpace!: Ref<Space>
 }
 
-@Model(core.class.TxModelUpgrade, core.class.Tx, DOMAIN_TX)
-export class TTxModelUpgrade extends TTx {}
-
 @Model(core.class.TxCUD, core.class.Tx)
 export class TTxCUD<T extends Doc> extends TTx implements TxCUD<T> {
   @Prop(TypeRef(core.class.Doc), core.string.Object)

packages/core/src/__tests__/client.test.ts

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 import { IntlString, Plugin } from '@hcengineering/platform'
-import { ClientConnectEvent, DocChunk } from '..'
-import type { Class, Data, Doc, Domain, PluginConfiguration, Ref, Timestamp } from '../classes'
+import { ClientConnectEvent, DocChunk, type WorkspaceUuid } from '..'
+import type { Account, Class, Data, Doc, Domain, PluginConfiguration, Ref, Timestamp } from '../classes'
 import { ClassifierKind, DOMAIN_MODEL, Space } from '../classes'
 import { ClientConnection, createClient } from '../client'
 import core from '../component'
@@ -104,21 +104,25 @@ describe('client', () => {
       }
 
       return new (class implements ClientConnection {
-        handler?: (event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>
+        handler?: (event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>
 
         set onConnect (
-          handler: ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>) | undefined
+          handler: ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>) | undefined
         ) {
           this.handler = handler
-          void this.handler?.(ClientConnectEvent.Connected, '', {})
+          void this.handler?.(ClientConnectEvent.Connected, {}, {})
         }
 
         get onConnect ():
-        | ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>)
+        | ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>)
         | undefined {
           return this.handler
         }
 
+        getAccount (): Promise<Account > {
+          throw new Error('Method not implemented.')
+        }
+
         isConnected = (): boolean => true
         findAll = findAll
         pushHandler = (): void => {}

packages/core/src/__tests__/connection.ts

@@ -13,8 +13,8 @@
 // limitations under the License.
 //
 
-import { ClientConnectEvent, DocChunk, generateId } from '..'
-import type { Class, Doc, Domain, Ref, Timestamp } from '../classes'
+import { ClientConnectEvent, DocChunk, generateId, type WorkspaceUuid } from '..'
+import type { Account, Class, Doc, Domain, Ref, Timestamp } from '../classes'
 import { ClientConnection } from '../client'
 import core from '../component'
 import { Hierarchy } from '../hierarchy'
@@ -47,19 +47,23 @@ export async function connect (handler: (tx: Tx) => void): Promise<ClientConnect
     isConnected = (): boolean => true
     findAll = findAll
 
-    handler?: (event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>
+    handler?: (event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>
 
     set onConnect (
-      handler: ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>) | undefined
+      handler: ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>) | undefined
     ) {
       this.handler = handler
-      void this.handler?.(ClientConnectEvent.Connected, '', {})
+      void this.handler?.(ClientConnectEvent.Connected, {}, {})
     }
 
-    get onConnect (): ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>) | undefined {
+    get onConnect (): ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>) | undefined {
       return this.handler
     }
 
+    getAccount (): Promise<Account> {
+      throw new Error('Method not implemented.')
+    }
+
     async searchFulltext (query: SearchQuery, options: SearchOptions): Promise<SearchResult> {
       return { docs: [] }
     }

packages/core/src/classes.ts

@@ -71,7 +71,10 @@ export interface Obj {
 
 export interface Account {
   uuid: AccountUuid
-  role: AccountRole
+  roles: Record<WorkspaceUuid, AccountRole>
+
+  role: AccountRole // Role in current workspace
+  targetWorkspace: WorkspaceUuid // In case target workspace is used, it will be filled with personal workspace UUID in case of all workspaces mode.
   primarySocialId: PersonId
   socialIds: PersonId[]
   fullSocialIds: SocialId[]
@@ -521,7 +524,8 @@ export enum AccountRole {
   Guest = 'GUEST',
   User = 'USER',
   Maintainer = 'MAINTAINER',
-  Owner = 'OWNER'
+  Owner = 'OWNER',
+  Undetermined = 'UNDETERMINED' // In case of multi workspaces mode
 }
 
 /**
@@ -530,6 +534,7 @@ export enum AccountRole {
 export const roleOrder: Record<AccountRole, number> = {
   [AccountRole.DocGuest]: 10,
   [AccountRole.Guest]: 20,
+  [AccountRole.Undetermined]: 25,
   [AccountRole.User]: 30,
   [AccountRole.Maintainer]: 40,
   [AccountRole.Owner]: 50

packages/core/src/client.ts

@@ -15,15 +15,16 @@
 
 import { Analytics } from '@hcengineering/analytics'
 import { BackupClient, DocChunk } from './backup'
-import { Class, DOMAIN_MODEL, Doc, Domain, Ref, Timestamp } from './classes'
+import { Class, DOMAIN_MODEL, Doc, Domain, Ref, Timestamp, type Account } from './classes'
 import core from './component'
 import { Hierarchy } from './hierarchy'
 import { MeasureContext, MeasureMetricsContext } from './measurements'
 import { ModelDb } from './memdb'
 import type { DocumentQuery, FindOptions, FindResult, FulltextStorage, Storage, TxResult, WithLookup } from './storage'
 import { SearchOptions, SearchQuery, SearchResult } from './storage'
 import { Tx, TxCUD, WorkspaceEvent, type TxWorkspaceEvent } from './tx'
-import { platformNow, platformNowDiff, toFindResult } from './utils'
+import { platformNow, platformNowDiff, toFindResult, type WorkspaceUuid } from './utils'
+import { deepEqual } from 'fast-equals'
 
 /**
  * @public
@@ -80,13 +81,15 @@ export interface ClientConnection extends Storage, FulltextStorage, BackupClient
   isConnected: () => boolean
 
   close: () => Promise<void>
-  onConnect?: (event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>
+  onConnect?: (event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>
 
   // If hash is passed, will return LoadModelResponse
   loadModel: (last: Timestamp, hash?: string) => Promise<Tx[] | LoadModelResponse>
 
-  getLastHash?: (ctx: MeasureContext) => Promise<string | undefined>
+  getLastHash?: (ctx: MeasureContext) => Promise<Record<WorkspaceUuid, string | undefined>>
   pushHandler: (handler: Handler) => void
+
+  getAccount: () => Promise<Account>
 }
 
 class ClientImpl implements Client, BackupClient {
@@ -237,7 +240,7 @@ export async function createClient (
   let hierarchy = new Hierarchy()
   let model = new ModelDb(hierarchy)
 
-  let lastTx: string | undefined
+  let lastTx: Record<WorkspaceUuid, string | undefined> | undefined
 
   function txHandler (...tx: Tx[]): void {
     if (tx == null || tx.length === 0) {
@@ -282,7 +285,7 @@ export async function createClient (
   txBuffer = undefined
 
   const oldOnConnect:
-  | ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>)
+  | ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>)
   | undefined = conn.onConnect
   conn.onConnect = async (event, _lastTx, data) => {
     console.log('Client: onConnect', event)
@@ -324,7 +327,7 @@ export async function createClient (
       return
     }
 
-    if (lastTx === _lastTx) {
+    if (deepEqual(lastTx, _lastTx)) {
       // Same lastTx, no need to refresh
       await oldOnConnect?.(ClientConnectEvent.Reconnected, _lastTx, data)
       return
@@ -362,9 +365,13 @@ async function loadModel (
     hash: ''
   }
 
-  if (conn.getLastHash !== undefined && (await conn.getLastHash(ctx)) === current.hash) {
-    // We have same model hash.
-    return { mode: 'same', current: current.transactions, addition: [] }
+  if (conn.getLastHash !== undefined) {
+    const lastHash = await conn.getLastHash(ctx)
+    const account = await conn.getAccount()
+    if (lastHash[account.targetWorkspace] === current.hash) {
+      // We have same model hash.
+      return { mode: 'same', current: current.transactions, addition: [] }
+    }
   }
   const lastTxTime = getLastTxTime(current.transactions)
   const result = await ctx.with('connection-load-model', { hash: current.hash !== '' }, (ctx) =>

packages/core/src/component.ts

@@ -15,9 +15,9 @@
 import type { Asset, IntlString, Metadata, Plugin, StatusCode } from '@hcengineering/platform'
 import { plugin } from '@hcengineering/platform'
 import type { BenchmarkDoc } from './benchmark'
-import { AccountRole } from './classes'
 import type {
   Account,
+  AccountUuid,
   AnyAttribute,
   ArrOf,
   Association,
@@ -59,21 +59,21 @@ import type {
   TypeAny,
   TypedSpace,
   UserStatus,
-  Version,
-  AccountUuid
+  Version
 } from './classes'
+import { AccountRole } from './classes'
 import { Status, StatusCategory } from './status'
 import type {
   Tx,
   TxApplyIf,
   TxCUD,
   TxCreateDoc,
   TxMixin,
-  TxModelUpgrade,
   TxRemoveDoc,
   TxUpdateDoc,
   TxWorkspaceEvent
 } from './tx'
+import type { WorkspaceUuid } from './utils'
 
 /**
  * @public
@@ -88,7 +88,9 @@ export const systemAccountEmail = '[email protected]'
 export const systemAccountUuid = '1749089e-22e6-48de-af4e-165e18fbd2f9' as AccountUuid
 export const systemAccount: Account = {
   uuid: systemAccountUuid,
+  roles: { },
   role: AccountRole.Owner,
+  targetWorkspace: systemAccountUuid as any as WorkspaceUuid,
   primarySocialId: '' as PersonId,
   socialIds: [],
   fullSocialIds: []
@@ -107,7 +109,6 @@ export default plugin(coreId, {
     Interface: '' as Ref<Class<Interface<Doc>>>,
     Attribute: '' as Ref<Class<AnyAttribute>>,
     Tx: '' as Ref<Class<Tx>>,
-    TxModelUpgrade: '' as Ref<Class<TxModelUpgrade>>,
     TxWorkspaceEvent: '' as Ref<Class<TxWorkspaceEvent>>,
     TxApplyIf: '' as Ref<Class<TxApplyIf>>,
     TxCUD: '' as Ref<Class<TxCUD<Doc>>>,

packages/core/src/tx.ts

@@ -34,7 +34,7 @@ import { setObjectValue } from './objvalue'
 import { _getOperator } from './operator'
 import { _toDoc } from './proxy'
 import type { DocumentQuery, TxResult } from './storage'
-import { generateId } from './utils'
+import { generateId, type WorkspaceUuid } from './utils'
 
 /**
  * @public
@@ -52,7 +52,9 @@ export enum WorkspaceEvent {
   SecurityChange,
   MaintenanceNotification,
   BulkUpdate,
-  LastTx
+  LastTx,
+  WorkpaceActive,
+  ModelUpgrade = 7
 }
 
 /**
@@ -62,6 +64,7 @@ export enum WorkspaceEvent {
 export interface TxWorkspaceEvent<T = any> extends Tx {
   event: WorkspaceEvent
   params: T
+  workspace?: WorkspaceUuid
 }
 
 /**
@@ -78,11 +81,6 @@ export interface BulkUpdateEvent {
   _class: Ref<Class<Doc>>[]
 }
 
-/**
- * @public
- */
-export interface TxModelUpgrade extends Tx {}
-
 /**
  * @public
  */

packages/core/src/utils.ts

@@ -762,7 +762,10 @@ export function isOwnerOrMaintainer (): boolean {
 }
 
 export function hasAccountRole (acc: Account, targerRole: AccountRole): boolean {
-  return roleOrder[acc.role] >= roleOrder[targerRole]
+  if (acc.targetWorkspace == null) {
+    throw new Error('Account has no target workspace')
+  }
+  return roleOrder[acc.roles[acc.targetWorkspace]] >= roleOrder[targerRole]
 }
 
 export function getBranding (brandings: BrandingMap, key: string | undefined): Branding | null {

packages/query/src/__tests__/connection.ts

@@ -39,7 +39,9 @@ import core, {
   Timestamp,
   Tx,
   TxDb,
-  TxResult
+  TxResult,
+  type Account,
+  type WorkspaceUuid
 } from '@hcengineering/core'
 import { genMinModel } from './minmodel'
 
@@ -50,6 +52,7 @@ FulltextStorage & {
   isConnected: () => boolean
   loadModel: (last: Timestamp, hash?: string) => Promise<Tx[] | LoadModelResponse>
   pushHandler: (handler: Handler) => void
+  getAccount: () => Promise<Account>
 }
 > {
   const txes = genMinModel()
@@ -150,18 +153,22 @@ FulltextStorage & {
 
     async sendForceClose (): Promise<void> {}
 
-    handler?: (event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>
+    handler?: (event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>
 
     set onConnect (
-      handler: ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>) | undefined
+      handler: ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>) | undefined
     ) {
       this.handler = handler
-      void this.handler?.(ClientConnectEvent.Connected, '', {})
+      void this.handler?.(ClientConnectEvent.Connected, {}, {})
     }
 
-    get onConnect (): ((event: ClientConnectEvent, lastTx: string | undefined, data: any) => Promise<void>) | undefined {
+    get onConnect (): ((event: ClientConnectEvent, lastTx: Record<WorkspaceUuid, string | undefined> | undefined, data: any) => Promise<void>) | undefined {
       return this.handler
     }
+
+    getAccount (): Promise<Account> {
+      throw new Error('Method not implemented.')
+    }
   }
 
   return new TestConnection(hierarchy, model, transactions)