@vcp-dev/site-edit-bridge 0.6.11 → 0.7.0

package/dist/protocol.js

@@ -1,4 +1,7 @@
-import { encodeRenderDocument, } from "./document-codec.js";
+import { encodeRenderDocument } from "./document-codec.js";
+export const SITE_EDIT_COMPOSITION_SESSION_MISMATCH = "SITE_EDIT_COMPOSITION_SESSION_MISMATCH";
+export const SITE_EDIT_COMPOSITION_SESSION_REQUIRED = "SITE_EDIT_COMPOSITION_SESSION_REQUIRED";
+export const SITE_EDIT_COMPOSITION_REINITIALIZE_REQUIRED = "SITE_EDIT_COMPOSITION_REINITIALIZE_REQUIRED";
 export class SiteEditBridgeTransport {
     constructor() { }
     static parseMessage(raw, options = {}) {
@@ -12,15 +15,10 @@ export class SiteEditBridgeTransport {
         return JSON.stringify(message);
     }
     static extractRequestInfo(message) {
-        if (typeof message === "object" &&
-            message !== null &&
-            "payload" in message &&
-            typeof message.payload === "object" &&
-            message.payload !== null) {
-            const payload = message.payload;
-            const id = typeof payload.id === "string" ? payload.id : "unknown";
-            const kind = SiteEditBridgeTransport.isRequestKind(payload.kind)
-                ? payload.kind
+        if (isRecord(message) && isRecord(message.payload)) {
+            const id = typeof message.payload.id === "string" ? message.payload.id : "unknown";
+            const kind = this.isRequestKind(message.payload.kind)
+                ? message.payload.kind
                 : "get-document";
             return { id, kind };
         }
@@ -41,11 +39,10 @@ export class SiteEditBridgeTransport {
             value === "redo");
     }
     static isMessage(value, options = {}) {
-        if (!isRecord(value) || typeof value.type !== "string") {
+        if (!isRecord(value) || typeof value.type !== "string")
             return false;
-        }
         if (value.type === "request") {
-            return SiteEditBridgeTransport.isRequestPayload(value.payload, options);
+            return isRequestPayload(value.payload, options);
         }
         if (value.type === "response" || value.type === "error") {
             return isRecord(value.payload) && typeof value.payload.id === "string";
@@ -56,57 +53,23 @@ export class SiteEditBridgeTransport {
         if (value.type === "auth") {
             return isRecord(value.payload) && typeof value.payload.key === "string";
         }
-        if (value.type === "auth-ok") {
-            return isRecord(value.payload) && value.payload.ok === true;
-        }
-        return false;
-    }
-    static isRequestPayload(payload, options = {}) {
-        if (!isRecord(payload) ||
-            typeof payload.id !== "string" ||
-            !SiteEditBridgeTransport.isRequestKind(payload.kind)) {
-            return false;
-        }
-        switch (payload.kind) {
-            case "initialize-session":
-                return (typeof payload.routeId === "string" &&
-                    (payload.mutationContext === undefined ||
-                        isValidMutationContext(payload.mutationContext)));
-            case "get-document":
-            case "get-style-context":
-                return typeof payload.routeId === "string";
-            case "get-object-edit-context":
-            case "get-class-name-source":
-            case "resolve-source-location":
-                return (typeof payload.key === "string" &&
-                    (payload.routeId === undefined || typeof payload.routeId === "string"));
-            case "get-history-status":
-                return payload.mutationContext === undefined;
-            case "get-source-tree":
-                return true;
-            case "get-source-file":
-                return typeof payload.path === "string";
-            case "execute":
-                return (isOperationRequestLike(payload.request) &&
-                    (payload.request.mutationContext === undefined ||
-                        isValidMutationContext(payload.request.mutationContext)) &&
-                    (options.validateOperationRequest?.(payload.request) ?? true));
-            case "undo":
-            case "redo":
-                return (payload.mutationContext === undefined ||
-                    isValidMutationContext(payload.mutationContext));
-        }
+        return (value.type === "auth-ok" &&
+            isRecord(value.payload) &&
+            value.payload.ok === true);
     }
 }
 export class SiteEditBridgeSocketServer {
     constructor(options) {
         this.options = options;
+        this.session = {
+            subscribedCompositionKeys: new Set(),
+        };
         this.messageQueue = new SerializedSiteEditMessageQueue();
         this.eventDispatcher = new BufferedSiteEditEventDispatcher((message) => {
             this.sendJson(message);
         });
         this.unsubscribe = options.engine.subscribe((event) => {
-            this.eventDispatcher.push(event);
+            this.handleEngineEvent(event);
         });
         options.socket.onmessage = (event) => {
             try {
@@ -126,138 +89,112 @@ export class SiteEditBridgeSocketServer {
         };
         options.socket.onclose = () => {
             this.unsubscribe();
+            this.session.activeComposition = undefined;
+            this.session.subscribedCompositionKeys.clear();
         };
     }
     async handleMessage(message) {
         try {
             const parsed = message;
-            if (parsed.type !== "request") {
+            if (parsed.type !== "request")
                 return;
-            }
             const payload = parsed.payload;
             const { id } = payload;
             switch (payload.kind) {
                 case "initialize-session": {
+                    const selector = requireCompositionSelector(payload);
+                    const resolution = await this.resolve(selector);
                     const result = await this.options.engine.initializeSession({
-                        routeId: payload.routeId,
+                        composition: resolution.context,
                         ...(payload.mutationContext
                             ? { mutationContext: payload.mutationContext }
                             : {}),
                     });
+                    this.activateSession(resolution.context);
                     this.sendJson({
                         type: "response",
                         payload: {
                             id,
                             kind: payload.kind,
-                            result: {
-                                ok: true,
+                            result: addComposition({
+                                ...result,
                                 data: {
-                                    document: encodeRenderDocument(result.data.document),
-                                    historyStatus: result.data.historyStatus,
+                                    ...result.data,
+                                    document: encodeBridgeRenderDocument(result.data.document),
                                 },
-                            },
+                            }, resolution.context),
                         },
                     });
                     return;
                 }
-                case "get-document":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: {
-                                ok: true,
-                                data: encodeRenderDocument((await this.options.engine.getDocument(payload.routeId)).data),
-                            },
-                        },
-                    });
+                case "get-document": {
+                    const context = await this.resolveWireContext(payload);
+                    const result = await this.options.engine.getDocument(context);
+                    this.sendResult(id, payload.kind, encodeDocumentResult(result, context));
                     return;
-                case "get-history-status":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getHistoryStatus(),
-                        },
-                    });
+                }
+                case "get-history-status": {
+                    const context = await this.resolveWireContext(payload);
+                    const result = await this.options.engine.getHistoryStatus(context);
+                    this.sendResult(id, payload.kind, addComposition(result, context));
                     return;
-                case "get-style-context":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getStyleContext(payload.routeId),
-                        },
-                    });
+                }
+                case "get-style-context": {
+                    const context = await this.resolveWireContext(payload);
+                    this.sendResult(id, payload.kind, addComposition(await this.options.engine.getStyleContext(context), context));
                     return;
-                case "get-object-edit-context":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getObjectEditContext(payload.key, payload.routeId),
-                        },
-                    });
+                }
+                case "get-object-edit-context": {
+                    const context = await this.resolveWireContext(payload);
+                    this.sendResult(id, payload.kind, addComposition(await this.options.engine.getObjectEditContext(payload.key, context), context));
                     return;
-                case "get-class-name-source":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getClassNameSource(payload.key, payload.routeId),
-                        },
-                    });
+                }
+                case "get-class-name-source": {
+                    const context = await this.resolveWireContext(payload);
+                    this.sendResult(id, payload.kind, addComposition(await this.options.engine.getClassNameSource(payload.key, context), context));
                     return;
-                case "get-source-tree":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getSourceTree(),
-                        },
-                    });
+                }
+                case "get-source-tree": {
+                    const context = await this.resolveWireContext(payload);
+                    this.sendResult(id, payload.kind, addComposition(await this.options.engine.getSourceTree(context), context));
                     return;
-                case "get-source-file":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.getSourceFile({
-                                path: payload.path,
-                            }),
-                        },
-                    });
+                }
+                case "get-source-file": {
+                    const context = await this.resolveWireContext(payload);
+                    this.sendResult(id, payload.kind, addComposition(await this.options.engine.getSourceFile({
+                        path: payload.path,
+                        composition: context,
+                    }), context));
                     return;
-                case "resolve-source-location":
-                    this.sendJson({
-                        type: "response",
-                        payload: {
-                            id,
-                            kind: payload.kind,
-                            result: await this.options.engine.resolveSourceLocation({
-                                key: payload.key,
-                                routeId: payload.routeId,
-                            }),
-                        },
-                    });
+                }
+                case "resolve-source-location": {
+                    const context = await this.resolveWireContext(payload);
+                    const result = addComposition(await this.options.engine.resolveSourceLocation({
+                        key: payload.key,
+                        composition: context,
+                    }), context);
+                    this.sendResult(id, payload.kind, result);
                     return;
+                }
                 case "execute": {
-                    await this.handleBufferedOperation(id, payload.kind, () => this.options.engine.execute(payload.request));
+                    const context = await this.resolveOperationWireContext(payload.request);
+                    const payloadContext = await this.resolveWireContext(payload);
+                    if (computeSiteEditCompositionKey(context) !==
+                        computeSiteEditCompositionKey(payloadContext)) {
+                        throw new BridgeProtocolError(SITE_EDIT_COMPOSITION_SESSION_MISMATCH, "The execute request composition does not match its operation composition.");
+                    }
+                    const request = await this.normalizeOperationRequest(payload.request, context);
+                    await this.handleBufferedOperation(id, payload.kind, () => this.options.engine.execute(request));
                     return;
                 }
                 case "undo":
