@cuboapp/crdt 1.0.0

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "trailingComma": "none",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true,
+  "eslintIntegration": true,
+  "printWidth": 140
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@cuboapp/crdt",
+  "version": "1.0.0",
+  "description": "CRDT for CUBO",
+  "main": "src/index.ts",
+  "repository": "git@github.com:cuboapp/crdt.git",
+  "author": "CuboSoft",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@cuboapp/constants": "^2.0.6",
+    "@cuboapp/database": "^1.0.3",
+    "@cuboapp/types": "^2.0.11",
+    "@cuboapp/utils": "1.0.9",
+    "@cuboapp/ws": "../ws",
+    "pg": "^8.16.3",
+    "ws": "^8.19.0",
+    "yjs": "^13.6.29"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,83 @@
+import { EventEmitter } from '@cuboapp/utils'
+import { createWsClient, WsClient } from '@cuboapp/ws'
+
+export type CuboCrdtClientOptions = {
+  host?: string
+  port?: number
+  authToken?: () => Promise<string>
+  debug?: boolean
+}
+
+export class CuboCrdtClient {
+  private ws: WsClient
+
+  constructor(
+    private opts: CuboCrdtClientOptions,
+    private ee = new EventEmitter()
+  ) {
+    this.ws = createWsClient({
+      host: this.opts.host,
+      port: this.opts.port,
+      autoReconnect: true,
+      pingInterval: 5000,
+      authToken: this.opts.authToken ? () => this.opts.authToken!() : () => ''
+    })
+  }
+
+  public async start() {
+    await this.ws.connect()
+
+    this.ws.registerHandler('message', this.onMessage.bind(this))
+  }
+
+  public async stop() {
+    try {
+      await this.ws.disconnect()
+    } catch {}
+  }
+
+  private onMessage({ message }: any) {
+    if (message.event) {
+      this.ee.emit(message.event, message)
+    }
+  }
+
+  async subscribe(event: string, cb: any, filters?: any) {
+    if (this.opts.debug) {
+      console.log('subscribe', event)
+    }
+
+    this.ee.addListener(event, cb)
+    this.ws.request({ method: 'crdt:subscribe', data: { event, filters } })
+  }
+
+  async unsubscribe(event: string, cb: any) {
+    if (this.opts.debug) {
+      console.log('unsubscribe', event)
+    }
+    this.ee.removeListener(event, cb)
+    this.ws.request({ method: 'crdt:unsubscribe', data: { event } })
+  }
+
+  async openDocument<T>(entity: string, id: number): Promise<T> {
+    const state = await this.ws.request(
+      {
+        method: 'crdt:open',
+        data: { name: `${entity}:${id}` }
+      },
+      { wait: true }
+    )
+
+    return state as T
+  }
+
+  async closeDocument(entity: string, id: number) {
+    await this.ws.request(
+      {
+        method: 'crdt:close',
+        data: { name: `${entity}:${id}` }
+      },
+      { wait: true }
+    )
+  }
+}

package/src/index.ts

