happy2 0.0.5

package/packages/happy2-server/dist/routes/operations.test.js

@@ -0,0 +1,106 @@
+import Fastify, {} from "fastify";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { Database } from "../modules/database.js";
+import { OperationsRepository } from "../modules/operations/repository.js";
+import { registerOperationsRoutes } from "./operations.js";
+describe("operations routes", () => {
+    let directory;
+    let database;
+    let repository;
+    let app;
+    let admin;
+    let member;
+    beforeEach(async () => {
+        directory = await mkdtemp(join(tmpdir(), "happy2-operations-routes-"));
+        const url = `file:${join(directory, "happy2.db")}`;
+        database = new Database(url);
+        await database.migrate();
+        repository = new OperationsRepository(url);
+        admin = await createUser(database, "admin@example.com", "admin", "Ada");
+        member = await createUser(database, "member@example.com", "member", "Grace");
+        app = Fastify({ trustProxy: false });
+        registerOperationsRoutes(app, fakeAuth(() => ({ admin, member })), repository);
+    });
+    afterEach(async () => {
+        await app.close();
+        repository.close();
+        database.close();
+        await rm(directory, { recursive: true, force: true });
+    });
+    it("maps authentication, role, and validation failures to stable HTTP errors", async () => {
+        const unauthorized = await app.inject({ method: "GET", url: "/v0/admin/auditLogs" });
+        expect(unauthorized.statusCode).toBe(401);
+        const forbidden = await app.inject({
+            method: "GET",
+            url: "/v0/admin/auditLogs",
+            headers: { authorization: "Bearer member" },
+        });
+        expect(forbidden.statusCode).toBe(403);
+        const invalid = await app.inject({
+            method: "POST",
+            url: `/v0/admin/users/${member.user.id}/applyBan`,
+            headers: { authorization: "Bearer admin" },
+            payload: { unexpected: true },
+        });
+        expect(invalid.statusCode).toBe(400);
+        expect(invalid.json()).toMatchObject({ error: "invalid_request" });
+    });
+    it("creates a member report and lets an administrator review it", async () => {
+        const created = await app.inject({
+            method: "POST",
+            url: "/v0/reports/createReport",
+            headers: {
+                authorization: "Bearer member",
+                "x-happy2-device": "Happy (2) Desktop",
+            },
+            payload: {
+                targetUserId: admin.user.id,
+                reason: "Profile needs review",
+            },
+        });
+        expect(created.statusCode).toBe(201);
+        expect(created.json().report).toMatchObject({
+            reportedByUserId: member.user.id,
+            status: "open",
+        });
+        const listed = await app.inject({
+            method: "GET",
+            url: "/v0/admin/reports?status=open&limit=10",
+            headers: { authorization: "Bearer admin" },
+        });
+        expect(listed.statusCode).toBe(200);
+        expect(listed.json().reports).toHaveLength(1);
+    });
+});
+function fakeAuth(identities) {
+    return {
+        async authenticate(request) {
+            const token = request.headers.authorization?.replace(/^Bearer /, "");
+            const selected = token === "admin"
+                ? identities().admin
+                : token === "member"
+                    ? identities().member
+                    : undefined;
+            if (!selected)
+                return undefined;
+            return {
+                session: {
+                    id: `session-${token}`,
+                    accountId: selected.account.id,
+                    expiresAt: new Date(Date.now() + 60_000),
+                },
+                accountId: selected.account.id,
+                user: selected.user,
+            };
+        },
+    };
+}
+async function createUser(database, email, username, firstName) {
+    const account = await database.createPasswordAccount(email, "not-used-in-this-test");
+    const user = await database.createProfile(account.id, { firstName, username, email });
+    return { account, user };
+}
+//# sourceMappingURL=operations.test.js.map

package/packages/happy2-server/dist/routes/operations.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.test.js","sourceRoot":"","sources":["../../sources/routes/operations.test.ts"],"names":[],"mappings":"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"}

package/packages/happy2-server/dist/routes/sync.d.ts

@@ -0,0 +1,6 @@
+import type { FastifyInstance } from "fastify";
+import type { AuthService } from "../modules/auth/service.js";
+import { CollaborationRepository } from "../modules/collaboration/repository.js";
+import { type PubSub } from "../modules/realtime/index.js";
+export declare function registerSyncRoutes(app: FastifyInstance, auth: AuthService, repository: CollaborationRepository, pubsub: PubSub): void;
+//# sourceMappingURL=sync.d.ts.map

