@ublitzjs/core 0.1.1 → 1.0.0

package/dist/cjs/http-codes.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.badRequest = badRequest;
+exports.c413 = exports.c411 = exports.c405 = exports.c404 = exports.c400 = void 0;
+exports.checkContentLength = checkContentLength;
+exports.notFoundConstructor = notFoundConstructor;
+exports.seeOtherMethods = seeOtherMethods;
+exports.tooLargeBody = tooLargeBody;
+var _index = require("./index.js");
+var c405Message = (0, _index.toAB)("Method is not allowed");
+var allowHeader = (0, _index.toAB)("Allow");
+var checkHeader = (0, _index.toAB)("content-length");
+var checkMessage = (0, _index.toAB)("Content-Length is required to be > 0 and to be an integer");
+/**
+ * If something wrong is to content-length, sends 411 code and throws error with a "cause" == { CL : string}, sets res.finished = true
+ */
+function checkContentLength(res, req) {
+  var header = req.getHeader(checkHeader);
+  var CL;
+  if (!header || !Number.isInteger(CL = Number(header))) {
+    res.finished = true;
+    res.cork(() => res.writeStatus(c411).end(checkMessage));
+    throw new Error("Wrong content-length", {
+      cause: {
+        CL: header
+      }
+    });
+  }
+  return CL;
+}
+/**
+ * sends http 400 and throws an Error with "causeForYou", sets res.finished = true
+ */
+function badRequest(res, error, causeForYou) {
+  res.finished = true;
+  if (!res.aborted) res.cork(() => res.writeStatus(c400).end((0, _index.toAB)(error)));
+  throw new Error("Bad request", {
+    cause: causeForYou
+  });
+}
+/**
+ * sends http 413, but doesn't throw an Error, sets res.finished = true
+ */
+function tooLargeBody(res, limit) {
+  var message = (0, _index.toAB)("Body is too large. Limit in bytes - " + limit);
+  if (!res.aborted) res.cork(() => res.writeStatus(c413).end(message));
+  res.finished = true;
+}
+/**
+ * Constructs function, which sends http 405 and sets http Allow header with all methods you passed.
+ * It ignores "ws" and replaces "del" on "DELETE"
+ */
+function seeOtherMethods(methodsArr) {
+  if (new Set(methodsArr).size != methodsArr.length) throw new Error("the methods repeat");
+  var arr = [];
+  loop: for (var method of methodsArr) {
+    switch (method) {
+      case "ws":
+        continue loop;
+      case "del":
+        arr.push("DELETE");
+        break;
+      default:
+        arr.push(method.toUpperCase());
+    }
+  }
+  var methods = (0, _index.toAB)(arr.join(", "));
+  return res => res.writeStatus(c405).writeHeader(allowHeader, methods).end(c405Message);
+}
+/**
+ * Constructs the function, which sets 404 http code and sends the message you have specified
+ */
+function notFoundConstructor(message = "Not found") {
+  var mes = (0, _index.toAB)(message);
+  return res => res.writeStatus(c404).end(mes, true);
+}
+/**
+ * code: required content length
+ */
+var c411 = exports.c411 = (0, _index.toAB)("411");
+/**
+ * code: bad request
+ */
+var c400 = exports.c400 = (0, _index.toAB)("400");
+/**
+ * code: payload too large
+ */
+var c413 = exports.c413 = (0, _index.toAB)("413");
+/**
+ * code: method not allowed
+ */
+var c405 = exports.c405 = (0, _index.toAB)("405");
+/**
+ * code: not found
+ */
+var c404 = exports.c404 = (0, _index.toAB)("404");

