sedentary 0.1.0 → 0.1.1

package/dist/cjs/db.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = exports.DB = exports.Table = exports.Attribute = exports.Type = exports.EntryBase = exports.transaction = exports.size = exports.loaded = exports.base = exports.actions = void 0;
+exports.deepCopy = deepCopy;
+exports.deepDiff = deepDiff;
+exports.actions = Symbol("actions");
+exports.base = Symbol("base");
+exports.loaded = Symbol("loaded");
+exports.size = Symbol("size");
+exports.transaction = Symbol("transaction");
+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() { }
+    remove() {
+        return Promise.resolve(false);
+    }
+    save() {
+        return Promise.resolve(false);
+    }
+}
+exports.EntryBase = EntryBase;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class Type {
+    constructor(from) {
+        Object.assign(this, from);
+    }
+}
+exports.Type = Type;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+class Attribute extends Type {
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(from) {
+        super(from);
+    }
+}
+exports.Attribute = Attribute;
+function autoImplement() {
+    return class {
+        constructor(defaults) {
+            Object.assign(this, defaults);
+        }
+    };
+}
+class Table extends autoImplement() {
+    findAttribute(name) {
+        return this.attributes.find(_ => _.attributeName === name);
+    }
+    findField(name) {
+        return this.attributes.find(_ => _.fieldName === name);
+    }
+}
+exports.Table = Table;
+class DB {
+    constructor(log) {
+        this.tables = [];
+        this.sync = true;
+        this.log = log;
+    }
+    findTable(name) {
+        return this.tables.find(_ => _.tableName === name);
+    }
+    indexesEq(a, b) {
+        if (a.fields.length !== b.fields.length)
+            return false;
+        for (let i = 0; i < a.fields.length; ++i)
+            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, exports.transaction, { 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, exports.transaction, { configurable: true, value: undefined });
+        }
+        this.entries = [];
+    }
+    commit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.postCommit(entry[exports.actions]);
+        this.clean();
+        return Promise.resolve();
+    }
+    preCommit() {
+        const { entries } = this;
+        for (const entry of entries)
+            if (entry[exports.actions])
+                entry.preCommit(entry[exports.actions]);
+    }
+    rollback() {
+        this.clean();
+        return Promise.resolve();
+    }
+}
+exports.Transaction = Transaction;
+const sortedEntries = (obj) => Object.entries(obj).sort((entryA, entryB) => (entryA[0] > entryB[0] ? -1 : 1));
+function deepCopy(o) {
+    if (!o || typeof o !== "object")
+        return o;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const [ret, entries] = o instanceof Array ? [new Array(o.length), o.entries()] : [{}, Object.entries(o)];
+    for (const [k, v] of entries)
+        ret[k] = deepCopy(v);
+    return ret;
+}
+function deepDiff(a, b) {
+    if (typeof a !== "object")
+        return a !== b;
+    if (typeof b !== "object")
+        return true;
+    if (a === null)
+        return b !== null;
+    if (b === null)
+        return true;
+    if (a instanceof Array) {
+        if (!(b instanceof Array))
+            return true;
+        for (const [i, value] of a.entries())
+            if (deepDiff(value, b[i]))
+                return true;
+        return false;
+    }
+    const entriesA = sortedEntries(a);
+    const entriesB = sortedEntries(b);
+    if (entriesA.length !== entriesB.length)
+        return true;
+    for (const [i, [key, value]] of entriesA.entries())
+        if (key !== entriesB[i][0] || deepDiff(value, entriesB[i][1]))
+            return true;
+    return false;
+}