te.js 1.0.0

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "singleQuote": true,
+  "printWidth": 80,
+  "semi": true
+}

package/README.md

@@ -0,0 +1 @@
+# IN DEVELOPMENT. DO NOT USE

package/database/index.js

@@ -0,0 +1,7 @@
+import mongo from './mongo.js';
+
+const database = {
+  mongodb: mongo,
+};
+
+export default database;

package/database/mongo.js

@@ -0,0 +1,14 @@
+import mongoose from './../example/node_modules/mongoose';
+
+const connect = (uri, options, cb) => {
+  mongoose
+    .connect(uri, options)
+    .then(() => {
+      cb(undefined);
+    })
+    .catch((error) => {
+      cb(error);
+    });
+};
+
+export default connect;

package/example/index.js

@@ -0,0 +1,6 @@
+import { Tejas } from 'te.js';
+import './routes/index.target.js';
+
+const tejas = new Tejas();
+tejas.connectDatabase();
+tejas.takeoff();

package/example/middlewares/auth.js

@@ -0,0 +1,9 @@
+const auth = (ammo, next) => {
+  if (ammo.headers.authorization === "Bearer 123") {
+    next();
+  } else {
+    return ammo.unauthorized();
+  }
+};
+
+export default auth;

package/example/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "example",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "te.js": "file:..",
+    "tej-env": "^1.0.2",
+    "mongoose": "^8.3.1"
+  }
+}

package/example/routes/index.target.js

@@ -0,0 +1,10 @@
+import { Target } from "te.js";
+
+const target = new Target();
+
+target.register('/hello', (ammo) => {
+  ammo.dispatch({
+    status: 200,
+    body: 'Hello, World!',
+  });
+});

package/example/routes/user/user.route.js

@@ -0,0 +1,13 @@
+import {Target} from 'te.js';
+
+const target = new Target();
+
+const registerMiddleware = (req, res) => {
+  console.log("Register user middleware");
+}
+
+target.register('/register', registerMiddleware, (req, res) => {
+  res.writeHead(200, {'Content-Type': 'text/html'});
+  res.write('Hello User');
+  res.end();
+});

package/example/tejas.config.json

@@ -0,0 +1,11 @@
+{
+  "port": 1403,
+  "log": {
+    "http_requests": true,
+    "exceptions": true
+  },
+  "db": {
+    "type": "mongodb",
+    "uri": "mongodb://localhost:27017/te-js"
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "te.js",
+  "version": "1.0.0",
+  "description": "A nodejs framework",
+  "type": "module",
+  "main": "te.js",
+  "scripts": {
+    "start": "node te.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "husky"
+  },
+  "author": "Hirak",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.12.5",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "prettier": "3.2.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:hirakchhatbar/te.js.git"
+  },
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "formidable": "^3.5.1",
+    "statuses": "^2.0.1",
+    "tej-env": "^1.0.5",
+    "tej-logger": "^1.2.1"
+  },
+  "lint-staged": {
+    "**/*.{js,ts}": "prettier --write --ignore-unknown"
+  }
+}

package/server/ammo/body-parser.js

@@ -0,0 +1,51 @@
+import formidable from 'formidable';
+
+async function parseDataBasedOnContentType(req) {
+  // Check if content type is JSON
+  if (req.headers['content-type'] === 'application/json') {
+    return await parseJSONRequestBody(req);
+  }
+
+  // Check if content type is URL encoded
+  if (req.headers['content-type'] === 'application/x-www-form-urlencoded') {
+    return await parseUrlEncodedData(req);
+  }
+
+  return null;
+}
+
+function parseJSONRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on('end', () => {
+      try {
+        const jsonData = JSON.parse(body);
+        resolve(jsonData); // Resolve promise with the parsed JSON
+      } catch (err) {
+        reject(new Error('Invalid JSON')); // Reject promise if JSON parsing fails
+      }
+    });
+  });
+}
+
+function parseUrlEncodedData(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+
+    req.on('data', (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on('end', () => {
+      const data = new URLSearchParams(body);
+      const parsedData = Object.fromEntries(data);
+      resolve(parsedData);
+    });
+  });
+}
+
+export default parseDataBasedOnContentType;

package/server/ammo/dispatch-helper.js