package/dist/cjs/http-headers.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeadersMap = exports.CSPDirs = void 0;
+exports.setCSP = setCSP;
+var _index = require("./index.js");
+var helmetHeaders = {
+  "X-Content-Type-Options": "nosniff",
+  "X-DNS-Prefetch-Control": "off",
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "same-origin",
+  "X-Permitted-Cross-Domain-Policies": "none",
+  "X-Download-Options": "noopen",
+  "Cross-Origin-Resource-Policy": "same-origin",
+  "Cross-Origin-Opener-Policy": "same-origin",
+  "Cross-Origin-Embedder-Policy": "require-corp",
+  "Origin-Agent-Cluster": "?1"
+  //"Content-Security-Policy-Report-Only":"",
+  //"Strict-Transport-Security":`max-age=${60 * 60 * 24 * 365}; includeSubDomains`,
+};
+/**
+ * A map containing all headers as ArrayBuffers, so speed remains. There are several use cases of it:
+ * 1) Don't define them in requests ( post(res){new HeadersMap({...headers}).prepare().toRes(res)} ). This is slow. Define maps BEFORE actual usage.
+ * 2) You can pass them in LightMethod or HeavyMethod in shared property (but handle it manually)
+ * 3) Don't define them before writing status on request. uWebSockets.js after first written header considers response as successful and puts "200" code automatically. Set headers AFTER validation in class controllers (handler function) and after writing status (or don't write it at all. It will be 200).
+ */
+class HeadersMap extends Map {
+  currentHeaders;
+  constructor(opts) {
+    super();
+    this.currentHeaders = opts;
+  }
+  /**
+   * remove several headers from this map. Use BEFORE map.prepare(), because it will compare them by location in memory (string !== ArrayBuffer)
+   * @example HeadersMap.default.remove("Content-Security-Policy", "X-DNS-Prefetch-Control", ...otherHeaders).prepare()
+   */
+  remove(...keys) {
+    for (const key of keys) delete this.currentHeaders[key];
+    return this;
+  }
+  /**
+   * last function before "going to response". It converts all strings to ArrayBuffers, so you should delete unwanted headers before it
+   * @returns function, which sets all headers on the response.
+   * @example
+   * new HeadersMap({...HeadersMap.baseObj,"a":"a"}).remove("a").prepare();
+   */
+  prepare() {
+    for (const key in this.currentHeaders) this.set((0, _index.toAB)(key), (0, _index.toAB)(this.currentHeaders[key]));
+    delete this.currentHeaders;
+    return res => {
+      for (var pair of this) res.writeHeader(pair[0], pair[1]);
+      return res;
+    };
+  }
+  /**
+   * write all static headers to response. Use BEFORE map.prepare function, because this function requires "currentHeaders" object.
+   * @example
+   * headersMap.toRes(res);
+   */
+  toRes(res) {
+    var key;
+    for (key in this.currentHeaders) res.writeHeader(key, this.currentHeaders[key]);
+    return res;
+  }
+  /**
+   * obj, containing basic headers, which u can use as a background for own headers. It is mutable, but doing so will modify "HeadersMap.default" behavior
+   * @example
+   * new HeadersMap({...HeadersMap.baseObj, "ownHeader":"hello world"}).remove("X-Download-Options")
+   */
+  static baseObj = helmetHeaders;
+  /**
+   * this is same as "toRes", but it uses HeadersMap.baseObj
+   */
+  static default(res) {
+    var key;
+    for (key in HeadersMap.baseObj) res.writeHeader(key, HeadersMap.baseObj[key]);
+    return res;
+  }
+}
+/**
+ * This function creates Content-Security-Policy string.
+ */
+exports.HeadersMap = HeadersMap;
+function setCSP(mainCSP, ...remove) {
+  var CSPstring = "";
+  for (const dir of remove) delete mainCSP[dir];
+  var key;
+  for (key in mainCSP) CSPstring += key + " " + mainCSP[key].join(" ") + "; ";
+  return CSPstring;
+}
+/**
+ * Usual CSP directories. If you want more dirs:
+ * 1) I will put more in soon
+ * 2) use string concatenation (use BASE)
+ * @example
+ * new HeadersMap({...HeadersMap.baseObj, "Content-Security-Policy":setCSP({...CSPDirs}) + " your-dir: 'self';"})
+ */
+var CSPDirs = exports.CSPDirs = {
+  "default-src": ["'self'"],
+  "base-uri": ["'self'"],
+  "font-src": ["'self'"],
+  "form-action": ["'self'"],
+  "frame-ancestors": ["'none'"],
+  "img-src": ["'self'"],
+  "connect-src": ["'self'"],
+  "object-src": ["'none'"],
+  "script-src": ["'self'"],
+  "script-src-attr": ["'none'"],
+  "script-src-elem": ["'self'"],
+  "style-src": ["'self'"],
+  "style-src-attr": ["'none'"],
+  "style-src-elem": ["'self'"],
+  "trusted-types": ["'none'"],
+  "worker-src": ["'self'"],
+  "media-src": ["'self'"]
+};

