sedentary 0.0.43 → 0.0.46

package/dist/cjs/db.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.loaded = exports.actions = void 0;
+exports.actions = Symbol("actions");
+exports.loaded = Symbol("loaded");
+class EntryBase {
+    constructor(from) {
+        if (from === "load")
+            this.preLoad();
+        else {
+            if (from)
+                Object.assign(this, from);
+            this.construct();
+        }
+    }
+    construct() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postCommit(actions) { }
+    postLoad() { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postRemove(deletedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    postSave(savedRecords) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preCommit(actions) { }
+    preLoad() { }
+    preRemove() { }
+    preSave() { }
+    async remove() {
+        return false;
+    }
+    async save() {
+        return false;
+    }
+}
+exports.EntryBase = EntryBase;
+class Type {
+    constructor(from) {
+        Object.assign(this, from);
+    }
+}
+exports.Type = Type;
+class Attribute extends Type {
+    constructor(from) {
+        super(from);
+    }
+}
+exports.Attribute = Attribute;
+function autoImplement() {
+    return class {
+        constructor(defaults) {
+            Object.assign(this, defaults);
+        }
+    };
+}
+class Table extends autoImplement() {
+    findField(name) {
+        return this.attributes.filter(_ => _.fieldName === name)[0];
+    }
+}
+exports.Table = Table;
+class DB {
+    constructor(log) {
+        this.tables = [];
+        this.sync = true;
+        this.log = log;
+    }
+    findTable(name) {
+        return this.tables.filter(_ => _.tableName === name)[0];
+    }
+    indexesEq(a, b) {
+        if (a.fields.length !== b.fields.length)
+            return false;
+        for (const i in a.fields)
+            if (a.fields[i] !== b.fields[i])
+                return false;
+        if (a.type !== b.type)
+            return false;
+        if (a.unique !== b.unique)
+            return false;
+        return true;
+    }
+    async syncDataBase() {
+        for (const table of this.tables) {
+            this.sync = table.sync;
+            await this.syncTable(table);
+            const indexes = await this.dropConstraints(table);
+            await this.dropIndexes(table, indexes);
+            await this.dropFields(table);
+            await this.syncFields(table);
+            await this.syncSequence(table);
+            await this.syncConstraints(table);
+            await this.syncIndexes(table);
+        }
+    }
+    syncLog(message) {
+        this.log(this.sync ? message : "NOT SYNCING: " + message);
+    }
+}
+exports.DB = DB;
+class Transaction {
+    constructor(log) {
+        this.entries = [];
+        this.log = log;
+    }
+    addEntry(entry) {
+        Object.defineProperty(entry, "tx", { configurable: true, value: this });
+        this.entries.push(entry);
+    }
+    clean() {
+        const { entries } = this;
+        for (const entry of entries) {
+            Object.defineProperty(entry, exports.actions, { configurable: true, value: undefined });
+            Object.defineProperty(entry, "tx", { configurable: true, value: undefined });
+        }
+        this.entries = [];
+    }
+    async commit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.postCommit(entry[exports.actions]);
+        this.clean();
+    }
+    preCommit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.preCommit(entry[exports.actions]);
+    }
+    async rollback() {
+        this.clean();
+    }
+}
+exports.Transaction = Transaction;