@koziatek/http 1.0.1

package/HttpStatusCodes.js

@@ -0,0 +1,26 @@
+class HttpStatusCodes {
+    
+    static continue         = 100;
+    static ok               = 200;
+    static created          = 201;
+    static accepted         = 202;
+    static noContent        = 204;
+    static badRequest       = 400;
+    static unauthorized     = 401;
+    static forbidden        = 403;
+    static notFound         = 404;
+    static notAllowed       = 405;
+    static notAccepted      = 406;
+    static conflict         = 409;
+    static teapot           = 418;
+    static unprocessible    = 422;
+    static tooManyAttempts  = 429;
+    static internal         = 500;
+    static notImplemented   = 501;
+    static unavailable      = 503;
+}
+
+
+module.exports = {
+    HttpStatusCodes,
+}

package/index.js

@@ -0,0 +1,23 @@
+const { HttpStatusCodes } = require("./HttpStatusCodes");
+const { CatchAll } = require("./middleware/CatchAll");
+const { ErrorRenderer } = require("./middleware/ErrorRender");
+const { Next } = require("./middleware/Next");
+const { OpenReq } = require("./middleware/OpenReq");
+const { ResData } = require("./middleware/ResData");
+const { SendRes } = require("./middleware/SendRes");
+const { Status } = require("./middleware/Status");
+
+
+module.exports = {
+    HttpStatusCodes,
+    middleware: {
+        CatchAll,
+        ErrorRenderer,
+        Next,
+        OpenReq,
+        ResData,
+        SendRes,
+        Status,
+    },
+
+}

package/middleware/CatchAll.js

@@ -0,0 +1,38 @@
+const { HttpStatusCodes } = require('../HttpStatusCodes.js');
+
+/**
+ * Default response content for unimplemented routes.
+ * @constant {Object}
+ */
+const DEFAULT_CONTENT = {
+    error: 'Not Implemented',
+    messages: [
+        'The requested endpoint does not exist.'
+    ]
+};
+
+/**
+ * Express middleware generator for catching all unmatched routes.
+ * 
+ * @function CatchAll
+ * @param {number} [status=HttpStatusCodes.notImplemented] - The HTTP status code to send (default is 501 Not Implemented).
+ * @param {Object} [content=DEFAULT_CONTENT] - The response content to send as JSON.
+ * @returns {function} Express middleware function to handle unmatched routes.
+ * 
+ * @example
+ * const { CatchAll } = require('./middleware/CatchAll');
+ * app.use(CatchAll());
+ * 
+ * @example
+ * // Custom status and message
+ * app.use(CatchAll(404, { error: "Not Found", messages: ["This page does not exist."] }));
+ */
+function CatchAll(status = HttpStatusCodes.notImplemented, content = DEFAULT_CONTENT) {
+    return (req, res, next) => {
+        res.status(status).send(content);
+    };
+}
+
+module.exports = {
+    CatchAll
+};

package/middleware/ErrorRender.js

@@ -0,0 +1,26 @@
+const { HttpStatusCodes } = require('../HttpStatusCodes.js');
+const { Log, isFunction } = require('@precision-sustainable-ag/utils');
+
+function ErrorRenderer(err, req, res, next) {
+    let response;
+    let statusCode = HttpStatusCodes.internal;
+    
+    if(isFunction(err.getStatusCode)) statusCode = err.getStatusCode();
+    else if(err.statusCode) statusCode = err.statusCode;
+
+    if(isFunction(err?.toJSON)) response = err.toJSON();
+    else response = {
+        metadata: err?.metadata || false,
+        message: err?.message || false,
+        stack: err?.stack || false,
+    };
+    
+    Log.Debug(err); 
+    res.status(statusCode).json(response);
+}
+
+
+
+module.exports = {
+    ErrorRenderer
+}

package/middleware/Next.js

@@ -0,0 +1,10 @@
+
+
+
+
+module.exports = { Next: (middleware) => {
+    return async (req,res,next) => {
+        await middleware(req,res);
+        next();
+    }
+}};