package/dist/cjs/index.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  registerAbort: true,
+  closure: true,
+  extendApp: true,
+  toAB: true,
+  DeclarativeResponse: true
+};
+exports.closure = exports.DeclarativeResponse = void 0;
+exports.extendApp = extendApp;
+exports.registerAbort = registerAbort;
+exports.toAB = toAB;
+var _uWebSockets = require("uWebSockets.js");
+var _nodeBuffer = require("node:buffer");
+var _tseep = require("tseep");
+var _httpCodes = require("./http-codes.js");
+Object.keys(_httpCodes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _httpCodes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _httpCodes[key];
+    }
+  });
+});
+var _httpHeaders = require("./http-headers.js");
+Object.keys(_httpHeaders).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _httpHeaders[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _httpHeaders[key];
+    }
+  });
+});
+_uWebSockets.DeclarativeResponse.prototype.writeHeaders = function (headers) {
+  for (const key in headers) this.writeHeader(key, headers[key]);
+  return this;
+};
+/**
+ * function to effortlessly mark response as aborted AND to attach an event emitter, so that you can easily scale the handler. If you don't need event emitter and only some res.aborted - set it by yourself (no overkill for the handler)
+ * @param res
+ */
+function registerAbort(res) {
+  if (typeof res.aborted === "boolean") throw new Error("abort already registered");
+  res.aborted = false;
+  res.emitter = new _tseep.EventEmitter();
+  return res.onAborted(() => {
+    res.aborted = true;
+    res.emitter.emit("abort");
+  });
+}
+;
+/**
+ * Utility for making closures. Exists for organizing code and caching values in non-global scope.
+ * @param param
+ * @returns what you passed
+ */
+var closure = param => param();
+/**
+ * extends uWS.App() or uWS.SSLApp. See interface Server
+ * @param app uWS.App()
+ */
+exports.closure = closure;
+function extendApp(app, ...rest) {
+  app.register = function (plugin) {
+    return plugin(this), this;
+  };
+  app.onError = function (fn) {
+    return this._errHandler = fn, this;
+  };
+  app._startPromises = [];
+  app.awaitLater = function () {
+    this._startPromises.push(...arguments);
+  };
+  app.ready = function () {
+    return Promise.all(this._startPromises).then(() => this._startPromises = []);
+  };
+  app.route = function (opts, plugins) {
+    if (plugins) for (const p of plugins) p(opts, this);
+    return this[opts.method](opts.path, opts.controller);
+  };
+  for (const extension of rest) Object.assign(app, extension);
+  return app;
+}
+/**
+ * conversion to ArrayBuffer ('cause transferring strings to uWS is really slow)
+ */
+function toAB(data) {
+  var NodeBuf = data instanceof _nodeBuffer.Buffer ? data : _nodeBuffer.Buffer.from(data);
+  return NodeBuf.buffer.slice(NodeBuf.byteOffset, NodeBuf.byteOffset + NodeBuf.byteLength);
+}
+/**
+ * Almost nothing different from uWS.DeclarativeResponse. The only modification - writeHeaders method (several methods, typescript intellisense)
+ */
+var DeclarativeResponse = exports.DeclarativeResponse = _uWebSockets.DeclarativeResponse;

package/dist/esm/http-codes.js

