@sockethub/server 5.0.0-alpha.4 → 5.0.0-alpha.6

package/src/middleware/validate.ts

@@ -1,47 +1,73 @@
 /**
  * responsible for handling the validation and expansion (when applicable) of all incoming objects
  */
-import debug from 'debug';
-import schemas, {IActivityStream, CallbackActivityStreamInterface} from '@sockethub/schemas';
+import debug from "debug";
 
-import init from "../bootstrap/init";
+import {
+    type ActivityStream,
+    type MiddlewareCallback,
+    validateActivityObject,
+    validateActivityStream,
+    validateCredentials,
+} from "@sockethub/schemas";
 
-init.platforms.forEach((platform) => {
-  Object.keys(platform.schemas).forEach((key) => {
-    if (! platform.schemas[key]) { return; }
-    schemas.addPlatformSchema(platform.schemas[key], `${platform.id}/${key}`);
-  });
-});
+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) {
-  const sessionLog = debug(`sockethub:server:validate:${sockethubId}`);
-  return (msg: IActivityStream, done: CallbackActivityStreamInterface) => {
-    sessionLog('applying schema validation for ' + type);
-    if (type === 'activity-object') {
-      const err = schemas.validateActivityObject(msg);
-      err ? done(new Error(err)) : done(msg);
-    } else if (! init.platforms.has(msg.context)) {
-      return done(
-        new Error(`platform context ${msg.context} not registered with this Sockethub instance.`)
-      );
-    } else if (type === 'credentials') {
-      const err = schemas.validateCredentials(msg);
-      err ? done(new Error(err)) : done(msg);
-    } else {
-      const err = schemas.validateActivityStream(msg);
-      if (err) {
-        done(new Error(err));
-      } else {
-        const platformMeta = init.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(', ')})`));
+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 {
-          done(msg);
+            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

@@ -1,154 +1,184 @@
-import { expect } from 'chai';
-import * as sinon from 'sinon';
+import { describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
 
-import middleware, { MiddlewareChain } from "./middleware";
+import middleware, { MiddlewareChain } from "./middleware.js";
 
 describe("Middleware", () => {
-  it("middleware() is a function", () => {
-    expect(typeof middleware).to.be.equal('function');
-  });
-
-  it('returns a MiddlewareChain instance', () => {
-    const mw = middleware('testa');
-    expect(mw).to.be.instanceof(MiddlewareChain);
-    const mwc = new MiddlewareChain('testa');
-    expect(mw.name).to.be.eql(mwc.name);
-  });
-
-  it("only accepts functions", () => {
-    const mw = middleware('test');
-    // @ts-ignore
-    expect(()=>{mw.use('foobar');}).to.throw(
-      'middleware use() can only take a function as an argument');
-  });
-
-  it("only accepts functions that expect 2 or 3 params", () => {
-    const mw = middleware('test');
-    // @ts-ignore
-    expect(()=>{mw.use((one, two, three, four) => {});}).to.throw(
-      'middleware function provided with incorrect number of params: 4');
-  });
+    it("middleware() is a function", () => {
+        expect(typeof middleware).toEqual("function");
+    });
 
-  it("calls each member of call list", (done) => {
-    const callback = (data: any, cb: Function) => { cb(data); };
-    const funcs = [ sinon.spy(callback), sinon.spy(callback), sinon.spy(callback) ];
-    const mw = middleware('test');
-    for (let func of funcs) {
-      // @ts-ignore
-      const entry = mw.use(func);
-    }
-    mw.done()('some data', (data: any) => {
-      expect(data).to.eql('some data');
-      // @ts-ignore
-      funcs.unshift(callback);
-      for (let i = 1; i < funcs.length; i++) {
-        expect(funcs[i].calledOnce).to.be.true;
-        expect(funcs[i].calledWith('foobar', funcs[i - 1]));
-      }
-      done();
+    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("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 (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err: any, data: any, next: Function) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      next(err);
+    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");
     });
-    mw.done()('foobar', () => {
-      expect(errorHandlerCalled).to.be.true;
-      done();
+
+    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("aborts call stack on error - calls error handler, and callback", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data: any, cb: Function) => { 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 (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err: any, data: any, next: Function) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      next(err);
+    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();
+        });
     });
-    mw.done()('foobar', (data: any) => {
-      // FIXME -- We need to also handle socket.io callbacks!
-      expect(data instanceof Error).to.be.true;
-      expect(funcs[0].calledOnce).to.be.true;
-      expect(funcs[0].calledWith('foobar', callback));
-      expect(funcs[1].calledOnce).to.be.true;
-      expect(funcs[1].calledWith('foobar', funcs[0]));
-      expect(funcs[2].calledOnce).to.be.false;
-      expect(errorHandlerCalled).to.be.true;
-      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("error handler receives error and no callback provided", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data: any, cb: Function) => { 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 (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err: any, data: any, next: Function) => {
-      expect(err instanceof Error).to.be.true;
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
-      expect(funcs[0].calledOnce).to.be.true;
-      expect(funcs[0].calledWith('foobar', callback));
-      expect(funcs[1].calledOnce).to.be.true;
-      expect(funcs[1].calledWith('foobar', funcs[0]));
-      expect(funcs[2].calledOnce).to.be.true;
-      expect(funcs[2].calledWith('foobar', funcs[1]));
-      expect(errorHandlerCalled).to.be.true;
-      setTimeout(done, 0);
+    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();
+        });
     });
-    mw.done()('foobar', () => {});
-  });
 
-  it("calls each member of chain (50)", (done) => {
-    let errorHandlerCalled = false;
-    const callback = (data: any, cb: Function) => { cb(data); };
-    let funcs: Array<any> = [];
-    for (let i = 0; i <= 50; i++) {
-      funcs.push(sinon.spy(callback));
-    }
-    const mw = middleware('test');
-    for (let func of funcs) {
-      mw.use(func);
-    }
-    mw.use((err: any, data: any, next: Function) => {
-      expect(err.toString()).to.equal('Error: some error');
-      errorHandlerCalled = true;
+    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", () => {});
     });
-    mw.done()('some data', (data: any) => {
-      expect(data).to.equal('some data');
-      funcs.unshift(callback);
-      for (let i = 1; i < funcs.length; i++) {
-        expect(funcs[i].calledOnce).to.be.true;
-        expect(funcs[i].calledWith('foo', funcs[i - 1]));
-      }
-      expect(errorHandlerCalled).to.be.false;
-      done();
+
+    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

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