@lsync/server 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { n as webSocketAttachmentSchema, t as router } from "./router-C4eYfMV7.mjs";
-import { and, compileReadExpression, compileReadExpression as compileReadExpression$1, eq, field, gt, gte, inArray, lt, lte, matchesReadPredicate, matchesReadPredicate as matchesReadPredicate$1, ne, not, or, parseClientRpcRequest, readExpressionReferences, readExpressionReferences as readExpressionReferences$1, readExpressionRow, readExpressionRow as readExpressionRow$1, readRpcId, sendServerMessage, val } from "@lsync/transport";
+import { n as webSocketAttachmentSchema, t as router } from "./router-CZnnFmXh.mjs";
+import { ProtocolError, and, compileReadExpression, compileReadExpression as compileReadExpression$1, eq, field, gt, gte, inArray, lt, lte, matchesReadPredicate, matchesReadPredicate as matchesReadPredicate$1, ne, not, or, parseClientMessage, protocolErrorCodeSchema, readExpressionReferences, readExpressionReferences as readExpressionReferences$1, readExpressionRow, readExpressionRow as readExpressionRow$1, readMessageId, sendServerMessage, val } from "@lsync/transport";
 import sqlTag, { join, raw } from "sql-template-tag";
 import { z } from "zod";
 //#region src/access-expression.ts
