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

package/src/middleware/expand-activity-stream.test.ts

@@ -1,78 +1,77 @@
-import { expect } from 'chai';
+import { describe, expect, it } from "bun:test";
 
-import expandActivityStream from "./expand-activity-stream";
+import expandActivityStream from "./expand-activity-stream.js";
 
-import asObjects from "./expand-activity-stream.test.data";
-import ActivityStreams from '@sockethub/activity-streams';
+import { ASFactory } from "@sockethub/activity-streams";
+import asObjects from "./expand-activity-stream.test.data.js";
+import { ActivityStream } from "@sockethub/schemas";
+
+const activity = ASFactory();
 
-const activity = ActivityStreams();
 // register known activity objects
 [
-  {
-    "id":"blah",
-    "type":"person",
-    "name":"dood"
-  },
-  {
-    "id":"blah2",
-    "type":"person",
-    "name":"bob",
-    "hello":"there",
-    "i":[
-      "am",
-      "extras"
-    ]
-  },
-  {
-    "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
+    {
+        id: "blah",
+        type: "person",
+        name: "dood",
+    },
+    {
+        id: "blah2",
+        type: "person",
+        name: "bob",
+        hello: "there",
+        i: ["am", "extras"],
+    },
+    {
+        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",
+    },
+    {
+        id: "blah3",
+        type: "person",
+        name: "bob",
+        hello: "there",
+        i: ["am", "extras"],
     },
-    "url":"https://sockethub.org"
-  },
-  {
-    "id":"blah3",
-    "type":"person",
-    "name":"bob",
-    "hello":"there",
-    "i":[
-      "am",
-      "extras"
-    ]
-  }
 ].forEach((obj) => {
-  activity.Object.create(obj);
+    activity.Object.create(obj);
 });
 
