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 * as Comlink from 'comlink';
import { eventBus } from '@colanode/client/lib';
import {
MutationInput,
MutationResult,
TempFileCreateMutationInput,
} from '@colanode/client/mutations';
import { QueryInput, QueryMap } from '@colanode/client/queries';
import { AppMeta, AppService } from '@colanode/client/services';
import { AppInitOutput } from '@colanode/client/types';
import {
build,
extractFileSubtype,
generateId,
IdType,
isColanodeDomain,
} from '@colanode/core';
import {
BroadcastInitMessage,
BroadcastMessage,
BroadcastMutationMessage,
BroadcastQueryAndSubscribeMessage,
BroadcastQueryMessage,
BroadcastQueryUnsubscribeMessage,
ColanodeWorkerApi,
PendingPromise,
} from '@colanode/web/lib/types';
import { WebBootstrapService } from '@colanode/web/services/bootstrap';
import { WebFileSystem } from '@colanode/web/services/file-system';
import { WebKyselyService } from '@colanode/web/services/kysely-service';
import { WebPathService } from '@colanode/web/services/path-service';
const windowId = generateId(IdType.Window);
const pendingPromises = new Map<string, PendingPromise>();
const fs = new WebFileSystem();
const path = new WebPathService();
let app: AppService | null = null;
let appInitOutput: AppInitOutput | null = null;
const broadcast = new BroadcastChannel('colanode');
broadcast.onmessage = (event) => {
handleMessage(event.data);
};
navigator.locks.request('colanode', async () => {
const appMeta: AppMeta = {
type: 'web',
platform: navigator.userAgent,
};
const bootstrap = await WebBootstrapService.create(path, fs);
if (bootstrap.needsFreshInstall) {
appInitOutput = 'reset';
if (pendingPromises.has('init')) {
const promise = pendingPromises.get('init');
if (promise && promise.type === 'init') {
promise.resolve(appInitOutput);
}
}
broadcastMessage({
type: 'init_result',
result: appInitOutput,
});
return;
}
app = new AppService(appMeta, fs, new WebKyselyService(), path);
await app.migrate();
await app.init();
await bootstrap.updateVersion(build.version);
await app.metadata.set('app', 'version', build.version);
await app.metadata.set('app', 'platform', appMeta.platform);
const domain = self.location.hostname;
if (isColanodeDomain(domain)) {
await app.createServer(new URL('https://eu.colanode.com/config'));
await app.createServer(new URL('https://us.colanode.com/config'));
}
appInitOutput = 'success';
broadcastMessage({
type: 'init_result',
result: appInitOutput,
});
const ids = Array.from(pendingPromises.keys());
for (const id of ids) {
const promise = pendingPromises.get(id);
if (!promise) {
continue;
}
if (promise.type === 'init') {
promise.resolve(appInitOutput);
} else if (promise.type === 'query') {
const result = await app.mediator.executeQuery(promise.input);
promise.resolve(result);
} else if (promise.type === 'query_and_subscribe') {
const result = await app.mediator.executeQueryAndSubscribe(
promise.key,
promise.windowId,
promise.input
);
promise.resolve(result);
} else if (promise.type === 'mutation') {
const result = await app.mediator.executeMutation(promise.input);
promise.resolve(result);
}
pendingPromises.delete(id);
}
eventBus.subscribe((event) => {
broadcastMessage({
type: 'event',
windowId,
event,
});
});
await new Promise(() => {});
});
const broadcastMessage = (message: BroadcastMessage) => {
broadcast.postMessage(message);
};
const handleMessage = async (message: BroadcastMessage) => {
if (message.type === 'init') {
if (!appInitOutput) {
return;
}
broadcastMessage({
type: 'init_result',
result: appInitOutput,
});
} else if (message.type === 'event') {
if (message.windowId === windowId) {
return;
}
eventBus.publish(message.event);
} else if (message.type === 'mutation') {
if (!app) {
return;
}
const result = await app.mediator.executeMutation(message.input);
broadcastMessage({
type: 'mutation_result',
mutationId: message.mutationId,
result,
});
} else if (message.type === 'query') {
if (!app) {
return;
}
const result = await app.mediator.executeQuery(message.input);
broadcastMessage({
type: 'query_result',
queryId: message.queryId,
result,
});
} else if (message.type === 'query_and_subscribe') {
if (!app) {
return;
}
const result = await app.mediator.executeQueryAndSubscribe(
message.key,
message.windowId,
message.input
);
broadcastMessage({
type: 'query_and_subscribe_result',
queryId: message.queryId,
key: message.key,
windowId: message.windowId,
result,
});
} else if (message.type === 'query_unsubscribe') {
if (!app) {
return;
}
app.mediator.unsubscribeQuery(message.key, message.windowId);
} else if (message.type === 'init_result') {
const promise = pendingPromises.get('init');
if (!promise || promise.type !== 'init') {
return;
}
promise.resolve(message.result);
pendingPromises.delete('init');
} else if (message.type === 'query_result') {
const promise = pendingPromises.get(message.queryId);
if (!promise || promise.type !== 'query') {
return;
}
promise.resolve(message.result);
pendingPromises.delete(message.queryId);
} else if (message.type === 'query_and_subscribe_result') {
const promise = pendingPromises.get(message.queryId);
if (!promise || promise.type !== 'query_and_subscribe') {
return;
}
promise.resolve(message.result);
pendingPromises.delete(message.queryId);
} else if (message.type === 'mutation_result') {
const promise = pendingPromises.get(message.mutationId);
if (!promise || promise.type !== 'mutation') {
return;
}
promise.resolve(message.result);
pendingPromises.delete(message.mutationId);
}
};
const waitForInit = async () => {
let count = 0;
while (!appInitOutput) {
await new Promise((resolve) => setTimeout(resolve, 50));
count++;
if (count > 100) {
throw new Error('App initialization timed out');
}
}
};
const api: ColanodeWorkerApi = {
async init() {
if (appInitOutput) {
return appInitOutput;
}
if (!appInitOutput) {
const message: BroadcastInitMessage = {
type: 'init',
};
const promise = new Promise<AppInitOutput>((resolve, reject) => {
pendingPromises.set('init', {
type: 'init',
resolve,
reject,
});
});
broadcastMessage(message);
return promise;
}
await waitForInit();
if (!appInitOutput) {
return Promise.reject(new Error('App not initialized'));
}
return appInitOutput;
},
async reset() {
await fs.reset();
},
async executeMutation(input) {
if (!appInitOutput) {
const mutationId = generateId(IdType.Mutation);
const message: BroadcastMutationMessage = {
type: 'mutation',
mutationId,
input,
};
const promise = new Promise<MutationResult<MutationInput>>(
(resolve, reject) => {
pendingPromises.set(mutationId, {
type: 'mutation',
mutationId,
input,
resolve,
reject,
});
}
);
broadcastMessage(message);
return promise;
}
if (!app || appInitOutput !== 'success') {
return Promise.reject(new Error('App not initialized'));
}
return app.mediator.executeMutation(input);
},
async executeQuery(input) {
if (!appInitOutput) {
const queryId = generateId(IdType.Query);
const message: BroadcastQueryMessage = {
type: 'query',
queryId,
input,
};
const promise = new Promise<QueryMap[QueryInput['type']]['output']>(
(resolve, reject) => {
pendingPromises.set(queryId, {
type: 'query',
queryId,
input,
resolve,
reject,
});
}
);
broadcastMessage(message);
return promise;
}
if (!app || appInitOutput !== 'success') {
return Promise.reject(new Error('App not initialized'));
}
return app.mediator.executeQuery(input);
},
async executeQueryAndSubscribe(key, input) {
if (!appInitOutput) {
const queryId = generateId(IdType.Query);
const message: BroadcastQueryAndSubscribeMessage = {
type: 'query_and_subscribe',
queryId,
key,
windowId,
input,
};
const promise = new Promise<QueryMap[QueryInput['type']]['output']>(
(resolve, reject) => {
pendingPromises.set(queryId, {
type: 'query_and_subscribe',
queryId,
key,
windowId,
input,
resolve,
reject,
});
}
);
broadcastMessage(message);
return promise;
}
if (!app || appInitOutput !== 'success') {
return Promise.reject(new Error('App not initialized'));
}
return app.mediator.executeQueryAndSubscribe(key, windowId, input);
},
async unsubscribeQuery(key) {
if (!appInitOutput) {
const message: BroadcastQueryUnsubscribeMessage = {
type: 'query_unsubscribe',
key,
windowId,
};
broadcastMessage(message);
return Promise.resolve();
}
if (!app || appInitOutput !== 'success') {
return;
}
return app.mediator.unsubscribeQuery(key, windowId);
},
subscribe(callback) {
const id = eventBus.subscribe(callback);
return Promise.resolve(id);
},
unsubscribe(subscriptionId) {
eventBus.unsubscribe(subscriptionId);
return Promise.resolve();
},
publish(event) {
eventBus.publish(event);
},
async saveTempFile(file) {
const id = generateId(IdType.TempFile);
const extension = path.extension(file.name);
const mimeType = file.type;
const subtype = extractFileSubtype(mimeType);
const filePath = path.tempFile(id + extension);
const arrayBuffer = await file.arrayBuffer();
const fileData = new Uint8Array(arrayBuffer);
await fs.writeFile(filePath, fileData);
const input: TempFileCreateMutationInput = {
type: 'temp.file.create',
id,
name: file.name,
size: file.size,
mimeType,
subtype,
extension,
path: filePath,
};
if (app && appInitOutput === 'success') {
await app.mediator.executeMutation(input);
} else {
const mutationId = generateId(IdType.Mutation);
const message: BroadcastMutationMessage = {
type: 'mutation',
mutationId,
input,
};
const promise = new Promise<MutationResult<MutationInput>>(
(resolve, reject) => {
pendingPromises.set(mutationId, {
type: 'mutation',
mutationId,
input,
resolve,
reject,
});
}
);
broadcastMessage(message);
await promise;
}
const url = await fs.url(filePath);
if (!url) {
await fs.delete(filePath);
return Promise.reject(new Error('Failed to save temp file'));
}
return {
id,
name: file.name,
size: file.size,
mimeType,
subtype,
path: filePath,
extension,
url,
};
},
};
Comlink.expose(api);