Adds initial progress

source/Repositories/Repository.ts

@@ -0,0 +1,52 @@
+import {DatabaseConnection} from "../Database/DatabaseConnection";
+import {Model} from "../Models/Model";
+import { Nullable } from "../types/Nullable";
+import {DatabaseDefinition} from "../Database/DatabaseDefinition";
+import {debug} from "node:util";
+
+export class Repository<ModelType extends Model, IntermediateModelType = unknown> {
+    constructor(
+        protected readonly database: DatabaseConnection,
+        public readonly schema: DatabaseDefinition,
+    ) {}
+    
+    public create(instance: Partial<ModelType>): number|bigint {
+        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 = `INSERT INTO ${this.schema.name}(${Object.keys(createObject).join(',')}) 
+                     VALUES (${Object.keys(createObject).map(() => "?").join(',')})`;
+        const result = this.database.execute(sql, ...Object.values(createObject));
+        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));
+    }
+    
+    public delete(id: number) {
+        const sql = `DELETE FROM ${this.schema.name} WHERE id = ?`;
+        return this.database.execute(sql, id);
+    }
+    
+    protected convertToModelType(intermediateModel: IntermediateModelType | undefined): ModelType {
+        return intermediateModel as unknown as ModelType;
+    }
+    protected convertToCreateObject(instance: Partial<ModelType>): object {
+        return instance;
+    }
+}