-                    await this.handleBufferedOperation(id, payload.kind, () => this.options.engine.undo());
-                    return;
-                case "redo":
-                    await this.handleBufferedOperation(id, payload.kind, () => this.options.engine.redo());
+                case "redo": {
+                    const context = await this.resolveWireContext(payload);
+                    await this.handleBufferedOperation(id, payload.kind, () => payload.kind === "undo"
+                        ? this.options.engine.undo(context)
+                        : this.options.engine.redo(context));
                     return;
+                }
             }
         }
         catch (error) {
@@ -272,6 +209,67 @@ export class SiteEditBridgeSocketServer {
             });
         }
     }
+    async resolve(selector) {
+        return this.options.engine.resolveComposition(selector);
+    }
+    async resolveAndAssert(selector) {
+        const resolution = await this.resolve(selector);
+        const active = this.session.activeComposition;
+        if (!active) {
+            throw new BridgeProtocolError(SITE_EDIT_COMPOSITION_SESSION_REQUIRED, "Initialize a composition session before issuing this request.");
+        }
+        if (computeSiteEditCompositionKey(active) !==
+            computeSiteEditCompositionKey(resolution.context)) {
+            throw new BridgeProtocolError(SITE_EDIT_COMPOSITION_SESSION_MISMATCH, "The request composition does not match the active socket session.");
+        }
+        return resolution.context;
+    }
+    async resolveWireContext(payload) {
+        const selector = requireCompositionSelector(payload);
+        return this.resolveAndAssert(selector);
+    }
+    async resolveOperationWireContext(request) {
+        const selector = requireOperationSelector(request);
+        return this.resolveAndAssert(selector);
+    }
+    activateSession(context) {
+        this.session.activeComposition = context;
+        this.session.subscribedCompositionKeys.clear();
+        this.session.subscribedCompositionKeys.add(computeSiteEditCompositionKey(context));
+    }
+    async normalizeOperationRequest(rawRequest, context) {
+        const request = {
+            ...rawRequest,
+            composition: contextToSelector(context),
+        };
+        if (request.target.kind === "route") {
+            const rawTarget = request.target;
+            const targetSelector = requireCompositionSelector(rawTarget);
+            const targetContext = await this.resolveAndAssert(targetSelector);
+            request.target = {
+                ...rawTarget,
+                composition: contextToSelector(targetContext),
+            };
+        }
+        return request;
+    }
+    handleEngineEvent(event) {
+        const composition = event?.composition;
+        if (!isCompositionContext(composition))
+            return;
+        const key = computeSiteEditCompositionKey(composition);
+        if (!this.session.subscribedCompositionKeys.has(key))
+            return;
+        this.eventDispatcher.push(event);
+        if (event.type === "site-edit.graph.invalidated" &&
+            key === activeKey(this.session)) {
+            this.session.activeComposition = undefined;
+            this.session.subscribedCompositionKeys.delete(key);
+        }
+    }
+    sendResult(id, kind, result) {
+        this.sendJson({ type: "response", payload: { id, kind, result } });
+    }
     async handleRawMessage(raw) {
         try {
             await this.handleMessage(SiteEditBridgeTransport.parseMessage(raw, {
@@ -279,11 +277,14 @@ export class SiteEditBridgeSocketServer {
             }));
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : "Invalid websocket message";
             const requestInfo = extractRawRequestInfo(raw);
             this.sendJson({
                 type: "error",
-                payload: { ...requestInfo, message },
+                payload: {
+                    ...requestInfo,
+                    message: getBridgeErrorMessage(error),
+                    code: getBridgeErrorCode(error),
+                },
             });
         }
     }
@@ -294,8 +295,7 @@ export class SiteEditBridgeSocketServer {
         this.eventDispatcher.beginBuffering();
         try {
             const result = await operation();
-            this.sendJson({ type: "response", payload: { id, kind, result } });
-            this.eventDispatcher.flush();
+            this.sendResult(id, kind, result);
         }
         catch (error) {
             this.sendJson({
@@ -307,10 +307,19 @@ export class SiteEditBridgeSocketServer {
                     code: getBridgeErrorCode(error),
                 },
             });
+        }
+        finally {
             this.eventDispatcher.flush();
         }
     }
 }
