First Commit

.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+lib/
+logs/
+databases/

config.ini

@@ -0,0 +1,5 @@
+[general]
+dev=true
+port=5013
+admin=admin
+access_log=true

package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hibas123/realtime-db",
+  "version": "1.0.0",
+  "description": "",
+  "main": "lib/index.js",
+  "scripts": {
+    "start": "node lib/index.js",
+    "build": "tsc",
+    "watch-ts": "tsc -w",
+    "watch-node": "nodemon --ignore *.ts lib/index.js",
+    "watch": "concurrently \"npm:watch-*\"",
+    "prepublishOnly": "tsc"
+  },
+  "author": "Fabian Stamm <dev@fabianstamm.de>",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/ini": "^1.3.30",
+    "@types/leveldown": "^4.0.0",
+    "@types/levelup": "^3.1.1",
+    "@types/node": "^12.7.5",
+    "@types/shortid": "0.0.29",
+    "@types/socket.io": "^2.1.2",
+    "concurrently": "^4.1.2",
+    "nodemon": "^1.19.2",
+    "typescript": "^3.6.3"
+  },
+  "dependencies": {
+    "@hibas123/binary-encoder": "^1.0.0",
+    "@hibas123/nodelogging": "^2.1.0",
+    "@hibas123/utils": "^2.1.1",
+    "@types/koa": "^2.0.49",
+    "@types/koa-router": "^7.0.42",
+    "handlebars": "^4.2.0",
+    "ini": "^1.3.5",
+    "koa": "^2.8.1",
+    "koa-body": "^4.1.1",
+    "koa-router": "^7.4.0",
+    "leveldown": "^5.2.0",
+    "levelup": "^4.2.0",
+    "shortid": "^2.2.15",
+    "socket.io": "^2.2.0"
+  }
+}

src/config.ts

@@ -0,0 +1,16 @@
+import * as ini from "ini";
+import * as fs from "fs";
+import Logging from "@hibas123/nodelogging";
+
+interface IConfig {
+   general: {
+      port: string;
+      admin: string;
+      access_log: boolean;
+      dev: boolean
+   }
+}
+
+const config = ini.parse(fs.readFileSync("config.ini").toString()) as IConfig;
+Logging.debug("Config:", config);
+export default config;

src/connection.ts

@@ -0,0 +1,67 @@
+import * as io from "socket.io";
+import { Server } from "http";
+import { DatabaseManager } from "./database/database";
+import Logging from "@hibas123/logging";
+
+type QueryTypes = "get" | "set" | "push" | "subscribe" | "unsubscribe";
+
+export class ConnectionManager {
+   static server: io.Server;
+   static bind(server: Server) {
+      this.server = io(server);
+      this.server.on("connection", this.onConnection.bind(this));
+   }
+
+   private static onConnection(socket: io.Socket) {
+      const reqMap = new Map<string, [number, number]>();
+      const answer = (id: string, data: any, err: boolean = false) => {
+         let time = process.hrtime(reqMap.get(id));
+         Logging.debug(`Sending answer for ${id} with data`, data, err ? "as error" : "", "Took", time[1] / 1000, "us");
+         socket.emit("message", id, err, data);
+      }
+
+      socket.on("login", (id: string) => {
+         //TODO: implement
+      })
+
+      socket.on("query", async (id: string, type: QueryTypes, database: string, path: string[], data: any) => {
+         Logging.debug(`Request with id ${id} from type ${type} for database ${database} and path ${path} with data ${data}`)
+         reqMap.set(id, process.hrtime());
+         try {
+            const db = DatabaseManager.getDatabase(database);
+            if (!db)
+               answer(id, "Database not found!", true);
+            else {
+               const query = db.getQuery(path);
+
+               switch (type) {
+                  case "get":
+                     answer(id, await query.get());
+                     break;
+                  case "set":
+                     answer(id, await query.set(data));
+                     break;
+                  case "push":
+                     answer(id, await query.push(data));
+                     break;
+                  case "subscribe":
+                     answer(id, await query.subscribe());
+                     break;
+                  case "unsubscribe":
+                     answer(id, await query.unsubscribe());
+                     break;
+               }
+
+            }
+         } catch (err) {
+            Logging.error(err);
+            answer(id, err.message, true);
+         }
+
+      })
+
+      socket.on("disconnect", () => {
+
+      })
+   }
+}

src/database/database.ts

@@ -0,0 +1,84 @@
+import { Rules } from "./rules";
+import Settings from "../settings";
+import getLevelDB from "../storage";
+import PathLock from "./lock";
+import Query from "./query";
+
+export class DatabaseManager {
+   static databases = new Map<string, Database>();
+
+   static async init() {
+      let databases = await Settings.getDatabases();
+
+      databases.forEach(dbconfig => {
+         let db = new Database(dbconfig.name, dbconfig.accesskey, dbconfig.rules, dbconfig.publickey);
+         this.databases.set(dbconfig.name, db);
+      })
+   }
+
+   static addDatabase(name: string) {
+      if (this.databases.has(name))
+         throw new Error("Database already exists!");
+
+      let database = new Database(name);
+      this.databases.set(name, database);
+      return database;
+   }
+
+   static getDatabase(name: string) {
+      return this.databases.get(name);
+   }
+
+   static async deleteDatabase(name: string) {
+      let db = this.databases.get(name)
+      if (db) {
+         await Settings.deleteDatabase(name);
+         await db.stop();
+
+      }
+   }
+}
+
+export class Database {
+   public level = getLevelDB(this.name);
+   private rules: Rules;
+   public locks = new PathLock()
+
+   toJSON() {
+      return {
+         name: this.name,
+         accesskey: this.accesskey,
+         publickey: this.publickey,
+         rules: this.rules
+      }
+   }
+
+   constructor(public name: string, public accesskey?: string, rawRules?: string, public publickey?: string) {
+      if (rawRules)
+         this.rules = new Rules(rawRules);
+   }
+
+   async setRules(rawRules: string) {
+      let rules = new Rules(rawRules);
+      await Settings.setDatabaseRules(this.name, rawRules);
+      this.rules = rules;
+   }
+
+   async setAccessKey(key: string) {
+      await Settings.setDatabaseAccessKey(this.name, key);
+      this.accesskey = key;
+   }
+
+   async setPublicKey(key: string) {
+      await Settings.setDatabasePublicKey(this.name, key);
+      this.publickey = key;
+   }
+
+   getQuery(path: string[]) {
+      return new Query(this, path);
+   }
+
+   async stop() {
+      await this.level.close();
+   }
+}

