There can be more than Notion and Miro. AFFiNE(pronounced [ə‘fain]) is a next-gen knowledge base that brings planning, sorting and creating all together. Privacy first, open-source, customizable and ready to use.
TypeScript appcrdteditorelectronknowledge-basemarkdownmironotesnotionnotion-alternativerustrust-langrust-languagetabletableviewwhiteboardwikiworkspace
feat(server): doc model (#9834)
fengmk2b40f007ccf9c
diff --git a/packages/backend/server/src/__tests__/models/doc.spec.ts b/packages/backend/server/src/__tests__/models/doc.spec.tsnew file mode 100644index 0000000000..2f19651b84--- /dev/null+++ b/packages/backend/server/src/__tests__/models/doc.spec.ts@@ -0,0 +1,589 @@+import { randomUUID } from 'node:crypto';++import ava, { TestFn } from 'ava';++import { Config } from '../../base/config';+import { DocModel } from '../../models/doc';+import { type User, UserModel } from '../../models/user';+import { type Workspace, WorkspaceModel } from '../../models/workspace';+import { createTestingModule, type TestingModule } from '../utils';++interface Context {+ config: Config;+ module: TestingModule;+ user: UserModel;+ workspace: WorkspaceModel;+ doc: DocModel;+}++const test = ava as TestFn<Context>;++test.before(async t => {+ const module = await createTestingModule();++ t.context.user = module.get(UserModel);+ t.context.workspace = module.get(WorkspaceModel);+ t.context.doc = module.get(DocModel);+ t.context.config = module.get(Config);+ t.context.module = module;+});++let user: User;+let workspace: Workspace;++test.beforeEach(async t => {+ await t.context.module.initTestingDB();+ user = await t.context.user.create({+ email: '[email protected]',+ });+ workspace = await t.context.workspace.create(user.id);+});++test.after(async t => {+ await t.context.module.close();+});++test('should create a batch updates on a doc', async t => {+ const docId = randomUUID();+ const updates = await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now() + 1000,+ seq: 2,+ },+ ]);+ t.is(updates.count, 2);+});++test('should create error when createdAt timestamp is not unique', async t => {+ const docId = randomUUID();+ const timestamp = Date.now();+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp,+ editorId: user.id,+ seq: 1,+ },+ ]);+ await t.throwsAsync(+ t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp,+ editorId: user.id,+ seq: 2,+ },+ ]),+ {+ message:+ /Unique constraint failed on the fields: \(`workspace_id`,`guid`,`created_at`\)/,+ }+ );+});++test('should find updates by spaceId and docId', async t => {+ const docId = randomUUID();+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now() + 1000,+ editorId: user.id,+ seq: 2,+ },+ ]);+ const foundUpdates = await t.context.doc.findUpdates(workspace.id, docId);+ t.is(foundUpdates.length, 2);+ t.deepEqual(foundUpdates[0].blob, Buffer.from('blob1'));+ t.deepEqual(foundUpdates[1].blob, Buffer.from('blob2'));++ let count = await t.context.doc.getUpdateCount(workspace.id, docId);+ t.is(count, 2);+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob3'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 3,+ },+ ]);+ count = await t.context.doc.getUpdateCount(workspace.id, docId);+ t.is(count, 3);+});++test('should delete updates by spaceId, docId, and createdAts', async t => {+ const docId = randomUUID();+ const timestamps = [Date.now(), Date.now() + 1000];+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: timestamps[0],+ editorId: user.id,+ seq: 1,+ },+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: timestamps[1],+ seq: 2,+ },+ ]);+ let count = await t.context.doc.deleteUpdates(+ workspace.id,+ docId,+ timestamps+ );+ t.is(count, 2);+ count = await t.context.doc.getUpdateCount(workspace.id, docId);+ t.is(count, 0);++ // delete non-existing updates+ count = await t.context.doc.deleteUpdates(workspace.id, docId, timestamps);+ t.is(count, 0);+});++test('should get global update count', async t => {+ const docId = randomUUID();+ const docId2 = randomUUID();+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now() + 1000,+ editorId: user.id,+ seq: 2,+ },+ {+ spaceId: workspace.id,+ docId: docId2,+ blob: Buffer.from('blob2'),+ timestamp: Date.now() + 1000,+ editorId: user.id,+ seq: 2,+ },+ ]);+ const count = await t.context.doc.getGlobalUpdateCount();+ t.is(count, 3);+});++test('should upsert a doc', async t => {+ const snapshot = {+ spaceId: workspace.id,+ docId: randomUUID(),+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ const foundSnapshot = await t.context.doc.get(+ snapshot.spaceId,+ snapshot.docId+ );+ t.truthy(foundSnapshot);+ t.deepEqual(foundSnapshot!.blob, snapshot.blob);+ t.is(foundSnapshot!.editorId, user.id);+ t.is(foundSnapshot!.timestamp, snapshot.timestamp);++ // update snapshot's editorId+ const otherUser = await t.context.user.create({+ email: '[email protected]',+ });+ const newSnapshot = {+ ...snapshot,+ editorId: otherUser.id,+ };+ await t.context.doc.upsert(newSnapshot);+ const updatedSnapshot = await t.context.doc.get(+ snapshot.spaceId,+ snapshot.docId+ );+ t.truthy(updatedSnapshot);+ t.deepEqual(updatedSnapshot!.blob, snapshot.blob);+ t.is(updatedSnapshot!.editorId, otherUser.id);+});++test('should get a doc meta', async t => {+ const snapshot = {+ spaceId: workspace.id,+ docId: randomUUID(),+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ const meta = await t.context.doc.getMeta(snapshot.spaceId, snapshot.docId);+ t.truthy(meta);+ t.deepEqual(meta!.createdByUser, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ t.deepEqual(meta!.updatedByUser, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ t.truthy(meta!.createdAt);+ t.deepEqual(meta!.updatedAt, new Date(snapshot.timestamp));++ // update snapshot's editorId+ const otherUser = await t.context.user.create({+ email: '[email protected]',+ });+ const newSnapshot = {+ ...snapshot,+ editorId: otherUser.id,+ timestamp: Date.now(),+ };+ await t.context.doc.upsert(newSnapshot);+ const updatedSnapshotMeta = await t.context.doc.getMeta(+ snapshot.spaceId,+ snapshot.docId+ );+ t.truthy(updatedSnapshotMeta);+ t.deepEqual(updatedSnapshotMeta!.createdByUser, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ t.deepEqual(updatedSnapshotMeta!.updatedByUser, {+ id: otherUser.id,+ name: otherUser.name,+ avatarUrl: otherUser.avatarUrl,+ });+ // createdAt should not change+ t.deepEqual(updatedSnapshotMeta!.createdAt, meta!.createdAt);+ t.deepEqual(updatedSnapshotMeta!.updatedAt, new Date(newSnapshot.timestamp));++ // get null when doc not found+ const notFoundMeta = await t.context.doc.getMeta(+ snapshot.spaceId,+ randomUUID()+ );+ t.is(notFoundMeta, null);+});++test('should create a history record', async t => {+ const snapshot = {+ spaceId: workspace.id,+ docId: randomUUID(),+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ const created = await t.context.doc.createHistory(snapshot, 1000);+ t.truthy(created);+ t.deepEqual(created.timestamp, snapshot.timestamp);+ t.deepEqual(created.editor, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ const history = await t.context.doc.getHistory(+ snapshot.spaceId,+ snapshot.docId,+ snapshot.timestamp+ );+ t.deepEqual(history, {+ ...created,+ blob: snapshot.blob,+ });+});++test('should return null when history timestamp not match', async t => {+ const snapshot = {+ spaceId: workspace.id,+ docId: randomUUID(),+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ await t.context.doc.createHistory(snapshot, 1000);+ const history = await t.context.doc.getHistory(+ snapshot.spaceId,+ snapshot.docId,+ snapshot.timestamp + 1+ );+ t.is(history, null);+});++test('should find history records', async t => {+ const docId = randomUUID();+ const snapshot1 = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now() - 1000,+ editorId: user.id,+ };+ const snapshot2 = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.createHistory(snapshot1, 1000);+ await t.context.doc.createHistory(snapshot2, 1000);+ let histories = await t.context.doc.findHistories(workspace.id, docId);+ t.is(histories.length, 2);+ t.deepEqual(histories[0].timestamp, snapshot2.timestamp);+ t.deepEqual(histories[0].editor, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ t.deepEqual(histories[1].timestamp, snapshot1.timestamp);+ t.deepEqual(histories[1].editor, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ // only take 1 history, order by timestamp desc+ histories = await t.context.doc.findHistories(workspace.id, docId, {+ take: 1,+ });+ t.is(histories.length, 1);+ t.deepEqual(histories[0].timestamp, snapshot2.timestamp);+ t.deepEqual(histories[0].editor, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ // get empty history+ histories = await t.context.doc.findHistories(workspace.id, docId, {+ before: Date.now() - 1000000,+ });+ t.is(histories.length, 0);+});++test('should get latest history', async t => {+ const docId = randomUUID();+ const snapshot1 = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now() - 1000,+ editorId: user.id,+ };+ const snapshot2 = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.createHistory(snapshot1, 1000);+ await t.context.doc.createHistory(snapshot2, 1000);+ const history = await t.context.doc.getLatestHistory(workspace.id, docId);+ t.truthy(history);+ t.deepEqual(history!.timestamp, snapshot2.timestamp);+ t.deepEqual(history!.editor, {+ id: user.id,+ name: user.name,+ avatarUrl: user.avatarUrl,+ });+ // return null when no history+ const emptyHistory = await t.context.doc.getLatestHistory(+ workspace.id,+ randomUUID()+ );+ t.is(emptyHistory, null);+});++test('should delete a doc, including histories, snapshots and updates', async t => {+ const docId = randomUUID();+ const snapshot = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ await t.context.doc.createHistory(snapshot, 1000);+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ ]);+ await t.context.doc.delete(workspace.id, docId);+ const foundSnapshot = await t.context.doc.get(workspace.id, docId);+ t.is(foundSnapshot, null);+ const foundHistory = await t.context.doc.getLatestHistory(+ workspace.id,+ docId+ );+ t.is(foundHistory, null);+ const foundUpdates = await t.context.doc.findUpdates(workspace.id, docId);+ t.is(foundUpdates.length, 0);+});++test('should delete all docs in a workspace', async t => {+ const docId1 = randomUUID();+ const docId2 = randomUUID();+ const snapshot1 = {+ spaceId: workspace.id,+ docId: docId1,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ const snapshot2 = {+ spaceId: workspace.id,+ docId: docId2,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot1);+ await t.context.doc.createHistory(snapshot1, 1000);+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId: docId1,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ ]);+ await t.context.doc.upsert(snapshot2);+ await t.context.doc.createHistory(snapshot2, 1000);+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId: docId2,+ blob: Buffer.from('blob2'),+ timestamp: Date.now(),+ editorId: user.id,+ seq: 1,+ },+ ]);+ const deletedCount = await t.context.doc.deleteAllByWorkspaceId(workspace.id);+ t.is(deletedCount, 2);+ const foundSnapshot1 = await t.context.doc.get(workspace.id, docId1);+ t.is(foundSnapshot1, null);+ const foundHistory1 = await t.context.doc.getLatestHistory(+ workspace.id,+ docId1+ );+ t.is(foundHistory1, null);+ const foundUpdates1 = await t.context.doc.findUpdates(workspace.id, docId1);+ t.is(foundUpdates1.length, 0);+ const foundSnapshot2 = await t.context.doc.get(workspace.id, docId2);+ t.is(foundSnapshot2, null);+ const foundHistory2 = await t.context.doc.getLatestHistory(+ workspace.id,+ docId2+ );+ t.is(foundHistory2, null);+ const foundUpdates2 = await t.context.doc.findUpdates(workspace.id, docId2);+ t.is(foundUpdates2.length, 0);+});++test('should find all docs timestamps in a workspace', async t => {+ const docId1 = randomUUID();+ const docId2 = randomUUID();+ const timestamp1 = Date.now();+ const timestamp2 = Date.now() + 1000;+ const timestamp3 = Date.now() + 2000;+ const snapshot1 = {+ spaceId: workspace.id,+ docId: docId1,+ blob: Buffer.from('blob1'),+ timestamp: timestamp1,+ editorId: user.id,+ };+ const snapshot2 = {+ spaceId: workspace.id,+ docId: docId2,+ blob: Buffer.from('blob2'),+ timestamp: timestamp2,+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot1);+ await t.context.doc.createUpdates([+ {+ spaceId: workspace.id,+ docId: docId1,+ blob: Buffer.from('blob2'),+ timestamp: timestamp3,+ editorId: user.id,+ seq: 1,+ },+ ]);+ await t.context.doc.upsert(snapshot2);+ const timestamps = await t.context.doc.findTimestampsByWorkspaceId(+ workspace.id+ );+ t.deepEqual(timestamps, {+ [docId1]: timestamp3,+ [docId2]: timestamp2,+ });+});++test('should increase doc seq', async t => {+ const docId = randomUUID();+ const snapshot = {+ spaceId: workspace.id,+ docId,+ blob: Buffer.from('blob1'),+ timestamp: Date.now(),+ editorId: user.id,+ };+ await t.context.doc.upsert(snapshot);+ const seq1 = await t.context.doc.increaseSeq(workspace.id, docId, 88);+ t.is(seq1, 88);+ const seq2 = await t.context.doc.increaseSeq(workspace.id, docId, 2);+ t.is(seq2, 90);+ // hit max seq, then reset to zero+ await t.context.doc.increaseSeq(workspace.id, docId, 0x3fffffff);+ const seq3 = await t.context.doc.increaseSeq(workspace.id, docId, 1);+ t.is(seq3, 1);+});diff --git a/packages/backend/server/src/models/common/doc.ts b/packages/backend/server/src/models/common/doc.tsnew file mode 100644index 0000000000..9206e7e1ea--- /dev/null+++ b/packages/backend/server/src/models/common/doc.ts@@ -0,0 +1,14 @@+import type { User } from '@prisma/client';++export interface Doc {+ /**+ * Can be workspace or user id.+ */+ spaceId: string;+ docId: string;+ blob: Buffer;+ timestamp: number;+ editorId?: string;+}++export type DocEditor = Pick<User, 'id' | 'name' | 'avatarUrl'>;diff --git a/packages/backend/server/src/models/common/index.ts b/packages/backend/server/src/models/common/index.tsindex 445e67262d..8f93c2e5cf 100644--- a/packages/backend/server/src/models/common/index.ts+++ b/packages/backend/server/src/models/common/index.ts@@ -1,2 +1,3 @@+export * from './doc';export * from './feature';export * from './page';diff --git a/packages/backend/server/src/models/doc.ts b/packages/backend/server/src/models/doc.tsnew file mode 100644index 0000000000..e6172d9ebe--- /dev/null+++ b/packages/backend/server/src/models/doc.ts@@ -0,0 +1,480 @@+import { Injectable } from '@nestjs/common';+import { Transactional } from '@nestjs-cls/transactional';+import type { Update } from '@prisma/client';++import { BaseModel } from './base';+import type { Doc, DocEditor } from './common';++export interface DocRecord extends Doc {+ // TODO: deprecated field, remove in the future+ seq: number | null;+}++export interface DocHistorySimple {+ timestamp: number;+ editor: DocEditor | null;+}++export interface DocHistory {+ blob: Buffer;+ timestamp: number;+ editor: DocEditor | null;+}++export interface DocHistoryFilter {+ /**+ * timestamp to filter histories before.+ */+ before?: number;+ /**+ * limit the number of histories to return.+ *+ * Default to `100`.+ */+ take?: number;+}++/**+ * Workspace Doc Model+ *+ * This model is responsible for managing the workspace docs, including:+ * - Updates: the changes made to the doc.+ * - History: the doc history of the doc.+ * - Doc: the doc itself.+ */+@Injectable()+export class DocModel extends BaseModel {+ // #region Update++ private updateToDocRecord(row: Update): DocRecord {+ return {+ spaceId: row.workspaceId,+ docId: row.id,+ blob: row.blob,+ timestamp: row.createdAt.getTime(),+ editorId: row.createdBy || undefined,+ seq: row.seq,+ };+ }++ private docRecordToUpdate(record: DocRecord): Update {+ return {+ workspaceId: record.spaceId,+ id: record.docId,+ blob: record.blob,+ createdAt: new Date(record.timestamp),+ createdBy: record.editorId || null,+ seq: record.seq,+ };+ }++ private get userSelectFields() {+ return {+ select: {+ id: true,+ name: true,+ avatarUrl: true,+ },+ };+ }++ async createUpdates(updates: DocRecord[]) {+ return await this.db.update.createMany({+ data: updates.map(r => this.docRecordToUpdate(r)),+ });+ }++ /**+ * Find updates by workspaceId and docId.+ */+ async findUpdates(workspaceId: string, docId: string): Promise<DocRecord[]> {+ const rows = await this.db.update.findMany({+ where: {+ workspaceId,+ id: docId,+ },+ orderBy: {+ createdAt: 'asc',+ },+ });+ return rows.map(r => this.updateToDocRecord(r));+ }++ /**+ * Get the pending updates count by workspaceId and docId.+ */+ async getUpdateCount(workspaceId: string, docId: string) {+ return await this.db.update.count({+ where: {+ workspaceId,+ id: docId,+ },+ });+ }++ /**+ * Get the global pending updates count.+ */+ async getGlobalUpdateCount() {+ return await this.db.update.count();+ }++ /**+ * Delete updates by workspaceId, docId, and createdAts.+ */+ async deleteUpdates(+ workspaceId: string,+ docId: string,+ timestamps: number[]+ ) {+ const { count } = await this.db.update.deleteMany({+ where: {+ workspaceId,+ id: docId,+ createdAt: {+ in: timestamps.map(t => new Date(t)),+ },+ },+ });+ this.logger.log(+ `Deleted ${count} updates for workspace ${workspaceId} doc ${docId}`+ );+ return count;+ }++ // #endregion++ // #region History++ /**+ * Create a doc history with a max age.+ */+ async createHistory(+ snapshot: Doc,+ maxAge: number+ ): Promise<DocHistorySimple> {+ const row = await this.db.snapshotHistory.create({+ select: {+ timestamp: true,+ createdByUser: this.userSelectFields,+ },+ data: {+ workspaceId: snapshot.spaceId,+ id: snapshot.docId,+ timestamp: new Date(snapshot.timestamp),+ blob: snapshot.blob,+ createdBy: snapshot.editorId,+ expiredAt: new Date(Date.now() + maxAge),+ },+ });+ return {+ timestamp: row.timestamp.getTime(),+ editor: row.createdByUser,+ };+ }++ /**+ * Find doc history by workspaceId and docId.+ *+ * Only including timestamp, createdByUser+ */+ async findHistories(+ workspaceId: string,+ docId: string,+ filter?: DocHistoryFilter+ ): Promise<DocHistorySimple[]> {+ const rows = await this.db.snapshotHistory.findMany({+ select: {+ timestamp: true,+ createdByUser: this.userSelectFields,+ },+ where: {+ workspaceId,+ id: docId,+ timestamp: {+ lt: filter?.before ? new Date(filter.before) : new Date(),+ },+ },+ orderBy: {+ timestamp: 'desc',+ },+ take: filter?.take ?? 100,+ });+ return rows.map(r => ({+ timestamp: r.timestamp.getTime(),+ editor: r.createdByUser,+ }));+ }++ /**+ * Get the history of a doc at a specific timestamp.+ *+ * Including blob and createdByUser+ */+ async getHistory(+ workspaceId: string,+ docId: string,+ timestamp: number+ ): Promise<DocHistory | null> {+ const row = await this.db.snapshotHistory.findUnique({+ where: {+ workspaceId_id_timestamp: {+ workspaceId,+ id: docId,+ timestamp: new Date(timestamp),+ },+ },+ include: {+ createdByUser: this.userSelectFields,+ },+ });+ if (!row) {+ return null;+ }+ return {+ blob: row.blob,+ timestamp: row.timestamp.getTime(),+ editor: row.createdByUser,+ };+ }++ /**+ * Get the latest history of a doc.+ *+ * Only including timestamp, createdByUser+ */+ async getLatestHistory(+ workspaceId: string,+ docId: string+ ): Promise<DocHistorySimple | null> {+ const row = await this.db.snapshotHistory.findFirst({+ where: {+ workspaceId,+ id: docId,+ },+ select: {+ timestamp: true,+ createdByUser: this.userSelectFields,+ },+ orderBy: {+ timestamp: 'desc',+ },+ });+ if (!row) {+ return null;+ }+ return {+ timestamp: row.timestamp.getTime(),+ editor: row.createdByUser,+ };+ }++ // #endregion++ // #region Doc++ /**+ * insert or update a doc.+ */+ async upsert(doc: Doc) {+ const { spaceId, docId, blob, timestamp, editorId } = doc;+ const updatedAt = new Date(timestamp);+ // CONCERNS:+ // i. Because we save the real user's last seen action time as `updatedAt`,+ // it's possible to simply compare the `updatedAt` to determine if the snapshot is older than the one we are going to save.+ //+ // ii. Prisma doesn't support `upsert` with additional `where` condition along side unique constraint.+ // In our case, we need to manually check the `updatedAt` to avoid overriding the newer snapshot.+ // where: { workspaceId_id: {}, updatedAt: { lt: updatedAt } }+ // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^+ const result: { updatedAt: Date }[] = await this.db.$queryRaw`+ INSERT INTO "snapshots" ("workspace_id", "guid", "blob", "created_at", "updated_at", "created_by", "updated_by")+ VALUES (${spaceId}, ${docId}, ${blob}, DEFAULT, ${updatedAt}, ${editorId}, ${editorId})+ ON CONFLICT ("workspace_id", "guid")+ DO UPDATE SET "blob" = ${blob}, "updated_at" = ${updatedAt}, "updated_by" = ${editorId}+ WHERE "snapshots"."workspace_id" = ${spaceId} AND "snapshots"."guid" = ${docId} AND "snapshots"."updated_at" <= ${updatedAt}+ RETURNING "snapshots"."workspace_id" as "workspaceId", "snapshots"."guid" as "id", "snapshots"."updated_at" as "updatedAt"+ `;++ // if the condition `snapshot.updatedAt > updatedAt` is true, by which means the snapshot has already been updated by other process,+ // the updates has been applied to current `doc` must have been seen by the other process as well.+ // The `updatedSnapshot` will be `undefined` in this case.+ return result.at(0);+ }++ /**+ * Get a doc by workspaceId and docId.+ */+ async get(workspaceId: string, docId: string): Promise<Doc | null> {+ const row = await this.db.snapshot.findUnique({+ where: {+ workspaceId_id: {+ workspaceId,+ id: docId,+ },+ },+ });+ if (!row) {+ return null;+ }+ return {+ spaceId: row.workspaceId,+ docId: row.id,+ blob: row.blob,+ timestamp: row.updatedAt.getTime(),+ editorId: row.updatedBy || undefined,+ };+ }++ async getMeta(workspaceId: string, docId: string) {+ return await this.db.snapshot.findUnique({+ where: {+ workspaceId_id: {+ workspaceId,+ id: docId,+ },+ },+ select: {+ createdAt: true,+ updatedAt: true,+ createdByUser: this.userSelectFields,+ updatedByUser: this.userSelectFields,+ },+ });+ }++ /**+ * @deprecated updates do not rely on seq number anymore+ */+ async increaseSeq(workspaceId: string, docId: string, increment: number) {+ const MAX_SEQ_NUM = 0x3fffffff; // u31+ const { seq } = await this.db.snapshot.update({+ select: {+ seq: true,+ },+ where: {+ workspaceId_id: {+ workspaceId,+ id: docId,+ },+ },+ data: {+ seq: {+ increment,+ },+ },+ });++ if (!seq) {+ return increment;+ }++ // reset+ if (seq >= MAX_SEQ_NUM) {+ await this.db.snapshot.update({+ select: {+ seq: true,+ },+ where: {+ workspaceId_id: {+ workspaceId,+ id: docId,+ },+ },+ data: {+ seq: 0,+ },+ });+ }+ return seq;+ }++ /**+ * Delete a doc and it's updates and snapshots.+ */+ @Transactional()+ async delete(workspaceId: string, docId: string) {+ const ident = { where: { workspaceId, id: docId } };+ const { count: snapshots } = await this.db.snapshot.deleteMany(ident);+ const { count: updates } = await this.db.update.deleteMany(ident);+ const { count: histories } =+ await this.db.snapshotHistory.deleteMany(ident);+ this.logger.log(+ `Deleted workspace ${workspaceId} doc ${docId}, including ${snapshots} snapshots, ${updates} updates, and ${histories} histories`+ );+ }++ /**+ * Delete the whole workspace's docs and their updates and snapshots.+ */+ @Transactional()+ async deleteAllByWorkspaceId(workspaceId: string) {+ const ident = { where: { workspaceId } };+ const { count: snapshots } = await this.db.snapshot.deleteMany(ident);+ const { count: updates } = await this.db.update.deleteMany(ident);+ const { count: histories } =+ await this.db.snapshotHistory.deleteMany(ident);+ this.logger.log(+ `Deleted workspace ${workspaceId} all docs, including ${snapshots} snapshots, ${updates} updates, and ${histories} histories`+ );+ return snapshots;+ }++ /**+ * Find the timestamps of docs by workspaceId.+ *+ * @param after Only return timestamps after this timestamp.+ */+ async findTimestampsByWorkspaceId(workspaceId: string, after?: number) {+ const snapshots = await this.db.snapshot.findMany({+ select: {+ id: true,+ updatedAt: true,+ },+ where: {+ workspaceId,+ ...(after+ ? {+ updatedAt: {+ gt: new Date(after),+ },+ }+ : {}),+ },+ });++ const updates = await this.db.update.groupBy({+ where: {+ workspaceId,+ ...(after+ ? {+ // [createdAt] in updates table is indexed, so it's fast+ createdAt: {+ gt: new Date(after),+ },+ }+ : {}),+ },+ by: ['id'],+ _max: {+ createdAt: true,+ },+ });++ const result: Record<string, number> = {};++ snapshots.forEach(s => {+ result[s.id] = s.updatedAt.getTime();+ });++ updates.forEach(u => {+ if (u._max.createdAt) {+ result[u.id] = u._max.createdAt.getTime();+ }+ });++ return result;+ }++ // #endregion+}diff --git a/packages/backend/server/src/models/index.ts b/packages/backend/server/src/models/index.tsindex 65522a0f71..44067c03e5 100644--- a/packages/backend/server/src/models/index.ts+++ b/packages/backend/server/src/models/index.ts@@ -7,6 +7,7 @@ import {import { ModuleRef } from '@nestjs/core';import { ApplyType } from '../base';+import { DocModel } from './doc';import { FeatureModel } from './feature';import { PageModel } from './page';import { MODELS_SYMBOL } from './provider';@@ -26,6 +27,7 @@ const MODELS = {page: PageModel,userFeature: UserFeatureModel,workspaceFeature: WorkspaceFeatureModel,+ doc: DocModel,};type ModelsType = {@@ -78,6 +80,7 @@ const ModelsSymbolProvider: ExistingProvider = {export class ModelsModule {}export * from './common';+export * from './doc';export * from './feature';export * from './page';export * from './session';