@@ -0,0 +1,53 @@
+import status from 'statuses';
+
+const formattedData = (data) => {
+  if (typeof data === 'object') return JSON.stringify(data);
+  if (typeof data === 'string') return data;
+  if (typeof data === 'number') return status[data];
+  return data;
+};
+
+const statusAndData = (args) => {
+  if (!args || args.length === 0)
+    return {
+      statusCode: 204,
+      data: status(204),
+      contentType: 'text/plain',
+    };
+
+  if (args.length === 1 && typeof args[0] === 'number')
+    return {
+      statusCode: args[0],
+      data: status(args[0]),
+      contentType: 'text/plain',
+    };
+
+  let statusCode = 200;
+  let data = args[0];
+  if (args.length > 1) {
+    statusCode = args[0];
+    data = args[1];
+    if (!data) data = status[statusCode];
+  }
+
+  return {
+    statusCode,
+    data: formattedData(data),
+    contentType: contentType(data),
+  };
+};
+
+const contentType = (data) => {
+  switch (typeof data) {
+    case 'object':
+      return 'application/json';
+    case 'string':
+      return 'text/html';
+    case 'number':
+      return 'text/plain';
+    default:
+      return 'text/plain';
+  }
+};
+
+export { statusAndData, contentType };

package/server/ammo/enhancer.js

@@ -0,0 +1,53 @@
+import bodyParser from './body-parser.js';
+
+function hostname(req) {
+  let host = req.headers['X-Forwarded-Host'];
+
+  if (!host) {
+    host = req.headers.host;
+  } else if (host.indexOf(',') !== -1) {
+    host = host.substring(0, host.indexOf(',')).trimRight();
+  }
+
+  return host;
+}
+
+async function generatePayload(req) {
+  const obj = {};
+
+  const searchParams = new URLSearchParams(req.url.split('?')[1]);
+  for (const [key, value] of searchParams) {
+    obj[key] = value;
+  }
+
+  const body = await bodyParser(req);
+  if (body) Object.assign(obj, body);
+  return obj;
+}
+
+function protocol(req) {
+  const proto = req.connection.encrypted ? 'https' : 'http';
+
+  const header = req.headers['X-Forwarded-Proto'] || proto;
+  const index = header.indexOf(',');
+
+  return index !== -1 ? header.substring(0, index).trim() : header.trim();
+}
+
+const enhance = async (ammo) => {
+  const req = ammo.req;
+
+  ammo.ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
+  ammo.headers = req.headers;
+  ammo.payload = await generatePayload(req);
+  ammo.method = req.method;
+
+  ammo.protocol = protocol(req);
+  ammo.hostname = hostname(req);
+  ammo.path = req.url;
+  ammo.endpoint = req.url.split('?')[0];
+
+  ammo.fullURL = `${ammo.protocol}://${ammo.hostname}/${ammo.path}`;
+};
+
+export default enhance;

package/server/ammo.js

@@ -0,0 +1,95 @@
+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;

package/server/handler.js

@@ -0,0 +1,70 @@
+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;

package/server/target.js

@@ -0,0 +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;

package/server/targets/middleware-validator.js

@@ -0,0 +1,22 @@
+import TejLogger from 'tej-logger';
+
+const logger = new TejLogger('MiddlewareValidator');
+
+const isMiddlewareValid = (middleware) => {
+  if (typeof middleware !== 'function') {
+    logger.error(`Middleware ${middleware} should be a function. Skipping...`);
+    return false;
+  }
+
+  const args = middleware.length;
+  if (args !== 2 && args !== 3) {
+    logger.error(
+      `Middleware ${middleware.name} should have 2 arguments (ammo, next) or 3 arguments (req, res, next). Skipping...`,
+    );
+    return false;
+  }
+
+  return true;
+};
+
+export default isMiddlewareValid;

package/server/targets/registry.js

@@ -0,0 +1,44 @@
+import isMiddlewareValid from './middleware-validator.js';
+
+class TargetRegistry {
+  constructor() {
+    if (TargetRegistry.instance) {
+      return TargetRegistry.instance;
+    }
+
+    TargetRegistry.instance = this;
+
+    // TODO - Add a default target
+    this.targets = [];
+    this.globalMiddlewares = [];
+  }
+
+  addGlobalMiddleware() {
+    if (!arguments) return;
+
+    const middlewares = [...arguments];
+    const validMiddlewares = middlewares.filter(isMiddlewareValid);
+    this.globalMiddlewares = this.globalMiddlewares.concat(validMiddlewares);
+  }
+
+  /**
+   * @param {Array || Object} targets
+   */
+  register(targets) {
+    if (Array.isArray(targets)) {
+      this.targets = this.targets.concat(targets);
+    } else {
+      this.targets.push(targets);
+    }
+  }
+
+  aim(method, endpoint) {
+    return this.targets.find((target) => {
+      return (
+        target.endpoint === endpoint && target.allowedMethods.includes(method)
+      );
+    });
+  }
+}
+
+export default TargetRegistry;

package/te.js