src/database/lock.ts

@@ -0,0 +1,43 @@
+export type Release = { release: () => void };
+
+export default class PathLock {
+   locks: {
+      path: string[],
+      next: (() => void)[]
+   }[] = [];
+
+   constructor() { }
+
+   async lock(path: string[]) {
+      let locks = this.locks.filter(lock => {
+         let idxs = Math.min(lock.path.length, path.length);
+         if (idxs === 0) return true;
+         for (let i = 0; i < idxs; i++) {
+            if (lock.path[i] !== path[i])
+               return false;
+         }
+         return true;
+      })
+
+      if (locks.length > 0) { // await till release
+         await Promise.all(locks.map(l => new Promise(res => l.next.push(res))))
+      } else {
+         let lock = {
+            path: path,
+            next: []
+         }
+         this.locks.push(lock);
+         locks = [lock];
+      }
+
+      return () => {
+         locks.forEach(lock => {
+            if (lock.next.length > 0) {
+               setImmediate(() => lock.next.shift()());
+            } else {
+               this.locks.splice(this.locks.indexOf(lock), 1);
+            }
+         })
+      }
+   }
+}

src/database/query.ts

@@ -0,0 +1,211 @@
+import { Database } from "./database";
+
+import Encoder, { DataTypes } from "@hibas123/binary-encoder";
+import { resNull } from "../storage";
+import { Bytes } from "leveldown";
+import { LevelUpChain } from "levelup";
+import shortid = require("shortid");
+import Logging from "@hibas123/nodelogging";
+
+enum FieldTypes {
+   OBJECT,
+   VALUE
+}
+
+interface IField {
+   type: FieldTypes;
+   // fields?: string[];
+   value?: any
+}
+
+const FieldEncoder = new Encoder<IField>({
+   type: {
+      index: 1,
+      type: DataTypes.UINT8
+   },
+   // fields: {
+   //    index: 2,
+   //    type: DataTypes.STRING,
+   //    array: true
+   // },
+   value: {
+      index: 3,
+      type: DataTypes.AUTO,
+      allowNull: true
+   }
+})
+
+export default class Query {
+   constructor(private database: Database, private path: string[]) {
+      if (path.length > 10) {
+         throw new Error("Path is to long. Path is only allowed to be 10 Layers deep!");
+      }
+      if (path.find(segment => segment.indexOf("/") >= 0)) {
+         throw new Error("Path cannot contain '/'!");
+      }
+   }
+
+   private pathToKey(path?: string[]) {
+      return "/" + (path || this.path).join("/");
+   }
+
+   private getField(path: string[]): Promise<IField | null> {
+      return this.database.level.get(this.pathToKey(path), { asBuffer: true }).then((res: Buffer) => FieldEncoder.decode(res)).catch(resNull);
+   }
+
+   private getFields(path: string[]) {
+      let p = this.pathToKey(path);
+      if (!p.endsWith("/"))
+         p += "/";
+      let t = Buffer.from(p);
+
+      let gt = Buffer.alloc(t.length + 1);
+      gt.set(t);
+      gt[t.length] = 0;
+
+      let lt = Buffer.alloc(t.length + 1);
+      lt.set(t);
+      lt[t.length] = 0xFF;
+
+      return new Promise<string[]>((yes, no) => {
+         let keys = [];
+         const stream = this.database.level.createKeyStream({
+            gt: Buffer.from(p),
+            lt: Buffer.from(lt)
+         })
+         stream.on("data", key => keys.push(key.toString()));
+         stream.on("end", () => yes(keys));
+         stream.on("error", no);
+      });
+   }
+
+   async get() {
+      const lock = await this.database.locks.lock(this.path);
+      try {
+         const getData = async (path: string[]) => {
+            let obj = await this.getField(path);
+            if (!obj)
+               return null;
+            else {
+               if (obj.type === FieldTypes.VALUE) {
+                  return obj.value;
+               } else {
+                  let res = {};
+
+
+                  let fields = await this.getFields(this.path);
+                  let a = fields.map(field => field.split("/").filter(e => e !== "")).sort((a, b) => a.length - b.length).map(async path => {
+                     let field = await this.getField(path);
+                     Logging.debug("Path:", path, "Field:", field);
+                     let shortened = path.slice(this.path.length);
+
+                     let t = res;
+                     for (let section of shortened.slice(0, -1)) {
+                        t = t[section];
+                     }
+
+                     if (field.type === FieldTypes.OBJECT) {
+                        t[path[path.length - 1]] = {};
+                     } else {
+                        t[path[path.length - 1]] = field.value;
+                     }
+                  })
+
+                  await Promise.all(a);
+
+                  return res;
+               }
+            }
+         }
+         return await getData(this.path);
+      } finally {
+         lock();
+      }
+   }
+
+   async push(value: any) {
+      let id = shortid.generate();
+      let q = new Query(this.database, [...this.path, id]);
+      await q.set(value);
+      return id;
+   }
+
+   async set(value: any) {
+      const lock = await this.database.locks.lock(this.path);
+      let batch = this.database.level.batch();
+      try {
+         let field = await this.getField(this.path);
+         if (field) {
+            await this.delete(batch);
+         } else {
+            for (let i = 0; i < this.path.length; i++) {
+               let subpath = this.path.slice(0, i);
+               let field = await this.getField(subpath);
+               if (!field) {
+                  batch.put(this.pathToKey(subpath), FieldEncoder.encode({
+                     type: FieldTypes.OBJECT
+                  }));
+               } else if (field.type !== FieldTypes.OBJECT) {
+                  throw new Error("Parent elements not all Object. Cannot set value!");
+               }
+            }
+         }
+
+         const saveValue = (path: string[], value: any) => {
+            Logging.debug("Save Value:", path, value);
+            if (typeof value === "object") {
+               //TODO: Handle case array!
+               // Field type array?
+               batch.put(this.pathToKey(path), FieldEncoder.encode({
+                  type: FieldTypes.OBJECT
+               }))
+               for (let field in value) {
+                  saveValue([...path, field], value[field]);
+               }
+            } else {
+               batch.put(this.pathToKey(path), FieldEncoder.encode({
+                  type: FieldTypes.VALUE,
+                  value
+               }));
+            }
+         }
+
+         saveValue(this.path, value);
+
+         await batch.write();
+      } catch (err) {
+         if (batch.length > 0)
+            batch.clear();
+         throw err;
+      } finally {
+         lock();
+      }
+   }
+
+   async delete(batch?: LevelUpChain) {
+      let lock = batch ? undefined : await this.database.locks.lock(this.path);
+      const commit = batch ? false : true;
+      if (!batch)
+         batch = this.database.level.batch();
+      try {
+         let field = await this.getField(this.path);
+         if (field) {
+            let fields = await this.getFields(this.path)
+            fields.forEach(field => batch.del(field));
+            batch.del(this.pathToKey(this.path));
+         }
+
+         if (commit)
+            await batch.write();
+      } catch (err) {
+         if (batch.length > 0)
+            batch.clear()
+      } finally {
+         if (lock)
+            lock()
+      }
+   }
+
+   async subscribe() { }
+   async unsubscribe() { }
+}

