Merged API and Databank into Main branch

database/create_db.ts

@@ -0,0 +1,107 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating the database and the tables
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import {
+  dirname,
+  fromFileUrl,
+  join,
+} from "https://deno.land/std@0.224.0/path/mod.ts";
+
+// +++ VARIABLES ---------------------------------------------------- //
+const _dirname: string = dirname(fromFileUrl(import.meta.url));
+const dbPath: string = join(_dirname, "../database/esp-projekt.sqlite");
+const db = new DB(dbPath);
+
+export function createDatabase(): void {
+  db.execute(`
+        CREATE TABLE IF NOT EXISTS accounts (
+            user_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_group TEXT,
+            bio TEXT,
+            displayname TEXT,
+            username TEXT,
+            user_email TEXT,
+            password TEXT,
+            password_salt TEXT,
+            firstname TEXT,
+            surname TEXT,
+            account_created TEXT,
+            blocked_users TEXT,
+            followers TEXT,
+            following TEXT,
+            contacts TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS posts (
+            posts_uuid INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER,
+            created_at TEXT,
+            post_text TEXT,
+            post_type TEXT,
+            likes INTEGER,
+            comments INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS comments (
+            comment_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            post_id INTEGER,
+            author_user_id INTEGER,
+            date_created_at TEXT,
+            text TEXT,
+            likes INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            message_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            chat_id INTEGER,
+            sender_id INTEGER,
+            content TEXT,
+            timestamp TEXT,
+            FOREIGN KEY (chat_id) REFERENCES chats (chat_id),
+            FOREIGN KEY (sender_id) REFERENCES accounts (user_id)
+        );
+
+    CREATE TABLE IF NOT EXISTS chats (
+    chat_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    chat_name TEXT,
+    participants TEXT,
+    created_at TEXT
+  )
+    `);
+}
+
+// Sample data generated using AI, does not work yet and will be adjusted
+export function insertSampleData(): void {
+  db.query(
+    `INSERT INTO accounts (user_group, bio, displayname, username, user_email, password, password_salt, firstname, surname, account_created, blocked_users, followers, following, contacts) VALUES
+        ('admin', 'Admin bio', 'Admin User', 'admin', 'admin@example.com', 'pw1', 'salt1', 'Admin', 'User', '2024-01-01', '[]', '[]', '[]', '[]'),
+        ('user', 'I love coding!', 'John Dev', 'johndev', 'john@example.com', 'pw2', 'salt2', 'John', 'Smith', '2024-01-02', '[]', '[]', '[3,4]', '[1,2]'),
+        ('user', 'Photography enthusiast', 'Alice', 'alice_photo', 'alice@example.com', 'pw3', 'salt3', 'Alice', 'Johnson', '2024-01-03', '[]', '[5]', '[1]', '[2]')
+    `,
+  );
+
+  db.query(
+    `INSERT INTO posts (user_id, created_at, post_text, post_type, likes, comments) VALUES
+        (1, '2024-01-15 10:00:00', 'First post about programming!', 'text', 5, 2),
+        (1, '2024-01-15 11:30:00', 'Check out this new feature', 'text', 10, 3),
+        (2, '2024-01-16 09:15:00', 'Just learned about TypeScript', 'text', 8, 1),
+        (3, '2024-01-16 14:20:00', 'Posted my new photo collection', 'image', 15, 4)
+    `,
+  );
+
+  db.query(
+    `INSERT INTO comments (post_id, author_user_id, date_created_at, text, likes) VALUES
+        (1, 2, '2024-01-15 10:05:00', 'Great post!', 3),
+        (1, 3, '2024-01-15 10:10:00', 'Very informative', 2),
+        (2, 3, '2024-01-15 11:35:00', 'Nice feature', 4),
+        (3, 1, '2024-01-16 09:20:00', 'TypeScript is awesome', 5),
+        (4, 2, '2024-01-16 14:25:00', 'Beautiful photos!', 6)
+    `,
+  );
+}

database/helpers/interfaces.ts

