Increase version

.drone.yml

@@ -0,0 +1,24 @@
+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: hibas123.azurecr.io/realtimedb
+      registry: hibas123.azurecr.io
+      debug: true
+    when:
+      branch: [master]

.editorconfig

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

.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+   // 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:12
+FROM node:14
 
 LABEL maintainer="Fabian Stamm <dev@fabianstamm.de>"
 
@@ -8,6 +8,8 @@ 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,15 +1,13 @@
 {
    "name": "@hibas123/realtimedb",
-  "version": "2.0.0-beta.8",
+   "version": "2.0.0-beta.22",
    "description": "",
    "main": "lib/index.js",
    "private": true,
    "scripts": {
       "start": "node lib/index.js",
       "build": "tsc",
-    "watch-ts": "tsc -w",
-    "watch-node": "nodemon --ignore *.ts lib/index.js",
-    "watch": "concurrently \"npm:watch-*\"",
+      "watch": "nodemon -e ts --exec ts-node src/index.ts",
       "build-docker": "npm run build && docker build -t realtimedb .",
       "prepublishOnly": "tsc"
    },
@@ -17,31 +15,32 @@
    "license": "ISC",
    "devDependencies": {
       "@types/dotenv": "^8.2.0",
-    "@types/jsonwebtoken": "^8.3.5",
-    "@types/koa": "^2.0.51",
-    "@types/koa-router": "^7.0.42",
-    "@types/leveldown": "^4.0.1",
-    "@types/levelup": "^3.1.1",
+      "@types/jsonwebtoken": "^8.5.0",
+      "@types/koa": "^2.11.6",
+      "@types/koa-router": "^7.4.1",
+      "@types/leveldown": "^4.0.2",
+      "@types/levelup": "^4.3.0",
       "@types/nanoid": "^2.1.0",
-    "@types/node": "^12.12.5",
-    "@types/ws": "^6.0.3",
-    "concurrently": "^5.0.0",
-    "nodemon": "^1.19.4",
-    "typescript": "^3.6.4"
+      "@types/node": "^14.14.5",
+      "@types/ws": "^7.2.8",
+      "concurrently": "^5.3.0",
+      "nodemon": "^2.0.6",
+      "ts-node": "^9.0.0",
+      "typescript": "^4.0.5"
    },
    "dependencies": {
-    "@hibas123/nodelogging": "^2.1.1",
-    "@hibas123/utils": "^2.1.1",
+      "@hibas123/nodelogging": "^2.4.5",
+      "@hibas123/utils": "^2.2.16",
       "dotenv": "^8.2.0",
-    "handlebars": "^4.5.1",
+      "handlebars": "^4.7.6",
       "jsonwebtoken": "^8.5.1",
-    "koa": "^2.11.0",
-    "koa-body": "^4.1.1",
-    "koa-router": "^7.4.0",
-    "leveldown": "^5.4.1",
-    "levelup": "^4.3.2",
-    "nanoid": "^2.1.6",
+      "koa": "^2.13.0",
+      "koa-body": "^4.2.0",
+      "koa-router": "^9.4.0",
+      "leveldown": "^5.6.0",
+      "levelup": "^4.4.0",
+      "nanoid": "^3.1.16",
       "what-the-pack": "^2.0.3",
-    "ws": "^7.2.0"
+      "ws": "^7.3.1"
    }
 }

src/config.ts

@@ -1,22 +1,21 @@
 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;

src/connection.ts

@@ -1,116 +0,0 @@
-import Logging from "@hibas123/nodelogging";
-import { IncomingMessage, Server } from "http";
-import * as WebSocket from "ws";
-import { DatabaseManager, IQuery, ITypedQuery } from "./database/database";
-import { CollectionQuery, DocumentQuery } from "./database/query";
-import Session from "./database/session";
-import { verifyJWT } from "./helper/jwt";
-import nanoid = require("nanoid");
-
-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());
-
-      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) {
-            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, error: boolean = false) => {
-         socket.send(JSON.stringify({ ns: "message", data: { id, error, data } }));
-      }
-
-      const handler = new Map<string, ((data: any) => void)>();
-
-      handler.set("v2", async ({ id, query }: { id: string, query: IQuery }) => 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 => {
-            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.errorMessage("Unknown Error:");
-            Logging.error(err);
-         }
-      })
-
-      socket.on("close", () => {
-         Logging.log(`${session.id} has disconnected!`);
-         session.queries.forEach((query: DocumentQuery | CollectionQuery) => {
-            query.unsubscribe();
-         })
-         session.queries.clear();
-         socket.removeAllListeners();
-      })
-   }
-}

src/database/database.ts

@@ -1,29 +1,31 @@
-import { Rules } from "./rules";
 import Settings from "../settings";
-import getLevelDB, { LevelDB, deleteLevelDB } from "../storage";
+import getLevelDB, { deleteLevelDB, resNull } from "../storage";
 import DocumentLock from "./lock";