src/database/rules.ts

@@ -0,0 +1,90 @@
+import Session from "./session";
+
+interface IRule<T> {
+   ".write"?: T
+   ".read"?: T
+}
+
+type IRuleConfig<T> = {
+   [segment: string]: IRuleConfig<T>;
+} | IRule<T>;
+
+type IRuleRaw = IRuleConfig<string>;
+type IRuleParsed = IRuleConfig<boolean>;
+
+const resolve = (value: any) => {
+   if (value === true) {
+      return true;
+   } else if (typeof value === "string") {
+
+   }
+   return undefined;
+}
+
+export class Rules {
+   rules: IRuleParsed;
+   constructor(private config: string) {
+      let parsed: IRuleRaw = JSON.parse(config);
+
+      const analyze = (raw: IRuleRaw) => {
+         let r: IRuleParsed = {};
+
+         if (raw[".read"]) {
+            let res = resolve(raw[".read"]);
+            if (res) {
+               r[".read"] = res;
+            }
+            delete raw[".read"];
+         }
+
+         if (raw[".write"]) {
+            let res = resolve(raw[".write"]);
+            if (res) {
+               r[".write"] = res;
+            }
+            delete raw[".write"];
+         }
+
+         for (let segment in raw) {
+            if (segment.startsWith("."))
+               continue;
+
+            r[segment] = analyze(raw[segment]);
+         }
+         return r;
+      }
+
+      this.rules = analyze(parsed);
+   }
+
+   hasPermission(path: string[], session: Session) {
+      let read = this.rules[".read"] || false;
+      let write = this.rules[".write"] || false;
+
+      let rules = this.rules;
+
+      for (let segment of path) {
+         rules = rules[segment];
+         if (rules[segment]) {
+            if (rules[".read"]) {
+               read = rules[".read"]
+            }
+
+            if (rules[".write"]) {
+               read = rules[".write"]
+            }
+         } else {
+            break;
+         }
+      }
+
+      return {
+         read,
+         write
+      }
+   }
+
+   toJSON() {
+      return this.config;
+   }
+}

src/database/session.ts

@@ -0,0 +1,3 @@
+export default class Session {
+
+}

src/index.ts

@@ -0,0 +1,20 @@
+import Logging from "@hibas123/nodelogging";
+// import getLevelDB from "./storage";
+// import Settings from "./settings";
+import Web from "./web";
+import config from "./config";
+import { DatabaseManager } from "./database/database";
+import { createServer } from "http";
+import { ConnectionManager } from "./connection";
+
+// Logging.debug(getLevelDB("system"));
+
+DatabaseManager.init().then(() => {
+   const http = createServer(Web.callback());
+   ConnectionManager.bind(http);
+   const port = Number(config.general.port) || 5013;
+   http.listen(port, () => Logging.log("Listening on port:", port))
+}).catch(err => {
+   Logging.error(err);
+   process.exit(-1);
+})

src/rules.ts

@@ -0,0 +1,3 @@
+export function checkRules(rules: any) {
+
+}

src/settings.ts

@@ -0,0 +1,129 @@
+import getLevelDB, { resNull } from "./storage";
+
+import Encoder, { DataTypes } from "@hibas123/binary-encoder";
+import Logging from "@hibas123/nodelogging";
+import { Lock } from "@hibas123/utils";
+
+interface IDatabaseConfig {
+   name: string;
+   publickey?: string;
+   rules?: string;
+   accesskey?: string;
+}
+
+// const DatabaseEncoder = new Encoder<IDatabaseConfig>({
+//    publickey: {
+//       index: 1,
+//       type: DataTypes.STRING,
+//       allowNull: true
+//    },
+//    rules: {
+//       index: 2,
+//       type: DataTypes.STRING
+//    }
+// });
+
+class SettingComponent {
+   db = getLevelDB("_server");
+   databaseLock = new Lock();
+
+   constructor() { }
+
+   private async setField(name: string, field: string, value: string) {
+      return this.db.put("database:" + name + ":" + field, value);
+   }
+
+   private async getField(name: string, field: string) {
+      return this.db.get("database:" + name + ":" + field).then(r => r.toString()).catch(resNull)
+   }
+
+   private getDatabaseList() {
+      return this.db.get("databases")
+         .then(res => res.toString())
+         .then(res => res.split(":"))
+         .catch(err => err.notFound ? [] as string[] : Promise.reject(err))
+   }
+
+   async getDatabases() {
+      const lock = await this.databaseLock.getLock();
+
+      const databases = await this.getDatabaseList().then(res => Promise.all(res.map(async database => {
+         let res: IDatabaseConfig = {
+            name: database
+         }
+         await Promise.all([
+            this.getField(database, "publickey").then(r => res.publickey = r),
+            this.getField(database, "rules").then(r => res.rules = r),
+            this.getField(database, "accesskey").then(r => res.accesskey = r)
+         ])
+         return res;
+      })))
+
+      lock.release();
+
+      return databases;
+   }
+
+   // hasDatabase(name: string): boolean {
+   //    //TODO may require lock
+   //    return this.databases.has(name);
+   // }
+
+   async addDatabase(name: string) {
+      //TODO: Check for valid name
+      if (name.indexOf(":") >= 0)
+         throw new Error("Invalid Database name. Cannot contain ':'!");
+
+      const lock = await this.databaseLock.getLock();
+
+      let dbs = await this.getDatabaseList()
+      dbs.push(name);
+      await this.db.put("databases", dbs.join(":"))
+
+      lock.release();
+   }
+
+   async setDatabasePublicKey(name: string, publickey: string) {
+      const lock = await this.databaseLock.getLock();
+
+      await this.setField(name, "publickey", publickey);
+
+      lock.release();
+   }
+
+   async setDatabaseRules(name: string, rules: string) {
+      const lock = await this.databaseLock.getLock();
+
+      await this.setField(name, "rules", rules);
+
+      lock.release();
+   }
+
+   async setDatabaseAccessKey(name: string, accesskey: string) {
+      const lock = await this.databaseLock.getLock();
+
+      await this.setField(name, "accesskey", accesskey);
+
+      lock.release();
+   }
+
+   async deleteDatabase(name: string) {
+      const lock = await this.databaseLock.getLock();
+
+      let pref = "database:" + name;
+
+      let dbs = await this.getDatabaseList().then(res => res.filter(e => e !== name));
+
+      await this.db.batch()
+         .put("databases", dbs.join(":"))
+         .del(pref + ":publickey")
+         .del(pref + ":rules")
+         .del(pref + ":accesskey")
+         .write();
+
+      lock.release();
+   }
+}
+
+const Settings = new SettingComponent();
+export default Settings;