@@ -0,0 +1,106 @@
+import { createServer } from 'node:http';
+
+import { env, setEnv } from 'tej-env';
+import TejLogger from 'tej-logger';
+import database from './database/index.js';
+
+import TargetRegistry from './server/targets/registry.js';
+import Target from './server/target.js';
+
+import { loadConfigFile, standardizeObj } from './utils/configuration.js';
+
+import targetHandler from './server/handler.js';
+
+const logger = new TejLogger('Tejas');
+const targetRegistry = new TargetRegistry();
+
+class Tejas {
+  /*
+   * Constructor for Tejas
+   * @param {Object} args - Arguments for Tejas
+   * @param {Number} args.port - Port to run Tejas on
+   * @param {Boolean} args.log.http_requests - Whether to log incoming HTTP requests
+   * @param {Boolean} args.log.exceptions - Whether to log exceptions
+   * @param {String} args.db.type - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
+   * @param {String} args.db.uri - Connection URI string for the database
+   */
+  constructor(args) {
+    if (Tejas.instance) return Tejas.instance;
+    Tejas.instance = this;
+
+    this.generateConfiguration(args);
+  }
+
+  /*
+   * Connect to a database
+   * @param {Object}
+   * @param {String} args.db - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
+   * @param {String} args.uri - Connection URI string for the database
+   * @param {Object} args.options - Options for the database connection
+   */
+  connectDatabase(args) {
+    const db = args?.db ?? env('DB_TYPE');
+    const uri = args?.uri ?? env('DB_URI');
+    const options = args?.options ?? {};
+
+    if (!db) return;
+    if (!uri) {
+      logger.error(
+        `Tejas could not connect to ${db} as it couldn't find a connection URI. See our documentation for more information.`,
+        false,
+      );
+      return;
+    }
+
+    const connect = database[db];
+    if (!connect) {
+      logger.error(
+        `Tejas could not connect to ${db} as it is not supported. See our documentation for more information.`,
+        false,
+      );
+      return;
+    }
+
+    connect(uri, options, (error) => {
+      if (error) {
+        logger.error(
+          `Tejas could not connect to ${db}. Error: ${error}`,
+          false,
+        );
+        return;
+      }
+
+      logger.info(`Tejas connected to ${db} successfully.`);
+    });
+  }
+
+  generateConfiguration(options) {
+    const configVars = standardizeObj(loadConfigFile());
+    const envVars = standardizeObj(process.env);
+    const userVars = standardizeObj(options);
+
+    const config = { ...configVars, ...envVars, ...userVars };
+    for (const key in config) {
+      if (config.hasOwnProperty(key)) {
+        setEnv(key, config[key]);
+      }
+    }
+
+    // Load defaults
+    if (!env('PORT')) setEnv('PORT', 1403);
+  }
+
+  midair() {
+    if (!arguments) return;
+    targetRegistry.addGlobalMiddleware(...arguments);
+  }
+
+  takeoff() {
+    this.engine = createServer(targetHandler);
+    this.engine.listen(env('PORT'), () => {
+      logger.info(`Tejas took off from port ${env('PORT')}`);
+    });
+  }
+}
+
+export { Tejas, Target };

package/utils/configuration.js

@@ -0,0 +1,61 @@
+import * as fs from 'fs';
+
+const loadConfigFile = () => {
+  try {
+    const data = fs.readFileSync('tejas.config.json', 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    return {};
+  }
+};
+
+const keysToUpperCase = (obj) => {
+  if (!obj) return {};
+  const standardObj = {};
+
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const value = obj[key];
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        standardObj[key.toUpperCase()] = standardizeObj(value);
+      } else {
+        standardObj[key.toUpperCase()] = value;
+      }
+    }
+  }
+
+  return standardObj;
+};
+const flattenObject = (obj, prefix = '') => {
+  let flattened = {};
+
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = prefix.length ? `${prefix}_${key}` : key; // Create a new key
+      const value = obj[key];
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        Object.assign(flattened, flattenObject(value, newKey));
+      } else {
+        flattened[newKey] = value;
+      }
+    }
+  }
+  return flattened;
+};
+
+const standardizeObj = (obj) => {
+  let standardObj = obj;
+  standardObj = keysToUpperCase(standardObj);
+  standardObj = flattenObject(standardObj);
+  return standardObj;
+};
+
+export { loadConfigFile, standardizeObj };

package/utils/request-logger.js

