@server/next 0.25.9 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.25.9",
+  "version": "0.26.0",
   "description": "A fully-fledged web server with routing, file uploads, sessions, static files, schema validation, websockets, testing, etc.",
   "homepage": "https://server-js.com/",
   "repository": "https://github.com/franciscop/server-next.git",
@@ -32,8 +32,7 @@
   "main": "src/index.js",
   "types": "src/index.d.ts",
   "files": [
-    "src/",
-    "jsx-dev-runtime.js"
+    "src/"
   ],
   "exports": {
     ".": "./src/index.js",

package/src/helpers/bucket.js

@@ -33,9 +33,14 @@ function thinLocalBucket(root) {
       }
       return fs.createWriteStream(fullPath);
     },
-    delete: (name) => {
+    delete: async (name) => {
       const fullPath = absolute(name);
-      return fsp.unlink(fullPath);
+      try {
+        await fsp.unlink(fullPath);
+        return true;
+      } catch (error) {
+        return false;
+      }
     },
   };
 }

package/src/helpers/bucket.test.js

@@ -37,4 +37,15 @@ describe("bucket", () => {
     const stream = await localBucket.read("testFile.txt");
     expect(stream).toBeNull();
   });
+
+  it("removes an existing file", async () => {
+    await localBucket.write("testFile.txt", "To be deleted");
+    const isDeleted = await localBucket.delete("testFile.txt");
+    expect(isDeleted).toBe(true);
+  });
+
+  it("tries to remove a non-existing file", async () => {
+    const isDeleted = await localBucket.delete("nonExistentFile.txt");
+    expect(isDeleted).toBe(false);
+  });
 });

package/src/helpers/createWebsocket.js

@@ -0,0 +1,21 @@
+export default function createWebsocket(sockets, handlers) {
+  return {
+    message: async (socket, body) => {
+      handlers.socket
+        ?.filter((s) => s[1] === "message")
+        ?.map((s) => s[2]({ socket, sockets, body }));
+    },
+    open: (socket) => {
+      sockets.push(socket);
+      handlers.socket
+        ?.filter((s) => s[1] === "open")
+        ?.map((s) => s[2]({ socket, sockets, body }));
+    },
+    close: (socket) => {
+      sockets.splice(sockets.indexOf(socket), 1);
+      handlers.socket
+        ?.filter((s) => s[1] === "close")
+        ?.map((s) => s[2]({ socket, sockets, body }));
+    },
+  };
+}

package/src/helpers/index.js

@@ -1,11 +1,14 @@
 export { default as createCookies } from "./createCookies.js";
 export { default as createId } from "./createId.js";
+export { default as createWebsocket } from "./createWebsocket.js";
 export { default as config } from "./config.js";
 export { default as cors } from "./cors.js";
 export { default as define } from "./define.js";
 export { default as getMachine } from "./getMachine.js";
 export { default as handleRequest } from "./handleRequest.js";
 export { default as iterate } from "./iterate.js";
+export { default as iteratorToReadable } from "./iteratorToReadable.js";
+export { default as iteratorAsyncToReadable } from "./iteratorAsyncToReadable.js";
 export { default as parseHeaders } from "./parseHeaders.js";
 export { default as toWeb } from "./toWeb.js";
 export { default as types } from "./types.js";

package/src/helpers/iteratorAsyncToReadable.js

@@ -0,0 +1,20 @@
+export default function iteratorAsyncToReadable(asyncGenerator) {
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await asyncGenerator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(new TextEncoder().encode(value));
+      } catch (err) {
+        console.error("Stream error:", err);
+        controller.error(err);
+      }
+    },
+    cancel() {
+      console.log("Stream cancelled");
+    },
+  });
+}

package/src/helpers/iteratorToReadable.js

@@ -0,0 +1,10 @@
+export default function iteratorToReadable(generator) {
+  return new ReadableStream({
+    async start(controller) {
+      for await (const chunk of generator) {
+        controller.enqueue(chunk);
+      }
+      controller.close();
+    },
+  });
+}

package/src/index.d.ts

@@ -17,7 +17,21 @@ type Store = {
   ) => Promise<any>;
 };
 
