Initial code implementation

Author: tobiemh

Diff for: mod.ts

@@ -0,0 +1 @@
+export { default } from "./src/mod.ts";

Diff for: src/classes/emitter.ts

@@ -0,0 +1,48 @@
+export default class Emitter {
+
+	#events = {};
+
+	on(e, func) {
+		if (typeof this.#events[e] !== "object") {
+			this.#events[e] = [];
+		}
+		this.#events[e].push(func);
+	}
+
+	off(e, func) {
+		if (typeof this.#events[e] === "object") {
+			const idx = this.#events[e].indexOf(func);
+			if (idx > -1) {
+				this.#events[e].splice(idx, 1);
+			}
+		}
+	}
+
+	once(e, func) {
+		this.on(e, function f(...args) {
+			this.off(e, f);
+			func.apply(this, args);
+		});
+	}
+
+	emit(e, ...args) {
+		if (typeof this.#events[e] === "object") {
+			this.#events[e].forEach(func => {
+				func.apply(this, args);
+			});
+		}
+	}
+
+	removeAllListeners(e) {
+		if (e) {
+			if (typeof this.#events[e] === "object") {
+				this.#events[e] = [];
+			}
+		} else {
+			for (const e in this.#events) {
+				this.#events[e] = [];
+			}
+		}
+	}
+
+}

Diff for: src/classes/live.ts

@@ -0,0 +1,83 @@
+import Emitter from "./emitter.ts";
+
+export default class Live extends Emitter {
+
+	#id = undefined;
+
+	#db = undefined;
+
+	#sql = undefined;
+
+	#vars = undefined;
+
+	constructor(db, sql, vars) {
+
+		super()
+
+		this.#db = db;
+
+		this.#sql = sql;
+
+		this.#vars = vars;
+
+		if (this.#db.ready) {
+			this.open();
+		}
+
+		this.#db.on("opened", e => {
+			this.open();
+		});
+
+		this.#db.on("closed", e => {
+			this.#id = undefined;
+		});
+
+		this.#db.on("notify", e => {
+			if (e.query === this.#id) {
+				switch (e.action) {
+				case "CREATE":
+					return this.emit("create", e.result);
+				case "UPDATE":
+					return this.emit("update", e.result);
+				case "DELETE":
+					return this.emit("delete", e.result);
+				}
+			}
+		});
+
+	}
+
+	// If we want to kill the live query
+	// then we can kill it. Once a query
+	// has been killed it can be opened
+	// again by calling the open() method.
+
+	kill() {
+
+		if (this.#id === undefined) return;
+
+		let res = this.#db.kill(this.#id);
+
+		this.#id = undefined;
+
+		return res;
+
+	}
+
+	// If the live query has been manually
+	// killed, then calling the open()
+	// method will re-enable the query.
+
+	open() {
+
+		if (this.#id !== undefined) return;
+
+		return this.#db.query(this.#sql, this.#vars).then(res => {
+			if (res[0] && res[0].result && res[0].result[0]) {
+				this.#id = res[0].result[0];
+			}
+		});
+
+	}
+
+}

Diff for: src/classes/pinger.ts

@@ -0,0 +1,19 @@
+export default class Pinger {
+
+	#pinger = undefined;
+
+	#interval = undefined;
+
+	constructor(interval = 30000) {
+		this.#interval = interval;
+	}
+
+	start(func, ...args) {
+		this.#pinger = setInterval(func, this.#interval);
+	}
+
+	stop() {
+		clearInterval(this.#pinger);
+	}
+
+}

Diff for: src/classes/socket.ts

@@ -0,0 +1,114 @@
+import Emitter from "./emitter.ts";
+
+const OPENED = Symbol("Opened");
+const CLOSED = Symbol("Closed");
+
+export default class Socket extends Emitter {
+
+	#ws = null;
+
+	#url = null;
+
+	#closed = false;
+
+	#status = CLOSED;
+
+	constructor(url) {
+
+		super();
+
+		this.#init();
+
+		this.#url = String(url)
+			.replace("http://", "ws://")
+			.replace("https://", "wss://")
+		;
+
+	}
+
+	#init() {
+
+		this.ready = new Promise(resolve => {
+			this.resolve = resolve;
+		});
+
+	}
+
+	open() {
+
+		this.#ws = new WebSocket(this.#url);
+
+		// Setup event listeners so that the
+		// Surreal instance can listen to the
+		// necessary event types.
+
+		this.#ws.addEventListener("message", (e) => {
+			this.emit("message", e);
+		});
+
+		this.#ws.addEventListener("error", (e) => {
+			this.emit("error", e);
+		});
+
+		this.#ws.addEventListener("close", (e) => {
+			this.emit("close", e);
+		});
+
+		this.#ws.addEventListener("open", (e) => {
+			this.emit("open", e);
+		});
+
+		// If the WebSocket connection with the
+		// database was disconnected, then we need
+		// to reset the ready promise.
+
+		this.#ws.addEventListener("close", (e) => {
+			if (this.#status === OPENED) {
+				this.#init();
+			}
+		});
+
+		// When the WebSocket is opened or closed
+		// then we need to store the connection
+		// status within the status property.
+
+		this.#ws.addEventListener("close", (e) => {
+			this.#status = CLOSED;
+		});
+
+		this.#ws.addEventListener("open", (e) => {
+			this.#status = OPENED;
+		});
+
+		// If the connection is closed, then we
+		// need to attempt to reconnect on a
+		// regular basis until we are successful.
+
+		this.#ws.addEventListener("close", (e) => {
+			if (this.#closed === false) {
+				setTimeout( () => {
+					this.open();
+				}, 2500);
+			}
+		});
+
+		// When the WebSocket successfully opens
+		// then let's resolve the ready promise so
+		// that promise based code can continue.
+
+		this.#ws.addEventListener("open", (e) => {
+			this.resolve();
+		});
+
+	}
+
+	send(data) {
+		this.#ws.send(data);
+	}
+
+	close(code=1000, reason="Some reason") {
+		this.#closed = true;
+		this.#ws.close(code, reason);
+	}
+
+}

Diff for: src/errors/mod.ts

@@ -0,0 +1,26 @@
+export class AuthenticationError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AuthenticationError";
+	}
+}
+
+export class PermissionError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PermissionError";
+	}
+}
+
+export class RecordError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RecordError";
+	}
+}
+
+export default {
+	AuthenticationError: AuthenticationError,
+	PermissionError: PermissionError,
+	RecordError: RecordError,
+}