-import { DocumentQuery, CollectionQuery, Query, QueryError } from "./query";
+import {
+   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";
 
-type IWriteQueries = "set" | "update" | "delete" | "add";
-type ICollectionQueries = "get" | "add" | "keys" | "delete-collection" | "list";
-type IDocumentQueries = "get" | "set" | "update" | "delete";
+const ALPHABET =
+   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-export interface ITypedQuery<T> {
-   path: string[];
-   type: T;
-   data?: any;
-   options?: any;
-}
-
-interface ITransaction {
-   queries: ITypedQuery<IWriteQueries>[];
-}
-
-export type IQuery = ITypedQuery<ICollectionQueries | IDocumentQueries>;
+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>();
@@ -31,15 +33,20 @@ export class DatabaseManager {
    static async init() {
       let databases = await Settings.getDatabases();
 
-      databases.forEach(dbconfig => {
-         let db = new Database(dbconfig.name, dbconfig.accesskey, dbconfig.rules, dbconfig.publickey, dbconfig.rootkey);
+      databases.forEach((dbconfig) => {
+         let db = new Database(
+            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);
@@ -52,11 +59,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);
       }
    }
 }
@@ -66,47 +73,96 @@ export type ChangeTypes = "added" | "modified" | "deleted";
 export type Change = {
    data: any;
    document: string;
+   collection: string;
    type: ChangeTypes;
    sender: string;
-}
-
+};
 
 export class Database {
-   private level = getLevelDB(this.name);
+   public static getKey(collectionid: string, documentid?: string) {
+      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;
 
-   public rules: Rules;
-   public locks = new DocumentLock()
-   public collectionLocks = new DocumentLock()
+   get rawRules() {
+      return this.#rawRules;
+   }
 
-   public changes = new Map<string, Set<(change: Change) => void>>();
+   get rules() {
+      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(public name: string, public accesskey?: string, rawRules?: string, public publickey?: string, public rootkey?: string) {
-      if (rawRules)
-         this.rules = new Rules(rawRules);
+   constructor(
+      public name: string,
+      public accesskey?: string,
+      rawRules?: string,
+      public publickey?: string,
+      public rootkey?: string
+   ) {
+      if (rawRules) this.applyRules(rawRules);
+   }
+
+   private applyRules(rawRules: string): undefined | RuleError {
+      try {
+         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) {
-      let rules = new Rules(rawRules);
+      const { runner, error } = compileRule(rawRules);
+      if (error) return error;
       await Settings.setDatabaseRules(this.name, rawRules);
-      this.rules = rules;
+      this.#rules = runner;
+      this.#rawRules = rawRules;
    }
 
    async setAccessKey(key: string) {
@@ -124,102 +180,209 @@ 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("/");
 
-   getQuery(path: string[], session: Session, type: "document" | "collection" | "any") {
-      if (type === "document")
-         return new DocumentQuery(this, path, session);
-      else if (type === "collection")
-         return new CollectionQuery(this, path, session);
-      else
-         return new Query(this, path, session);
+      const lock = await this.collectionLocks.lock(key);
+
+      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 || typeof query !== "object") throw inv;
 
-      if (!query.type)
-         throw inv;
+      if (!query.type) throw inv;
 
-      if (!query.path)
-         throw inv;
+      if (!query.path) throw inv;
    }
 
-   async run(query: IQuery, session: Session) {
-      this.validate(query);
-      const isCollection = query.path.length % 2 === 1;
-      if (isCollection) {
-         const q = new CollectionQuery(this, query.path, session);
-         let type = query.type as ICollectionQueries;
-         switch (type) {
-            case "add":
-               return q.add(query.data);
-            case "get":
-               const limit = (query.options || {}).limit;
-               if (limit)
-                  q.limit = limit;
-               const where = (query.options || {}).where;
-               if (where)
-                  q.where = where;
-               return q.get();
-            case "keys":
-               return q.keys();
-            case "list":
-               return q.collections();
-            case "delete-collection":
-               return q.deleteCollection();
-            default:
-               return Promise.reject(new Error("Invalid query!"));
-         }
-      } else {
-         const q = new DocumentQuery(this, query.path, session);
-         let type = query.type as IDocumentQueries;
-         switch (type) {
-            case "get":
-               return q.get();
-            case "set":
-               return q.set(query.data, query.options || {});
-            case "update":
-               return q.update(query.data);
-            case "delete":
-               return q.delete();
-            default:
-               return Promise.reject(new Error("Invalid query!"));
-         }
+   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);
          }
 
-   async snapshot(query: ITypedQuery<"snapshot">, session: Session, onchange: (change: any) => void) {
-      this.validate(query);
+         entry.create = entry.create || create;
 
-      const isCollection = query.path.length % 2 === 1;
-      let q: DocumentQuery | CollectionQuery;
-      if (isCollection) {
-         q = new CollectionQuery(this, query.path, session);
-         const limit = (query.options || {}).limit;
-         if (limit)
-            q.limit = limit;
-         const where = (query.options || {}).where;
-         if (where)
-            q.where = where;
-      } else {
-         q = new DocumentQuery(this, query.path, session);
+         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));
       }
 
-      const id = nanoid(16);
-      session.queries.set(id, q);
+      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: await q.snapshot(onchange)
+         snaphot: value,
       };
    }
 
    async unsubscribe(id: string, session: Session) {
-      let query: CollectionQuery | DocumentQuery = session.queries.get(id) as any;
+      let query = session.subscriptions.get(id);
       if (query) {
-         query.unsubscribe();
-         session.queries.delete(id);
+         query();
+         session.subscriptions.delete(id);
       }
    }
 
@@ -231,39 +394,39 @@ export class Database {
       const should = await new Promise<Set<string>>((yes, no) => {
          const stream = this.collections.iterator({
             keyAsBuffer: false,
-            valueAsBuffer: 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))
+               stream.end((err) => Logging.error(err));
                no(err);
             }
 
             if (!key && !value) {
                yes(collections);
             } else {
-               collections.add(value)
+               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
-         })
+            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))
+               stream.end((err) => Logging.error(err));
                no(err);
             }
 
@@ -271,19 +434,18 @@ export class Database {
                yes(collections);
             } else {
                let coll = key.split("/")[0];
-               collections.add(coll)
+               collections.add(coll);
                stream.next(onValue);
             }
-         }
+         };
 
          stream.next(onValue);