package/middleware/OpenReq.js

@@ -0,0 +1,36 @@
+
+function OpenReq(req){
+    return {
+        method: req.method,             // GET, POST, etc.
+        url: req.url,                   // /api/resource
+        originalUrl: req.originalUrl,   // Full URL (preserves route changes from middleware)
+        path: req.path,                 // Just the pathname, no query string
+        query: req.query,               // Parsed query string as an object
+        params: req.params,             // URL route params (e.g., /:id)
+        headers: req.headers,           // Raw headers object
+        ip: req.ip,                     // Client IP
+        ips: req.ips,                   // If using `trust proxy`
+        hostname: req.hostname,         // Hostname of the request
+        protocol: req.protocol,         // http or https
+        secure: req.secure,             // True if HTTPS
+        xhr: req.xhr,                   // True if requested via AJAX
+        body: req.body,                 // Parsed body (requires middleware)
+        cookies: req.cookies,           // Parsed cookies (requires cookie-parser)
+        fresh: req.fresh,               // For caching
+        stale: req.stale,               // Opposite of fresh
+        subdomains: req.subdomains,     // Subdomains in the host
+        route: req.route,               // Current route info (after matching)
+        baseUrl: req.baseUrl,           // URL path on which a router was mounted
+        user: req.user,                 // If using authentication middleware (e.g. Passport)
+    }; 
+}
+
+function AttachReqMeta(req,res,next){
+    req.metadata = OpenReq(req);
+    return next();
+}
+
+module.exports = {
+    OpenReq,
+    AttachReqMeta,
+}

package/middleware/ResData.js

@@ -0,0 +1,8 @@
+
+
+module.exports = { ResData: (middleware) => {
+    return async (req,res,next) => {
+        res.data = await middleware(req,res);
+        next();
+    }
+}};

package/middleware/SendRes.js

@@ -0,0 +1,14 @@
+
+
+
+
+module.exports = { SendRes: (data) => {
+    return async (req,res,next) => {
+        if(typeof data === 'function') data = await data(req,res,next);
+        else if (typeof data === 'undefined') data = res?.data;
+
+        if(typeof data === 'undefined') throw new Error('Could not resolve response data.');
+
+        return res.send(data);
+    }
+}};

package/middleware/Status.js

@@ -0,0 +1,10 @@
+
+
+
+
+module.exports = { Status: (statusCode) => {
+    return async (req,res,next) => {
+        res.status(statusCode);
+        return next();
+    }
+}};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@koziatek/http",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@precision-sustainable-ag/utils": "^1.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/tests/CatchAll.test.js

