@verdant-web/server 1.7.8

package/src/TokenProvider.ts

@@ -0,0 +1,39 @@
+import { ReplicaType } from '@verdant-web/common';
+import jwt from 'jsonwebtoken';
+
+export class TokenProvider {
+	constructor(private config: { secret: string }) {}
+
+	getToken = ({
+		userId,
+		libraryId,
+		syncEndpoint,
+		role,
+		type = ReplicaType.Realtime,
+		expiresIn = '1d',
+		fileEndpoint,
+	}: {
+		userId: string;
+		libraryId: string;
+		syncEndpoint: string;
+		fileEndpoint?: string;
+		role?: string;
+		type?: ReplicaType;
+		expiresIn?: string | number;
+	}) => {
+		return jwt.sign(
+			{
+				sub: userId,
+				lib: libraryId,
+				url: syncEndpoint,
+				file: fileEndpoint,
+				role,
+				type,
+			},
+			this.config.secret,
+			{
+				expiresIn,
+			},
+		);
+	};
+}

package/src/TokenVerifier.ts

@@ -0,0 +1,30 @@
+import { assert, ReplicaType } from '@verdant-web/common';
+import jwt, { JwtPayload } from 'jsonwebtoken';
+
+export class TokenVerifier {
+	constructor(private config: { secret: string }) {}
+
+	verifyToken = (token: string): TokenInfo => {
+		const decoded = jwt.verify(token, this.config.secret, {
+			complete: false,
+		}) as JwtPayload;
+		assert(decoded.sub);
+		return {
+			userId: decoded.sub,
+			libraryId: decoded.lib,
+			syncEndpoint: decoded.url,
+			role: decoded.role,
+			type: decoded.type,
+			token,
+		};
+	};
+}
+
+export interface TokenInfo {
+	userId: string;
+	libraryId: string;
+	syncEndpoint: string;
+	role?: string;
+	type: ReplicaType;
+	token: string;
+}

package/src/files/FileMetadata.ts

@@ -0,0 +1,112 @@
+import { Database } from 'better-sqlite3';
+import { FileInfo } from './FileStorage.js';
+
+export interface FileMetadataConfig {
+	deleteExpirationDays?: number;
+}
+
+export class FileMetadata {
+	private deleteExpirationDays = 1;
+
+	constructor(
+		private db: Database,
+		{ deleteExpirationDays = 1 }: FileMetadataConfig = {},
+	) {
+		this.deleteExpirationDays = deleteExpirationDays;
+	}
+
+	get = (
+		libraryId: string,
+		fileId: string,
+	): {
+		libraryId: string;
+		fileId: string;
+		name: string;
+		type: string;
+	} => {
+		return this.db
+			.prepare(
+				`
+      SELECT * FROM FileMetadata
+      WHERE libraryId = ? AND fileId = ?
+    `,
+			)
+			.get(libraryId, fileId);
+	};
+
+	getAll = (libraryId: string) => {
+		return this.db
+			.prepare(
+				`
+			SELECT * FROM FileMetadata
+			WHERE libraryId = ?
+		`,
+			)
+			.all(libraryId);
+	};
+
+	deleteAll = (libraryId: string) => {
+		return this.db
+			.prepare(
+				`
+			DELETE FROM FileMetadata
+			WHERE libraryId = ?
+		`,
+			)
+			.run(libraryId);
+	};
+
+	put = (libraryId: string, fileInfo: FileInfo) => {
+		return this.db
+			.prepare(
+				`
+      INSERT OR REPLACE INTO FileMetadata (libraryId, fileId, name, type)
+      VALUES (?, ?, ?, ?)
+    `,
+			)
+			.run(libraryId, fileInfo.id, fileInfo.fileName, fileInfo.type);
+	};
+
+	markPendingDelete = (libraryId: string, fileId: string) => {
+		return this.db
+			.prepare(
+				`
+					UPDATE FileMetadata
+					SET pendingDeleteAt = ?
+					WHERE libraryId = ? AND fileId = ?
+				`,
+			)
+			.run(Date.now(), libraryId, fileId);
+	};
+
+	delete = (libraryId: string, fileId: string) => {
+		return this.db
+			.prepare(
+				`
+      DELETE FROM FileMetadata
+      WHERE libraryId = ? AND fileId = ?
+    `,
+			)
+			.run(libraryId, fileId);
+	};
+
+	getPendingDeletes = (libraryId: string) => {
+		return this.db
+			.prepare(
+				`
+					SELECT * FROM FileMetadata
+					WHERE libraryId = ? AND pendingDeleteAt < ?
+				`,
+			)
+			.all(
+				libraryId,
+				Date.now() - 1000 * 60 * 60 * 24 * this.deleteExpirationDays,
+			) as {
+			libraryId: string;
+			fileId: string;
+			name: string;
+			type: string;
+			pendingDeleteAt: number;
+		}[];
+	};
+}