@@ -0,0 +1,91 @@
+import { type CuboApiEntitiesMap } from '@cuboapp/types'
+import { EventEmitter } from '@cuboapp/utils'
+
+import { CuboCrdtOptions } from './types'
+import { CuboCrdtDocument } from './yjs'
+
+export * from './client'
+export * from './types'
+export * from './utils'
+export * from './yjs'
+
+export const CUBO_CRDT_EVENT = {
+  DOCUMENT_UPDATED: 'document:updated',
+  DOCUMENT_DELETED: 'document:deleted',
+  DOCUMENT_CREATED: 'document:created'
+}
+
+export class CuboCrdt<
+  T extends CuboApiEntitiesMap<T>,
+  A = {},
+  K extends string = Extract<keyof T, string>,
+  ID extends string = `${K}:${number | string}`
+> {
+  private documents = new Map<ID, CuboCrdtDocument>()
+  private loading = new Map<ID, Promise<CuboCrdtDocument>>()
+
+  public ee = new EventEmitter()
+
+  constructor(private options: CuboCrdtOptions<A>) {}
+
+  public async start() {}
+
+  public async stop() {}
+
+  public async getDocument(name: ID) {
+    // существующий документ
+    if (!this.documents.has(name)) {
+      if (this.options.debug) {
+        console.log('CRDT create document', name)
+      }
+
+      if (!this.loading.has(name)) {
+        this.loading.set(
+          name,
+          new Promise(async (resolve) => {
+            const document = new CuboCrdtDocument({
+              autoRemove: true,
+              debug: this.options.debug,
+              initialState: () => {
+                return this.options.beforeLoadDocument?.(name)
+              },
+              onUpdate: ({ data, document }) => {
+                this.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_UPDATED, { name, data, document })
+              }
+            })
+
+            await document.init()
+
+            resolve(document)
+          })
+        )
+      }
+
+      this.documents.set(name, await this.loading.get(name)!)
+    }
+
+    return this.documents.get(name)
+  }
+
+  public async updateDocument(name: ID, dto: object) {
+    const document = await this.getDocument(name)
+
+    if (document) {
+      await document.write(dto)
+    }
+
+    await this.checkDocumentUnload(name)
+  }
+
+  public async checkDocumentUnload(name: ID) {
+    const doc = this.documents.get(name)
+
+    if (doc?.opts?.autoRemove && doc.clients.size === 0) {
+      if (this.options.debug) {
+        console.log('CRDT destroy document', name)
+      }
+
+      this.documents.delete(name)
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+import { WsServer, WsServerRequest } from '@cuboapp/ws'
+
+export type CuboCrdtOptions<A> = {
+  host?: string
+  port?: number
+  debug?: boolean
+
+  authHandler?: (ctx: { server: WsServer<{ auth: A }>; request: WsServerRequest<{ auth: A }> }) => Promise<A> | A
+
+  beforeLoadDocument?: (name: string) => Promise<any> | any
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+import { CuboApiEntitiesMap } from '@cuboapp/types'
+
+import { CuboCrdt, CuboCrdtOptions } from '..'
+
+export function createCrdt<T extends CuboApiEntitiesMap<T>, A = {}>(opts: CuboCrdtOptions<A>) {
+  return new CuboCrdt<T, A>(opts)
+}

package/src/yjs/index.ts

@@ -0,0 +1,100 @@
+import { type WsServerSocket } from '@cuboapp/ws'
+import { Doc } from 'yjs'
+
+export type CuboCrdtDocumentHooks = {
+  onBeforeDestroy?: () => Promise<void> | void
+  onAfterDestroy?: () => Promise<void> | void
+}
+
+export type CuboCrdtDocumentOptions = CuboCrdtDocumentHooks & {
+  autoRemove?: boolean
+  debug?: boolean
+  initial?: any
+
+  initialState?: () => Promise<any>
+  onUpdate?: (ctx: { data: Uint8Array<ArrayBufferLike>; document: CuboCrdtDocument }) => void
+
+  yjsOptions?: {
+    guid?: string
+    collectionid?: string
+    gc?: boolean
+    gcFilter?: () => true
+    meta?: any
+  }
+}
+
+export class CuboCrdtDocument {
+  private ydoc: Doc
+  public clients = new Set<WsServerSocket>()
+
+  constructor(public opts?: CuboCrdtDocumentOptions) {
+    opts = opts || {}
+    opts.autoRemove = opts?.autoRemove ?? true
+  }
+
+  get stat() {
+    return {
+      clients: this.clients.size
+    }
+  }
+
+  async init() {
+    this.ydoc = new Doc({
+      ...(this.opts?.yjsOptions || {}),
+      autoLoad: false,
+      shouldLoad: false
+    })
+
+    const state = this.opts?.initialState ? await this.opts?.initialState() : {}
+
+    return new Promise<void>((resolve) => {
+      this.ydoc.once('updateV2', () => {
+        this.ydoc.on('updateV2', (data) => {
+          this.opts?.onUpdate?.({ data, document: this })
+        })
+
+        resolve()
+      })
+
+      this.ydoc.transact((t) => {
+        const map = t.doc.getMap()
+
+        Object.entries(state).forEach(([key, value]) => {
+          map.set(key, value)
+        })
+      })
+    })
+  }
+
+  getMap(name?: string) {
+    return this.ydoc.getMap(name)
+  }
+
+  async hasClient(client: WsServerSocket) {
+    return this.clients.has(client)
+  }
+
+  async addClient(client: WsServerSocket) {
+    this.clients.add(client)
+  }
+
+  async removeClient(client: WsServerSocket) {
+    this.clients.delete(client)
+  }
+
+  async write(dto: object) {
+    return new Promise<void>(async (resolve) => {
+      this.ydoc.transact(({ doc }) => {
+        const map = doc.getMap()
+
+        Object.entries(dto).forEach(([key, value]) => {
+          map.set(key, value)
+        })
+
+        // Внимание! Резолв промиса не означает раскатку по всем подключениям,
+        // только лишь запись в Yjs-документ
+        resolve()
+      })
+    })
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}