@server/next 0.20.0 → 0.20.2

package/index.d.ts

@@ -0,0 +1,50 @@
+type Bucket = {};
+
+type Method =
+  | "socket"
+  | "get"
+  | "head"
+  | "post"
+  | "put"
+  | "patch"
+  | "delete"
+  | "options";
+
+type ServerOptions = {
+  port?: number;
+  views?: string | Bucket;
+  public?: string | Bucket;
+  uploads?: string | Bucket;
+};
+
+type Context = {
+  method: Method;
+  headers: { [key: string]: string | string[] };
+  cookies: { [key: string]: any };
+  body?: any;
+  url: URL & { params: {}; query: {} };
+  options: ServerOptions;
+};
+
+type Middleware = (ctx: Context) => any;
+
+type Router = {};
+
+declare interface Server {
+  (options?: ServerOptions): this;
+
+  socket(path: string, ...middleware: Middleware[]): this;
+  get(path: string, ...middleware: Middleware[]): this;
+  head(path: string, ...middleware: Middleware[]): this;
+  post(path: string, ...middleware: Middleware[]): this;
+  put(path: string, ...middleware: Middleware[]): this;
+  patch(path: string, ...middleware: Middleware[]): this;
+  del(path: string, ...middleware: Middleware[]): this;
+  options(path: string, ...middleware: Middleware[]): this;
+
+  use(...middleware: Middleware[]): this;
+  router(router: Router): this;
+}
+
+declare const server: Server;
+export default server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "An experimental reimplementation of server.js focused on the DX",
   "homepage": "https://node-server.com/",
   "repository": "https://github.com/franciscop/server-next.git",
@@ -10,10 +10,9 @@
   "license": "UNLICENSED",
   "scripts": {
     "demo": "nodemon ./demo/app.js",
-    "build": "bun build src/index.js --outdir ./ --entry-naming server.js",
     "start": "bun test --watch",
-    "size": "echo \"$(gzip -c server.js | wc -c) bytes\" # Only for Unix",
-    "test": "bun test"
+    "test": "bun test",
+    "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "keywords": [
     "server",
@@ -21,9 +20,11 @@
     "server.js"
   ],
   "type": "module",
