@sockethub/server 5.0.0-alpha.11 → 5.0.0-alpha.12

package/src/middleware/validate.ts

@@ -4,22 +4,89 @@
 
 import { createLogger } from "@sockethub/logger";
 import {
+    type ActivityObject,
     type ActivityStream,
-    type MiddlewareCallback,
+    AS2_BASE_CONTEXT_URL,
+    buildCanonicalContext,
+    resolvePlatformId,
+    SOCKETHUB_BASE_CONTEXT_URL,
     validateActivityObject,
     validateActivityStream,
     validateCredentials,
 } from "@sockethub/schemas";
 
 import getInitObject, { type IInitObject } from "../bootstrap/init.js";
+import type { MiddlewareChainInterface } from "../middleware.js";
 
 // called when registered with the middleware function, define the type of validation
 // that will be called when the middleware eventually does.
+export default function validate<T extends ActivityObject>(
+    type: "activity-object",
+    sockethubId: string,
+    passedInitObj?: IInitObject,
+): (msg: T, done: MiddlewareChainInterface<T>) => void;
+export default function validate<T extends ActivityStream>(
+    type: "credentials" | "message",
+    sockethubId: string,
+    passedInitObj?: IInitObject,
+): (msg: T, done: MiddlewareChainInterface<T>) => void;
 export default function validate(
     type: string,
     sockethubId: string,
     passedInitObj?: IInitObject,
 ) {
+    const baseContextUrls = new Set([
+        AS2_BASE_CONTEXT_URL,
+        SOCKETHUB_BASE_CONTEXT_URL,
+    ]);
+
+    const getLegacyContext = (stream: ActivityStream): string | undefined => {
+        const legacyContext = (stream as ActivityStream & { context?: unknown })
+            .context;
+        return typeof legacyContext === "string" ? legacyContext : undefined;
+    };
+
+    const getContextValues = (stream: ActivityStream): Array<string> => {
+        if (!Array.isArray(stream["@context"])) {
+            return [];
+        }
+        return stream["@context"].filter(
+            (value): value is string => typeof value === "string",
+        );
+    };
+
+    const getPlatformContextCandidates = (
+        stream: ActivityStream,
+    ): Array<string> => {
+        return getContextValues(stream).filter(
+            (value) => !baseContextUrls.has(value),
+        );
+    };
+
+    const normalizeLegacyContext = (
+        stream: ActivityStream,
+        initObj: IInitObject,
+    ) => {
+        if (resolvePlatformId(stream)) {
+            return;
+        }
+        const legacyContext = getLegacyContext(stream);
+        if (!legacyContext) {
+            return;
+        }
+        const platformMeta = initObj.platforms.get(legacyContext);
+        if (!platformMeta) {
+            return;
+        }
+        const platformContextUrl =
+            platformMeta.contextUrl ||
+            `https://sockethub.org/ns/context/platform/${legacyContext}/v1.jsonld`;
+        // Intentionally mutate the incoming stream so legacy `context` payloads
+        // continue through canonical @context/platform validation paths.
+        stream["@context"] = buildCanonicalContext(platformContextUrl);
+        stream.platform = legacyContext;
+    };
+
     let initObj = passedInitObj;
     if (!passedInitObj) {
         getInitObject().then((init) => {
@@ -28,45 +95,85 @@ export default function validate(
     }
 
     const sessionLog = createLogger(`server:validate:${sockethubId}`);
-    return (msg: ActivityStream, done: MiddlewareCallback) => {
+    return (
+        msg: ActivityStream | ActivityObject,
+        done: MiddlewareChainInterface<ActivityStream | ActivityObject>,
+    ) => {
         sessionLog.debug(`applying schema validation for ${type}`);
         if (type === "activity-object") {
-            const err = validateActivityObject(msg);
-            if (err) {
-                done(new Error(err));
-            } else {
-                done(msg);
-            }
-        } else if (!initObj.platforms.has(msg.context)) {
-            return done(
-                new Error(
-                    `platform context ${msg.context} not registered with this Sockethub instance.`,
-                ),
-            );
-        } else if (type === "credentials") {
-            const err = validateCredentials(msg);
+            const err = validateActivityObject(msg as ActivityObject);
             if (err) {
                 done(new Error(err));
             } else {
                 done(msg);
             }
         } else {
-            const err = validateActivityStream(msg);
-            if (err) {
-                done(new Error(err));
+            if (!initObj) {
+                return done(
+                    new Error(
+                        "Sockethub platforms not initialized for validation.",
+                    ),
+                );
+            }
+            const stream = msg as ActivityStream;
+            // Intentional mutation for backward compatibility with legacy `context`.
+            normalizeLegacyContext(stream, initObj);
+            const platformId = resolvePlatformId(stream);
+            if (!platformId) {
+                const platformContextCandidates =
+                    getPlatformContextCandidates(stream);
+                const contextDetails =
+                    platformContextCandidates.length === 0
+                        ? " No platform @context values were provided."
+                        : platformContextCandidates.length > 1
+                          ? ` Multiple platform @context values were provided: ${platformContextCandidates.join(", ")}.`
+                          : ` Unregistered platform @context value: ${platformContextCandidates[0]}`;
+                return done(
+                    new Error(
+                        `platform context URL not registered with this Sockethub instance.${contextDetails}`,
+                    ),
+                );
+            }
+            if (!initObj.platforms.has(platformId)) {
+                return done(
+                    new Error(
+                        `platform ${platformId} resolved from @context is not enabled in this Sockethub instance.`,
+                    ),
+                );
+            }
+            stream.platform = platformId;
+            if (type === "credentials") {
+                const err = validateCredentials(stream);
+                if (err) {
+                    done(new Error(err));
+                } else {
+                    done(stream);
+                }
             } else {
-                const platformMeta = initObj.platforms.get(msg.context);
-                if (!platformMeta.types.includes(msg.type)) {
-                    return done(
-                        new Error(
-                            `platform type ${msg.type} not supported by ${msg.context} ` +
-                                `platform. (types: ${platformMeta.types.join(
-                                    ", ",
-                                )})`,
-                        ),
-                    );
+                const err = validateActivityStream(stream);
+                if (err) {
+                    done(new Error(err));
+                } else {
+                    const platformMeta = initObj.platforms.get(platformId);
+                    if (!platformMeta) {
+                        return done(
+                            new Error(
+                                `platform ${platformId} not registered with this Sockethub instance.`,
+                            ),
+                        );
+                    }
+                    if (!platformMeta.types.includes(stream.type)) {
+                        return done(
+                            new Error(
+                                `platform type ${stream.type} not supported by ${platformId} ` +
+                                    `platform. (types: ${platformMeta.types.join(
+                                        ", ",
+                                    )})`,
+                            ),
+                        );
+                    }
+                    done(stream);
                 }
-                done(msg);
             }
         }
     };

package/src/middleware.ts

@@ -5,24 +5,27 @@ import type {
     Logger,
 } from "@sockethub/schemas";
 
-export default function middleware(name: string): MiddlewareChain {
-    return new MiddlewareChain(name);
+export default function middleware<T>(name: string): MiddlewareChain<T> {
+    return new MiddlewareChain<T>(name);
 }
 
-export type MiddlewareChainInterface = (
-    error: ActivityStream | ActivityObject | Error,
-    data?: ActivityStream | ActivityObject | MiddlewareChainInterface,
-    next?: MiddlewareChainInterface,
-) => void;
+export type MiddlewareNext<T> = (data?: T | Error) => void;
 
-type ErrorHandlerInterface = (err: Error, data?: unknown, cb?: unknown) => void;
+export type MiddlewareHandler<T> = (data: T, next: MiddlewareNext<T>) => void;
+export type MiddlewareErrorHandler<T> = (
+    err: Error,
+    data: T,
+    next: MiddlewareNext<T>,
+) => void;
 
 export type LogErrorInterface = (msg: Error) => void;
+export type MiddlewareChainInterface<T = ActivityStream | ActivityObject> =
+    MiddlewareNext<T>;
 
-export class MiddlewareChain {
+export class MiddlewareChain<T> {
     public name: string;
-    private chain: Array<MiddlewareChainInterface> = [];
-    private errHandler: ErrorHandlerInterface = (err: Error) => {
+    private chain: Array<MiddlewareHandler<T>> = [];
+    private errHandler: MiddlewareErrorHandler<T> = (err: Error) => {
         throw err;
     };
     private readonly logger: Logger;
@@ -32,16 +35,16 @@ export class MiddlewareChain {
         this.logger = createLogger(`middleware:${name}`);
     }
 
-    use(func: ErrorHandlerInterface | MiddlewareChainInterface): this {
+    use(func: MiddlewareErrorHandler<T> | MiddlewareHandler<T>): this {
         if (typeof func !== "function") {
             throw new Error(
                 "middleware use() can only take a function as an argument",
             );
         }
         if (func.length === 3) {
-            this.errHandler = func as ErrorHandlerInterface;
+            this.errHandler = func as MiddlewareErrorHandler<T>;
         } else if (func.length === 2) {
-            this.chain.push(func as MiddlewareChainInterface);
+            this.chain.push(func as MiddlewareHandler<T>);
         } else {
             throw new Error(
                 `middleware function provided with incorrect number of params: ${func.length}`,
@@ -51,22 +54,23 @@ export class MiddlewareChain {
     }
 
     done() {
-        return (data: unknown, callbackFunc: MiddlewareChainInterface) => {
-            let cb = callbackFunc;
+        return (data: T, callbackFunc: MiddlewareNext<T>) => {
+            let cb = callbackFunc as MiddlewareNext<T>;
             let position = 0;
             if (typeof callbackFunc !== "function") {
                 cb = () => {
                     // ensure we have a callback function
                 };
             }
-            const next = (_data: unknown) => {
-                if (_data instanceof Error) {
-                    this.logger.error(_data.toString());
-                    this.errHandler(_data, data, cb);
+            const next: MiddlewareNext<T> = (_data) => {
+                const nextData = _data === undefined ? data : _data;
+                if (nextData instanceof Error) {
+                    this.logger.error(nextData.toString());
+                    this.errHandler(nextData, data, cb);
                 } else if (typeof this.chain[position] === "function") {
-                    this.chain[position++](_data as ActivityStream, next);
+                    this.chain[position++](nextData as T, next);
                 } else {
-                    cb(_data as ActivityStream);
+                    cb(nextData as T);
                 }
             };
             next(data);

package/src/platform-instance.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import * as sinon from "sinon";
+import {
+    buildCanonicalContext,
+    INTERNAL_PLATFORM_CONTEXT_URL,
+} from "@sockethub/schemas";
 import { __dirname } from "./util.js";
 const FORK_PATH = __dirname + "/platform.js";
 
@@ -173,8 +177,37 @@ describe("PlatformInstance", () => {
             sandbox.assert.calledOnce(socketMock.emit);
             sandbox.assert.calledWith(socketMock.emit, "message", {
                 foo: "this is a message object",
-                context: "a platform name",
+                platform: "a platform name",
+                "@context": buildCanonicalContext(
+                    INTERNAL_PLATFORM_CONTEXT_URL,
+                ),
+            });
+        });
+
+        it("injects platform-specific @context when contextUrl is set", async () => {
+            const testContextUrl =
+                "https://sockethub.org/ns/context/platform/dummy/v1.jsonld";
+            pi.contextUrl = testContextUrl;
+            await pi.sendToClient("my session id", {
+                type: "echo",
+                actor: { id: "test@dummy", type: "person" },
+            });
+            sandbox.assert.calledOnce(socketMock.emit);
+            const emittedMsg = socketMock.emit.firstCall.args[1];
+            expect(emittedMsg["@context"]).toEqual(
+                buildCanonicalContext(testContextUrl),
+            );
+        });
+
+        it("strips legacy context field from outbound payloads", async () => {
+            await pi.sendToClient("my session id", {
+                type: "echo",
+                context: "dummy",
+                actor: { id: "test@dummy", type: "person" },
             });
+            const emittedMsg = socketMock.emit.firstCall.args[1];
+            expect(emittedMsg.context).toBeUndefined();
+            expect(emittedMsg["@context"]).toBeDefined();
         });
 
         it("broadcasts to peers", async () => {
@@ -212,6 +245,7 @@ describe("PlatformInstance", () => {
                 expect(pi.broadcastToSharedPeers.callCount).toEqual(1);
                 sandbox.assert.calledWith(pi.sendToClient, "a session id", {
                     foo: "bar",
+                    platform: "a platform name",
                 });
             });
 
@@ -225,6 +259,7 @@ describe("PlatformInstance", () => {
                 sandbox.assert.calledWith(pi.sendToClient, "a session id", {
                     foo: "bar",
                     error: "a bad result message",
+                    platform: "a platform name",
                 });
             });
         });
@@ -353,7 +388,7 @@ describe("PlatformInstance", () => {
                     sessionId: "session123",
                     msg: {
                         type: "connect",
-                        context: "xmpp",
+                        platform: "xmpp",
                         actor: { id: "testuser@localhost", type: "person" },
                     },
                     title: "xmpp-1",
@@ -405,7 +440,7 @@ describe("PlatformInstance", () => {
                     sessionId: "session123",
                     msg: {
                         type: "connect",
-                        context: "xmpp",
+                        platform: "xmpp",
                         actor: { id: "testuser@localhost", type: "person" },
                     },
                     title: "xmpp-1",
@@ -424,7 +459,7 @@ describe("PlatformInstance", () => {
                     sessionId: "session456",
                     msg: {
                         type: "send",
-                        context: "xmpp",
+                        platform: "xmpp",
                         actor: { id: "testuser@localhost", type: "person" },
                     },
                     title: "xmpp-2",
@@ -465,7 +500,7 @@ describe("PlatformInstance", () => {
                     sessionId: "session123",
                     msg: {
                         type: "connect",
-                        context: "xmpp",
+                        platform: "xmpp",
                         actor: { id: "testuser@localhost", type: "person" },
                     },
                     title: "xmpp-1",
@@ -514,7 +549,7 @@ describe("PlatformInstance", () => {
                     sessionId: "session123",
                     msg: {
                         type: "connect",
-                        context: "xmpp",
+                        platform: "xmpp",
                         actor: { id: "testuser@localhost", type: "person" },
                     },
                     title: "xmpp-1",