-describe('Middleware: Expand Activity Stream', () => {
-  describe('AS object expansion', () => {
-    asObjects.forEach((obj) => {
-      it(`${obj.type}: ${obj.name}, should ${obj.valid ? 'pass' : 'fail'}`, (done) => {
-        // @ts-ignore
-        expandActivityStream(obj.input, (msg) => {
-          if (obj.output) {
-            if (obj.output === 'same') {
-              expect(obj.input).to.eql(msg);
-            } else {
-              expect(obj.output).to.eql(msg);
-            }
-          }
-          if (obj.valid) {
-            expect(msg instanceof Error).to.be.false;
-          } else {
-            expect(msg instanceof Error).to.be.true;
-            if (obj.error) {
-              expect(obj.error).to.equal(msg.toString());
-            }
-          }
-          done();
+describe("Middleware: Expand Activity Stream", () => {
+    describe("AS object expansion", () => {
+        asObjects.forEach((obj) => {
+            it(`${obj.type}: ${obj.name}, should ${
+                obj.valid ? "pass" : "fail"
+            }`, (done) => {
+                expandActivityStream(obj.input as ActivityStream, (msg) => {
+                    if (obj.output) {
+                        if (obj.output === "same") {
+                            // @ts-ignore
+                            expect(obj.input).toEqual(msg);
+                        } else {
+                            // @ts-ignore
+                            expect(obj.output).toEqual(msg);
+                        }
+                    }
+                    if (obj.valid) {
+                        expect(msg instanceof Error).toBeFalse();
+                    } else {
+                        expect(msg instanceof Error).toBeTrue();
+                        if (obj.error) {
+                            expect(obj.error).toEqual(msg.toString());
+                        }
+                    }
+                    done();
+                });
+            });
         });
-      });
     });
-  });
 });

package/src/middleware/expand-activity-stream.ts

@@ -1,32 +1,37 @@
-import ActivityStreams from '@sockethub/activity-streams';
-import {IActivityStream} from "@sockethub/schemas";
+import { ASFactory, type ASFactoryOptions } from "@sockethub/activity-streams";
+import type { ActivityStream } from "@sockethub/schemas";
 
-import config, {ActivityStreamConfigOptions} from "../config";
-import {MiddlewareChainInterface} from "../middleware";
+import config from "../config.js";
+import type { MiddlewareChainInterface } from "../middleware.js";
 
-const asConfig = config.get('activity-streams:opts') as ActivityStreamConfigOptions;
+const asConfig = config.get(
+    "packageConfig:@sockethub/activity-streams",
+) as ASFactoryOptions;
 asConfig.warnOnUnknownObjectProperties = false;
 asConfig.failOnUnknownObjectProperties = false;
-const activity = ActivityStreams(asConfig);
+
+const activity = ASFactory(asConfig);
 
 function ensureObject(msg: unknown) {
-  return !((typeof msg !== 'object') || (Array.isArray(msg)));
+    return !(typeof msg !== "object" || Array.isArray(msg));
 }
 
-export default function expandActivityStream(msg: IActivityStream,
-                                             done: MiddlewareChainInterface) {
-  if (! ensureObject(msg)) {
-    done(new Error(`message received is not an object.`));
-  } else if (typeof msg.context !== 'string') {
-    done(new Error('activity stream must contain a context property'));
-  } else if (typeof msg.type !== 'string') {
-    done(new Error('activity stream must contain a type property.'));
-  } else {
-    msg = activity.Stream(msg);
-    if (!msg.actor) {
-      done(new Error('activity stream must contain an actor property.'));
+export default function expandActivityStream(
+    msg: ActivityStream,
+    done: MiddlewareChainInterface,
+) {
+    if (!ensureObject(msg)) {
+        done(new Error("message received is not an object."));
+    } else if (typeof msg.context !== "string") {
+        done(new Error("activity stream must contain a context property"));
+    } else if (typeof msg.type !== "string") {
+        done(new Error("activity stream must contain a type property."));
     } else {
-      done(msg);
+        const msgStream = activity.Stream(msg) as ActivityStream;
+        if (!msgStream.actor) {
+            done(new Error("activity stream must contain an actor property."));
+        } else {
+            done(msgStream);
+        }
     }
-  }
 }

package/src/middleware/store-credentials.test.ts

@@ -1,71 +1,85 @@
-import { expect } from 'chai';
-import * as sinon from 'sinon';
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
 
-import storeCredentials from "./store-credentials";
+import type { CredentialsObject } from "@sockethub/schemas";
+import storeCredentials from "./store-credentials.js";
 
-const creds = {
-  "id":"blah",
-  "type":"credentials",
-  "context":"dummy",
-  "actor":{
-    "id":"dood@irc.freenode.net",
-    "type":"person",
-    "name":"dood"
-  },
-  "target":{
-    "id":"irc.freenode.net/service",
-    "type":"person",
-    "name":"service"
-  },
-  "object":{
-    "type":"credentials"
-  }
+const creds: CredentialsObject = {
+    type: "credentials",
+    context: "dummy",
+    actor: {
+        id: "dood@irc.freenode.net",
+        type: "person",
+        name: "dood",
+    },
+    target: {
+        id: "irc.freenode.net/service",
+        type: "person",
+        name: "service",
+    },
+    object: {
+        type: "credentials",
+    },
 };
 
-describe('Middleware: storeCredentials', () => {
-  let storeSuccess: any, storeError: any, saveErrorFake: any,
-      saveSuccessFake: any;
+describe("Middleware: storeCredentials", () => {
+    let storeSuccess: any,
+        storeError: any,
+        saveErrorFake: any,
+        saveSuccessFake: any;
 
-  beforeEach(() => {
-    storeSuccess = {
-      save: (id: any, creds: any, cb: Function) => {
-        cb();
-      }
-    };
-    storeError = {
-      save: (id: any, creds: any, cb: Function) => {
-        cb('some error');
-      }
-    };
-    saveSuccessFake = sinon.replace(storeSuccess, 'save', sinon.fake(storeSuccess.save));
-    saveErrorFake = sinon.replace(storeError, 'save', sinon.fake(storeError.save));
-  });
+    beforeEach(() => {
+        storeSuccess = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            save: async (id: any, creds: any) => {
+                return Promise.resolve();
+            },
+        };
+        storeError = {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            save: (id: any, creds: any): Promise<void> => {
+                throw new Error("some error");
+            },
+        };
+        saveSuccessFake = sinon.replace(
+            storeSuccess,
+            "save",
+            sinon.fake(storeSuccess.save),
+        );
+        saveErrorFake = sinon.replace(
+            storeError,
+            "save",
+            sinon.fake(storeError.save),
+        );
+    });
 
-  afterEach(() => {
-    sinon.reset();
-  });
+    afterEach(() => {
+        sinon.reset();
+    });
 
-  it('returns a middleware handler', () => {
-    const sc = storeCredentials(storeSuccess);
-    expect(typeof sc).to.equal('function');
-    expect(saveSuccessFake.callCount).to.equal(0);
-  });
+    it("returns a middleware handler", () => {
+        const sc = storeCredentials(storeSuccess);
+        expect(typeof sc).toEqual("function");
+        expect(saveSuccessFake.callCount).toEqual(0);
+    });
 
-  it('successfully store credentials', () => {
-    const sc = storeCredentials(storeSuccess);
-    sc(creds, (err: any) => {
-      expect(saveSuccessFake.callCount).to.equal(1);
-      expect(saveSuccessFake.firstArg).to.equal(creds.actor.id);
-      expect(err).to.be.undefined;
+    it("successfully stores credentials", (done) => {
+        const sc = storeCredentials(storeSuccess);
+        sc(creds as CredentialsObject, (err: any) => {
+            expect(saveSuccessFake.callCount).toEqual(1);
+            expect(saveSuccessFake.firstArg).toEqual(creds.actor.id);
+            expect(err).toEqual(creds);
+            done();
+        });
     });
-  });
 
-  it('handle error while storing credentials', () => {
-    const sc = storeCredentials(storeError);
-    sc(creds, (err: any) => {
-      expect(saveErrorFake.callCount).to.equal(1);
-      expect(saveErrorFake.firstArg).to.equal(creds.actor.id);
-      expect(err).to.eql('some error');
+    it("handle error while storing credentials", (done) => {
+        const sc = storeCredentials(storeError);
+        sc(creds as CredentialsObject, (err: any) => {
+            expect(saveErrorFake.callCount).toEqual(1);
+            expect(saveErrorFake.firstArg).toEqual(creds.actor.id);
+            expect(err.toString()).toEqual("Error: some error");
+            done();
+        });
     });
-  });
-});
+});

package/src/middleware/store-credentials.ts

@@ -1,10 +1,16 @@
-import {IActivityStream, CallbackInterface} from "@sockethub/schemas";
-import { CredentialsStore } from "@sockethub/data-layer";
+import type { CredentialsStoreInterface } from "@sockethub/data-layer";
+import type { CredentialsObject } from "@sockethub/schemas";
 
-export default function storeCredentials(
-  credentialsStore: CredentialsStore
-) {
-  return (creds: IActivityStream, done: CallbackInterface) => {
-    credentialsStore.save(creds.actor.id, creds, done);
-  };
+import type { MiddlewareChainInterface } from "../middleware.js";
+
+export default function storeCredentials(store: CredentialsStoreInterface) {
+    return (creds: CredentialsObject, done: MiddlewareChainInterface) => {
+        try {
+            store.save(creds.actor.id, creds).then(() => {
+                done(creds);
+            });
+        } catch (err) {
+            done(err);
+        }
+    };
 }