+  "types": "index.d.ts",
   "main": "src/index.js",
   "files": [
-    "src/"
+    "src/",
+    "index.d.ts"
   ],
   "engines": {
     "node": ">=20.0.0"
@@ -31,8 +32,7 @@
   "engineStrict": true,
   "dependencies": {},
   "devDependencies": {
-    "jest": "^26.0.1",
-    "prettier": "^2.7.0"
+    "jest": "^29.7.0"
   },
   "jest": {
     "testEnvironment": "jest-environment-node",

package/readme.md

@@ -1,6 +1,8 @@
 # Server @ Next
 
-> **EXPERIMENTAL LIBRARY**
+> **⚠️ WIP** This is an **experimental library** right now!
+
+[**Documentation Here**](https://node-server.com/documentation/)
 
 A fully-fledged web server for Bun and Node.js, with all the basics covered for you:
 
@@ -9,26 +11,26 @@ import server from "@server/next";
 
 // Create a running instance of the server
 export default server(options)
-  .router("/admin/", dashboard)
-  .get("/users", getUsers)
-  .post("/users", createUser)
-  .put("/users/:id", editUser);
+  .get("/books", () => Book.list())
+  .post("/books", { body: BookSchema }, (ctx) => {
+    return Book.create(ctx.body).save();
+  });
 ```
 
-It includes all the things you would expect from a modern Server framework, like routing, static file serving, options\*, body+file parsing, gzip+brotli, streaming, server-timing, plugins\*, etc.
-
-> \* not yet available
+It includes all the things you would expect from a modern Server framework, like routing, static file serving, body+file parsing, gzip+brotli, streaming, testing, error handling, websockets, etc. We also have integrations with these:
 
-For testing it's also easy, since we are exporting our server throught the WinterCG API we can do:
+- KV Stores: in-memory, Redis, Consul, DynamoDB.
+- Buckets: AWS S3, Cloudflare R2, Backblaze B2.
+- Validation libraries: Zod, Joi, Yup.
 
 ```js
-// index.test.js
+// Easy testing as well - index.test.js
 import app from "./";
 
 it("can retrieve the homepage", async () => {
-  const res = await app.fetch(new Request("http://localhost:3000/hello/"));
-  const data = await res.text();
-  expect(data).toBe("Hello world");
+  const res = await app.fetch(new Request("http://localhost:3000/books/"));
+  const books = await res.json();
+  expect(books[0]).toEqual({ id: 0, name: 'The Catcher In The Rye', ... });
 });
 ```
 
@@ -43,18 +45,10 @@ Why? We live in the era of multi-cloud (Heroku, Workers, Lambda, etc) and multi-
 - Changed the reply logic greatly, including the removal of `render()`. This is the main reason express was removed. Many servers don't need render() at all.
 - **[security]** Removed mandatory CSRF token, since this is only useful for server-rendered pages and not for SPA. Now we provide an `auth` module instead.
 
-Major changes:
-
-- New fully fledged `ctx.url` that extends [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) object inside `ctx` (also note: `ctx.url` is no longer a string):
-  - `ctx.params` is now `ctx.url.params`, e.g. `ctx.url.params.id`.
-  - `ctx.query` is now `ctx.url.query`, e.g. `ctx.url.query.search`.
-  - `ctx.path` is now `ctx.url.path` (or `ctx.url.pathname`).
-  - All URL properties are available, like `ctx.url.port`, `ctx.url.searchParams`, etc.
-
 ## Progress
 
 - Router has all verbs, as well as URL pattern matches
-- Full URL parsing, including `query` and `params` in ctx.url.
+- Full URL parsing, including `query` and `params` in `ctx.url`.
 - Body and Files parsing is working (need testing)
 - The middleware can return:
   - A number and it'll be set as the status code
@@ -63,42 +57,6 @@ Major changes:
   - An object with `status`, `body` and `headers` and it'll be set raw.
 - Response compression works
 
-## Some plugins
-
-> This question is just some concepts/ideas
-
-Plugins? Or internals?
-
-```js
-import Bucket from 'bucket/s3';
-import Redis from 'redis';
-
-const bucket = Bucket('my-bucket', { id, key });
-const cache = Redis('my-redis', ...);
-
-const app = server({ public: bucket, uploads: bucket, cache });
-
-app([
-  post('/uploads', ctx => {
-    // Without { public: bucket }, it'd be a local file in the filesystem
-    console.log(ctx.files.profile);
-    // file.name
-    // file.id
-    // file.path
-    // file.type
-    // file.size
-
-    // With { public: bucket }, it's the reference to the bucket file
-    console.log(ctx.files.profile);
-    // file.name
-    // file.id
-    // file.path
-    // file.type
-    // file.size
-  })
-]);
-```
-
 ## Examples
 
 ### Streams
@@ -156,58 +114,3 @@ export default server()
     return 201;
   });
 ```
-
-```js
-import server, { jwtAuth } from "server";
-import BookRouter from "./BookRouter";
-import UserRouter from "./UserRouter";
-
-export default server({ port: 3000 })
-  .use(jwtAuth)
-  .route("/users", UserRouter)
-  .route("/books", BookRouter);
-```
-
-```js
-// UserRouter.js -> A custom router
-import server, { router } from "server";
-
-export default router()
-  .get("/", getUsers)
-  .get("/:id", getUser)
-  .post("/", createUser);
-```
-
-MAYBE?
-
-```js
-// BookRouter.js -> a REST API router
-import { RestRouter } from "server";
-
-export default class BookRouter extends RestRouter {
-  async create(ctx) {
-    // POST /
-  }
-  async list(ctx) {
-    // GET /
-  }
-  async get(ctx) {
-    // GET /:id
-  }
-  async search(ctx) {
-    // GET /?...
-  }
-  async update(ctx) {
-    // PUT /:id
-  }
-  async set(ctx) {
-    // PATCH /:id
-  }
-  async delete(ctx) {
-    // DELETE /:id
-  }
-  async error(ctx) {
-    // ctx.error
-  }
-}
-```

package/src/helpers/define.js

@@ -8,8 +8,8 @@ export default function define(obj, key, cb) {
     get() {
       const value = cb(obj);
       Object.defineProperty(obj, key, {
-        configurable: false,
-        writable: false,
+        configurable: true,
+        writable: true,
         value,
       });
       return obj[key];

package/src/helpers/handleRequest.js

@@ -4,7 +4,7 @@ import define from "./define.js";
 import validate from "./validate.js";
 
 export default async function handleRequest(handlers, ctx) {
-  for (let [matcher, ...cbs] of handlers[ctx.method]) {
+  for (let [method, matcher, ...cbs] of handlers[ctx.method]) {
     const match = pathPattern(matcher, ctx.url.pathname || "/");
     // Skip this whole middleware if there was no match
     if (!match) continue;
@@ -22,6 +22,9 @@ export default async function handleRequest(handlers, ctx) {
         return new Response(error.message, { status: error.status || 500 });
       }
     }
+
+    // When it's an HTTP method, break free after it's done (which will 404)
+    if (method !== "*") break;
   }
 
   return new Response("Not Found", { status: 404 });

package/src/index.js

@@ -19,7 +19,18 @@ export default function server(options = {}) {
 
   this.platform = getMachine();
 
-  this.handlers = {};
+  this.handlers = {
+    socket: [],
+    get: [],
+    head: [],
+    post: [],
+    put: [],
+    patch: [],
+    delete: [],
+    options: [],
+  };
+
+  options.port = options.port || process.env.PORT || 3000;
 
   options.views = options.views ? Bucket(options.views) : null;
   options.public = options.public ? Bucket(options.public) : null;
@@ -57,14 +68,14 @@ export default function server(options = {}) {
           }
           response.end();
         })
-        .listen(options.port || 3000);
+        .listen(options.port);
     })();
   }
 
   this.fetch = async (request, env, fetchCtx) => {
     if (env?.upgrade(request)) return;
 
-    const ctx = await createWinterContext(request, options);
+    const ctx = await createWinterContext(request, options, this.platform);
     ctx.platform = this.platform;
 
     return await handleRequest(this.handlers, ctx);
@@ -72,62 +83,55 @@ export default function server(options = {}) {
 }
 
 // INTERNAL
-server.prototype.handle = function (name, ...middleware) {
-  if (!this.handlers[name]) {
-    this.handlers[name] = [];
+server.prototype.handle = function (method, path, ...middleware) {
+  if (method === "*") {
+    for (let m in this.handlers) {
+      this.handlers[m].push(["*", path, ...middleware]);
+    }
+  } else {
+    this.handlers[method].push([method, path, ...middleware]);
   }
-  this.handlers[name].push(...middleware);
+
   return this;
 };
 
 server.prototype.socket = function (path, ...middleware) {
-  return this.handle("socket", [path, ...middleware]);
+  return this.handle("socket", path, ...middleware);
 };
 
 server.prototype.get = function (path, ...middleware) {
-  return this.handle("get", [path, ...middleware]);
+  return this.handle("get", path, ...middleware);
 };
 
 server.prototype.head = function (path, ...middleware) {
-  return this.handle("head", [path, ...middleware]);
+  return this.handle("head", path, ...middleware);
 };
 
 server.prototype.post = function (path, ...middleware) {
-  return this.handle("post", [path, ...middleware]);
+  return this.handle("post", path, ...middleware);
 };
 
 server.prototype.put = function (path, ...middleware) {
-  return this.handle("put", [path, ...middleware]);
+  return this.handle("put", path, ...middleware);
 };
 
 server.prototype.patch = function (path, ...middleware) {
-  return this.handle("patch", [path, ...middleware]);
+  return this.handle("patch", path, ...middleware);
 };
 
 server.prototype.del = function (path, ...middleware) {
-  return this.handle("del", [path, ...middleware]);
+  return this.handle("del", path, ...middleware);
 };
 
 server.prototype.options = function (path, ...middleware) {
-  return this.handle("options", [path, ...middleware]);
+  return this.handle("options", path, ...middleware);
 };
 
 server.prototype.use = function (...middleware) {
-  let path = "*";
-  if (typeof middleware[0] === "string" || middleware[0] instanceof RegExp) {
-    path = middleware.shift();
+  if (typeof middleware[0] === "string") {
+    return this.handle("*", ...middleware);
   }
-
-  this.handle("socket", [path, ...middleware]);
-  this.handle("get", [path, ...middleware]);
-  this.handle("head", [path, ...middleware]);
-  this.handle("post", [path, ...middleware]);
-  this.handle("put", [path, ...middleware]);
-  this.handle("patch", [path, ...middleware]);
-  this.handle("del", [path, ...middleware]);
-  this.handle("options", [path, ...middleware]);
-
-  return this;
+  return this.handle("*", "*", ...middleware);
 };
 
 server.prototype.router = function (basePath, router) {

package/src/index.test.js

@@ -1,21 +1,37 @@
 import server, { status } from "./index.js";
 
-describe("server", () => {
+describe("return different types", () => {
   const app = server()
     .get("/", () => "Hello world")
     .get("/text", () => "Hello world")
     .get("/array", () => ["Hello world"])
     .get("/object", () => ({ hello: "world" }))
-    .get("/status", () => 201)
-    .post("/", (ctx) => status(201).send(ctx.body));
+    .get("/status", () => 201);
 
-  it("can render hello world", async () => {
-    const res = await app.fetch(new Request("http://localhost:3000/"));
-
-    expect(res.status).toBe(200);
+  it("can get the plain text", async () => {
+    const res = await app.fetch(new Request("http://localhost:3000/text"));
     expect(await res.text()).toBe("Hello world");
   });
 
+  it("can get the array", async () => {
+    const res = await app.fetch(new Request("http://localhost:3000/array"));
+    expect(await res.json()).toEqual(["Hello world"]);
+  });
+
+  it("can get the object", async () => {
+    const res = await app.fetch(new Request("http://localhost:3000/object"));
+    expect(await res.json()).toEqual({ hello: "world" });
+  });
+
+  it("can get the status", async () => {
+    const res = await app.fetch(new Request("http://localhost:3000/status"));
+    expect(res.status).toBe(201);
+  });
+});
+
+describe("simple post works", () => {
+  const app = server().post("/", (ctx) => status(201).send(ctx.body));
+
   it("can post new data", async () => {
     const res = await app.fetch(
       new Request("http://localhost:3000/", {
@@ -41,5 +57,3 @@ describe("server", () => {
     expect(await res.json()).toEqual({ hello: "world" });
   });
 });
-
-describe("all the replies", () => {});

package/src/pathPattern.js

@@ -1,4 +1,5 @@
 export default function pathPattern(pattern, path) {
+  pattern = "/" + pattern.replace(/^\//, "");
   pattern = pattern.replace(/\/$/, "") || "/";
   path = path.replace(/\/$/, "") || "/";
 

package/src/url.test.js

@@ -0,0 +1,24 @@
+import server from "./index.js";
+
+describe("can match the url", () => {
+  it("stops at the first matching route", async () => {
+    const app = server()
+      .get("/:id", (ctx) => ctx.url.params)
+      .get("/*", (ctx) => ctx.url.params);
+
+    const res = await app.fetch(new Request("http://localhost:3000/hello"));
+    expect(await res.json()).toEqual({ id: "hello" });
+  });
+
+  it("but it doesn't if it's a use", async () => {
+    const app = server()
+      .use(() => {
+        // No-op
+      })
+      .get("/:id", (ctx) => ctx.url.params)
+      .get("/*", (ctx) => ctx.url.params);
+
+    const res = await app.fetch(new Request("http://localhost:3000/hello"));
+    expect(await res.json()).toEqual({ id: "hello" });
+  });
+});