te.js 1.0.0 → 1.0.2

package/server/ammo.js

@@ -1,95 +1,96 @@
-import { statusAndData } from './ammo/dispatch-helper.js';
-import {
-  isStatusCode,
-  toStatusCode,
-  toStatusMessage,
-} from '../utils/status-codes.js';
-import html from '../utils/tejas-entrypoint-html.js';
-import ammoEnhancer from './ammo/enhancer.js';
-
-class Ammo {
-  constructor(req, res) {
-    this.req = req;
-    this.res = res;
-
-    // Request related data
-    this.ip = undefined;
-    this.headers = undefined;
-    this.payload = undefined;
-    this.method = undefined;
-
-    // URL related data
-    this.protocol = undefined;
-    this.hostname = undefined;
-    this.path = undefined;
-    this.endpoint = undefined;
-
-    this.fullURL = undefined;
-
-    // Response related data
-    this.dispatchedData = undefined;
-  }
-
-  async enhance() {
-    await ammoEnhancer(this);
-  }
-
-  dispatch() {
-    const { statusCode, data, contentType } = statusAndData(arguments);
-    const contentTypeHeader = { 'Content-Type': contentType };
-
-    this.dispatchedData = data;
-
-    this.res.writeHead(statusCode, contentTypeHeader);
-    this.res.write(data ?? '');
-    this.res.end();
-  }
-
-  notFound() {
-    this.throw(new Error('Not Found'));
-  }
-
-  notAllowed() {
-    this.throw(new Error('Method Not Allowed'));
-  }
-
-  unauthorized() {
-    this.throw(new Error('Unauthorized'));
-  }
-
-  defaultEntry() {
-    this.dispatch(html);
-  }
-
-  throw() {
-    const err = arguments[0];
-    const errCode = arguments[1];
-
-    let errMsg = err instanceof Error ? err.message : err.toString();
-
-    if (errCode && isStatusCode(errCode)) {
-      if (!errMsg) errMsg = toStatusMessage(errCode);
-      this.dispatch(errCode, errMsg);
-      return;
-    }
-
-    if (err instanceof Error) {
-      const errMessage = err.message;
-
-      if (!isNaN(parseInt(errMessage))) {
-        // Execute when errMessage is a number. Notice ! in front of isNan
-        const message = toStatusMessage(errMessage) ?? toStatusMessage(500);
-        this.dispatch(message, message);
-        return;
-      }
-
-      const code = toStatusCode(errMsg) ?? 500;
-      this.dispatch(code, errMsg);
-      return;
-    }
-
-    this.dispatch(err);
-  }
-}
-
-export default Ammo;
+import { statusAndData } from './ammo/dispatch-helper.js';
+import {
+  isStatusCode,
+  toStatusCode,
+  toStatusMessage,
+} from '../utils/status-codes.js';
+import html from '../utils/tejas-entrypoint-html.js';
+import ammoEnhancer from './ammo/enhancer.js';
+import TejError from './error.js';
+
+class Ammo {
+  constructor(req, res) {
+    this.req = req;
+    this.res = res;
+
+    // Request related data
+    this.ip = undefined;
+    this.headers = undefined;
+    this.payload = undefined;
+    this.method = undefined;
+
+    // URL related data
+    this.protocol = undefined;
+    this.hostname = undefined;
+    this.path = undefined;
+    this.endpoint = undefined;
+
+    this.fullURL = undefined;
+
+    // Response related data
+    this.dispatchedData = undefined;
+  }
+
+  async enhance() {
+    await ammoEnhancer(this);
+  }
+
+  fire() {
+    const { statusCode, data, contentType } = statusAndData(arguments);
+    const contentTypeHeader = { 'Content-Type': contentType };
+
+    this.dispatchedData = data;
+
+    this.res.writeHead(statusCode, contentTypeHeader);
+    this.res.write(data ?? '');
+    this.res.end();
+  }
+
+  notFound() {
+    this.throw(new Error('Not Found'));
+  }
+
+  notAllowed() {
+    this.throw(new Error('Method Not Allowed'));
+  }
+
+  unauthorized() {
+    throw new TejError(401, 'Unauthorized');
+  }
+
+  defaultEntry() {
+    this.fire(html);
+  }
+
+  throw() {
+    const errCode = arguments[0];
+    const err = arguments[1];
+
+    let errMsg = err instanceof Error ? err.message : err.toString();
+
+    if (errCode && isStatusCode(errCode)) {
+      if (!errMsg) errMsg = toStatusMessage(errCode);
+      this.fire(errCode, errMsg);
+      return;
+    }
+
+    if (err instanceof Error) {
+      const errMessage = err.message;
+
+      if (!isNaN(parseInt(errMessage))) {
+        // Execute when errMessage is a number. Notice ! in front of isNan
+        const message = toStatusMessage(errMessage) ?? toStatusMessage(500);
+        this.fire(message, message);
+        return;
+      }
+
+      const code = toStatusCode(errMsg) ?? 500;
+      this.fire(code, errMsg);
+      return;
+    }
+
+    this.fire(err);
+  }
+}
+
+export default Ammo;