-      })
+      });
 
       const toDelete = new Set<string>();
-      existing.forEach(collection => {
-         if (!should.has(collection))
-            toDelete.add(collection);
-      })
+      existing.forEach((collection) => {
+         if (!should.has(collection)) toDelete.add(collection);
+      });
 
       for (let collection of toDelete) {
          const batch = this.data.batch();
@@ -293,20 +455,20 @@ export class Database {
 
          let lt = Buffer.alloc(gt.length);
          lt.set(gt);
-         lt[gt.length - 1] = 0xFF;
+         lt[gt.length - 1] = 0xff;
 
          await new Promise<void>((yes, no) => {
             const stream = this.data.iterator({
                keyAsBuffer: false,
                values: false,
                gt,
-               lt
-            })
+               lt,
+            });
 
             const onValue = (err: Error, key: string, value: Buffer) => {
                if (err) {
                   Logging.error(err);
-                  stream.end((err) => Logging.error(err))
+                  stream.end((err) => Logging.error(err));
                   no(err);
                }
 
@@ -316,15 +478,14 @@ export class Database {
                   batch.del(key);
                   stream.next(onValue);
                }
-            }
+            };
 
             stream.next(onValue);
-         })
+         });
 
          await batch.write();
       }
 
       return Array.from(toDelete.values());
    }
-
 }

src/database/lock.ts

@@ -4,24 +4,26 @@ 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(resolve => { l.push(resolve); this.locks.set(key, l) });
+         await new Promise((resolve) => {
+            l.push(resolve);
+            this.locks.set(key, l);
+         });
       else {
          l = [];
          this.locks.set(key, l);
       }
 
       return () => {
-         if (l.length > 0)
-            setImmediate(() => l.shift()());
-         else
-            this.locks.delete(key)
-      }
+         if (l.length > 0) setImmediate(() => l.shift()());
+         else this.locks.delete(key);
+      };
    }
 }

src/database/query.ts

@@ -1,90 +1,249 @@
 import { Database, Change, ChangeTypes } from "./database";
 import { resNull } from "../storage";
-import nanoid = require("nanoid/generate");
+import * as nanoid from "nanoid";
 import Logging from "@hibas123/nodelogging";
 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 type ICollectionQueries =
+   | "get"
+   | "add"
+   | "keys"
+   | "delete-collection"
+   | "list";
+export type IDocumentQueries = "get" | "set" | "update" | "delete";
+
+export interface ITypedQuery<T> {
+   path: string[];
+   type: T;
+   data?: any;
+   options?: any;
+}
+
+export type IQuery = ITypedQuery<
+   ICollectionQueries | IDocumentQueries | "snapshot"
+>;
 
 export const MP = MSGPack.initialize(2 ** 20);
 
-const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ALPHABET =
+   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+const longNanoID = nanoid.customAlphabet(ALPHABET, 32);
 
 const { encode, decode } = MP;
 