package/packages/happy2-server/dist/routes/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../sources/routes/sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,SAAS,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEjF,OAAO,EAOH,KAAK,MAAM,EAKd,MAAM,8BAA8B,CAAC;AAatC,wBAAgB,kBAAkB,CAC9B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,uBAAuB,EACnC,MAAM,EAAE,MAAM,GACf,IAAI,CA+KN"}

package/packages/happy2-server/dist/routes/sync.js

@@ -0,0 +1,549 @@
+import { createId } from "@paralleldrive/cuid2";
+import { CollaborationRepository } from "../modules/collaboration/repository.js";
+import { CollaborationError } from "../modules/collaboration/types.js";
+import { assertRealtimeEvent, assertRealtimeId, assertSequence, DEFAULT_REALTIME_LIMITS, realtimeTopics, } from "../modules/realtime/index.js";
+const COMMON_DIFFERENCE_LIMIT = 500;
+const MAX_COMMON_DIFFERENCE_LIMIT = 1_000;
+const CHAT_DIFFERENCE_LIMIT = 100;
+const MAX_CHAT_DIFFERENCE_LIMIT = 1_000;
+const DEFAULT_TYPING_TTL_MS = 10_000;
+const HEARTBEAT_MS = 15_000;
+const MAX_INITIAL_EVENTS = 256;
+const MAX_SSE_QUEUE_BYTES = 256 * 1024;
+export function registerSyncRoutes(app, auth, repository, pubsub) {
+    // Presence connections are intentionally process-local, just like the current PubSub adapter.
+    // Keeping ownership here prevents one user from touching another user's connection by id.
+    const presenceOwners = new Map();
+    app.get("/v0/sync/state", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        return { state: await repository.getState(), serverTime: new Date().toISOString() };
+    });
+    app.post("/v0/sync/getDifference", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const body = object(request.body, "body");
+            const state = object(body.state, "state");
+            return await repository.getDifference({
+                userId: current.user.id,
+                generation: id(state.generation, "state.generation"),
+                fromSequence: sequence(state.sequence, "state.sequence"),
+                untilSequence: optionalSequence(body.untilSequence, "untilSequence"),
+                limit: limit(body.limit, COMMON_DIFFERENCE_LIMIT, MAX_COMMON_DIFFERENCE_LIMIT),
+            });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+    app.post("/v0/sync/acknowledge", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const body = object(request.body, "body");
+            const state = object(body.state, "state");
+            await repository.acknowledgeSyncConsumer({
+                userId: current.user.id,
+                deviceId: id(body.deviceId, "deviceId"),
+                generation: id(state.generation, "state.generation"),
+                sequence: sequence(state.sequence, "state.sequence"),
+            });
+            return reply.code(202).send({ accepted: true });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+    app.post("/v0/chats/:chatId/getDifference", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const chatId = routeId(request, "chatId");
+            const body = object(request.body, "body");
+            const state = object(body.state, "state");
+            return await repository.getChatDifference({
+                userId: current.user.id,
+                chatId,
+                membershipEpoch: id(state.membershipEpoch, "state.membershipEpoch"),
+                fromPts: sequence(state.pts, "state.pts"),
+                untilPts: optionalSequence(body.untilPts, "untilPts"),
+                limit: limit(body.limit, CHAT_DIFFERENCE_LIMIT, MAX_CHAT_DIFFERENCE_LIMIT),
+            });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+    app.get("/v0/sync/events", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        return openEventStream(request, reply, current.user.id, auth, repository, pubsub, presenceOwners);
+    });
+    app.post("/v0/chats/:chatId/setTyping", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const chatId = routeId(request, "chatId");
+            const body = object(request.body, "body");
+            if (typeof body.active !== "boolean")
+                throw new RequestValidationError("active must be a boolean");
+            const ttlMs = typingTtl(body.ttlMs);
+            if (!(await repository.canPostToChat(current.user.id, chatId))) {
+                return (await repository.canAccessChat(current.user.id, chatId))
+                    ? reply.code(403).send({ error: "forbidden" })
+                    : reply.code(404).send({ error: "not_found" });
+            }
+            const occurredAt = Date.now();
+            const event = body.active
+                ? {
+                    type: "typing",
+                    chatId,
+                    userId: current.user.id,
+                    active: true,
+                    occurredAt,
+                    expiresAt: occurredAt + ttlMs,
+                }
+                : {
+                    type: "typing",
+                    chatId,
+                    userId: current.user.id,
+                    active: false,
+                    occurredAt,
+                };
+            assertRealtimeEvent(event);
+            await pubsub.publish(realtimeTopics.chat(chatId), event);
+            return reply.code(202).send({ accepted: true });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+    app.post("/v0/me/updatePresence", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const body = object(request.body, "body");
+            const connectionId = id(body.connectionId, "connectionId");
+            if (presenceOwners.get(connectionId) !== current.user.id)
+                return reply.code(404).send({ error: "presence_connection_not_found" });
+            const presence = await pubsub.recordPresenceActivity(connectionId);
+            return presence
+                ? { presence }
+                : reply.code(404).send({ error: "presence_connection_not_found" });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+    app.post("/v0/calls/:callId/sendSignal", async (request, reply) => {
+        const current = await auth.authenticate(request);
+        if (!current)
+            return unauthorized(reply);
+        try {
+            const callId = routeId(request, "callId");
+            const body = object(request.body, "body");
+            const chatId = id(body.chatId, "chatId");
+            const recipientUserId = id(body.recipientUserId, "recipientUserId");
+            if (recipientUserId === current.user.id)
+                throw new RequestValidationError("recipientUserId must identify another user");
+            if (!(await repository.canSignalCall({
+                userId: current.user.id,
+                callId,
+                chatId,
+                recipientUserId,
+            })))
+                return reply.code(404).send({ error: "call_or_recipient_not_found" });
+            const event = {
+                type: "call.signal",
+                callId,
+                chatId,
+                senderUserId: current.user.id,
+                recipientUserId,
+                signal: webRtcSignal(body.signal),
+                occurredAt: Date.now(),
+            };
+            assertRealtimeEvent(event);
+            await Promise.all([
+                pubsub.publish(realtimeTopics.call(callId), event),
+                pubsub.publish(realtimeTopics.user(recipientUserId), event),
+            ]);
+            return reply.code(202).send({ accepted: true });
+        }
+        catch (error) {
+            return handledError(reply, error) ?? Promise.reject(error);
+        }
+    });
+}
+async function openEventStream(request, reply, userId, auth, repository, pubsub, presenceOwners) {
+    const connectionId = createId();
+    const subscriptions = new Map();
+    const pending = [];
+    let responseReady = false;
+    let presenceConnected = false;
+    let heartbeat;
+    let heartbeatRunning = false;
+    let closed = false;
+    let writer;
+    const cleanup = () => {
+        if (closed)
+            return;
+        closed = true;
+        if (heartbeat)
+            clearInterval(heartbeat);
+        for (const unsubscribe of subscriptions.values())
+            unsubscribe();
+        subscriptions.clear();
+        writer?.close();
+        if (presenceOwners.get(connectionId) === userId)
+            presenceOwners.delete(connectionId);
+        if (presenceConnected) {
+            presenceConnected = false;
+            void pubsub.disconnectPresence(connectionId).catch((error) => {
+                request.log.error(error, "Could not disconnect realtime presence");
+            });
+        }
+    };
+    const terminate = () => {
+        cleanup();
+        if (!reply.raw.destroyed && !reply.raw.writableEnded)
+            reply.raw.end();
+    };
+    const send = (name, data) => {
+        if (closed)
+            return;
+        if (!responseReady || !writer) {
+            if (pending.length >= MAX_INITIAL_EVENTS) {
+                // Never silently discard signaling during stream setup. Closing makes the
+                // overflow explicit; durable state is recovered by getDifference on reconnect.
+                terminate();
+                return;
+            }
+            pending.push({ name, data });
+            return;
+        }
+        if (!writer.send(name, data))
+            terminate();
+    };
+    const ensureSubscription = (topic) => {
+        if (closed || subscriptions.has(topic))
+            return;
+        subscriptions.set(topic, pubsub.subscribe(topic, async (event) => {
+            const visible = await visibleRealtimeEvent(repository, userId, event);
+            if (!visible || closed)
+                return;
+            if (visible.type === "sync") {
+                for (const chat of visible.chats)
+                    ensureSubscription(realtimeTopics.chat(chat.chatId));
+            }
+            send(visible.type, visible);
+        }));
+    };
+    const reconcileChatSubscriptions = async () => {
+        const chats = await repository.listChats(userId);
+        const expected = new Set(chats.map((chat) => realtimeTopics.chat(chat.id)));
+        for (const topic of expected)
+            ensureSubscription(topic);
+        for (const [topic, unsubscribe] of subscriptions) {
+            if (topic.startsWith("chat:") && !expected.has(topic)) {
+                unsubscribe();
+                subscriptions.delete(topic);
+            }
+        }
+    };
+    request.raw.once("aborted", cleanup);
+    reply.raw.once("close", cleanup);
+    reply.raw.once("error", cleanup);
+    try {
+        // Install the broad subscriptions before reading state. Anything delivered during setup is
+        // queued, and durable changes are still recovered from the ready-state cursor.
+        ensureSubscription(realtimeTopics.user(userId));
+        ensureSubscription(realtimeTopics.presence);
+        ensureSubscription(realtimeTopics.server);
+        await reconcileChatSubscriptions();
+        if (closed)
+            return;
+        await pubsub.connectPresence({ connectionId, userId });
+        if (closed) {
+            await pubsub.disconnectPresence(connectionId);
+            return;
+        }
+        presenceConnected = true;
+        presenceOwners.set(connectionId, userId);
+        const state = await repository.getState();
+        if (closed)
+            return;
+        reply.hijack();
+        prepareSseResponse(reply);
+        writer = new SseWriter(reply.raw, MAX_SSE_QUEUE_BYTES, terminate);
+        responseReady = true;
+        send("ready", { connectionId, state, heartbeatMs: HEARTBEAT_MS });
+        for (const event of pending.splice(0))
+            send(event.name, event.data);
+        if (closed)
+            return;
+        heartbeat = setInterval(() => {
+            if (closed || heartbeatRunning)
+                return;
+            heartbeatRunning = true;
+            void (async () => {
+                const authenticated = await auth.authenticate(request);
+                if (!authenticated || authenticated.user.id !== userId) {
+                    terminate();
+                    return;
+                }
+                await reconcileChatSubscriptions();
+                const nextState = await repository.getState();
+                send("heartbeat", {
+                    serverTime: new Date().toISOString(),
+                    state: nextState,
+                });
+            })()
+                .catch((error) => {
+                request.log.error(error, "Realtime heartbeat failed");
+                terminate();
+            })
+                .finally(() => {
+                heartbeatRunning = false;
+            });
+        }, HEARTBEAT_MS);
+        heartbeat.unref();
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+}
+async function visibleRealtimeEvent(repository, userId, event) {
+    if (event.type === "presence")
+        return event;
+    if (event.type === "sync") {
+        const chats = [];
+        for (const chat of event.chats) {
+            if (await repository.canAccessChat(userId, chat.chatId))
+                chats.push(chat);
+        }
+        return { ...event, chats };
+    }
+    if (event.type === "workspace.changed")
+        return (await repository.canAccessChatWorkspace(userId, event.chatId)) ? event : undefined;
+    if (!(await repository.canAccessChat(userId, event.chatId)))
+        return undefined;
+    if (event.type === "call.signal" &&
+        event.recipientUserId !== undefined &&
+        event.recipientUserId !== userId)
+        return undefined;
+    return event;
+}
+function prepareSseResponse(reply) {
+    // Fastify lifecycle hooks have already populated response headers (notably CORS); copying them
+    // before the raw response is flushed preserves those headers after hijacking the response.
+    for (const [name, value] of Object.entries(reply.getHeaders())) {
+        if (value !== undefined)
+            reply.raw.setHeader(name, value);
+    }
+    reply.raw.statusCode = 200;
+    reply.raw.setHeader("content-type", "text/event-stream; charset=utf-8");
+    reply.raw.setHeader("cache-control", "no-cache, no-transform");
+    reply.raw.setHeader("connection", "keep-alive");
+    reply.raw.setHeader("x-accel-buffering", "no");
+    reply.raw.socket?.setKeepAlive(true);
+    reply.raw.flushHeaders();
+}
+class SseWriter {
+    response;
+    maxQueuedBytes;
+    onFailure;
+    queued = [];
+    queuedBytes = 0;
+    blocked = false;
+    closed = false;
+    constructor(response, maxQueuedBytes, onFailure) {
+        this.response = response;
+        this.maxQueuedBytes = maxQueuedBytes;
+        this.onFailure = onFailure;
+    }
+    send(name, data) {
+        if (this.closed || this.response.destroyed || this.response.writableEnded)
+            return false;
+        const frame = `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`;
+        const bytes = Buffer.byteLength(frame);
+        if (this.blocked) {
+            if (this.queuedBytes + bytes > this.maxQueuedBytes)
+                return false;
+            this.queued.push(frame);
+            this.queuedBytes += bytes;
+            return true;
+        }
+        try {
+            if (!this.response.write(frame)) {
+                this.blocked = true;
+                this.response.once("drain", this.flush);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.response.off("drain", this.flush);
+        this.queued.length = 0;
+        this.queuedBytes = 0;
+    }
+    flush = () => {
+        if (this.closed)
+            return;
+        this.blocked = false;
+        while (this.queued.length > 0) {
+            const frame = this.queued.shift();
+            this.queuedBytes -= Buffer.byteLength(frame);
+            try {
+                if (!this.response.write(frame)) {
+                    this.blocked = true;
+                    this.response.once("drain", this.flush);
+                    return;
+                }
+            }
+            catch {
+                this.onFailure();
+                return;
+            }
+        }
+    };
+}
+function object(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new RequestValidationError(`${name} must be an object`);
+    return value;
+}
+function id(value, name) {
+    if (typeof value !== "string")
+        throw new RequestValidationError(`${name} must be a string`);
+    try {
+        assertRealtimeId(value, name);
+        return value;
+    }
+    catch (error) {
+        throw new RequestValidationError(message(error));
+    }
+}
+function routeId(request, name) {
+    return id(request.params?.[name], name);
+}
+function sequence(value, name) {
+    if (typeof value !== "string")
+        throw new RequestValidationError(`${name} must be an unsigned decimal string`);
+    try {
+        assertSequence(value, name);
+    }
+    catch (error) {
+        throw new RequestValidationError(message(error));
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        throw new RequestValidationError(`${name} exceeds the supported integer range`);
+    return parsed;
+}
+function optionalSequence(value, name) {
+    return value === undefined ? undefined : sequence(value, name);
+}
+function limit(value, fallback, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+        throw new RequestValidationError(`limit must be an integer between 1 and ${maximum}`);
+    return value;
+}
+function typingTtl(value) {
+    if (value === undefined)
+        return DEFAULT_TYPING_TTL_MS;
+    if (!Number.isSafeInteger(value) ||
+        value < 1 ||
+        value > DEFAULT_REALTIME_LIMITS.maxTypingTtlMs)
+        throw new RequestValidationError(`ttlMs must be an integer between 1 and ${DEFAULT_REALTIME_LIMITS.maxTypingTtlMs}`);
+    return value;
+}
+function webRtcSignal(value) {
+    const signal = object(value, "signal");
+    if (signal.kind === "offer" || signal.kind === "answer") {
+        if (typeof signal.sdp !== "string")
+            throw new RequestValidationError("signal.sdp must be a string");
+        return { kind: signal.kind, sdp: signal.sdp };
+    }
+    if (signal.kind === "ice-candidate") {
+        if (typeof signal.candidate !== "string")
+            throw new RequestValidationError("signal.candidate must be a string");
+        if (signal.sdpMid !== undefined &&
+            signal.sdpMid !== null &&
+            typeof signal.sdpMid !== "string")
+            throw new RequestValidationError("signal.sdpMid must be a string or null");
+        if (signal.sdpMLineIndex !== undefined &&
+            signal.sdpMLineIndex !== null &&
+            (!Number.isSafeInteger(signal.sdpMLineIndex) || signal.sdpMLineIndex < 0))
+            throw new RequestValidationError("signal.sdpMLineIndex must be a non-negative integer");
+        if (signal.usernameFragment !== undefined &&
+            signal.usernameFragment !== null &&
+            typeof signal.usernameFragment !== "string")
+            throw new RequestValidationError("signal.usernameFragment must be a string or null");
+        return {
+            kind: "ice-candidate",
+            candidate: signal.candidate,
+            sdpMid: signal.sdpMid,
+            sdpMLineIndex: signal.sdpMLineIndex,
+            usernameFragment: signal.usernameFragment,
+        };
+    }
+    if (signal.kind === "hangup") {
+        if (signal.reason !== undefined &&
+            signal.reason !== "ended" &&
+            signal.reason !== "declined" &&
+            signal.reason !== "busy" &&
+            signal.reason !== "failed")
+            throw new RequestValidationError("signal.reason is invalid");
+        return {
+            kind: "hangup",
+            reason: signal.reason,
+        };
+    }
+    throw new RequestValidationError("signal.kind is invalid");
+}
+function handledError(reply, error) {
+    if (error instanceof RequestValidationError)
+        return reply.code(400).send({ error: "invalid_request", message: error.message });
+    if (!(error instanceof CollaborationError))
+        return undefined;
+    const status = {
+        not_found: 404,
+        forbidden: 403,
+        invalid: 400,
+        conflict: 409,
+        future_state: 409,
+        generation_mismatch: 409,
+    }[error.code];
+    const responseCode = error.code === "invalid"
+        ? "invalid_request"
+        : error.code === "future_state"
+            ? "future_sync_state"
+            : error.code;
+    return reply.code(status).send({ error: responseCode, message: error.message });
+}
+function unauthorized(reply) {
+    return reply.code(401).send({ error: "unauthorized" });
+}
+function message(error) {
+    return error instanceof Error ? error.message : "Invalid request";
+}
+class RequestValidationError extends Error {
+}
+//# sourceMappingURL=sync.js.map