@@ -0,0 +1,61 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for making Interfaces accessible by every file, deduplicating it.
+ * @file interfaces.ts
+ */
+
+interface Post {
+  posts_uuid: number;
+  user_id: number;
+  created_at: string;
+  post_text: string;
+  post_type: string;
+  likes: number;
+  comments: number;
+}
+
+interface Accounts {
+  user_id: number;
+  user_group: string;
+  bio: string;
+  displayname: string;
+  username: string;
+  user_email: string;
+  password: string;
+  password_salt: string;
+  firstname: string;
+  surname: string;
+  account_created: string;
+  blocked_users: string;
+  followers: string;
+  following: string;
+  contacts: string;
+}
+
+interface Comments {
+  comment_id: number;
+  post_id: number;
+  author_user_id: number;
+  date_created_at: string;
+  text: string;
+  likes: number;
+}
+
+interface Chat {
+  chat_id: number;
+  chat_name: string;
+  participants: string;
+  created_at: string;
+}
+
+interface Message {
+  message_id: number;
+  chat_id: number;
+  sender_id: number;
+  content: string;
+  timestamp: string;
+}
+
+export type { Accounts, Chat, Comments, Message, Post };

database/helpers/maphelper.ts

@@ -0,0 +1,122 @@
+/// <reference lib="deno.ns" />
+/**
+ * @author Esad Mustafoski
+ * @description This file makes accessing the Database easier by creating a map for each type of data
+ * @file maphelper.ts
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { Row } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import {
+  Accounts,
+  Chat,
+  Comments,
+  Message,
+  Post,
+} from "../helpers/interfaces.ts";
+
+function mapPostRow(row: Row): Post {
+  const [
+    posts_uuid,
+    user_id,
+    created_at,
+    post_text,
+    post_type,
+    likes,
+    comments,
+  ] = row;
+  return {
+    posts_uuid: Number(posts_uuid),
+    user_id: Number(user_id),
+    created_at: String(created_at),
+    post_text: String(post_text),
+    post_type: String(post_type),
+    likes: Number(likes),
+    comments: Number(comments),
+  };
+}
+
+function mapCommentRow(row: Row): Comments {
+  const [
+    comment_id,
+    post_id,
+    author_user_id,
+    date_created_at,
+    text,
+    likes,
+  ] = row;
+  return {
+    comment_id: Number(comment_id),
+    post_id: Number(post_id),
+    author_user_id: Number(author_user_id),
+    date_created_at: String(date_created_at),
+    text: String(text),
+    likes: Number(likes),
+  };
+}
+
+function mapChatRow(row: Row): Chat {
+  const [chat_id, chat_name, participants, created_at] = row;
+  return {
+    chat_id: Number(chat_id),
+    chat_name: String(chat_name),
+    participants: String(participants),
+    created_at: String(created_at),
+  };
+}
+
+function mapMessageRow(row: Row): Message {
+  const [message_id, chat_id, sender_id, content, timestamp] = row;
+  return {
+    message_id: Number(message_id),
+    chat_id: Number(chat_id),
+    sender_id: Number(sender_id),
+    content: String(content),
+    timestamp: String(timestamp),
+  };
+}
+
+function mapAccountRow(row: Row): Accounts {
+  const [
+    user_id,
+    user_group,
+    bio,
+    displayname,
+    username,
+    user_email,
+    password,
+    password_salt,
+    firstname,
+    surname,
+    account_created,
+    blocked_users,
+    followers,
+    following,
+    contacts,
+  ] = row;
+  return {
+    user_id: Number(user_id),
+    user_group: String(user_group),
+    bio: String(bio),
+    displayname: String(displayname),
+    username: String(username),
+    user_email: String(user_email),
+    password: String(password),
+    password_salt: String(password_salt),
+    firstname: String(firstname),
+    surname: String(surname),
+    account_created: String(account_created),
+    blocked_users: String(blocked_users),
+    followers: String(followers),
+    following: String(following),
+    contacts: String(contacts),
+  };
+}
+
+export {
+    mapAccountRow,
+    mapChatRow,
+    mapCommentRow,
+    mapMessageRow,
+    mapPostRow
+};

database/helpers/utils/chat_utils.ts

@@ -0,0 +1,86 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating Functions to easily access the Database, Specifically for Chats
+ * @file chatUtil.ts
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import { Chat, Message } from "../interfaces.ts";
+import { mapChatRow, mapMessageRow, queryDatabase } from "./mod.ts";
+
+async function getUserChats(db: DB, userId: string): Promise<Chat[]> {
+  const query = `SELECT * FROM chats WHERE participants LIKE '%${userId}%'`;
+  return await queryDatabase<Chat>(db, query, [], mapChatRow);
+}
+
+async function getChatById(db: DB, chatId: string): Promise<Chat | null> {
+  const query = `SELECT * FROM chats WHERE chat_id = ?`;
+  const chats = await queryDatabase<Chat>(db, query, [chatId], mapChatRow);
+  return chats.length > 0 ? chats[0] : null;
+}
+
+async function getChatMessages(db: DB, chatId: string): Promise<Message[]> {
+  const query =
+    `SELECT * FROM messages WHERE chat_id = ? ORDER BY timestamp ASC`;
+  return await queryDatabase<Message>(db, query, [chatId], mapMessageRow);
+}
+
+async function createChat(
+  db: DB,
+  participants: string[],
+  chatName: string,
+): Promise<string> {
+  const participantsJson = JSON.stringify(participants);
+  const timestamp = `${Math.floor(Date.now() / 1000)}-${
+    new Date().toLocaleDateString("en-GB").split("/").join("-")
+  }`;
+
+  const query = `
+    INSERT INTO chats (chat_name, participants, created_at)
+    VALUES (?, ?, ?)
+  `;
+
+  db.query(query, [chatName, participantsJson, timestamp]);
+  return db.lastInsertRowId.toString();
+}
+
+async function addMessageToChat(
+  db: DB,
+  chatId: string,
+  senderId: string,
+  content: string,
+): Promise<string> {
+  const timestamp = `${Math.floor(Date.now() / 1000)}-${
+    new Date().toLocaleDateString("en-GB").split("/").join("-")
+  }`;
+
+  const query = `
+    INSERT INTO messages (chat_id, sender_id, content, timestamp)
+    VALUES (?, ?, ?, ?)
+  `;
+
+  db.query(query, [chatId, senderId, content, timestamp]);
+  return db.lastInsertRowId.toString();
+}
+
+async function deleteChat(db: DB, chatId: string): Promise<void> {
+  // First delete all messages in the chat
+  const deleteMessagesQuery = `DELETE FROM messages WHERE chat_id = ?`;
+  db.query(deleteMessagesQuery, [chatId]);
+
+  // Then delete the chat itself
+  const deleteChatQuery = `DELETE FROM chats WHERE chat_id = ?`;
+  db.query(deleteChatQuery, [chatId]);
+}
+
+export {
+  getUserChats,
+  getChatById,
+  getChatMessages,
+  createChat,
+  addMessageToChat,
+  deleteChat
+};

database/helpers/utils/comment_utils.ts

@@ -0,0 +1,81 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating Functions to easily access the Database, Specifically for Comments
+ * @file commentUtil.ts
+ */
+
+import { DB } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import { Comments } from "../interfaces.ts";
+import { mapCommentRow, queryDatabase } from "./mod.ts";
+
+async function getCommentsFromDB(
+  db: DB,
+  post_id?: number,
+): Promise<Comments[]> {
+  const query = post_id
+    ? `SELECT * FROM comments WHERE post_id = ?`
+    : `SELECT * FROM comments`;
+  const params = post_id ? [post_id] : [];
+  return await queryDatabase<Comments>(db, query, params, mapCommentRow);
+}
+
+function createComment(
+  db: DB,
+  postId: string,
+  userId: string,
+  createdAt: string,
+  text: string,
+): string {
+  const query = `
+    INSERT INTO comments (post_id, author_user_id, date_created_at, text, likes)
+    VALUES (?, ?, ?, ?, 0)
+  `;
+  db.query(query, [postId, userId, createdAt, text]);
+
+  const updatePostQuery =
+    `UPDATE posts SET comments = comments + 1 WHERE posts_uuid = ?`;
+  db.query(updatePostQuery, [postId]);
+
+  return db.lastInsertRowId.toString();
+}
+
+async function updateComment(
+  db: DB,
+  commentId: string,
+  text: string,
+): Promise<void> {
+  const query = `UPDATE comments SET text = ? WHERE comment_id = ?`;
+  db.query(query, [text, commentId]);
+}
+
+async function deleteComment(db: DB, commentId: string): Promise<void> {
+  const getPostIdQuery = `SELECT post_id FROM comments WHERE comment_id = ?`;
+  const result = db.query(getPostIdQuery, [commentId]);
+  const postId: any = result[0][0];
+
+  const deleteCommentQuery = `DELETE FROM comments WHERE comment_id = ?`;
+  db.query(deleteCommentQuery, [commentId]);
+
+  const updatePostQuery =
+    `UPDATE posts SET comments = comments - 1 WHERE posts_uuid = ?`;
+  db.query(updatePostQuery, [postId]);
+}
+
+async function likeComment(
+  db: DB,
+  commentId: string,
+  userId: string,
+): Promise<void> {
+  const query = `UPDATE comments SET likes = likes + 1 WHERE comment_id = ?`;
+  db.query(query, [commentId]);
+}
+
+export {
+  createComment,
+  deleteComment,
+  getCommentsFromDB,
+  likeComment,
+  updateComment,
+};

