@sockethub/server 5.0.0-alpha.10

package/src/middleware/validate.test.data.ts

@@ -0,0 +1,259 @@
+export default [
+    {
+        name: "mismatched types",
+        valid: false,
+        type: "credentials",
+        input: {
+            id: "blah",
+            type: "send",
+            context: "fakeplatform",
+            actor: {
+                id: "dood@irc.freenode.net",
+                type: "person",
+                name: "dood",
+            },
+            target: {
+                id: "irc.freenode.net/service",
+                type: "person",
+                name: "service",
+            },
+            object: {
+                type: "credentials",
+                user: "foo",
+                pass: "bar",
+            },
+        },
+        error: "Error: credential activity streams must have credentials set as type",
+    },
+    {
+        name: "basic",
+        valid: true,
+        type: "credentials",
+        input: {
+            id: "blah",
+            type: "credentials",
+            context: "fakeplatform",
+            actor: {
+                id: "dood@irc.freenode.net",
+                type: "person",
+                name: "dood",
+            },
+            object: {
+                type: "credentials",
+                user: "foo",
+                pass: "bar",
+            },
+        },
+        output: "same",
+    },
+    {
+        name: "no type specified",
+        valid: false,
+        type: "credentials",
+        input: {
+            actor: "hyper_rau@localhost",
+            context: "fakeplatform",
+            object: {
+                username: "hyper_rau",
+                password: "123",
+                server: "localhost",
+                port: 5222,
+                resource: "laptop",
+            },
+        },
+        error: "Error: credential activity streams must have credentials set as type",
+    },
+    {
+        name: "basic person",
+        type: "activity-object",
+        valid: true,
+        input: {
+            id: "blah",
+            type: "person",
+            name: "dood",
+        },
+        output: "same",
+    },
+    {
+        name: "person with extras",
+        valid: true,
+        type: "activity-object",
+        input: {
+            id: "blah",
+            type: "person",
+            name: "bob",
+            hello: "there",
+            i: ["am", "extras"],
+        },
+        output: "same",
+    },
+    {
+        name: "alone credentials (as activity-object)",
+        valid: false,
+        type: "activity-object",
+        input: {
+            type: "credentials",
+            nick: "sh-9K3Vk",
+            port: 6667,
+            secure: false,
+            server: "irc.freenode.net",
+        },
+        error:
+            "Error: /object: must match exactly one schema in oneOf: " +
+            "credentials, feed, message, me, person, room, service, website, " +
+            "attendance, presence, relationship, topic, address",
+    },
+    {
+        name: "alone credentials (as credentials)",
+        valid: false,
+        type: "credentials",
+        input: {
+            type: "credentials",
+            nick: "sh-9K3Vk",
+            port: 6667,
+            secure: false,
+            server: "irc.freenode.net",
+        },
+        error: "Error: platform context undefined not registered with this Sockethub instance.",
+    },
+    {
+        name: "new person",
+        valid: true,
+        type: "activity-object",
+        input: {
+            id: "sh-9K3Vk@irc.freenode.net",
+            type: "person",
+            name: "sh-9K3Vk",
+            image: {
+                height: 250,
+                mediaType: "image/jpeg",
+                url: "https://example.org/image.jpg",
+                width: 250,
+            },
+            url: "https://sockethub.org",
+        },
+        output: "same",
+    },
+    {
+        name: "new person",
+        valid: true,
+        type: "activity-object",
+        input: {
+            id: "irc://sh-9K3Vk@irc.freenode.net",
+            type: "person",
+            name: "sh-9K3Vk",
+            url: "https://sockethub.org",
+        },
+        output: "same",
+    },
+    {
+        name: "bad parent object",
+        valid: false,
+        type: "activity-stream",
+        input: {
+            string: "this is a string",
+            array: [
+                "this",
+                "is",
+                {
+                    an: "array",
+                },
+            ],
+            as: {
+                id: "blah",
+                type: "send",
+                context: "hello",
+                actor: {
+                    name: "dood",
+                },
+                target: {
+                    type: "person",
+                    name: "bob",
+                },
+                object: {
+                    type: "credentials",
+                },
+            },
+            noId: {
+                name: "dood",
+            },
+            noId2: {
+                type: "person",
+                name: "bob",
+            },
+            noDisplayName: {
+                id: "larg",
+            },
+        },
+        error: "Error: platform context undefined not registered with this Sockethub instance.",
+    },
+    {
+        name: "unexpected AS",
+        valid: false,
+        type: "message",
+        input: {
+            actor: "irc://uuu@localhost",
+            type: "join",
+            context: "fakeplatform",
+            target: "irc://irc.dooder.net/a-room",
+        },
+        error: "Error: [fakeplatform] /actor: must be object",
+    },
+    {
+        name: "missing type property",
+        valid: false,
+        type: "message",
+        input: {
+            actor: { id: "irc://uuu@localhost", type: "person" },
+            context: "fakeplatform",
+            target: { id: "irc://irc.dooder.net/a-room", type: "room" },
+        },
+        error: "Error: [fakeplatform] activity stream: must have required property 'type'",
+    },
+    {
+        name: "invalid context property",
+        valid: false,
+        type: "message",
+        input: {
+            actor: { id: "irc://uuu@localhost", type: "person" },
+            type: "foo",
+            context: "foobar111",
+            target: { id: "irc://irc.dooder.net/a-room", type: "room" },
+        },
+        error: "Error: platform context foobar111 not registered with this Sockethub instance.",
+    },
+    {
+        name: "missing actor property",
+        valid: false,
+        type: "message",
+        input: {
+            type: "foo",
+            context: "fakeplatform",
+            target: { id: "irc://irc.dooder.net/a-room", type: "room" },
+        },
+        error: "Error: [fakeplatform] activity stream: must have required property 'actor'",
+    },
+    {
+        name: "traditional message",
+        valid: true,
+        type: "message",
+        input: {
+            type: "echo",
+            context: "fakeplatform",
+            actor: { id: "irc://uuu@localhost", type: "person" },
+        },
+    },
+    {
+        name: "message with wrong type",
+        valid: false,
+        type: "message",
+        input: {
+            type: "foorg",
+            context: "fakeplatform",
+            actor: { id: "irc://uuu@localhost", type: "person" },
+        },
+        error:
+            "Error: platform type foorg not supported by fakeplatform platform. " +
+            "(types: credentials, echo, fail)",
+    },
+];