src/storage.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+
+if (!fs.existsSync("./databases/")) {
+   fs.mkdirSync("./databases");
+}
+
+import LevelUp, { LevelUp as LU } from "levelup";
+import LevelDown, { LevelDown as LD } from "leveldown";
+import { AbstractIterator } from "abstract-leveldown";
+
+export type LevelDB = LU<LD, AbstractIterator<any, any>>;
+
+const databases = new Map<string, LevelDB>();
+
+export function resNull(err) {
+   if (!err.notFound)
+      throw err;
+   return null;
+}
+
+function rmRecursice(path: string) {
+   if (fs.existsSync(path)) {
+      fs.readdirSync(path).forEach(function (file, index) {
+         var curPath = path + "/" + file;
+         if (fs.lstatSync(curPath).isDirectory()) { // recurse
+            rmRecursice(curPath);
+         } else { // delete file
+            fs.unlinkSync(curPath);
+         }
+      });
+      fs.rmdirSync(path);
+   }
+};
+
+export async function deleteLevelDB(name: string) {
+   if (!name || name === "")
+      return;
+   let db = databases.get(name);
+
+   if (db && !db.isClosed())
+      await db.close()
+
+
+   //TODO make sure, that name doesn't make it possible to delete all databases :)
+   rmRecursice("./databases/" + name);
+}
+
+export default function getLevelDB(name: string): LevelDB {
+   let db = databases.get(name);
+   if (!db || db.isClosed()) {
+      db = LevelUp(LevelDown("./databases/" + name));
+      databases.set(name, db);
+   }
+   return db;
+}

src/web/helper/error.ts

@@ -0,0 +1,35 @@
+import { HttpError, HttpStatusCode } from "./errors";
+import Logging from "@hibas123/nodelogging";
+import { Context } from "koa";
+export default function RequestError(ctx: Context, next) {
+   function reply(status, message) {
+      ctx.status = status;
+      ctx.body = message;
+   }
+
+   return next().then(() => {
+      if (ctx.status === HttpStatusCode.NOT_FOUND) {
+         reply(HttpStatusCode.NOT_FOUND, "Not found");
+      }
+   }).catch(error => {
+      let message = "Internal server error";
+      let status = HttpStatusCode.INTERNAL_SERVER_ERROR;
+      if (typeof error === "string") {
+         message = error;
+      } else if (!(error instanceof HttpError)) {
+         Logging.error(error);
+         message = error.message;
+      } else {
+         if (error.status === HttpStatusCode.INTERNAL_SERVER_ERROR) {
+            //If internal server error log whole error
+            Logging.error(error);
+         }
+         else {
+            message = error.message.split("\n", 1)[0];
+            Logging.errorMessage(message);
+         }
+         status = error.status;
+      }
+      reply(status, message);
+   })
+};

src/web/helper/errors.ts