database/helpers/utils/core_utils.ts

@@ -0,0 +1,46 @@
+/// <reference lib="deno.ns" />
+/**
+ * @author Esad Mustafoski
+ * @description Core Utility for querying the Database and inserting Sample Data
+ * @file core_utils.ts
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB, Row } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import * as db_create from "../../create_db.ts";
+
+// +++ Helper ------------------------------------------------------ //
+// "T" is a generic type, it can be anything and makes the function "flexible"(?)
+async function queryDatabase<T>(
+  db: DB,
+  query: string,
+  params: any[],
+  mapRow: (row: Row) => T,
+): Promise<T[]> {
+  const results: T[] = [];
+  try {
+    const rows = await db.query(query, params);
+    for (const row of rows) {
+      results.push(mapRow(row));
+    }
+  } catch (error) {
+    console.error("Database query error:", error);
+  }
+  return results;
+}
+
+// +++ FUNCTIONS --------------------------------------------------- //
+
+/**
+ * See:
+ * @file ./create_db.ts
+ */
+function insertSamples(): void {
+  db_create.insertSampleData();
+}
+
+function createDatabaseIfNotExist(): void {
+  db_create.createDatabase();
+}
+
+export { queryDatabase, insertSamples, createDatabaseIfNotExist };

database/helpers/utils/mod.ts

