@visulima/connect 1.0.1 → 1.1.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## @visulima/connect [1.1.1](https://github.com/visulima/visulima/compare/@visulima/connect@1.1.0...@visulima/connect@1.1.1) (2022-11-09)
+
+
+### Bug Fixes
+
+* **connect:** added missing type to the types.d ([33f7fa8](https://github.com/visulima/visulima/commit/33f7fa8282d23e00cd3bb4aeb7691f4b615b9afc))
+
+## @visulima/connect [1.1.0](https://github.com/visulima/visulima/compare/@visulima/connect@1.0.1...@visulima/connect@1.1.0) (2022-11-07)
+
+
+### Features
+
+* **connect:** renamed createRouter to createNodeRouter ([92f6d3f](https://github.com/visulima/visulima/commit/92f6d3f4d3430c281ae7106f7d09bb5b744df341))
+
 ## @visulima/connect [1.0.1](https://github.com/visulima/visulima/compare/@visulima/connect@1.0.0...@visulima/connect@1.0.1) (2022-10-27)
 
 

package/README.md

@@ -66,12 +66,12 @@ Below are some use cases.
 ```typescript
 // pages/api/hello.js
 import type { NextApiRequest, NextApiResponse } from "next";
-import { createRouter, expressWrapper } from "@visulima/connect";
+import { createNodeRouter, expressWrapper } from "@visulima/connect";
 import cors from "cors";
 
 // Default Req and Res are IncomingMessage and ServerResponse
 // You may want to pass in NextApiRequest and NextApiResponse
-const router = createRouter<NextApiRequest, NextApiResponse>({
+const router = createNodeRouter<NextApiRequest, NextApiResponse>({
   onError: (err, req, res) => {
     console.error(err.stack);
     res.status(500).end("Something broke!");
@@ -100,7 +100,7 @@ router
   .put(
     async (req, res, next) => {
       // You may want to pass in NextApiRequest & { isLoggedIn: true }
-      // in createRouter generics to define this extra property
+      // in createNodeRouter generics to define this extra property
       if (!req.isLoggedIn) throw new Error("thrown stuff will be caught");
       // go to the next in chain
       return next();
@@ -111,16 +111,14 @@ router
     }
   );
 
-// create a handler from router with custom
-// onError and onNoMatch
-export default router.handler();
+export default router.nodeHandler();
 ```
 
 ### Next.js getServerSideProps
 
 ```jsx
 // page/users/[id].js
-import { createRouter } from "@visulima/connect";
+import { createNodeRouter } from "@visulima/connect";
 
 export default function Page({ user, updated }) {
   return (
@@ -132,7 +130,7 @@ export default function Page({ user, updated }) {
   );
 }
 
-const router = createRouter()
+const router = createNodeRouter()
   .use(async (req, res, next) => {
     // this serve as the error handling middleware
     try {
@@ -222,7 +220,7 @@ router
     });
   });
 
-export default router.handler();
+export default router.nodeHandler();
 ```
 
 ### Next.js Middleware
@@ -267,9 +265,9 @@ export function middleware(request: NextRequest) {
 
 ## API
 
-The following APIs are rewritten in terms of `NodeRouter` (`createRouter`), but they apply to `EdgeRouter` (`createEdgeRouter`) as well.
+The following APIs are rewritten in terms of `NodeRouter` (`createNodeRouter`), but they apply to `EdgeRouter` (`createEdgeRouter`) as well.
 
-### router = createRouter()
+### router = createNodeRouter()
 
 Create an instance Node.js router.
 
@@ -285,31 +283,31 @@ Create an instance Node.js router.
 ```javascript
 // Mount a middleware function
 router1.use(async (req, res, next) => {
-  req.hello = "world";
-  await next(); // call to proceed to the next in chain
-  console.log("request is done"); // call after all downstream handler has run
+    req.hello = "world";
+    await next(); // call to proceed to the next in chain
+    console.log("request is done"); // call after all downstream nodeHandler has run
 });
 
 // Or include a base
 router2.use("/foo", fn); // Only run in /foo/**
 
 // mount an instance of router
-const sub1 = createRouter().use(fn1, fn2);
-const sub2 = createRouter().use("/dashboard", auth);
-const sub3 = createRouter()
-  .use("/waldo", subby)
-  .get(getty)
-  .post("/baz", posty)
-  .put("/", putty);
+const sub1 = createNodeRouter().use(fn1, fn2);
+const sub2 = createNodeRouter().use("/dashboard", auth);
+const sub3 = createNodeRouter()
+    .use("/waldo", subby)
+    .get(getty)
+    .post("/baz", posty)
+    .put("/", putty);
 router3
-  // - fn1 and fn2 always run
-  // - auth runs only on /dashboard
-  .use(sub1, sub2)
-  // `subby` runs on ANY /foo/waldo?/*
-  // `getty` runs on GET /foo/*
-  // `posty` runs on POST /foo/baz
-  // `putty` runs on PUT /foo
-  .use("/foo", sub3);
+    // - fn1 and fn2 always run
+    // - auth runs only on /dashboard
+    .use(sub1, sub2)
+    // `subby` runs on ANY /foo/waldo?/*
+    // `getty` runs on GET /foo/*
+    // `posty` runs on POST /foo/baz
+    // `putty` runs on PUT /foo
+    .use("/foo", sub3);
 ```
 
 ### router.METHOD(pattern, ...fns)
@@ -340,47 +338,47 @@ router.get((req, res, next) => {
 ```
 
 > **Note**
-> You should understand Next.js [file-system based routing](https://nextjs.org/docs/routing/introduction). For example, having a `router.put("/api/foo", handler)` inside `page/api/index.js` _does not_ serve that handler at `/api/foo`.
+> You should understand Next.js [file-system based routing](https://nextjs.org/docs/routing/introduction). For example, having a `router.put("/api/foo", nodeHandler)` inside `page/api/index.js` _does not_ serve that nodeHandler at `/api/foo`.
 
 ### router.all(pattern, ...fns)
 
 Same as [.METHOD](#methodpattern-fns) but accepts _any_ methods.
 
-### router.handler(options)
+### router.nodeHandler(options)
 
-Create a handler to handle incoming requests.
+Create a nodeHandler to handle incoming requests.
 
 **options.onError**
 
-Accepts a function as a catch-all error handler; executed whenever a handler throws an error.
+Accepts a function as a catch-all error nodeHandler; executed whenever a nodeHandler throws an error.
 By default, it responds with a generic `500 Internal Server Error` while logging the error to `console`.
 
 ```javascript
 function onError(err, req, res) {
-  logger.log(err);
-  // OR: console.error(err);
+    logger.log(err);
+    // OR: console.error(err);
 
-  res.status(500).end("Internal server error");
+    res.status(500).end("Internal server error");
 }
 
-const router = createRouter({ onError });
+const router = createNodeRouter({onError});
 
-export default router.handler();
+export default router.nodeHandler();
 ```
 
 **options.onNoMatch**
 
-Accepts a function of `(req, res)` as a handler when no route is matched.
+Accepts a function of `(req, res)` as a nodeHandler when no route is matched.
 By default, it responds with a `404` status and a `Route [Method] [Url] not found` body.
 
 ```javascript
 function onNoMatch(req, res) {
-  res.status(404).end("page is not found... or is it!?");
+    res.status(404).end("page is not found... or is it!?");
 }
 
-const router = createRouter({ onNoMatch });
+const router = createNodeRouter({onNoMatch});
 
-export default router.handler();
+export default router.nodeHandler();
 ```
 
 ### router.run(req, res)
@@ -462,10 +460,10 @@ router
   });
 ```
 
-Another issue is that the handler would resolve before all the code in each layer runs.
+Another issue is that the nodeHandler would resolve before all the code in each layer runs.
 
 ```javascript
-const handler = router
+const nodeHandler = router
   .use(async (req, res, next) => {
     next(); // this is not returned or await
   })
@@ -475,9 +473,9 @@ const handler = router
     res.send("ok");
     console.log("request is completed");
   })
-  .handler();
+  .nodeHandler();
 
-await handler(req, res);
+await nodeHandler(req, res);
 console.log("finally"); // this will run before the get layer gets to finish
 
 // This will result in:
@@ -489,15 +487,17 @@ console.log("finally"); // this will run before the get layer gets to finish
 
 ```javascript
 // api-libs/base.js
-export default createRouter().use(a).use(b);
+export default createNodeRouter().use(a).use(b);
 
 // api/foo.js
 import router from "api-libs/base";
-export default router.get(x).handler();
+
+export default router.get(x).nodeHandler();
 
 // api/bar.js
 import router from "api-libs/base";
-export default router.get(y).handler();
+
+export default router.get(y).nodeHandler();
 ```
 
 This is because, in each API Route, the same router instance is mutated, leading to undefined behaviors.
@@ -505,52 +505,54 @@ If you want to achieve something like that, you can use `router.clone` to return
 
 ```javascript
 // api-libs/base.js
-export default createRouter().use(a).use(b);
+export default createNodeRouter().use(a).use(b);
 
 // api/foo.js
 import router from "api-libs/base";
-export default router.clone().get(x).handler();
+
+export default router.clone().get(x).nodeHandler();
 
 // api/bar.js
 import router from "api-libs/base";
-export default router.clone().get(y).handler();
+
+export default router.clone().get(y).nodeHandler();
 ```
 
 3. **DO NOT** use response function like `res.(s)end` or `res.redirect` inside `getServerSideProps`.
 
 ```javascript
 // page/index.js
-const handler = createRouter()
-  .use((req, res) => {
-    // BAD: res.redirect is not a function (not defined in `getServerSideProps`)
-    // See https://github.com/hoangvvo/@visulima/connect/issues/194#issuecomment-1172961741 for a solution
-    res.redirect("foo");
-  })
-  .use((req, res) => {
-    // BAD: `getServerSideProps` gives undefined behavior if we try to send a response
-    res.end("bar");
-  });
+const nodeHandler = createNodeRouter()
+    .use((req, res) => {
+        // BAD: res.redirect is not a function (not defined in `getServerSideProps`)
+        // See https://github.com/hoangvvo/@visulima/connect/issues/194#issuecomment-1172961741 for a solution
+        res.redirect("foo");
+    })
+    .use((req, res) => {
+        // BAD: `getServerSideProps` gives undefined behavior if we try to send a response
+        res.end("bar");
+    });
 
-export async function getServerSideProps({ req, res }) {
-  await router.run(req, res);
-  return {
-    props: {},
-  };
+export async function getServerSideProps({req, res}) {
+    await router.run(req, res);
+    return {
+        props: {},
+    };
 }
 ```
 
-3. **DO NOT** use `handler()` directly in `getServerSideProps`.
+4. **DO NOT** use `nodeHandler()` directly in `getServerSideProps`.
 
 ```javascript
 // page/index.js
-const router = createRouter().use(foo).use(bar);
-const handler = router.handler();
-
-export async function getServerSideProps({ req, res }) {
-  await handler(req, res); // BAD: You should call router.run(req, res);
-  return {
-    props: {},
-  };
+const router = createNodeRouter().use(foo).use(bar);
+const nodeHandler = router.nodeHandler();
+
+export async function getServerSideProps({req, res}) {
+    await nodeHandler(req, res); // BAD: You should call router.run(req, res);
+    return {
+        props: {},
+    };
 }
 ```
 
@@ -561,24 +563,24 @@ export async function getServerSideProps({ req, res }) {
 <details>
 <summary>Match multiple routes</summary>
 
-If you created the file `/api/<specific route>.js` folder, the handler will only run on that specific route.
+If you created the file `/api/<specific route>.js` folder, the nodeHandler will only run on that specific route.
 
 If you need to create all handlers for all routes in one file (similar to `Express.js`). You can use [Optional catch-all API routes](https://nextjs.org/docs/api-routes/dynamic-api-routes#optional-catch-all-api-routes).
 
 ```javascript
 // pages/api/[[...slug]].js
-import { createRouter } from "@visulima/connect";
+import { createNodeRouter } from "@visulima/connect";
 
-const router = createRouter()
+const router = createNodeRouter()
   .use("/api/hello", someMiddleware())
   .get("/api/user/:userId", (req, res) => {
     res.send(`Hello ${req.params.userId}`);
   });
 
-export default router.handler();
+export default router.nodeHandler();
 ```
 
-While this allows quick migration from Express.js, consider seperating routes into different files (`/api/user/[userId].js`, `/api/hello.js`) in the future.
+While this allows quick migration from Express.js, consider separating routes into different files (`/api/user/[userId].js`, `/api/hello.js`) in the future.
 
 </details>
 

package/dist/index.d.ts

@@ -138,4 +138,4 @@ declare const withZod: <Request_1 extends object, Response_1 extends unknown, Ha
 
 declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: any) => void;
 
-export { RequestHandler$1 as EdgeRequestHandler, EdgeRouter, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, NodeRouter, RequestHandler, Route, RouteShortcutMethod, Router, ValueOrPromise, createEdgeRouter, createRouter, expressWrapper, sendJson, withZod };
+export { RequestHandler$1 as EdgeRequestHandler, EdgeRouter, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler as NodeRequestHandler, NodeRouter, Route, RouteShortcutMethod, Router, ValueOrPromise, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };

package/dist/index.js

@@ -331,5 +331,6 @@ var send_json_default = sendJson;
 
 
 
-exports.EdgeRouter = EdgeRouter; exports.NodeRouter = NodeRouter; exports.Router = Router; exports.createEdgeRouter = createEdgeRouter; exports.createRouter = createRouter; exports.expressWrapper = express_default; exports.sendJson = send_json_default; exports.withZod = with_zod_default;
+
+exports.EdgeRouter = EdgeRouter; exports.NodeRouter = NodeRouter; exports.Router = Router; exports.createEdgeRouter = createEdgeRouter; exports.createNodeRouter = createRouter; exports.createRouter = createRouter; exports.expressWrapper = express_default; exports.sendJson = send_json_default; exports.withZod = with_zod_default;
 //# sourceMappingURL=index.js.map

package/dist/index.mjs

@@ -327,6 +327,7 @@ export {
   NodeRouter,
   Router,
   createEdgeRouter,
+  createRouter as createNodeRouter,
   createRouter,
   express_default as expressWrapper,
   send_json_default as sendJson,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@visulima/connect",
-    "version": "1.0.1",
+    "version": "1.1.1",
     "description": "The minimal router and middleware layer for Next.js, Micro, Vercel, or Node.js http/http2 with support for zod validation.",
     "keywords": [
         "javascript",

package/src/index.ts

@@ -1,10 +1,14 @@
 export type { RequestHandler as EdgeRequestHandler } from "./edge";
 export { createEdgeRouter, EdgeRouter } from "./edge";
+
 export type { ExpressRequestHandler } from "./adapter/express";
 export { default as expressWrapper } from "./adapter/express";
 
-export type { RequestHandler } from "./node";
-export { createRouter, NodeRouter } from "./node";
+export type { RequestHandler as NodeRequestHandler } from "./node";
+export { createRouter as createNodeRouter, NodeRouter } from "./node";
+
+// @deprecated Use `createNodeRouter` instead
+export { createRouter } from "./node";
 
 export type { Route } from "./router";
 export { Router } from "./router";

package/src/types.d.ts

@@ -1,4 +1,4 @@
-import { AnyZodObject } from "zod";
+import type { AnyZodObject } from "zod";
 
 export type HttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";