@@ -0,0 +1,84 @@
+"use strict";
+import { toAB } from "./index.js";
+var c405Message = toAB("Method is not allowed");
+var allowHeader = toAB("Allow");
+var checkHeader = toAB("content-length");
+var checkMessage = toAB("Content-Length is required to be > 0 and to be an integer");
+/**
+ * If something wrong is to content-length, sends 411 code and throws error with a "cause" == { CL : string}, sets res.finished = true
+ */
+export function checkContentLength(res, req) {
+    var header = req.getHeader(checkHeader);
+    var CL;
+    if (!header || !Number.isInteger(CL = Number(header))) {
+        res.finished = true;
+        res.cork(() => res.writeStatus(c411).end(checkMessage));
+        throw new Error("Wrong content-length", { cause: { CL: header } });
+    }
+    return CL;
+}
+/**
+ * sends http 400 and throws an Error with "causeForYou", sets res.finished = true
+ */
+export function badRequest(res, error, causeForYou) {
+    res.finished = true;
+    if (!res.aborted)
+        res.cork(() => res.writeStatus(c400).end(toAB(error)));
+    throw new Error("Bad request", { cause: causeForYou });
+}
+/**
+ * sends http 413, but doesn't throw an Error, sets res.finished = true
+ */
+export function tooLargeBody(res, limit) {
+    var message = toAB("Body is too large. Limit in bytes - " + limit);
+    if (!res.aborted)
+        res.cork(() => res.writeStatus(c413).end(message));
+    res.finished = true;
+}
+/**
+ * Constructs function, which sends http 405 and sets http Allow header with all methods you passed.
+ * It ignores "ws" and replaces "del" on "DELETE"
+ */
+export function seeOtherMethods(methodsArr) {
+    if (new Set(methodsArr).size != methodsArr.length)
+        throw new Error("the methods repeat");
+    var arr = [];
+    loop: for (var method of methodsArr) {
+        switch (method) {
+            case "ws": continue loop;
+            case "del":
+                arr.push("DELETE");
+                break;
+            default: arr.push(method.toUpperCase());
+        }
+    }
+    var methods = toAB(arr.join(", "));
+    return (res) => res.writeStatus(c405).writeHeader(allowHeader, methods).end(c405Message);
+}
+/**
+ * Constructs the function, which sets 404 http code and sends the message you have specified
+ */
+export function notFoundConstructor(message = "Not found") {
+    var mes = toAB(message);
+    return (res) => res.writeStatus(c404).end(mes, true);
+}
+/**
+ * code: required content length
+ */
+export var c411 = toAB("411");
+/**
+ * code: bad request
+ */
+export var c400 = toAB("400");
+/**
+ * code: payload too large
+ */
+export var c413 = toAB("413");
+/**
+ * code: method not allowed
+ */
+export var c405 = toAB("405");
+/**
+ * code: not found
+ */
+export var c404 = toAB("404");

package/dist/esm/http-headers.js

