A ton of fixes and it's now possible to track servers and channels in the DB

src/utilties/storage/enumerations.ts

@@ -0,0 +1,7 @@
+export enum SQLResult {
+    CREATED,
+    UPDATED,
+    DELETED,
+    ALREADYEXISTS,
+    FAILED
+}

src/utilties/storage/interfaces.ts

@@ -1,4 +1,4 @@
-export interface sql_common {
+export interface SQLCommon {
     run(query: string) : Promise<number>
     runParameterized(query: string, parameters: any[]): Promise<number>
     getAll(query: string) : Promise<Object[]>

src/utilties/storage/sqlite.ts

@@ -1,8 +1,8 @@
 import * as sqlite3 from 'sqlite3'
 
-import { sql_common } from "./interfaces"
+import { SQLCommon } from "./interfaces"
 
-export class SqliteDB implements sql_common {
+export class SqliteDB implements SQLCommon {
     private db : sqlite3.Database;
 
     public constructor(private readonly dbName: string) {
@@ -10,7 +10,7 @@ export class SqliteDB implements sql_common {
     }
     
     async run(query: string): Promise<number> {
-        return new Promise(() => {
+        return new Promise((resolve, reject) => {
             this.db.run(query, (result : sqlite3.RunResult, err: Error) => {
                 if (err) {
                     // TODO Winston should handle this
@@ -18,9 +18,9 @@ export class SqliteDB implements sql_common {
                     throw err
                 } else {
                     if (result != null) {
-                        return result.changes
+                        resolve(result.changes)
                     } else {
-                        return 0
+                        resolve(0)
                     }
                 }
             })
@@ -28,42 +28,47 @@ export class SqliteDB implements sql_common {
     }
 
     async runParameterized(query: string, parameters: any[]): Promise<number> {
-        return new Promise(() => {
+        return new Promise((resolve, reject) => {
             this.db.run(query, parameters, (result : sqlite3.RunResult, err: Error) => {
                 if (err) {
                     // TODO Winston should handle this
                     console.log(err)
                     throw err
                 } else {
-                    return result.changes
+                    if (result != null) {
+                        resolve(result.changes)
+                    } else {
+                        resolve(0)
+                    }
                 }
             })
         })
     }
 
     async getAll(query: string): Promise<Object[]> {
-        return new Promise(() => {
+        return new Promise((resolve, reject) => {
             this.db.all(query, (err: Error, rows: Object[]) => {
                 if (err) {
                     // TODO Winston should handle this
                     console.log(err)
                     throw err
                 } else {
-                    return rows
+                    console.log("Got rows")
+                    resolve(rows)
                 }
             })
         })
     }
 
     getAllParameterized(query: string, parameters: any[]): Promise<Object[]> {
-        return new Promise(() => {
+        return new Promise((resolve, reject) => {
             this.db.all(query, parameters, (err: Error, rows: Object[]) => {
                 if (err) {
                     // TODO Winston should handle this
                     console.log(err)
                     throw err
                 } else {
-                    return rows
+                    resolve(rows)
                 }
             })
         })

src/utilties/storage/tables.ts

@@ -1,11 +1,22 @@
-import { sql_common } from "./interfaces";
+import { SQLCommon } from "./interfaces";
 
 const tables: string[] = [
     "CREATE TABLE IF NOT EXISTS servers (server_snowflake bigint NOT NULL PRIMARY KEY,server_name text NOT NULL,server_description mediumtext);",
-    "CREATE TABLE IF NOT EXISTS channels (channel_snowflake bigint NOT NULL PRIMARY KEY,server_snowflake bigint NOT NULL,channel_name text NOT NULL);"
+    "CREATE TABLE IF NOT EXISTS channels (channel_snowflake bigint NOT NULL PRIMARY KEY,server_snowflake bigint NOT NULL,channel_name text NOT NULL,is_thread bit NOT NULL);",
+    "CREATE TABLE IF NOT EXISTS messages (message_snowflake bigint NOT NULL PRIMARY KEY,channel_snowflake bigint NOT NULL,user_snowflake bigint NOT NULL,message_content longtext NOT NULL,message_timestamp datetime NOT NULL,message_deleted bit NOT NULL);",
+    "CREATE TABLE IF NOT EXISTS message_content_changes (message_change_id bigint NOT NULL PRIMARY KEY,message_snowflake bigint NOT NULL,message_change_old_timestamp datetime NOT NULL,message_change_old_content longtext NOT NULL);",
+    "CREATE TABLE IF NOT EXISTS message_attachments (attachment_snowflake bigint NOT NULL PRIMARY KEY,message_snowflake bigint NOT NULL,attachment_name text NOT NULL,attachment_description text,attachment_timestamp datetime NOT NULL,attachment_mime_type text,attachment_url text NOT NULL,attachment_downloaded bit NOT NULL);"
 ]
 
-export async function makeTables(db: sql_common): Promise<number[]> {
+const constraints: string[] = [
+    "ALTER TABLE channels ADD CONSTRAINT channels_server_snowflake_fk FOREIGN KEY (server_snowflake) REFERENCES servers (server_snowflake);"
+]
+
+export async function makeTables(db: SQLCommon): Promise<number[]> {
     return Promise.all(tables.map((statement) => db.run(statement)))
 }
 
+export async function makeConstraints(db: SQLCommon): Promise<number[]> {
+    return Promise.all(constraints.map((statement) => db.run(statement)))
+}
+