package/src/files/FileStorage.ts

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Readable } from 'stream';
+
+export interface FileInfo {
+	fileName: string;
+	id: string;
+	libraryId: string;
+	type: string;
+}
+
+/**
+ * The interface for implementing a file storage backend.
+ * verdant will supply file Blobs and metadata, and the storage backend
+ * must store them somewhere.
+ *
+ * The storage backend must also provide a way to get a URL for the file,
+ * even if the file is not yet uploaded, based on its metadata.
+ */
+export interface FileStorage {
+	put(fileStream: Readable, data: FileInfo): Promise<void>;
+	getUrl(data: FileInfo): string | Promise<string>;
+	delete(data: FileInfo): Promise<void>;
+}
+
+export class LocalFileStorage implements FileStorage {
+	private readonly host: string;
+	private readonly rootDirectory: string;
+
+	constructor({
+		rootDirectory,
+		host,
+	}: {
+		rootDirectory: string;
+		host: string;
+	}) {
+		this.host = this.prepareHost(host);
+		this.rootDirectory = rootDirectory;
+	}
+
+	private prepareHost = (host: string) => {
+		if (host.endsWith('/')) {
+			return host.slice(0, -1);
+		}
+		return host;
+	};
+
+	async put(fileStream: Readable, data: FileInfo): Promise<void> {
+		const filePath = this.getPath(data);
+		const containingDirectory = path.dirname(
+			path.join(this.rootDirectory, filePath),
+		);
+		await fs.promises.mkdir(containingDirectory, {
+			recursive: true,
+		});
+		const dest = fs.createWriteStream(this.getStorageLocation(data));
+		fileStream.pipe(dest);
+	}
+
+	getUrl(data: FileInfo): string {
+		return `${this.host}/${this.getPath(data)}`;
+	}
+
+	async delete(data: FileInfo): Promise<void> {
+		await fs.promises.unlink(this.getStorageLocation(data));
+
+		const containingDirectory = path.dirname(
+			path.join(this.rootDirectory, this.getPath(data)),
+		);
+
+		// delete the containing folder if it's empty
+		try {
+			await fs.promises.rmdir(containingDirectory);
+		} catch (e) {
+			// ignore
+		}
+	}
+
+	private getPath(data: FileInfo): string {
+		// retain the file extension
+		return `${data.libraryId}/${data.id}/${data.fileName}`;
+	}
+
+	private getStorageLocation(data: FileInfo): string {
+		return path.join(this.rootDirectory, this.getPath(data));
+	}
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export type { MessageSender } from './MessageSender.js';
+export type { UserProfiles } from './Profiles.js';
+export type { ClientMessage, ServerMessage } from '@verdant-web/common';
+export { ReplicaType } from '@verdant-web/common';
+export { Server } from './Server.js';
+export { TokenProvider } from './TokenProvider.js';
+export { LocalFileStorage } from './files/FileStorage.js';
+export type { FileStorage, FileInfo } from './files/FileStorage.js';
+export type { TokenInfo } from './TokenVerifier.js';

package/src/migrations/v0.sql.ts

@@ -0,0 +1,26 @@
+export default `
+CREATE TABLE IF NOT EXISTS ReplicaInfo (
+  id TEXT PRIMARY KEY NOT NULL,
+  libraryId TEXT NOT NULL,
+  clientId TEXT NOT NULL,
+  lastSeenWallClockTime INTEGER,
+  ackedLogicalTime TEXT,
+  type INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS OperationHistory (
+  libraryId TEXT NOT NULL,
+  replicaId TEXT NOT NULL,
+  oid TEXT NOT NULL,
+  data TEXT NOT NULL,
+  timestamp INTEGER NOT NULL,
+  PRIMARY KEY (libraryId, replicaId, oid, timestamp)
+);
+
+CREATE TABLE IF NOT EXISTS DocumentBaseline (
+  oid TEXT PRIMARY KEY NOT NULL,
+  snapshot TEXT,
+  timestamp TEXT NOT NULL,
+  libraryId TEXT NOT NULL
+);
+`;

package/src/migrations/v1.sql.ts

@@ -0,0 +1,28 @@
+export default `
+ALTER TABLE
+  ReplicaInfo RENAME TO ReplicaInfoOld;
+
+CREATE TABLE ReplicaInfo (
+  id TEXT NOT NULL,
+  libraryId TEXT NOT NULL,
+  clientId TEXT NOT NULL,
+  lastSeenWallClockTime INTEGER,
+  ackedLogicalTime TEXT,
+  type INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (id, libraryId)
+);
+
+INSERT INTO
+  ReplicaInfo
+SELECT
+  id,
+  libraryId,
+  clientId,
+  lastSeenWallClockTime,
+  ackedLogicalTime,
+  type
+FROM
+  ReplicaInfoOld;
+
+DROP TABLE ReplicaInfoOld;
+`;

package/src/migrations/v2.sql.ts

@@ -0,0 +1,26 @@
+// fixes primary key for document baselines to include libraryId
+
+export default `
+  ALTER TABLE
+    DocumentBaseline RENAME TO DocumentBaselineOld;
+
+  CREATE TABLE DocumentBaseline (
+    oid TEXT NOT NULL,
+    snapshot TEXT,
+    timestamp TEXT NOT NULL,
+    libraryId TEXT NOT NULL,
+    PRIMARY KEY (libraryId, oid)
+  );
+
+  INSERT INTO
+    DocumentBaseline
+  SELECT
+    oid,
+    snapshot,
+    timestamp,
+    libraryId
+  FROM
+    DocumentBaselineOld;
+
+  DROP TABLE DocumentBaselineOld;
+`;

package/src/migrations/v3.sql.ts

@@ -0,0 +1,12 @@
+// add the FileMetadata table
+
+export default `
+  CREATE TABLE IF NOT EXISTS FileMetadata (
+    libraryId TEXT NOT NULL,
+    fileId TEXT NOT NULL,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL,
+    pendingDeleteAt INTEGER,
+    PRIMARY KEY (libraryId, fileId)
+  );
+`;

package/src/migrations/v4.sql.ts

@@ -0,0 +1,6 @@
+// add server order to replicas and operations
+
+export default `
+  ALTER TABLE ReplicaInfo ADD COLUMN ackedServerOrder INTEGER DEFAULT 0 NOT NULL;
+  ALTER TABLE OperationHistory ADD COLUMN serverOrder INTEGER DEFAULT 0 NOT NULL;
+`;

package/src/migrations.ts

@@ -0,0 +1,51 @@
+import type { Database } from 'better-sqlite3';
+import v0Sql from './migrations/v0.sql.js';
+import v1Sql from './migrations/v1.sql.js';
+import v2Sql from './migrations/v2.sql.js';
+import v3Sql from './migrations/v3.sql.js';
+import v4Sql from './migrations/v4.sql.js';
+
+const allMigrations = [v0Sql, v1Sql, v2Sql, v3Sql, v4Sql];
+
+export function migrations(db: Database) {
+	// create the versions table if it doesn't exist
+	db.prepare(
+		`
+    CREATE TABLE IF NOT EXISTS versions (
+      version INTEGER NOT NULL PRIMARY KEY
+    );
+  `,
+	).run();
+
+	// get the current version
+	const versionResult = db
+		.prepare(
+			`
+    SELECT version FROM versions ORDER BY version DESC LIMIT 1;
+  `,
+		)
+		.get() as { version: number } | undefined;
+	const version = versionResult?.version ?? 0;
+
+	const sqlToRun = allMigrations.slice(version);
+
+	if (sqlToRun.length === 0) return;
+
+	console.info(
+		'Running migrations from ',
+		version,
+		'to',
+		allMigrations.length - 1,
+	);
+
+	const run = db.transaction(() => {
+		sqlToRun.forEach((sql) => db.exec(sql));
+		db.prepare(
+			`
+			INSERT INTO versions (version) VALUES (?);
+		`,
+		).run(allMigrations.length);
+	});
+
+	run();
+}

package/src/types.ts

@@ -0,0 +1,35 @@
+import {
+	DocumentBaseline,
+	Operation,
+	ReplicaInfo,
+	ReplicaType,
+} from '@verdant-web/common';
+
+export interface OperationSpec extends Operation {
+	serverOrder: number;
+	replicaId: string;
+}
+
+export interface DocumentBaselineSpec
+	extends Omit<DocumentBaseline<any>, 'snapshot'> {
+	snapshot: string;
+	libraryId: string;
+}
+
+export interface ReplicaInfoSpec extends ReplicaInfo {
+	libraryId: string;
+	// the authenticated client ID authorized
+	// to write to this replica
+	clientId: string;
+	lastSeenWallClockTime: number | null;
+	type: ReplicaType;
+	ackedServerOrder: number;
+}
+
+// patch File
+declare global {
+	interface File {
+		readonly lastModified: number;
+		readonly name: string;
+	}
+}