.drone.yml

@@ -1,24 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-steps:
-  - name: Build with node
-    image: node:14
-    commands:
-      - npm config set registry https://npm.hibas123.de
-      - npm install
-      - npm run build
-  - name: Publish to docker
-    image: plugins/docker
-    settings:
-      username:
-        from_secret: docker_username
-      password:
-        from_secret: docker_password
-      auto_tag: true
-      repo: docker.hibas123.de/realtimedb
-      registry: docker.hibas123.de
-      debug: false
-    when:
-      branch: [master]

.editorconfig

@@ -1,8 +1,3 @@
-root=true
-[*]
 charset = utf-8
 indent_size = 3
 indent_style = space
-insert_final_newline = true
-[*.yml]
-indent_size = 2

.vscode/launch.json

@@ -1,20 +0,0 @@
-{
-   // Use IntelliSense to learn about possible attributes.
-   // Hover to view descriptions of existing attributes.
-   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-   "version": "0.2.0",
-   "configurations": [
-      {
-         "type": "pwa-node",
-         "request": "launch",
-         "name": "Launch Program",
-         "skipFiles": [
-            "<node_internals>/**"
-         ],
-         "program": "${workspaceFolder}\\lib\\index.js",
-         "outFiles": [
-            "${workspaceFolder}/**/*.js"
-         ]
-      }
-   ]
-}

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:14
+FROM node:12
 
 LABEL maintainer="Fabian Stamm <dev@fabianstamm.de>"
 
@@ -8,8 +8,6 @@ LABEL maintainer="Fabian Stamm <dev@fabianstamm.de>"
 RUN mkdir -p /usr/src/app
 WORKDIR /usr/src/app
 
-RUN npm config set registry https://npm.hibas123.de/
-
 ENV NODE_ENV=production
 
 COPY ["package.json", "package-lock.json", "/usr/src/app/"]

package.json

@@ -1,45 +1,48 @@
 {
   "name": "@hibas123/realtimedb",
-   "version": "2.0.0-beta.22",
+  "version": "2.0.0-beta.1",
   "description": "",
   "main": "lib/index.js",
   "private": true,
   "scripts": {
     "start": "node lib/index.js",
     "build": "tsc",
-      "watch": "nodemon -e ts --exec ts-node src/index.ts",
+    "watch-ts": "tsc -w",
+    "watch-node": "nodemon --ignore *.ts lib/index.js",
+    "watch": "concurrently \"npm:watch-*\"",
     "build-docker": "npm run build && docker build -t realtimedb .",
     "prepublishOnly": "tsc"
   },
   "author": "Fabian Stamm <dev@fabianstamm.de>",
   "license": "ISC",
   "devDependencies": {
-      "@types/jsonwebtoken": "^8.5.1",
+    "@types/dotenv": "^8.2.0",
-      "@types/koa": "^2.13.3",
+    "@types/jsonwebtoken": "^8.3.5",
-      "@types/koa-router": "^7.4.2",
+    "@types/koa": "^2.0.51",
-      "@types/leveldown": "^4.0.2",
+    "@types/koa-router": "^7.0.42",
-      "@types/levelup": "^4.3.1",
+    "@types/leveldown": "^4.0.1",
-      "@types/msgpack5": "^3.4.1",
+    "@types/levelup": "^3.1.1",
-      "@types/node": "^14.17.2",
+    "@types/nanoid": "^2.1.0",
-      "@types/ws": "^7.4.4",
+    "@types/node": "^12.12.5",
-      "nodemon": "^2.0.7",
+    "@types/ws": "^6.0.3",
-      "ts-node": "^10.0.0",
+    "concurrently": "^5.0.0",
-      "typescript": "^4.3.2"
+    "nodemon": "^1.19.4",
+    "typescript": "^3.6.4"
   },
   "dependencies": {
-      "@hibas123/logging": "^3.1.2",
+    "@hibas123/logging": "^2.1.1",
-      "@hibas123/nodelogging": "^3.1.3",
+    "@hibas123/nodelogging": "^2.1.1",
-      "@hibas123/utils": "^2.2.18",
+    "@hibas123/utils": "^2.1.1",
-      "dotenv": "^10.0.0",
+    "dotenv": "^8.2.0",
-      "handlebars": "^4.7.7",
+    "handlebars": "^4.5.1",
     "jsonwebtoken": "^8.5.1",
-      "koa": "^2.13.1",
+    "koa": "^2.11.0",
-      "koa-body": "^4.2.0",
+    "koa-body": "^4.1.1",
-      "koa-router": "^10.0.0",
+    "koa-router": "^7.4.0",
-      "leveldown": "^6.0.0",
+    "leveldown": "^5.4.1",
-      "levelup": "^5.0.0",
+    "levelup": "^4.3.2",
-      "msgpack5": "^5.3.2",
+    "nanoid": "^2.1.6",
-      "nanoid": "^3.1.23",
+    "what-the-pack": "^2.0.3",
-      "ws": "^7.4.6"
+    "ws": "^7.2.0"
   }
 }

src/config.ts

@@ -1,24 +1,20 @@
 import Logging from "@hibas123/nodelogging";
 import * as dotenv from "dotenv";
-import { LoggingTypes } from "@hibas123/logging";
+dotenv.config()
-dotenv.config();
+
 
 interface IConfig {
    port: number;
    admin: string;
    access_log: boolean;
-   dev: boolean;
+   dev: boolean
 }
 
 const config: IConfig = {
    port: Number(process.env.PORT),
    access_log: (process.env.ACCESS_LOG || "").toLowerCase() === "true",
    admin: process.env.ADMIN_KEY,
-   dev: (process.env.DEV || "").toLowerCase() === "true",
+   dev: (process.env.DEV || "").toLowerCase() === "true"
-};
-
-if (config.dev) {
-   Logging.logLevel = LoggingTypes.Log;
 }
 
 export default config;

src/connection.ts

@@ -0,0 +1,224 @@
+import * as WebSocket from "ws";
+import { Server, IncomingMessage } from "http";
+import { DatabaseManager } from "./database/database";
+import Logging from "@hibas123/logging";
+import Query from "./database/query";
+import Session from "./database/session";
+import nanoid = require("nanoid");
+
+import * as JWT from "jsonwebtoken";
+
+async function verifyJWT(token: string, publicKey: string) {
+   return new Promise<any | undefined>((yes) => {
+      JWT.verify(token, publicKey, (err, decoded) => {
+         if (err)
+            yes(undefined);
+         else
+            yes(decoded);
+      })
+   })
+}
+
+const StoreSym = Symbol("store");
+function StoreQuery(result?: any) {
+   return {
+      [StoreSym]: true,
+      result
+   }
+}
+
+function DeleteQuery(result?: any) {
+   return {
+      [StoreSym]: false,
+      result
+   }
+}
+
+import { URLSearchParams } from "url";
+
+type QueryTypes = "keys" | "get" | "set" | "update" | "delete" | "push" | "subscribe" | "unsubscribe";
+
+export class ConnectionManager {
+   static server: WebSocket.Server;
+
+   static bind(server: Server) {
+      this.server = new WebSocket.Server({ server });
+      this.server.on("connection", this.onConnection.bind(this));
+   }
+
+   private static async onConnection(socket: WebSocket, req: IncomingMessage) {
+      Logging.log("New Connection:");
+      const sendError = (error: string) => socket.send(JSON.stringify({ ns: "error_msg", data: error }));
+
+
+      const session = new Session(nanoid());
+
+      let query = new URLSearchParams(req.url.split("?").pop());
+
+      const database = query.get("database");
+      const db = DatabaseManager.getDatabase(database);
+      if (!db) {
+         sendError("Invalid Database!");
+         socket.close();
+         return;
+      }
+
+      const accesskey = query.get("accesskey");
+      if (db.accesskey) {
+         if (!accesskey || accesskey !== db.accesskey) {
+            sendError("Unauthorized!");
+            socket.close();
+            return;
+         }
+      }
+
+      const authkey = query.get("authkey");
+      if (authkey && db.publickey) {
+         let res = await verifyJWT(authkey, db.publickey);
+         if (!res || !res.uid) {
+            sendError("Invalid JWT");
+            socket.close();
+            return;
+         } else {
+            session.uid = res.uid;
+         }
+      }
+
+      const rootkey = query.get("rootkey");
+      if (rootkey && db.rootkey) {
+         if (rootkey === db.rootkey) {
+            session.root = true;
+            Logging.warning(`Somebody logged into ${database} via rootkey`);
+         }
+      }
+
+      const stored = new Map<string, Query>();
+      const answer = (id: string, data: any, error: boolean = false) => {
+         socket.send(JSON.stringify({ ns: "message", data: { id, error, data } }));
+      }
+
+      const handler = new Map<string, ((data: any) => void)>();
+      type QueryData = { id: string, type: QueryTypes, path: string[], data: any, options: any };
+
+      const queryHandler = new Map<string, (query: Query, permissions: { read: boolean, write: boolean }, data?: any) => Promise<any>>();
+
+      const noperm = new Error("No permisison!");
+
+      if (session.root) {
+         queryHandler.set("collections", (query, perm, data) => {
+            return query.getCollections();
+         })
+
+         queryHandler.set("delete-collection", (query, perm, data) => {
+            return query.deleteCollection();
+         })
+      }
+
+      queryHandler.set("keys", (query, perm, data) => {
+         if (!perm.read)
+            throw noperm;
+         return query.keys();
+      })
+
+      queryHandler.set("get", (query, perm, data) => {
+         if (!perm.read)
+            throw noperm;
+         return query.get();
+      })
+
+      queryHandler.set("set", (query, perm, data) => {
+         if (!perm.write)
+            throw noperm;
+         return query.set(data, {});
+      })
+
+      queryHandler.set("update", (query, perm, data) => {
+         if (!perm.write)
+            throw noperm;
+         return query.update(data);
+      })
+
+      queryHandler.set("push", (query, perm, data) => {
+         if (!perm.write)
+            throw noperm;
+         return query.push(data);
+      })
+
+      queryHandler.set("delete", (query, perm, data) => {
+         if (!perm.write)
+            throw noperm;
+         return query.delete();
+      })
+
+      queryHandler.set("subscribe", async (query, perm, data) => {
+         if (!perm.read)
+            throw noperm;
+
+         let subscriptionID = nanoid();
+
+         query.subscribe((data) => {
+            socket.send(JSON.stringify({ ns: "event", data: { id: subscriptionID, data } }));
+         }, data.types, data.options);
+
+         return StoreQuery(subscriptionID);
+      })
+
+      queryHandler.set("unsubscribe", async (query, perm, data) => {
+         query.unsubscribe();
+         return DeleteQuery(true);
+      })
+
+      handler.set("query", async ({ id, type, path, data }: QueryData) => {
+         //TODO: Handle case with no id, type, path
+         Logging.debug(`Request with id '${id}' from type '${type}' and path '${path}' with data`, data)
+
+         try {
+            if (!db)
+               throw new Error("Database not found!");
+            else {
+               let handler = queryHandler.get(type);
+               if (!handler) {
+                  throw new Error("Invalid Request!");
+               } else {
+                  const query = stored.get(id) || db.getQuery(path || [], session.sessionid);
+                  const perms = db.rules.hasPermission(path, session);
+
+                  let res = await handler(query, perms, data);
+                  if (res && typeof res === "object" && res[StoreSym] !== undefined) {
+                     if (res[StoreSym])
+                        stored.set(id, query);
+                     else
+                        stored.delete(id);
+
+                     res = res.result;
+                  }
+                  answer(id, res);
+               }
+            }
+         } catch (err) {
+            // Logging.error(err);
+            Logging.debug("Sending error:", err);
+            answer(id, err.message, true);
+         }
+      })
+
+      socket.on("message", async (rawData: string) => {
+         try {
+            let message: { ns: string, data: any } = JSON.parse(rawData);
+            let h = handler.get(message.ns);
+            if (h) {
+               h(message.data);
+            }
+         } catch (err) {
+            Logging.errorMessage("Unknown Error:");
+            Logging.error(err);
+         }
+      })
+
+      socket.on("disconnect", () => {
+         stored.forEach(query => query.unsubscribe());
+         stored.clear();
+         socket.removeAllListeners();
+      })
+   }
+}

src/database/database.ts

@@ -1,31 +1,8 @@
+import { Rules } from "./rules";
 import Settings from "../settings";
-import getLevelDB, { deleteLevelDB, resNull } from "../storage";
+import getLevelDB, { LevelDB, deleteLevelDB } from "../storage";
 import DocumentLock from "./lock";