@@ -0,0 +1,411 @@
+/**
+ * Hypertext Transfer Protocol (HTTP) response status codes.
+ * @see {@link https://en.wikipedia.org/wiki/List_of_HTTP_status_codes}
+ */
+export enum HttpStatusCode {
+
+   /**
+    * The server has received the request headers and the client should proceed to send the request body
+    * (in the case of a request for which a body needs to be sent; for example, a POST request).
+    * Sending a large request body to a server after a request has been rejected for inappropriate headers would be inefficient.
+    * To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request
+    * and receive a 100 Continue status code in response before sending the body. The response 417 Expectation Failed indicates the request should not be continued.
+    */
+   CONTINUE = 100,
+
+   /**
+    * The requester has asked the server to switch protocols and the server has agreed to do so.
+    */
+   SWITCHING_PROTOCOLS = 101,
+
+   /**
+    * A WebDAV request may contain many sub-requests involving file operations, requiring a long time to complete the request.
+    * This code indicates that the server has received and is processing the request, but no response is available yet.
+    * This prevents the client from timing out and assuming the request was lost.
+    */
+   PROCESSING = 102,
+
+   /**
+    * Standard response for successful HTTP requests.
+    * The actual response will depend on the request method used.
+    * In a GET request, the response will contain an entity corresponding to the requested resource.
+    * In a POST request, the response will contain an entity describing or containing the result of the action.
+    */
+   OK = 200,
+
+   /**
+    * The request has been fulfilled, resulting in the creation of a new resource.
+    */
+   CREATED = 201,
+
+   /**
+    * The request has been accepted for processing, but the processing has not been completed.
+    * The request might or might not be eventually acted upon, and may be disallowed when processing occurs.
+    */
+   ACCEPTED = 202,
+
+   /**
+    * SINCE HTTP/1.1
+    * The server is a transforming proxy that received a 200 OK from its origin,
+    * but is returning a modified version of the origin's response.
+    */
+   NON_AUTHORITATIVE_INFORMATION = 203,
+
+   /**
+    * The server successfully processed the request and is not returning any content.
+    */
+   NO_CONTENT = 204,
+
+   /**
+    * The server successfully processed the request, but is not returning any content.
+    * Unlike a 204 response, this response requires that the requester reset the document view.
+    */
+   RESET_CONTENT = 205,
+
+   /**
+    * The server is delivering only part of the resource (byte serving) due to a range header sent by the client.
+    * The range header is used by HTTP clients to enable resuming of interrupted downloads,
+    * or split a download into multiple simultaneous streams.
+    */
+   PARTIAL_CONTENT = 206,
+
+   /**
+    * The message body that follows is an XML message and can contain a number of separate response codes,
+    * depending on how many sub-requests were made.
+    */
+   MULTI_STATUS = 207,
+
+   /**
+    * The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response,
+    * and are not being included again.
+    */
+   ALREADY_REPORTED = 208,
+
+   /**
+    * The server has fulfilled a request for the resource,
+    * and the response is a representation of the result of one or more instance-manipulations applied to the current instance.
+    */
+   IM_USED = 226,
+
+   /**
+    * Indicates multiple options for the resource from which the client may choose (via agent-driven content negotiation).
+    * For example, this code could be used to present multiple video format options,
+    * to list files with different filename extensions, or to suggest word-sense disambiguation.
+    */
+   MULTIPLE_CHOICES = 300,
+
+   /**
+    * This and all future requests should be directed to the given URI.
+    */
+   MOVED_PERMANENTLY = 301,
+
+   /**
+    * This is an example of industry practice contradicting the standard.
+    * The HTTP/1.0 specification (RFC 1945) required the client to perform a temporary redirect
+    * (the original describing phrase was "Moved Temporarily"), but popular browsers implemented 302
+    * with the functionality of a 303 See Other. Therefore, HTTP/1.1 added status codes 303 and 307
+    * to distinguish between the two behaviours. However, some Web applications and frameworks
+    * use the 302 status code as if it were the 303.
+    */
+   FOUND = 302,
+
+   /**
+    * SINCE HTTP/1.1
+    * The response to the request can be found under another URI using a GET method.
+    * When received in response to a POST (or PUT/DELETE), the client should presume that
+    * the server has received the data and should issue a redirect with a separate GET message.
+    */
+   SEE_OTHER = 303,
+
+   /**
+    * Indicates that the resource has not been modified since the version specified by the request headers If-Modified-Since or If-None-Match.
+    * In such case, there is no need to retransmit the resource since the client still has a previously-downloaded copy.
+    */
+   NOT_MODIFIED = 304,
+
+   /**
+    * SINCE HTTP/1.1
+    * The requested resource is available only through a proxy, the address for which is provided in the response.
+    * Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code, primarily for security reasons.
+    */
+   USE_PROXY = 305,
+
+   /**
+    * No longer used. Originally meant "Subsequent requests should use the specified proxy."
+    */
+   SWITCH_PROXY = 306,
+
+   /**
+    * SINCE HTTP/1.1
+    * In this case, the request should be repeated with another URI; however, future requests should still use the original URI.
+    * In contrast to how 302 was historically implemented, the request method is not allowed to be changed when reissuing the original request.
+    * For example, a POST request should be repeated using another POST request.
+    */
+   TEMPORARY_REDIRECT = 307,
+
+   /**
+    * The request and all future requests should be repeated using another URI.
+    * 307 and 308 parallel the behaviors of 302 and 301, but do not allow the HTTP method to change.
+    * So, for example, submitting a form to a permanently redirected resource may continue smoothly.
+    */
+   PERMANENT_REDIRECT = 308,
+
+   /**
+    * The server cannot or will not process the request due to an apparent client error
+    * (e.g., malformed request syntax, too large size, invalid request message framing, or deceptive request routing).
+    */
+   BAD_REQUEST = 400,
+
+   /**
+    * Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet
+    * been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the
+    * requested resource. See Basic access authentication and Digest access authentication. 401 semantically means
+    * "unauthenticated",i.e. the user does not have the necessary credentials.
+    */
+   UNAUTHORIZED = 401,
+
+   /**
+    * Reserved for future use. The original intention was that this code might be used as part of some form of digital
+    * cash or micro payment scheme, but that has not happened, and this code is not usually used.
+    * Google Developers API uses this status if a particular developer has exceeded the daily limit on requests.
+    */
+   PAYMENT_REQUIRED = 402,
+
+   /**
+    * The request was valid, but the server is refusing action.
+    * The user might not have the necessary permissions for a resource.
+    */
+   FORBIDDEN = 403,
+
+   /**
+    * The requested resource could not be found but may be available in the future.
+    * Subsequent requests by the client are permissible.
+    */
+   NOT_FOUND = 404,
+
+   /**
+    * A request method is not supported for the requested resource;
+    * for example, a GET request on a form that requires data to be presented via POST, or a PUT request on a read-only resource.
+    */
+   METHOD_NOT_ALLOWED = 405,
+
+   /**
+    * The requested resource is capable of generating only content not acceptable according to the Accept headers sent in the request.
+    */
+   NOT_ACCEPTABLE = 406,
+
+   /**
+    * The client must first authenticate itself with the proxy.
+    */
+   PROXY_AUTHENTICATION_REQUIRED = 407,
+
+   /**
+    * The server timed out waiting for the request.
+    * According to HTTP specifications:
+    * "The client did not produce a request within the time that the server was prepared to wait. The client MAY repeat the request without modifications at any later time."
+    */
+   REQUEST_TIMEOUT = 408,
+
+   /**
+    * Indicates that the request could not be processed because of conflict in the request,
+    * such as an edit conflict between multiple simultaneous updates.
+    */
+   CONFLICT = 409,
+
+   /**
+    * Indicates that the resource requested is no longer available and will not be available again.
+    * This should be used when a resource has been intentionally removed and the resource should be purged.
+    * Upon receiving a 410 status code, the client should not request the resource in the future.
+    * Clients such as search engines should remove the resource from their indices.
+    * Most use cases do not require clients and search engines to purge the resource, and a "404 Not Found" may be used instead.
+    */
+   GONE = 410,
+
+   /**
+    * The request did not specify the length of its content, which is required by the requested resource.
+    */
+   LENGTH_REQUIRED = 411,
+
+   /**
+    * The server does not meet one of the preconditions that the requester put on the request.
+    */
+   PRECONDITION_FAILED = 412,
+
+   /**
+    * The request is larger than the server is willing or able to process. Previously called "Request Entity Too Large".
+    */
+   PAYLOAD_TOO_LARGE = 413,
+
+   /**
+    * The URI provided was too long for the server to process. Often the result of too much data being encoded as a query-string of a GET request,
+    * in which case it should be converted to a POST request.
+    * Called "Request-URI Too Long" previously.
+    */
+   URI_TOO_LONG = 414,
+
+   /**
+    * The request entity has a media type which the server or resource does not support.
+    * For example, the client uploads an image as image/svg+xml, but the server requires that images use a different format.
+    */
+   UNSUPPORTED_MEDIA_TYPE = 415,
+
+   /**
+    * The client has asked for a portion of the file (byte serving), but the server cannot supply that portion.
+    * For example, if the client asked for a part of the file that lies beyond the end of the file.
+    * Called "Requested Range Not Satisfiable" previously.
+    */
+   RANGE_NOT_SATISFIABLE = 416,
+
+   /**
+    * The server cannot meet the requirements of the Expect request-header field.
+    */
+   EXPECTATION_FAILED = 417,
+
+   /**
+    * This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324, Hyper Text Coffee Pot Control Protocol,
+    * and is not expected to be implemented by actual HTTP servers. The RFC specifies this code should be returned by
+    * teapots requested to brew coffee. This HTTP status is used as an Easter egg in some websites, including Google.com.
+    */
+   I_AM_A_TEAPOT = 418,
+
+   /**
+    * The request was directed at a server that is not able to produce a response (for example because a connection reuse).
+    */
+   MISDIRECTED_REQUEST = 421,
+
+   /**
+    * The request was well-formed but was unable to be followed due to semantic errors.
+    */
+   UNPROCESSABLE_ENTITY = 422,
+
+   /**
+    * The resource that is being accessed is locked.
+    */
+   LOCKED = 423,
+
+   /**
+    * The request failed due to failure of a previous request (e.g., a PROPPATCH).
+    */
+   FAILED_DEPENDENCY = 424,
+
+   /**
+    * The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.
+    */
+   UPGRADE_REQUIRED = 426,
+
+   /**
+    * The origin server requires the request to be conditional.
+    * Intended to prevent "the 'lost update' problem, where a client
+    * GETs a resource's state, modifies it, and PUTs it back to the server,
+    * when meanwhile a third party has modified the state on the server, leading to a conflict."
+    */
+   PRECONDITION_REQUIRED = 428,
+
+   /**
+    * The user has sent too many requests in a given amount of time. Intended for use with rate-limiting schemes.
+    */
+   TOO_MANY_REQUESTS = 429,
+
+   /**
+    * The server is unwilling to process the request because either an individual header field,
+    * or all the header fields collectively, are too large.
+    */
+   REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+
+   /**
+    * A server operator has received a legal demand to deny access to a resource or to a set of resources
+    * that includes the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451.
+    */
+   UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+
+   /**
+    * A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
+    */
+   INTERNAL_SERVER_ERROR = 500,
+
+   /**
+    * The server either does not recognize the request method, or it lacks the ability to fulfill the request.
+    * Usually this implies future availability (e.g., a new feature of a web-service API).
+    */
+   NOT_IMPLEMENTED = 501,
+
+   /**
+    * The server was acting as a gateway or proxy and received an invalid response from the upstream server.
+    */
+   BAD_GATEWAY = 502,
+
+   /**
+    * The server is currently unavailable (because it is overloaded or down for maintenance).
+    * Generally, this is a temporary state.
+    */
+   SERVICE_UNAVAILABLE = 503,
+
+   /**
+    * The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
+    */
+   GATEWAY_TIMEOUT = 504,
+
+   /**
+    * The server does not support the HTTP protocol version used in the request
+    */
+   HTTP_VERSION_NOT_SUPPORTED = 505,
+
+   /**
+    * Transparent content negotiation for the request results in a circular reference.
+    */
+   VARIANT_ALSO_NEGOTIATES = 506,
+
+   /**
+    * The server is unable to store the representation needed to complete the request.
+    */
+   INSUFFICIENT_STORAGE = 507,
+
+   /**
+    * The server detected an infinite loop while processing the request.
+    */
+   LOOP_DETECTED = 508,
+
+   /**
+    * Further extensions to the request are required for the server to fulfill it.
+    */
+   NOT_EXTENDED = 510,
+
+   /**
+    * The client needs to authenticate to gain network access.
+    * Intended for use by intercepting proxies used to control access to the network (e.g., "captive portals" used
+    * to require agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
+    */
+   NETWORK_AUTHENTICATION_REQUIRED = 511
+}
+
+
+export class HttpError extends Error {
+   constructor(message: string, public status: HttpStatusCode) {
+      super(message)
+   }
+}
+
+export class NotFoundError extends HttpError {
+   constructor(message: string) {
+      super(message, HttpStatusCode.NOT_FOUND)
+   }
+}
+
+
+export class NoPermissionError extends HttpError {
+   constructor(message: string) {
+      super(message, HttpStatusCode.FORBIDDEN)
+   }
+}
+
+export class BadRequestError extends HttpError {
+   constructor(message: string) {
+      super(message, HttpStatusCode.BAD_REQUEST)
+   }
+}
+
+export class InternalServerError extends HttpError {
+   constructor(message: string) {
+      super(message, HttpStatusCode.INTERNAL_SERVER_ERROR)
+   }
+}