@@ -0,0 +1,119 @@
+"use strict";
+import { toAB } from "./index.js";
+var helmetHeaders = {
+    "X-Content-Type-Options": "nosniff",
+    "X-DNS-Prefetch-Control": "off",
+    "X-Frame-Options": "DENY",
+    "Referrer-Policy": "same-origin",
+    "X-Permitted-Cross-Domain-Policies": "none",
+    "X-Download-Options": "noopen",
+    "Cross-Origin-Resource-Policy": "same-origin",
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Embedder-Policy": "require-corp",
+    "Origin-Agent-Cluster": "?1",
+    //"Content-Security-Policy-Report-Only":"",
+    //"Strict-Transport-Security":`max-age=${60 * 60 * 24 * 365}; includeSubDomains`,
+};
+/**
+ * A map containing all headers as ArrayBuffers, so speed remains. There are several use cases of it:
+ * 1) Don't define them in requests ( post(res){new HeadersMap({...headers}).prepare().toRes(res)} ). This is slow. Define maps BEFORE actual usage.
+ * 2) You can pass them in LightMethod or HeavyMethod in shared property (but handle it manually)
+ * 3) Don't define them before writing status on request. uWebSockets.js after first written header considers response as successful and puts "200" code automatically. Set headers AFTER validation in class controllers (handler function) and after writing status (or don't write it at all. It will be 200).
+ */
+export class HeadersMap extends Map {
+    currentHeaders;
+    constructor(opts) {
+        super();
+        this.currentHeaders = opts;
+    }
+    ;
+    /**
+     * remove several headers from this map. Use BEFORE map.prepare(), because it will compare them by location in memory (string !== ArrayBuffer)
+     * @example HeadersMap.default.remove("Content-Security-Policy", "X-DNS-Prefetch-Control", ...otherHeaders).prepare()
+     */
+    remove(...keys) {
+        for (const key of keys)
+            delete this.currentHeaders[key];
+        return this;
+    }
+    /**
+     * last function before "going to response". It converts all strings to ArrayBuffers, so you should delete unwanted headers before it
+     * @returns function, which sets all headers on the response.
+     * @example
+     * new HeadersMap({...HeadersMap.baseObj,"a":"a"}).remove("a").prepare();
+     */
+    prepare() {
+        for (const key in this.currentHeaders)
+            this.set(toAB(key), toAB(this.currentHeaders[key]));
+        delete this.currentHeaders;
+        return (res) => {
+            for (var pair of this)
+                res.writeHeader(pair[0], pair[1]);
+            return res;
+        };
+    }
+    /**
+     * write all static headers to response. Use BEFORE map.prepare function, because this function requires "currentHeaders" object.
+     * @example
+     * headersMap.toRes(res);
+     */
+    toRes(res) {
+        var key;
+        for (key in this.currentHeaders)
+            res.writeHeader(key, this.currentHeaders[key]);
+        return res;
+    }
+    /**
+     * obj, containing basic headers, which u can use as a background for own headers. It is mutable, but doing so will modify "HeadersMap.default" behavior
+     * @example
+     * new HeadersMap({...HeadersMap.baseObj, "ownHeader":"hello world"}).remove("X-Download-Options")
+     */
+    static baseObj = helmetHeaders;
+    /**
+     * this is same as "toRes", but it uses HeadersMap.baseObj
+     */
+    static default(res) {
+        var key;
+        for (key in HeadersMap.baseObj)
+            res.writeHeader(key, HeadersMap.baseObj[key]);
+        return res;
+    }
+}
+/**
+ * This function creates Content-Security-Policy string.
+ */
+export function setCSP(mainCSP, ...remove) {
+    var CSPstring = "";
+    for (const dir of remove)
+        delete mainCSP[dir];
+    var key;
+    for (key in mainCSP)
+        CSPstring += key + " " + mainCSP[key].join(" ") + "; ";
+    return CSPstring;
+}
+/**
+ * Usual CSP directories. If you want more dirs:
+ * 1) I will put more in soon
+ * 2) use string concatenation (use BASE)
+ * @example
+ * new HeadersMap({...HeadersMap.baseObj, "Content-Security-Policy":setCSP({...CSPDirs}) + " your-dir: 'self';"})
+ */
+export var CSPDirs = {
+    "default-src": ["'self'"],
+    "base-uri": ["'self'"],
+    "font-src": ["'self'"],
+    "form-action": ["'self'"],
+    "frame-ancestors": ["'none'"],
+    "img-src": ["'self'"],
+    "connect-src": ["'self'"],
+    "object-src": ["'none'"],
+    "script-src": ["'self'"],
+    "script-src-attr": ["'none'"],
+    "script-src-elem": ["'self'"],
+    "style-src": ["'self'"],
+    "style-src-attr": ["'none'"],
+    "style-src-elem": ["'self'"],
+    "trusted-types": ["'none'"],
+    "worker-src": ["'self'"],
+    "media-src": ["'self'"],
+};

package/dist/esm/index.js