-import {
+import Query from "./query";
-   DocumentQuery,
-   CollectionQuery,
-   Query,
-   QueryError,
-   ITypedQuery,
-   IQuery,
-} from "./query";
-import Logging from "@hibas123/nodelogging";
-import Session from "./session";
-import nanoid = require("nanoid");
-import { Observable } from "@hibas123/utils";
-import { RuleRunner } from "../rules/compile";
-import compileRule from "../rules";
-import { RuleError } from "../rules/error";
-
-const ALPHABET =
-   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-const longNanoId = nanoid.customAlphabet(ALPHABET, 32);
-const shortNanoId = nanoid.customAlphabet(ALPHABET, 16);
-
-// interface ITransaction {
-//    queries: ITypedQuery<IWriteQueries>[];
-// }
 
 export class DatabaseManager {
    static databases = new Map<string, Database>();
@@ -33,20 +10,15 @@ export class DatabaseManager {
    static async init() {
       let databases = await Settings.getDatabases();
 
-      databases.forEach((dbconfig) => {
+      databases.forEach(dbconfig => {
-         let db = new Database(
+         let db = new Database(dbconfig.name, dbconfig.accesskey, dbconfig.rules, dbconfig.publickey, dbconfig.rootkey);
-            dbconfig.name,
-            dbconfig.accesskey,
-            dbconfig.rules,
-            dbconfig.publickey,
-            dbconfig.rootkey
-         );
          this.databases.set(dbconfig.name, db);
-      });
+      })
    }
 
    static async addDatabase(name: string) {
-      if (this.databases.has(name)) throw new Error("Database already exists!");
+      if (this.databases.has(name))
+         throw new Error("Database already exists!");
 
       await Settings.addDatabase(name);
       let database = new Database(name);
@@ -59,11 +31,11 @@ export class DatabaseManager {
    }
 
    static async deleteDatabase(name: string) {
-      let db = this.databases.get(name);
+      let db = this.databases.get(name)
       if (db) {
          await Settings.deleteDatabase(name);
          await db.stop();
-         await deleteLevelDB(db.name);
+         await deleteLevelDB(db.name)
       }
    }
 }
@@ -73,96 +45,47 @@ export type ChangeTypes = "added" | "modified" | "deleted";
 export type Change = {
    data: any;
    document: string;
-   collection: string;
    type: ChangeTypes;
    sender: string;
-};
+}
+
 
 export class Database {
-   public static getKey(collectionid: string, documentid?: string) {
+   private level = getLevelDB(this.name);
-      return `${collectionid || ""}/${documentid || ""}`;
-   }
-
-   #level = getLevelDB(this.name);
 
    get data() {
-      return this.#level.data;
+      return this.level.data;
    }
 
    get collections() {
-      return this.#level.collection;
+      return this.level.collection;
    }
 
-   #rules: RuleRunner;
-   #rawRules?: string;
 
-   get rawRules() {
+   public rules: Rules;
-      return this.#rawRules;
+   public locks = new DocumentLock()
-   }
+   public collectionLocks = new DocumentLock()
 
-   get rules() {
+   public changes = new Map<string, Set<(change: Change) => void>>();
-      return this.#rules;
-   }
-
-   public connections = 0;
-
-   private locks = new DocumentLock();
-   public collectionLocks = new DocumentLock();
-
-   public changeListener = new Map<string, Set<(change: Change[]) => void>>();
-   public collectionChangeListener = new Observable<{
-      key: string;
-      id: string;
-      type: "create" | "delete";
-   }>();
 
    toJSON() {
       return {
          name: this.name,
          accesskey: this.accesskey,
          publickey: this.publickey,
-         rules: this.#rules,
+         rules: this.rules
-         connections: this.connections,
+      }
-      };
    }
 
-   constructor(
+   constructor(public name: string, public accesskey?: string, rawRules?: string, public publickey?: string, public rootkey?: string) {
-      public name: string,
+      if (rawRules)
-      public accesskey?: string,
+         this.rules = new Rules(rawRules);
-      rawRules?: string,
-      public publickey?: string,
-      public rootkey?: string
-   ) {
-      if (rawRules) this.applyRules(rawRules);
    }
 
-   private applyRules(rawRules: string): undefined | RuleError {
+   async setRules(rawRules: string) {
-      try {
+      let rules = new Rules(rawRules);
-         JSON.parse(rawRules);
-         Logging.warning(
-            "Found old rule! Replacing with a 100% permissive one!"
-         );
-         rawRules =
-            "service realtimedb {\n   match /* {\n      allow read, write, list: if false; \n   }\n}";
-         // still json, so switching to
-      } catch (err) { }
-
-      let { runner, error } = compileRule(rawRules);
-      if (error) {
-         Logging.warning("Found error in existing config!", error);
-         runner = compileRule("service realtimesb {}").runner;
-      }
-      this.#rules = runner;
-      this.#rawRules = rawRules;
-      return undefined;
-   }
-
-   async setRules(rawRules: string): Promise<RuleError | undefined> {
-      const { runner, error } = compileRule(rawRules);
-      if (error) return error;
       await Settings.setDatabaseRules(this.name, rawRules);
-      this.#rules = runner;
+      this.rules = rules;
-      this.#rawRules = rawRules;
    }
 
    async setAccessKey(key: string) {
@@ -180,312 +103,12 @@ export class Database {
       this.publickey = key;
    }
 
-   public async resolve(
-      path: string[],
-      create = false
-   ): Promise<{ collection: string; document: string; collectionKey: string }> {
-      path = [...path]; // Create modifiable copy
-      let collectionID: string = undefined;
-      let documentKey = path.length % 2 === 0 ? path.pop() : undefined;
-      let key = path.join("/");
 
-      const lock = await this.collectionLocks.lock(key);
+   getQuery(path: string[], sender: string) {
-
+      return new Query(this, path, sender);
-      try {
-         collectionID = await this.collections
-            .get(key)
-            .then((r) => r.toString())
-            .catch(resNull);
-         if (!collectionID && create) {
-            collectionID = longNanoId();
-            await this.collections.put(key, collectionID);
-            setImmediate(() => {
-               this.collectionChangeListener.send({
-                  id: collectionID,
-                  key,
-                  type: "create",
-               });
-            });
-         }
-      } finally {
-         lock();
-      }
-
-      return {
-         collection: collectionID,
-         document: documentKey,
-         collectionKey: key,
-      };
-   }
-
-   private sendChanges(changes: Change[]) {
-      let col = new Map<string, Map<string, Change[]>>();
-      changes.forEach((change) => {
-         let e = col.get(change.collection);
-         if (!e) {
-            e = new Map();
-            col.set(change.collection, e);
-         }
-
-         let d = e.get(change.document);
-         if (!d) {
-            d = [];
-            e.set(change.document, d);
-         }
-
-         d.push(change);
-      });
-
-      setImmediate(() => {
-         for (let [collection, documents] of col.entries()) {
-            let collectionChanges = [];
-            for (let [document, documentChanges] of documents.entries()) {
-               let s = this.changeListener.get(
-                  Database.getKey(collection, document)
-               );
-               if (s) s.forEach((e) => setImmediate(() => e(documentChanges)));
-
-               collectionChanges.push(...documentChanges);
-            }
-            let s = this.changeListener.get(Database.getKey(collection));
-            if (s) s.forEach((e) => setImmediate(() => e(collectionChanges)));
-         }
-      });
-   }
-
-   private validate(query: ITypedQuery<any>) {
-      const inv = new QueryError("Malformed query!");
-      if (!query || typeof query !== "object") throw inv;
-
-      if (!query.type) throw inv;
-
-      if (!query.path) throw inv;
-   }
-
-   async run(queries: IQuery[], session: Session) {
-      let resolve: {
-         path: string[];
-         create: boolean;
-         resolved?: [string, string, string];
-      }[] = [];
-
-      const addToResolve = (path: string[], create?: boolean) => {
-         let entry = resolve.find((e) => {
-            //TODO: Find may be slow...
-            if (e.path.length !== path.length) return false;
-            for (let i = 0; i < e.path.length; i++) {
-               if (e.path[i] !== path[i]) return false;
-            }
-            return true;
-         });
-
-         if (!entry) {
-            entry = {
-               path,
-               create,
-            };
-            resolve.push(entry);
-         }
-
-         entry.create = entry.create || create;
-
-         return entry;
-      };
-
-      const isBatch = queries.length > 1;
-      let parsed = queries.map((rawQuery) => {
-         Logging.debug("Running query:", rawQuery.type);
-         this.validate(rawQuery);
-         const isCollection = rawQuery.path.length % 2 === 1;
-
-         let query = isCollection
-            ? new CollectionQuery(this, session, rawQuery)
-            : new DocumentQuery(this, session, rawQuery);
-
-         if (isBatch && !query.batchCompatible)
-            throw new Error("There are queries that are not batch compatible!");
-
-         let path = addToResolve(rawQuery.path, query.createCollection);
-         if (query.additionalLock) addToResolve(query.additionalLock);
-
-         return {
-            path,
-            query,
-         };
-      });
-
-      resolve = resolve.sort((a, b) => a.path.length - b.path.length);
-
-      let locks: (() => void)[] = [];
-      for (let e of resolve) {
-         let { collection, document, collectionKey } = await this.resolve(
-            e.path,
-            e.create
-         );
-         e.resolved = [collection, document, collectionKey];
-
-         locks.push(await this.locks.lock(collection, document));
-      }
-
-      let result = [];
-      try {
-         let batch = this.data.batch();
-         let changes: Change[] = [];
-         for (let e of parsed) {
-            result.push(
-               await e.query.run(
-                  e.path.resolved[0],
-                  e.path.resolved[1],
-                  batch,
-                  e.path.resolved[2]
-               )
-            );
-            changes.push(...e.query.changes);
-         }
-         if (batch.length > 0) await batch.write();
-
-         this.sendChanges(changes);
-      } finally {
-         locks.forEach((lock) => lock());
-      }
-
-      if (isBatch) return result;
-      else return result[0];
-   }
-
-   async snapshot(
-      rawQuery: ITypedQuery<"snapshot">,
-      session: Session,
-      onchange: (change: any) => void
-   ) {
-      Logging.debug("Snaphot request:", rawQuery.path);
-      this.validate(rawQuery);
-
-      if (rawQuery.type !== "snapshot") throw new Error("Invalid query type!");
-
-      const isCollection = rawQuery.path.length % 2 === 1;
-      let query = isCollection
-         ? new CollectionQuery(this, session, rawQuery, true)
-         : new DocumentQuery(this, session, rawQuery, true);
-
-      const { unsubscribe, value } = await query.snapshot(onchange);
-
-      const id = shortNanoId();
-      session.subscriptions.set(id, unsubscribe);
-      return {
-         id,
-         snaphot: value,
-      };
-   }
-
-   async unsubscribe(id: string, session: Session) {
-      let query = session.subscriptions.get(id);
-      if (query) {
-         query();
-         session.subscriptions.delete(id);
-      }
    }
 
    async stop() {
       await this.data.close();
    }
-
-   public async runCleanup() {
-      const should = await new Promise<Set<string>>((yes, no) => {
-         const stream = this.collections.iterator({
-            keyAsBuffer: false,
-            valueAsBuffer: false,
-         });
-
-         const collections = new Set<string>();
-         const onValue = (err: Error, key: string, value: string) => {
-            if (err) {
-               Logging.error(err);
-               stream.end((err) => Logging.error(err));
-               no(err);
-            }
-
-            if (!key && !value) {
-               yes(collections);
-            } else {
-               collections.add(value);
-               stream.next(onValue);
-            }
-         };
-
-         stream.next(onValue);
-      });
-
-      const existing = await new Promise<Set<string>>((yes, no) => {
-         const stream = this.data.iterator({
-            keyAsBuffer: false,
-            values: false,
-         });
-
-         const collections = new Set<string>();
-         const onValue = (err: Error, key: string, value: Buffer) => {
-            if (err) {
-               Logging.error(err);
-               stream.end((err) => Logging.error(err));
-               no(err);
-            }
-
-            if (!key && !value) {
-               yes(collections);
-            } else {
-               let coll = key.split("/")[0];
-               collections.add(coll);
-               stream.next(onValue);
-            }
-         };
-
-         stream.next(onValue);
-      });
-
-      const toDelete = new Set<string>();
-      existing.forEach((collection) => {
-         if (!should.has(collection)) toDelete.add(collection);
-      });
-
-      for (let collection of toDelete) {
-         const batch = this.data.batch();
-
-         let gt = Buffer.from(collection + "/ ");
-         gt[gt.length - 1] = 0;
-
-         let lt = Buffer.alloc(gt.length);
-         lt.set(gt);
-         lt[gt.length - 1] = 0xff;
-
-         await new Promise<void>((yes, no) => {
-            const stream = this.data.iterator({
-               keyAsBuffer: false,
-               values: false,
-               gt,
-               lt,
-            });
-
-            const onValue = (err: Error, key: string, value: Buffer) => {
-               if (err) {
-                  Logging.error(err);
-                  stream.end((err) => Logging.error(err));
-                  no(err);
-               }
-
-               if (!key && !value) {
-                  yes();
-               } else {
-                  batch.del(key);
-                  stream.next(onValue);
-               }
-            };
-
-            stream.next(onValue);
-         });
-
-         await batch.write();
-      }
-
-      return Array.from(toDelete.values());
-   }
 }

src/database/lock.ts

@@ -4,26 +4,24 @@ export default class DocumentLock {
    private locks = new Map<string, (() => void)[]>();
 
    getLocks() {
-      return Array.from(this.locks.keys());
+      return Array.from(this.locks.keys())
    }
 
    async lock(collection: string = "", document: string = "") {
-      //TODO: Check collection locks
       let key = collection + "/" + document;
       let l = this.locks.get(key);
       if (l)
-         await new Promise<void>((resolve) => {
+         await new Promise(resolve => { l.push(resolve); this.locks.set(key, l) });
-            l.push(resolve);
-            this.locks.set(key, l);
-         });
       else {
          l = [];
          this.locks.set(key, l);
       }
 
       return () => {
-         if (l.length > 0) setImmediate(() => l.shift()());
+         if (l.length > 0)
-         else this.locks.delete(key);
+            setImmediate(() => l.shift());
-      };
+         else
+            this.locks.delete(key)
+      }
    }
 }

src/database/query.ts

@@ -1,730 +1,293 @@
 import { Database, Change, ChangeTypes } from "./database";
 import { resNull } from "../storage";
-import * as nanoid from "nanoid";
+import nanoid = require("nanoid/generate");
 import Logging from "@hibas123/nodelogging";
-import * as MSGPack from "msgpack5";
+import * as MSGPack from "what-the-pack";
-import Session from "./session";
-import { LevelUpChain } from "levelup";
-import { Operations } from "../rules/parser";
 
-export type IWriteQueries = "set" | "update" | "delete" | "add";
+export const MP = MSGPack.initialize(2 ** 20);
-export type ICollectionQueries =
-   | "get"
-   | "add"
-   | "keys"
-   | "delete-collection"
-   | "list";
-export type IDocumentQueries = "get" | "set" | "update" | "delete";
 
-export interface ITypedQuery<T> {
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-   path: string[];
-   type: T;
-   data?: any;
-   options?: any;
-}
-
-export type IQuery = ITypedQuery<
-   ICollectionQueries | IDocumentQueries | "snapshot"
->;
-
-export const MP = MSGPack({});
-
-// MSGPack.initialize(2 ** 20);
-
-const ALPHABET =
-   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-const longNanoID = nanoid.customAlphabet(ALPHABET, 32);
 
 const { encode, decode } = MP;
 
-type Runner = (
+interface ISubscribeOptions {
-   collection: string,
+   existing: boolean;
-   document: string,
-   batch: LevelUpChain,
-   collectionKey: string
-) => any;
-
-interface IPreparedQuery {
-   createCollection: boolean;
-   needDocument: boolean;
-   batchCompatible: boolean;
-   runner: Runner;
-   permission: Operations;
-   additionalLock?: string[];
 }
 
-interface DocRes {
+export default class Query {
-   id: string;
-   data: any;
-}
-
-export abstract class Query {
    /**
     * Returns true if the path only contains valid characters and false if it doesn't
     * @param path Path to be checked
     */
    private validatePath(path: string[]) {
-      return path.every(
+      return path.every(e => (e.match(/[^a-zA-Z0-9_\-\<\>]/g) || []).length === 0);
-         (e) => (e.match(/[^a-zA-Z0-9_\-\<\>]/g) || []).length === 0
-      );
    }
 
-   public changes: Change[] = [];
+   constructor(private database: Database, private path: string[], private sender: string) {
-
+      if (path.length > 10) {
-   public readonly createCollection: boolean;
+         throw new Error("Path is to long. Path is only allowed to be 10 Layers deep!");
-   public readonly needDocument: boolean;
-   public readonly batchCompatible: boolean;
-   public readonly additionalLock?: string[];
-   public readonly permission: Operations;
-   private readonly _runner: Runner;
-
-   constructor(
-      protected database: Database,
-      protected session: Session,
-      protected query: IQuery,
-      snapshot = false
-   ) {
-      if (query.path.length > 10) {
-         throw new QueryError(
-            "Path is to long. Path is only allowed to be 10 Layers deep!"
-         );
       }
-      if (!this.validatePath(query.path)) {
+      if (!this.validatePath(path)) {
-         throw new QueryError(
+         throw new Error("Path can only contain a-z A-Z 0-9  '-' '-' '<' and '>' ");
-            "Path can only contain a-z A-Z 0-9  '-' '-' '<' and '>' "
-         );
       }
 
-      if (!snapshot) {
+      this.onChange = this.onChange.bind(this);
-         let data = this.prepare(query);
-         this.createCollection = data.createCollection;
-         this.needDocument = data.needDocument;
-         this.batchCompatible = data.batchCompatible;
-         this.additionalLock = data.additionalLock;
-         this.permission = data.permission;
-         this._runner = data.runner;
-      }
    }
 
-   protected abstract prepare(query: IQuery): IPreparedQuery;
 
-   protected getDoc(collection: string, document: string) {
+   private async resolve(path: string[], create = false): Promise<{ collection: string, document: string, collectionKey: string }> {
-      return this.database.data
+      path = [...path]; // Create modifiable copy
-         .get(Database.getKey(collection, document), { asBuffer: true })
+      let collectionID: string = undefined;
-         .then((res) => decode(res as Buffer))
+      let documentKey = path.length % 2 === 0 ? path.pop() : undefined;
-         .catch(resNull);
+      let key = path.join("/");
+
+      const lock = await this.database.collectionLocks.lock(key);
+
+      try {
+         collectionID = await this.database.collections.get(key).then(r => r.toString()).catch(resNull);
+         if (!collectionID && create) {
+            collectionID = nanoid(ALPHABET, 32);
+            await this.database.collections.put(key, collectionID);
+         }
+      } finally {
+         lock();
       }
 
-   protected sendChange(
+      return {
-      collection: string,
+         collection: collectionID,
-      document: string,
+         document: documentKey,
-      type: ChangeTypes,
+         collectionKey: key
-      data: any
+      };
-   ) {
+   }
+
+   private getKey(collection: string, document?: string) {
+      return `${collection || ""}/${document || ""}`;
+   }
+
+   private getDoc(collection: string, document: string) {
+      return this.database.data.get(this.getKey(collection, document), { asBuffer: true }).then(res => decode(res as Buffer)).catch(resNull);
+   }
+
+   private sendChange(collection: string, document: string, type: ChangeTypes, data: any) {
       let change: Change = {
          type,
          document,
-         collection,
          data,
-         sender: this.session.id,
+         sender: this.sender
-      };
-
-      Logging.debug("Sending change:", change);
-
-      this.changes.push(change);
       }
 
-   protected static getConstructorParams(
+      let s = this.database.changes.get(this.getKey(collection, document))
-      query: Query
+      if (s)
-   ): [Database, Session, IQuery] {
+         s.forEach(e => setImmediate(() => e(change)))
-      return [query.database, query.session, query.query];
+      s = this.database.changes.get(this.getKey(collection))
+      if (s)
+         s.forEach(e => setImmediate(() => e(change)))
+
    }
 
-   protected abstract checkChange(change: Change): boolean;
+   public async get() {
-   protected abstract firstSend(
+      let { collection, document } = await this.resolve(this.path);
-      collection: string,
-      document: string
-   ): Promise<any>;
 
-   public run(
-      collection: string,
-      document: string,
-      batch: LevelUpChain,
-      collectionKey: string
-   ) {
-      let perm = this.database.rules.hasPermission(
-         this.query.path,
-         this.permission,
-         this.session
-      );
-
-      if (!perm) throw new QueryError("No permission!");
-
-      // this.query.path = perm.path;
-      return this._runner.call(
-         this,
-         collection,
-         document,
-         batch,
-         collectionKey
-      );
-   }
-
-   public async snapshot(
-      onChange: (change: (DocRes & { type: ChangeTypes })[]) => void
-   ) {
-      let perm = this.database.rules.hasPermission(
-         this.query.path,
-         "read",
-         this.session
-      );
-      if (!perm) {
-         throw new QueryError("No permission!");
-      }
-
-      const receivedChanges = (changes: Change[]) => {
-         let res = changes
-            .filter((change) => this.checkChange(change))
-            .map((change) => {
-               return {
-                  id: change.document,
-                  data: change.data,
-                  type: change.type,
-               };
-            });
-         if (res.length > 0) onChange(res);
-      };
-
-      const unsub = this.database.collectionChangeListener.subscribe(
-         (change) => {
-            if (change.key === collectionKey) {
-               if (change.type === "create") addSubscriber(change.id);
-               else removeSubscriber(); // Send delete for all elements (Don't know how to do this...)
-            }
-         }
-      );
-
-      let { collection, document, collectionKey } = await this.database.resolve(
-         this.query.path
-      );
-      let oldKey: string = undefined;
-
-      const removeSubscriber = () => {
-         if (!oldKey) return;
-         let s = this.database.changeListener.get(oldKey);
-         if (s) {
-            s.delete(receivedChanges);
-            if (s.size <= 0) this.database.changeListener.delete(oldKey);
-         }
-         oldKey = undefined;
-      };
-
-      const addSubscriber = (collection: string) => {
-         let key = Database.getKey(collection, document);
-         if (oldKey !== key) {
-            if (oldKey !== undefined) removeSubscriber();
-
-            let s = this.database.changeListener.get(key);
-            if (!s) {
-               s = new Set();
-               this.database.changeListener.set(key, s);
-            }
-
-            s.add(receivedChanges);
-         }
-      };
-
-      if (collection) {
-         addSubscriber(collection);
-      }
-
-      return {
-         unsubscribe: () => {
-            unsub();
-            removeSubscriber();
-         },
-         value: await this.firstSend(collection, document),
-      };
-   }
-}
-
-interface UpdateData {
-   [path: string]: {
-      type: "value" | "timestamp" | "increment" | "push";
-      value: any;
-   };
-}
-export class DocumentQuery extends Query {
-   prepare(query: IQuery): IPreparedQuery {
-      let type = query.type as IDocumentQueries;
-      switch (type) {
-         case "get":
-            return {
-               batchCompatible: false,
-               createCollection: false,
-               needDocument: false,
-               permission: "read",
-               runner: this.get,
-            };
-         case "set":
-            return {
-               batchCompatible: true,
-               createCollection: true,
-               needDocument: true,
-               permission: "write",
-               runner: this.set,
-            };
-         case "update":
-            return {
-               batchCompatible: true,
-               createCollection: true,
-               needDocument: true,
-               permission: "write",
-               runner: this.update,
-            };
-         case "delete":
-            return {
-               batchCompatible: true,
-               createCollection: false,
-               needDocument: true,
-               permission: "write",
-               runner: this.delete,
-            };
-         default:
-            throw new Error("Invalid query type: " + type);
-      }
-   }
-
-   private async get(collection: string, document: string) {
       if (!collection || !document) {
          return null;
       }
-
+      const lock = await this.database.locks.lock(collection, document);
-      return this.getDoc(collection, document);
+      return this.getDoc(collection, document).finally(() => lock())
    }
 
-   private async set(
+   public async keys() {
-      collection: string,
+      let { collection, document } = await this.resolve(this.path);
-      document: string,
+      if (document)
-      batch?: LevelUpChain
+         throw new Error("Keys only works on collections!");
-   ) {
+      if (!collection)
-      const { data, options } = this.query;
+         throw new Error("There must be a collection");
-      if (data === null) return this.delete(collection, document, batch);
 
-      let isNew = !(await this.getDoc(collection, document));
-      batch.put(Database.getKey(collection, document), encode(data));
-      this.sendChange(collection, document, isNew ? "added" : "modified", data);
-   }
 
-   private async update(
+      let gt = Buffer.from(this.getKey(collection) + " ");
-      collection: string,
-      document: string,
-      batch?: LevelUpChain
-   ) {
-      const updateData: UpdateData = this.query.data;
-
-      let data = await this.getDoc(collection, document);
-      let isNew = false;
-      if (!data) {
-         isNew = true;
-         data = {};
-      }
-
-      for (let path in updateData) {
-         const toUpdate = updateData[path];
-         let d = data;
-         let parts = path.split(".");
-         while (parts.length > 1) {
-            let seg = parts.shift();
-            if (!data[seg]) data[seg] = {};
-            d = data[seg];
-         }
-
-         const last = parts[0];
-
-         switch (toUpdate.type) {
-            case "value":
-               d[last] = toUpdate.value;
-               break;
-            case "increment":
-               if (d[last] === undefined || d[last] === null)
-                  d[last] = toUpdate.value;
-               else if (typeof d[last] !== "number") {
-                  throw new QueryError("Field is no number!");
-               } else {
-                  d[last] += toUpdate.value;
-               }
-               break;
-            case "timestamp":
-               d[last] = new Date().valueOf();
-               break;
-            case "push":
-               if (d[last] === undefined || d[last] === null)
-                  d[last] = [toUpdate.value];
-               else if (Array.isArray(d[last])) {
-                  d[last].push(toUpdate.value);
-               } else {
-                  throw new QueryError("Field is not array!");
-               }
-               break;
-            default:
-               throw new QueryError("Invalid update type: " + toUpdate.type);
-         }
-      }
-
-      if (batch) {
-         batch.put(Database.getKey(collection, document), encode(data));
-      } else {
-         await this.database.data.put(
-            Database.getKey(collection, document),
-            encode(data).slice(0)
-         );
-      }
-
-      this.sendChange(collection, document, isNew ? "added" : "modified", data);
-   }
-
-   private async delete(
-      collection: string,
-      document: string,
-      batch?: LevelUpChain
-   ) {
-      if (batch) {
-         batch.del(Database.getKey(collection, document));
-      } else {
-         await this.database.data.del(Database.getKey(collection, document));
-      }
-
-      this.sendChange(collection, document, "deleted", null);
-   }
-
-   checkChange(change: Change) {
-      return true;
-   }
-
-   firstSend(collection: string, document: string) {
-      return this.get(collection, document);
-   }
-
-   public static fromQuery(query: Query) {
-      return new DocumentQuery(...Query.getConstructorParams(query));
-   }
-}
-
-type FieldPath = string;
-type WhereFilterOp =
-   | "<"
-   | "<="
-   | "=="
-   | ">="
-   | ">"
-   | "array-contains"
-   | "in"
-   | "array-contains-any";
-
-interface IQueryWhereVerbose {
-   fieldPath: FieldPath;
-   opStr: WhereFilterOp;
-   value: any;
-}
-
-type IQueryWhereArray = [FieldPath, WhereFilterOp, any];
-
-type IQueryWhere = IQueryWhereArray | IQueryWhereVerbose;
-
-export class CollectionQuery extends Query {
-   private _addId: string;
-
-   prepare(query): IPreparedQuery {
-      switch (query.type as ICollectionQueries) {
-         case "add":
-            this._addId = longNanoID();
-            return {
-               batchCompatible: true,
-               createCollection: true,
-               needDocument: false,
-               runner: this.add,
-               permission: "write",
-               additionalLock: [...query.path, this._addId],
-            };
-         case "get":
-            const limit = (query.options || {}).limit;
-            if (limit) this.limit = limit;
-            const where = (query.options || {}).where;
-            if (where) this.where = where;
-
-            return {
-               batchCompatible: false,
-               createCollection: false,
-               needDocument: false,
-               permission: "read",
-               runner: this.get,
-            };
-         case "keys":
-            return {
-               batchCompatible: false,
-               createCollection: false,
-               needDocument: false,
-               permission: "list",
-               runner: this.keys,
-            };
-         case "list":
-            return {
-               batchCompatible: false,
-               createCollection: false,
-               needDocument: false,
-               permission: "read",
-               runner: this.keys,
-            };
-         case "delete-collection":
-            return {
-               batchCompatible: false,
-               createCollection: false,
-               needDocument: false,
-               permission: "write",
-               runner: this.deleteCollection,
-            };
-         // run = () => q.deleteCollection();
-         // break;
-         default:
-            throw new Error("Invalid query!");
-      }
-   }
-
-   private _where: IQueryWhereArray[];
-   public set where(value: IQueryWhere[]) {
-      const invalidWhere = new QueryError("Invalid Where");
-      if (!Array.isArray(value)) throw invalidWhere;
-      let c = [];
-      this._where = value.map((cond) => {
-         Logging.debug("Query Condition", cond);
-         if (Array.isArray(cond)) {
-            if (cond.length !== 3) throw invalidWhere;
-            return cond;
-         } else {
-            if (
-               cond &&
-               typeof cond === "object" &&
-               "fieldPath" in cond &&
-               "opStr" in cond &&
-               "value" in cond
-            ) {
-               return [cond.fieldPath, cond.opStr, cond.value];
-            } else {
-               throw invalidWhere;
-            }
-         }
-      });
-   }
-
-   public limit: number = -1;
-
-   public async add(
-      collection: string,
-      document: string,
-      batch: LevelUpChain,
-      collectionKey: string
-   ) {
-      let q = new DocumentQuery(this.database, this.session, {
-         type: "set",
-         path: this.additionalLock,
-         data: this.query.data,
-         options: this.query.options,
-      });
-      await q.run(collection, this._addId, batch, collectionKey);
-      this.changes = q.changes;
-      return this._addId;
-   }
-
-   private getStreamOptions(collection: string) {
-      let gt = Buffer.from(Database.getKey(collection) + " ");
       gt[gt.length - 1] = 0;
 
       let lt = Buffer.alloc(gt.length);
       lt.set(gt);
-      lt[gt.length - 1] = 0xff;
+      lt[gt.length - 1] = 0xFF;
-
-      return {
-         gt,
-         lt,
-      };
-   }
-
-   public async keys(collection: string) {
-      if (!collection) return [];
 
       return new Promise<string[]>((yes, no) => {
          let keys = [];
          const stream = this.database.data.createKeyStream({
-            ...this.getStreamOptions(collection),
+            gt,
-            keyAsBuffer: false,
+            lt,
-         });
+            keyAsBuffer: false
+         })
          stream.on("data", (key: string) => {
             let s = key.split("/", 2);
-            if (s.length > 1) keys.push(s[1]);
+            if (s.length > 1)
+               keys.push(s[1]);
          });
          stream.on("end", () => yes(keys));
          stream.on("error", no);
       });
    }
 
-   private _getFieldValue(data: any, path: FieldPath) {
+   public async set(data: any, { merge = false }) {
-      let parts = path.split(".");
+      if (data === null)
-      let d = data;
+         return this.delete();
-      while (parts.length > 0) {
+      let { collection, document } = await this.resolve(this.path, true);
-         let seg = parts.shift();
+      if (!collection) {
-
+         throw new Error("There must be a collection!")
-         d = data[seg];
-         if (d === undefined || d === null) break; // Undefined/Null has no other fields!
-      }
-      return d;
       }
 
-   private _fitsWhere(data: any): boolean {
+      if (!document) {
-      if (this._where && this._where.length > 0) {
+         throw new Error("There must be a document key!")
-         return this._where.every(([fieldPath, opStr, value]) => {
-            let val = this._getFieldValue(data, fieldPath);
-            switch (opStr) {
-               case "<":
-                  return val < value;
-               case "<=":
-                  return val <= value;
-               case "==":
-                  return val == value;
-               case ">=":
-                  return val >= value;
-               case ">":
-                  return val > value;
-               case "array-contains":
-                  if (Array.isArray(val)) {
-                     return val.some((e) => e === value);
       }
 
-                  return false;
+      const lock = await this.database.locks.lock(collection, document);
-               // case "array-contains-any":
+
-               case "in":
+      let isNew = await this.database.data.get(this.getKey(collection, document)).catch(resNull).then(e => e !== null);
-                  if (typeof val === "object") {
+
-                     return value in val;
+      return this.database.data
-                  }
+         .put(this.getKey(collection, document), encode(data))
-                  return false;
+         .then(() => this.sendChange(collection, document, isNew ? "added" : "modified", data))
-               default:
+         .finally(() => lock())
-                  throw new QueryError("Invalid where operation " + opStr);
-            }
-         });
-      }
-      return true;
    }
 
-   async get(collection: string) {
+   public async push(value: any) {
-      if (!collection) return [];
+      let id = nanoid(ALPHABET, 32);
-
+      let q = new Query(this.database, [...this.path, id], this.sender);
-      return new Promise<DocRes[]>((yes, no) => {
+      await q.set(value, {});
-         const stream = this.database.data.iterator({
+      return id;
-            ...this.getStreamOptions(collection),
-            keyAsBuffer: false,
-            valueAsBuffer: true,
-         });
-
-         let values: DocRes[] = [];
-
-         const onValue = (err: Error, key: string, value: Buffer) => {
-            if (err) {
-               no(err);
-               stream.end((err) => Logging.error(err));
-            } else {
-               if (!key && !value) {
-                  // END
-                  Logging.debug("Checked all!");
-                  yes(values);
-               } else {
-                  let s = key.split("/", 2);
-                  if (s.length <= 1) return;
-
-                  const id = s[1];
-
-                  let data = decode(value);
-                  if (this._fitsWhere(data)) {
-                     if (this.limit < 0 || values.length < this.limit) {
-                        values.push({
-                           id,
-                           data,
-                        });
-                     } else {
-                        stream.end((err) => (err ? no(err) : yes(values)));
-                        return;
-                     }
    }
 
-                  stream.next(onValue);
+   public async delete() {
-               }
+      let { collection, document } = await this.resolve(this.path);
-            }
-         };
 
-         stream.next(onValue);
+      if (!collection) {
-      });
+         throw new Error("There must be a collection!")
       }
 
-   checkChange(change: Change) {
+      if (!document) {
-      return this._fitsWhere(change.data);
+         throw new Error("There must be a document key!")
       }
 
-   firstSend(collection: string) {
+
-      return this.get(collection);
+      const lock = await this.database.locks.lock(collection, document);
+
+      return await this.database.data
+         .del(`${collection}/${document}`)
+         .then(() => this.sendChange(collection, document, "deleted", null))
+         .finally(() => lock())
    }
 
-   public async collections() {
+   public async update(data: any) {
-      if (!this.session.root) throw new QueryError("No Permission!");
+      //TODO: Implement
+   }
 
+   public async getCollections() {
       return new Promise<string[]>((yes, no) => {
          let keys = [];
-         const stream = this.database.data.createKeyStream({
+         const stream = this.database.data.createKeyStream({ keyAsBuffer: false })
-            keyAsBuffer: false,
-         });
          stream.on("data", (key: string) => keys.push(key.split("/")));
          stream.on("end", () => yes(keys));
          stream.on("error", no);
       });
    }
 
-   public async deleteCollection(
+   public async deleteCollection() {
-      collection: string,
+      const { collection, document, collectionKey } = await this.resolve(this.path);
-      document: string,
+
-      _b: LevelUpChain,
+      if (document) {
-      collectionKey: string
+         throw new Error("There can be no document defined on this operation");
-   ) {
+      }
-      if (!this.session.root) throw new QueryError("No Permission!");
 
-      //TODO: Lock whole collection!
       let batch = this.database.data.batch();
       try {
          if (collection) {
-            let documents = await this.keys(collection);
+            let keys = await this.keys();
-            // Logging.debug("To delete:", documents)
+            for (let key in keys) {
-            for (let document of documents) {
+               batch.del(key);
-               batch.del(Database.getKey(collection, document));
             }
             await batch.write();
             batch = undefined;
             await this.database.collections.del(collectionKey);
-            this.database.collectionChangeListener.send({
-               id: collection,
-               key: collectionKey,
-               type: "delete",
-            });
          }
       } finally {
-         if (batch) batch.clear();
+         if (batch)
+            batch.clear();
       }
    }
 
-   public static fromQuery(query: Query) {
-      return new CollectionQuery(...Query.getConstructorParams(query));
-   }
-}
 
-export class QueryError extends Error {
+
-   constructor(message: string) {
+   private subscription: {
-      super(message);
+      key: string;
+      type: Set<ChangeTypes>;
+      send: (data: Omit<Change, "sender">) => void;
+   };
+   async subscribe(send: (data: Omit<Change, "sender">) => void, type: ChangeTypes[] | undefined, _options: Partial<ISubscribeOptions>) {
+      let options: ISubscribeOptions = {
+         existing: true,
+         ..._options
+      }
+
+      let { collection, document } = await this.resolve(this.path);
+
+      let key = this.getKey(collection, document);
+      let s = this.database.changes.get(key) || new Set();
+      s.add(this.onChange)
+      this.database.changes.set(key, s);
+
+      this.subscription = {
+         key,
+         send,
+         type: new Set(type || [])
+      };
+
+      Logging.debug("Existing?", options.existing)
+
+      if (options.existing) {
+         if (document) {
+            send({
+               document: document,
+               type: "added",
+               data: await this.get(),
+            })
+         } else {
+            await this.keys().then(async documents => {
+               for (let document of documents) {
+                  const data = await this.getDoc(collection, document);
+                  if (data)
+                     send({
+                        type: "added",
+                        document,
+                        data
+                     })
+               }
+            })
+         }
+      }
+
+      Logging.debug("Subscribed");
+   }
+
+   async onChange(change: Change) {
+      const { type, send } = this.subscription;
+
+      // Events from the sender are handled locally
+      if (change.sender !== this.sender && type.has(change.type)) {
+         let c = { ...change };
+         delete c.sender;
+         send(c)
+      }
+   }
+
+   unsubscribe() {
+      if (!this.subscription) {
+         const { key } = this.subscription;
+         let s = this.database.changes.get(key);
+         if (s) {
+            s.delete(this.onChange);
+            if (s.size <= 0)
+               this.database.changes.delete(key);
+         }
+         this.subscription = undefined;
+      }
    }
 }

src/database/rules.ts

@@ -0,0 +1,111 @@
+import Session from "./session";
+import Logging from "@hibas123/nodelogging";
+
+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): { read: boolean, write: boolean } {
+      let read = this.rules[".read"] || false;
+      let write = this.rules[".write"] || false;
+
+      let rules = this.rules;
+
+      for (let segment of path) {
+         if (segment.startsWith("$") || segment.startsWith(".")) {
+            read = false;
+            write = false;
+            Logging.log("Invalid query path (started with '$' or '.'):", path);
+            break;
+         }
+
+         let k = Object.keys(rules)
+            .filter(e => e.startsWith("$"))
+            .find(e => {
+               switch (e) {
+                  case "$uid":
+                     if (segment === session.uid)
+                        return true;
+                     break;
+               }
+               return false;
+            })
+
+         rules = (k ? rules[k] : undefined) || rules[segment] || rules["*"];
+
+         if (rules) {
+            if (rules[".read"]) {
+               read = rules[".read"]
+            }
+
+            if (rules[".write"]) {
+               read = rules[".write"]
+            }
+         } else {
+            break;
+         }
+      }
+
+      return {
+         read: read as boolean,
+         write: write as boolean
+      }
+   }
+
+   toJSON() {
+      return this.config;
+   }
+}

src/database/session.ts

@@ -1,10 +1,8 @@
 export default class Session {
-   constructor(private _sessionid: string) {}
+   constructor(private _sessionid: string) { }
-   get id() {
+   get sessionid() {
       return this._sessionid;
    }
    root: boolean = false;
-   uid: string = null;
+   uid: string = undefined;
-
-   subscriptions = new Map<string, () => void>();
 }

src/helper/jwt.ts

@@ -1,12 +0,0 @@
-import * as JWT from "jsonwebtoken";
-
-export async function verifyJWT(token: string, publicKey: string) {
-   return new Promise<any | undefined>((yes) => {
-      JWT.verify(token, publicKey, (err, decoded) => {
-         if (err)
-            yes(undefined);
-         else
-            yes(decoded);
-      })
-   })
-}

src/index.ts

@@ -3,24 +3,17 @@ import Web from "./web";
 import config from "./config";
 import { DatabaseManager } from "./database/database";
 import { createServer } from "http";
-import { WebsocketConnectionManager } from "./websocket";
+import { ConnectionManager } from "./connection";
 import { LoggingTypes } from "@hibas123/logging";
-import { readFileSync } from "fs";
 
 Logging.logLevel = config.dev ? LoggingTypes.Debug : LoggingTypes.Log;
 
-const version = JSON.parse(readFileSync("./package.json").toString()).version;
+DatabaseManager.init().then(() => {
-
-Logging.log("Starting Database version:", version);
-
-DatabaseManager.init()
-   .then(() => {
    const http = createServer(Web.callback());
-      WebsocketConnectionManager.bind(http);
+   ConnectionManager.bind(http);
    const port = config.port || 5000;
-      http.listen(port, () => Logging.log("WS:  Listening on port:", port));
+   http.listen(port, () => Logging.log("Listening on port:", port))
-   })
+}).catch(err => {
-   .catch((err) => {
    Logging.error(err);
    process.exit(-1);
-   });
+})

src/rules/compile.ts

@@ -1,293 +0,0 @@
-import {
-   Node,
-   MatchStatement,
-   Operations,
-   ServiceStatement,
-   Expression,
-   ValueStatement,
-   Operators,
-} from "./parser";
-
-export class CompilerError extends Error {
-   node: Node;
-   constructor(message: string, node: Node) {
-      super(message);
-      this.node = node;
-   }
-}
-
-type Variables = { [key: string]: string | Variables };
-
-class Variable {
-   #name: string;
-   constructor(name: string) {
-      this.#name = name;
-   }
-
-   getValue(variables: Variables) {
-      const parts = this.#name.split(".");
-      let current = variables as any;
-      while (parts.length > 0) {
-         const name = parts.shift();
-         if (current && typeof current == "object") current = current[name];
-      }
-      return current;
-   }
-}
-
-class Value {
-   #value: any;
-   constructor(value: any) {
-      this.#value = value;
-   }
-
-   get value() {
-      return this.#value;
-   }
-}
-
-type ConditionParameters = Value | ConditionMatcher | Variable;
-class ConditionMatcher {
-   #left: ConditionParameters;
-   #right: ConditionParameters;
-   #operator: Operators;
-   constructor(
-      left: ConditionParameters,
-      right: ConditionParameters,
-      operator: Operators
-   ) {
-      this.#left = left;
-      this.#right = right;
-      this.#operator = operator;
-   }
-
-   test(variables: Variables): boolean {
-      let leftValue: any;
-      if (this.#left instanceof Value) {
-         leftValue = this.#left.value;
-      } else if (this.#left instanceof Variable) {
-         leftValue = this.#left.getValue(variables);
-      } else {
-         leftValue = this.#left.test(variables);
-      }
-
-      let rightValue: any;
-      if (this.#right instanceof Value) {
-         rightValue = this.#right.value;
-      } else if (this.#right instanceof Variable) {
-         rightValue = this.#right.getValue(variables);
-      } else {
-         rightValue = this.#right.test(variables);
-      }
-
-      switch (this.#operator) {
-         case "==":
-            return leftValue == rightValue;
-         case "!=":
-            return leftValue != rightValue;
-         case ">=":
-            return leftValue >= rightValue;
-         case "<=":
-            return leftValue <= rightValue;
-         case ">":
-            return leftValue > rightValue;
-         case "<":
-            return leftValue < rightValue;
-         case "&&":
-            return leftValue && rightValue;
-         case "||":
-            return leftValue || rightValue;
-         default:
-            throw new Error("Invalid operator " + this.#operator);
-      }
-   }
-}
-
-class Rule {
-   #operation: Operations;
-
-   #condition: ConditionParameters;
-
-   get operation() {
-      return this.#operation;
-   }
-
-   constructor(operation: Operations, condition: ConditionParameters) {
-      this.#operation = operation;
-      this.#condition = condition;
-   }
-
-   test(variables: Variables): boolean {
-      if (this.#condition instanceof Value) {
-         return Boolean(this.#condition.value);
-      } else if (this.#condition instanceof Variable) {
-         return Boolean(this.#condition.getValue(variables));
-      } else {
-         return this.#condition.test(variables);
-      }
-   }
-}
-
-class Segment {
-   #name: string;
-   #variable: boolean;
-   get name() {
-      return this.#name;
-   }
-   constructor(name: string, variable = false) {
-      this.#name = name;
-      this.#variable = variable;
-   }
-
-   match(segment: string): { match: boolean; variable?: string } {
-      return {
-         match: this.#name === segment || this.#variable,
-         variable: this.#variable && this.#name,
-      };
-   }
-}
-
-class Match {
-   #submatches: Match[];
-   #rules: Rule[];
-
-   #segments: Segment[];
-   #wildcard: boolean;
-
-   constructor(
-      segments: Segment[],
-      rules: Rule[],
-      wildcard: boolean,
-      submatches: Match[]
-   ) {
-      this.#segments = segments;
-      this.#rules = rules;
-      this.#wildcard = wildcard;
-      this.#submatches = submatches;
-   }
-
-   match(
-      segments: string[],
-      operation: Operations,
-      variables: Variables
-   ): boolean {
-      let localVars = { ...variables };
-      if (segments.length >= this.#segments.length) {
-         for (let i = 0; i < this.#segments.length; i++) {
-            const match = this.#segments[i].match(segments[i]);
-            if (match.match) {
-               if (match.variable) {
-                  localVars[match.variable] = segments[i];
-               }
-            } else {
-               return false;
-            }
-         }
-         let remaining = segments.slice(this.#segments.length);
-         if (remaining.length > 0 && !this.#wildcard) {
-            for (const match of this.#submatches) {
-               const res = match.match(remaining, operation, localVars);
-               if (res) return true;
-            }
-         } else {
-            for (const rule of this.#rules) {
-               if (rule.operation === operation) {
-                  if (rule.test(localVars)) return true;
-               }
-            }
-         }
-      }
-
-      return false;
-   }
-}
-
-export class RuleRunner {
-   #root_matches: Match[];
-   constructor(root_matches: Match[]) {
-      this.#root_matches = root_matches;
-   }
-
-   hasPermission(path: string[], operation: Operations, request: any): boolean {
-      if (request.root) return true;
-      for (const match of this.#root_matches) {
-         const res = match.match(path, operation, { request });
-         if (res) return true;
-      }
-      return false;
-   }
-}
-
-export function getRuleRunner(service: ServiceStatement) {
-   const createMatch = (s_match: MatchStatement) => {
-      let wildcard = false;
-      let segments = s_match.path.segments
-         .map((segment, idx, arr) => {
-            if (typeof segment === "string") {
-               if (segment === "*") {
-                  if (idx === arr.length - 1) {
-                     wildcard = true;
-                     return null;
-                  } else {
-                     throw new CompilerError("Invalid path wildcard!", s_match);
-                  }
-               } else {
-                  return new Segment(segment, false);
-               }
-            } else {
-               return new Segment(segment.name, true);
-            }
-         })
-         .filter((e) => e !== null);
-
-      const resolveParameter = (e: Expression | ValueStatement) => {
-         let val: Value | ConditionMatcher | Variable;
-         if (e.type === "value") {
-            const c = e;
-            if (c.isFalse) {
-               val = new Value(false);
-            } else if (c.isTrue) {
-               val = new Value(true);
-            } else if (c.isNull) {
-               val = new Value(null);
-            } else if (c.isNumber) {
-               val = new Value(Number(c.value));
-            } else if (c.isString) {
-               val = new Value(String(c.value));
-            } else if (c.isVariable) {
-               val = new Variable(String(c.value));
-            } else {
-               throw new CompilerError("Invalid value type!", e);
-            }
-         } else {
-            val = createCondition(e);
-         }
-
-         return val;
-      };
-
-      const createCondition = (cond: Expression): ConditionMatcher => {
-         let left: ConditionParameters = resolveParameter(cond.left);
-         let right: ConditionParameters = resolveParameter(cond.right);
-
-         return new ConditionMatcher(left, right, cond.operator);
-      };
-
-      const rules: Rule[] = s_match.rules
-         .map((rule) => {
-            const condition = resolveParameter(rule.condition);
-            return rule.operations.map((op) => new Rule(op, condition));
-         })
-         .flat(1);
-      const submatches = s_match.matches.map((sub) => createMatch(sub));
-      const match = new Match(segments, rules, wildcard, submatches);
-
-      return match;
-   };
-
-   const root_matches = service.matches.map((match) => createMatch(match));
-
-   const runner = new RuleRunner(root_matches);
-
-   return runner;
-}

src/rules/error.ts

@@ -1,36 +0,0 @@
-export interface RuleError {
-   line: number;
-   column: number;
-   message: string;
-   original_err: Error;
-}
-
-function indexToLineAndCol(src: string, index: number) {
-   let line = 1;
-   let col = 1;
-   for (let i = 0; i < index; i++) {
-      if (src.charAt(i) === "\n") {
-         line++;
-         col = 1;
-      } else {
-         col++;
-      }
-   }
-
-   return { line, col };
-}
-
-export function transformError(
-   err: Error,
-   data: string,
-   idx: number
-): RuleError {
-   let loc = indexToLineAndCol(data, idx);
-
-   return {
-      line: loc.line,
-      column: loc.col,
-      message: err.message,
-      original_err: err,
-   };
-}

src/rules/index.ts

@@ -1,29 +0,0 @@
-import { RuleError, transformError } from "./error";
-import parse, { ParserError } from "./parser";
-import tokenize, { TokenizerError } from "./tokenise";
-import { getRuleRunner, RuleRunner } from "./compile";
-import { inspect } from "util";
-
-export default function compileRule(rule: string) {
-   let runner: RuleRunner | undefined;
-   let error: RuleError | undefined;
-   try {
-      const tokenised = tokenize(rule);
-      const parsed = parse(tokenised);
-      const dbservice = parsed.find((e) => e.name === "realtimedb");
-
-      if (!dbservice) throw new Error("No realtimedb service available!");
-
-      runner = getRuleRunner(dbservice);
-   } catch (err) {
-      if (err instanceof TokenizerError) {
-         error = transformError(err, rule, err.index);
-      } else if (err instanceof ParserError) {
-         error = transformError(err, rule, err.token.startIdx);
-      } else {
-         throw err;
-      }
-   }
-
-   return { runner, error };
-}

src/rules/parser.ts

@@ -1,349 +0,0 @@
-import { Token } from "./tokenise";
-
-export interface Node {
-   type: string;
-   idx: number;
-}
-
-export interface PathStatement extends Node {
-   type: "path";
-   segments: (string | { type: "variable"; name: string })[];
-}
-
-export interface ValueStatement extends Node {
-   type: "value";
-   isNull: boolean;
-   isTrue: boolean;
-   isFalse: boolean;
-   isNumber: boolean;
-   isString: boolean;
-   isVariable: boolean;
-
-   value?: any;
-}
-
-export type Operators = "&&" | "||" | "==" | "<=" | ">=" | "!=" | ">" | "<";
-
-export interface Expression extends Node {
-   type: "expression";
-
-   left: ValueStatement | Expression;
-   operator: Operators;
-   right: ValueStatement | Expression;
-}
-
-export type Operations = "read" | "write" | "list"; // | "update" | "create" | "delete" | "list";
-
-export interface AllowStatement extends Node {
-   type: "permission";
-   operations: Operations[];
-   condition: Expression | ValueStatement;
-}
-
-export interface MatchStatement extends Node {
-   type: "match";
-   path: PathStatement;
-   matches: MatchStatement[];
-   rules: AllowStatement[];
-}
-
-export interface ServiceStatement extends Node {
-   type: "service";
-   name: string;
-   matches: MatchStatement[];
-}
-
-export class ParserError extends Error {
-   token: Token;
-   constructor(message: string, token: Token) {
-      super(message);
-      this.token = token;
-   }
-}
-
-export default function parse(tokens: Token[]) {
-   const tokenIterator = tokens[Symbol.iterator]();
-   let currentToken: Token = tokenIterator.next().value;
-   let nextToken: Token = tokenIterator.next().value;
-
-   const eatToken = (value?: string) => {
-      if (value && value !== currentToken.value) {
-         throw new ParserError(
-            `Unexpected token value, expected '${value}', received '${currentToken.value}'`,
-            currentToken
-         );
-      }
-      let idx = currentToken.startIdx;
-      currentToken = nextToken;
-      nextToken = tokenIterator.next().value;
-      return idx;
-   };
-
-   const eatText = (): [string, number] => {
-      checkTypes("text");
-      let val = currentToken.value;
-      let idx = currentToken.startIdx;
-      eatToken();
-      return [val, idx];
-   };
-   const eatNumber = (): number => {
-      checkTypes("number");
-      let val = Number(currentToken.value);
-      if (Number.isNaN(val)) {
-         throw new ParserError(
-            `Value cannot be parsed as number! ${currentToken.value}`,
-            currentToken
-         );
-      }
-      eatToken();
-      return val;
-   };
-
-   const checkTypes = (...types: string[]) => {
-      if (types.indexOf(currentToken.type) < 0) {
-         throw new ParserError(
-            `Unexpected token value, expected ${types.join(" | ")}, received '${
-               currentToken.value
-            }'`,
-            currentToken
-         );
-      }
-   };
-
-   const parsePathStatement = (): PathStatement => {
-      const segments: (string | { name: string; type: "variable" })[] = [];
-      const idx = currentToken.startIdx;
-      let next = currentToken.type === "slash";
-      while (next) {
-         eatToken("/");
-         if (currentToken.type === "curly_open" && nextToken.type === "text") {
-            eatToken("{");
-            const [name] = eatText();
-            segments.push({
-               type: "variable",
-               name,
-            });
-            eatToken("}");
-         } else if (currentToken.type === "text") {
-            const [name] = eatText();
-            segments.push(name);
-         }
-         next = currentToken.type === "slash";
-      }
-
-      return {
-         type: "path",
-         idx,
-         segments,
-      };
-   };
-
-   const parseValue = (): ValueStatement => {
-      const idx = currentToken.startIdx;
-
-      let isTrue = false;
-      let isFalse = false;
-      let isNull = false;
-      let isVariable = false;
-      let isNumber = false;
-      let isString = false;
-      let value: any = undefined;
-      if (currentToken.type === "keyword") {
-         if (currentToken.value === "true") isTrue = true;
-         else if (currentToken.value === "false") isFalse = true;
-         else if (currentToken.value === "null") isNull = true;
-         else {
-            throw new ParserError(
-               `Invalid keyword at this position ${currentToken.value}`,
-               currentToken
-            );
-         }
-         eatToken();
-      } else if (currentToken.type === "string") {
-         isString = true;
-         value = currentToken.value.slice(1, currentToken.value.length - 1);
-         eatToken();
-      } else if (currentToken.type === "number") {
-         isNumber = true;
-         value = eatNumber();
-      } else if (currentToken.type === "text") {
-         isVariable = true;
-         [value] = eatText();
-      } else {
-         throw new ParserError(
-            `Expected value got ${currentToken.type}`,
-            currentToken
-         );
-      }
-
-      return {
-         type: "value",
-         isFalse,
-         isNull,
-         isNumber,
-         isString,
-         isTrue,
-         isVariable,
-         value,
-         idx,
-      };
-   };
-
-   const parseCondition = (): Expression | ValueStatement => {
-      // let running = true;
-      let res: Expression | ValueStatement;
-      let left: Expression | ValueStatement | undefined;
-
-      // while (running) {
-      const idx = currentToken.startIdx;
-
-      if (!left) {
-         if (currentToken.type === "bracket_open") {
-            eatToken("(");
-            left = parseCondition();
-            eatToken(")");
-         } else {
-            left = parseValue();
-         }
-      }
-
-      if (currentToken.type === "comparison_operator") {
-         const operator = currentToken.value;
-
-         eatToken();
-
-         let right: Expression | ValueStatement;
-
-         let ct = currentToken; //Quick hack because of TypeScript
-         if (ct.type === "bracket_open") {
-            eatToken("(");
-            right = parseCondition();
-            eatToken(")");
-         } else {
-            right = parseValue();
-         }
-
-         res = {
-            type: "expression",
-            left,
-            right,
-            operator: operator as Operators,
-            idx,
-         };
-      } else if (currentToken.type === "logic_operator") {
-         const operator = currentToken.value;
-
-         eatToken();
-
-         const right = parseCondition();
-
-         res = {
-            type: "expression",
-            left,
-            operator: operator as Operators,
-            right,
-            idx,
-         };
-      } else {
-         res = left;
-      }
-
-      // let ct = currentToken;
-      // if (
-      //    ct.type === "comparison_operator" ||
-      //    ct.type === "logic_operator"
-      // ) {
-      //    left = res;
-      // } else {
-      //    running = false;
-      // }
-      // }
-      return res;
-   };
-
-   const parsePermissionStatement = (): AllowStatement => {
-      const idx = eatToken("allow");
-
-      const operations: Operations[] = [];
-      let next = currentToken.type !== "colon";
-      while (next) {
-         const [operation] = eatText();
-         operations.push(operation as Operations);
-         if (currentToken.type === "comma") {
-            next = true;
-            eatToken(",");
-         } else {
-            next = false;
-         }
-      }
-
-      eatToken(":");
-
-      eatToken("if");
-
-      const condition = parseCondition();
-
-      eatToken(";");
-
-      return {
-         type: "permission",
-         idx,
-         operations,
-         condition,
-      };
-   };
-
-   const parseMatchStatement = (): MatchStatement => {
-      const idx = eatToken("match");
-      const path = parsePathStatement();
-
-      eatToken("{");
-      const matches: MatchStatement[] = [];
-      const permissions: AllowStatement[] = [];
-      while (currentToken.type !== "curly_close") {
-         if (currentToken.value === "match") {
-            matches.push(parseMatchStatement());
-         } else if (currentToken.value === "allow") {
-            permissions.push(parsePermissionStatement());
-         } else {
-            throw new ParserError(
-               `Unexpected token value, expected 'match' or 'allow', received '${currentToken.value}'`,
-               currentToken
-            );
-         }
-      }
-      eatToken("}");
-
-      return {
-         type: "match",
-         path,
-         idx,
-         matches,
-         rules: permissions,
-      };
-   };
-
-   const parseServiceStatement = (): ServiceStatement => {
-      const idx = eatToken("service");
-      let [name] = eatText();
-      eatToken("{");
-      const matches: MatchStatement[] = [];
-      while (currentToken.value === "match") {
-         matches.push(parseMatchStatement());
-      }
-      eatToken("}");
-
-      return {
-         type: "service",
-         name: name,
-         idx,
-         matches,
-      };
-   };
-
-   const nodes: ServiceStatement[] = [];
-   while (currentToken) {
-      nodes.push(parseServiceStatement());
-   }
-   return nodes;
-}

src/rules/tokenise.ts

@@ -1,98 +0,0 @@
-export type TokenTypes =
-   | "space"
-   | "comment"
-   | "string"
-   | "keyword"
-   | "colon"
-   | "semicolon"
-   | "comma"
-   | "comparison_operator"
-   | "logic_operator"
-   | "equals"
-   | "slash"
-   | "bracket_open"
-   | "bracket_close"
-   | "curly_open"
-   | "curly_close"
-   | "array"
-   | "questionmark"
-   | "number"
-   | "text";
-
-export type Token = {
-   type: TokenTypes;
-   value: string;
-   startIdx: number;
-   endIdx: number;
-};
-
-type Matcher = (input: string, index: number) => undefined | Token;
-
-export class TokenizerError extends Error {
-   index: number;
-   constructor(message: string, index: number) {
-      super(message);
-      this.index = index;
-   }
-}
-
-function regexMatcher(regex: string | RegExp, type: TokenTypes): Matcher {
-   if (typeof regex === "string") regex = new RegExp(regex);
-
-   return (input: string, index: number) => {
-      let matches = input.substring(index).match(regex as RegExp);
-      if (!matches || matches.length <= 0) return undefined;
-
-      return {
-         type,
-         value: matches[0],
-         startIdx: index,
-         endIdx: index + matches[0].length,
-      } as Token;
-   };
-}
-
-const matcher = [
-   regexMatcher(/^\s+/, "space"),
-   regexMatcher(/^\/\/.+/, "comment"),
-   regexMatcher(/^#.+/, "comment"),
-   regexMatcher(/^".*?"/, "string"),
-   // regexMatcher(/(?<=^")(.*?)(?=")/, "string"),
-   regexMatcher(/^(service|match|allow|if|true|false|null)/, "keyword"),
-   regexMatcher(/^\:/, "colon"),
-   regexMatcher(/^\;/, "semicolon"),
-   regexMatcher(/^\,/, "comma"),
-   regexMatcher(/^(\=\=|\!\=|\<\=|\>\=|\>|\<)/, "comparison_operator"),
-   regexMatcher(/^(&&|\|\|)/, "logic_operator"),
-   regexMatcher(/^\=/, "equals"),
-   regexMatcher(/^\//, "slash"),
-   regexMatcher(/^\(/, "bracket_open"),
-   regexMatcher(/^\)/, "bracket_close"),
-   regexMatcher(/^{/, "curly_open"),
-   regexMatcher(/^}/, "curly_close"),
-   regexMatcher(/^\[\]/, "array"),
-   regexMatcher(/^\?/, "questionmark"),
-   regexMatcher(/^[0-9]+(\.[0-9]+)?/, "number"),
-   regexMatcher(/^[a-zA-Z_\*]([a-zA-Z0-9_\.\*]?)+/, "text"),
-];
-
-export default function tokenize(input: string) {
-   let index = 0;
-   let tokens: Token[] = [];
-   while (index < input.length) {
-      const matches = matcher.map((m) => m(input, index)).filter((e) => !!e);
-      let match = matches[0];
-      if (match) {
-         if (match.type !== "space" && match.type !== "comment") {
-            tokens.push(match);
-         }
-         index += match.value.length;
-      } else {
-         throw new TokenizerError(
-            `Unexpected token '${input.substring(index, index + 1)}'`,
-            index
-         );
-      }
-   }
-   return tokens;
-}

src/storage.ts

@@ -4,53 +4,49 @@ if (!fs.existsSync("./databases/")) {
    fs.mkdirSync("./databases");
 }
 
-import * as LUR from "levelup";
+import LevelUp, { LevelUp as LU } from "levelup";
-import * as LDR from "leveldown";
+import LevelDown, { LevelDown as LD } from "leveldown";
-
-const LevelUp = LUR as any;
-const LevelDown = LDR as any;
-
-import type { LevelUp as LU } from "levelup";
-import type { LevelDown as LD } from "leveldown";
 import { AbstractIterator } from "abstract-leveldown";
 
 export type LevelDB = LU<LD, AbstractIterator<any, any>>;
-export type DBSet = { data: LevelDB; collection: LevelDB };
+export type DBSet = { data: LevelDB, collection: LevelDB };
 
 const databases = new Map<string, DBSet>();
 
 export function resNull(err): null {
-   if (!err.notFound) throw err;
+   if (!err.notFound)
+      throw err;
    return null;
 }
 
 async function rmRecursice(path: string) {
    if (fs.existsSync(path)) {
-      await Promise.all(
+      await Promise.all(fs.readdirSync(path).map(async (file) => {
-         fs.readdirSync(path).map(async (file) => {
          var curPath = path + "/" + file;
-            if (fs.lstatSync(curPath).isDirectory()) {
+         if (fs.lstatSync(curPath).isDirectory()) { // recurse
-               // recurse
             await rmRecursice(curPath);
-            } else {
+         } else { // delete file
-               // delete file
             await fs.promises.unlink(curPath);
          }
-         })
+      }));
-      );
       await fs.promises.rmdir(path);
    }
-}
+};
+
 
 export async function deleteLevelDB(name: string) {
-   if (!name || name === "") return;
+   if (!name || name === "")
+      return;
    let db = databases.get(name);
 
    if (db) {
-      if (db.data.isOpen()) await db.data.close();
+      if (db.data.isOpen())
-      if (db.collection.isOpen()) await db.collection.close();
+         await db.data.close()
+      if (db.collection.isOpen())
+         await db.collection.close()
    }
 
+
    //TODO make sure, that name doesn't make it possible to delete all databases :)
    await rmRecursice("./databases/" + name);
 }
@@ -64,15 +60,9 @@ export default function getLevelDB(name: string): DBSet {
    }
 
    db = {
-      data:
+      data: db && db.data.isOpen() ? db.data : LevelUp(LevelDown("./databases/" + name + "/data")),
-         db && db.data.isOpen()
+      collection: db && db.collection.isOpen() ? db.collection : LevelUp(LevelDown("./databases/" + name + "/collection"))
-            ? db.data
+   }
-            : LevelUp(LevelDown("./databases/" + name + "/data")),
-      collection:
-         db && db.collection.isOpen()
-            ? db.collection
-            : LevelUp(LevelDown("./databases/" + name + "/collection")),
-   };
 
    databases.set(name, db);
    return db;

src/web/helper/error.ts

@@ -7,13 +7,11 @@ export default function RequestError(ctx: Context, next) {
       ctx.body = message;
    }
 
-   return next()
+   return next().then(() => {
-      .then(() => {
       if (ctx.status === HttpStatusCode.NOT_FOUND) {
          reply(HttpStatusCode.NOT_FOUND, "Not found");
       }
-      })
+   }).catch(error => {
-      .catch((error) => {
       let message = "Internal server error";
       let status = HttpStatusCode.INTERNAL_SERVER_ERROR;
       if (typeof error === "string") {
@@ -25,12 +23,13 @@ export default function RequestError(ctx: Context, next) {
          if (error.status === HttpStatusCode.INTERNAL_SERVER_ERROR) {
             //If internal server error log whole error
             Logging.error(error);
-            } else {
+         }
+         else {
             message = error.message.split("\n", 1)[0];
-               Logging.error(message);
+            Logging.errorMessage(message);
          }
          status = error.status;
       }
       reply(status, message);
-      });
+   })
-}
+};

src/web/helper/errors.ts

@@ -398,12 +398,6 @@ export class NoPermissionError extends HttpError {
    }
 }
 
-export class UnauthorizedError extends HttpError {
-   constructor(message: string) {
-      super(message, HttpStatusCode.UNAUTHORIZED)
-   }
-}
-
 export class BadRequestError extends HttpError {
    constructor(message: string) {
       super(message, HttpStatusCode.BAD_REQUEST)

src/web/helper/form.ts

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

src/web/helper/hb.ts

@@ -1,7 +1,7 @@
 import * as Handlebars from "handlebars";
 import { readFileSync } from "fs";
 import config from "../../config";
-import Logging from "@hibas123/nodelogging";
+import Logging from "@hibas123/logging";
 
 
 function checkCondition(v1, operator, v2) {
@@ -37,22 +37,8 @@ Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {
 
 
 const cache = new Map<string, Handlebars.TemplateDelegate>();
-const htmlCache = new Map<string, string>();
 
-export function getView(name: string) {
+export default function getTemplate(name: string) {
-   let tl: string;
-   if (!config.dev)
-      tl = htmlCache.get(name);
-
-   if (!tl) {
-      tl = readFileSync(`./views/${name}.html`).toString();
-      htmlCache.set(name, tl);
-   }
-
-   return tl;
-}
-
-export function getTemplate(name: string) {
    let tl: Handlebars.TemplateDelegate;
    if (!config.dev)
       tl = cache.get(name);

src/web/helper/log.ts

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

src/web/helper/table.ts

@@ -1,5 +1,5 @@
 import { Context } from "koa";
-import { getTemplate } from "./hb";
+import getTemplate from "./hb";
 
 export default function getTable(title: string, data: any[], ctx: Context) {
    let table: string[][] = [];

src/web/v1/admin.ts

@@ -2,97 +2,81 @@ import * as Router from "koa-router";
 import Settings from "../../settings";
 import getForm from "../helper/form";
 import getTable from "../helper/table";
-import {
+import { BadRequestError, NoPermissionError } from "../helper/errors";
-   BadRequestError,
-   NoPermissionError,
-   NotFoundError,
-} from "../helper/errors";
 import { DatabaseManager } from "../../database/database";
 import { MP } from "../../database/query";
 import config from "../../config";
-import Logging from "@hibas123/nodelogging";
+import Logging from "@hibas123/logging";
-import { getView } from "../helper/hb";
 
 const AdminRoute = new Router();
 
 AdminRoute.use(async (ctx, next) => {
    const { key } = ctx.query;
-   if (key !== config.admin) throw new NoPermissionError("No permission!");
+   if (key !== config.admin)
+      throw new NoPermissionError("No permission!");
    return next();
-});
+})
 
-AdminRoute.get("/", async (ctx) => {
+AdminRoute.get("/settings", async ctx => {
-   //TODO: Main Interface
-   ctx.body = getView("admin");
-});
-
-AdminRoute.get("/settings", async (ctx) => {
    let res = await new Promise<string[][]>((yes, no) => {
       const stream = Settings.db.createReadStream({
          keys: true,
          values: true,
-         valueAsBuffer: 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));
+      stream.on("end", () => yes(res))
-   });
+   })
 
    if (ctx.query.view) {
       return getTable("Settings", res, ctx);
    } else {
       ctx.body = res;
    }
-});
+})
 
-AdminRoute.get("/data", async (ctx) => {
+AdminRoute.get("/data", async ctx => {
    const { database } = ctx.query;
-   let db = DatabaseManager.getDatabase(database as string);
+   let db = DatabaseManager.getDatabase(database);
-   if (!db) throw new BadRequestError("Database not found");
+   if (!db)
+      throw new BadRequestError("Database not found");
    let res = await new Promise<string[][]>((yes, no) => {
+
       const stream = db.data.createReadStream({
          keys: true,
          values: true,
          valueAsBuffer: true,
-         keyAsBuffer: false,
+         keyAsBuffer: false
-         limit: 1000,
       });
       let res = [["key", "value"]];
-      stream.on("data", ({ key, value }: { key: string; value: Buffer }) => {
+      stream.on("data", ({ key, value }: { key: string, value: Buffer }) => {
-         res.push([
+         Logging.debug("Admin Key:", key);
-            key,
+         res.push([key, key.split("/").length > 2 ? value.toString() : JSON.stringify(MP.decode(value))]);
-            key.split("/").length > 2
+      })
-               ? value.toString()
-               : JSON.stringify(MP.decode(value)),
-         ]);
-      });
 
       stream.on("error", no);
-      stream.on("end", () => yes(res));
+      stream.on("end", () => yes(res))
-   });
+   })
 
    if (ctx.query.view) {
       return getTable("Data from " + database, res, ctx);
    } else {
       ctx.body = res;
    }
-});
+})
 
-AdminRoute.get("/database", (ctx) => {
+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(
+         res = Array.from(DatabaseManager.databases.entries()).map(([name, config]) => ({ name, ...(JSON.parse(JSON.stringify(config))) }));
-         ([name, config]) => ({
-            name,
-            ...JSON.parse(JSON.stringify(config)),
-         })
-      );
       } else {
          res = Array.from(DatabaseManager.databases.keys());
       }
@@ -102,118 +86,40 @@ AdminRoute.get("/database", (ctx) => {
       } else {
          ctx.body = res;
       }
-}).post("/database", async (ctx) => {
+   })
+   .post("/database", async ctx => {
       const { name, rules, publickey, accesskey, rootkey } = ctx.request.body;
 
-   if (!name) throw new BadRequestError("Name must be set!");
+      if (!name)
+         throw new BadRequestError("Name must be set!");
 
       let db = DatabaseManager.getDatabase(name);
-   if (!db) db = await DatabaseManager.addDatabase(name);
+      if (!db)
+         db = await DatabaseManager.addDatabase(name);
 
-   if (publickey) await db.setPublicKey(publickey);
+      if (publickey)
+         await db.setPublicKey(publickey);
 
-   if (rules) {
+      if (rules)
-      const error = await db.setRules(rules);
+         await db.setRules(rules);
-      if (error) {
-         ctx.status = 500;
-         ctx.body = error;
-         return;
-      }
-   }
 
-   if (accesskey) await db.setAccessKey(accesskey);
+      if (accesskey)
+         await db.setAccessKey(accesskey);
+
+
+      if (rootkey)
+         await db.setRootKey(rootkey);
 
-   if (rootkey) await db.setRootKey(rootkey);
 
       ctx.body = "Success";
-});
+   })
 
-AdminRoute.get("/collections", async (ctx) => {
+AdminRoute.get("/database/new", getForm("/v1/admin/database", "New/Change Database", {
-   const { database } = ctx.query;
+   name: { label: "Name", type: "text", },
-   let db = DatabaseManager.getDatabase(database as string);
-   if (!db) throw new BadRequestError("Database not found");
-
-   let res = await new Promise<string[]>((yes, no) => {
-      const stream = db.collections.createKeyStream({
-         keyAsBuffer: false,
-         limit: 1000,
-      });
-      let res = [];
-      stream.on("data", (key: string) => {
-         res.push(key);
-      });
-
-      stream.on("error", no);
-      stream.on("end", () => yes(res));
-   });
-
-   if (ctx.query.view) {
-      return getTable("Databases", res, ctx);
-   } else {
-      ctx.body = res;
-   }
-});
-
-AdminRoute.get("/collections/cleanup", async (ctx) => {
-   const { database } = ctx.query;
-   let db = DatabaseManager.getDatabase(database as string);
-   if (!db) throw new BadRequestError("Database not found");
-
-   let deleted = await db.runCleanup();
-   if (ctx.query.view) {
-      return getTable("Databases", deleted, ctx);
-   } else {
-      ctx.body = deleted;
-   }
-});
-
-AdminRoute.get(
-   "/database/new",
-   getForm("/v1/admin/database", "New Database", {
-      name: { label: "Name", type: "text" },
    accesskey: { label: "Access Key", type: "text" },
    rootkey: { label: "Root access key", type: "text" },
-      rules: {
+   rules: { label: "Rules", type: "textarea", value: `{\n   ".write": true, \n   ".read": true \n}` },
-         label: "Rules",
+   publickey: { label: "Public Key", type: "textarea" }
-         type: "codemirror",
+}))
-         value: `{\n   ".write": true, \n   ".read": true \n}`,
-      },
-      publickey: { label: "Public Key", type: "textarea" },
-   })
-);
-
-AdminRoute.get("/database/update", async (ctx) => {
-   const { database } = ctx.query;
-   let db = DatabaseManager.getDatabase(database as string);
-   if (!db) throw new NotFoundError("Database not found!");
-   getForm("/v1/admin/database", "Change Database", {
-      name: {
-         label: "Name",
-         type: "text",
-         value: db.name,
-         disabled: true,
-      },
-      accesskey: {
-         label: "Access Key",
-         type: "text",
-         value: db.accesskey,
-      },
-      rootkey: {
-         label: "Root access key",
-         type: "text",
-         value: db.rootkey,
-      },
-      rules: {
-         label: "Rules",
-         type: "codemirror",
-         value: db.rawRules,
-      },
-      publickey: {
-         label: "Public Key",
-         type: "textarea",
-         value: db.publickey,
-      },
-   })(ctx);
-});
 
 export default AdminRoute;

src/web/v1/index.ts

@@ -1,63 +1,5 @@
 import * as Router from "koa-router";
 import AdminRoute from "./admin";
-import { DatabaseManager } from "../../database/database";
-import {
-   NotFoundError,
-   NoPermissionError,
-   BadRequestError,
-} from "../helper/errors";
-import Logging from "@hibas123/nodelogging";
-import Session from "../../database/session";
-import { nanoid } from "nanoid";
-import { verifyJWT } from "../../helper/jwt";
-import { QueryError } from "../../database/query";
 const V1 = new Router({ prefix: "/v1" });
-
 V1.use("/admin", AdminRoute.routes(), AdminRoute.allowedMethods());
-
-V1.post("/db/:database/query", async (ctx) => {
-   const { database } = ctx.params;
-   const { accesskey, authkey, rootkey } = ctx.query;
-
-   const query = ctx.request.body;
-   if (!query) {
-      throw new BadRequestError("Query not defined!");
-   }
-
-   const session = new Session(nanoid());
-   const db = DatabaseManager.getDatabase(database);
-   if (!db) {
-      throw new NotFoundError("Database not found!");
-   }
-
-   if (db.accesskey) {
-      if (!accesskey || accesskey !== db.accesskey) {
-         throw new NoPermissionError("Invalid Access Key");
-      }
-   }
-
-   if (authkey && db.publickey) {
-      let res = await verifyJWT(authkey as string, db.publickey);
-      if (res && !res.uid && res.user) res.uid = res.user;
-      if (!res || !res.uid) {
-         throw new BadRequestError("Invalid JWT");
-      } else {
-         session.uid = res.uid;
-      }
-   }
-
-   if (rootkey && db.rootkey) {
-      if (rootkey === db.rootkey) {
-         session.root = true;
-         Logging.warning(`Somebody logged into ${database} via rootkey`);
-      }
-   }
-
-   ctx.body = await db.run([query], session).catch((err) => {
-      if (err instanceof QueryError) {
-         throw new BadRequestError(err.message);
-      }
-      throw err;
-   });
-});
 export default V1;

src/websocket.ts

@@ -1,163 +0,0 @@
-import Logging from "@hibas123/nodelogging";
-import { IncomingMessage, Server } from "http";
-import * as WebSocket from "ws";
-import { DatabaseManager } from "./database/database";
-import {
-   CollectionQuery,
-   DocumentQuery,
-   IQuery,
-   ITypedQuery,
-} from "./database/query";
-import Session from "./database/session";
-import { verifyJWT } from "./helper/jwt";
-import { nanoid } from "nanoid";
-
-export class WebsocketConnectionManager {
-   static server: WebSocket.Server;
-
-   static bind(server: Server) {
-      this.server = new WebSocket.Server({ server });
-      this.server.on("connection", this.onConnection.bind(this));
-   }
-
-   private static async onConnection(socket: WebSocket, req: IncomingMessage) {
-      Logging.log("New Connection:");
-
-      socket.on("error", (err) => {
-         Logging.error(err);
-         socket.close();
-      });
-
-      const sendError = (error: string) =>
-         socket.send(JSON.stringify({ ns: "error_msg", data: error }));
-
-      const session = new Session(nanoid());
-
-      const query = new URL(req.url, "http://localhost").searchParams;
-
-      const database = query.get("database");
-      const db = DatabaseManager.getDatabase(database);
-      if (!db) {
-         sendError("Invalid Database!");
-         socket.close();
-         return;
-      }
-
-      const accesskey = query.get("accesskey");
-      if (db.accesskey) {
-         if (!accesskey || accesskey !== db.accesskey) {
-            sendError("Unauthorized!");
-            socket.close();
-            return;
-         }
-      }
-
-      const authkey = query.get("authkey");
-      if (authkey && db.publickey) {
-         let res = await verifyJWT(authkey, db.publickey);
-         if (res && !res.uid && res.user) res.uid = res.user;
-         if (!res || !res.uid) {
-            sendError("Invalid JWT");
-            socket.close();
-            return;
-         } else {
-            session.uid = res.uid;
-         }
-      }
-
-      const rootkey = query.get("rootkey");
-      if (rootkey && db.rootkey) {
-         if (rootkey === db.rootkey) {
-            session.root = true;
-            Logging.warning(`Somebody logged into ${database} via rootkey`);
-         }
-      }
-
-      const answer = (id: string, data: any, err?: Error | string) => {
-         let error = false;
-         if (err) {
-            Logging.error(err);
-            if (err instanceof Error) {
-               data = err.message;
-            } else {
-               data = err;
-            }
-
-            error = true;
-         }
-         socket.send(
-            JSON.stringify({ ns: "message", data: { id, error, data } })
-         );
-      };
-
-      const handler = new Map<string, (data: any) => void>();
-
-      handler.set("v2", async ({ id, query }) =>
-         db
-            .run(Array.isArray(query) ? query : [query], session)
-            .then((res) => answer(id, res))
-            .catch((err) => answer(id, undefined, err))
-      );
-
-      // handler.set("bulk", async ({ id, query }) => db.run(query, session)
-      //    .then(res => answer(id, res))
-      //    .catch(err => answer(id, undefined, err))
-      // );
-
-      const SnapshotMap = new Map<string, string>();
-      handler.set(
-         "snapshot",
-         async ({
-            id,
-            query,
-         }: {
-            id: string;
-            query: ITypedQuery<"snapshot">;
-         }) => {
-            db.snapshot(query, session, (data) => {
-               Logging.debug("Sending snapshot");
-               socket.send(
-                  JSON.stringify({
-                     ns: "snapshot",
-                     data: { id, data },
-                  })
-               );
-            })
-               .then((s) => {
-                  answer(id, s.snaphot);
-                  SnapshotMap.set(id, s.id);
-               })
-               .catch((err) => answer(id, undefined, err));
-         }
-      );
-
-      handler.set("unsubscribe", async ({ id }) => {
-         let i = SnapshotMap.get(id);
-         if (i) {
-            db.unsubscribe(i, session);
-            SnapshotMap.delete(i);
-         }
-      });
-
-      socket.on("message", async (rawData: string) => {
-         try {
-            let message: { ns: string; data: any } = JSON.parse(rawData);
-            let h = handler.get(message.ns);
-            if (h) {
-               h(message.data);
-            }
-         } catch (err) {
-            Logging.error("Unknown Error:");
-            Logging.error(err);
-         }
-      });
-      db.connections++;
-      socket.on("close", () => {
-         db.connections--;
-         Logging.log(`${session.id} has disconnected!`);
-         session.subscriptions.forEach((unsubscribe) => unsubscribe());
-         session.subscriptions.clear();
-         socket.removeAllListeners();
-      });
-   }
-}

tsconfig.json

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

views/admin.html

@@ -1,125 +0,0 @@
-<!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>Admin Interface</title>
-      <link
-         rel="stylesheet"
-         href="https://unpkg.com/@hibas123/theme@1/out/base.css"
-      />
-      <link
-         rel="stylesheet"
-         href="https://unpkg.com/@hibas123/theme@1/out/light.css"
-      />
-
-      <script src="https://unpkg.com/handlebars/dist/handlebars.min.js"></script>
-
-      <style>
-         #message {
-            visibility: hidden;
-            background-color: lightgreen;
-            border: 1px solid lime;
-            border-radius: 0.5rem;
-            padding: 1rem;
-            font-size: 1.5rem;
-            margin-bottom: 1rem;
-         }
-
-         .grid {
-            display: grid;
-            height: 100vh;
-            grid-template-columns: 360px auto;
-         }
-
-         #navigation {
-            height: 100vh;
-            overflow: auto;
-            border-right: 1px solid darkgrey;
-            padding: 1rem;
-         }
-
-         #content {
-            position: absolute;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100vh;
-            border: 0;
-         }
-      </style>
-   </head>
-
-   <body>
-      <div class="grid">
-         <div id="navigation">
-            <h2>Navigation:</h2>
-            <ul class="list list-clickable">
-               <li onclick="loadView('settings');">Settings</li>
-               <li onclick="loadView('database', {full:true});">Databases</li>
-               <li onclick="loadView('database/new');">New Database</li>
-            </ul>
-            Databases:
-            <div
-               id="dbs"
-               class="list list-clickable"
-               style="margin: 1rem"
-            ></div>
-         </div>
-         <div style="position: relative">
-            <iframe id="content"></iframe>
-         </div>
-      </div>
-
-      <template> </template>
-
-      <script>
-         const key = new URL(window.location.href).searchParams.get("key");
-         const content = document.getElementById("content");
-         const base = new URL(window.location.href).host;
-
-         function getUrl(name, params, view = true) {
-            const url = new URL(window.location.href);
-            url.pathname = "/v1/admin/" + name;
-            for (let key in params || {})
-               url.searchParams.set(key, params[key]);
-
-            url.searchParams.set("key", key);
-            if (view) url.searchParams.set("view", "true");
-
-            return url.href;
-         }
-
-         function loadView(name, params) {
-            content.src = getUrl(name, params);
-         }
-
-         loadView("settings");
-
-         const dbsul = document.getElementById("dbs");
-         function reloadDBs() {
-            fetch(getUrl("database", {}, false))
-               .then((res) => res.json())
-               .then((databases) =>
-                  databases.map(
-                     (database) => `
-<div class="card margin elv-4">
-   <h3>${database}</h3>
-   <button class=btn onclick="loadView('data', {database:'${database}'})">Data</button>
-   <button class=btn onclick="loadView('collections', {database:'${database}'})">Collections</button>
-   <button class=btn onclick="loadView('database/update', {database:'${database}'})">Change</button>
-   <button class=btn onclick="loadView('collections/cleanup', {database:'${database}'})">Clean</button>
-</div>`
-                  )
-               )
-               .then((d) => d.join("\n"))
-               .then((d) => (dbsul.innerHTML = d))
-               .catch(console.error);
-         }
-
-         reloadDBs();
-         setInterval(reloadDBs, 5000);
-      </script>
-   </body>
-</html>

views/forms.hbs

@@ -6,9 +6,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@1/out/base.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/light.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
-   <link rel="stylesheet" href="https://unpkg.com/codemirror@5.58.2/lib/codemirror.css">
 
    <style>
       #message {
@@ -33,23 +32,19 @@
             <div class="input-group">
                <label>{{label}}</label>
                {{#ifCond type  "===" "text"}}
-               <input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
+               <input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
                {{/ifCond}}
 
                {{#ifCond type "===" "number"}}
-               <input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
+               <input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
                {{/ifCond}}
 
                {{#ifCond type "===" "boolean"}}
-               <input type="checkbox" name="{{name}}" checked="{{value}}" {{disabled}} />
+               <input type="checkbox" name="{{name}}" checked="{{value}}" />
                {{/ifCond}}
 
                {{#ifCond type "===" "textarea"}}
-               <textarea class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
+               <textarea class="inp" name="{{name}}" rows="20">{{value}}</textarea>
-               {{/ifCond}}
-
-               {{#ifCond type "===" "codemirror"}}
-               <textarea codemirror class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
                {{/ifCond}}
             </div>
             {{/each}}
@@ -86,19 +81,6 @@
          return false;
       }
    </script>
-
-   <script src="https://unpkg.com/codemirror@5.58.2/lib/codemirror.js"></script>
-   <script>
-      document.querySelectorAll("textarea[codemirror]").forEach(elm => {
-         const cm = CodeMirror.fromTextArea(elm, {
-            lineNumbers: true,
-            indentUnit: 3,
-            tabSize: 3,
-         })
-
-         cm.on("change", () => cm.save())
-      })
-   </script>
 </body>
 
 </html>

views/tables.hbs

@@ -6,8 +6,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@1/out/base.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/light.css">
+   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
 
    <style>
       table {