@@ -0,0 +1,13 @@
+/// <reference lib="deno.ns" />
+/**
+ * @author Esad Mustafoski
+ * @description A mod file is used to export all the functions in the folder, making them easier to access.
+ * @file mod.ts
+ */
+
+export * from "./chat_utils.ts";
+export * from "./comment_utils.ts";
+export * from "./post_utils.ts";
+export * from "./user_utils.ts";
+export * from "./core_utils.ts"
+export * from "../maphelper.ts";

database/helpers/utils/post_utils.ts

@@ -0,0 +1,128 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating Functions to easily access the Database, Specifically for Posts
+ * @file postUtil.ts
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import { Post } from "../interfaces.ts";
+import { mapPostRow, queryDatabase } from "./mod.ts";
+
+async function getPostsFromDB(db: DB, user_uuid?: string): Promise<Post[]> {
+  const query = user_uuid
+    ? `SELECT * FROM posts WHERE user_id = ?`
+    : `SELECT * FROM posts`;
+  const params = user_uuid ? [user_uuid] : [];
+  return await queryDatabase<Post>(db, query, params, mapPostRow);
+}
+
+async function getPostById(db: DB, postId: string): Promise<Post | null> {
+  const query = `SELECT * FROM posts WHERE posts_uuid = ?`;
+  const posts = await queryDatabase<Post>(db, query, [postId], mapPostRow);
+  return posts.length > 0 ? posts[0] : null;
+}
+
+async function createPost(
+  db: DB,
+  userId: string,
+  createdAt: string,
+  postText: string,
+  postType: string,
+): Promise<string> {
+  const query = `
+    INSERT INTO posts (user_id, created_at, post_text, post_type, likes, comments)
+    VALUES (?, ?, ?, ?, 0, 0)
+  `;
+
+  db.query(query, [userId, createdAt, postText, postType]);
+  return db.lastInsertRowId.toString();
+}
+
+async function updatePost(
+  db: DB,
+  postId: string,
+  postText?: string,
+  postType?: string,
+): Promise<void> {
+  let query = `UPDATE posts SET `;
+  const params: any[] = [];
+
+  if (postText) {
+    query += `post_text = ?`;
+    params.push(postText);
+
+    if (postType) {
+      query += `, post_type = ?`;
+      params.push(postType);
+    }
+  } else if (postType) {
+    query += `post_type = ?`;
+    params.push(postType);
+  }
+
+  query += ` WHERE posts_uuid = ?`;
+  params.push(postId);
+
+  db.query(query, params);
+}
+
+// This function deletes the comments on the post first, then
+// deletes the post to avoid errors
+async function deletePost(db: DB, postId: string): Promise<void> {
+  const deleteCommentsQuery = `DELETE FROM comments WHERE post_id = ?`;
+  db.query(deleteCommentsQuery, [postId]);
+
+  const deletePostQuery = `DELETE FROM posts WHERE posts_uuid = ?`;
+  db.query(deletePostQuery, [postId]);
+}
+
+// This is simplified and doesn't work as it would in a real application
+// or website like twitter, this only exists as a test
+async function likePost(db: DB, postId: string, userId: string): Promise<void> {
+  const query = `UPDATE posts SET likes = likes + 1 WHERE posts_uuid = ?`;
+  db.query(query, [postId]);
+}
+
+/**
+ * @param posts_to_filter The Posts in an array to filter
+ * @param post_types The types of Posts to filter for
+ * @returns Array of Posts
+ */
+// Filter functions merged to one
+function filterPosts(posts_to_filter: Post[], post_types: string[]): Post[] {
+  if (post_types.length === 0) {
+    return posts_to_filter;
+  }
+
+  // Set is a type that we can specify the values to
+  // example: const set = new Set<number>();
+  // set.add(1); Will work
+  // set.add("2"); Will not work, it will error because
+  // it is a string.
+  const includedPostIds = new Set<number>();
+  const result: Post[] = [];
+
+  for (const type of post_types) {
+    for (const post of posts_to_filter) {
+      if (!includedPostIds.has(post.posts_uuid) && post.post_type === type) {
+        result.push(post);
+        includedPostIds.add(post.posts_uuid);
+      }
+    }
+  }
+
+  return result;
+}
+
+export {
+  getPostsFromDB,
+  getPostById,
+  createPost,
+  updatePost,
+  deletePost,
+  likePost,
+  filterPosts,
+};

