Compare commits
No commits in common. "master" and "v2.0.0-beta.1" have entirely different histories.
master
...
v2.0.0-bet
24
.drone.yml
24
.drone.yml
@ -1,24 +0,0 @@
|
||||
kind: pipeline
|
||||
type: docker
|
||||
name: default
|
||||
|
||||
steps:
|
||||
- name: Build with node
|
||||
image: node:14
|
||||
commands:
|
||||
- npm config set registry https://npm.hibas123.de
|
||||
- npm install
|
||||
- npm run build
|
||||
- name: Publish to docker
|
||||
image: plugins/docker
|
||||
settings:
|
||||
username:
|
||||
from_secret: docker_username
|
||||
password:
|
||||
from_secret: docker_password
|
||||
auto_tag: true
|
||||
repo: docker.hibas123.de/realtimedb
|
||||
registry: docker.hibas123.de
|
||||
debug: false
|
||||
when:
|
||||
branch: [master]
|
||||
@ -1,8 +1,3 @@
|
||||
root=true
|
||||
[*]
|
||||
charset = utf-8
|
||||
indent_size = 3
|
||||
indent_style = space
|
||||
insert_final_newline = true
|
||||
[*.yml]
|
||||
indent_size = 2
|
||||
|
||||
20
.vscode/launch.json
vendored
20
.vscode/launch.json
vendored
@ -1,20 +0,0 @@
|
||||
{
|
||||
// Use IntelliSense to learn about possible attributes.
|
||||
// Hover to view descriptions of existing attributes.
|
||||
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"type": "pwa-node",
|
||||
"request": "launch",
|
||||
"name": "Launch Program",
|
||||
"skipFiles": [
|
||||
"<node_internals>/**"
|
||||
],
|
||||
"program": "${workspaceFolder}\\lib\\index.js",
|
||||
"outFiles": [
|
||||
"${workspaceFolder}/**/*.js"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,4 +1,4 @@
|
||||
FROM node:14
|
||||
FROM node:12
|
||||
|
||||
LABEL maintainer="Fabian Stamm <dev@fabianstamm.de>"
|
||||
|
||||
@ -8,8 +8,6 @@ LABEL maintainer="Fabian Stamm <dev@fabianstamm.de>"
|
||||
RUN mkdir -p /usr/src/app
|
||||
WORKDIR /usr/src/app
|
||||
|
||||
RUN npm config set registry https://npm.hibas123.de/
|
||||
|
||||
ENV NODE_ENV=production
|
||||
|
||||
COPY ["package.json", "package-lock.json", "/usr/src/app/"]
|
||||
|
||||
9068
package-lock.json
generated
9068
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
89
package.json
89
package.json
@ -1,45 +1,48 @@
|
||||
{
|
||||
"name": "@hibas123/realtimedb",
|
||||
"version": "2.0.0-beta.22",
|
||||
"description": "",
|
||||
"main": "lib/index.js",
|
||||
"private": true,
|
||||
"scripts": {
|
||||
"start": "node lib/index.js",
|
||||
"build": "tsc",
|
||||
"watch": "nodemon -e ts --exec ts-node src/index.ts",
|
||||
"build-docker": "npm run build && docker build -t realtimedb .",
|
||||
"prepublishOnly": "tsc"
|
||||
},
|
||||
"author": "Fabian Stamm <dev@fabianstamm.de>",
|
||||
"license": "ISC",
|
||||
"devDependencies": {
|
||||
"@types/jsonwebtoken": "^8.5.1",
|
||||
"@types/koa": "^2.13.3",
|
||||
"@types/koa-router": "^7.4.2",
|
||||
"@types/leveldown": "^4.0.2",
|
||||
"@types/levelup": "^4.3.1",
|
||||
"@types/msgpack5": "^3.4.1",
|
||||
"@types/node": "^14.17.2",
|
||||
"@types/ws": "^7.4.4",
|
||||
"nodemon": "^2.0.7",
|
||||
"ts-node": "^10.0.0",
|
||||
"typescript": "^4.3.2"
|
||||
},
|
||||
"dependencies": {
|
||||
"@hibas123/logging": "^3.1.2",
|
||||
"@hibas123/nodelogging": "^3.1.3",
|
||||
"@hibas123/utils": "^2.2.18",
|
||||
"dotenv": "^10.0.0",
|
||||
"handlebars": "^4.7.7",
|
||||
"jsonwebtoken": "^8.5.1",
|
||||
"koa": "^2.13.1",
|
||||
"koa-body": "^4.2.0",
|
||||
"koa-router": "^10.0.0",
|
||||
"leveldown": "^6.0.0",
|
||||
"levelup": "^5.0.0",
|
||||
"msgpack5": "^5.3.2",
|
||||
"nanoid": "^3.1.23",
|
||||
"ws": "^7.4.6"
|
||||
}
|
||||
"name": "@hibas123/realtimedb",
|
||||
"version": "2.0.0-beta.1",
|
||||
"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-*\"",
|
||||
"build-docker": "npm run build && docker build -t realtimedb .",
|
||||
"prepublishOnly": "tsc"
|
||||
},
|
||||
"author": "Fabian Stamm <dev@fabianstamm.de>",
|
||||
"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/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"
|
||||
},
|
||||
"dependencies": {
|
||||
"@hibas123/logging": "^2.1.1",
|
||||
"@hibas123/nodelogging": "^2.1.1",
|
||||
"@hibas123/utils": "^2.1.1",
|
||||
"dotenv": "^8.2.0",
|
||||
"handlebars": "^4.5.1",
|
||||
"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",
|
||||
"what-the-pack": "^2.0.3",
|
||||
"ws": "^7.2.0"
|
||||
}
|
||||
}
|
||||
1771
pnpm-lock.yaml
generated
1771
pnpm-lock.yaml
generated
File diff suppressed because it is too large
Load Diff
@ -1,24 +1,20 @@
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import * as dotenv from "dotenv";
|
||||
import { LoggingTypes } from "@hibas123/logging";
|
||||
dotenv.config();
|
||||
dotenv.config()
|
||||
|
||||
|
||||
interface IConfig {
|
||||
port: number;
|
||||
admin: string;
|
||||
access_log: boolean;
|
||||
dev: boolean;
|
||||
dev: boolean
|
||||
}
|
||||
|
||||
const config: IConfig = {
|
||||
port: Number(process.env.PORT),
|
||||
access_log: (process.env.ACCESS_LOG || "").toLowerCase() === "true",
|
||||
admin: process.env.ADMIN_KEY,
|
||||
dev: (process.env.DEV || "").toLowerCase() === "true",
|
||||
};
|
||||
|
||||
if (config.dev) {
|
||||
Logging.logLevel = LoggingTypes.Log;
|
||||
dev: (process.env.DEV || "").toLowerCase() === "true"
|
||||
}
|
||||
|
||||
export default config;
|
||||
224
src/connection.ts
Normal file
224
src/connection.ts
Normal file
@ -0,0 +1,224 @@
|
||||
import * as WebSocket from "ws";
|
||||
import { Server, IncomingMessage } from "http";
|
||||
import { DatabaseManager } from "./database/database";
|
||||
import Logging from "@hibas123/logging";
|
||||
import Query from "./database/query";
|
||||
import Session from "./database/session";
|
||||
import nanoid = require("nanoid");
|
||||
|
||||
import * as JWT from "jsonwebtoken";
|
||||
|
||||
async function verifyJWT(token: string, publicKey: string) {
|
||||
return new Promise<any | undefined>((yes) => {
|
||||
JWT.verify(token, publicKey, (err, decoded) => {
|
||||
if (err)
|
||||
yes(undefined);
|
||||
else
|
||||
yes(decoded);
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
const StoreSym = Symbol("store");
|
||||
function StoreQuery(result?: any) {
|
||||
return {
|
||||
[StoreSym]: true,
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
function DeleteQuery(result?: any) {
|
||||
return {
|
||||
[StoreSym]: false,
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
import { URLSearchParams } from "url";
|
||||
|
||||
type QueryTypes = "keys" | "get" | "set" | "update" | "delete" | "push" | "subscribe" | "unsubscribe";
|
||||
|
||||
export class ConnectionManager {
|
||||
static server: WebSocket.Server;
|
||||
|
||||
static bind(server: Server) {
|
||||
this.server = new WebSocket.Server({ server });
|
||||
this.server.on("connection", this.onConnection.bind(this));
|
||||
}
|
||||
|
||||
private static async onConnection(socket: WebSocket, req: IncomingMessage) {
|
||||
Logging.log("New Connection:");
|
||||
const sendError = (error: string) => socket.send(JSON.stringify({ ns: "error_msg", data: error }));
|
||||
|
||||
|
||||
const session = new Session(nanoid());
|
||||
|
||||
let query = new URLSearchParams(req.url.split("?").pop());
|
||||
|
||||
const database = query.get("database");
|
||||
const db = DatabaseManager.getDatabase(database);
|
||||
if (!db) {
|
||||
sendError("Invalid Database!");
|
||||
socket.close();
|
||||
return;
|
||||
}
|
||||
|
||||
const accesskey = query.get("accesskey");
|
||||
if (db.accesskey) {
|
||||
if (!accesskey || accesskey !== db.accesskey) {
|
||||
sendError("Unauthorized!");
|
||||
socket.close();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const authkey = query.get("authkey");
|
||||
if (authkey && db.publickey) {
|
||||
let res = await verifyJWT(authkey, db.publickey);
|
||||
if (!res || !res.uid) {
|
||||
sendError("Invalid JWT");
|
||||
socket.close();
|
||||
return;
|
||||
} else {
|
||||
session.uid = res.uid;
|
||||
}
|
||||
}
|
||||
|
||||
const rootkey = query.get("rootkey");
|
||||
if (rootkey && db.rootkey) {
|
||||
if (rootkey === db.rootkey) {
|
||||
session.root = true;
|
||||
Logging.warning(`Somebody logged into ${database} via rootkey`);
|
||||
}
|
||||
}
|
||||
|
||||
const stored = new Map<string, Query>();
|
||||
const answer = (id: string, data: any, error: boolean = false) => {
|
||||
socket.send(JSON.stringify({ ns: "message", data: { id, error, data } }));
|
||||
}
|
||||
|
||||
const handler = new Map<string, ((data: any) => void)>();
|
||||
type QueryData = { id: string, type: QueryTypes, path: string[], data: any, options: any };
|
||||
|
||||
const queryHandler = new Map<string, (query: Query, permissions: { read: boolean, write: boolean }, data?: any) => Promise<any>>();
|
||||
|
||||
const noperm = new Error("No permisison!");
|
||||
|
||||
if (session.root) {
|
||||
queryHandler.set("collections", (query, perm, data) => {
|
||||
return query.getCollections();
|
||||
})
|
||||
|
||||
queryHandler.set("delete-collection", (query, perm, data) => {
|
||||
return query.deleteCollection();
|
||||
})
|
||||
}
|
||||
|
||||
queryHandler.set("keys", (query, perm, data) => {
|
||||
if (!perm.read)
|
||||
throw noperm;
|
||||
return query.keys();
|
||||
})
|
||||
|
||||
queryHandler.set("get", (query, perm, data) => {
|
||||
if (!perm.read)
|
||||
throw noperm;
|
||||
return query.get();
|
||||
})
|
||||
|
||||
queryHandler.set("set", (query, perm, data) => {
|
||||
if (!perm.write)
|
||||
throw noperm;
|
||||
return query.set(data, {});
|
||||
})
|
||||
|
||||
queryHandler.set("update", (query, perm, data) => {
|
||||
if (!perm.write)
|
||||
throw noperm;
|
||||
return query.update(data);
|
||||
})
|
||||
|
||||
queryHandler.set("push", (query, perm, data) => {
|
||||
if (!perm.write)
|
||||
throw noperm;
|
||||
return query.push(data);
|
||||
})
|
||||
|
||||
queryHandler.set("delete", (query, perm, data) => {
|
||||
if (!perm.write)
|
||||
throw noperm;
|
||||
return query.delete();
|
||||
})
|
||||
|
||||
queryHandler.set("subscribe", async (query, perm, data) => {
|
||||
if (!perm.read)
|
||||
throw noperm;
|
||||
|
||||
let subscriptionID = nanoid();
|
||||
|
||||
query.subscribe((data) => {
|
||||
socket.send(JSON.stringify({ ns: "event", data: { id: subscriptionID, data } }));
|
||||
}, data.types, data.options);
|
||||
|
||||
return StoreQuery(subscriptionID);
|
||||
})
|
||||
|
||||
queryHandler.set("unsubscribe", async (query, perm, data) => {
|
||||
query.unsubscribe();
|
||||
return DeleteQuery(true);
|
||||
})
|
||||
|
||||
handler.set("query", async ({ id, type, path, data }: QueryData) => {
|
||||
//TODO: Handle case with no id, type, path
|
||||
Logging.debug(`Request with id '${id}' from type '${type}' and path '${path}' with data`, data)
|
||||
|
||||
try {
|
||||
if (!db)
|
||||
throw new Error("Database not found!");
|
||||
else {
|
||||
let handler = queryHandler.get(type);
|
||||
if (!handler) {
|
||||
throw new Error("Invalid Request!");
|
||||
} else {
|
||||
const query = stored.get(id) || db.getQuery(path || [], session.sessionid);
|
||||
const perms = db.rules.hasPermission(path, session);
|
||||
|
||||
let res = await handler(query, perms, data);
|
||||
if (res && typeof res === "object" && res[StoreSym] !== undefined) {
|
||||
if (res[StoreSym])
|
||||
stored.set(id, query);
|
||||
else
|
||||
stored.delete(id);
|
||||
|
||||
res = res.result;
|
||||
}
|
||||
answer(id, res);
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
// Logging.error(err);
|
||||
Logging.debug("Sending error:", err);
|
||||
answer(id, err.message, true);
|
||||
}
|
||||
})
|
||||
|
||||
socket.on("message", async (rawData: string) => {
|
||||
try {
|
||||
let message: { ns: string, data: any } = JSON.parse(rawData);
|
||||
let h = handler.get(message.ns);
|
||||
if (h) {
|
||||
h(message.data);
|
||||
}
|
||||
} catch (err) {
|
||||
Logging.errorMessage("Unknown Error:");
|
||||
Logging.error(err);
|
||||
}
|
||||
})
|
||||
|
||||
socket.on("disconnect", () => {
|
||||
stored.forEach(query => query.unsubscribe());
|
||||
stored.clear();
|
||||
socket.removeAllListeners();
|
||||
})
|
||||
}
|
||||
}
|
||||
@ -1,31 +1,8 @@
|
||||
import { Rules } from "./rules";
|
||||
import Settings from "../settings";
|
||||
import getLevelDB, { deleteLevelDB, resNull } from "../storage";
|
||||
import getLevelDB, { LevelDB, deleteLevelDB } from "../storage";
|
||||
import DocumentLock from "./lock";
|
||||
import {
|
||||
DocumentQuery,
|
||||
CollectionQuery,
|
||||
Query,
|
||||
QueryError,
|
||||
ITypedQuery,
|
||||
IQuery,
|
||||
} from "./query";
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import Session from "./session";
|
||||
import nanoid = require("nanoid");
|
||||
import { Observable } from "@hibas123/utils";
|
||||
import { RuleRunner } from "../rules/compile";
|
||||
import compileRule from "../rules";
|
||||
import { RuleError } from "../rules/error";
|
||||
|
||||
const ALPHABET =
|
||||
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
const longNanoId = nanoid.customAlphabet(ALPHABET, 32);
|
||||
const shortNanoId = nanoid.customAlphabet(ALPHABET, 16);
|
||||
|
||||
// interface ITransaction {
|
||||
// queries: ITypedQuery<IWriteQueries>[];
|
||||
// }
|
||||
import Query from "./query";
|
||||
|
||||
export class DatabaseManager {
|
||||
static databases = new Map<string, Database>();
|
||||
@ -33,20 +10,15 @@ export class DatabaseManager {
|
||||
static async init() {
|
||||
let databases = await Settings.getDatabases();
|
||||
|
||||
databases.forEach((dbconfig) => {
|
||||
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);
|
||||
@ -59,11 +31,11 @@ export class DatabaseManager {
|
||||
}
|
||||
|
||||
static async deleteDatabase(name: string) {
|
||||
let db = this.databases.get(name);
|
||||
let db = this.databases.get(name)
|
||||
if (db) {
|
||||
await Settings.deleteDatabase(name);
|
||||
await db.stop();
|
||||
await deleteLevelDB(db.name);
|
||||
await deleteLevelDB(db.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -73,96 +45,47 @@ export type ChangeTypes = "added" | "modified" | "deleted";
|
||||
export type Change = {
|
||||
data: any;
|
||||
document: string;
|
||||
collection: string;
|
||||
type: ChangeTypes;
|
||||
sender: string;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
export class Database {
|
||||
public static getKey(collectionid: string, documentid?: string) {
|
||||
return `${collectionid || ""}/${documentid || ""}`;
|
||||
}
|
||||
|
||||
#level = getLevelDB(this.name);
|
||||
private level = getLevelDB(this.name);
|
||||
|
||||
get data() {
|
||||
return this.#level.data;
|
||||
return this.level.data;
|
||||
}
|
||||
|
||||
get collections() {
|
||||
return this.#level.collection;
|
||||
return this.level.collection;
|
||||
}
|
||||
|
||||
#rules: RuleRunner;
|
||||
#rawRules?: string;
|
||||
|
||||
get rawRules() {
|
||||
return this.#rawRules;
|
||||
}
|
||||
public rules: Rules;
|
||||
public locks = new DocumentLock()
|
||||
public collectionLocks = new DocumentLock()
|
||||
|
||||
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";
|
||||
}>();
|
||||
public changes = new Map<string, Set<(change: Change) => void>>();
|
||||
|
||||
toJSON() {
|
||||
return {
|
||||
name: this.name,
|
||||
accesskey: this.accesskey,
|
||||
publickey: this.publickey,
|
||||
rules: this.#rules,
|
||||
connections: this.connections,
|
||||
};
|
||||
}
|
||||
|
||||
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;
|
||||
rules: this.rules
|
||||
}
|
||||
this.#rules = runner;
|
||||
this.#rawRules = rawRules;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
async setRules(rawRules: string): Promise<RuleError | undefined> {
|
||||
const { runner, error } = compileRule(rawRules);
|
||||
if (error) return error;
|
||||
constructor(public name: string, public accesskey?: string, rawRules?: string, public publickey?: string, public rootkey?: string) {
|
||||
if (rawRules)
|
||||
this.rules = new Rules(rawRules);
|
||||
}
|
||||
|
||||
async setRules(rawRules: string) {
|
||||
let rules = new Rules(rawRules);
|
||||
await Settings.setDatabaseRules(this.name, rawRules);
|
||||
this.#rules = runner;
|
||||
this.#rawRules = rawRules;
|
||||
this.rules = rules;
|
||||
}
|
||||
|
||||
async setAccessKey(key: string) {
|
||||
@ -180,312 +103,12 @@ export class Database {
|
||||
this.publickey = key;
|
||||
}
|
||||
|
||||
public async resolve(
|
||||
path: string[],
|
||||
create = false
|
||||
): Promise<{ collection: string; document: string; collectionKey: string }> {
|
||||
path = [...path]; // Create modifiable copy
|
||||
let collectionID: string = undefined;
|
||||
let documentKey = path.length % 2 === 0 ? path.pop() : undefined;
|
||||
let key = path.join("/");
|
||||
|
||||
const lock = await this.collectionLocks.lock(key);
|
||||
|
||||
try {
|
||||
collectionID = await this.collections
|
||||
.get(key)
|
||||
.then((r) => r.toString())
|
||||
.catch(resNull);
|
||||
if (!collectionID && create) {
|
||||
collectionID = longNanoId();
|
||||
await this.collections.put(key, collectionID);
|
||||
setImmediate(() => {
|
||||
this.collectionChangeListener.send({
|
||||
id: collectionID,
|
||||
key,
|
||||
type: "create",
|
||||
});
|
||||
});
|
||||
}
|
||||
} finally {
|
||||
lock();
|
||||
}
|
||||
|
||||
return {
|
||||
collection: collectionID,
|
||||
document: documentKey,
|
||||
collectionKey: key,
|
||||
};
|
||||
}
|
||||
|
||||
private sendChanges(changes: Change[]) {
|
||||
let col = new Map<string, Map<string, Change[]>>();
|
||||
changes.forEach((change) => {
|
||||
let e = col.get(change.collection);
|
||||
if (!e) {
|
||||
e = new Map();
|
||||
col.set(change.collection, e);
|
||||
}
|
||||
|
||||
let d = e.get(change.document);
|
||||
if (!d) {
|
||||
d = [];
|
||||
e.set(change.document, d);
|
||||
}
|
||||
|
||||
d.push(change);
|
||||
});
|
||||
|
||||
setImmediate(() => {
|
||||
for (let [collection, documents] of col.entries()) {
|
||||
let collectionChanges = [];
|
||||
for (let [document, documentChanges] of documents.entries()) {
|
||||
let s = this.changeListener.get(
|
||||
Database.getKey(collection, document)
|
||||
);
|
||||
if (s) s.forEach((e) => setImmediate(() => e(documentChanges)));
|
||||
|
||||
collectionChanges.push(...documentChanges);
|
||||
}
|
||||
let s = this.changeListener.get(Database.getKey(collection));
|
||||
if (s) s.forEach((e) => setImmediate(() => e(collectionChanges)));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private validate(query: ITypedQuery<any>) {
|
||||
const inv = new QueryError("Malformed query!");
|
||||
if (!query || typeof query !== "object") throw inv;
|
||||
|
||||
if (!query.type) throw inv;
|
||||
|
||||
if (!query.path) throw inv;
|
||||
}
|
||||
|
||||
async run(queries: IQuery[], session: Session) {
|
||||
let resolve: {
|
||||
path: string[];
|
||||
create: boolean;
|
||||
resolved?: [string, string, string];
|
||||
}[] = [];
|
||||
|
||||
const addToResolve = (path: string[], create?: boolean) => {
|
||||
let entry = resolve.find((e) => {
|
||||
//TODO: Find may be slow...
|
||||
if (e.path.length !== path.length) return false;
|
||||
for (let i = 0; i < e.path.length; i++) {
|
||||
if (e.path[i] !== path[i]) return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
if (!entry) {
|
||||
entry = {
|
||||
path,
|
||||
create,
|
||||
};
|
||||
resolve.push(entry);
|
||||
}
|
||||
|
||||
entry.create = entry.create || create;
|
||||
|
||||
return entry;
|
||||
};
|
||||
|
||||
const isBatch = queries.length > 1;
|
||||
let parsed = queries.map((rawQuery) => {
|
||||
Logging.debug("Running query:", rawQuery.type);
|
||||
this.validate(rawQuery);
|
||||
const isCollection = rawQuery.path.length % 2 === 1;
|
||||
|
||||
let query = isCollection
|
||||
? new CollectionQuery(this, session, rawQuery)
|
||||
: new DocumentQuery(this, session, rawQuery);
|
||||
|
||||
if (isBatch && !query.batchCompatible)
|
||||
throw new Error("There are queries that are not batch compatible!");
|
||||
|
||||
let path = addToResolve(rawQuery.path, query.createCollection);
|
||||
if (query.additionalLock) addToResolve(query.additionalLock);
|
||||
|
||||
return {
|
||||
path,
|
||||
query,
|
||||
};
|
||||
});
|
||||
|
||||
resolve = resolve.sort((a, b) => a.path.length - b.path.length);
|
||||
|
||||
let locks: (() => void)[] = [];
|
||||
for (let e of resolve) {
|
||||
let { collection, document, collectionKey } = await this.resolve(
|
||||
e.path,
|
||||
e.create
|
||||
);
|
||||
e.resolved = [collection, document, collectionKey];
|
||||
|
||||
locks.push(await this.locks.lock(collection, document));
|
||||
}
|
||||
|
||||
let result = [];
|
||||
try {
|
||||
let batch = this.data.batch();
|
||||
let changes: Change[] = [];
|
||||
for (let e of parsed) {
|
||||
result.push(
|
||||
await e.query.run(
|
||||
e.path.resolved[0],
|
||||
e.path.resolved[1],
|
||||
batch,
|
||||
e.path.resolved[2]
|
||||
)
|
||||
);
|
||||
changes.push(...e.query.changes);
|
||||
}
|
||||
if (batch.length > 0) await batch.write();
|
||||
|
||||
this.sendChanges(changes);
|
||||
} finally {
|
||||
locks.forEach((lock) => lock());
|
||||
}
|
||||
|
||||
if (isBatch) return result;
|
||||
else return result[0];
|
||||
}
|
||||
|
||||
async snapshot(
|
||||
rawQuery: ITypedQuery<"snapshot">,
|
||||
session: Session,
|
||||
onchange: (change: any) => void
|
||||
) {
|
||||
Logging.debug("Snaphot request:", rawQuery.path);
|
||||
this.validate(rawQuery);
|
||||
|
||||
if (rawQuery.type !== "snapshot") throw new Error("Invalid query type!");
|
||||
|
||||
const isCollection = rawQuery.path.length % 2 === 1;
|
||||
let query = isCollection
|
||||
? new CollectionQuery(this, session, rawQuery, true)
|
||||
: new DocumentQuery(this, session, rawQuery, true);
|
||||
|
||||
const { unsubscribe, value } = await query.snapshot(onchange);
|
||||
|
||||
const id = shortNanoId();
|
||||
session.subscriptions.set(id, unsubscribe);
|
||||
return {
|
||||
id,
|
||||
snaphot: value,
|
||||
};
|
||||
}
|
||||
|
||||
async unsubscribe(id: string, session: Session) {
|
||||
let query = session.subscriptions.get(id);
|
||||
if (query) {
|
||||
query();
|
||||
session.subscriptions.delete(id);
|
||||
}
|
||||
getQuery(path: string[], sender: string) {
|
||||
return new Query(this, path, sender);
|
||||
}
|
||||
|
||||
async stop() {
|
||||
await this.data.close();
|
||||
}
|
||||
|
||||
public async runCleanup() {
|
||||
const should = await new Promise<Set<string>>((yes, no) => {
|
||||
const stream = this.collections.iterator({
|
||||
keyAsBuffer: false,
|
||||
valueAsBuffer: false,
|
||||
});
|
||||
|
||||
const collections = new Set<string>();
|
||||
const onValue = (err: Error, key: string, value: string) => {
|
||||
if (err) {
|
||||
Logging.error(err);
|
||||
stream.end((err) => Logging.error(err));
|
||||
no(err);
|
||||
}
|
||||
|
||||
if (!key && !value) {
|
||||
yes(collections);
|
||||
} else {
|
||||
collections.add(value);
|
||||
stream.next(onValue);
|
||||
}
|
||||
};
|
||||
|
||||
stream.next(onValue);
|
||||
});
|
||||
|
||||
const existing = await new Promise<Set<string>>((yes, no) => {
|
||||
const stream = this.data.iterator({
|
||||
keyAsBuffer: false,
|
||||
values: false,
|
||||
});
|
||||
|
||||
const collections = new Set<string>();
|
||||
const onValue = (err: Error, key: string, value: Buffer) => {
|
||||
if (err) {
|
||||
Logging.error(err);
|
||||
stream.end((err) => Logging.error(err));
|
||||
no(err);
|
||||
}
|
||||
|
||||
if (!key && !value) {
|
||||
yes(collections);
|
||||
} else {
|
||||
let coll = key.split("/")[0];
|
||||
collections.add(coll);
|
||||
stream.next(onValue);
|
||||
}
|
||||
};
|
||||
|
||||
stream.next(onValue);
|
||||
});
|
||||
|
||||
const toDelete = new Set<string>();
|
||||
existing.forEach((collection) => {
|
||||
if (!should.has(collection)) toDelete.add(collection);
|
||||
});
|
||||
|
||||
for (let collection of toDelete) {
|
||||
const batch = this.data.batch();
|
||||
|
||||
let gt = Buffer.from(collection + "/ ");
|
||||
gt[gt.length - 1] = 0;
|
||||
|
||||
let lt = Buffer.alloc(gt.length);
|
||||
lt.set(gt);
|
||||
lt[gt.length - 1] = 0xff;
|
||||
|
||||
await new Promise<void>((yes, no) => {
|
||||
const stream = this.data.iterator({
|
||||
keyAsBuffer: false,
|
||||
values: false,
|
||||
gt,
|
||||
lt,
|
||||
});
|
||||
|
||||
const onValue = (err: Error, key: string, value: Buffer) => {
|
||||
if (err) {
|
||||
Logging.error(err);
|
||||
stream.end((err) => Logging.error(err));
|
||||
no(err);
|
||||
}
|
||||
|
||||
if (!key && !value) {
|
||||
yes();
|
||||
} else {
|
||||
batch.del(key);
|
||||
stream.next(onValue);
|
||||
}
|
||||
};
|
||||
|
||||
stream.next(onValue);
|
||||
});
|
||||
|
||||
await batch.write();
|
||||
}
|
||||
|
||||
return Array.from(toDelete.values());
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,26 +4,24 @@ export default class DocumentLock {
|
||||
private locks = new Map<string, (() => void)[]>();
|
||||
|
||||
getLocks() {
|
||||
return Array.from(this.locks.keys());
|
||||
return Array.from(this.locks.keys())
|
||||
}
|
||||
|
||||
async lock(collection: string = "", document: string = "") {
|
||||
//TODO: Check collection locks
|
||||
let key = collection + "/" + document;
|
||||
let l = this.locks.get(key);
|
||||
if (l)
|
||||
await new Promise<void>((resolve) => {
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,730 +1,293 @@
|
||||
import { Database, Change, ChangeTypes } from "./database";
|
||||
import { resNull } from "../storage";
|
||||
import * as nanoid from "nanoid";
|
||||
import nanoid = require("nanoid/generate");
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import * as MSGPack from "msgpack5";
|
||||
import Session from "./session";
|
||||
import { LevelUpChain } from "levelup";
|
||||
import { Operations } from "../rules/parser";
|
||||
import * as MSGPack from "what-the-pack";
|
||||
|
||||
export type IWriteQueries = "set" | "update" | "delete" | "add";
|
||||
export type ICollectionQueries =
|
||||
| "get"
|
||||
| "add"
|
||||
| "keys"
|
||||
| "delete-collection"
|
||||
| "list";
|
||||
export type IDocumentQueries = "get" | "set" | "update" | "delete";
|
||||
export const MP = MSGPack.initialize(2 ** 20);
|
||||
|
||||
export interface ITypedQuery<T> {
|
||||
path: string[];
|
||||
type: T;
|
||||
data?: any;
|
||||
options?: any;
|
||||
}
|
||||
|
||||
export type IQuery = ITypedQuery<
|
||||
ICollectionQueries | IDocumentQueries | "snapshot"
|
||||
>;
|
||||
|
||||
export const MP = MSGPack({});
|
||||
|
||||
// MSGPack.initialize(2 ** 20);
|
||||
|
||||
const ALPHABET =
|
||||
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
const longNanoID = nanoid.customAlphabet(ALPHABET, 32);
|
||||
const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
const { encode, decode } = MP;
|
||||
|
||||
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 ISubscribeOptions {
|
||||
existing: boolean;
|
||||
}
|
||||
|
||||
interface DocRes {
|
||||
id: string;
|
||||
data: any;
|
||||
}
|
||||
|
||||
export abstract class Query {
|
||||
export default 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);
|
||||
}
|
||||
|
||||
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!"
|
||||
);
|
||||
constructor(private database: Database, private path: string[], private sender: string) {
|
||||
if (path.length > 10) {
|
||||
throw new Error("Path is to long. Path is only allowed to be 10 Layers deep!");
|
||||
}
|
||||
if (!this.validatePath(query.path)) {
|
||||
throw new QueryError(
|
||||
"Path can only contain a-z A-Z 0-9 '-' '-' '<' and '>' "
|
||||
);
|
||||
if (!this.validatePath(path)) {
|
||||
throw new Error("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;
|
||||
}
|
||||
this.onChange = this.onChange.bind(this);
|
||||
}
|
||||
|
||||
protected abstract prepare(query: IQuery): IPreparedQuery;
|
||||
|
||||
protected getDoc(collection: string, document: string) {
|
||||
return this.database.data
|
||||
.get(Database.getKey(collection, document), { asBuffer: true })
|
||||
.then((res) => decode(res as Buffer))
|
||||
.catch(resNull);
|
||||
}
|
||||
private 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("/");
|
||||
|
||||
protected sendChange(
|
||||
collection: string,
|
||||
document: string,
|
||||
type: ChangeTypes,
|
||||
data: any
|
||||
) {
|
||||
let change: Change = {
|
||||
type,
|
||||
document,
|
||||
collection,
|
||||
data,
|
||||
sender: this.session.id,
|
||||
};
|
||||
const lock = await this.database.collectionLocks.lock(key);
|
||||
|
||||
Logging.debug("Sending change:", change);
|
||||
|
||||
this.changes.push(change);
|
||||
}
|
||||
|
||||
protected static getConstructorParams(
|
||||
query: Query
|
||||
): [Database, Session, IQuery] {
|
||||
return [query.database, query.session, query.query];
|
||||
}
|
||||
|
||||
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...)
|
||||
}
|
||||
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);
|
||||
}
|
||||
);
|
||||
|
||||
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);
|
||||
} finally {
|
||||
lock();
|
||||
}
|
||||
|
||||
return {
|
||||
unsubscribe: () => {
|
||||
unsub();
|
||||
removeSubscriber();
|
||||
},
|
||||
value: await this.firstSend(collection, document),
|
||||
collection: collectionID,
|
||||
document: documentKey,
|
||||
collectionKey: key
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
interface UpdateData {
|
||||
[path: string]: {
|
||||
type: "value" | "timestamp" | "increment" | "push";
|
||||
value: any;
|
||||
};
|
||||
}
|
||||
export class DocumentQuery extends Query {
|
||||
prepare(query: IQuery): IPreparedQuery {
|
||||
let type = query.type as IDocumentQueries;
|
||||
switch (type) {
|
||||
case "get":
|
||||
return {
|
||||
batchCompatible: false,
|
||||
createCollection: false,
|
||||
needDocument: false,
|
||||
permission: "read",
|
||||
runner: this.get,
|
||||
};
|
||||
case "set":
|
||||
return {
|
||||
batchCompatible: true,
|
||||
createCollection: true,
|
||||
needDocument: true,
|
||||
permission: "write",
|
||||
runner: this.set,
|
||||
};
|
||||
case "update":
|
||||
return {
|
||||
batchCompatible: true,
|
||||
createCollection: true,
|
||||
needDocument: true,
|
||||
permission: "write",
|
||||
runner: this.update,
|
||||
};
|
||||
case "delete":
|
||||
return {
|
||||
batchCompatible: true,
|
||||
createCollection: false,
|
||||
needDocument: true,
|
||||
permission: "write",
|
||||
runner: this.delete,
|
||||
};
|
||||
default:
|
||||
throw new Error("Invalid query type: " + type);
|
||||
}
|
||||
private getKey(collection: string, document?: string) {
|
||||
return `${collection || ""}/${document || ""}`;
|
||||
}
|
||||
|
||||
private async get(collection: string, document: string) {
|
||||
private getDoc(collection: string, document: string) {
|
||||
return this.database.data.get(this.getKey(collection, document), { asBuffer: true }).then(res => decode(res as Buffer)).catch(resNull);
|
||||
}
|
||||
|
||||
private sendChange(collection: string, document: string, type: ChangeTypes, data: any) {
|
||||
let change: Change = {
|
||||
type,
|
||||
document,
|
||||
data,
|
||||
sender: this.sender
|
||||
}
|
||||
|
||||
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)))
|
||||
|
||||
}
|
||||
|
||||
public async get() {
|
||||
let { collection, document } = await this.resolve(this.path);
|
||||
|
||||
if (!collection || !document) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this.getDoc(collection, document);
|
||||
const lock = await this.database.locks.lock(collection, document);
|
||||
return this.getDoc(collection, document).finally(() => lock())
|
||||
}
|
||||
|
||||
private async set(
|
||||
collection: string,
|
||||
document: string,
|
||||
batch?: LevelUpChain
|
||||
) {
|
||||
const { data, options } = this.query;
|
||||
if (data === null) return this.delete(collection, document, batch);
|
||||
public async keys() {
|
||||
let { collection, document } = await this.resolve(this.path);
|
||||
if (document)
|
||||
throw new Error("Keys only works on collections!");
|
||||
if (!collection)
|
||||
throw new Error("There must be a collection");
|
||||
|
||||
let isNew = !(await this.getDoc(collection, document));
|
||||
batch.put(Database.getKey(collection, document), encode(data));
|
||||
this.sendChange(collection, document, isNew ? "added" : "modified", data);
|
||||
}
|
||||
|
||||
private async update(
|
||||
collection: string,
|
||||
document: string,
|
||||
batch?: LevelUpChain
|
||||
) {
|
||||
const updateData: UpdateData = this.query.data;
|
||||
|
||||
let data = await this.getDoc(collection, document);
|
||||
let isNew = false;
|
||||
if (!data) {
|
||||
isNew = true;
|
||||
data = {};
|
||||
}
|
||||
|
||||
for (let path in updateData) {
|
||||
const toUpdate = updateData[path];
|
||||
let d = data;
|
||||
let parts = path.split(".");
|
||||
while (parts.length > 1) {
|
||||
let seg = parts.shift();
|
||||
if (!data[seg]) data[seg] = {};
|
||||
d = data[seg];
|
||||
}
|
||||
|
||||
const last = parts[0];
|
||||
|
||||
switch (toUpdate.type) {
|
||||
case "value":
|
||||
d[last] = toUpdate.value;
|
||||
break;
|
||||
case "increment":
|
||||
if (d[last] === undefined || d[last] === null)
|
||||
d[last] = toUpdate.value;
|
||||
else if (typeof d[last] !== "number") {
|
||||
throw new QueryError("Field is no number!");
|
||||
} else {
|
||||
d[last] += toUpdate.value;
|
||||
}
|
||||
break;
|
||||
case "timestamp":
|
||||
d[last] = new Date().valueOf();
|
||||
break;
|
||||
case "push":
|
||||
if (d[last] === undefined || d[last] === null)
|
||||
d[last] = [toUpdate.value];
|
||||
else if (Array.isArray(d[last])) {
|
||||
d[last].push(toUpdate.value);
|
||||
} else {
|
||||
throw new QueryError("Field is not array!");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
throw new QueryError("Invalid update type: " + toUpdate.type);
|
||||
}
|
||||
}
|
||||
|
||||
if (batch) {
|
||||
batch.put(Database.getKey(collection, document), encode(data));
|
||||
} else {
|
||||
await this.database.data.put(
|
||||
Database.getKey(collection, document),
|
||||
encode(data).slice(0)
|
||||
);
|
||||
}
|
||||
|
||||
this.sendChange(collection, document, isNew ? "added" : "modified", data);
|
||||
}
|
||||
|
||||
private async delete(
|
||||
collection: string,
|
||||
document: string,
|
||||
batch?: LevelUpChain
|
||||
) {
|
||||
if (batch) {
|
||||
batch.del(Database.getKey(collection, document));
|
||||
} else {
|
||||
await this.database.data.del(Database.getKey(collection, document));
|
||||
}
|
||||
|
||||
this.sendChange(collection, document, "deleted", null);
|
||||
}
|
||||
|
||||
checkChange(change: Change) {
|
||||
return true;
|
||||
}
|
||||
|
||||
firstSend(collection: string, document: string) {
|
||||
return this.get(collection, document);
|
||||
}
|
||||
|
||||
public static fromQuery(query: Query) {
|
||||
return new DocumentQuery(...Query.getConstructorParams(query));
|
||||
}
|
||||
}
|
||||
|
||||
type FieldPath = string;
|
||||
type WhereFilterOp =
|
||||
| "<"
|
||||
| "<="
|
||||
| "=="
|
||||
| ">="
|
||||
| ">"
|
||||
| "array-contains"
|
||||
| "in"
|
||||
| "array-contains-any";
|
||||
|
||||
interface IQueryWhereVerbose {
|
||||
fieldPath: FieldPath;
|
||||
opStr: WhereFilterOp;
|
||||
value: any;
|
||||
}
|
||||
|
||||
type IQueryWhereArray = [FieldPath, WhereFilterOp, any];
|
||||
|
||||
type IQueryWhere = IQueryWhereArray | IQueryWhereVerbose;
|
||||
|
||||
export class CollectionQuery extends Query {
|
||||
private _addId: string;
|
||||
|
||||
prepare(query): IPreparedQuery {
|
||||
switch (query.type as ICollectionQueries) {
|
||||
case "add":
|
||||
this._addId = longNanoID();
|
||||
return {
|
||||
batchCompatible: true,
|
||||
createCollection: true,
|
||||
needDocument: false,
|
||||
runner: this.add,
|
||||
permission: "write",
|
||||
additionalLock: [...query.path, this._addId],
|
||||
};
|
||||
case "get":
|
||||
const limit = (query.options || {}).limit;
|
||||
if (limit) this.limit = limit;
|
||||
const where = (query.options || {}).where;
|
||||
if (where) this.where = where;
|
||||
|
||||
return {
|
||||
batchCompatible: false,
|
||||
createCollection: false,
|
||||
needDocument: false,
|
||||
permission: "read",
|
||||
runner: this.get,
|
||||
};
|
||||
case "keys":
|
||||
return {
|
||||
batchCompatible: false,
|
||||
createCollection: false,
|
||||
needDocument: false,
|
||||
permission: "list",
|
||||
runner: this.keys,
|
||||
};
|
||||
case "list":
|
||||
return {
|
||||
batchCompatible: false,
|
||||
createCollection: false,
|
||||
needDocument: false,
|
||||
permission: "read",
|
||||
runner: this.keys,
|
||||
};
|
||||
case "delete-collection":
|
||||
return {
|
||||
batchCompatible: false,
|
||||
createCollection: false,
|
||||
needDocument: false,
|
||||
permission: "write",
|
||||
runner: this.deleteCollection,
|
||||
};
|
||||
// run = () => q.deleteCollection();
|
||||
// break;
|
||||
default:
|
||||
throw new Error("Invalid query!");
|
||||
}
|
||||
}
|
||||
|
||||
private _where: IQueryWhereArray[];
|
||||
public set where(value: IQueryWhere[]) {
|
||||
const invalidWhere = new QueryError("Invalid Where");
|
||||
if (!Array.isArray(value)) throw invalidWhere;
|
||||
let c = [];
|
||||
this._where = value.map((cond) => {
|
||||
Logging.debug("Query Condition", cond);
|
||||
if (Array.isArray(cond)) {
|
||||
if (cond.length !== 3) throw invalidWhere;
|
||||
return cond;
|
||||
} else {
|
||||
if (
|
||||
cond &&
|
||||
typeof cond === "object" &&
|
||||
"fieldPath" in cond &&
|
||||
"opStr" in cond &&
|
||||
"value" in cond
|
||||
) {
|
||||
return [cond.fieldPath, cond.opStr, cond.value];
|
||||
} else {
|
||||
throw invalidWhere;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public limit: number = -1;
|
||||
|
||||
public async add(
|
||||
collection: string,
|
||||
document: string,
|
||||
batch: LevelUpChain,
|
||||
collectionKey: string
|
||||
) {
|
||||
let q = new DocumentQuery(this.database, this.session, {
|
||||
type: "set",
|
||||
path: this.additionalLock,
|
||||
data: this.query.data,
|
||||
options: this.query.options,
|
||||
});
|
||||
await q.run(collection, this._addId, batch, collectionKey);
|
||||
this.changes = q.changes;
|
||||
return this._addId;
|
||||
}
|
||||
|
||||
private getStreamOptions(collection: string) {
|
||||
let gt = Buffer.from(Database.getKey(collection) + " ");
|
||||
let gt = Buffer.from(this.getKey(collection) + " ");
|
||||
gt[gt.length - 1] = 0;
|
||||
|
||||
let lt = Buffer.alloc(gt.length);
|
||||
lt.set(gt);
|
||||
lt[gt.length - 1] = 0xff;
|
||||
|
||||
return {
|
||||
gt,
|
||||
lt,
|
||||
};
|
||||
}
|
||||
|
||||
public async keys(collection: string) {
|
||||
if (!collection) return [];
|
||||
lt[gt.length - 1] = 0xFF;
|
||||
|
||||
return new Promise<string[]>((yes, no) => {
|
||||
let keys = [];
|
||||
const stream = this.database.data.createKeyStream({
|
||||
...this.getStreamOptions(collection),
|
||||
keyAsBuffer: false,
|
||||
});
|
||||
gt,
|
||||
lt,
|
||||
keyAsBuffer: false
|
||||
})
|
||||
stream.on("data", (key: string) => {
|
||||
let s = key.split("/", 2);
|
||||
if (s.length > 1) keys.push(s[1]);
|
||||
if (s.length > 1)
|
||||
keys.push(s[1]);
|
||||
});
|
||||
stream.on("end", () => yes(keys));
|
||||
stream.on("error", no);
|
||||
});
|
||||
}
|
||||
|
||||
private _getFieldValue(data: any, path: FieldPath) {
|
||||
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!
|
||||
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 Error("There must be a collection!")
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
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);
|
||||
switch (opStr) {
|
||||
case "<":
|
||||
return val < value;
|
||||
case "<=":
|
||||
return val <= value;
|
||||
case "==":
|
||||
return val == value;
|
||||
case ">=":
|
||||
return val >= value;
|
||||
case ">":
|
||||
return val > value;
|
||||
case "array-contains":
|
||||
if (Array.isArray(val)) {
|
||||
return val.some((e) => e === value);
|
||||
}
|
||||
|
||||
return false;
|
||||
// case "array-contains-any":
|
||||
case "in":
|
||||
if (typeof val === "object") {
|
||||
return value in val;
|
||||
}
|
||||
return false;
|
||||
default:
|
||||
throw new QueryError("Invalid where operation " + opStr);
|
||||
}
|
||||
});
|
||||
if (!document) {
|
||||
throw new Error("There must be a document key!")
|
||||
}
|
||||
return true;
|
||||
|
||||
const lock = await this.database.locks.lock(collection, document);
|
||||
|
||||
let isNew = await this.database.data.get(this.getKey(collection, document)).catch(resNull).then(e => e !== null);
|
||||
|
||||
return this.database.data
|
||||
.put(this.getKey(collection, document), encode(data))
|
||||
.then(() => this.sendChange(collection, document, isNew ? "added" : "modified", data))
|
||||
.finally(() => lock())
|
||||
}
|
||||
|
||||
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,
|
||||
});
|
||||
|
||||
let values: DocRes[] = [];
|
||||
|
||||
const onValue = (err: Error, key: string, value: Buffer) => {
|
||||
if (err) {
|
||||
no(err);
|
||||
stream.end((err) => Logging.error(err));
|
||||
} else {
|
||||
if (!key && !value) {
|
||||
// END
|
||||
Logging.debug("Checked all!");
|
||||
yes(values);
|
||||
} else {
|
||||
let s = key.split("/", 2);
|
||||
if (s.length <= 1) return;
|
||||
|
||||
const id = s[1];
|
||||
|
||||
let data = decode(value);
|
||||
if (this._fitsWhere(data)) {
|
||||
if (this.limit < 0 || values.length < this.limit) {
|
||||
values.push({
|
||||
id,
|
||||
data,
|
||||
});
|
||||
} else {
|
||||
stream.end((err) => (err ? no(err) : yes(values)));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
stream.next(onValue);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
stream.next(onValue);
|
||||
});
|
||||
public async push(value: any) {
|
||||
let id = nanoid(ALPHABET, 32);
|
||||
let q = new Query(this.database, [...this.path, id], this.sender);
|
||||
await q.set(value, {});
|
||||
return id;
|
||||
}
|
||||
|
||||
checkChange(change: Change) {
|
||||
return this._fitsWhere(change.data);
|
||||
public async delete() {
|
||||
let { collection, document } = await this.resolve(this.path);
|
||||
|
||||
if (!collection) {
|
||||
throw new Error("There must be a collection!")
|
||||
}
|
||||
|
||||
if (!document) {
|
||||
throw new Error("There must be a document key!")
|
||||
}
|
||||
|
||||
|
||||
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())
|
||||
}
|
||||
|
||||
firstSend(collection: string) {
|
||||
return this.get(collection);
|
||||
public async update(data: any) {
|
||||
//TODO: Implement
|
||||
}
|
||||
|
||||
public async collections() {
|
||||
if (!this.session.root) throw new QueryError("No Permission!");
|
||||
|
||||
public async getCollections() {
|
||||
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(
|
||||
collection: string,
|
||||
document: string,
|
||||
_b: LevelUpChain,
|
||||
collectionKey: string
|
||||
) {
|
||||
if (!this.session.root) throw new QueryError("No Permission!");
|
||||
public async deleteCollection() {
|
||||
const { collection, document, collectionKey } = await this.resolve(this.path);
|
||||
|
||||
if (document) {
|
||||
throw new Error("There can be no document defined on this operation");
|
||||
}
|
||||
|
||||
//TODO: Lock whole collection!
|
||||
let batch = this.database.data.batch();
|
||||
try {
|
||||
if (collection) {
|
||||
let documents = await this.keys(collection);
|
||||
// Logging.debug("To delete:", documents)
|
||||
for (let document of documents) {
|
||||
batch.del(Database.getKey(collection, document));
|
||||
let keys = await this.keys();
|
||||
for (let key in keys) {
|
||||
batch.del(key);
|
||||
}
|
||||
await batch.write();
|
||||
batch = undefined;
|
||||
await this.database.collections.del(collectionKey);
|
||||
this.database.collectionChangeListener.send({
|
||||
id: collection,
|
||||
key: collectionKey,
|
||||
type: "delete",
|
||||
});
|
||||
}
|
||||
} finally {
|
||||
if (batch) batch.clear();
|
||||
if (batch)
|
||||
batch.clear();
|
||||
}
|
||||
}
|
||||
|
||||
public static fromQuery(query: Query) {
|
||||
return new CollectionQuery(...Query.getConstructorParams(query));
|
||||
}
|
||||
}
|
||||
|
||||
export class QueryError extends Error {
|
||||
constructor(message: string) {
|
||||
super(message);
|
||||
|
||||
private subscription: {
|
||||
key: string;
|
||||
type: Set<ChangeTypes>;
|
||||
send: (data: Omit<Change, "sender">) => void;
|
||||
};
|
||||
async subscribe(send: (data: Omit<Change, "sender">) => void, type: ChangeTypes[] | undefined, _options: Partial<ISubscribeOptions>) {
|
||||
let options: ISubscribeOptions = {
|
||||
existing: true,
|
||||
..._options
|
||||
}
|
||||
|
||||
let { collection, document } = await this.resolve(this.path);
|
||||
|
||||
let key = this.getKey(collection, document);
|
||||
let s = this.database.changes.get(key) || new Set();
|
||||
s.add(this.onChange)
|
||||
this.database.changes.set(key, s);
|
||||
|
||||
this.subscription = {
|
||||
key,
|
||||
send,
|
||||
type: new Set(type || [])
|
||||
};
|
||||
|
||||
Logging.debug("Existing?", options.existing)
|
||||
|
||||
if (options.existing) {
|
||||
if (document) {
|
||||
send({
|
||||
document: document,
|
||||
type: "added",
|
||||
data: await this.get(),
|
||||
})
|
||||
} else {
|
||||
await this.keys().then(async documents => {
|
||||
for (let document of documents) {
|
||||
const data = await this.getDoc(collection, document);
|
||||
if (data)
|
||||
send({
|
||||
type: "added",
|
||||
document,
|
||||
data
|
||||
})
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Logging.debug("Subscribed");
|
||||
}
|
||||
|
||||
async onChange(change: Change) {
|
||||
const { type, send } = this.subscription;
|
||||
|
||||
// Events from the sender are handled locally
|
||||
if (change.sender !== this.sender && type.has(change.type)) {
|
||||
let c = { ...change };
|
||||
delete c.sender;
|
||||
send(c)
|
||||
}
|
||||
}
|
||||
|
||||
unsubscribe() {
|
||||
if (!this.subscription) {
|
||||
const { key } = this.subscription;
|
||||
let s = this.database.changes.get(key);
|
||||
if (s) {
|
||||
s.delete(this.onChange);
|
||||
if (s.size <= 0)
|
||||
this.database.changes.delete(key);
|
||||
}
|
||||
this.subscription = undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
111
src/database/rules.ts
Normal file
111
src/database/rules.ts
Normal file
@ -0,0 +1,111 @@
|
||||
import Session from "./session";
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
|
||||
interface IRule<T> {
|
||||
".write"?: T
|
||||
".read"?: T
|
||||
}
|
||||
|
||||
type IRuleConfig<T> = {
|
||||
[segment: string]: IRuleConfig<T>;
|
||||
} | IRule<T>;
|
||||
|
||||
type IRuleRaw = IRuleConfig<string>;
|
||||
type IRuleParsed = IRuleConfig<boolean>;
|
||||
|
||||
const resolve = (value: any) => {
|
||||
if (value === true) {
|
||||
return true;
|
||||
} else if (typeof value === "string") {
|
||||
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export class Rules {
|
||||
rules: IRuleParsed;
|
||||
constructor(private config: string) {
|
||||
let parsed: IRuleRaw = JSON.parse(config);
|
||||
|
||||
const analyze = (raw: IRuleRaw) => {
|
||||
let r: IRuleParsed = {};
|
||||
|
||||
if (raw[".read"]) {
|
||||
let res = resolve(raw[".read"]);
|
||||
if (res) {
|
||||
r[".read"] = res;
|
||||
}
|
||||
delete raw[".read"];
|
||||
}
|
||||
|
||||
if (raw[".write"]) {
|
||||
let res = resolve(raw[".write"]);
|
||||
if (res) {
|
||||
r[".write"] = res;
|
||||
}
|
||||
delete raw[".write"];
|
||||
}
|
||||
|
||||
for (let segment in raw) {
|
||||
if (segment.startsWith("."))
|
||||
continue;
|
||||
|
||||
r[segment] = analyze(raw[segment]);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
this.rules = analyze(parsed);
|
||||
}
|
||||
|
||||
hasPermission(path: string[], session: Session): { read: boolean, write: boolean } {
|
||||
let read = this.rules[".read"] || false;
|
||||
let write = this.rules[".write"] || false;
|
||||
|
||||
let rules = this.rules;
|
||||
|
||||
for (let segment of path) {
|
||||
if (segment.startsWith("$") || segment.startsWith(".")) {
|
||||
read = false;
|
||||
write = false;
|
||||
Logging.log("Invalid query path (started with '$' or '.'):", path);
|
||||
break;
|
||||
}
|
||||
|
||||
let k = Object.keys(rules)
|
||||
.filter(e => e.startsWith("$"))
|
||||
.find(e => {
|
||||
switch (e) {
|
||||
case "$uid":
|
||||
if (segment === session.uid)
|
||||
return true;
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
})
|
||||
|
||||
rules = (k ? rules[k] : undefined) || rules[segment] || rules["*"];
|
||||
|
||||
if (rules) {
|
||||
if (rules[".read"]) {
|
||||
read = rules[".read"]
|
||||
}
|
||||
|
||||
if (rules[".write"]) {
|
||||
read = rules[".write"]
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
read: read as boolean,
|
||||
write: write as boolean
|
||||
}
|
||||
}
|
||||
|
||||
toJSON() {
|
||||
return this.config;
|
||||
}
|
||||
}
|
||||
@ -1,10 +1,8 @@
|
||||
export default class Session {
|
||||
constructor(private _sessionid: string) {}
|
||||
get id() {
|
||||
constructor(private _sessionid: string) { }
|
||||
get sessionid() {
|
||||
return this._sessionid;
|
||||
}
|
||||
root: boolean = false;
|
||||
uid: string = null;
|
||||
|
||||
subscriptions = new Map<string, () => void>();
|
||||
uid: string = undefined;
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
import * as JWT from "jsonwebtoken";
|
||||
|
||||
export async function verifyJWT(token: string, publicKey: string) {
|
||||
return new Promise<any | undefined>((yes) => {
|
||||
JWT.verify(token, publicKey, (err, decoded) => {
|
||||
if (err)
|
||||
yes(undefined);
|
||||
else
|
||||
yes(decoded);
|
||||
})
|
||||
})
|
||||
}
|
||||
27
src/index.ts
27
src/index.ts
@ -3,24 +3,17 @@ import Web from "./web";
|
||||
import config from "./config";
|
||||
import { DatabaseManager } from "./database/database";
|
||||
import { createServer } from "http";
|
||||
import { WebsocketConnectionManager } from "./websocket";
|
||||
import { ConnectionManager } from "./connection";
|
||||
import { LoggingTypes } from "@hibas123/logging";
|
||||
import { readFileSync } from "fs";
|
||||
|
||||
Logging.logLevel = config.dev ? LoggingTypes.Debug : LoggingTypes.Log;
|
||||
|
||||
const version = JSON.parse(readFileSync("./package.json").toString()).version;
|
||||
|
||||
Logging.log("Starting Database version:", version);
|
||||
|
||||
DatabaseManager.init()
|
||||
.then(() => {
|
||||
const http = createServer(Web.callback());
|
||||
WebsocketConnectionManager.bind(http);
|
||||
const port = config.port || 5000;
|
||||
http.listen(port, () => Logging.log("WS: Listening on port:", port));
|
||||
})
|
||||
.catch((err) => {
|
||||
Logging.error(err);
|
||||
process.exit(-1);
|
||||
});
|
||||
DatabaseManager.init().then(() => {
|
||||
const http = createServer(Web.callback());
|
||||
ConnectionManager.bind(http);
|
||||
const port = config.port || 5000;
|
||||
http.listen(port, () => Logging.log("Listening on port:", port))
|
||||
}).catch(err => {
|
||||
Logging.error(err);
|
||||
process.exit(-1);
|
||||
})
|
||||
@ -1,293 +0,0 @@
|
||||
import {
|
||||
Node,
|
||||
MatchStatement,
|
||||
Operations,
|
||||
ServiceStatement,
|
||||
Expression,
|
||||
ValueStatement,
|
||||
Operators,
|
||||
} from "./parser";
|
||||
|
||||
export class CompilerError extends Error {
|
||||
node: Node;
|
||||
constructor(message: string, node: Node) {
|
||||
super(message);
|
||||
this.node = node;
|
||||
}
|
||||
}
|
||||
|
||||
type Variables = { [key: string]: string | Variables };
|
||||
|
||||
class Variable {
|
||||
#name: string;
|
||||
constructor(name: string) {
|
||||
this.#name = name;
|
||||
}
|
||||
|
||||
getValue(variables: Variables) {
|
||||
const parts = this.#name.split(".");
|
||||
let current = variables as any;
|
||||
while (parts.length > 0) {
|
||||
const name = parts.shift();
|
||||
if (current && typeof current == "object") current = current[name];
|
||||
}
|
||||
return current;
|
||||
}
|
||||
}
|
||||
|
||||
class Value {
|
||||
#value: any;
|
||||
constructor(value: any) {
|
||||
this.#value = value;
|
||||
}
|
||||
|
||||
get value() {
|
||||
return this.#value;
|
||||
}
|
||||
}
|
||||
|
||||
type ConditionParameters = Value | ConditionMatcher | Variable;
|
||||
class ConditionMatcher {
|
||||
#left: ConditionParameters;
|
||||
#right: ConditionParameters;
|
||||
#operator: Operators;
|
||||
constructor(
|
||||
left: ConditionParameters,
|
||||
right: ConditionParameters,
|
||||
operator: Operators
|
||||
) {
|
||||
this.#left = left;
|
||||
this.#right = right;
|
||||
this.#operator = operator;
|
||||
}
|
||||
|
||||
test(variables: Variables): boolean {
|
||||
let leftValue: any;
|
||||
if (this.#left instanceof Value) {
|
||||
leftValue = this.#left.value;
|
||||
} else if (this.#left instanceof Variable) {
|
||||
leftValue = this.#left.getValue(variables);
|
||||
} else {
|
||||
leftValue = this.#left.test(variables);
|
||||
}
|
||||
|
||||
let rightValue: any;
|
||||
if (this.#right instanceof Value) {
|
||||
rightValue = this.#right.value;
|
||||
} else if (this.#right instanceof Variable) {
|
||||
rightValue = this.#right.getValue(variables);
|
||||
} else {
|
||||
rightValue = this.#right.test(variables);
|
||||
}
|
||||
|
||||
switch (this.#operator) {
|
||||
case "==":
|
||||
return leftValue == rightValue;
|
||||
case "!=":
|
||||
return leftValue != rightValue;
|
||||
case ">=":
|
||||
return leftValue >= rightValue;
|
||||
case "<=":
|
||||
return leftValue <= rightValue;
|
||||
case ">":
|
||||
return leftValue > rightValue;
|
||||
case "<":
|
||||
return leftValue < rightValue;
|
||||
case "&&":
|
||||
return leftValue && rightValue;
|
||||
case "||":
|
||||
return leftValue || rightValue;
|
||||
default:
|
||||
throw new Error("Invalid operator " + this.#operator);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Rule {
|
||||
#operation: Operations;
|
||||
|
||||
#condition: ConditionParameters;
|
||||
|
||||
get operation() {
|
||||
return this.#operation;
|
||||
}
|
||||
|
||||
constructor(operation: Operations, condition: ConditionParameters) {
|
||||
this.#operation = operation;
|
||||
this.#condition = condition;
|
||||
}
|
||||
|
||||
test(variables: Variables): boolean {
|
||||
if (this.#condition instanceof Value) {
|
||||
return Boolean(this.#condition.value);
|
||||
} else if (this.#condition instanceof Variable) {
|
||||
return Boolean(this.#condition.getValue(variables));
|
||||
} else {
|
||||
return this.#condition.test(variables);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Segment {
|
||||
#name: string;
|
||||
#variable: boolean;
|
||||
get name() {
|
||||
return this.#name;
|
||||
}
|
||||
constructor(name: string, variable = false) {
|
||||
this.#name = name;
|
||||
this.#variable = variable;
|
||||
}
|
||||
|
||||
match(segment: string): { match: boolean; variable?: string } {
|
||||
return {
|
||||
match: this.#name === segment || this.#variable,
|
||||
variable: this.#variable && this.#name,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
class Match {
|
||||
#submatches: Match[];
|
||||
#rules: Rule[];
|
||||
|
||||
#segments: Segment[];
|
||||
#wildcard: boolean;
|
||||
|
||||
constructor(
|
||||
segments: Segment[],
|
||||
rules: Rule[],
|
||||
wildcard: boolean,
|
||||
submatches: Match[]
|
||||
) {
|
||||
this.#segments = segments;
|
||||
this.#rules = rules;
|
||||
this.#wildcard = wildcard;
|
||||
this.#submatches = submatches;
|
||||
}
|
||||
|
||||
match(
|
||||
segments: string[],
|
||||
operation: Operations,
|
||||
variables: Variables
|
||||
): boolean {
|
||||
let localVars = { ...variables };
|
||||
if (segments.length >= this.#segments.length) {
|
||||
for (let i = 0; i < this.#segments.length; i++) {
|
||||
const match = this.#segments[i].match(segments[i]);
|
||||
if (match.match) {
|
||||
if (match.variable) {
|
||||
localVars[match.variable] = segments[i];
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
let remaining = segments.slice(this.#segments.length);
|
||||
if (remaining.length > 0 && !this.#wildcard) {
|
||||
for (const match of this.#submatches) {
|
||||
const res = match.match(remaining, operation, localVars);
|
||||
if (res) return true;
|
||||
}
|
||||
} else {
|
||||
for (const rule of this.#rules) {
|
||||
if (rule.operation === operation) {
|
||||
if (rule.test(localVars)) return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export class RuleRunner {
|
||||
#root_matches: Match[];
|
||||
constructor(root_matches: Match[]) {
|
||||
this.#root_matches = root_matches;
|
||||
}
|
||||
|
||||
hasPermission(path: string[], operation: Operations, request: any): boolean {
|
||||
if (request.root) return true;
|
||||
for (const match of this.#root_matches) {
|
||||
const res = match.match(path, operation, { request });
|
||||
if (res) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export function getRuleRunner(service: ServiceStatement) {
|
||||
const createMatch = (s_match: MatchStatement) => {
|
||||
let wildcard = false;
|
||||
let segments = s_match.path.segments
|
||||
.map((segment, idx, arr) => {
|
||||
if (typeof segment === "string") {
|
||||
if (segment === "*") {
|
||||
if (idx === arr.length - 1) {
|
||||
wildcard = true;
|
||||
return null;
|
||||
} else {
|
||||
throw new CompilerError("Invalid path wildcard!", s_match);
|
||||
}
|
||||
} else {
|
||||
return new Segment(segment, false);
|
||||
}
|
||||
} else {
|
||||
return new Segment(segment.name, true);
|
||||
}
|
||||
})
|
||||
.filter((e) => e !== null);
|
||||
|
||||
const resolveParameter = (e: Expression | ValueStatement) => {
|
||||
let val: Value | ConditionMatcher | Variable;
|
||||
if (e.type === "value") {
|
||||
const c = e;
|
||||
if (c.isFalse) {
|
||||
val = new Value(false);
|
||||
} else if (c.isTrue) {
|
||||
val = new Value(true);
|
||||
} else if (c.isNull) {
|
||||
val = new Value(null);
|
||||
} else if (c.isNumber) {
|
||||
val = new Value(Number(c.value));
|
||||
} else if (c.isString) {
|
||||
val = new Value(String(c.value));
|
||||
} else if (c.isVariable) {
|
||||
val = new Variable(String(c.value));
|
||||
} else {
|
||||
throw new CompilerError("Invalid value type!", e);
|
||||
}
|
||||
} else {
|
||||
val = createCondition(e);
|
||||
}
|
||||
|
||||
return val;
|
||||
};
|
||||
|
||||
const createCondition = (cond: Expression): ConditionMatcher => {
|
||||
let left: ConditionParameters = resolveParameter(cond.left);
|
||||
let right: ConditionParameters = resolveParameter(cond.right);
|
||||
|
||||
return new ConditionMatcher(left, right, cond.operator);
|
||||
};
|
||||
|
||||
const rules: Rule[] = s_match.rules
|
||||
.map((rule) => {
|
||||
const condition = resolveParameter(rule.condition);
|
||||
return rule.operations.map((op) => new Rule(op, condition));
|
||||
})
|
||||
.flat(1);
|
||||
const submatches = s_match.matches.map((sub) => createMatch(sub));
|
||||
const match = new Match(segments, rules, wildcard, submatches);
|
||||
|
||||
return match;
|
||||
};
|
||||
|
||||
const root_matches = service.matches.map((match) => createMatch(match));
|
||||
|
||||
const runner = new RuleRunner(root_matches);
|
||||
|
||||
return runner;
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
export interface RuleError {
|
||||
line: number;
|
||||
column: number;
|
||||
message: string;
|
||||
original_err: Error;
|
||||
}
|
||||
|
||||
function indexToLineAndCol(src: string, index: number) {
|
||||
let line = 1;
|
||||
let col = 1;
|
||||
for (let i = 0; i < index; i++) {
|
||||
if (src.charAt(i) === "\n") {
|
||||
line++;
|
||||
col = 1;
|
||||
} else {
|
||||
col++;
|
||||
}
|
||||
}
|
||||
|
||||
return { line, col };
|
||||
}
|
||||
|
||||
export function transformError(
|
||||
err: Error,
|
||||
data: string,
|
||||
idx: number
|
||||
): RuleError {
|
||||
let loc = indexToLineAndCol(data, idx);
|
||||
|
||||
return {
|
||||
line: loc.line,
|
||||
column: loc.col,
|
||||
message: err.message,
|
||||
original_err: err,
|
||||
};
|
||||
}
|
||||
@ -1,29 +0,0 @@
|
||||
import { RuleError, transformError } from "./error";
|
||||
import parse, { ParserError } from "./parser";
|
||||
import tokenize, { TokenizerError } from "./tokenise";
|
||||
import { getRuleRunner, RuleRunner } from "./compile";
|
||||
import { inspect } from "util";
|
||||
|
||||
export default function compileRule(rule: string) {
|
||||
let runner: RuleRunner | undefined;
|
||||
let error: RuleError | undefined;
|
||||
try {
|
||||
const tokenised = tokenize(rule);
|
||||
const parsed = parse(tokenised);
|
||||
const dbservice = parsed.find((e) => e.name === "realtimedb");
|
||||
|
||||
if (!dbservice) throw new Error("No realtimedb service available!");
|
||||
|
||||
runner = getRuleRunner(dbservice);
|
||||
} catch (err) {
|
||||
if (err instanceof TokenizerError) {
|
||||
error = transformError(err, rule, err.index);
|
||||
} else if (err instanceof ParserError) {
|
||||
error = transformError(err, rule, err.token.startIdx);
|
||||
} else {
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
return { runner, error };
|
||||
}
|
||||
@ -1,349 +0,0 @@
|
||||
import { Token } from "./tokenise";
|
||||
|
||||
export interface Node {
|
||||
type: string;
|
||||
idx: number;
|
||||
}
|
||||
|
||||
export interface PathStatement extends Node {
|
||||
type: "path";
|
||||
segments: (string | { type: "variable"; name: string })[];
|
||||
}
|
||||
|
||||
export interface ValueStatement extends Node {
|
||||
type: "value";
|
||||
isNull: boolean;
|
||||
isTrue: boolean;
|
||||
isFalse: boolean;
|
||||
isNumber: boolean;
|
||||
isString: boolean;
|
||||
isVariable: boolean;
|
||||
|
||||
value?: any;
|
||||
}
|
||||
|
||||
export type Operators = "&&" | "||" | "==" | "<=" | ">=" | "!=" | ">" | "<";
|
||||
|
||||
export interface Expression extends Node {
|
||||
type: "expression";
|
||||
|
||||
left: ValueStatement | Expression;
|
||||
operator: Operators;
|
||||
right: ValueStatement | Expression;
|
||||
}
|
||||
|
||||
export type Operations = "read" | "write" | "list"; // | "update" | "create" | "delete" | "list";
|
||||
|
||||
export interface AllowStatement extends Node {
|
||||
type: "permission";
|
||||
operations: Operations[];
|
||||
condition: Expression | ValueStatement;
|
||||
}
|
||||
|
||||
export interface MatchStatement extends Node {
|
||||
type: "match";
|
||||
path: PathStatement;
|
||||
matches: MatchStatement[];
|
||||
rules: AllowStatement[];
|
||||
}
|
||||
|
||||
export interface ServiceStatement extends Node {
|
||||
type: "service";
|
||||
name: string;
|
||||
matches: MatchStatement[];
|
||||
}
|
||||
|
||||
export class ParserError extends Error {
|
||||
token: Token;
|
||||
constructor(message: string, token: Token) {
|
||||
super(message);
|
||||
this.token = token;
|
||||
}
|
||||
}
|
||||
|
||||
export default function parse(tokens: Token[]) {
|
||||
const tokenIterator = tokens[Symbol.iterator]();
|
||||
let currentToken: Token = tokenIterator.next().value;
|
||||
let nextToken: Token = tokenIterator.next().value;
|
||||
|
||||
const eatToken = (value?: string) => {
|
||||
if (value && value !== currentToken.value) {
|
||||
throw new ParserError(
|
||||
`Unexpected token value, expected '${value}', received '${currentToken.value}'`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
let idx = currentToken.startIdx;
|
||||
currentToken = nextToken;
|
||||
nextToken = tokenIterator.next().value;
|
||||
return idx;
|
||||
};
|
||||
|
||||
const eatText = (): [string, number] => {
|
||||
checkTypes("text");
|
||||
let val = currentToken.value;
|
||||
let idx = currentToken.startIdx;
|
||||
eatToken();
|
||||
return [val, idx];
|
||||
};
|
||||
const eatNumber = (): number => {
|
||||
checkTypes("number");
|
||||
let val = Number(currentToken.value);
|
||||
if (Number.isNaN(val)) {
|
||||
throw new ParserError(
|
||||
`Value cannot be parsed as number! ${currentToken.value}`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
eatToken();
|
||||
return val;
|
||||
};
|
||||
|
||||
const checkTypes = (...types: string[]) => {
|
||||
if (types.indexOf(currentToken.type) < 0) {
|
||||
throw new ParserError(
|
||||
`Unexpected token value, expected ${types.join(" | ")}, received '${
|
||||
currentToken.value
|
||||
}'`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
const parsePathStatement = (): PathStatement => {
|
||||
const segments: (string | { name: string; type: "variable" })[] = [];
|
||||
const idx = currentToken.startIdx;
|
||||
let next = currentToken.type === "slash";
|
||||
while (next) {
|
||||
eatToken("/");
|
||||
if (currentToken.type === "curly_open" && nextToken.type === "text") {
|
||||
eatToken("{");
|
||||
const [name] = eatText();
|
||||
segments.push({
|
||||
type: "variable",
|
||||
name,
|
||||
});
|
||||
eatToken("}");
|
||||
} else if (currentToken.type === "text") {
|
||||
const [name] = eatText();
|
||||
segments.push(name);
|
||||
}
|
||||
next = currentToken.type === "slash";
|
||||
}
|
||||
|
||||
return {
|
||||
type: "path",
|
||||
idx,
|
||||
segments,
|
||||
};
|
||||
};
|
||||
|
||||
const parseValue = (): ValueStatement => {
|
||||
const idx = currentToken.startIdx;
|
||||
|
||||
let isTrue = false;
|
||||
let isFalse = false;
|
||||
let isNull = false;
|
||||
let isVariable = false;
|
||||
let isNumber = false;
|
||||
let isString = false;
|
||||
let value: any = undefined;
|
||||
if (currentToken.type === "keyword") {
|
||||
if (currentToken.value === "true") isTrue = true;
|
||||
else if (currentToken.value === "false") isFalse = true;
|
||||
else if (currentToken.value === "null") isNull = true;
|
||||
else {
|
||||
throw new ParserError(
|
||||
`Invalid keyword at this position ${currentToken.value}`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
eatToken();
|
||||
} else if (currentToken.type === "string") {
|
||||
isString = true;
|
||||
value = currentToken.value.slice(1, currentToken.value.length - 1);
|
||||
eatToken();
|
||||
} else if (currentToken.type === "number") {
|
||||
isNumber = true;
|
||||
value = eatNumber();
|
||||
} else if (currentToken.type === "text") {
|
||||
isVariable = true;
|
||||
[value] = eatText();
|
||||
} else {
|
||||
throw new ParserError(
|
||||
`Expected value got ${currentToken.type}`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
type: "value",
|
||||
isFalse,
|
||||
isNull,
|
||||
isNumber,
|
||||
isString,
|
||||
isTrue,
|
||||
isVariable,
|
||||
value,
|
||||
idx,
|
||||
};
|
||||
};
|
||||
|
||||
const parseCondition = (): Expression | ValueStatement => {
|
||||
// let running = true;
|
||||
let res: Expression | ValueStatement;
|
||||
let left: Expression | ValueStatement | undefined;
|
||||
|
||||
// while (running) {
|
||||
const idx = currentToken.startIdx;
|
||||
|
||||
if (!left) {
|
||||
if (currentToken.type === "bracket_open") {
|
||||
eatToken("(");
|
||||
left = parseCondition();
|
||||
eatToken(")");
|
||||
} else {
|
||||
left = parseValue();
|
||||
}
|
||||
}
|
||||
|
||||
if (currentToken.type === "comparison_operator") {
|
||||
const operator = currentToken.value;
|
||||
|
||||
eatToken();
|
||||
|
||||
let right: Expression | ValueStatement;
|
||||
|
||||
let ct = currentToken; //Quick hack because of TypeScript
|
||||
if (ct.type === "bracket_open") {
|
||||
eatToken("(");
|
||||
right = parseCondition();
|
||||
eatToken(")");
|
||||
} else {
|
||||
right = parseValue();
|
||||
}
|
||||
|
||||
res = {
|
||||
type: "expression",
|
||||
left,
|
||||
right,
|
||||
operator: operator as Operators,
|
||||
idx,
|
||||
};
|
||||
} else if (currentToken.type === "logic_operator") {
|
||||
const operator = currentToken.value;
|
||||
|
||||
eatToken();
|
||||
|
||||
const right = parseCondition();
|
||||
|
||||
res = {
|
||||
type: "expression",
|
||||
left,
|
||||
operator: operator as Operators,
|
||||
right,
|
||||
idx,
|
||||
};
|
||||
} else {
|
||||
res = left;
|
||||
}
|
||||
|
||||
// let ct = currentToken;
|
||||
// if (
|
||||
// ct.type === "comparison_operator" ||
|
||||
// ct.type === "logic_operator"
|
||||
// ) {
|
||||
// left = res;
|
||||
// } else {
|
||||
// running = false;
|
||||
// }
|
||||
// }
|
||||
return res;
|
||||
};
|
||||
|
||||
const parsePermissionStatement = (): AllowStatement => {
|
||||
const idx = eatToken("allow");
|
||||
|
||||
const operations: Operations[] = [];
|
||||
let next = currentToken.type !== "colon";
|
||||
while (next) {
|
||||
const [operation] = eatText();
|
||||
operations.push(operation as Operations);
|
||||
if (currentToken.type === "comma") {
|
||||
next = true;
|
||||
eatToken(",");
|
||||
} else {
|
||||
next = false;
|
||||
}
|
||||
}
|
||||
|
||||
eatToken(":");
|
||||
|
||||
eatToken("if");
|
||||
|
||||
const condition = parseCondition();
|
||||
|
||||
eatToken(";");
|
||||
|
||||
return {
|
||||
type: "permission",
|
||||
idx,
|
||||
operations,
|
||||
condition,
|
||||
};
|
||||
};
|
||||
|
||||
const parseMatchStatement = (): MatchStatement => {
|
||||
const idx = eatToken("match");
|
||||
const path = parsePathStatement();
|
||||
|
||||
eatToken("{");
|
||||
const matches: MatchStatement[] = [];
|
||||
const permissions: AllowStatement[] = [];
|
||||
while (currentToken.type !== "curly_close") {
|
||||
if (currentToken.value === "match") {
|
||||
matches.push(parseMatchStatement());
|
||||
} else if (currentToken.value === "allow") {
|
||||
permissions.push(parsePermissionStatement());
|
||||
} else {
|
||||
throw new ParserError(
|
||||
`Unexpected token value, expected 'match' or 'allow', received '${currentToken.value}'`,
|
||||
currentToken
|
||||
);
|
||||
}
|
||||
}
|
||||
eatToken("}");
|
||||
|
||||
return {
|
||||
type: "match",
|
||||
path,
|
||||
idx,
|
||||
matches,
|
||||
rules: permissions,
|
||||
};
|
||||
};
|
||||
|
||||
const parseServiceStatement = (): ServiceStatement => {
|
||||
const idx = eatToken("service");
|
||||
let [name] = eatText();
|
||||
eatToken("{");
|
||||
const matches: MatchStatement[] = [];
|
||||
while (currentToken.value === "match") {
|
||||
matches.push(parseMatchStatement());
|
||||
}
|
||||
eatToken("}");
|
||||
|
||||
return {
|
||||
type: "service",
|
||||
name: name,
|
||||
idx,
|
||||
matches,
|
||||
};
|
||||
};
|
||||
|
||||
const nodes: ServiceStatement[] = [];
|
||||
while (currentToken) {
|
||||
nodes.push(parseServiceStatement());
|
||||
}
|
||||
return nodes;
|
||||
}
|
||||
@ -1,98 +0,0 @@
|
||||
export type TokenTypes =
|
||||
| "space"
|
||||
| "comment"
|
||||
| "string"
|
||||
| "keyword"
|
||||
| "colon"
|
||||
| "semicolon"
|
||||
| "comma"
|
||||
| "comparison_operator"
|
||||
| "logic_operator"
|
||||
| "equals"
|
||||
| "slash"
|
||||
| "bracket_open"
|
||||
| "bracket_close"
|
||||
| "curly_open"
|
||||
| "curly_close"
|
||||
| "array"
|
||||
| "questionmark"
|
||||
| "number"
|
||||
| "text";
|
||||
|
||||
export type Token = {
|
||||
type: TokenTypes;
|
||||
value: string;
|
||||
startIdx: number;
|
||||
endIdx: number;
|
||||
};
|
||||
|
||||
type Matcher = (input: string, index: number) => undefined | Token;
|
||||
|
||||
export class TokenizerError extends Error {
|
||||
index: number;
|
||||
constructor(message: string, index: number) {
|
||||
super(message);
|
||||
this.index = index;
|
||||
}
|
||||
}
|
||||
|
||||
function regexMatcher(regex: string | RegExp, type: TokenTypes): Matcher {
|
||||
if (typeof regex === "string") regex = new RegExp(regex);
|
||||
|
||||
return (input: string, index: number) => {
|
||||
let matches = input.substring(index).match(regex as RegExp);
|
||||
if (!matches || matches.length <= 0) return undefined;
|
||||
|
||||
return {
|
||||
type,
|
||||
value: matches[0],
|
||||
startIdx: index,
|
||||
endIdx: index + matches[0].length,
|
||||
} as Token;
|
||||
};
|
||||
}
|
||||
|
||||
const matcher = [
|
||||
regexMatcher(/^\s+/, "space"),
|
||||
regexMatcher(/^\/\/.+/, "comment"),
|
||||
regexMatcher(/^#.+/, "comment"),
|
||||
regexMatcher(/^".*?"/, "string"),
|
||||
// regexMatcher(/(?<=^")(.*?)(?=")/, "string"),
|
||||
regexMatcher(/^(service|match|allow|if|true|false|null)/, "keyword"),
|
||||
regexMatcher(/^\:/, "colon"),
|
||||
regexMatcher(/^\;/, "semicolon"),
|
||||
regexMatcher(/^\,/, "comma"),
|
||||
regexMatcher(/^(\=\=|\!\=|\<\=|\>\=|\>|\<)/, "comparison_operator"),
|
||||
regexMatcher(/^(&&|\|\|)/, "logic_operator"),
|
||||
regexMatcher(/^\=/, "equals"),
|
||||
regexMatcher(/^\//, "slash"),
|
||||
regexMatcher(/^\(/, "bracket_open"),
|
||||
regexMatcher(/^\)/, "bracket_close"),
|
||||
regexMatcher(/^{/, "curly_open"),
|
||||
regexMatcher(/^}/, "curly_close"),
|
||||
regexMatcher(/^\[\]/, "array"),
|
||||
regexMatcher(/^\?/, "questionmark"),
|
||||
regexMatcher(/^[0-9]+(\.[0-9]+)?/, "number"),
|
||||
regexMatcher(/^[a-zA-Z_\*]([a-zA-Z0-9_\.\*]?)+/, "text"),
|
||||
];
|
||||
|
||||
export default function tokenize(input: string) {
|
||||
let index = 0;
|
||||
let tokens: Token[] = [];
|
||||
while (index < input.length) {
|
||||
const matches = matcher.map((m) => m(input, index)).filter((e) => !!e);
|
||||
let match = matches[0];
|
||||
if (match) {
|
||||
if (match.type !== "space" && match.type !== "comment") {
|
||||
tokens.push(match);
|
||||
}
|
||||
index += match.value.length;
|
||||
} else {
|
||||
throw new TokenizerError(
|
||||
`Unexpected token '${input.substring(index, index + 1)}'`,
|
||||
index
|
||||
);
|
||||
}
|
||||
}
|
||||
return tokens;
|
||||
}
|
||||
@ -4,53 +4,49 @@ if (!fs.existsSync("./databases/")) {
|
||||
fs.mkdirSync("./databases");
|
||||
}
|
||||
|
||||
import * as LUR from "levelup";
|
||||
import * as LDR from "leveldown";
|
||||
|
||||
const LevelUp = LUR as any;
|
||||
const LevelDown = LDR as any;
|
||||
|
||||
import type { LevelUp as LU } from "levelup";
|
||||
import type { LevelDown as LD } from "leveldown";
|
||||
import LevelUp, { LevelUp as LU } from "levelup";
|
||||
import LevelDown, { LevelDown as LD } from "leveldown";
|
||||
import { AbstractIterator } from "abstract-leveldown";
|
||||
|
||||
export type LevelDB = LU<LD, AbstractIterator<any, any>>;
|
||||
export type DBSet = { data: LevelDB; collection: LevelDB };
|
||||
export type DBSet = { data: LevelDB, collection: LevelDB };
|
||||
|
||||
const databases = new Map<string, DBSet>();
|
||||
|
||||
export function resNull(err): null {
|
||||
if (!err.notFound) throw err;
|
||||
if (!err.notFound)
|
||||
throw err;
|
||||
return null;
|
||||
}
|
||||
|
||||
async function rmRecursice(path: string) {
|
||||
if (fs.existsSync(path)) {
|
||||
await Promise.all(
|
||||
fs.readdirSync(path).map(async (file) => {
|
||||
var curPath = path + "/" + file;
|
||||
if (fs.lstatSync(curPath).isDirectory()) {
|
||||
// recurse
|
||||
await rmRecursice(curPath);
|
||||
} else {
|
||||
// delete file
|
||||
await fs.promises.unlink(curPath);
|
||||
}
|
||||
})
|
||||
);
|
||||
await Promise.all(fs.readdirSync(path).map(async (file) => {
|
||||
var curPath = path + "/" + file;
|
||||
if (fs.lstatSync(curPath).isDirectory()) { // recurse
|
||||
await rmRecursice(curPath);
|
||||
} else { // delete file
|
||||
await fs.promises.unlink(curPath);
|
||||
}
|
||||
}));
|
||||
await fs.promises.rmdir(path);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
export async function deleteLevelDB(name: string) {
|
||||
if (!name || name === "") return;
|
||||
if (!name || name === "")
|
||||
return;
|
||||
let db = databases.get(name);
|
||||
|
||||
if (db) {
|
||||
if (db.data.isOpen()) await db.data.close();
|
||||
if (db.collection.isOpen()) await db.collection.close();
|
||||
if (db.data.isOpen())
|
||||
await db.data.close()
|
||||
if (db.collection.isOpen())
|
||||
await db.collection.close()
|
||||
}
|
||||
|
||||
|
||||
//TODO make sure, that name doesn't make it possible to delete all databases :)
|
||||
await rmRecursice("./databases/" + name);
|
||||
}
|
||||
@ -64,15 +60,9 @@ export default function getLevelDB(name: string): DBSet {
|
||||
}
|
||||
|
||||
db = {
|
||||
data:
|
||||
db && db.data.isOpen()
|
||||
? db.data
|
||||
: LevelUp(LevelDown("./databases/" + name + "/data")),
|
||||
collection:
|
||||
db && db.collection.isOpen()
|
||||
? db.collection
|
||||
: LevelUp(LevelDown("./databases/" + name + "/collection")),
|
||||
};
|
||||
data: db && db.data.isOpen() ? db.data : LevelUp(LevelDown("./databases/" + name + "/data")),
|
||||
collection: db && db.collection.isOpen() ? db.collection : LevelUp(LevelDown("./databases/" + name + "/collection"))
|
||||
}
|
||||
|
||||
databases.set(name, db);
|
||||
return db;
|
||||
|
||||
@ -7,30 +7,29 @@ export default function RequestError(ctx: Context, next) {
|
||||
ctx.body = message;
|
||||
}
|
||||
|
||||
return next()
|
||||
.then(() => {
|
||||
if (ctx.status === HttpStatusCode.NOT_FOUND) {
|
||||
reply(HttpStatusCode.NOT_FOUND, "Not found");
|
||||
}
|
||||
})
|
||||
.catch((error) => {
|
||||
let message = "Internal server error";
|
||||
let status = HttpStatusCode.INTERNAL_SERVER_ERROR;
|
||||
if (typeof error === "string") {
|
||||
message = error;
|
||||
} else if (!(error instanceof HttpError)) {
|
||||
return next().then(() => {
|
||||
if (ctx.status === HttpStatusCode.NOT_FOUND) {
|
||||
reply(HttpStatusCode.NOT_FOUND, "Not found");
|
||||
}
|
||||
}).catch(error => {
|
||||
let message = "Internal server error";
|
||||
let status = HttpStatusCode.INTERNAL_SERVER_ERROR;
|
||||
if (typeof error === "string") {
|
||||
message = error;
|
||||
} else if (!(error instanceof HttpError)) {
|
||||
Logging.error(error);
|
||||
message = error.message;
|
||||
} else {
|
||||
if (error.status === HttpStatusCode.INTERNAL_SERVER_ERROR) {
|
||||
//If internal server error log whole error
|
||||
Logging.error(error);
|
||||
message = error.message;
|
||||
} else {
|
||||
if (error.status === HttpStatusCode.INTERNAL_SERVER_ERROR) {
|
||||
//If internal server error log whole error
|
||||
Logging.error(error);
|
||||
} else {
|
||||
message = error.message.split("\n", 1)[0];
|
||||
Logging.error(message);
|
||||
}
|
||||
status = error.status;
|
||||
}
|
||||
reply(status, message);
|
||||
});
|
||||
}
|
||||
else {
|
||||
message = error.message.split("\n", 1)[0];
|
||||
Logging.errorMessage(message);
|
||||
}
|
||||
status = error.status;
|
||||
}
|
||||
reply(status, message);
|
||||
})
|
||||
};
|
||||
@ -398,12 +398,6 @@ export class NoPermissionError extends HttpError {
|
||||
}
|
||||
}
|
||||
|
||||
export class UnauthorizedError extends HttpError {
|
||||
constructor(message: string) {
|
||||
super(message, HttpStatusCode.UNAUTHORIZED)
|
||||
}
|
||||
}
|
||||
|
||||
export class BadRequestError extends HttpError {
|
||||
constructor(message: string) {
|
||||
super(message, HttpStatusCode.BAD_REQUEST)
|
||||
|
||||
@ -1,30 +1,20 @@
|
||||
import { getTemplate } from "./hb";
|
||||
import getTemplate from "./hb";
|
||||
import { Context } from "vm";
|
||||
|
||||
interface IFormConfigField {
|
||||
type: "text" | "number" | "boolean" | "textarea" | "codemirror";
|
||||
type: "text" | "number" | "boolean" | "textarea";
|
||||
label: string;
|
||||
value?: string;
|
||||
disabled?: boolean;
|
||||
}
|
||||
|
||||
type IFormConfig = { [name: string]: IFormConfigField };
|
||||
type IFormConfig = { [name: string]: IFormConfigField }
|
||||
|
||||
export default function getForm(
|
||||
url: string,
|
||||
title: string,
|
||||
fieldConfig: IFormConfig
|
||||
): (ctx: Context) => void {
|
||||
let fields = Object.keys(fieldConfig).map((name) => ({
|
||||
name,
|
||||
...fieldConfig[name],
|
||||
disabled: fieldConfig.disabled ? "disabled" : "",
|
||||
}));
|
||||
export default function getForm(url: string, title: string, fieldConfig: IFormConfig): (ctx: Context) => void {
|
||||
let fields = Object.keys(fieldConfig).map(name => ({ name, ...fieldConfig[name] }))
|
||||
|
||||
return (ctx) =>
|
||||
(ctx.body = getTemplate("forms")({
|
||||
url,
|
||||
title,
|
||||
fields,
|
||||
}));
|
||||
return ctx => ctx.body = getTemplate("forms")({
|
||||
url,
|
||||
title,
|
||||
fields
|
||||
});
|
||||
}
|
||||
@ -1,7 +1,7 @@
|
||||
import * as Handlebars from "handlebars";
|
||||
import { readFileSync } from "fs";
|
||||
import config from "../../config";
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import Logging from "@hibas123/logging";
|
||||
|
||||
|
||||
function checkCondition(v1, operator, v2) {
|
||||
@ -37,22 +37,8 @@ Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {
|
||||
|
||||
|
||||
const cache = new Map<string, Handlebars.TemplateDelegate>();
|
||||
const htmlCache = new Map<string, string>();
|
||||
|
||||
export function getView(name: string) {
|
||||
let tl: string;
|
||||
if (!config.dev)
|
||||
tl = htmlCache.get(name);
|
||||
|
||||
if (!tl) {
|
||||
tl = readFileSync(`./views/${name}.html`).toString();
|
||||
htmlCache.set(name, tl);
|
||||
}
|
||||
|
||||
return tl;
|
||||
}
|
||||
|
||||
export function getTemplate(name: string) {
|
||||
export default function getTemplate(name: string) {
|
||||
let tl: Handlebars.TemplateDelegate;
|
||||
if (!config.dev)
|
||||
tl = cache.get(name);
|
||||
|
||||
@ -1,40 +1,27 @@
|
||||
import { LoggingBase } from "@hibas123/logging";
|
||||
import { FileAdapter } from "@hibas123/nodelogging";
|
||||
import { LoggingBase } from "@hibas123/nodelogging";
|
||||
import { Context } from "koa";
|
||||
import config from "../../config";
|
||||
|
||||
const route_logging = new LoggingBase({
|
||||
name: "access",
|
||||
console: config.dev,
|
||||
});
|
||||
|
||||
route_logging.addAdapter(new FileAdapter("logs/access.log"));
|
||||
|
||||
const route_logging = new LoggingBase({ name: "access", files: { errorfile: null }, console: config.dev })
|
||||
const RequestLog = async (ctx: Context, next) => {
|
||||
if (!config.access_log) return next();
|
||||
let start = process.hrtime();
|
||||
let to = false;
|
||||
let start = process.hrtime()
|
||||
let to = false
|
||||
let print = () => {
|
||||
let td = process.hrtime(start);
|
||||
let time = !to ? (td[0] * 1e3 + td[1] / 1e6).toFixed(2) : "--.--";
|
||||
let resColor = "";
|
||||
let td = process.hrtime(start)
|
||||
let time = !to ? (td[0] * 1e3 + td[1] / 1e6).toFixed(2) : "--.--"
|
||||
let resColor = ""
|
||||
let status = ctx.status;
|
||||
if (status >= 200 && status < 300) resColor = "\x1b[32m";
|
||||
//Green
|
||||
else if (status === 304 || status === 302) resColor = "\x1b[33m";
|
||||
else if (status >= 400 && status < 500) resColor = "\x1b[36m";
|
||||
//Cyan
|
||||
else if (status >= 500 && status < 600) resColor = "\x1b[31m"; //Red
|
||||
let m = ctx.method;
|
||||
while (m.length < 4) m += " ";
|
||||
let message = `${m} ${
|
||||
ctx.originalUrl.split("?", 1)[0]
|
||||
} ${resColor}${status}\x1b[0m - ${time}ms`;
|
||||
if (status >= 200 && status < 300) resColor = "\x1b[32m" //Green
|
||||
else if (status === 304 || status === 302) resColor = "\x1b[33m"
|
||||
else if (status >= 400 && status < 500) resColor = "\x1b[36m" //Cyan
|
||||
else if (status >= 500 && status < 600) resColor = "\x1b[31m" //Red
|
||||
let m = ctx.method
|
||||
while (m.length < 4) m += " "
|
||||
let message = `${m} ${ctx.originalUrl.split("?", 1)[0]} ${resColor}${status}\x1b[0m - ${time}ms`;
|
||||
route_logging.log(message);
|
||||
};
|
||||
let timeout = new Promise<void>((yes) =>
|
||||
setTimeout(() => (to = true) && yes(), 10000)
|
||||
);
|
||||
}
|
||||
let timeout = new Promise((yes) => setTimeout(() => (to = true) && yes(), 10000));
|
||||
await Promise.race([timeout, next()]);
|
||||
print();
|
||||
};
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
import { Context } from "koa";
|
||||
import { getTemplate } from "./hb";
|
||||
import getTemplate from "./hb";
|
||||
|
||||
export default function getTable(title: string, data: any[], ctx: Context) {
|
||||
let table: string[][] = [];
|
||||
|
||||
@ -2,218 +2,124 @@ import * as Router from "koa-router";
|
||||
import Settings from "../../settings";
|
||||
import getForm from "../helper/form";
|
||||
import getTable from "../helper/table";
|
||||
import {
|
||||
BadRequestError,
|
||||
NoPermissionError,
|
||||
NotFoundError,
|
||||
} from "../helper/errors";
|
||||
import { BadRequestError, NoPermissionError } from "../helper/errors";
|
||||
import { DatabaseManager } from "../../database/database";
|
||||
import { MP } from "../../database/query";
|
||||
import config from "../../config";
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import { getView } from "../helper/hb";
|
||||
import Logging from "@hibas123/logging";
|
||||
|
||||
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) => {
|
||||
//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 as string);
|
||||
if (!db) throw new BadRequestError("Database not found");
|
||||
let db = DatabaseManager.getDatabase(database);
|
||||
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,
|
||||
keyAsBuffer: false
|
||||
});
|
||||
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 }) => {
|
||||
Logging.debug("Admin Key:", key);
|
||||
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) => {
|
||||
const isFull = ctx.query.full === "true" || ctx.query.full === "1";
|
||||
let res;
|
||||
if (isFull) {
|
||||
//TODO: Better than JSON.parse / JSON.stringify
|
||||
res = Array.from(DatabaseManager.databases.entries()).map(
|
||||
([name, config]) => ({
|
||||
name,
|
||||
...JSON.parse(JSON.stringify(config)),
|
||||
})
|
||||
);
|
||||
} else {
|
||||
res = Array.from(DatabaseManager.databases.keys());
|
||||
}
|
||||
|
||||
if (ctx.query.view) {
|
||||
return getTable("Databases" + (isFull ? "" : " small"), res, ctx);
|
||||
} else {
|
||||
ctx.body = res;
|
||||
}
|
||||
}).post("/database", async (ctx) => {
|
||||
const { name, rules, publickey, accesskey, rootkey } = ctx.request.body;
|
||||
|
||||
if (!name) throw new BadRequestError("Name must be set!");
|
||||
|
||||
let db = DatabaseManager.getDatabase(name);
|
||||
if (!db) db = await DatabaseManager.addDatabase(name);
|
||||
|
||||
if (publickey) await db.setPublicKey(publickey);
|
||||
|
||||
if (rules) {
|
||||
const error = await db.setRules(rules);
|
||||
if (error) {
|
||||
ctx.status = 500;
|
||||
ctx.body = error;
|
||||
return;
|
||||
AdminRoute
|
||||
.get("/database", ctx => {
|
||||
const isFull = ctx.query.full === "true" || ctx.query.full === "1";
|
||||
let res;
|
||||
if (isFull) {
|
||||
//TODO: Better than JSON.parse / JSON.stringify
|
||||
res = Array.from(DatabaseManager.databases.entries()).map(([name, config]) => ({ name, ...(JSON.parse(JSON.stringify(config))) }));
|
||||
} else {
|
||||
res = Array.from(DatabaseManager.databases.keys());
|
||||
}
|
||||
}
|
||||
|
||||
if (accesskey) await db.setAccessKey(accesskey);
|
||||
|
||||
if (rootkey) await db.setRootKey(rootkey);
|
||||
|
||||
ctx.body = "Success";
|
||||
});
|
||||
|
||||
AdminRoute.get("/collections", async (ctx) => {
|
||||
const { database } = ctx.query;
|
||||
let db = DatabaseManager.getDatabase(database as string);
|
||||
if (!db) throw new BadRequestError("Database not found");
|
||||
|
||||
let res = await new Promise<string[]>((yes, no) => {
|
||||
const stream = db.collections.createKeyStream({
|
||||
keyAsBuffer: false,
|
||||
limit: 1000,
|
||||
});
|
||||
let res = [];
|
||||
stream.on("data", (key: string) => {
|
||||
res.push(key);
|
||||
});
|
||||
|
||||
stream.on("error", no);
|
||||
stream.on("end", () => yes(res));
|
||||
});
|
||||
|
||||
if (ctx.query.view) {
|
||||
return getTable("Databases", res, ctx);
|
||||
} else {
|
||||
ctx.body = res;
|
||||
}
|
||||
});
|
||||
|
||||
AdminRoute.get("/collections/cleanup", async (ctx) => {
|
||||
const { database } = ctx.query;
|
||||
let db = DatabaseManager.getDatabase(database as string);
|
||||
if (!db) throw new BadRequestError("Database not found");
|
||||
|
||||
let deleted = await db.runCleanup();
|
||||
if (ctx.query.view) {
|
||||
return getTable("Databases", deleted, ctx);
|
||||
} else {
|
||||
ctx.body = deleted;
|
||||
}
|
||||
});
|
||||
|
||||
AdminRoute.get(
|
||||
"/database/new",
|
||||
getForm("/v1/admin/database", "New Database", {
|
||||
name: { label: "Name", type: "text" },
|
||||
accesskey: { label: "Access Key", type: "text" },
|
||||
rootkey: { label: "Root access key", type: "text" },
|
||||
rules: {
|
||||
label: "Rules",
|
||||
type: "codemirror",
|
||||
value: `{\n ".write": true, \n ".read": true \n}`,
|
||||
},
|
||||
publickey: { label: "Public Key", type: "textarea" },
|
||||
if (ctx.query.view) {
|
||||
return getTable("Databases" + (isFull ? "" : " small"), res, ctx);
|
||||
} else {
|
||||
ctx.body = res;
|
||||
}
|
||||
})
|
||||
);
|
||||
.post("/database", async ctx => {
|
||||
const { name, rules, publickey, accesskey, rootkey } = ctx.request.body;
|
||||
|
||||
AdminRoute.get("/database/update", async (ctx) => {
|
||||
const { database } = ctx.query;
|
||||
let db = DatabaseManager.getDatabase(database as string);
|
||||
if (!db) throw new NotFoundError("Database not found!");
|
||||
getForm("/v1/admin/database", "Change Database", {
|
||||
name: {
|
||||
label: "Name",
|
||||
type: "text",
|
||||
value: db.name,
|
||||
disabled: true,
|
||||
},
|
||||
accesskey: {
|
||||
label: "Access Key",
|
||||
type: "text",
|
||||
value: db.accesskey,
|
||||
},
|
||||
rootkey: {
|
||||
label: "Root access key",
|
||||
type: "text",
|
||||
value: db.rootkey,
|
||||
},
|
||||
rules: {
|
||||
label: "Rules",
|
||||
type: "codemirror",
|
||||
value: db.rawRules,
|
||||
},
|
||||
publickey: {
|
||||
label: "Public Key",
|
||||
type: "textarea",
|
||||
value: db.publickey,
|
||||
},
|
||||
})(ctx);
|
||||
});
|
||||
if (!name)
|
||||
throw new BadRequestError("Name must be set!");
|
||||
|
||||
let db = DatabaseManager.getDatabase(name);
|
||||
if (!db)
|
||||
db = await DatabaseManager.addDatabase(name);
|
||||
|
||||
if (publickey)
|
||||
await db.setPublicKey(publickey);
|
||||
|
||||
if (rules)
|
||||
await db.setRules(rules);
|
||||
|
||||
if (accesskey)
|
||||
await db.setAccessKey(accesskey);
|
||||
|
||||
|
||||
if (rootkey)
|
||||
await db.setRootKey(rootkey);
|
||||
|
||||
|
||||
ctx.body = "Success";
|
||||
})
|
||||
|
||||
AdminRoute.get("/database/new", getForm("/v1/admin/database", "New/Change Database", {
|
||||
name: { label: "Name", type: "text", },
|
||||
accesskey: { label: "Access Key", type: "text" },
|
||||
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" }
|
||||
}))
|
||||
|
||||
export default AdminRoute;
|
||||
@ -1,63 +1,5 @@
|
||||
import * as Router from "koa-router";
|
||||
import AdminRoute from "./admin";
|
||||
import { DatabaseManager } from "../../database/database";
|
||||
import {
|
||||
NotFoundError,
|
||||
NoPermissionError,
|
||||
BadRequestError,
|
||||
} from "../helper/errors";
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import Session from "../../database/session";
|
||||
import { nanoid } from "nanoid";
|
||||
import { verifyJWT } from "../../helper/jwt";
|
||||
import { QueryError } from "../../database/query";
|
||||
const V1 = new Router({ prefix: "/v1" });
|
||||
|
||||
V1.use("/admin", AdminRoute.routes(), AdminRoute.allowedMethods());
|
||||
|
||||
V1.post("/db/:database/query", async (ctx) => {
|
||||
const { database } = ctx.params;
|
||||
const { accesskey, authkey, rootkey } = ctx.query;
|
||||
|
||||
const query = ctx.request.body;
|
||||
if (!query) {
|
||||
throw new BadRequestError("Query not defined!");
|
||||
}
|
||||
|
||||
const session = new Session(nanoid());
|
||||
const db = DatabaseManager.getDatabase(database);
|
||||
if (!db) {
|
||||
throw new NotFoundError("Database not found!");
|
||||
}
|
||||
|
||||
if (db.accesskey) {
|
||||
if (!accesskey || accesskey !== db.accesskey) {
|
||||
throw new NoPermissionError("Invalid Access Key");
|
||||
}
|
||||
}
|
||||
|
||||
if (authkey && db.publickey) {
|
||||
let res = await verifyJWT(authkey as string, db.publickey);
|
||||
if (res && !res.uid && res.user) res.uid = res.user;
|
||||
if (!res || !res.uid) {
|
||||
throw new BadRequestError("Invalid JWT");
|
||||
} else {
|
||||
session.uid = res.uid;
|
||||
}
|
||||
}
|
||||
|
||||
if (rootkey && db.rootkey) {
|
||||
if (rootkey === db.rootkey) {
|
||||
session.root = true;
|
||||
Logging.warning(`Somebody logged into ${database} via rootkey`);
|
||||
}
|
||||
}
|
||||
|
||||
ctx.body = await db.run([query], session).catch((err) => {
|
||||
if (err instanceof QueryError) {
|
||||
throw new BadRequestError(err.message);
|
||||
}
|
||||
throw err;
|
||||
});
|
||||
});
|
||||
export default V1;
|
||||
163
src/websocket.ts
163
src/websocket.ts
@ -1,163 +0,0 @@
|
||||
import Logging from "@hibas123/nodelogging";
|
||||
import { IncomingMessage, Server } from "http";
|
||||
import * as WebSocket from "ws";
|
||||
import { DatabaseManager } from "./database/database";
|
||||
import {
|
||||
CollectionQuery,
|
||||
DocumentQuery,
|
||||
IQuery,
|
||||
ITypedQuery,
|
||||
} from "./database/query";
|
||||
import Session from "./database/session";
|
||||
import { verifyJWT } from "./helper/jwt";
|
||||
import { nanoid } from "nanoid";
|
||||
|
||||
export class WebsocketConnectionManager {
|
||||
static server: WebSocket.Server;
|
||||
|
||||
static bind(server: Server) {
|
||||
this.server = new WebSocket.Server({ server });
|
||||
this.server.on("connection", this.onConnection.bind(this));
|
||||
}
|
||||
|
||||
private static async onConnection(socket: WebSocket, req: IncomingMessage) {
|
||||
Logging.log("New Connection:");
|
||||
|
||||
socket.on("error", (err) => {
|
||||
Logging.error(err);
|
||||
socket.close();
|
||||
});
|
||||
|
||||
const sendError = (error: string) =>
|
||||
socket.send(JSON.stringify({ ns: "error_msg", data: error }));
|
||||
|
||||
const session = new Session(nanoid());
|
||||
|
||||
const query = new URL(req.url, "http://localhost").searchParams;
|
||||
|
||||
const database = query.get("database");
|
||||
const db = DatabaseManager.getDatabase(database);
|
||||
if (!db) {
|
||||
sendError("Invalid Database!");
|
||||
socket.close();
|
||||
return;
|
||||
}
|
||||
|
||||
const accesskey = query.get("accesskey");
|
||||
if (db.accesskey) {
|
||||
if (!accesskey || accesskey !== db.accesskey) {
|
||||
sendError("Unauthorized!");
|
||||
socket.close();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const authkey = query.get("authkey");
|
||||
if (authkey && db.publickey) {
|
||||
let res = await verifyJWT(authkey, db.publickey);
|
||||
if (res && !res.uid && res.user) res.uid = res.user;
|
||||
if (!res || !res.uid) {
|
||||
sendError("Invalid JWT");
|
||||
socket.close();
|
||||
return;
|
||||
} else {
|
||||
session.uid = res.uid;
|
||||
}
|
||||
}
|
||||
|
||||
const rootkey = query.get("rootkey");
|
||||
if (rootkey && db.rootkey) {
|
||||
if (rootkey === db.rootkey) {
|
||||
session.root = true;
|
||||
Logging.warning(`Somebody logged into ${database} via rootkey`);
|
||||
}
|
||||
}
|
||||
|
||||
const answer = (id: string, data: any, err?: Error | string) => {
|
||||
let error = false;
|
||||
if (err) {
|
||||
Logging.error(err);
|
||||
if (err instanceof Error) {
|
||||
data = err.message;
|
||||
} else {
|
||||
data = err;
|
||||
}
|
||||
|
||||
error = true;
|
||||
}
|
||||
socket.send(
|
||||
JSON.stringify({ ns: "message", data: { id, error, data } })
|
||||
);
|
||||
};
|
||||
|
||||
const handler = new Map<string, (data: any) => void>();
|
||||
|
||||
handler.set("v2", async ({ id, query }) =>
|
||||
db
|
||||
.run(Array.isArray(query) ? query : [query], session)
|
||||
.then((res) => answer(id, res))
|
||||
.catch((err) => answer(id, undefined, err))
|
||||
);
|
||||
|
||||
// handler.set("bulk", async ({ id, query }) => db.run(query, session)
|
||||
// .then(res => answer(id, res))
|
||||
// .catch(err => answer(id, undefined, err))
|
||||
// );
|
||||
|
||||
const SnapshotMap = new Map<string, string>();
|
||||
handler.set(
|
||||
"snapshot",
|
||||
async ({
|
||||
id,
|
||||
query,
|
||||
}: {
|
||||
id: string;
|
||||
query: ITypedQuery<"snapshot">;
|
||||
}) => {
|
||||
db.snapshot(query, session, (data) => {
|
||||
Logging.debug("Sending snapshot");
|
||||
socket.send(
|
||||
JSON.stringify({
|
||||
ns: "snapshot",
|
||||
data: { id, data },
|
||||
})
|
||||
);
|
||||
})
|
||||
.then((s) => {
|
||||
answer(id, s.snaphot);
|
||||
SnapshotMap.set(id, s.id);
|
||||
})
|
||||
.catch((err) => answer(id, undefined, err));
|
||||
}
|
||||
);
|
||||
|
||||
handler.set("unsubscribe", async ({ id }) => {
|
||||
let i = SnapshotMap.get(id);
|
||||
if (i) {
|
||||
db.unsubscribe(i, session);
|
||||
SnapshotMap.delete(i);
|
||||
}
|
||||
});
|
||||
|
||||
socket.on("message", async (rawData: string) => {
|
||||
try {
|
||||
let message: { ns: string; data: any } = JSON.parse(rawData);
|
||||
let h = handler.get(message.ns);
|
||||
if (h) {
|
||||
h(message.data);
|
||||
}
|
||||
} catch (err) {
|
||||
Logging.error("Unknown Error:");
|
||||
Logging.error(err);
|
||||
}
|
||||
});
|
||||
db.connections++;
|
||||
socket.on("close", () => {
|
||||
db.connections--;
|
||||
Logging.log(`${session.id} has disconnected!`);
|
||||
session.subscriptions.forEach((unsubscribe) => unsubscribe());
|
||||
session.subscriptions.clear();
|
||||
socket.removeAllListeners();
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -1,17 +1,21 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
/* Basic 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. */,
|
||||
"resolveJsonModule": true
|
||||
},
|
||||
"exclude": ["node_modules/"],
|
||||
"include": ["./src"]
|
||||
"compilerOptions": {
|
||||
/* Basic Options */
|
||||
"target": "es2017", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */
|
||||
"module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */
|
||||
"declaration": true, /* Generates corresponding '.d.ts' file. */
|
||||
"sourceMap": true, /* Generates corresponding '.map' file. */
|
||||
"outDir": "./lib", /* Redirect output structure to the directory. */
|
||||
"strict": false, /* Enable all strict type-checking options. */
|
||||
"preserveWatchOutput": true,
|
||||
"experimentalDecorators": true, /* Enables experimental support for ES7 decorators. */
|
||||
"emitDecoratorMetadata": true, /* Enables experimental support for emitting type metadata for decorators. */
|
||||
"resolveJsonModule": true
|
||||
},
|
||||
"exclude": [
|
||||
"node_modules/"
|
||||
],
|
||||
"include": [
|
||||
"./src"
|
||||
]
|
||||
}
|
||||
125
views/admin.html
125
views/admin.html
@ -1,125 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
|
||||
<title>Admin Interface</title>
|
||||
<link
|
||||
rel="stylesheet"
|
||||
href="https://unpkg.com/@hibas123/theme@1/out/base.css"
|
||||
/>
|
||||
<link
|
||||
rel="stylesheet"
|
||||
href="https://unpkg.com/@hibas123/theme@1/out/light.css"
|
||||
/>
|
||||
|
||||
<script src="https://unpkg.com/handlebars/dist/handlebars.min.js"></script>
|
||||
|
||||
<style>
|
||||
#message {
|
||||
visibility: hidden;
|
||||
background-color: lightgreen;
|
||||
border: 1px solid lime;
|
||||
border-radius: 0.5rem;
|
||||
padding: 1rem;
|
||||
font-size: 1.5rem;
|
||||
margin-bottom: 1rem;
|
||||
}
|
||||
|
||||
.grid {
|
||||
display: grid;
|
||||
height: 100vh;
|
||||
grid-template-columns: 360px auto;
|
||||
}
|
||||
|
||||
#navigation {
|
||||
height: 100vh;
|
||||
overflow: auto;
|
||||
border-right: 1px solid darkgrey;
|
||||
padding: 1rem;
|
||||
}
|
||||
|
||||
#content {
|
||||
position: absolute;
|
||||
top: 0;
|
||||
left: 0;
|
||||
width: 100%;
|
||||
height: 100vh;
|
||||
border: 0;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div class="grid">
|
||||
<div id="navigation">
|
||||
<h2>Navigation:</h2>
|
||||
<ul class="list list-clickable">
|
||||
<li onclick="loadView('settings');">Settings</li>
|
||||
<li onclick="loadView('database', {full:true});">Databases</li>
|
||||
<li onclick="loadView('database/new');">New Database</li>
|
||||
</ul>
|
||||
Databases:
|
||||
<div
|
||||
id="dbs"
|
||||
class="list list-clickable"
|
||||
style="margin: 1rem"
|
||||
></div>
|
||||
</div>
|
||||
<div style="position: relative">
|
||||
<iframe id="content"></iframe>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<template> </template>
|
||||
|
||||
<script>
|
||||
const key = new URL(window.location.href).searchParams.get("key");
|
||||
const content = document.getElementById("content");
|
||||
const base = new URL(window.location.href).host;
|
||||
|
||||
function getUrl(name, params, view = true) {
|
||||
const url = new URL(window.location.href);
|
||||
url.pathname = "/v1/admin/" + name;
|
||||
for (let key in params || {})
|
||||
url.searchParams.set(key, params[key]);
|
||||
|
||||
url.searchParams.set("key", key);
|
||||
if (view) url.searchParams.set("view", "true");
|
||||
|
||||
return url.href;
|
||||
}
|
||||
|
||||
function loadView(name, params) {
|
||||
content.src = getUrl(name, params);
|
||||
}
|
||||
|
||||
loadView("settings");
|
||||
|
||||
const dbsul = document.getElementById("dbs");
|
||||
function reloadDBs() {
|
||||
fetch(getUrl("database", {}, false))
|
||||
.then((res) => res.json())
|
||||
.then((databases) =>
|
||||
databases.map(
|
||||
(database) => `
|
||||
<div class="card margin elv-4">
|
||||
<h3>${database}</h3>
|
||||
<button class=btn onclick="loadView('data', {database:'${database}'})">Data</button>
|
||||
<button class=btn onclick="loadView('collections', {database:'${database}'})">Collections</button>
|
||||
<button class=btn onclick="loadView('database/update', {database:'${database}'})">Change</button>
|
||||
<button class=btn onclick="loadView('collections/cleanup', {database:'${database}'})">Clean</button>
|
||||
</div>`
|
||||
)
|
||||
)
|
||||
.then((d) => d.join("\n"))
|
||||
.then((d) => (dbsul.innerHTML = d))
|
||||
.catch(console.error);
|
||||
}
|
||||
|
||||
reloadDBs();
|
||||
setInterval(reloadDBs, 5000);
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@ -6,9 +6,8 @@
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<meta http-equiv="X-UA-Compatible" content="ie=edge">
|
||||
<title>{{title}}</title>
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/base.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/light.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/codemirror@5.58.2/lib/codemirror.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
|
||||
|
||||
<style>
|
||||
#message {
|
||||
@ -33,23 +32,19 @@
|
||||
<div class="input-group">
|
||||
<label>{{label}}</label>
|
||||
{{#ifCond type "===" "text"}}
|
||||
<input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
|
||||
<input type="text" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
|
||||
{{/ifCond}}
|
||||
|
||||
{{#ifCond type "===" "number"}}
|
||||
<input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" {{disabled}} />
|
||||
<input type="number" placeholder="{{label}}" name="{{name}}" value="{{value}}" />
|
||||
{{/ifCond}}
|
||||
|
||||
{{#ifCond type "===" "boolean"}}
|
||||
<input type="checkbox" name="{{name}}" checked="{{value}}" {{disabled}} />
|
||||
<input type="checkbox" name="{{name}}" checked="{{value}}" />
|
||||
{{/ifCond}}
|
||||
|
||||
{{#ifCond type "===" "textarea"}}
|
||||
<textarea class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
|
||||
{{/ifCond}}
|
||||
|
||||
{{#ifCond type "===" "codemirror"}}
|
||||
<textarea codemirror class="inp" name="{{name}}" rows="20" {{disabled}}>{{value}}</textarea>
|
||||
<textarea class="inp" name="{{name}}" rows="20">{{value}}</textarea>
|
||||
{{/ifCond}}
|
||||
</div>
|
||||
{{/each}}
|
||||
@ -86,19 +81,6 @@
|
||||
return false;
|
||||
}
|
||||
</script>
|
||||
|
||||
<script src="https://unpkg.com/codemirror@5.58.2/lib/codemirror.js"></script>
|
||||
<script>
|
||||
document.querySelectorAll("textarea[codemirror]").forEach(elm => {
|
||||
const cm = CodeMirror.fromTextArea(elm, {
|
||||
lineNumbers: true,
|
||||
indentUnit: 3,
|
||||
tabSize: 3,
|
||||
})
|
||||
|
||||
cm.on("change", () => cm.save())
|
||||
})
|
||||
</script>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
@ -6,8 +6,8 @@
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<meta http-equiv="X-UA-Compatible" content="ie=edge">
|
||||
<title>{{title}}</title>
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/base.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme@1/out/light.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/base.css">
|
||||
<link rel="stylesheet" href="https://unpkg.com/@hibas123/theme/out/light.css">
|
||||
|
||||
<style>
|
||||
table {
|
||||
@ -37,18 +37,18 @@
|
||||
<div class="margin" style="margin-top: 4rem;">
|
||||
<h1>{{title}}</h1>
|
||||
{{#if empty}}
|
||||
<h3>No Data available!</h3>
|
||||
<h3>No Data available!</h3>
|
||||
{{else}}
|
||||
|
||||
<table style="overflow-x: auto">
|
||||
{{#each table as |row|}}
|
||||
<tr>
|
||||
{{#each row as |col|}}
|
||||
<td>{{col}}</td>
|
||||
<table style="overflow-x: auto">
|
||||
{{#each table as |row|}}
|
||||
<tr>
|
||||
{{#each row as |col|}}
|
||||
<td>{{col}}</td>
|
||||
{{/each}}
|
||||
</tr>
|
||||
{{/each}}
|
||||
</tr>
|
||||
{{/each}}
|
||||
</table>
|
||||
</table>
|
||||
{{/if}}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user