@arcote.tech/arc-host 0.1.5 → 0.1.7

package/host.ts

@@ -102,7 +102,7 @@ class RTCHost implements RealTimeCommunicationAdapter {
    */
   private getDefaultAuthContext(ipAddress?: string): AuthContext {
     return {
-      userId: "anonymous",
+      userId: undefined as any,
       roles: [],
       ipAddress,
     };
@@ -282,6 +282,70 @@ class RTCHost implements RealTimeCommunicationAdapter {
     }
   }
 
+  private async handleRoute(req: Request) {
+    const url = new URL(req.url);
+    const method = req.method;
+
+    // Find matching route
+    let matchedRoute: any = null;
+    let routeParams: Record<string, string> = {};
+
+    for (const element of this.context.elements) {
+      // Check if element has matchesRoutePath method (ArcRoute)
+      if (typeof (element as any).matchesRoutePath === "function") {
+        const { matches, params } = (element as any).matchesRoutePath(
+          url.pathname,
+        );
+        if (matches) {
+          matchedRoute = element;
+          routeParams = params || {};
+          break;
+        }
+      }
+    }
+
+    if (!matchedRoute) {
+      return new Response("Route not found", { status: 404 });
+    }
+
+    const handler = matchedRoute.getHandler(method);
+    if (!handler) {
+      return new Response(`Method ${method} not allowed`, { status: 405 });
+    }
+
+    try {
+      // Extract token from Authorization header
+      const authHeader = req.headers.get("Authorization");
+      const token = authHeader?.replace("Bearer ", "");
+
+      const clientIp = this.getClientIpAddress(req);
+      let authContext: AuthContext;
+
+      if (token && !matchedRoute.isPublic) {
+        const payload = await this.verifyAuthToken(token);
+        if (!payload) {
+          return new Response("Invalid or expired token", { status: 401 });
+        }
+        authContext = this.tokenToAuthContext(payload, clientIp);
+      } else {
+        authContext = this.getDefaultAuthContext(clientIp);
+      }
+
+      // Use the model's routes method to properly handle event publishing
+      const routes = this.model.routes(authContext);
+      const response = await routes[matchedRoute.name](
+        method,
+        req,
+        routeParams,
+        url,
+      );
+      return response;
+    } catch (error) {
+      console.error(`Error executing route ${matchedRoute.name}:`, error);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+
   private setupServer() {
     this.server = Bun.serve({
       fetch: async (req, server) => {
@@ -328,6 +392,12 @@ class RTCHost implements RealTimeCommunicationAdapter {
           return await this.handleQuery(req);
         }
 
+        // Try to handle as a route
+        const routeResponse = await this.handleRoute(req);
+        if (routeResponse.status !== 404) {
+          return routeResponse;
+        }
+
         return new Response("Not Found", { status: 404 });
       },
       websocket: {
@@ -344,25 +414,31 @@ class RTCHost implements RealTimeCommunicationAdapter {
   }
 
   private isPublicEndpoint(pathname: string): boolean {
-    // Extract command name from pathname
-    if (!pathname.startsWith("/command/")) {
-      return false;
-    }
+    // Iterate through all context elements and check if any match and are public
+    for (const element of this.context.elements) {
+      // Check if element has matchesCommandPath method (ArcCommand)
+      if (typeof (element as any).matchesCommandPath === "function") {
+        const { matches, isPublic } = (element as any).matchesCommandPath(
+          pathname,
+        );
+        if (matches) {
+          return isPublic;
+        }
+      }
 
-    const commandName = pathname.split("/command/")[1];
-    if (!commandName) {
-      return false;
+      // Check if element has matchesRoutePath method (ArcRoute)
+      if (typeof (element as any).matchesRoutePath === "function") {
+        const { matches, isPublic } = (element as any).matchesRoutePath(
+          pathname,
+        );
+        if (matches) {
+          return isPublic;
+        }
+      }
     }
 
-    // Get the command from the context and check if it's marked as public
-    const contextElement = this.context.elements.find(
-      (element: any) => element.name === commandName,
-    );
-
-    // Check if it's an ArcCommand instance and if it's marked as public
-    return contextElement && "isPublic" in contextElement
-      ? contextElement.isPublic === true
-      : false;
+    // Default to non-public if no matching element found
+    return false;
   }
 
   private async handleSync(lastDate: string | null) {

package/index.ts

@@ -3,11 +3,9 @@ import { rtcHostFactory } from "./host";
 import { sqliteAdapterFactory } from "./sqliteAdapter";
 
 export function hostLiveModel<C extends ArcContextAny>(
-  contextPromise: Promise<C>,
+  context: C,
   options: { db: string; version: number },
 ) {
   const dbAdapterFactory = sqliteAdapterFactory(options.db);
-  contextPromise.then((context) => {
-    rtcHostFactory(context, dbAdapterFactory(context))();
-  });
+  rtcHostFactory(context, dbAdapterFactory(context))();
 }

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "dependencies": {