+class BridgeProtocolError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BridgeProtocolError";
+    }
+}
 class BufferedSiteEditEventDispatcher {
     constructor(send) {
         this.send = send;
@@ -333,9 +342,7 @@ class BufferedSiteEditEventDispatcher {
     flush() {
         const buffered = this.bufferedEvents ?? [];
         this.bufferedEvents = null;
-        buffered.forEach((message) => {
-            this.send(message);
-        });
+        buffered.forEach((message) => this.send(message));
     }
 }
 class SerializedSiteEditMessageQueue {
@@ -345,9 +352,8 @@ class SerializedSiteEditMessageQueue {
         this.queued = 0;
     }
     enqueue(task) {
-        if (this.queued >= this.maxQueued) {
+        if (this.queued >= this.maxQueued)
             throw new Error("Bridge request queue is full");
-        }
         this.queued += 1;
         const run = async () => {
             this.queued -= 1;
@@ -358,49 +364,126 @@ class SerializedSiteEditMessageQueue {
         return next;
     }
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
+function isRequestPayload(payload, options) {
+    if (!isRecord(payload) ||
+        typeof payload.id !== "string" ||
+        !SiteEditBridgeTransport.isRequestKind(payload.kind))
+        return false;
+    const compositionOk = isCompositionSelector(payload.composition);
+    switch (payload.kind) {
+        case "initialize-session":
+            return (compositionOk &&
+                (payload.mutationContext === undefined ||
+                    isMutationContextLike(payload.mutationContext)));
+        case "get-document":
+        case "get-style-context":
+            return compositionOk;
+        case "get-object-edit-context":
+        case "get-class-name-source":
+        case "resolve-source-location":
+            return typeof payload.key === "string" && compositionOk;
+        case "get-history-status":
+            return compositionOk;
+        case "get-source-tree":
+            return compositionOk;
+        case "get-source-file":
+            return typeof payload.path === "string" && compositionOk;
+        case "execute":
+            return (compositionOk &&
+                isOperationRequestLike(payload.request) &&
+                (payload.request.mutationContext === undefined ||
+                    isMutationContextLike(payload.request.mutationContext)) &&
+                (options.validateOperationRequest?.(payload.request) ?? true));
+        case "undo":
+        case "redo":
+            return ((compositionOk && payload.mutationContext === undefined) ||
+                (compositionOk && isMutationContextLike(payload.mutationContext)));
+    }
 }
 function isOperationRequestLike(value) {
     return (isRecord(value) &&
         typeof value.id === "string" &&
         typeof value.siteId === "string" &&
         typeof value.baseSnapshotId === "string" &&
-        (value.routeId === undefined || typeof value.routeId === "string") &&
+        isCompositionSelector(value.composition) &&
         typeof value.kind === "string" &&
         isRecord(value.target) &&
+        (value.target.kind !== "route" ||
+            isCompositionSelector(value.target.composition)) &&
         typeof value.documentVersion === "number" &&
         Number.isInteger(value.documentVersion) &&
         value.documentVersion >= 0 &&
         isRecord(value.params));
 }
-function isValidMutationContext(value) {
-    return isMutationContextLike(value);
+function isCompositionSelector(value) {
+    return (isRecord(value) &&
+        typeof value.routeId === "string" &&
+        value.routeId.length > 0 &&
+        (value.templateId === undefined ||
+            (typeof value.templateId === "string" && value.templateId.length > 0)) &&
+        Object.keys(value).every((key) => key === "routeId" || key === "templateId"));
 }
-function getBridgeErrorCode(error) {
-    if (!error || typeof error !== "object") {
-        return undefined;
-    }
-    const code = error.code;
-    return typeof code === "string" && code.length > 0 ? code : undefined;
+function isCompositionContext(value) {
+    return (isRecord(value) &&
+        typeof value.routeId === "string" &&
+        (value.effectiveTemplateId === undefined ||
+            typeof value.effectiveTemplateId === "string"));
 }
-function getBridgeErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (!error || typeof error !== "object") {
-        return "Unknown websocket operation failure";
-    }
-    const message = error.message;
-    return typeof message === "string" && message.length > 0
-        ? message
-        : "Unknown websocket operation failure";
+function requireCompositionSelector(payload) {
+    if (isCompositionSelector(payload.composition))
+        return payload.composition;
+    throw new BridgeProtocolError(SITE_EDIT_COMPOSITION_SESSION_REQUIRED, "A composition selector is required for this request.");
+}
+function requireOperationSelector(request) {
+    if (isRecord(request) && isCompositionSelector(request.composition))
+        return request.composition;
+    throw new BridgeProtocolError(SITE_EDIT_COMPOSITION_SESSION_REQUIRED, "A composition selector is required for execute.");
+}
+function contextToSelector(context) {
+    return {
+        routeId: context.routeId,
+        ...(context.effectiveTemplateId
+            ? { templateId: context.effectiveTemplateId }
+            : {}),
+    };
+}
+function activeKey(session) {
+    return session.activeComposition
+        ? computeSiteEditCompositionKey(session.activeComposition)
+        : null;
+}
+function computeSiteEditCompositionKey(context) {
+    return JSON.stringify([context.routeId, context.effectiveTemplateId ?? null]);
+}
+function addComposition(result, context) {
+    return isRecord(result) && result.ok === true
+        ? { ...result, composition: context }
+        : result;
+}
+function encodeDocumentResult(result, context) {
+    if (!isRecord(result) || result.ok !== true)
+        return result;
+    return {
+        ...result,
+        ...(context ? { composition: context } : {}),
+        data: encodeBridgeRenderDocument(result.data),
+    };
+}
+function encodeBridgeRenderDocument(document) {
+    const value = document;
+    return encodeRenderDocument(value.routeId
+        ? value
+        : {
+            ...value,
+            routeId: value.composition.routeId,
+        });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
 }
 function isMutationContextLike(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    return (typeof value.editingSessionId === "string" &&
+    return (isRecord(value) &&
+        typeof value.editingSessionId === "string" &&
         value.editingSessionId.length > 0 &&
         typeof value.lockId === "string" &&
         value.lockId.length > 0 &&
@@ -409,6 +492,22 @@ function isMutationContextLike(value) {
         typeof value.leaseAssertion === "string" &&
         value.leaseAssertion.length > 0);
 }
+function getBridgeErrorCode(error) {
+    if (!isRecord(error) ||
+        typeof error.code !== "string" ||
+        error.code.length === 0)
+        return undefined;
+    return error.code;
+}
+function getBridgeErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (isRecord(error) &&
+        typeof error.message === "string" &&
+        error.message.length > 0)
+        return error.message;
+    return "Unknown websocket operation failure";
+}
 function extractRawRequestInfo(raw) {
     try {
         return SiteEditBridgeTransport.extractRequestInfo(JSON.parse(raw));

package/dist/server.d.ts

@@ -56,12 +56,15 @@ export declare class SiteEditBridgeServer {
     private readonly mutationQueue;
     private readonly eventListeners;
     private routes;
+    private compositions;
+    private compositionFiles;
+    private compositionResolutionError;
     private stopWatching;
     private stopWebSocketServer;
     private readonly pendingChangedFiles;
     private fileChangeTimer;
     private isStarted;
-    private runtimeVersionFloor;
+    private readonly runtimeVersionFloors;
     private activeHistoryStore;
     private versionPersistence;
     constructor(options: ReturnType<typeof normalizeOptions>, server?: HttpServer, closeHttpServerOnStop?: boolean, dependencies?: SiteEditBridgeServerDependencies);
@@ -74,13 +77,12 @@ export declare class SiteEditBridgeServer {
     private createBridgeEngine;
     private bindHistorySession;
     private recordRuntimeVersion;
-    private activateRoute;
-    private normalizeRequest;
     private handleFileChanged;
     private handleFilesChanged;
     private flushChangedFiles;
-    private refreshRoutes;
-    private resolveRouteId;
+    private refreshCompositions;
+    private resolveComposition;
+    private getInitialDocumentVersions;
     private getRuntime;
 }
 declare function normalizeOptions(options: SiteEditBridgeServerOptions): {