package/src/middleware/validate.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "bun:test";
+import type { ActivityStream } from "@sockethub/schemas";
+import getInitObject from "../bootstrap/init.js";
+import { initMockFakePlatform } from "../bootstrap/init.test.js";
+import validate from "./validate.js";
+import asObjects from "./validate.test.data.js";
+
+describe("Middleware: Validate", async () => {
+    const loadInitMock = await initMockFakePlatform("fakeplatform");
+    const initObj = await getInitObject(loadInitMock);
+
+    describe("AS object validations", () => {
+        asObjects.forEach((obj) => {
+            it(`${obj.type}: ${obj.name}, should ${
+                obj.valid ? "pass" : "fail"
+            }`, (done) => {
+                validate(
+                    obj.type,
+                    "tests",
+                    initObj,
+                )(obj.input as ActivityStream, (msg) => {
+                    if (obj.output) {
+                        if (obj.output === "same") {
+                            // @ts-ignore
+                            expect(msg).toEqual(obj.input);
+                        } else {
+                            // @ts-ignore
+                            expect(msg).toEqual(obj.output);
+                        }
+                    }
+                    if (obj.valid) {
+                        expect(msg).not.toBeInstanceOf(Error);
+                    } else {
+                        expect(msg).toBeInstanceOf(Error);
+                        if (obj.error) {
+                            expect(msg.toString()).toEqual(obj.error);
+                        }
+                    }
+                    done();
+                });
+            });
+        });
+    });
+});

package/src/middleware/validate.ts

@@ -0,0 +1,73 @@
+/**
+ * responsible for handling the validation and expansion (when applicable) of all incoming objects
+ */
+import debug from "debug";
+
+import {
+    type ActivityStream,
+    type MiddlewareCallback,
+    validateActivityObject,
+    validateActivityStream,
+    validateCredentials,
+} from "@sockethub/schemas";
+
+import getInitObject, { type IInitObject } from "../bootstrap/init.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(
+    type: string,
+    sockethubId: string,
+    passedInitObj?: IInitObject,
+) {
+    let initObj = passedInitObj;
+    if (!passedInitObj) {
+        getInitObject().then((init) => {
+            initObj = init;
+        });
+    }
+
+    const sessionLog = debug(`sockethub:server:validate:${sockethubId}`);
+    return (msg: ActivityStream, done: MiddlewareCallback) => {
+        sessionLog(`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);
+            if (err) {
+                done(new Error(err));
+            } else {
+                done(msg);
+            }
+        } else {
+            const err = validateActivityStream(msg);
+            if (err) {
+                done(new Error(err));
+            } 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(
+                                    ", ",
+                                )})`,
+                        ),
+                    );
+                }
+                done(msg);
+            }
+        }
+    };
+}