database/helpers/utils/user_utils.ts

@@ -0,0 +1,103 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating Functions to easily access the Database, Specifically for Users
+ * @file userUtil.ts
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB, Row } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import { mapAccountRow, queryDatabase } from "./mod.ts";
+import { Accounts } from "../interfaces.ts";
+
+/**
+ * @param user The username of the User to add
+ * @param password The hashed password of the User to add
+ * @param salt The salt used for the password
+ * @returns "noUser" if user exists, "newUser" if registration successful
+ */
+function registerUser(
+  db: DB,
+  user: string,
+  password: string,
+  salt: string,
+  userGroup: string,
+  displayname: string,
+  user_email: string,
+  firstname: string,
+  surname: string,
+  account_created: string,
+): any {
+  const query_user_exists =
+    `SELECT * FROM accounts WHERE displayname = '${user}'`;
+  if (!query_user_exists) {
+    return "noUser";
+  }
+
+  const query_add_user = `
+        INSERT INTO accounts (
+            username,
+            password,
+            password_salt,
+            user_group,
+            displayname,
+            user_email,
+            firstname,
+            surname,
+            account_created,
+            bio,
+            blocked_users,
+            followers,
+            following,
+            contacts
+        ) VALUES (
+            '${user}',
+            '${password}',
+            '${salt}',
+            '${userGroup}',
+            '${displayname}',
+            '${user_email}',
+            '${firstname}',
+            '${surname}',
+            '${account_created}',
+            '',
+            '[]',
+            '[]',
+            '[]',
+            '[]'
+        )`;
+  db.query(query_add_user);
+  const userId = db.query(
+    `SELECT user_id FROM accounts WHERE displayname = '${user}'`,
+  );
+  console.log(`New user: ${user}`);
+
+  return userId;
+}
+
+/**
+ * @returns Array of all Users in the Database
+ */
+async function getAllUsersFromDB(db: DB): Promise<Accounts[]> {
+  const query = `SELECT * FROM accounts`;
+  return await queryDatabase<Accounts>(db, query, [], mapAccountRow);
+}
+
+/**
+ * @param username
+ * @returns Returns the Accounts for the User with the given username
+ */
+async function getUserByUsername(db: DB, username: string): Promise<Accounts> {
+  const query = `SELECT * FROM accounts WHERE username = '${username}'`;
+  const params: string[] = [];
+  const result = await queryDatabase<Accounts>(
+    db,
+    query,
+    params,
+    mapAccountRow,
+  );
+  return result[0];
+}
+
+export { getAllUsersFromDB, getUserByUsername, registerUser };