src/web/helper/form.ts

@@ -0,0 +1,20 @@
+import { Middleware } from "koa";
+import getTemplate from "./hb";
+
+interface IFormConfigField {
+   type: "text" | "number" | "boolean" | "textarea";
+   label: string;
+   value?: string;
+}
+
+type IFormConfig = { [name: string]: IFormConfigField }
+
+export default function getForm(url: string, title: string, fieldConfig: IFormConfig): Middleware {
+   let fields = Object.keys(fieldConfig).map(name => ({ name, ...fieldConfig[name] }))
+
+   return ctx => ctx.body = getTemplate("forms")({
+      url,
+      title,
+      fields
+   });
+}

src/web/helper/hb.ts

@@ -0,0 +1,55 @@
+import * as Handlebars from "handlebars";
+import { readFileSync } from "fs";
+import config from "../../config";
+import Logging from "@hibas123/logging";
+
+
+function checkCondition(v1, operator, v2) {
+   switch (operator) {
+      case '==':
+         return (v1 == v2);
+      case '===':
+         return (v1 === v2);
+      case '!==':
+         return (v1 !== v2);
+      case '<':
+         return (v1 < v2);
+      case '<=':
+         return (v1 <= v2);
+      case '>':
+         return (v1 > v2);
+      case '>=':
+         return (v1 >= v2);
+      case '&&':
+         return (v1 && v2);
+      case '||':
+         return (v1 || v2);
+      default:
+         return false;
+   }
+}
+
+Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {
+   return checkCondition(v1, operator, v2)
+      ? options.fn(this)
+      : options.inverse(this);
+});
+
+
+const formsTemplate = Handlebars.compile(readFileSync("./views/forms.hbs").toString());
+
+const cache = new Map<string, Handlebars.TemplateDelegate>();
+
+export default function getTemplate(name: string) {
+   let tl: Handlebars.TemplateDelegate;
+   if (!config.general.dev)
+      tl = cache.get(name);
+
+   if (!tl) {
+      Logging.debug("Recompiling template!");
+      tl = Handlebars.compile(readFileSync(`./views/${name}.hbs`).toString());
+      cache.set(name, tl);
+   }
+
+   return tl;
+}