package/src/middleware.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
+
+import middleware, { MiddlewareChain } from "./middleware.js";
+
+describe("Middleware", () => {
+    it("middleware() is a function", () => {
+        expect(typeof middleware).toEqual("function");
+    });
+
+    it("returns a MiddlewareChain instance", () => {
+        const mw = middleware("testa");
+        expect(mw).toBeInstanceOf(MiddlewareChain);
+        const mwc = new MiddlewareChain("testa");
+        expect(mw.name).toEqual(mwc.name);
+    });
+
+    it("only accepts functions", () => {
+        const mw = middleware("test");
+        expect(() => {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            mw.use("foobar343");
+        }).toThrow("middleware use() can only take a function as an argument");
+    });
+
+    it("only accepts functions that expect 2 or 3 params", () => {
+        const mw = middleware("test");
+        expect(() => {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            mw.use((one, two, three, four) => {});
+        }).toThrow(
+            "middleware function provided with incorrect number of params: 4",
+        );
+    });
+
+    it("calls each member of call list", (done) => {
+        const callback = (data: any, cb: (v: any) => void) => {
+            cb(data);
+        };
+        const funcs = [
+            sinon.spy(callback),
+            sinon.spy(callback),
+            sinon.spy(callback),
+        ];
+        const mw = middleware("test");
+        for (const func of funcs) {
+            mw.use(func);
+        }
+        mw.done()("some data", (data: any) => {
+            expect(data).toEqual("some data");
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            funcs.unshift(callback);
+            for (let i = 1; i < funcs.length; i++) {
+                expect(funcs[i].calledOnce).toBeTrue();
+                expect(funcs[i].calledWith("foobar981", funcs[i - 1]));
+            }
+            done();
+        });
+    });
+
+    it("does not throw exception on error with no callback provided", (done) => {
+        let errorHandlerCalled = false;
+        const callbackError = (data: any, cb: (arg0: Error) => void) => {
+            cb(new Error("some error"));
+        };
+        const funcs = [sinon.spy(callbackError)];
+        const mw = middleware("test");
+        for (const func of funcs) {
+            mw.use(func);
+        }
+        mw.use((err: any, data: any, next: (v: string) => void) => {
+            expect(err.toString()).toEqual("Error: some error");
+            errorHandlerCalled = true;
+            next(err);
+        });
+        mw.done()("foobar0121", () => {
+            expect(errorHandlerCalled).toBeTrue();
+            done();
+        });
+    });
+
+    it("aborts call stack on error - calls error handler, and callback", (done) => {
+        let errorHandlerCalled = false;
+        const callback = (data: any, cb: (v: any) => void) => {
+            cb(data);
+        };
+        const callbackError = (data: any, cb: (arg0: Error) => void) => {
+            cb(new Error("some error"));
+        };
+        const funcs = [
+            sinon.spy(callback),
+            sinon.spy(callbackError),
+            sinon.spy(callback),
+        ];
+        const mw = middleware("test");
+        for (const func of funcs) {
+            mw.use(func);
+        }
+        mw.use((err: any, data: any, next: (v: any) => void) => {
+            expect(err.toString()).toEqual("Error: some error");
+            errorHandlerCalled = true;
+            next(err);
+        });
+        mw.done()("foobar637", (data: any) => {
+            // FIXME -- We need to also handle socket.io callbacks!
+            expect(data instanceof Error).toBeTrue();
+            expect(funcs[0].calledOnce).toBeTrue();
+            expect(funcs[0].calledWith("foobar637", callback));
+            expect(funcs[1].calledOnce).toBeTrue();
+            expect(funcs[1].calledWith("foobar637", funcs[0]));
+            expect(funcs[2].calledOnce).toBeFalse();
+            expect(errorHandlerCalled).toBeTrue();
+            done();
+        });
+    });
+
+    it("error handler receives error and no callback provided", (done) => {
+        let errorHandlerCalled = false;
+        const callback = (data: any, cb: (v: any) => void) => {
+            cb(data);
+        };
+        const callbackError = (data: any, cb: (arg0: Error) => void) => {
+            cb(new Error("some error"));
+        };
+        const funcs = [
+            sinon.spy(callback),
+            sinon.spy(callback),
+            sinon.spy(callbackError),
+        ];
+        const mw = middleware("test");
+        for (const func of funcs) {
+            mw.use(func);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        mw.use((err: any, data: any, next: (v: any) => void) => {
+            expect(err instanceof Error).toBeTrue();
+            expect(err.toString()).toEqual("Error: some error");
+            errorHandlerCalled = true;
+            expect(funcs[0].calledOnce).toBeTrue();
+            expect(funcs[0].calledWith("foobar98", callback));
+            expect(funcs[1].calledOnce).toBeTrue();
+            expect(funcs[1].calledWith("foobar98", funcs[0]));
+            expect(funcs[2].calledOnce).toBeTrue();
+            expect(funcs[2].calledWith("foobar98", funcs[1]));
+            expect(errorHandlerCalled).toBeTrue();
+            setTimeout(done, 0);
+        });
+        mw.done()("foobar98", () => {});
+    });
+
+    it("calls each member of chain (50)", (done) => {
+        let errorHandlerCalled = false;
+        const callback = (data: any, cb: (v: any) => void) => {
+            cb(data);
+        };
+        const funcs: Array<any> = [];
+        for (let i = 0; i <= 50; i++) {
+            funcs.push(sinon.spy(callback));
+        }
+        const mw = middleware("test");
+        for (const func of funcs) {
+            mw.use(func);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        mw.use((err: any, data: any, next: (v: any) => void) => {
+            expect(err.toString()).toEqual("Error: some error");
+            errorHandlerCalled = true;
+        });
+        mw.done()("some data", (data: any) => {
+            expect(data).toEqual("some data");
+            funcs.unshift(callback);
+            for (let i = 1; i < funcs.length; i++) {
+                expect(funcs[i].calledOnce).toBeTrue();
+                expect(funcs[i].calledWith("foo", funcs[i - 1]));
+            }
+            expect(errorHandlerCalled).toBeFalse();
+            done();
+        });
+    });
+});

package/src/middleware.ts

@@ -0,0 +1,71 @@
+import type { ActivityObject, ActivityStream } from "@sockethub/schemas";
+import debug, { type Debugger } from "debug";
+
+export default function middleware(name: string): MiddlewareChain {
+    return new MiddlewareChain(name);
+}
+
+export type MiddlewareChainInterface = (
+    error: ActivityStream | ActivityObject | Error,
+    data?: ActivityStream | ActivityObject | MiddlewareChainInterface,
+    next?: MiddlewareChainInterface,
+) => void;
+
+type ErrorHandlerInterface = (err: Error, data?: unknown, cb?: unknown) => void;
+
+export type LogErrorInterface = (msg: Error) => void;
+
+export class MiddlewareChain {
+    public name: string;
+    private chain: Array<MiddlewareChainInterface> = [];
+    private errHandler: ErrorHandlerInterface = (err: Error) => {
+        throw err;
+    };
+    private readonly logger: Debugger;
+
+    constructor(name: string) {
+        this.name = name;
+        this.logger = debug(`sockethub:middleware:${name}`);
+    }
+
+    use(func: ErrorHandlerInterface | MiddlewareChainInterface): 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;
+        } else if (func.length === 2) {
+            this.chain.push(func as MiddlewareChainInterface);
+        } else {
+            throw new Error(
+                `middleware function provided with incorrect number of params: ${func.length}`,
+            );
+        }
+        return this;
+    }
+
+    done() {
+        return (data: unknown, callbackFunc: MiddlewareChainInterface) => {
+            let cb = callbackFunc;
+            let position = 0;
+            if (typeof callbackFunc !== "function") {
+                cb = () => {
+                    // ensure we have a callback function
+                };
+            }
+            const next = (_data: unknown) => {
+                if (_data instanceof Error) {
+                    this.logger(_data.toString());
+                    this.errHandler(_data, data, cb);
+                } else if (typeof this.chain[position] === "function") {
+                    this.chain[position++](_data as ActivityStream, next);
+                } else {
+                    cb(_data as ActivityStream);
+                }
+            };
+            next(data);
+        };
+    }
+}