@mobtakronio/capskit 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -5362,6 +5362,7 @@ module.exports = __toCommonJS(index_exports);
 
 // src/kernel/platform.ts
 var path2 = __toESM(require("path"), 1);
+var import_url = require("url");
 
 // src/kernel/loader.ts
 var fs = __toESM(require("fs"), 1);
@@ -21375,49 +21376,45 @@ function createElysiaRouter(capskit, traitHandlers = {}) {
   manifests.forEach((manifest) => {
     if (manifest.routes) {
       manifest.routes.forEach((route) => {
+        const path3 = route.path;
+        let hooks = {};
+        if (route.traits) {
+          hooks.beforeHandle = [];
+          for (const [traitName, traitValue] of Object.entries(route.traits)) {
+            if (traitHandlers[traitName]) {
+              hooks.beforeHandle.push((c) => traitHandlers[traitName](traitValue, c));
+            } else {
+              console.warn(`[HTTP Elysia] No handler provided for trait "${traitName}" on route ${route.method} ${path3}`);
+            }
+          }
+        }
         const handler = async ({ body, params, query, set }) => {
           try {
-            const result = await capskit.call(`${manifest.name}.${route.action}`, {
+            return await capskit.call(`${manifest.name}.${route.action}`, {
               body,
               params,
               query
             });
-            return result;
           } catch (error) {
             set.status = 500;
             return { error: error.message };
           }
         };
-        const path3 = route.path;
-        let config = {};
-        if (route.traits) {
-          const beforeHandle = [];
-          for (const [traitName, traitValue] of Object.entries(route.traits)) {
-            if (traitHandlers[traitName]) {
-              beforeHandle.push(async (c) => traitHandlers[traitName](traitValue, c));
-            } else {
-              console.warn(`[HTTP Elysia] No handler provided for trait "${traitName}" on route ${route.method} ${path3}`);
-            }
-          }
-          if (beforeHandle.length > 0) {
-            config.beforeHandle = beforeHandle;
-          }
-        }
         switch (route.method) {
           case "GET":
-            app.get(path3, handler, config);
+            app.get(path3, handler, hooks);
             break;
           case "POST":
-            app.post(path3, handler, config);
+            app.post(path3, handler, hooks);
             break;
           case "PUT":
-            app.put(path3, handler, config);
+            app.put(path3, handler, hooks);
             break;
           case "DELETE":
-            app.delete(path3, handler, config);
+            app.delete(path3, handler, hooks);
             break;
           case "PATCH":
-            app.patch(path3, handler, config);
+            app.patch(path3, handler, hooks);
             break;
         }
       });
@@ -21494,7 +21491,59 @@ var service3 = {
   }
 };
 
+// src/capsules/websocket/src/adapters/elysia.ts
+function createElysiaSocket(capskit) {
+  const manifests = capskit.getManifests();
+  const sockets = {};
+  manifests.forEach((manifest) => {
+    if (manifest.sockets) {
+      manifest.sockets.forEach((socket) => {
+        sockets[socket.path] = {
+          open: socket.open ? async (ws) => {
+            await capskit.call(`${manifest.name}.${socket.open}`, { ws, body: ws.data });
+          } : void 0,
+          message: async (ws, message) => {
+            const result = await capskit.call(`${manifest.name}.${socket.message}`, { ws, body: message });
+            if (result) ws.send(result);
+          },
+          close: socket.close ? async (ws, code, message) => {
+            await capskit.call(`${manifest.name}.${socket.close}`, { ws, code, message });
+          } : void 0,
+          drain: socket.drain ? async (ws) => {
+            await capskit.call(`${manifest.name}.${socket.drain}`, { ws });
+          } : void 0
+        };
+      });
+    }
+  });
+  return sockets;
+}
+
+// src/capsules/websocket/src/actions/buildSocket.ts
+var buildSocket = async (payload, context) => {
+  const { adapter = "elysia" } = payload?.body || payload || {};
+  const capskit = context.deps.capskit;
+  if (adapter === "elysia") {
+    const sockets = createElysiaSocket(capskit);
+    return { sockets };
+  }
+  throw new Error(`Unsupported WebSocket adapter: ${adapter}`);
+};
+
+// src/capsules/websocket/manifest.ts
+var service4 = {
+  name: "websocket",
+  requires: ["capskit"],
+  actions: {
+    buildSocket: {
+      handler: buildSocket,
+      description: "Returns a WebSocket configuration containing all platform capabilities mapped to WebSockets"
+    }
+  }
+};
+
 // src/kernel/platform.ts
+var import_meta = {};
 var CapsKit = class {
   constructor(config) {
     this.config = config;
@@ -21512,6 +21561,19 @@ var CapsKit = class {
     this.registerCapsule(service);
     this.registerCapsule(service2);
     this.registerCapsule(service3);
+    this.registerCapsule(service4);
+    try {
+      const currentDir = path2.dirname((0, import_url.fileURLToPath)(import_meta.url));
+      const builtinDir = path2.resolve(currentDir, "../capsules");
+      const builtinManifests = await loadCapsules(builtinDir);
+      for (const manifest of builtinManifests) {
+        if (!this.manifests.has(manifest.name)) {
+          this.registerCapsule(manifest);
+        }
+      }
+    } catch (error) {
+      console.warn("[CapsKit] Could not auto-load built-in capsules directory:", error);
+    }
     if (this.config.capsuleDirs) {
       for (const dir of this.config.capsuleDirs) {
         const absoluteDir = path2.resolve(dir);