-export class Query {
+type Runner = (
+   collection: string,
+   document: string,
+   batch: LevelUpChain,
+   collectionKey: string
+) => any;
+
+interface IPreparedQuery {
+   createCollection: boolean;
+   needDocument: boolean;
+   batchCompatible: boolean;
+   runner: Runner;
+   permission: Operations;
+   additionalLock?: string[];
+}
+
+interface DocRes {
+   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(e => (e.match(/[^a-zA-Z0-9_\-\<\>]/g) || []).length === 0);
+      return path.every(
+         (e) => (e.match(/[^a-zA-Z0-9_\-\<\>]/g) || []).length === 0
+      );
    }
 
-   constructor(protected database: Database, protected path: string[], protected session: Session) {
-      if (path.length > 10) {
-         throw new QueryError("Path is to long. Path is only allowed to be 10 Layers deep!");
+   public changes: Change[] = [];
+
+   public readonly createCollection: boolean;
+   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(path)) {
-         throw new QueryError("Path can only contain a-z A-Z 0-9  '-' '-' '<' and '>' ");
+      if (!this.validatePath(query.path)) {
+         throw new QueryError(
+            "Path can only contain a-z A-Z 0-9  '-' '-' '<' and '>' "
+         );
+      }
+
+      if (!snapshot) {
+         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 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.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();
-      }
-
-      return {
-         collection: collectionID,
-         document: documentKey,
-         collectionKey: key
-      };
-   }
-
-   protected getKey(collection: string, document?: string) {
-      return `${collection || ""}/${document || ""}`;
-   }
+   protected abstract prepare(query: IQuery): IPreparedQuery;
 
    protected getDoc(collection: string, document: string) {
       return this.database.data
-         .get(this.getKey(collection, document), { asBuffer: true })
-         .then(res => decode<any>(res as Buffer)).catch(resNull);
+         .get(Database.getKey(collection, document), { asBuffer: true })
+         .then((res) => decode<any>(res as Buffer))
+         .catch(resNull);
    }
 
-   protected sendChange(collection: string, document: string, type: ChangeTypes, data: any) {
+   protected sendChange(
+      collection: string,
+      document: string,
+      type: ChangeTypes,
+      data: any
+   ) {
       let change: Change = {
          type,
          document,
+         collection,
          data,
-         sender: this.session.id
+         sender: this.session.id,
+      };
+
+      Logging.debug("Sending change:", change);
+
+      this.changes.push(change);
    }
 
-      let s = this.database.changes.get(this.getKey(collection, document))
-
-      if (s)
-         s.forEach(e => setImmediate(() => e(change)))
-      s = this.database.changes.get(this.getKey(collection))
-      if (s)
-         s.forEach(e => setImmediate(() => e(change)))
-
+   protected static getConstructorParams(
+      query: Query
+   ): [Database, Session, IQuery] {
+      return [query.database, query.session, query.query];
    }
 
-   protected static getConstructorParams(query: Query): [Database, string[], Session] {
-      return [query.database, query.path, query.session];
+   protected abstract checkChange(change: Change): boolean;
+   protected abstract firstSend(
+      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),
+      };
    }
 }
 
@@ -92,62 +251,79 @@ interface UpdateData {
    [path: string]: {
       type: "value" | "timestamp" | "increment" | "push";
       value: any;
-   }
+   };
 }
 export class DocumentQuery extends Query {
-   constructor(database: Database, path: string[], session: Session) {
-      super(database, path, session);
-      this.onChange = this.onChange.bind(this);
+   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);
+      }
    }
 
