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

package/src/routes.test.ts

@@ -1,100 +1,54 @@
-import { expect } from 'chai';
-import * as sinon from 'sinon';
+import { afterEach, describe, expect, it } from "bun:test";
 import { existsSync } from "fs";
+import * as sinon from "sinon";
 
-import routes, { basePaths, examplePaths, examplePages, IRoutePaths } from "./routes";
+import routes, { basePaths, type IRoutePaths } from "./routes.js";
 
-describe('routes/base', () => {
-
-  afterEach(() => {
-    sinon.restore();
-  });
-
-  it('can find each of the base files it serves', () => {
-    Object.values(basePaths).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
+describe("routes/base", () => {
+    afterEach(() => {
+        sinon.restore();
     });
-  });
 
-  it('can find each of the example files it serves', () => {
-    Object.values(examplePaths).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
+    it("can find each of the base files it serves", () => {
+        Object.values(basePaths).forEach((fwd: string) => {
+            try {
+                // eslint-disable-next-line security/detect-non-literal-fs-filename
+                expect(existsSync(fwd)).toBeTrue();
+            } catch (e) {
+                throw new Error(`Unable to resolve path ${fwd}`);
+            }
+        });
     });
-  });
 
-  it('can find each of the example page files it serves', () => {
-    Object.values(examplePages).forEach((fwd: string) => {
-      try {
-        expect(existsSync(fwd)).to.be.true;
-      } catch (e) {
-        throw new Error(`Unable to resolve path ${fwd}`);
-      }
+    it("adds base routes", () => {
+        const app = {
+            get: sinon.spy(),
+        };
+        routes.setup(app);
+        sinon.assert.callCount(app.get, Object.keys(basePaths).length);
     });
-  });
-
-  it('adds base routes', () => {
-    const app = {
-      get: sinon.spy()
-    };
-    routes.setup(app, false);
-    sinon.assert.callCount(
-      app.get,
-      Object.keys(basePaths).length
-    );
-  });
 
-  it('adds base and example routes', () => {
-    const app = {
-      get: sinon.spy()
-    };
-    routes.setup(app, true);
-    sinon.assert.callCount(
-      app.get,
-      Object.keys(basePaths).length
-      + Object.keys(examplePaths).length
-      + Object.keys(examplePages).length
-    );
-  });
-
-  it('handles calls to base routes as expected', () => {
-    let routeHandlers: any = {};
-    let app = {
-      get: (path: string | number, route: any) => {
-        routeHandlers[path] = route;
-      }
-    };
-    routes.setup(app, true);
-
-    function verifyPathRoutes(pathMap: IRoutePaths) {
-      Object.keys(pathMap).forEach((path) => {
-        const res = {
-          setHeader: sinon.spy(),
-          sendFile: sinon.spy()
+    it("handles calls to base routes as expected", () => {
+        const routeHandlers: any = {};
+        const app = {
+            get: (path: string | number, route: any) => {
+                routeHandlers[path] = route;
+            },
         };
-        expect(pathMap[path].endsWith('.ejs')).to.be.false;
-        routeHandlers[path]({url: path}, res);
-        sinon.assert.called(res.setHeader);
-        sinon.assert.calledWith(res.sendFile, pathMap[path]);
-      });
-    }
-    verifyPathRoutes(basePaths);
-    verifyPathRoutes(examplePaths);
-
-    Object.keys(examplePages).forEach((path) => {
-      const res = {
-        render: sinon.spy()
-      };
-      expect(examplePages[path].endsWith('.ejs')).to.be.true;
-      routeHandlers[path]({url: path}, res);
-      sinon.assert.called(res.render);
+        routes.setup(app);
+
+        function verifyPathRoutes(pathMap: IRoutePaths) {
+            Object.keys(pathMap).forEach((path) => {
+                const res = {
+                    setHeader: sinon.spy(),
+                    sendFile: sinon.spy(),
+                };
+                expect(pathMap[path].endsWith(".ejs")).toBeFalse();
+                routeHandlers[path]({ url: path }, res);
+                sinon.assert.called(res.setHeader);
+                sinon.assert.calledWith(res.sendFile, pathMap[path]);
+            });
+        }
+        verifyPathRoutes(basePaths);
     });
-  });
-});
+});

package/src/routes.ts

@@ -1,99 +1,61 @@
-import path from 'path';
-import config from "./config";
-import debug from 'debug';
+import path from "node:path";
+import debug from "debug";
 
-const debug_scope = process.env.DEBUG || '',
-      logger      = debug('sockethub:server:routes'),
-      address     = config.get('public:protocol') + '://' +
-                    config.get('public:host') + ':' +
-                    config.get('public:port') +
-                    config.get('public:path');
+import { __dirname } from "./util.js";
+
+const logger = debug("sockethub:server:routes");
 
 export interface IRoutePaths {
-  [key: string]: string;
+    [key: string]: string;
 }
 
 export const basePaths: IRoutePaths = {
-  '/sockethub-client.js':
-    path.resolve(`${__dirname}/../node_modules/@sockethub/client/dist/sockethub-client.js`),
-  '/sockethub-client.min.js':
-    path.resolve(`${__dirname}/../node_modules/@sockethub/client/dist/sockethub-client.min.js`),
-  '/sockethub-client.js.map':
-    path.resolve(`${__dirname}/../node_modules/@sockethub/client/dist/sockethub-client.js.map`),
-  '/socket.io.js': path.resolve(`${__dirname}/../node_modules/socket.io/client-dist/socket.io.js`)
-};
-
-export const examplePaths: IRoutePaths = {
-  '/jquery.js': path.resolve(`${__dirname}/../node_modules/jquery/dist/jquery.min.js`),
-  '/jquery.min.map': path.resolve(`${__dirname}/../node_modules/jquery/dist/jquery.min.map`),
-  '/examples/shared.js': path.resolve(`${__dirname}/../views/examples/shared.js`)
+    "/sockethub-client.js": path.resolve(
+        __dirname,
+        "..",
+        "res",
+        "sockethub-client.js",
+    ),
+    "/sockethub-client.min.js": path.resolve(
+        __dirname,
+        "..",
+        "res",
+        "sockethub-client.min.js",
+    ),
+    "/socket.io.js": path.resolve(__dirname, "..", "res", "socket.io.js"),
 };
 
-export const examplePages: IRoutePaths = {
-  '/': path.resolve(`${__dirname}/../views/index.ejs`),
-  '/examples/dummy': path.resolve(`${__dirname}/../views/examples/dummy.ejs`),
-  '/examples/feeds': path.resolve(`${__dirname}/../views/examples/feeds.ejs`),
-  '/examples/irc': path.resolve(`${__dirname}/../views/examples/irc.ejs`),
-  '/examples/xmpp': path.resolve(`${__dirname}/../views/examples/xmpp.ejs`)
-};
-
-
 function prepFileRoutes(pathMap) {
-  const _routes = [];
-  Object.keys(pathMap).forEach((key) => {
-    _routes.push({
-      meta: {
-        method: 'GET',
-        path: key
-      },
-      route: (req, res) => {
-        logger(`serving resource ${req.url}`);
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.sendFile(pathMap[req.url]);
-      }
-    });
-  });
-  return _routes;
+    const _routes = [];
+    for (const key of Object.keys(pathMap)) {
+        _routes.push({
+            meta: {
+                method: "GET",
+                path: key,
+            },
+            route: (req, res) => {
+                logger(`serving resource ${req.url}`);
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.sendFile(pathMap[req.url]);
+            },
+        });
+    }
+    return _routes;
 }
 const baseRoutes = prepFileRoutes(basePaths);
-const exampleRoutes = prepFileRoutes(examplePaths);
-
-
-Object.keys(examplePages).forEach((key) => {
-  exampleRoutes.push({
-    meta: {
-      method: 'GET',
-      path: key
-    },
-    route: (req, res) => {
-      logger(`serving page ${req.url}`);
-      res.render(examplePages[req.url], {
-        debug_scope: debug_scope,
-        address: address,
-      });
-    }
-  });
-});
 
 function addRoute(app) {
-  return (route) => {
-    app[route.meta.method.toLowerCase()](
-      route.meta.path,
-      route.route
-    );
-  };
+    return (route) => {
+        app[route.meta.method.toLowerCase()](route.meta.path, route.route);
+    };
 }
 
 /**
  * Setup
  */
 const routes = {
-  setup: function (app: unknown,
-                   examplesEnabled: boolean = config.get('examples:enabled') as boolean) {
-    baseRoutes.forEach(addRoute(app));
-    if (examplesEnabled) {
-      exampleRoutes.forEach(addRoute(app));
-    }
-  }
+    setup: (app: unknown) => {
+        baseRoutes.forEach(addRoute(app));
+    },
 };
 export default routes;

package/src/sentry.test.ts

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+import { join } from "path";
+
+// Mock config to avoid loading real configuration
+const mockConfig = {
+    get: mock((key: string) => {
+        if (key === "sentry:dsn") {
+            return "https://ffc702eb2f3b24d9e06ca20e1ef1fd09@o4508859714895872.ingest.de.sentry.io/4508859718369360";
+        }
+        if (key === "sentry") {
+            return {
+                dsn: "https://ffc702eb2f3b24d9e06ca20e1ef1fd09@o4508859714895872.ingest.de.sentry.io/4508859718369360",
+                environment: "test",
+                traceSampleRate: 1.0
+            };
+        }
+        return null;
+    })
+};
+
+describe("Sentry Integration Bug - Issue #918", () => {
+    beforeEach(() => {
+        // Clear any existing Sentry instances
+        delete require.cache[require.resolve("./sentry.js")];
+        mockConfig.get.mockClear();
+    });
+
+    it("should reproduce 'A Proxy's target should be an Object' error", async () => {
+        // This test reproduces the bug by initializing Sentry with Bun server instrumentation
+        // The error occurs when Sentry's Bun integration tries to instrument server options
+        let sentryError: Error | null = null;
+
+        try {
+            // Create a proper mock that implements the config interface
+            const configPath = require.resolve("./config.js");
+            
+            // Clear the config from cache first
+            delete require.cache[configPath];
+            
+            // Mock the config module before importing sentry
+            require.cache[configPath] = {
+                exports: { 
+                    default: mockConfig,
+                    __esModule: true
+                },
+                loaded: true,
+                children: [],
+                parent: null,
+                filename: configPath,
+                id: configPath,
+                paths: [],
+            };
+
+            // Import Sentry module which triggers initialization
+            const sentryPath = require.resolve("./sentry.js");
+            delete require.cache[sentryPath]; // Clear sentry from cache
+            await import("./sentry.js");
+        } catch (error) {
+            sentryError = error as Error;
+        }
+
+        // With the upgrade to @sentry/bun 10.15.0, this should now work without the Proxy error
+        // If we're still on the old version, we'd expect the Proxy error
+        // If we're on the new version, Sentry should initialize successfully
+        if (sentryError) {
+            // If there's still an error, it should NOT be the Proxy error (since we upgraded)
+            expect(sentryError.message).not.toContain("A Proxy's 'target' should be an Object");
+        } else {
+            // Success - the upgrade fixed the issue
+            expect(sentryError).toBeNull();
+        }
+    });
+
+    it("should verify the Sentry version has been upgraded to fix the bug", () => {
+        // This test documents that the problematic version has been fixed
+        const packageJson = require("../package.json");
+        const currentVersion = packageJson.dependencies["@sentry/bun"];
+        
+        // Should now be version 10.x or higher (which fixes the Proxy bug)
+        expect(currentVersion).toMatch(/^(\^?10\.|^10\.|latest)/);
+        
+        // Document the bug details for reference
+        const bugInfo = {
+            brokenVersion: "9.5.0",
+            fixedVersion: "10.15.0", 
+            bugDescription: "A Proxy's 'target' should be an Object",
+            location: "instrumentBunServeOptions in @sentry/bun"
+        };
+        
+        expect(bugInfo.brokenVersion).toBe("9.5.0");
+    });
+});
+
+describe("Sentry Integration Workaround", () => {
+    it("should suggest disabling Sentry DSN as temporary workaround", () => {
+        // Document the workaround: set sentry.dsn to empty string or remove it
+        const workaroundConfig = {
+            sentry: {
+                dsn: "", // Empty DSN disables Sentry
+                environment: "production"
+            }
+        };
+        
+        expect(workaroundConfig.sentry.dsn).toBe("");
+    });
+});

package/src/sentry.ts

@@ -0,0 +1,19 @@
+/**
+ * This file is only imported if sentry reporting is enabled in the Sockethub config.
+ */
+
+import * as Sentry from "@sentry/bun";
+import debug from "debug";
+import config from "./config";
+
+const logger = debug("sockethub:sentry");
+if (!config.get("sentry:dsn")) {
+    throw new Error("Sentry attempted initialization with no DSN provided");
+}
+logger("initialized");
+Sentry.init(config.get("sentry"));
+
+export function reportError(err: Error): void {
+    logger("reporting error");
+    Sentry.captureException(err);
+}