@@ -0,0 +1,43 @@
+import { env } from 'tej-env';
+import ansi from 'ansi-colors';
+import TejLogger from 'tej-logger';
+
+const logger = new TejLogger('Tejas.Request');
+const { italic, bold, blue, white, bgGreen, bgRed, whiteBright } = ansi;
+
+function logHttpRequest(ammo, next) {
+  if (!env('LOG_HTTP_REQUESTS')) return;
+
+  const startTime = new Date();
+  ammo.res.on('finish', () => {
+    const res = ammo.res;
+    const method = italic(whiteBright(ammo.method));
+    const endpoint = bold(ammo.endpoint.split('?')[0].replace(/\/$/, ''));
+    const statusCode =
+      res.statusCode >= 400
+        ? bgRed(whiteBright(bold(`✖ ${res.statusCode}`)))
+        : bgGreen(whiteBright(bold(`✔ ${res.statusCode}`)));
+
+    const duration = white(`${new Date() - startTime}ms`);
+    const payload = `${blue('Request')}: ${white(
+      JSON.stringify(ammo.payload),
+    )}`;
+    const dispatchedData = `${blue('Response')}: ${white(ammo.dispatchedData)}`;
+    const nextLine = '\n';
+
+    logger.log(
+      italic(`Incoming request from ${ammo.ip}`),
+      nextLine,
+      method,
+      endpoint,
+      statusCode,
+      duration,
+      nextLine,
+      payload,
+      nextLine,
+      dispatchedData,
+    );
+  });
+}
+
+export default logHttpRequest;

package/utils/status-codes.js

@@ -0,0 +1,82 @@
+const statuses = {
+  '100': 'Continue',
+  '101': 'Switching Protocols',
+  '102': 'Processing',
+  '103': 'Early Hints',
+  '200': 'OK',
+  '201': 'Created',
+  '202': 'Accepted',
+  '203': 'Non-Authoritative Information',
+  '204': 'No Content',
+  '205': 'Reset Content',
+  '206': 'Partial Content',
+  '207': 'Multi-Status',
+  '208': 'Already Reported',
+  '226': 'IM Used',
+  '300': 'Multiple Choices',
+  '301': 'Moved Permanently',
+  '302': 'Found',
+  '303': 'See Other',
+  '304': 'Not Modified',
+  '305': 'Use Proxy',
+  '307': 'Temporary Redirect',
+  '308': 'Permanent Redirect',
+  '400': 'Bad Request',
+  '401': 'Unauthorized',
+  '402': 'Payment Required',
+  '403': 'Forbidden',
+  '404': 'Not Found',
+  '405': 'Method Not Allowed',
+  '406': 'Not Acceptable',
+  '407': 'Proxy Authentication Required',
+  '408': 'Request Timeout',
+  '409': 'Conflict',
+  '410': 'Gone',
+  '411': 'Length Required',
+  '412': 'Precondition Failed',
+  '413': 'Payload Too Large',
+  '414': 'URI Too Long',
+  '415': 'Unsupported Media Type',
+  '416': 'Range Not Satisfiable',
+  '417': 'Expectation Failed',
+  '418': 'I\'m a Teapot',
+  '421': 'Misdirected Request',
+  '422': 'Unprocessable Entity',
+  '423': 'Locked',
+  '424': 'Failed Dependency',
+  '425': 'Too Early',
+  '426': 'Upgrade Required',
+  '428': 'Precondition Required',
+  '429': 'Too Many Requests',
+  '431': 'Request Header Fields Too Large',
+  '451': 'Unavailable For Legal Reasons',
+  '500': 'Internal Server Error',
+  '501': 'Not Implemented',
+  '502': 'Bad Gateway',
+  '503': 'Service Unavailable',
+  '504': 'Gateway Timeout',
+  '505': 'HTTP Version Not Supported',
+  '506': 'Variant Also Negotiates',
+  '507': 'Insufficient Storage',
+  '508': 'Loop Detected',
+  '509': 'Bandwidth Limit Exceeded',
+  '510': 'Not Extended',
+  '511': 'Network Authentication Required',
+};
+
+const reverseStatuses = Object.fromEntries(
+    Object.entries(statuses).map(([key, value]) => [value, key]));
+
+const toStatusCode = (message) => {
+  return reverseStatuses[message];
+};
+
+const toStatusMessage = (code) => {
+  return statuses[code];
+};
+
+const isStatusCode = (code) => {
+  return statuses[code] !== undefined;
+}
+
+export {toStatusCode, toStatusMessage, isStatusCode};

package/utils/tejas-entrypoint-html.js

@@ -0,0 +1,18 @@
+// TODO Create a better entrypoint html
+
+const html =
+  "" +
+  "<!DOCTYPE html>" +
+  '<html lang="en">' +
+  "<head>" +
+  '<meta charset="UTF-8">' +
+  '<meta http-equiv="X-UA-Compatible" content="IE=edge">' +
+  '<meta name="viewport" content="width=device-width, initial-scale=1.0">' +
+  "<title>te.js</title>" +
+  "</head>" +
+  "<body>" +
+  "<h1>Tejas is flying</h1>" +
+  "</body>" +
+  "</html>";
+
+export default html;