@@ -242,7 +242,7 @@ function authorizeWriteBatch(batch, collections, auth, store) {
 }
 function authorizeApiCall(handler, name, input, auth) {
 	if (!handler) return;
-	const row = asRecord(input) ?? {};
+	const row = asRecord$1(input) ?? {};
 	const decision = reduceAccessExpression(handler({
 		auth,
 		input: readExpressionRow$1()
@@ -345,16 +345,16 @@ function writeAccessHandler(access, type) {
 	return access[type] ?? access.write ?? access.read;
 }
 function writeAccessRow(update, store) {
-	if (update.type === "insert") return asRecord(update.value);
-	const existing = asRecord(update.previousValue) ?? store.read(update.collection, update.key);
+	if (update.type === "insert") return asRecord$1(update.value);
+	const existing = asRecord$1(update.previousValue) ?? store.read(update.collection, update.key);
 	if (update.type === "delete") return existing;
-	const next = asRecord(update.value);
+	const next = asRecord$1(update.value);
 	return existing && next ? {
 		...existing,
 		...next
 	} : next ?? existing;
 }
-function asRecord(value) {
+function asRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 //#endregion
@@ -438,7 +438,7 @@ function selectRows(sql, table, options) {
 	const where = [sqlTag`path = ${options.scope}`];
 	where.push(...options.filters.map((filter) => filterSql(filter)));
 	if (options.predicate) where.push(predicateSql(options.predicate));
-	const order = options.orderBy.length > 0 ? join(options.orderBy.map((item) => orderBySql(item))) : sqlTag`key`;
+	const order = options.orderBy.length > 0 ? sqlTag`${join(options.orderBy.map((item) => orderBySql(item)))}, key` : sqlTag`key`;
 	return execSql(sql, sqlTag`
         SELECT key, value FROM ${identifierSql(table)}
         WHERE ${join(where, " AND ")}
@@ -623,39 +623,9 @@ function isRecord(value) {
 }
 //#endregion
 //#region src/collection-builder.ts
-function collectionConfigsBuilder() {
-	return new CollectionConfigsBuilder({});
-}
 function collectionBuilder() {
 	return new CollectionBuilder({});
 }
-const Collections = {
-	builder: collectionConfigsBuilder,
-	collection: collectionBuilder
-};
-var CollectionConfigsBuilder = class CollectionConfigsBuilder {
-	collections;
-	constructor(collections) {
-		this.collections = Object.freeze({ ...collections });
-	}
-	collection(name, configure) {
-		const builder = configure(new CollectionBuilder({ path: rootPathForName(name) }));
-		return new CollectionConfigsBuilder({
-			...this.collections,
-			...builder.entries()
-		});
-	}
-	path(path, configure) {
-		const builder = configure(new CollectionBuilder({ path }));
-		return new CollectionConfigsBuilder({
-			...this.collections,
-			...builder.entries()
-		});
-	}
-	build() {
-		return { ...this.collections };
-	}
-};
 var CollectionBuilder = class CollectionBuilder {
 	state;
 	constructor(state) {
@@ -769,26 +739,43 @@ function singularize(value) {
 //#endregion
 //#region src/definition-builder.ts
 function collectionShardOptionsFrom(definitions) {
-	return new CollectionShardDefinitionBuilder(definitions.collections, {});
+	return new CollectionShardDefinitionBuilder(definitions.collections, {}, {});
 }
 var CollectionShardDefinitionBuilder = class CollectionShardDefinitionBuilder {
 	definitions;
 	overrides;
-	constructor(definitions, overrides) {
+	options;
+	constructor(definitions, overrides, options) {
 		this.definitions = definitions;
 		this.overrides = overrides;
+		this.options = options;
+	}
+	limits(limits) {
+		return new CollectionShardDefinitionBuilder(this.definitions, this.overrides, {
+			...this.options,
+			limits
+		});
+	}
+	rateLimit(rateLimit) {
+		return new CollectionShardDefinitionBuilder(this.definitions, this.overrides, {
+			...this.options,
+			rateLimit
+		});
 	}
 	collection(path, configure) {
 		const override = configure(new ServerCollectionBuilder({})).toOverride();
 		return new CollectionShardDefinitionBuilder(this.definitions, {
 			...this.overrides,
 			[path]: override
-		});
+		}, this.options);
 	}
 	build() {
 		const collections = {};
 		for (const [name, definition] of Object.entries(this.definitions)) addDefinition(collections, definition, name, this.overrides);
-		return { collections };
+		return {
+			...this.options,
+			collections
+		};
 	}
 };
 var ServerCollectionBuilder = class ServerCollectionBuilder {
@@ -874,22 +861,25 @@ function accessConfig(override) {
 }
 //#endregion
 //#region src/durable-object-rpc.ts
-function callRouter(caller, request) {
-	if (request.method === "query" && request.params.path === "read") return caller.read(request.params.input.json);
-	if (request.method === "query" && request.params.path === "changes") return caller.changes(request.params.input.json);
-	if (request.method === "subscribe") return caller.subscribe(request.params.input.json);
-	if (request.method === "unsubscribe") return caller.unsubscribe(request.params.input.json);
-	if (request.method !== "mutation") throw new Error("Unsupported operation");
-	if (request.params.path === "push") return caller.push(request.params.input.json);
-	if (request.params.path === "api") return caller.api(request.params.input.json);
-	throw new Error("Unsupported operation");
+async function callRouter(caller, request) {
+	switch (request.type) {
+		case "read": return caller.read(request.input);
+		case "push": return caller.push(request.input);
+		case "changes": return caller.changes(request.input);
+		case "api": return caller.api(request.input);
+		case "subscribe": return caller.subscribe(request.input);
+		case "unsubscribe": return caller.unsubscribe(request.input);
+	}
+}
+function isResyncRequired(result) {
+	return typeof result === "object" && result !== null && result.type === "resyncRequired";
 }
 //#endregion
 //#region src/history-watermarks.ts
 const COLLECTION_WATERMARKS_TABLE = "_lsync_collection_watermarks";
 function ensureCollectionWatermarkTable(sql) {
 	sql.exec(`
-    CREATE TABLE IF NOT EXISTS ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)} (
+    CREATE TABLE IF NOT EXISTS ${quoteIdentifier$2(COLLECTION_WATERMARKS_TABLE)} (
       scope TEXT PRIMARY KEY,
       collection TEXT NOT NULL,
       latest_sequence INTEGER NOT NULL
@@ -898,7 +888,7 @@ function ensureCollectionWatermarkTable(sql) {
 }
 function recordCollectionWatermark(sql, collection, scope, sequence) {
 	sql.exec(`
-      INSERT INTO ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)}
+      INSERT INTO ${quoteIdentifier$2(COLLECTION_WATERMARKS_TABLE)}
         (scope, collection, latest_sequence)
       VALUES (?, ?, ?)
       ON CONFLICT(scope) DO UPDATE SET
@@ -908,21 +898,66 @@ function recordCollectionWatermark(sql, collection, scope, sequence) {
 }
 function readCollectionWatermark(sql, scope) {
 	return sql.exec(`
-        SELECT latest_sequence FROM ${quoteIdentifier$1(COLLECTION_WATERMARKS_TABLE)}
+        SELECT latest_sequence FROM ${quoteIdentifier$2(COLLECTION_WATERMARKS_TABLE)}
         WHERE scope = ?
       `, scope).toArray()[0]?.latest_sequence ?? 0;
 }
+function quoteIdentifier$2(identifier) {
+	return `"${identifier.replaceAll(`"`, `""`)}"`;
+}
+//#endregion
+//#region src/mutation-dedup.ts
+const APPLIED_UPDATES_TABLE = "_lsync_applied_updates";
+function deduplicateMutations(sql, batch) {
+	ensureAppliedUpdatesTable(sql);
+	const seen = /* @__PURE__ */ new Map();
+	return { updates: batch.updates.filter((update) => {
+		const payload = JSON.stringify(update);
+		const priorPayload = seen.get(update.id) ?? readAppliedPayload(sql, update.id);
+		if (priorPayload === void 0) {
+			seen.set(update.id, payload);
+			return true;
+		}
+		if (priorPayload !== payload) throw new Error(`Mutation id reused with a different payload: ${update.id}`);
+		return false;
+	}) };
+}
+function recordAppliedMutations(sql, updates) {
+	for (const update of updates) {
+		const { sequence, serverCreatedAt, ...original } = update;
+		sql.exec(`INSERT INTO ${quoteIdentifier$1(APPLIED_UPDATES_TABLE)} (update_id, payload, sequence) VALUES (?, ?, ?)`, update.id, JSON.stringify(original), sequence);
+	}
+}
+function ensureAppliedUpdatesTable(sql) {
+	sql.exec(`
+    CREATE TABLE IF NOT EXISTS ${quoteIdentifier$1(APPLIED_UPDATES_TABLE)} (
+      update_id TEXT PRIMARY KEY,
+      payload TEXT NOT NULL,
+      sequence INTEGER NOT NULL
+    )
+  `);
+}
+function readAppliedPayload(sql, updateId) {
+	return sql.exec(`SELECT payload FROM ${quoteIdentifier$1(APPLIED_UPDATES_TABLE)} WHERE update_id = ?`, updateId).toArray()[0]?.payload;
+}
 function quoteIdentifier$1(identifier) {
 	return `"${identifier.replaceAll(`"`, `""`)}"`;
 }
 //#endregion
 //#region src/history.ts
 const CHANGES_TABLE = "_lsync_changes";
+const SQLITE_JSON_CONFLICT_POLICY = "server-sequence-last-write-wins";
 function persistSQLiteJsonBatchWithHistory(sql, batch, collections = {}, options = {}) {
 	ensureSQLiteJsonTables(sql, collections);
 	ensureChangesTable(sql);
-	applySQLiteJsonBatch(sql, batch, collections);
-	const updates = batch.updates.map((update) => appendChange(sql, update, collections));
+	const pending = deduplicateMutations(sql, batch);
+	if (pending.updates.length === 0) return {
+		updates: [],
+		watermark: readWatermark(sql)
+	};
+	applySQLiteJsonBatch(sql, pending, collections);
+	const updates = pending.updates.map((update) => appendChange(sql, update, collections));
+	recordAppliedMutations(sql, updates);
 	const watermark = updates.at(-1)?.sequence ?? readWatermark(sql);
 	pruneChanges(sql, watermark, options.maxChanges ?? 1e4);
 	return {
@@ -952,11 +987,19 @@ function readSQLiteJsonChanges(sql, query, collections = {}) {
 	};
 	const limit = query.limit ?? 1e3;
 	const rows = selectChanges(sql, requested, limit + 1);
+	const page = rows.slice(0, limit);
+	const cursors = Object.fromEntries(requested.map((item) => [item.collection, item.sequence]));
+	for (const row of page) {
+		const item = requested.find((candidate) => candidate.scope === row.scope);
+		if (item) cursors[item.collection] = row.sequence;
+	}
+	if (rows.length <= limit) for (const item of requested) cursors[item.collection] = watermark;
 	return {
 		type: "changes",
-		updates: rows.slice(0, limit).map(rowToUpdate),
+		updates: page.map(rowToUpdate),
 		watermark,
-		hasMore: rows.length > limit
+		hasMore: rows.length > limit,
+		cursors
 	};
 }
 function ensureChangesTable(sql) {
@@ -1003,7 +1046,7 @@ function selectChanges(sql, requested, limit) {
 	const bindings = requested.flatMap((item) => [item.scope, item.sequence]);
 	bindings.push(limit);
 	return sql.exec(`
-        SELECT sequence, update_id, collection, "key", type, value, previous_value, client_id,
+        SELECT sequence, update_id, collection, scope, "key", type, value, previous_value, client_id,
                client_created_at, server_created_at
         FROM ${quoteIdentifier(CHANGES_TABLE)}
         WHERE ${requested.map(() => "(scope = ? AND sequence > ?)").join(" OR ")}
@@ -1051,21 +1094,69 @@ function quoteIdentifier(identifier) {
 }
 //#endregion
 //#region src/messages.ts
-function sendRpcResult(ws, id, result) {
+function sendResult(ws, id, payload) {
 	sendServerMessage(ws, {
+		version: 1,
 		id,
-		result: {
-			type: "data",
-			data: { json: result }
-		}
+		type: "result",
+		payload
 	});
 }
-function sendRpcError(ws, id, error) {
+function sendProtocolError(ws, id, error) {
 	sendServerMessage(ws, {
+		version: 1,
 		id,
-		error: { message: error instanceof Error ? error.message : "Unknown error" }
+		type: "error",
+		error: protocolErrorFrom(error)
 	});
 }
+function protocolErrorFrom(error) {
+	if (error instanceof ProtocolError) return {
+		code: error.code,
+		message: error.message,
+		...error.details !== void 0 ? { details: error.details } : {}
+	};
+	if (error instanceof z.ZodError) return {
+		code: "VALIDATION_FAILED",
+		message: "The request failed validation",
+		details: error.issues
+	};
+	const message = error instanceof Error ? error.message : "Unknown protocol error";
+	if (message.toLowerCase().includes("access denied")) return {
+		code: "AUTH_DENIED",
+		message
+	};
+	if (message.toLowerCase().includes("unknown collection")) return {
+		code: "VALIDATION_FAILED",
+		message
+	};
+	if (message.toLowerCase().includes("maximum subscriptions")) return {
+		code: "CONFLICT",
+		message
+	};
+	if (message.toLowerCase().includes("rate limit")) return {
+		code: "RATE_LIMITED",
+		message
+	};
+	if (message.toLowerCase().includes("unknown api path")) return {
+		code: "NOT_FOUND",
+		message
+	};
+	const candidate = asRecord(error);
+	const code = protocolErrorCodeSchema.safeParse(candidate?.code);
+	if (code.success) return {
+		code: code.data,
+		message,
+		...candidate?.details !== void 0 ? { details: candidate.details } : {}
+	};
+	return {
+		code: "INTERNAL_ERROR",
+		message
+	};
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
 //#endregion
 //#region src/socket-attachment.ts
 function webSocketAttachment(ws) {
@@ -1097,6 +1188,38 @@ function updateSocketSubscriptions(ws, collection, normalize, update) {
 	};
 }
 //#endregion
+//#region src/safeguards.ts
+const DEFAULT_MAX_SUBSCRIPTIONS_PER_WEBSOCKET = 100;
+function assertSubscriptionAllowed(ws, collection, limits) {
+	const attachment = webSocketAttachment(ws);
+	if (!attachment) throw new Error("Missing WebSocket attachment");
+	const maximum = limits?.maxSubscriptionsPerWebSocket ?? 100;
+	if (maximum === false || attachment.subscriptions.includes(collection)) return;
+	assertPositiveInteger(maximum, "maxSubscriptionsPerWebSocket");
+	if (attachment.subscriptions.length >= maximum) throw new Error(`Maximum subscriptions per WebSocket exceeded (${maximum})`);
+}
+async function enforceRateLimit(ws, env, rateLimit) {
+	if (!rateLimit) return;
+	const attachment = webSocketAttachment(ws);
+	if (!await rateLimit({
+		auth: webSocketAuth(ws),
+		clientId: attachment?.clientId ?? "unknown",
+		env
+	})) throw new Error("Rate limit exceeded");
+}
+function cloudflareRateLimiter(options = {}) {
+	const bindingName = options.binding ?? "RATE_LIMITER";
+	return async (context) => {
+		const binding = context.env[bindingName];
+		if (!binding?.limit) throw new Error(`Missing Cloudflare rate limit binding: ${bindingName}`);
+		const key = options.key?.(context) ?? context.clientId;
+		return (await binding.limit({ key })).success;
+	};
+}
+function assertPositiveInteger(value, name) {
+	if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer or false`);
+}
+//#endregion
 //#region src/access-invalidation.ts
 function invalidatesDependency(update, dependencies) {
 	return dependencies.some((dependency) => {
@@ -1185,7 +1308,8 @@ var CollectionShardDurableObject = class {
 	}
 	async webSocketMessage(ws, message) {
 		try {
-			const request = parseClientRpcRequest(message);
+			await enforceRateLimit(ws, this.env, this.options.rateLimit);
+			const request = parseClientMessage(message);
 			const result = await callRouter(router.createCaller({
 				shardId: this.shardId(),
 				validate: (input) => this.validate(input),
@@ -1198,9 +1322,17 @@ var CollectionShardDurableObject = class {
 				changes: (input) => this.readChanges(input, webSocketAuth(ws)),
 				callApi: (input) => this.callApi(ws, input)
 			}), request);
-			sendRpcResult(ws, request.id, result);
+			if (request.type === "changes" && isResyncRequired(result)) {
+				sendProtocolError(ws, request.id, {
+					code: "RESYNC_REQUIRED",
+					message: "The requested change history is no longer available",
+					details: result
+				});
+				return;
+			}
+			sendResult(ws, request.id, result);
 		} catch (error) {
-			sendRpcError(ws, readRpcId(message), error);
+			sendProtocolError(ws, readMessageId(message), error);
 		}
 	}
 	publish(batch) {
@@ -1212,17 +1344,16 @@ var CollectionShardDurableObject = class {
 		};
 		for (const socket of this.state.getWebSockets()) {
 			const updates = this.subscribedUpdates(socket, batch);
-			const invalidations = this.subscribedInvalidations(socket, batch);
+			const attachment = webSocketAttachment(socket);
+			const invalidations = attachment ? subscribedInvalidations(attachment.subscriptions, batch, this.options.collections, webSocketAuth(socket), this.accessStore()) : [];
 			if (updates.length === 0 && invalidations.length === 0) continue;
 			sendServerMessage(socket, {
-				method: "subscription",
-				params: {
-					path: "updates",
-					input: { json: {
-						...payload,
-						...invalidations.length > 0 ? { invalidations } : {},
-						updates
-					} }
+				version: 1,
+				type: "updates",
+				payload: {
+					...payload,
+					...invalidations.length > 0 ? { invalidations } : {},
+					updates
 				}
 			});
 		}
@@ -1253,6 +1384,7 @@ var CollectionShardDurableObject = class {
 		};
 	}
 	subscribe(ws, input) {
+		assertSubscriptionAllowed(ws, normalizeCollection(input.collection, this.options.collections), this.options.limits);
 		return this.updateSubscriptions(ws, input.collection, (subscriptions, collection) => {
 			subscriptions.add(collection);
 		});
@@ -1284,8 +1416,9 @@ var CollectionShardDurableObject = class {
 		return handler(args);
 	}
 	mutate(batch, auth = {}) {
-		this.validate(batch);
-		authorizeWriteBatch(batch, this.options.collections, auth, this.accessStore());
+		const pending = deduplicateMutations(this.state.storage.sql, batch);
+		this.validate(pending);
+		authorizeWriteBatch(pending, this.options.collections, auth, this.accessStore());
 		const persisted = this.persist(batch);
 		this.publish(persisted);
 		return {
@@ -1314,11 +1447,6 @@ var CollectionShardDurableObject = class {
 			}] : [];
 		});
 	}
-	subscribedInvalidations(ws, batch) {
-		const attachment = webSocketAttachment(ws);
-		if (!attachment || attachment.subscriptions.length === 0) return [];
-		return subscribedInvalidations(attachment.subscriptions, batch, this.options.collections, webSocketAuth(ws), this.accessStore());
-	}
 	accessStore() {
 		return { read: (collection, key) => readSQLiteJsonRow(this.state.storage.sql, collection, key, this.options.collections) };
 	}
@@ -1341,6 +1469,6 @@ function createWorkerHandler(options = {}) {
 	} };
 }
 //#endregion
-export { CollectionBuilder, CollectionConfigsBuilder, CollectionShardDefinitionBuilder, CollectionShardDurableObject, Collections, ServerCollectionBuilder, and, applySQLiteJsonBatch, authorizeApiCall, authorizeReadQuery, authorizeWriteBatch, collectionApiHandlers, collectionBuilder, collectionConfigsBuilder, collectionScope, compileReadExpression, createWorkerHandler, defaultCollectionApiPath, ensureSQLiteJsonTables, eq, field, gt, gte, inArray, isCollectionPattern, lt, lte, matchesReadPredicate, ne, not, or, persistSQLiteJsonBatchWithHistory, readAccessDecision, readExpressionReferences, readExpressionRow, readSQLiteJsonChanges, readSQLiteJsonRow, readSQLiteJsonRows, resolveCollection, router, sqliteJsonTable, val, validateBatch, visibleUpdateForAuth };
+export { CollectionShardDurableObject, DEFAULT_MAX_SUBSCRIPTIONS_PER_WEBSOCKET, SQLITE_JSON_CONFLICT_POLICY, and, applySQLiteJsonBatch, authorizeApiCall, authorizeReadQuery, authorizeWriteBatch, cloudflareRateLimiter, collectionApiHandlers, collectionScope, collectionShardOptionsFrom, compileReadExpression, createWorkerHandler, defaultCollectionApiPath, ensureSQLiteJsonTables, eq, field, gt, gte, inArray, isCollectionPattern, lt, lte, matchesReadPredicate, ne, not, or, persistSQLiteJsonBatchWithHistory, readAccessDecision, readExpressionReferences, readExpressionRow, readSQLiteJsonChanges, readSQLiteJsonRow, readSQLiteJsonRows, resolveCollection, router, sqliteJsonTable, val, validateBatch, visibleUpdateForAuth };
 
 //# sourceMappingURL=index.mjs.map