-type Bucket = any;
+type Bucket =
+  | string
+  | {
+      read: (key: string) => ReadableStream;
+      write: (
+        key: string,
+        data:
+          | string
+          | NodeJS.ArrayBufferView
+          | Iterable<string | NodeJS.ArrayBufferView>
+          | AsyncIterable<string | NodeJS.ArrayBufferView>,
+        type: BufferEncoding,
+      ) => Promise<Boolean>;
+      delete: (key: string) => Promise<Boolean>;
+    };
 
 type Auth = {
   type: "cookie" | "token";

package/src/index.js

@@ -5,6 +5,7 @@ import createNodeContext from "./context/node.js";
 import createWinterContext from "./context/winter.js";
 import {
   config,
+  createWebsocket,
   getMachine,
   handleRequest,
   iterate,
@@ -31,9 +32,6 @@ export default function server(options = {}) {
   this.opts = config(options);
   this.platform = getMachine();
 
-  // TODO: find a way to remove this hack
-  this.extended = false;
-
   // Skip "forbidden methods" https://fetch.spec.whatwg.org/#concept-method
   this.handlers = {
     socket: [],
@@ -46,27 +44,11 @@ export default function server(options = {}) {
     options: [],
   };
 
+  // Keep a reference of the currently connected sockets
   this.sockets = [];
+
   // Note: required by Bun
-  this.websocket = {
-    message: async (socket, body) => {
-      this.handlers.socket
-        ?.filter((s) => s[1] === "message")
-        ?.map((s) => s[2]({ socket, sockets: this.sockets, body }));
-    },
-    open: (ws) => {
-      this.sockets.push(ws);
-      this.handlers.socket
-        ?.filter((s) => s[1] === "open")
-        ?.map((s) => s[2]({ socket, sockets: this.sockets, body }));
-    },
-    close: (ws) => {
-      this.sockets.splice(this.sockets.indexOf(ws), 1);
-      this.handlers.socket
-        ?.filter((s) => s[1] === "close")
-        ?.map((s) => s[2]({ socket, sockets: this.sockets, body }));
-    },
-  };
+  this.websocket = createWebsocket(this.sockets, this.handlers);
 
   // Initialize it right away for Node.js
   if (this.platform.runtime === "node") {

package/src/parseResponse.js

@@ -1,4 +1,9 @@
-import { cors, createId } from "./helpers/index.js";
+import {
+  cors,
+  createId,
+  iteratorToReadable,
+  iteratorAsyncToReadable,
+} from "./helpers/index.js";
 import { json } from "./reply.js";
 import ServerError from "./ServerError.js";
 
@@ -34,14 +39,25 @@ export default async function parseResponse(out, ctx) {
     out = json(out);
   }
 
+  // Sync and Async iterators
+  if (out[Symbol.iterator]) {
+    out = new Response(iteratorToReadable(out));
+  }
+
+  // The ReadableStream seems to be an asyncIterator, but we don't want to handle that yet
+  if (out[Symbol.asyncIterator] && !(out instanceof Response)) {
+    out = new Response(iteratorAsyncToReadable(out));
+  }
+
   // The output from fetch(), create a copy of it into a new response
   if (out instanceof Response && out.url && out.body) {
     out = new Response(out.body, {
-      status: 200,
+      status: out.status,
       headers: out.headers,
     });
+
+    // Compression not supported for streaming response, stripping header
     if (/^(br|gzip)$/.test(out.headers.get("content-encoding"))) {
-      console.warn("Compression not yet supported for response");
       out.headers.delete("content-encoding");
     }
   }

package/src/reply.js

@@ -76,11 +76,11 @@ Reply.prototype.redirect = function (Location) {
   return this.headers({ Location }).status(302).send();
 };
 
-Reply.prototype.file = async function (path) {
+Reply.prototype.file = async function (path, renderer = (data) => data) {
   try {
     const data = await fs.readFile(path);
     const ext = path.split(".").pop();
-    return this.type(ext).send(data);
+    return this.type(ext).send(await renderer(data));
   } catch (error) {
     if (error.code === "ENOENT") {
       return status(404).send();
@@ -89,14 +89,14 @@ Reply.prototype.file = async function (path) {
   }
 };
 
-Reply.prototype.view = async function (path) {
+Reply.prototype.view = async function (path, renderer = (data) => data) {
   return async (ctx) => {
     if (!ctx.options.views) {
       throw new Error("Views not enabled");
     }
     const data = await ctx.options.views.read(path);
-    if (data) return this.type(path.split(".").pop()).send(data);
-    return this.status(404).send();
+    if (!data) return this.status(404).send();
+    return this.type(path.split(".").pop()).send(await renderer(data));
   };
 };