database/utils.ts

@@ -0,0 +1,203 @@
+/// <reference lib="deno.ns" />
+
+/**
+ * @author Esad Mustafoski
+ * @description This file is responsible for creating Functions to easily access the Database, Intended for use in the API
+ */
+
+// +++ IMPORTS ------------------------------------------------------ //
+import { DB } from "https://deno.land/x/sqlite@v3.9.1/mod.ts";
+import {
+  dirname,
+  fromFileUrl,
+  join,
+} from "https://deno.land/std@0.224.0/path/mod.ts";
+import * as db_create from "./create_db.ts";
+
+// Import all internal utilities with renamed imports to avoid naming conflicts
+import {
+  addMessageToChat as addMessageToChatInternal,
+  createChat as createChatInternal,
+  // getCommentsForComments as getCommentsForCommentsInternal,
+  // Accidentally deleted function...
+  createComment as createCommentInternal,
+  createPost as createPostInternal,
+  deleteChat as deleteChatInternal,
+  deleteComment as deleteCommentInternal,
+  deletePost as deletePostInternal,
+  filterPosts,
+  // --- Account Functions --- //
+  getAllUsersFromDB as getAllUsersFromDBInternal,
+  getChatById as getChatByIdInternal,
+  getChatMessages as getChatMessagesInternal,
+  // --- Comment Functions --- //
+  getCommentsFromDB as getCommentsFromDBInternal,
+  getPostById as getPostByIdInternal,
+  // --- Post Functions --- //
+  getPostsFromDB as getPostsFromDBInternal,
+  getUserByUsername as getUserByUsernameInternal,
+  // --- Chat Functions --- //
+  getUserChats as getUserChatsInternal,
+  likeComment as likeCommentInternal,
+  likePost as likePostInternal,
+  // --- Mapper Functions --- //
+  queryDatabase as queryDatabaseInternal,
+  // getAllUserInfoByID as getAllUserInfoByIDInternal,
+  // Accidentally deleted function...
+  registerUser as registerUserInternal,
+  updateComment as updateCommentInternal,
+  updatePost as updatePostInternal,
+} from "./helpers/utils/mod.ts";
+
+// +++ VARIABLES ---------------------------------------------------- //
+// _dirname Is never getting used again, It's only needed because the DB Import
+// from SQLite doesn't like relative paths, so I use this as
+// A Workaround
+const _dirname: string = dirname(fromFileUrl(import.meta.url));
+const dbPath: string = join(_dirname, "../database/esp-projekt.sqlite");
+const db = new DB(dbPath);
+
+// +++ INTERFACES --------------------------------------------------- //
+// Only re-export interfaces that are needed by external code
+export type {
+  Accounts,
+  Chat,
+  Comments,
+  Message,
+  Post,
+} from "./helpers/interfaces.ts";
+// +++ HELPER FUNCTIONS --------------------------------------------- //
+export function queryDatabase<T>(
+  query: string,
+  params: any[],
+  mapRow: (row: any) => T,
+): Promise<T[]> {
+  return queryDatabaseInternal(db, query, params, mapRow);
+}
+
+// +++ DATABASE INITIALIZATION -------------------------------------- //
+export async function ensureDatabaseExists(): Promise<void> {
+  try {
+    // Check if the database directory exists, create it if not
+    const dbDir = dirname(dbPath);
+    try {
+      await Deno.stat(dbDir);
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        // Create the database directory
+        await Deno.mkdir(dbDir, { recursive: true });
+        console.log(`Created database directory: ${dbDir}`);
+      } else {
+        throw error;
+      }
+    }
+
+    // Check if the database file exists
+    try {
+      await Deno.stat(dbPath);
+      console.log("Database file already exists");
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        createDatabaseIfNotExist();
+        insertSamples();
+        // Nothing, file will be created below
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    console.error("Error ensuring database exists:", error);
+    throw error;
+  }
+}
+
+export function createDatabaseIfNotExist(): void {
+  db_create.createDatabase();
+}
+
+export function insertSamples(): void {
+  db_create.insertSampleData();
+}
+
+// +++ ACCOUNT FUNCTIONS -------------------------------------------- //
+export const getAllUsersFromDB = () => getAllUsersFromDBInternal(db);
+export const getUserByUsername = (username: string) =>
+  getUserByUsernameInternal(db, username);
+// export const getAllUserInfoByID = (user_id: string) => getAllUserInfoByIDInternal(db, user_id);
+export const registerUser = (
+  user: string,
+  password: string,
+  salt: string,
+  userGroup: string,
+  displayname: string,
+  user_email: string,
+  firstname: string,
+  surname: string,
+  account_created: string,
+) =>
+  registerUserInternal(
+    db,
+    user,
+    password,
+    salt,
+    userGroup,
+    displayname,
+    user_email,
+    firstname,
+    surname,
+    account_created,
+  );
+
+// +++ POST FUNCTIONS ----------------------------------------------- //
+export const getPostsFromDB = (user_uuid?: string) =>
+  getPostsFromDBInternal(db, user_uuid);
+export const getPostById = (postId: string) => getPostByIdInternal(db, postId);
+export const createPost = (
+  userId: string,
+  createdAt: string,
+  postText: string,
+  postType: string,
+) => createPostInternal(db, userId, createdAt, postText, postType);
+export const updatePost = (
+  postId: string,
+  postText?: string,
+  postType?: string,
+) => updatePostInternal(db, postId, postText, postType);
+export const deletePost = (postId: string) => deletePostInternal(db, postId);
+export const likePost = (postId: string, userId: string) =>
+  likePostInternal(db, postId, userId);
+
+// +++ COMMENT FUNCTIONS -------------------------------------------- //
+export const getCommentsFromDB = (post_id?: number) =>
+  getCommentsFromDBInternal(db, post_id);
+// export const getCommentsForComments = (comment_id: number) => getCommentsForCommentsInternal(db, comment_id);
+export const createComment = (
+  postId: string,
+  userId: string,
+  createdAt: string,
+  text: string,
+) => createCommentInternal(db, postId, userId, createdAt, text);
+export const updateComment = (commentId: string, text: string) =>
+  updateCommentInternal(db, commentId, text);
+export const deleteComment = (commentId: string) =>
+  deleteCommentInternal(db, commentId);
+export const likeComment = (commentId: string, userId: string) =>
+  likeCommentInternal(db, commentId, userId);
+
+// +++ CHAT FUNCTIONS ----------------------------------------------- //
+export const getUserChats = (userId: string) =>
+  getUserChatsInternal(db, userId);
+export const getChatById = (chatId: string) => getChatByIdInternal(db, chatId);
+export const getChatMessages = (chatId: string) =>
+  getChatMessagesInternal(db, chatId);
+export const createChat = (participants: string[], chatName: string) =>
+  createChatInternal(db, participants, chatName);
+export const addMessageToChat = (
+  chatId: string,
+  senderId: string,
+  content: string,
+) => addMessageToChatInternal(db, chatId, senderId, content);
+export const deleteChat = (chatId: string) => deleteChatInternal(db, chatId);
+
+// +++ UTILITY FUNCTIONS -------------------------------------------- //
+export { filterPosts };