Adds group configuration

source/Repositories/GroupConfigurationRepository.ts

@@ -0,0 +1,65 @@
+import {Repository} from "./Repository";
+import GroupConfiguration, {DBGroupConfiguration} from "../Database/tables/GroupConfiguration";
+import {GroupConfigurationModel} from "../Models/GroupConfigurationModel";
+import { GroupModel } from "../Models/GroupModel";
+import {Nullable} from "../types/Nullable";
+import {DatabaseConnection} from "../Database/DatabaseConnection";
+import {GroupRepository} from "./GroupRepository";
+
+export class GroupConfigurationRepository extends Repository<GroupConfigurationModel, DBGroupConfiguration> {
+
+    constructor(
+        protected readonly database: DatabaseConnection,
+        private readonly groupRepository: GroupRepository,
+    ) {
+        super(
+            database,
+            GroupConfiguration
+        );
+    }
+    
+    public findGroupConfigurations(group: GroupModel): GroupConfigurationModel[] {
+        return this.database.fetchAll<number, DBGroupConfiguration>(`
+            SELECT * FROM groupConfiguration WHERE groupid = ?`,
+            group.id
+        ).map((config) => {
+            return this.convertToModelType(config, group);
+        })
+    }
+    
+    public findConfigurationByPath(group: GroupModel, path: string): Nullable<GroupConfigurationModel> {
+        const result = this.database.fetch<number, DBGroupConfiguration>(`
+            SELECT * FROM groupConfiguration WHERE groupid = ? AND key = ?`,
+            group.id,
+            path
+        );
+        
+        if (!result) {
+            return null;
+        } 
+        
+        return this.convertToModelType(result, group);
+    }
+    
+    
+    protected convertToModelType(intermediateModel: DBGroupConfiguration | undefined, group: Nullable<GroupModel> = null): GroupConfigurationModel {
+        if (!intermediateModel) {
+            throw new Error("No intermediate model provided");
+        }
+        
+        return {
+            id: intermediateModel.id,
+            group: group ?? this.groupRepository.getById(intermediateModel.id),
+            key: intermediateModel.key,
+            value: intermediateModel.value,
+        }
+    }
+    
+    protected convertToCreateObject(instance: Partial<GroupConfigurationModel>): object {
+        return {
+            groupid: instance.group?.id ?? undefined,
+            key: instance.key ?? undefined,
+            value: instance.value ?? undefined,
+        }
+    }
+}

source/Repositories/Repository.ts

@@ -33,6 +33,30 @@ export class Repository<ModelType extends Model, IntermediateModelType = unknown
         return result.lastInsertRowid;
     }
     
+    public update(instance: Partial<ModelType>&{id: number}): boolean {
+        const columnNames = this.schema.columns.filter((column) => {
+            return !column.primaryKey
+        }).map((column) => {
+            return column.name;
+        });
+        
+        const createObject = this.convertToCreateObject(instance);
+        const keys = Object.keys(createObject);
+        const missingColumns = columnNames.filter((columnName) => {
+            return !keys.includes(columnName);
+        })
+
+        if (missingColumns.length > 0) {
+            throw new Error("Can't create instance, due to missing column values: " + missingColumns);
+        }
+
+        const sql = `UPDATE ${this.schema.name}
+                     SET ${Object.keys(createObject).map((key) => `${key} = ?`).join(',')}
+                     WHERE id = ?`;
+        const result = this.database.execute(sql, ...Object.values(createObject), instance.id);
+        return result.lastInsertRowid;
+    }
+    
     public getById(id: number): Nullable<ModelType> {
         const sql = `SELECT * FROM ${this.schema.name} WHERE id = ? LIMIT 1`;
         return this.convertToModelType(this.database.fetch<number, IntermediateModelType>(sql, id));