First commit. Publish package:)

Author: danybeltran

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+package-lock.json

README.md

@@ -0,0 +1,110 @@
+###  Next API Validation
+
+This is basically the same as [serverless-request-validator](https://www.npmjs.com/package/serverless-request-validator) ready be used in Next.js
+
+### How to use it:
+
+It is nice to be able to programmatically define what you want your API endpoint(s) to do deppending on the request method used.
+
+In express it's something like:
+
+```js
+app.get((req,res)=>{
+    res.send("Something");
+})
+```
+> That will work only when using a `GET` request
+
+In Next.js (and Vercel) apps, your api are files in a specific order in the project directory, each file with a default export being the actual handler that will handle that request.
+
+First, install the module:
+
+```sh
+npm install next-api-validation
+```
+Or
+```sh
+yarn add next-api-validation
+```
+
+Using it in any of your API routes in Next.js:
+
+```js
+import validation from "next-api-validation";
+
+export default validation.get((req,res)=>{
+    res.send("This only accepts GET request")
+})
+```
+> As you can see, using the `get` method in the `validation` object prevents the handler from being executed if a different request method is used.
+
+And so with other methods:
+
+
+```js
+// api/index.js or api/index.ts
+import validation from "next-api-validation";
+
+export default validation.post((req,res)=>{
+    res.send("You just sent a POST request")
+})
+```
+> This handler a POST request
+
+**What if an endpoint should handle requests using more than one or two methods?**
+
+Creating a default export of the function should solve that:
+
+```js
+// api/index.js or api/index.ts
+import validate from "next-api-validation"
+
+export default validate({
+    get(req,res){
+        res.send("A get request")
+    },
+    post(req,res){
+        res.send("I only handle post requests"))
+    },
+    put(req,res){
+        res.send("Did you put something?")
+    }
+})
+```
+
+The previous code handles requests that use three different methods, and calls only the necessary handler. An example of how it can be used:
+
+```js
+// CRUD of a MongoDB Document model
+
+import { Post } from "src/Models";
+import { connectToDatabase } from "src/utils";
+import validate from "next-api-validation";
+
+connectToDatabase();
+
+export default validate({
+  get: async (req, res) => {
+    const posts = await Post.find();
+    res.send(posts);
+  },
+  post: async (req, res) => {
+    const newPost = new Post(req.body);
+    const saved = await newPost.save();
+    res.send(saved);
+  },
+  put: async (req, res) => {
+    const editedPost = await Post.findByIdAndUpdate(req.body._id, req.body);
+    res.send(editedPost);
+  },
+  delete: async (req, res) => {
+    const deletedPost = await Post.findByIdAndDelete(req.body._id);
+    res.send(deletedPost);
+  },
+});
+```
+> Async handlers work too:), but this is thanks to Next.js itself, not me:P
+
+That's it!
+
+You can follow me on Github as [Danybeltran](https://github.com/danybeltran),  I sometimes works on other stuff. Check a similar package made for Vercel APIs: [serverless-request-validator](https://www.npmjs.com/package/serverless-request-validator), also by me. Thanks!

index.d.ts

@@ -0,0 +1,39 @@
+import { VercelRequest, VercelResponse } from "@vercel/node";
+interface ValidateRequest extends VercelRequest {
+}
+interface ValidateResponse<T> extends VercelResponse {
+    sendStatus?: (code: number, message?: string) => void;
+    sendFile?: (url?: string) => void;
+}
+/** Request handler */
+declare type RequestValidatorHandlerType = (
+/** Request object */
+Req: ValidateRequest, 
+/** Response object */
+Res: ValidateResponse<any>) => void;
+interface IValidatorProps {
+    /** Handles a GET request */
+    get?: RequestValidatorHandlerType;
+    /** Handles a POST request */
+    post?: RequestValidatorHandlerType;
+    /** Handles a PUT request */
+    put?: RequestValidatorHandlerType;
+    /** Handles a DELETE request */
+    delete?: RequestValidatorHandlerType;
+    /** Handles a HEAD request */
+    head?: RequestValidatorHandlerType;
+    /** Handles a CONNECT request */
+    connect?: RequestValidatorHandlerType;
+    /** Handles an OPTIONS request */
+    options?: RequestValidatorHandlerType;
+    /** Handles a TRACE request */
+    trace?: RequestValidatorHandlerType;
+    /** Handles a PATCH request */
+    patch?: RequestValidatorHandlerType;
+}
+/** Specify callbacks for different methods made to an endpoint */
+declare type ValidateType = (handlers: IValidatorProps) => Function;
+interface IValidate extends IValidatorProps, ValidateType {
+}
+declare const Validate: IValidate;
+export default Validate;

index.js

@@ -0,0 +1,120 @@
+"use strict";
+var __assign =
+  (this && this.__assign) ||
+  function () {
+    __assign =
+      Object.assign ||
+      function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+    return __assign.apply(this, arguments);
+  };
+exports.__esModule = true;
+var mime_types_1 = require("mime-types");
+var fs = require("fs");
+var RequestMethods = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "head",
+  "connect",
+  "options",
+  "trace",
+  "patch",
+];
+var Validate = function (handlers) {
+  var validateResponseCallback = function (req, res) {
+    var _handlers = __assign({}, handlers);
+    var vResponse = __assign(__assign({}, res), {
+      sendStatus: function (code, message) {
+        if (message === void 0) {
+          message = "";
+        }
+        res.status(code).send(message);
+      },
+      sendFile: function (url) {
+        if (url === void 0) {
+          url = "";
+        }
+        try {
+          var fileHeadType = mime_types_1.lookup(url);
+          if (typeof fileHeadType === "string") {
+            res.writeHead(200, {
+              "Content-Type": fileHeadType.toString(),
+            });
+            var rs = fs.createReadStream(url);
+            rs.pipe(res);
+          } else {
+            res.status(404).send("File not found");
+          }
+        } catch (err) {
+          throw err;
+        }
+      },
+    });
+    try {
+      RequestMethods.forEach(function (requestMethod) {
+        if (!handlers[requestMethod]) {
+          var invalidMethodCb = function (req, res) {
+            res
+              .status(405)
+              .send("Cannot " + requestMethod.toUpperCase() + " " + req.url);
+          };
+          _handlers[requestMethod] = invalidMethodCb;
+        }
+      });
+      return _handlers[req.method.toLowerCase()](req, vResponse);
+    } catch (err) {
+      res.send("An error ocurred");
+      throw err;
+    }
+  };
+  return validateResponseCallback;
+};
+RequestMethods.forEach(function (requestMethod) {
+  Validate[requestMethod] = function (handler) {
+    var responseCb = function (req, res) {
+      var method = req.method;
+      var vResponse = __assign(__assign({}, res), {
+        sendStatus: function (code, message) {
+          if (message === void 0) {
+            message = "";
+          }
+          res.status(code).send(message);
+        },
+        sendFile: function (url) {
+          if (url === void 0) {
+            url = "";
+          }
+          try {
+            var fileHeadType = mime_types_1.lookup(url);
+            if (typeof fileHeadType === "string") {
+              res.writeHead(200, {
+                "Content-Type": fileHeadType.toString(),
+              });
+              var rs = fs.createReadStream(url);
+              rs.pipe(res);
+            } else {
+              res.status(404).send("File not found");
+            }
+          } catch (err) {
+            throw err;
+          }
+        },
+      });
+      if (method.toLowerCase() === requestMethod) {
+        handler(req, vResponse);
+      } else {
+        vResponse.sendStatus(405, "Cannot " + method + " " + req.url);
+      }
+    };
+    return responseCb;
+  };
+});
+exports["default"] = Validate;