@@ -0,0 +1,44 @@
+const { CatchAll } = require('../middleware/CatchAll');
+const { HttpStatusCodes } = require('../HttpStatusCodes');
+
+describe('CatchAll middleware', () => {
+  let req, res, next;
+
+  beforeEach(() => {
+    req = {};
+    res = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn()
+    };
+    next = jest.fn();
+  });
+
+  test('should respond with default 501 and default content', () => {
+    const middleware = CatchAll();
+
+    middleware(req, res, next);
+
+    expect(res.status).toHaveBeenCalledWith(HttpStatusCodes.notImplemented);
+    expect(res.send).toHaveBeenCalledWith({
+      error: 'Not Implemented',
+      messages: ['The requested endpoint does not exist.']
+    });
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  test('should respond with custom status and content', () => {
+    const customStatus = 404;
+    const customContent = {
+      error: 'Not Found',
+      messages: ['This page does not exist.']
+    };
+
+    const middleware = CatchAll(customStatus, customContent);
+
+    middleware(req, res, next);
+
+    expect(res.status).toHaveBeenCalledWith(customStatus);
+    expect(res.send).toHaveBeenCalledWith(customContent);
+    expect(next).not.toHaveBeenCalled();
+  });
+});

package/tests/Next.test.js

@@ -0,0 +1,44 @@
+const { Next } = require('../middleware/Next');
+
+describe('Next wrapper middleware', () => {
+  let req, res, next;
+
+  beforeEach(() => {
+    req = {};
+    res = {};
+    next = jest.fn();
+  });
+
+  test('should call the wrapped middleware and then next()', async () => {
+    const mockMiddleware = jest.fn();
+
+    const wrapped = Next(mockMiddleware);
+
+    await wrapped(req, res, next);
+
+    expect(mockMiddleware).toHaveBeenCalledWith(req, res);
+    expect(next).toHaveBeenCalled();
+  });
+
+  test('should await async middleware and then call next()', async () => {
+    const asyncMiddleware = jest.fn().mockResolvedValue();
+
+    const wrapped = Next(asyncMiddleware);
+
+    await wrapped(req, res, next);
+
+    expect(asyncMiddleware).toHaveBeenCalledWith(req, res);
+    expect(next).toHaveBeenCalled();
+  });
+
+  test('should not call next() if middleware throws', async () => {
+    const throwingMiddleware = jest.fn().mockImplementation(() => {
+      throw new Error('Failure');
+    });
+
+    const wrapped = Next(throwingMiddleware);
+
+    await expect(wrapped(req, res, next)).rejects.toThrow('Failure');
+    expect(next).not.toHaveBeenCalled();
+  });
+});

package/tests/OpenReq.test.js

@@ -0,0 +1,90 @@
+const { OpenReq, AttachReqMeta } = require('../middleware/OpenReq.js'); // Adjust path as needed
+
+describe('OpenReq', () => {
+  test('should extract all relevant metadata from request object', () => {
+    const mockReq = {
+      method: 'POST',
+      url: '/api/test',
+      originalUrl: '/api/test?query=true',
+      path: '/api/test',
+      query: { query: 'true' },
+      params: { id: '123' },
+      headers: { 'x-custom-header': 'value' },
+      ip: '127.0.0.1',
+      ips: ['127.0.0.1'],
+      hostname: 'localhost',
+      protocol: 'https',
+      secure: true,
+      xhr: true,
+      body: { name: 'test' },
+      cookies: { session: 'abc123' },
+      fresh: true,
+      stale: false,
+      subdomains: ['api'],
+      route: { path: '/test/:id' },
+      baseUrl: '/api',
+      user: { id: 1, role: 'admin' }
+    };
+
+    const result = OpenReq(mockReq);
+
+    expect(result).toEqual({
+      method: 'POST',
+      url: '/api/test',
+      originalUrl: '/api/test?query=true',
+      path: '/api/test',
+      query: { query: 'true' },
+      params: { id: '123' },
+      headers: { 'x-custom-header': 'value' },
+      ip: '127.0.0.1',
+      ips: ['127.0.0.1'],
+      hostname: 'localhost',
+      protocol: 'https',
+      secure: true,
+      xhr: true,
+      body: { name: 'test' },
+      cookies: { session: 'abc123' },
+      fresh: true,
+      stale: false,
+      subdomains: ['api'],
+      route: { path: '/test/:id' },
+      baseUrl: '/api',
+      user: { id: 1, role: 'admin' }
+    });
+  });
+});
+
+describe('AttachReqMeta middleware', () => {
+  test('should attach metadata to req and call next()', () => {
+    const req = {
+      method: 'GET',
+      url: '/',
+      originalUrl: '/',
+      path: '/',
+      query: {},
+      params: {},
+      headers: {},
+      ip: '127.0.0.1',
+      ips: [],
+      hostname: 'localhost',
+      protocol: 'http',
+      secure: false,
+      xhr: false,
+      body: {},
+      cookies: {},
+      fresh: false,
+      stale: true,
+      subdomains: [],
+      route: {},
+      baseUrl: '',
+      user: null
+    };
+    const res = {};
+    const next = jest.fn();
+
+    AttachReqMeta(req, res, next);
+
+    expect(req.metadata).toEqual(OpenReq(req));
+    expect(next).toHaveBeenCalled();
+  });
+});

package/tests/ResData.test.js

@@ -0,0 +1,43 @@
+const { ResData } = require('../middleware/ResData'); // Adjust the path as needed
+
+describe('ResData wrapper middleware', () => {
+  let req, res, next;
+
+  beforeEach(() => {
+    req = {};
+    res = {};
+    next = jest.fn();
+  });
+
+  test('should await middleware and assign result to res.data, then call next()', async () => {
+    const mockMiddleware = jest.fn().mockResolvedValue({ key: 'value' });
+
+    const wrapped = ResData(mockMiddleware);
+
+    await wrapped(req, res, next);
+
+    expect(mockMiddleware).toHaveBeenCalledWith(req, res);
+    expect(res.data).toEqual({ key: 'value' });
+    expect(next).toHaveBeenCalled();
+  });
+
+  test('should handle async middleware that returns undefined', async () => {
+    const mockMiddleware = jest.fn().mockResolvedValue(undefined);
+
+    const wrapped = ResData(mockMiddleware);
+
+    await wrapped(req, res, next);
+
+    expect(res.data).toBeUndefined();
+    expect(next).toHaveBeenCalled();
+  });
+
+  test('should not call next() if middleware throws', async () => {
+    const mockMiddleware = jest.fn().mockRejectedValue(new Error('Failure'));
+
+    const wrapped = ResData(mockMiddleware);
+
+    await expect(wrapped(req, res, next)).rejects.toThrow('Failure');
+    expect(next).not.toHaveBeenCalled();
+  });
+});

package/tests/SendRes.test.js

@@ -0,0 +1,52 @@
+const { SendRes } = require('../middleware/SendRes.js'); // Adjust path as needed
+
+describe('SendRes middleware', () => {
+  let req, res, next;
+
+  beforeEach(() => {
+    req = {};
+    res = {
+      data: undefined,
+      send: jest.fn()
+    };
+    next = jest.fn();
+  });
+
+  test('should send data if data is a value', async () => {
+    const value = { hello: 'world' };
+
+    const middleware = SendRes(value);
+
+    await middleware(req, res, next);
+
+    expect(res.send).toHaveBeenCalledWith(value);
+  });
+
+  test('should call function and send result if data is a function', async () => {
+    const mockFn = jest.fn().mockResolvedValue({ message: 'from fn' });
+
+    const middleware = SendRes(mockFn);
+
+    await middleware(req, res, next);
+
+    expect(mockFn).toHaveBeenCalledWith(req, res, next);
+    expect(res.send).toHaveBeenCalledWith({ message: 'from fn' });
+  });
+
+  test('should use res.data if data is undefined', async () => {
+    res.data = { default: 'response' };
+
+    const middleware = SendRes(undefined);
+
+    await middleware(req, res, next);
+
+    expect(res.send).toHaveBeenCalledWith(res.data);
+  });
+
+  test('should throw error if no data is resolved', async () => {
+    const middleware = SendRes(undefined);
+
+    await expect(middleware(req, res, next)).rejects.toThrow('Could not resolve response data.');
+    expect(res.send).not.toHaveBeenCalled();
+  });
+});

package/tests/Status.test.js

@@ -0,0 +1,31 @@
+const { Status } = require('../middleware/Status.js'); // Adjust path as needed
+
+describe('Status middleware', () => {
+  let req, res, next;
+
+  beforeEach(() => {
+    req = {};
+    res = {
+      status: jest.fn()
+    };
+    next = jest.fn();
+  });
+
+  test('should set the given status code and call next()', async () => {
+    const middleware = Status(418); // I'm a teapot ☕
+
+    await middleware(req, res, next);
+
+    expect(res.status).toHaveBeenCalledWith(418);
+    expect(next).toHaveBeenCalled();
+  });
+
+  test('should work with standard HTTP status codes', async () => {
+    const middleware = Status(200);
+
+    await middleware(req, res, next);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(next).toHaveBeenCalled();
+  });
+});