-   public async get() {
-      let { collection, document } = await this.resolve(this.path);
-
+   private async get(collection: string, document: string) {
       if (!collection || !document) {
          return null;
       }
 
-      return this.getDoc(collection, document)
+      return this.getDoc(collection, document);
    }
 
-   public async set(data: any, { merge = false }) {
-      if (data === null)
-         return this.delete();
-      let { collection, document } = await this.resolve(this.path, true);
-      if (!collection) {
-         throw new QueryError("There must be a collection!")
+   private async set(
+      collection: string,
+      document: string,
+      batch?: LevelUpChain
+   ) {
+      const { data, options } = this.query;
+      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);
    }
 
-      if (!document) {
-         throw new QueryError("There must be a document key!")
-      }
+   private async update(
+      collection: string,
+      document: string,
+      batch?: LevelUpChain
+   ) {
+      const updateData: UpdateData = this.query.data;
 
-      const lock = await this.database.locks.lock(collection, document);
-
-      let isNew = !(await this.getDoc(collection, document))
-
-      return this.database.data
-         .put(this.getKey(collection, document), encode(data))
-         .then(() => this.sendChange(collection, document, isNew ? "added" : "modified", data))
-         .finally(() => lock())
-   }
-
-   public async update(updateData: UpdateData) {
-      let { collection, document } = await this.resolve(this.path, true);
-      if (!collection) {
-         throw new QueryError("There must be a collection!")
-      }
-
-      if (!document) {
-         throw new QueryError("There must be a document key!")
-      }
-
-      // Logging.debug(updateData);
-
-      const lock = await this.database.locks.lock(collection, document);
-      try {
       let data = await this.getDoc(collection, document);
-         let isNew = false
+      let isNew = false;
       if (!data) {
          isNew = true;
          data = {};
@@ -159,15 +335,12 @@ export class DocumentQuery extends Query {
          let parts = path.split(".");
          while (parts.length > 1) {
             let seg = parts.shift();
-               if (!data[seg])
-                  data[seg] = {}
+            if (!data[seg]) data[seg] = {};
             d = data[seg];
          }
 
          const last = parts[0];
 
-            // Logging.debug(parts, last, d)
-
          switch (toUpdate.type) {
             case "value":
                d[last] = toUpdate.value;
@@ -198,82 +371,38 @@ export class DocumentQuery extends Query {
          }
       }
 
-         this.database.data
-            .put(this.getKey(collection, document), encode(data))
-            .then(() => this.sendChange(collection, document, isNew ? "added" : "modified", data))
-      } finally {
-         lock();
-      }
-      //TODO: Implement
+      if (batch) {
+         batch.put(Database.getKey(collection, document), encode(data));
+      } else {
+         await this.database.data.put(
+            Database.getKey(collection, document),
+            encode(data)
+         );
       }
 
-   public async delete() {
-      let { collection, document } = await this.resolve(this.path);
-
-      if (!collection) {
-         throw new QueryError("There must be a collection!")
+      this.sendChange(collection, document, isNew ? "added" : "modified", data);
    }
 
-      if (!document) {
-         throw new QueryError("There must be a document key!")
+   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));
       }
 
-      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())
+      this.sendChange(collection, document, "deleted", null);
    }
 
-
-
-   private subscription: {
-      key: string,
-      onChange: (change: DocRes & { type: ChangeTypes }) => void
-   };
-
-   async snapshot(onChange: (change: DocRes & { type: ChangeTypes }) => void) {
-      if (this.subscription)
-         throw new QueryError("This query is already subscribed!");
-      let { collection, document } = await this.resolve(this.path);
-
-      let data = await this.getDoc(collection, document);
-      let key = this.getKey(collection, document);
-      this.subscription = {
-         key,
-         onChange
-      }
-      let s = this.database.changes.get(key);
-      if (!s) {
-         s = new Set();
-         this.database.changes.set(key, s);
+   checkChange(change: Change) {
+      return true;
    }
 
-      s.add(this.onChange);
-
-      return data;
-   }
-
-   onChange(change: Change) {
-      // if(change.sender === this.sender)
-      //    return
-      this.subscription.onChange({
-         id: change.document,
-         data: change.data,
-         type: change.type
-      })
-   }
-
-   unsubscribe() {
-      if (!this.subscription)
-         return;
-      let s = this.database.changes.get(this.subscription.key);
-      s.delete(this.onChange);
-      if (s.size <= 0)
-         this.database.changes.delete(this.subscription.key);
-
-      this.subscription = undefined;
+   firstSend(collection: string, document: string) {
+      return this.get(collection, document);
    }
 
    public static fromQuery(query: Query) {
@@ -283,122 +412,177 @@ export class DocumentQuery extends Query {
 
 type FieldPath = string;
 type WhereFilterOp =
-   | '<'
-   | '<='
-   | '=='
-   | '>='
-   | '>'
-   | 'array-contains'
-   | 'in'
-   | 'array-contains-any';
+   | "<"
+   | "<="
+   | "=="
+   | ">="
+   | ">"
+   | "array-contains"
+   | "in"
+   | "array-contains-any";
 
 interface IQueryWhereVerbose {
-   fieldPath: FieldPath,
-   opStr: WhereFilterOp,
-   value: any
+   fieldPath: FieldPath;
+   opStr: WhereFilterOp;
+   value: any;
 }
 
 type IQueryWhereArray = [FieldPath, WhereFilterOp, any];
 
 type IQueryWhere = IQueryWhereArray | IQueryWhereVerbose;
 
-interface DocRes {
-   id: string;
-   data: any;
-}
-
 export class CollectionQuery extends Query {
-   constructor(database: Database, path: string[], session: Session) {
-      super(database, path, session);
-      this.onChange = this.onChange.bind(this);
+   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[] = [];
+   private _where: IQueryWhereArray[];
    public set where(value: IQueryWhere[]) {
       const invalidWhere = new QueryError("Invalid Where");
-      if (!Array.isArray(value))
-         throw invalidWhere;
+      if (!Array.isArray(value)) throw invalidWhere;
       let c = [];
-      this._where = value.map(cond => {
+      this._where = value.map((cond) => {
          Logging.debug("Query Condition", cond);
          if (Array.isArray(cond)) {
-            if (cond.length !== 3)
-               throw invalidWhere;
+            if (cond.length !== 3) throw invalidWhere;
             return cond;
          } else {
-            if (cond && typeof cond === "object" && "fieldPath" in cond && "opStr" in cond && "value" in cond) {
+            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(value: any) {
-      let id = nanoid(ALPHABET, 32);
-      let q = new DocumentQuery(this.database, [...this.path, id], this.session);
-      await q.set(value, {});
-      return id;
+   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(this.getKey(collection) + " ");
+      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
-      }
+         lt,
+      };
    }
 
-   public async keys() {
-      let { collection, document } = await this.resolve(this.path);
-      if (document)
-         throw new QueryError("Keys only works on collections!");
-      if (!collection)
-         return []
+   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),
-            keyAsBuffer: false
-         })
+            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) {
+   private _getFieldValue(data: any, path: FieldPath) {
       let parts = path.split(".");
       let d = data;
       while (parts.length > 0) {
          let seg = parts.shift();
 
          d = data[seg];
-         if (d === undefined || d === null)
-            break; // Undefined/Null has no other fields!
+         if (d === undefined || d === null) break; // Undefined/Null has no other fields!
       }
       return d;
    }
 
-   private fitsWhere(data: any): boolean {
-      if (this._where.length > 0) {
+   private _fitsWhere(data: any): boolean {
+      if (this._where && this._where.length > 0) {
          return this._where.every(([fieldPath, opStr, value]) => {
-            let val = this.getFieldValue(data, fieldPath);
+            let val = this._getFieldValue(data, fieldPath);
             switch (opStr) {
                case "<":
                   return val < value;
@@ -412,7 +596,7 @@ export class CollectionQuery extends Query {
                   return val > value;
                case "array-contains":
                   if (Array.isArray(val)) {
-                     return val.some(e => e === value);
+                     return val.some((e) => e === value);
                   }
 
                   return false;
@@ -425,54 +609,47 @@ export class CollectionQuery extends Query {
                default:
                   throw new QueryError("Invalid where operation " + opStr);
             }
-         })
+         });
       }
       return true;
    }
 
-   async get() {
-      let { collection, document } = await this.resolve(this.path);
-      if (document)
-         throw new QueryError("Keys only works on collections!");
-      if (!collection)
-         return [];
+   async get(collection: string) {
+      if (!collection) return [];
 
       return new Promise<DocRes[]>((yes, no) => {
          const stream = this.database.data.iterator({
             ...this.getStreamOptions(collection),
             keyAsBuffer: false,
-            valueAsBuffer: true
-         })
+            valueAsBuffer: true,
+         });
 
          let values: DocRes[] = [];
 
          const onValue = (err: Error, key: string, value: Buffer) => {
             if (err) {
                no(err);
-               stream.end(err => Logging.error(err));
-            }
-            else {
+               stream.end((err) => Logging.error(err));
+            } else {
                if (!key && !value) {
                   // END
-                  Logging.debug("Checked all!")
+                  Logging.debug("Checked all!");
                   yes(values);
                } else {
                   let s = key.split("/", 2);
-                  if (s.length <= 1)
-                     return;
+                  if (s.length <= 1) return;
 
                   const id = s[1];
 
                   let data = decode(value);
-                  if (this.fitsWhere(data)) {
+                  if (this._fitsWhere(data)) {
                      if (this.limit < 0 || values.length < this.limit) {
                         values.push({
                            id,
-                           data
+                           data,
                         });
-                     }
-                     else {
-                        stream.end((err) => err ? no(err) : yes(values))
+                     } else {
+                        stream.end((err) => (err ? no(err) : yes(values)));
                         return;
                      }
                   }
@@ -480,105 +657,62 @@ export class CollectionQuery extends Query {
                   stream.next(onValue);
                }
             }
-         }
-
-         stream.next(onValue);
-      })
-   }
-
-   private subscription: {
-      key: string,
-      onChange: (change: (DocRes & { type: ChangeTypes })[]) => void
          };
 
-   async snapshot(onChange: (change: (DocRes & { type: ChangeTypes })[]) => void) {
-      if (this.subscription)
-         throw new QueryError("This query is already subscribed!");
-      let { collection, document } = await this.resolve(this.path, true);
-
-      let data = await this.get();
-
-      let key = this.getKey(collection, document);
-      this.subscription = {
-         key,
-         onChange
-      }
-      let s = this.database.changes.get(key);
-      if (!s) {
-         s = new Set();
-         this.database.changes.set(key, s);
+         stream.next(onValue);
+      });
    }
 
-      s.add(this.onChange);
-
-      return data;
+   checkChange(change: Change) {
+      return this._fitsWhere(change.data);
    }
 
-   onChange(change: Change) {
-      // if(change.sender === this.sender)
-      //    return
-
-      if (this.fitsWhere(change.data)) {
-         this.subscription.onChange([{
-            id: change.document,
-            data: change.data,
-            type: change.type
-         }])
+   firstSend(collection: string) {
+      return this.get(collection);
    }
-   }
-
-   unsubscribe() {
-      if (!this.subscription)
-         return;
-      let s = this.database.changes.get(this.subscription.key);
-      s.delete(this.onChange);
-      if (s.size <= 0)
-         this.database.changes.delete(this.subscription.key);
-
-      this.subscription = undefined;
-   }
-
 
    public async collections() {
-      if (!this.session.root)
-         throw new QueryError("No Permission!");
+      if (!this.session.root) throw new QueryError("No Permission!");
 
       return new Promise<string[]>((yes, no) => {
          let keys = [];
-         const stream = this.database.data.createKeyStream({ keyAsBuffer: false })
+         const stream = this.database.data.createKeyStream({
+            keyAsBuffer: false,
+         });
          stream.on("data", (key: string) => keys.push(key.split("/")));
          stream.on("end", () => yes(keys));
          stream.on("error", no);
       });
    }
 
-   public async deleteCollection() {
-      if (!this.session.root)
-         throw new QueryError("No Permission!");
-
-      const { collection, document, collectionKey } = await this.resolve(this.path);
-
-      if (document) {
-         throw new QueryError("There can be no document defined on this operation");
-      }
+   public async deleteCollection(
+      collection: string,
+      document: string,
+      _b: LevelUpChain,
+      collectionKey: string
+   ) {
+      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();
+            let documents = await this.keys(collection);
             // Logging.debug("To delete:", documents)
             for (let document of documents) {
-               batch.del(this.getKey(collection, document));
+               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();
       }
    }
 

src/database/rules.ts

@@ -1,111 +0,0 @@
-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,12 +1,10 @@
-import { Query } from "./query";
-
 export default class Session {
-   constructor(private _sessionid: string) { }
+   constructor(private _sessionid: string) {}
    get id() {
       return this._sessionid;
    }
    root: boolean = false;
-   uid: string = undefined;
+   uid: string = null;
 
-   queries = new Map<string, Query>();
+   subscriptions = new Map<string, () => void>();
 }

src/index.ts

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

src/rules/compile.ts

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

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

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

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

@@ -0,0 +1,98 @@
+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/web/helper/form.ts

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

src/web/v1/admin.ts

@@ -2,7 +2,11 @@ import * as Router from "koa-router";
 import Settings from "../../settings";
 import getForm from "../helper/form";
 import getTable from "../helper/table";
-import { BadRequestError, NoPermissionError } from "../helper/errors";
+import {
+   BadRequestError,
+   NoPermissionError,
+   NotFoundError,
+} from "../helper/errors";
 import { DatabaseManager } from "../../database/database";
 import { MP } from "../../database/query";
 import config from "../../config";
@@ -13,76 +17,82 @@ 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("/", async (ctx) => {
    //TODO: Main Interface
    ctx.body = getView("admin");
 });
 
-AdminRoute.get("/settings", async ctx => {
+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);
-   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,
-         limit: 1000
+         limit: 1000,
       });
       let res = [["key", "value"]];
-      stream.on("data", ({ key, value }: { key: string, value: Buffer }) => {
-         res.push([key, key.split("/").length > 2 ? value.toString() : JSON.stringify(MP.decode(value))]);
-      })
+      stream.on("data", ({ key, value }: { key: string; value: Buffer }) => {
+         res.push([
+            key,
+            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(([name, config]) => ({ name, ...(JSON.parse(JSON.stringify(config))) }));
+      res = Array.from(DatabaseManager.databases.entries()).map(
+         ([name, config]) => ({
+            name,
+            ...JSON.parse(JSON.stringify(config)),
+         })
+      );
    } else {
       res = Array.from(DatabaseManager.databases.keys());
    }
@@ -92,67 +102,55 @@ AdminRoute
    } 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)
-         await db.setRules(rules);
+   if (rules) await db.setRules(rules);
 
-      if (accesskey)
-         await db.setAccessKey(accesskey);
-
-
-      if (rootkey)
-         await db.setRootKey(rootkey);
+   if (accesskey) await db.setAccessKey(accesskey);
 
+   if (rootkey) await db.setRootKey(rootkey);
 
    ctx.body = "Success";
-   })
+});
 
-AdminRoute.get("/collections", async ctx => {
+AdminRoute.get("/collections", async (ctx) => {
    const { database } = ctx.query;
    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.collections.createKeyStream({
          keyAsBuffer: false,
-         limit: 1000
+         limit: 1000,
       });
       let res = [];
       stream.on("data", (key: string) => {
          res.push(key);
-      })
+      });
 
       stream.on("error", no);
-      stream.on("end", () => yes(res))
-   })
+      stream.on("end", () => yes(res));
+   });
 
    if (ctx.query.view) {
       return getTable("Databases", res, ctx);
    } else {
       ctx.body = res;
    }
-})
+});
 
-AdminRoute.get("/collections/cleanup", async ctx => {
+AdminRoute.get("/collections/cleanup", async (ctx) => {
    const { database } = ctx.query;
    let db = DatabaseManager.getDatabase(database);
-   if (!db)
-      throw new BadRequestError("Database not found");
+   if (!db) throw new BadRequestError("Database not found");
 
    let deleted = await db.runCleanup();
    if (ctx.query.view) {
@@ -160,14 +158,55 @@ AdminRoute.get("/collections/cleanup", async ctx => {
    } else {
       ctx.body = deleted;
    }
-})
+});
 
-AdminRoute.get("/database/new", getForm("/v1/admin/database", "New/Change Database", {
-   name: { label: "Name", type: "text", },
+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: { label: "Rules", type: "textarea", value: `{\n   ".write": true, \n   ".read": true \n}` },
-   publickey: { label: "Public Key", type: "textarea" }
-}))
+      rules: {
+         label: "Rules",
+         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);
+   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,17 +1,21 @@
 import * as Router from "koa-router";
 import AdminRoute from "./admin";
 import { DatabaseManager } from "../../database/database";
-import { NotFoundError, NoPermissionError, BadRequestError } from "../helper/errors";
+import {
+   NotFoundError,
+   NoPermissionError,
+   BadRequestError,
+} from "../helper/errors";
 import Logging from "@hibas123/nodelogging";
 import Session from "../../database/session";
-import nanoid = require("nanoid");
+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 => {
+V1.post("/db/:database/query", async (ctx) => {
    const { database } = ctx.params;
    const { accesskey, authkey, rootkey } = ctx.query;
 
@@ -28,15 +32,15 @@ V1.post("/db/:database/query", async ctx => {
 
    if (db.accesskey) {
       if (!accesskey || accesskey !== db.accesskey) {
-         throw new NoPermissionError("");
+         throw new NoPermissionError("Invalid Access Key");
       }
    }
 
    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) {
          throw new BadRequestError("Invalid JWT");
-         return;
       } else {
          session.uid = res.uid;
       }
@@ -49,11 +53,11 @@ V1.post("/db/:database/query", async ctx => {
       }
    }
 
-   ctx.body = await db.run(query, session).catch(err => {
+   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

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

views/admin.html

@@ -1,13 +1,18 @@
 <!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">
+   <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/out/base.css">
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
+      <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>
 
@@ -16,7 +21,7 @@
             visibility: hidden;
             background-color: lightgreen;
             border: 1px solid lime;
-         border-radius: .5rem;
+            border-radius: 0.5rem;
             padding: 1rem;
             font-size: 1.5rem;
             margin-bottom: 1rem;
@@ -28,38 +33,46 @@
             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: 100%;
+            height: 100vh;
             border: 0;
          }
       </style>
-</head>
+   </head>
 
-<body>
+   <body>
       <div class="grid">
-      <div style="border-right: 1px solid darkgrey; padding: 1rem;">
-         <h2>Navigation: </h2>
+         <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
+               id="dbs"
+               class="list list-clickable"
+               style="margin: 1rem"
+            ></div>
          </div>
-      <div style="position:relative;">
+         <div style="position: relative">
             <iframe id="content"></iframe>
          </div>
       </div>
 
-   <template>
-
-   </template>
+      <template> </template>
 
       <script>
          const key = new URL(window.location.href).searchParams.get("key");
@@ -73,8 +86,7 @@
                url.searchParams.set(key, params[key]);
 
             url.searchParams.set("key", key);
-         if (view)
-            url.searchParams.set("view", "true");
+            if (view) url.searchParams.set("view", "true");
 
             return url.href;
          }
@@ -83,30 +95,31 @@
             content.src = getUrl(name, params);
          }
 
-      loadView("settings")
+         loadView("settings");
 
          const dbsul = document.getElementById("dbs");
          function reloadDBs() {
             fetch(getUrl("database", {}, false))
-            .then(res => res.json())
-            .then(databases => databases.map(database => `
+               .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)
-
-
+                  )
+               )
+               .then((d) => d.join("\n"))
+               .then((d) => (dbsul.innerHTML = d))
+               .catch(console.error);
          }
 
          reloadDBs();
          setInterval(reloadDBs, 5000);
       </script>
-</body>
-
+   </body>
 </html>

views/forms.hbs

@@ -6,8 +6,9 @@
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>{{title}}</title>
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
+   <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">
+   <link rel="stylesheet" href="https://unpkg.com/codemirror@5.58.2/lib/codemirror.css">
 
    <style>
       #message {
@@ -32,19 +33,23 @@
             <div class="input-group">
                <label>{{label}}</label>
                {{#ifCond type  "===" "text"}}
-               <input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
+               <input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
                {{/ifCond}}
 
                {{#ifCond type "===" "number"}}
-               <input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
+               <input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
                {{/ifCond}}
 
                {{#ifCond type "===" "boolean"}}
-               <input type="checkbox" name="{{name}}" checked="{{value}}" />
+               <input type="checkbox" name="{{name}}" checked="{{value}}" {{disabled}} />
                {{/ifCond}}
 
                {{#ifCond type "===" "textarea"}}
-               <textarea class="inp" name="{{name}}" rows="20">{{value}}</textarea>
+               <textarea class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
+               {{/ifCond}}
+
+               {{#ifCond type "===" "codemirror"}}
+               <textarea codemirror class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
                {{/ifCond}}
             </div>
             {{/each}}
@@ -81,6 +86,19 @@
          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/out/base.css">
-   <link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
+   <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">
 
    <style>
       table {