src/web/helper/log.ts

@@ -0,0 +1,29 @@
+import { LoggingBase } from "@hibas123/nodelogging";
+import { Context } from "koa";
+import config from "../../config";
+
+const route_logging = new LoggingBase({ name: "access", files: { errorfile: null }, console: config.general.dev })
+const RequestLog = async (ctx: Context, next) => {
+   if (!config.general.access_log) return next();
+   let start = process.hrtime()
+   let to = false
+   let print = () => {
+      let td = process.hrtime(start)
+      let time = !to ? (td[0] * 1e3 + td[1] / 1e6).toFixed(2) : "--.--"
+      let resColor = ""
+      let status = ctx.status;
+      if (status >= 200 && status < 300) resColor = "\x1b[32m" //Green
+      else if (status === 304 || status === 302) resColor = "\x1b[33m"
+      else if (status >= 400 && status < 500) resColor = "\x1b[36m" //Cyan
+      else if (status >= 500 && status < 600) resColor = "\x1b[31m" //Red
+      let m = ctx.method
+      while (m.length < 4) m += " "
+      let message = `${m} ${ctx.originalUrl.split("?", 1)[0]} ${resColor}${status}\x1b[0m - ${time}ms`;
+      route_logging.log(message);
+   }
+   let timeout = new Promise((yes) => setTimeout(() => (to = true) && yes(), 10000));
+   await Promise.race([timeout, next()]);
+   print();
+};
+
+export default RequestLog;

src/web/helper/table.ts

@@ -0,0 +1,28 @@
+import { Context } from "koa";
+import getTemplate from "./hb";
+
+export default function getTable(title: string, data: any[], ctx: Context) {
+   let table: string[][] = [];
+
+   if (data.length > 0) {
+      if (typeof data[0] !== "object") {
+         table = [["value"], ...data.map(value => [value.toString()])];
+      } else {
+         if (Array.isArray(data[0])) {
+            table = data.map(row => row.map(col => col.toString()));
+         } else {
+            let fields = new Set<string>();
+            data.forEach(val => Object.keys(val).forEach(key => fields.add(key)))
+
+            let f = Array.from(fields.keys());
+
+            table = [f, ...data.map(value => f.map(key => value[key]))];
+         }
+      }
+   }
+   ctx.body = getTemplate("tables")({
+      title,
+      table,
+      empty: table.length <= 0
+   });
+}

src/web/index.ts

@@ -0,0 +1,16 @@
+import * as koa from "koa";
+import * as BodyParser from "koa-body";
+import RequestLog from "./helper/log";
+import RequestError from "./helper/error";
+import V1 from "./v1";
+
+const Web = new koa();
+
+Web.use(RequestLog)
+Web.use(RequestError);
+Web.use(BodyParser({}))
+
+Web.use(V1.routes())
+Web.use(V1.allowedMethods())
+
+export default Web;

src/web/v1/admin.ts