@@ -0,0 +1,71 @@
+"use strict";
+import uWS from "uWebSockets.js";
+import { Buffer } from "node:buffer";
+import { EventEmitter } from "tseep";
+uWS.DeclarativeResponse.prototype.writeHeaders = function (headers) {
+    for (const key in headers)
+        this.writeHeader(key, headers[key]);
+    return this;
+};
+/**
+ * function to effortlessly mark response as aborted AND to attach an event emitter, so that you can easily scale the handler. If you don't need event emitter and only some res.aborted - set it by yourself (no overkill for the handler)
+ * @param res
+ */
+export function registerAbort(res) {
+    if (typeof res.aborted === "boolean")
+        throw new Error("abort already registered");
+    res.aborted = false;
+    res.emitter = new EventEmitter();
+    return res.onAborted(() => {
+        res.aborted = true;
+        res.emitter.emit("abort");
+    });
+}
+;
+/**
+ * Utility for making closures. Exists for organizing code and caching values in non-global scope.
+ * @param param
+ * @returns what you passed
+ */
+export var closure = (param) => param();
+/**
+ * extends uWS.App() or uWS.SSLApp. See interface Server
+ * @param app uWS.App()
+ */
+export function extendApp(app, ...rest) {
+    app.register = function (plugin) {
+        return plugin(this), this;
+    };
+    app.onError = function (fn) {
+        return (this._errHandler = fn), this;
+    };
+    app._startPromises = [];
+    app.awaitLater = function () {
+        this._startPromises.push(...arguments);
+    };
+    app.ready = function () {
+        return Promise.all(this._startPromises).then(() => (this._startPromises = []));
+    };
+    app.route = function (opts, plugins) {
+        if (plugins)
+            for (const p of plugins)
+                p(opts, this);
+        return this[opts.method](opts.path, opts.controller);
+    };
+    for (const extension of rest)
+        Object.assign(app, extension);
+    return app;
+}
+/**
+ * conversion to ArrayBuffer ('cause transferring strings to uWS is really slow)
+ */
+export function toAB(data) {
+    var NodeBuf = data instanceof Buffer ? data : Buffer.from(data);
+    return NodeBuf.buffer.slice(NodeBuf.byteOffset, NodeBuf.byteOffset + NodeBuf.byteLength);
+}
+/**
+ * Almost nothing different from uWS.DeclarativeResponse. The only modification - writeHeaders method (several methods, typescript intellisense)
+ */
+export var DeclarativeResponse = uWS.DeclarativeResponse;
+export * from "./http-codes.js";
+export * from "./http-headers.js";

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/dist/types/http-codes.d.ts

@@ -0,0 +1,43 @@
+import type { HttpResponse as uwsHttpResponse } from "uWebSockets.js";
+import type { HttpRequest, HttpMethods } from "./index.ts";
+/**
+ * If something wrong is to content-length, sends 411 code and throws error with a "cause" == { CL : string}, sets res.finished = true
+ */
+export declare function checkContentLength(res: uwsHttpResponse, req: HttpRequest): number;
+/**
+ * sends http 400 and throws an Error with "causeForYou", sets res.finished = true
+ */
+export declare function badRequest(res: uwsHttpResponse, error: string, causeForYou: string): void;
+/**
+ * sends http 413, but doesn't throw an Error, sets res.finished = true
+ */
+export declare function tooLargeBody(res: uwsHttpResponse, limit: number): void;
+/**
+ * Constructs function, which sends http 405 and sets http Allow header with all methods you passed.
+ * It ignores "ws" and replaces "del" on "DELETE"
+ */
+export declare function seeOtherMethods(methodsArr: HttpMethods[]): (res: uwsHttpResponse, req: any) => any;
+/**
+ * Constructs the function, which sets 404 http code and sends the message you have specified
+ */
+export declare function notFoundConstructor(message?: string): (res: uwsHttpResponse, req: any) => any;
+/**
+ * code: required content length
+ */
+export declare var c411: ArrayBuffer;
+/**
+ * code: bad request
+ */
+export declare var c400: ArrayBuffer;
+/**
+ * code: payload too large
+ */
+export declare var c413: ArrayBuffer;
+/**
+ * code: method not allowed
+ */
+export declare var c405: ArrayBuffer;
+/**
+ * code: not found
+ */
+export declare var c404: ArrayBuffer;