package/server/error.js

@@ -0,0 +1,9 @@
+class TejError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+  }
+}
+
+export default TejError;

package/server/files/helper.js

@@ -0,0 +1,33 @@
+import mime from 'mime';
+
+const paths = (destination, filename) => {
+  const dir = `${process.cwd()}\\${destination}`;
+  const path = `${dir}\\${filename}`;
+
+  const absolute = path;
+  const relative = path.replace(process.cwd(), '');
+
+  return { dir, absolute, relative };
+};
+
+const extAndType = (obj) => {
+  const contentType = obj.headers['content-type'];
+  const ext = mime.getExtension(contentType);
+  const type = mime.getType(ext);
+  return {
+    ext,
+    type,
+  };
+};
+
+const extract = (contentDisposition, key) => {
+  if (!contentDisposition) {
+    return null;
+  }
+
+  const parts = contentDisposition.split(';').map((part) => part.trim());
+  const part = parts.find((part) => part.startsWith(key));
+  return part ? part?.split('=')[1]?.trim()?.replace(/"/g, '') : undefined;
+};
+
+export { extAndType, extract, paths };

package/server/files/uploader.js

@@ -0,0 +1,142 @@
+import { filesize } from 'filesize';
+import fs from 'fs';
+import TejError from './../error.js';
+import { extAndType, extract, paths } from './helper.js';
+
+class TejFileUploader {
+  /*
+   * @param {Object} options
+   * @param {string} options.destination - Destination to upload file to
+   * @param {string} options.name - Name of the file
+   * @param {number} options.maxFileSize - Maximum file size in bytes
+   */
+  constructor(options = {}) {
+    this.destination = options.destination;
+    this.name = options.name;
+    this.maxFileSize = options.maxFileSize;
+  }
+
+  file() {
+    const keys = [...arguments];
+    return async (ammo, next) => {
+      if (!ammo.headers['content-type'].startsWith('multipart/form-data'))
+        return next();
+
+      const payload = ammo.payload;
+      const updatedPayload = {};
+
+      for (const part in payload) {
+        const obj = payload[part];
+        const contentDisposition = obj.headers['content-disposition'];
+
+        const { ext, type } = extAndType(obj);
+        if (!ext) continue;
+
+        const key = extract(contentDisposition, 'name');
+        if (ext === 'txt') {
+          updatedPayload[key] = obj.value;
+        } else {
+          if (!keys.includes(key)) continue;
+
+          const filename = extract(contentDisposition, 'filename');
+          if (!filename) continue;
+
+          const { dir, absolute, relative } = paths(this.destination, filename);
+          const size = filesize(obj.value.length,
+            { output: 'object', round: 0 });
+          const maxSize = filesize(this.maxFileSize,
+            { output: 'object', round: 0 });
+          if (this.maxFileSize && obj.value.length > this.maxFileSize)
+            throw new TejError(413,
+              `File size exceeds ${maxSize.value} ${maxSize.symbol}`);
+
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          fs.writeFileSync(absolute, obj.value, 'binary');
+
+          updatedPayload[key] = {
+            filename,
+            extension: ext,
+            path: {
+              absolute: absolute,
+              relative: relative
+            },
+            mimetype: type,
+            size
+          };
+        }
+      }
+
+      ammo.payload = updatedPayload;
+      next();
+    };
+  }
+
+  files() {
+    const keys = [...arguments];
+    return async (ammo, next) => {
+      if (!ammo.headers['content-type'].startsWith('multipart/form-data'))
+        return next();
+
+      const payload = ammo.payload;
+      const updatedPayload = {};
+      const files = [];
+
+      for (const part in payload) {
+        const obj = payload[part];
+        const contentDisposition = obj.headers['content-disposition'];
+
+        const { ext, type } = extAndType(obj);
+        if (!ext) continue;
+
+        const key = extract(contentDisposition, 'name');
+        if (ext === 'txt') {
+          updatedPayload[key] = obj.value;
+        } else {
+          if (!keys.includes(key)) continue;
+
+          const filename = extract(contentDisposition, 'filename');
+          if (!filename) continue;
+
+          const { dir, absolute, relative } = paths(this.destination, filename);
+          const size = filesize(obj.value.length,
+            { output: 'object', round: 0 });
+          const maxSize = filesize(this.maxFileSize,
+            { output: 'object', round: 0 });
+          if (this.maxFileSize && obj.value.length > this.maxFileSize) {
+            throw new TejError(413,
+              `File size exceeds ${maxSize.value} ${maxSize.symbol}`);
+          }
+
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          fs.writeFileSync(absolute, obj.value, 'binary');
+
+          files.push({
+            key,
+            filename,
+            path: {
+              absolute: absolute,
+              relative: relative
+            },
+            mimetype: type,
+            size
+          });
+        }
+      }
+
+      const groupedFilesByKey = files.reduce((acc, file) => {
+        if (!acc[file.key]) acc[file.key] = [];
+        acc[file.key].push(file);
+        return acc;
+      }, {});
+
+      for (const key in groupedFilesByKey) {
+        updatedPayload[key] = groupedFilesByKey[key];
+      }
+
+      ammo.payload = updatedPayload;
+      next();
+    };
+  }
+}
+
+export default TejFileUploader;

package/server/handler.js

@@ -1,70 +1,71 @@
-import TejLogger from 'tej-logger';
-import { env } from 'tej-env';
-
-import Ammo from './ammo.js';
-import TargetRegistry from './targets/registry.js';
-import logHttpRequest from '../utils/request-logger.js';
-
-const targetRegistry = new TargetRegistry();
-const errorLogger = new TejLogger('Tejas.Exception');
-
-const executeChain = async (target, ammo) => {
-  let i = 0;
-
-  const chain = targetRegistry.globalMiddlewares.concat(target.middlewares);
-  chain.push(target.shoot);
-
-  const next = async () => {
-    const middleware = chain[i];
-    i++;
-
-    const args =
-      middleware.length === 3 ? [ammo.req, ammo.res, next] : [ammo, next];
-
-    try {
-      await middleware(...args);
-    } catch (err) {
-      const ammo =
-        middleware.length === 2 ? args[0] : new Ammo(args[0], args[1]);
-      errorHandler(ammo, err);
-    }
-  };
-
-  await next();
-};
-
-const errorHandler = (ammo, err, errCode) => {
-  if (env('LOG_EXCEPTIONS')) errorLogger.error(err);
-
-  ammo.throw(err, errCode);
-};
-
-const handler = async (req, res) => {
-  const target = targetRegistry.aim(req.method, req.url.split('?')[0]);
-  const ammo = new Ammo(req, res);
-  await ammo.enhance();
-
-  if (env('LOG_HTTP_REQUESTS')) logHttpRequest(ammo);
-
-  try {
-    if (target) {
-      await executeChain(target, ammo);
-    } else {
-      if (req.url === '/') {
-        ammo.defaultEntry();
-      } else {
-        errorHandler(
-          ammo,
-          new Error(
-            `No target found for URL ${ammo.fullURL} with method ${ammo.method}`,
-          ),
-          404,
-        );
-      }
-    }
-  } catch (err) {
-    errorHandler(ammo, err);
-  }
-};
-
-export default handler;
+import { env } from 'tej-env';
+import TejLogger from 'tej-logger';
+import logHttpRequest from '../utils/request-logger.js';
+
+import Ammo from './ammo.js';
+import TejError from './error.js';
+import TargetRegistry from './targets/registry.js';
+
+const targetRegistry = new TargetRegistry();
+const errorLogger = new TejLogger('Tejas.Exception');
+
+const executeChain = async (target, ammo) => {
+  let i = 0;
+
+  const chain = targetRegistry.globalMiddlewares.concat(target.middlewares);
+  chain.push(target.shoot);
+
+  const next = async () => {
+    const middleware = chain[i];
+    i++;
+
+    const args =
+      middleware.length === 3 ? [ammo.req, ammo.res, next] : [ammo, next];
+
+    try {
+      await middleware(...args);
+    } catch (err) {
+      errorHandler(ammo, err);
+    }
+  };
+
+  await next();
+};
+
+const errorHandler = (ammo, err) => {
+  if (env('LOG_EXCEPTIONS')) errorLogger.error(err);
+
+  if (err instanceof TejError)
+    return ammo.throw(err.code, err);
+
+  ammo.throw(500, err);
+};
+
+const handler = async (req, res) => {
+  const target = targetRegistry.aim(req.method, req.url.split('?')[0]);
+  const ammo = new Ammo(req, res);
+  await ammo.enhance();
+
+  if (env('LOG_HTTP_REQUESTS')) logHttpRequest(ammo);
+
+  try {
+    if (target) {
+      await executeChain(target, ammo);
+    } else {
+      if (req.url === '/') {
+        ammo.defaultEntry();
+      } else {
+        errorHandler(
+          ammo,
+          new TejError(404,
+            `No target found for URL ${ammo.fullURL} with method ${ammo.method}`
+          )
+        );
+      }
+    }
+  } catch (err) {
+    errorHandler(ammo, err);
+  }
+};
+
+export default handler;

package/server/target.js

@@ -1,62 +1,62 @@
-import isMiddlewareValid from './targets/middleware-validator.js';
-import TargetRegistry from './targets/registry.js';
-
-const targetRegistry = new TargetRegistry();
-
-const isEndpointValid = (endpoint) => {
-  if (typeof endpoint !== 'string') return false;
-  if (endpoint.length === 0) return false;
-  return endpoint[0] === '/';
-};
-
-const isShootValid = (shoot) => typeof shoot === 'function';
-
-const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
-
-class Target {
-  constructor(base = '') {
-    this.base = base;
-    this.targetMiddlewares = [];
-  }
-
-  base(base) {
-    if (!base || !base.startsWith('/')) return;
-    this.base = base;
-  }
-
-  midair() {
-    if (!arguments) return;
-    const middlewares = [...arguments];
-    const validMiddlewares = middlewares.filter(isMiddlewareValid);
-    this.targetMiddlewares = this.targetMiddlewares.concat(validMiddlewares);
-  }
-
-  register() {
-    let allowedMethods = validMethods;
-    let args = arguments;
-    if (!args) return;
-
-    if (validMethods.includes(args[0])) {
-      allowedMethods = [args[0]];
-      args = arguments[1];
-    }
-
-    const endpoint = args[0];
-    const shoot = args[args.length - 1];
-    const middlewares = Array.from(args).slice(1, args.length - 1);
-
-    if (!isEndpointValid(endpoint)) return;
-    if (!isShootValid(shoot)) return;
-
-    const validMiddlewares = middlewares.filter(isMiddlewareValid);
-
-    targetRegistry.targets.push({
-      allowedMethods: allowedMethods.length > 0 ? allowedMethods : validMethods,
-      endpoint: this.base + endpoint,
-      middlewares: this.targetMiddlewares.concat(validMiddlewares),
-      shoot,
-    });
-  }
-}
-
-export default Target;
+import isMiddlewareValid from './targets/middleware-validator.js';
+import TargetRegistry from './targets/registry.js';
+
+const targetRegistry = new TargetRegistry();
+
+const isEndpointValid = (endpoint) => {
+  if (typeof endpoint !== 'string') return false;
+  if (endpoint.length === 0) return false;
+  return endpoint[0] === '/';
+};
+
+const isShootValid = (shoot) => typeof shoot === 'function';
+
+const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+
+class Target {
+  constructor(base = '') {
+    this.base = base;
+    this.targetMiddlewares = [];
+  }
+
+  base(base) {
+    if (!base || !base.startsWith('/')) return;
+    this.base = base;
+  }
+
+  midair() {
+    if (!arguments) return;
+    const middlewares = [...arguments];
+    const validMiddlewares = middlewares.filter(isMiddlewareValid);
+    this.targetMiddlewares = this.targetMiddlewares.concat(validMiddlewares);
+  }
+
+  register() {
+    let allowedMethods = validMethods;
+    let args = arguments;
+    if (!args) return;
+
+    if (validMethods.includes(args[0])) {
+      allowedMethods = [args[0]];
+      args = arguments[1];
+    }
+
+    const endpoint = args[0];
+    const shoot = args[args.length - 1];
+    const middlewares = Array.from(args).slice(1, args.length - 1);
+
+    if (!isEndpointValid(endpoint)) return;
+    if (!isShootValid(shoot)) return;
+
+    const validMiddlewares = middlewares.filter(isMiddlewareValid);
+
+    targetRegistry.targets.push({
+      allowedMethods: allowedMethods.length > 0 ? allowedMethods : validMethods,
+      endpoint: this.base + endpoint,
+      middlewares: this.targetMiddlewares.concat(validMiddlewares),
+      shoot,
+    });
+  }
+}
+
+export default Target;