@@ -0,0 +1,113 @@
+import * as Router from "koa-router";
+import Settings from "../../settings";
+import getForm from "../helper/form";
+import Logging from "@hibas123/nodelogging";
+import getTable from "../helper/table";
+import { BadRequestError } from "../helper/errors";
+import { DatabaseManager } from "../../database/database";
+
+const AdminRoute = new Router();
+
+AdminRoute.use((ctx, next) => {
+   //TODO: Check permission
+   return next();
+})
+
+AdminRoute.get("/settings", async ctx => {
+   let res = await new Promise<string[][]>((yes, no) => {
+      const stream = Settings.db.createReadStream({
+         keys: true,
+         values: true,
+         valueAsBuffer: true
+      });
+      let res = [["key", "value"]];
+      stream.on("data", ({ key, value }) => {
+         res.push([key, value]);
+      })
+
+      stream.on("error", no);
+      stream.on("end", () => yes(res))
+   })
+
+   if (ctx.query.view) {
+      return getTable("Settings", res, ctx);
+   } else {
+      ctx.body = res;
+   }
+})
+
+AdminRoute.get("/data", async ctx => {
+   const { database } = ctx.query;
+   let db = DatabaseManager.getDatabase(database);
+   if (!db)
+      throw new BadRequestError("Database not found");
+   let res = await new Promise<string[][]>((yes, no) => {
+
+      const stream = db.level.createReadStream({
+         keys: true,
+         values: true,
+         valueAsBuffer: true
+      });
+      let res = [["key", "value"]];
+      stream.on("data", ({ key, value }) => {
+         res.push([key, value]);
+      })
+
+      stream.on("error", no);
+      stream.on("end", () => yes(res))
+   })
+
+   if (ctx.query.view) {
+      return getTable("Data from " + database, res, ctx);
+   } else {
+      ctx.body = res;
+   }
+})
+
+AdminRoute
+   .get("/database", ctx => {
+      const isFull = ctx.query.full === "true" || ctx.query.full === "1";
+      let res;
+      if (isFull) {
+         //TODO: Better than JSON.parse / JSON.stringify
+         res = Array.from(DatabaseManager.databases.entries()).map(([name, config]) => ({ name, ...(JSON.parse(JSON.stringify(config))) }));
+      } else {
+         res = Array.from(DatabaseManager.databases.keys());
+      }
+
+      if (ctx.query.view) {
+         return getTable("Databases" + (isFull ? "" : " small"), res, ctx);
+      } else {
+         ctx.body = res;
+      }
+   })
+   .post("/database", async ctx => {
+      const { name, rules, publickey, accesskey } = ctx.request.body;
+
+      if (!name)
+         throw new BadRequestError("Name must be set!");
+
+      let db = DatabaseManager.getDatabase(name);
+      if (!db)
+         db = await DatabaseManager.addDatabase(name);
+
+      if (publickey)
+         await db.setPublicKey(publickey);
+
+      if (rules)
+         await db.setRules(rules);
+      db
+      if (accesskey)
+         await db.setAccessKey(accesskey);
+
+      ctx.body = "Success";
+   })
+
+AdminRoute.get("/database/new", getForm("/v1/admin/database", "New/Change Database", {
+   name: { label: "Name", type: "text", },
+   accesskey: { label: "Access Key", type: "text" },
+   rules: { label: "Rules", type: "textarea", value: `{\n   ".write": true, \n   ".read": true \n}` },
+   publickey: { label: "Public Key", type: "textarea" }
+}))
+
+export default AdminRoute;

src/web/v1/index.ts

@@ -0,0 +1,5 @@
+import * as Router from "koa-router";
+import AdminRoute from "./admin";
+const V1 = new Router({ prefix: "/v1" });
+V1.use("/admin", AdminRoute.routes(), AdminRoute.allowedMethods());
+export default V1;

tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        /* Basic Options */
+        "target": "es2017", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
+        "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
+        "declaration": true, /* Generates corresponding '.d.ts' file. */
+        "sourceMap": true, /* Generates corresponding '.map' file. */
+        "outDir": "./lib", /* Redirect output structure to the directory. */
+        "strict": false, /* Enable all strict type-checking options. */
+        "preserveWatchOutput": true,
+        "experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
+        "emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
+        "resolveJsonModule": true
+    },
+    "exclude": [
+        "node_modules/"
+    ],
+    "include": [
+        "./src"
+    ]
+}

views/forms.hbs

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+   <meta charset="UTF-8">
+   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+   <meta http-equiv="X-UA-Compatible" content="ie=edge">
+   <title>{{title}}</title>
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1.2.6/out/light.css">
+
+   <style>
+      #message {
+         visibility: hidden;
+         background-color: lightgreen;
+         border: 1px solid lime;
+         border-radius: .5rem;
+         padding: 1rem;
+         font-size: 1.5rem;
+         margin-bottom: 1rem;
+      }
+   </style>
+</head>
+
+<body>
+   <div class="container">
+      <div class="margin" style="margin-top: 4rem;">
+         <h1>{{title}}</h1>
+         <div id="message"> </div>
+         <form id="f1" action="JavaScript:void(null)">
+            {{#each fields}}
+            <div class="input-group">
+               <label>{{label}}</label>
+               {{#ifCond type  "===" "text"}}
+               <input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
+               {{/ifCond}}
+
+               {{#ifCond type "===" "number"}}
+               <input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
+               {{/ifCond}}
+
+               {{#ifCond type "===" "boolean"}}
+               <input type="checkbox" name="{{name}}" checked="{{value}}" />
+               {{/ifCond}}
+
+               {{#ifCond type "===" "textarea"}}
+               <textarea class="inp" name="{{name}}" rows="20">{{value}}</textarea>
+               {{/ifCond}}
+            </div>
+            {{/each}}
+
+            <button class="btn btn-primary" onclick="submitData()">Submit</button>
+         </form>
+      </div>
+   </div>
+
+   <script>
+      const url = "{{url}}";
+
+      const message = document.getElementById("message");
+      const form = document.getElementById("f1");
+      function submitData() {
+         let res = {};
+         Array.from(new FormData(form).entries()).forEach(([name, value]) => res[name] = value);
+         fetch(url, {
+            method: "POST",
+            headers: {
+               "content-type": "application/json"
+            },
+            body: JSON.stringify(res)
+         }).then(res => {
+            return res.text();
+         }).then(res => {
+            message.innerText = res;
+            message.style.visibility = "unset";
+         })
+
+         return false;
+      }
+   </script>
+</body>
+
+</html>

views/tables.hbs

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+   <meta charset="UTF-8">
+   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+   <meta http-equiv="X-UA-Compatible" content="ie=edge">
+   <title>{{title}}</title>
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1.2.6/out/light.css">
+
+   <style>
+      table {
+         border-collapse: collapse;
+         width: 100%;
+      }
+
+      th,
+      td {
+         text-align: left;
+         padding: 8px;
+      }
+
+      tr:nth-child(even) {
+         background-color: #f2f2f2
+      }
+
+      tr:first-child {
+         background-color: var(--primary);
+         color: var(--on-primary);
+      }
+   </style>
+</head>
+
+<body>
+   <div class="container">
+      <div class="margin" style="margin-top: 4rem;">
+         <h1>{{title}}</h1>
+         {{#if empty}}
+         <h3>No Data available!</h3>
+         {{else}}
+
+         <table style="overflow-x: auto">
+            {{#each table as |row|}}
+            <tr>
+               {{#each row as |col|}}
+               <td>{{col}}</td>
+               {{/each}}
+            </tr>
+            {{/each}}
+         </table>
+         {{/if}}
+      </div>
+   </div>
+</body>
+
+</html>