@iamkirbki/database-handler-core 4.4.3 → 4.4.4

package/dist/runtime/Repository.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import Table from "../base/Table.js";
 class Repository {
     constructor(tableName, ModelClass, customDatabaseAdapter, tableFactory = (name, adapter) => new Table(name, adapter)) {
@@ -40,38 +31,30 @@ class Repository {
             [relation.pivotForeignKey]: isLocal ? modelOfOrigin.values[relation.foreignKey] : foreignKey
         };
     }
-    insertRecordIntoPivotTable(foreignKey, modelOfOrigin, relation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
-            yield table.Insert(this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation));
-        });
+    async insertRecordIntoPivotTable(foreignKey, modelOfOrigin, relation) {
+        const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
+        await table.Insert(this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation));
     }
-    deleteRecordFromPivotTable(foreignKey, modelOfOrigin, relation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
-            const record = yield table.Record({ base: { where: this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation) } });
-            yield (record === null || record === void 0 ? void 0 : record.Delete());
-        });
+    async deleteRecordFromPivotTable(foreignKey, modelOfOrigin, relation) {
+        const table = this.tableFactory(relation.pivotTable, this.customDatabaseAdapter);
+        const record = await table.Record({ base: { where: this.generatePivotTableKeys(foreignKey, modelOfOrigin, relation) } });
+        await (record === null || record === void 0 ? void 0 : record.Delete());
     }
-    getManyToManyRelation(relation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (relation.pivotTable && this.manyToManyRelations.has(relation.pivotTable)) {
-                return this.manyToManyRelations.get(relation.pivotTable);
-            }
-            if (yield this.doesTableExist(relation.pivotTable)) {
-                this.manyToManyRelations.set(relation.pivotTable, relation);
-                return relation;
-            }
-            else {
-                throw new Error(`Pivot table ${relation.pivotTable} does not exist. Create it in alphabetical order before using many-to-many relationships.`);
-            }
-        });
+    async getManyToManyRelation(relation) {
+        if (relation.pivotTable && this.manyToManyRelations.has(relation.pivotTable)) {
+            return this.manyToManyRelations.get(relation.pivotTable);
+        }
+        if (await this.doesTableExist(relation.pivotTable)) {
+            this.manyToManyRelations.set(relation.pivotTable, relation);
+            return relation;
+        }
+        else {
+            throw new Error(`Pivot table ${relation.pivotTable} does not exist. Create it in alphabetical order before using many-to-many relationships.`);
+        }
     }
-    doesTableExist(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const table = this.tableFactory(name, this.customDatabaseAdapter);
-            return yield table.exists();
-        });
+    async doesTableExist(name) {
+        const table = this.tableFactory(name, this.customDatabaseAdapter);
+        return await table.exists();
     }
     syncModel(model) {
         var _a;
@@ -81,70 +64,63 @@ class Repository {
     getModel(name) {
         return this.models.get(name);
     }
-    save(attributes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.Table.Insert(attributes);
-        });
-    }
-    first(queryLayers, Model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record;
-            if (Model.JoinedEntities.length > 0) {
-                const result = (yield this.join(Model, Object.assign(Object.assign({}, queryLayers), { final: Object.assign(Object.assign({}, queryLayers.final), { limit: 1 }) })))[0];
-                record = result ? { values: result } : undefined;
-            }
-            else {
-                record = yield this.Table.Record(queryLayers);
-            }
-            return record === null || record === void 0 ? void 0 : record.values;
-        });
+    async save(attributes) {
+        await this.Table.Insert(attributes);
     }
-    get(QueryLayers, Model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (Model.JoinedEntities.length > 0) {
-                return yield this.join(Model, QueryLayers);
-            }
-            else {
-                const records = yield this.Table.Records(QueryLayers);
-                return records.map(record => record.values);
-            }
-        });
+    async first(queryLayers, Model) {
+        let record;
+        if (Model.JoinedEntities.length > 0) {
+            const result = (await this.join(Model, { ...queryLayers, final: { ...queryLayers.final, limit: 1 } }))[0];
+            record = result ? { values: result } : undefined;
+        }
+        else {
+            record = await this.Table.Record(queryLayers);
+        }
+        return record === null || record === void 0 ? void 0 : record.values;
     }
-    all(Model, QueryLayers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.get(QueryLayers, Model);
-        });
+    async get(QueryLayers, Model) {
+        if (Model.JoinedEntities.length > 0) {
+            return await this.join(Model, QueryLayers);
+        }
+        else {
+            const records = await this.Table.Records(QueryLayers);
+            return records.map(record => record.values);
+        }
     }
-    update(primaryKey, newAttributes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = yield this.Table.Record({ base: { where: primaryKey } });
-            if (record) {
-                return yield record.Update(newAttributes, primaryKey);
-            }
-        });
+    async all(Model, QueryLayers) {
+        return this.get(QueryLayers, Model);
     }
-    join(Model, queryLayers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { joins, queryLayers: nextLayers } = this.buildJoinObject(Model, queryLayers);
-            nextLayers.base.joins = joins;
-            const records = yield this.Table.Join(nextLayers);
-            return records.map(record => record.values);
-        });
+    async update(primaryKey, newAttributes, table) {
+        const record = await this.Table.Record({ base: { from: table, where: primaryKey } });
+        if (record) {
+            return await record.Update(newAttributes, primaryKey);
+        }
     }
-    toSql(queryLayers, Model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let nextLayers = queryLayers;
-            if (Model.JoinedEntities.length > 0) {
-                const result = this.buildJoinObject(Model, queryLayers);
-                nextLayers = result.queryLayers;
-                nextLayers.base.joins = result.joins;
-            }
-            return this.Table.toSql(nextLayers);
-        });
+    async join(Model, queryLayers) {
+        const { joins, queryLayers: nextLayers } = this.buildJoinObject(Model, queryLayers);
+        nextLayers.base.joins = joins;
+        const records = await this.Table.Join(nextLayers);
+        return records.map(record => record.values);
+    }
+    async toSql(queryLayers, Model) {
+        let nextLayers = queryLayers;
+        if (Model.JoinedEntities.length > 0) {
+            const result = this.buildJoinObject(Model, queryLayers);
+            nextLayers = result.queryLayers;
+            nextLayers.base.joins = result.joins;
+        }
+        return this.Table.toSql(nextLayers);
     }
     buildJoinObject(Model, inputLayers) {
-        const queryLayers = Object.assign(Object.assign({}, inputLayers), { base: Object.assign({}, inputLayers.base), final: inputLayers.final
-                ? Object.assign({}, inputLayers.final) : undefined });
+        const queryLayers = {
+            ...inputLayers,
+            base: {
+                ...inputLayers.base,
+            },
+            final: inputLayers.final
+                ? { ...inputLayers.final }
+                : undefined
+        };
         const joins = Model.JoinedEntities.flatMap(join => {
             var _a, _b;
             var _c;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamkirbki/database-handler-core",
-  "version": "4.4.3",
+  "version": "4.4.4",
   "author": "iamkirbki",
   "description": "Core database abstractions and interfaces",
   "license": "ISC",