Open-source and local-first Slack and Notion alternative that puts you in control of your data
TypeScript chatchat-applicationcrdteditorelectronknowledge-baselocal-firstnotionnotion-alternativerealtime-collaborationself-hostedslacksqliteteam-collaborationwikiyjs
import { cloneDeep } from 'lodash-es';
import {
CanUpdateDocumentContext,
DocumentContent,
generateId,
getNodeModel,
IdType,
MutationStatus,
UpdateDocumentMutationData,
} from '@colanode/core';
import { decodeState, YDoc } from '@colanode/crdt';
import { database } from '@colanode/server/data/database';
import { eventBus } from '@colanode/server/lib/event-bus';
import { createLogger } from '@colanode/server/lib/logger';
import { fetchNode, fetchNodeTree, mapNode } from '@colanode/server/lib/nodes';
import { WorkspaceContext } from '@colanode/server/types/api';
import {
CreateDocumentInput,
CreateDocumentOutput,
UpdateDocumentInput,
} from '@colanode/server/types/documents';
import { ConcurrentUpdateResult } from '@colanode/server/types/nodes';
const logger = createLogger('server:lib:documents');
const UPDATE_RETRIES_LIMIT = 10;
export const createDocument = async (
input: CreateDocumentInput
): Promise<CreateDocumentOutput | null> => {
const node = await fetchNode(input.nodeId);
if (!node) {
return null;
}
const model = getNodeModel(node.type);
if (!model.documentSchema) {
return null;
}
const ydoc = new YDoc();
const update = ydoc.update(model.documentSchema, input.content);
if (!update) {
return null;
}
const content = ydoc.getObject<DocumentContent>();
const { createdDocument, createdDocumentUpdate } = await database
.transaction()
.execute(async (trx) => {
const createdDocumentUpdate = await trx
.insertInto('document_updates')
.returningAll()
.values({
id: generateId(IdType.Update),
document_id: input.nodeId,
workspace_id: input.workspaceId,
root_id: node.root_id,
data: update,
created_at: new Date(),
created_by: input.userId,
})
.executeTakeFirst();
if (!createdDocumentUpdate) {
throw new Error('Failed to create document update');
}
const createdDocument = await trx
.insertInto('documents')
.returningAll()
.values({
id: input.nodeId,
workspace_id: input.workspaceId,
content: JSON.stringify(content),
created_at: new Date(),
created_by: input.userId,
revision: createdDocumentUpdate.revision,
})
.executeTakeFirst();
if (!createdDocument) {
throw new Error('Failed to create document');
}
return {
createdDocument,
createdDocumentUpdate,
};
});
if (!createdDocument || !createdDocumentUpdate) {
return null;
}
eventBus.publish({
type: 'document.updated',
documentId: input.nodeId,
workspaceId: input.workspaceId,
});
eventBus.publish({
type: 'document.update.created',
documentId: input.nodeId,
rootId: node.root_id,
workspaceId: input.workspaceId,
});
return {
document: createdDocument,
};
};
export const updateDocumentFromMutation = async (
workspace: WorkspaceContext,
mutation: UpdateDocumentMutationData
): Promise<MutationStatus> => {
for (let count = 0; count < UPDATE_RETRIES_LIMIT; count++) {
const existingDocumentUpdate = await database
.selectFrom('document_updates')
.where('id', '=', mutation.updateId)
.selectAll()
.executeTakeFirst();
if (existingDocumentUpdate) {
return MutationStatus.OK;
}
const result = await tryUpdateDocumentFromMutation(workspace, mutation);
if (result.type === 'success') {
return result.output;
}
if (result.type === 'error') {
return MutationStatus.INTERNAL_SERVER_ERROR;
}
}
return MutationStatus.INTERNAL_SERVER_ERROR;
};
const tryUpdateDocumentFromMutation = async (
workspace: WorkspaceContext,
mutation: UpdateDocumentMutationData
): Promise<ConcurrentUpdateResult<MutationStatus>> => {
const tree = await fetchNodeTree(mutation.documentId);
if (tree.length === 0) {
return { type: 'success', output: MutationStatus.NOT_FOUND };
}
const node = tree[tree.length - 1];
if (!node) {
return { type: 'success', output: MutationStatus.NOT_FOUND };
}
const model = getNodeModel(node.type);
if (!model.documentSchema) {
return { type: 'success', output: MutationStatus.NOT_FOUND };
}
const context: CanUpdateDocumentContext = {
user: {
id: workspace.user.id,
role: workspace.user.role,
workspaceId: workspace.id,
accountId: workspace.user.accountId,
},
node: mapNode(node),
tree: tree.map((node) => mapNode(node)),
};
if (!model.canUpdateDocument(context)) {
return { type: 'success', output: MutationStatus.FORBIDDEN };
}
const document = await database
.selectFrom('documents')
.where('id', '=', mutation.documentId)
.selectAll()
.executeTakeFirst();
const documentUpdates = await database
.selectFrom('document_updates')
.where('document_id', '=', mutation.documentId)
.selectAll()
.execute();
const ydoc = new YDoc();
for (const update of documentUpdates) {
ydoc.applyUpdate(update.data);
}
ydoc.applyUpdate(mutation.data);
const content = ydoc.getObject<DocumentContent>();
if (!model.documentSchema.safeParse(content).success) {
return { type: 'success', output: MutationStatus.BAD_REQUEST };
}
try {
const { updatedDocument, createdDocumentUpdate } = await database
.transaction()
.execute(async (trx) => {
const createdDocumentUpdate = await trx
.insertInto('document_updates')
.returningAll()
.values({
id: mutation.updateId,
document_id: mutation.documentId,
root_id: node.root_id,
workspace_id: workspace.id,
data: decodeState(mutation.data),
created_at: new Date(mutation.createdAt),
created_by: workspace.user.id,
merged_updates: null,
})
.executeTakeFirst();
if (!createdDocumentUpdate) {
throw new Error('Failed to create document update');
}
const updatedDocument = document
? await trx
.updateTable('documents')
.returningAll()
.set({
content: JSON.stringify(content),
updated_at: new Date(mutation.createdAt),
updated_by: workspace.user.id,
revision: createdDocumentUpdate.revision,
})
.where('id', '=', mutation.documentId)
.where('revision', '=', document.revision)
.executeTakeFirst()
: await trx
.insertInto('documents')
.returningAll()
.values({
id: mutation.documentId,
workspace_id: workspace.id,
content: JSON.stringify(content),
created_at: new Date(mutation.createdAt),
created_by: workspace.user.id,
revision: createdDocumentUpdate.revision,
})
.onConflict((cb) => cb.doNothing())
.executeTakeFirst();
if (!updatedDocument) {
throw new Error('Failed to create document');
}
return {
updatedDocument,
createdDocumentUpdate,
};
});
if (!updatedDocument || !createdDocumentUpdate) {
throw new Error('Failed to update document');
}
eventBus.publish({
type: 'document.updated',
documentId: mutation.documentId,
workspaceId: workspace.id,
});
eventBus.publish({
type: 'document.update.created',
documentId: mutation.documentId,
rootId: node.root_id,
workspaceId: workspace.id,
});
return {
type: 'success',
output: MutationStatus.OK,
};
} catch (error) {
logger.error(error, `Failed to update document`);
return { type: 'retry' };
}
};
export const updateDocument = async (
input: UpdateDocumentInput
): Promise<boolean> => {
for (let count = 0; count < UPDATE_RETRIES_LIMIT; count++) {
const result = await tryUpdateDocument(input);
if (result.type === 'success') {
return true;
}
if (result.type === 'error') {
return false;
}
}
return false;
};
const tryUpdateDocument = async (
input: UpdateDocumentInput
): Promise<ConcurrentUpdateResult<boolean>> => {
const node = await fetchNode(input.documentId);
if (!node) {
return { type: 'error', error: 'Node not found' };
}
const model = getNodeModel(node.type);
if (!model.documentSchema) {
return { type: 'error', error: 'Node does not support documents' };
}
const documentUpdates = await database
.selectFrom('document_updates')
.where('document_id', '=', input.documentId)
.selectAll()
.execute();
const ydoc = new YDoc();
for (const update of documentUpdates) {
ydoc.applyUpdate(update.data);
}
const currentContent = ydoc.getObject<DocumentContent>();
const updatedContent = input.updater(cloneDeep(currentContent));
if (!updatedContent) {
return { type: 'error', error: 'Failed to update document' };
}
const update = ydoc.update(model.documentSchema, updatedContent);
if (!update) {
return { type: 'error', error: 'Failed to create document update' };
}
const content = ydoc.getObject<DocumentContent>();
if (!model.documentSchema.safeParse(content).success) {
return { type: 'error', error: 'Updated content is invalid' };
}
const date = new Date();
const updateId = generateId(IdType.Update);
try {
const { updatedDocument, createdDocumentUpdate } = await database
.transaction()
.execute(async (trx) => {
const createdDocumentUpdate = await trx
.insertInto('document_updates')
.returningAll()
.values({
id: updateId,
document_id: input.documentId,
root_id: node.root_id,
workspace_id: input.workspaceId,
data: update,
created_at: date,
created_by: input.userId,
merged_updates: null,
})
.executeTakeFirst();
if (!createdDocumentUpdate) {
throw new Error('Failed to create document update');
}
const updatedDocument = await trx
.insertInto('documents')
.returningAll()
.values({
id: input.documentId,
workspace_id: input.workspaceId,
content: JSON.stringify(content),
created_at: date,
created_by: input.userId,
revision: createdDocumentUpdate.revision,
})
.onConflict((cb) =>
cb.column('id').doUpdateSet({
content: JSON.stringify(content),
updated_at: date,
updated_by: input.userId,
revision: createdDocumentUpdate.revision,
})
)
.executeTakeFirst();
if (!updatedDocument) {
throw new Error('Failed to update document');
}
return {
updatedDocument,
createdDocumentUpdate,
};
});
if (!updatedDocument || !createdDocumentUpdate) {
throw new Error('Failed to update document');
}
eventBus.publish({
type: 'document.updated',
documentId: input.documentId,
workspaceId: input.workspaceId,
});
eventBus.publish({
type: 'document.update.created',
documentId: input.documentId,
rootId: node.root_id,
workspaceId: input.workspaceId,
});
return {
type: 'success',
output: true,
};
} catch (error) {
logger.error(error, `Failed to update document`);
return { type: 'retry' };
}
};