Added update capabilities to database. Changed id to ROWID in all instances (#11)

Author: ConnerWithAnE

server/src/database-controller.ts

@@ -3,7 +3,7 @@ import { open, Database } from "sqlite";
 import { DataTable } from "./interfaces/database-interface";
 import { resolve } from "path";
 import { rejects } from "assert";
-import { GetQuery, TableData, RadData } from "./types";
+import { GetQuery, TableData, InsertData, UpdateData } from "./types";
 import { error } from "console";
 
 export class DatabaseController {
@@ -68,6 +68,29 @@ export class DatabaseController {
         `);
   }
 
+  // Will probably remove, decided to change id to ROWID to add efficiency
+  private async initializeViews(): Promise<void> {
+    const paperView = `CREATE VIEW paper_view AS
+    SELECT
+      ROWID AS id,
+      year,
+      paper_name,
+      part_no,
+      type,
+      manufacturer,
+      data_type,
+      testing_location,
+      testing_type
+    FROM paper`;
+    await this.db.run(paperView, (err: any) => {
+      if (err) {
+        console.error(`Error creating paper view: ${err}`);
+      } else {
+        console.log("View created successfully.");
+      }
+    });
+  }
+
   /*
    * Parameters:
    *  - tableName (string): the name of the table to check
@@ -99,15 +122,15 @@ export class DatabaseController {
    *           created in the 'author_paper_join' table for each author.
    * Returns: None
    */
-  async insertPaper(paperData: TableData): Promise<void> {
+  async insertPaper(paperData: InsertData): Promise<void> {
     if (!this.db) {
       throw new Error(`Database not initialized`);
     }
     try {
       const paperId = await this.createPaper(paperData);
       console.log(paperData.author);
       for (const author in paperData.author) {
-        const authorRowId = await this.getOrCreateAuthor(
+        const authorRowId = await this.getOrCreateAuthorByName(
           paperData.author[author],
         );
         await this.linkPaperToAuthor(authorRowId, paperId);
@@ -120,14 +143,36 @@ export class DatabaseController {
     }
   }
 
+  /*
+   * !!! NOTE !!!!
+   * paperData MUST contain the ROWID of the paper for proper update purposes.
+   *
+   * Parameters:
+   *  - paperData: Data to be updated coresponding to a sepcific paper
+   * Function: Updates an entry for the given paper in the 'paper' table and
+   *           entries in the 'author' and 'author_paper_join' are updated.
+   * Returns: None
+   */
+  async updatePaper(paperData: UpdateData): Promise<void> {
+    if (!this.db) {
+      throw new Error(`Database not initialized`);
+    }
+    try {
+      await this.updatePaperTable(paperData);
+      if (paperData.author) {
+        await this.syncPaperAuthors(paperData.ROWID, paperData.author);
+      }
+    } catch (error) {}
+  }
+
   /*
    * Parameters:
    *  - paperData: An insertData instance
    * Function: Uses the given data to create an entry in the table cotaining the papers
    * Returns:
    *  - number: The ROWID of the paper.
    */
-  private async createPaper(paperData: TableData): Promise<number> {
+  private async createPaper(paperData: InsertData): Promise<number> {
     if (!this.db) {
       throw new Error(`Database not initialized`);
     }
@@ -165,6 +210,34 @@ export class DatabaseController {
     }
   }
 
+  private async updatePaperTable(paperData: UpdateData): Promise<void> {
+    let query = `UPDATE paper SET `;
+    let conditions: string[] = [];
+    const params: string[] = [];
+    if (!this.db) {
+      throw new Error(`Database not initialized`);
+    }
+    try {
+      for (const [key, value] of Object.entries(paperData)) {
+        if (
+          value !== undefined &&
+          value !== null &&
+          key !== "author" &&
+          key !== "ROWID"
+        ) {
+          conditions.push(`${key} = ?`);
+          params.push(`${value}`);
+        }
+      }
+      params.push(`${paperData.ROWID}`);
+      query += `${conditions.join(",")} WHERE ROWID = ?`;
+      await this.db.run(query, params);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+
   /*
    * Parameters:
    *  - author: the name of the author to be added/retrieved
@@ -173,7 +246,7 @@ export class DatabaseController {
    * Returns:
    *  - number: The ROWID of the author.
    */
-  private async getOrCreateAuthor(author: string): Promise<number> {
+  private async getOrCreateAuthorByName(author: string): Promise<number> {
     if (!this.db) {
       throw new Error(`Database not initialized`);
     }
@@ -197,6 +270,100 @@ export class DatabaseController {
     }
   }
 
+  /*
+   * Parameters:
+   *  - authors: List of authors given when update is passed
+   *  - paperId: Id of the paper to update
+   * Function: Compares the new list of authors to the current links, if it is
+   *           found that a preexisting link should no longer exist, it is removed.
+   *           If a new link is needed, it is created.
+   * Returns: None
+   */
+  private async syncPaperAuthors(
+    paperId: number,
+    authors: string[],
+  ): Promise<void> {
+    if (!this.db) {
+      throw new Error(`Database not initialized`);
+    }
+
+    try {
+      // Begin transaction for consistency
+      await this.db.exec("BEGIN TRANSACTION");
+
+      // Retrieve the current authors linked to the paper
+      const currentAuthors = await this.db.all<
+        { author_id: number; name: string }[]
+      >(
+        `
+        SELECT a.name
+        FROM paper_author_join paj
+        INNER JOIN author a ON paj.author_id = a.ROWID
+        WHERE paj.paper_id = ?
+        `,
+        [paperId],
+      );
+
+      // Extract names of current authors
+      const currentAuthorNames = currentAuthors.map((author) => author.name);
+
+      // Identify authors to add
+      const authorsToAdd = authors.filter(
+        (author) => !currentAuthorNames.includes(author),
+      );
+
+      // Identify authors to remove
+      const authorsToRemove = currentAuthorNames.filter(
+        (author) => !authors.includes(author),
+      );
+
+      // Add new author links
+      for (const authorName of authorsToAdd) {
+        // Ensure the author exists in the `author` table
+        const row = await this.db.get<{ ROWID: number }>(
+          `
+          INSERT OR IGNORE INTO author (name) VALUES (?);
+          SELECT ROWID FROM author WHERE name = ?;
+          `,
+          [authorName, authorName],
+        );
+
+        if (!row || typeof row.ROWID !== "number") {
+          throw new Error(`Failed to retrieve ROWID for author: ${authorName}`);
+        }
+        // Link the author to the paper using the retrieved ROWID
+        await this.db.run(
+          `
+          INSERT INTO paper_author_join (paper_id, author_id) VALUES (?, ?)
+          `,
+          [paperId, row.ROWID],
+        );
+      }
+
+      // Remove unwanted author links
+      for (const authorName of authorsToRemove) {
+        await this.db.run(
+          `
+          DELETE FROM paper_author_join
+          WHERE paper_id = ?
+          AND author_id = (SELECT ROWID FROM author WHERE name = ?)
+          `,
+          [paperId, authorName],
+        );
+      }
+
+      // Commit the transaction
+      await this.db.exec("COMMIT");
+    } catch (error) {
+      // Rollback the transaction on error
+      await this.db.exec("ROLLBACK");
+      console.error(
+        `Failed to sync authors for paperID: ${paperId}\nError: ${error}`,
+      );
+      throw error;
+    }
+  }
+
   /*
    * Parameters:
    *  - authorId: The ROWID of the author to link
@@ -212,8 +379,12 @@ export class DatabaseController {
   ): Promise<void> {
     try {
       await this.db.run(
-        "INSERT INTO paper_author_join (paper_id, author_id) VALUES (?, ?)",
-        [paperId, authorId],
+        `INSERT INTO paper_author_join (paper_id, author_id)
+        SELECT ?, ?
+        WHERE NOT EXISTS (
+        SELECT 1 FROM paper_author_join WHERE paper_id = ? AND author_id = ?
+        )`,
+        [paperId, authorId, paperId, authorId],
       );
     } catch (error) {
       console.error(
@@ -223,6 +394,35 @@ export class DatabaseController {
     }
   }
 
+  /*
+   * Parameters:
+   *  - authorId: The ROWID of the author to check
+   *  - paperId: The ROWID of the paper to checl
+   * Function: Checks for the existence of an entry in author_paper_join table.
+   *           This
+   * Returns: None
+   */
+  private async checkPaperToAuthorLink(
+    authorId: number,
+    paperId: number,
+  ): Promise<boolean> {
+    if (!this.db) {
+      throw new Error(`Database not initialized`);
+    }
+    try {
+      const row = await this.db.get(
+        "SELECT * FROM paper_author_join WHERE paper_id = ? AND author_id = ?",
+        [paperId, authorId],
+      );
+      return !!row; // Return true if a row is found, otherwise false
+    } catch (error) {
+      console.error(
+        `Problem retrieving paper-author link for authorID: ${authorId}, paperID: ${paperId}\n Error: ${error}`,
+      );
+      throw error;
+    }
+  }
+
   /*
    * Parameters: None
    * Function: Gets the total number of papers in the table 'paper'
@@ -262,7 +462,6 @@ export class DatabaseController {
     let query = `
       SELECT 
         p.*,
-        p.ROWID AS id, 
         GROUP_CONCAT(a.name, ', ') AS author
       FROM 
         paper p
@@ -278,7 +477,6 @@ export class DatabaseController {
 
     return new Promise<TableData[]>(async (resolve, reject) => {
       try {
-       
         const result = await this.db.all(query, `${search}%`);
         console.log("Query executed successfully:");
 
@@ -296,22 +494,15 @@ export class DatabaseController {
     });
   }
 
-  async getFilteredData(queryData: GetQuery): Promise<RadData[]> {
+  async getFilteredData(queryData: GetQuery): Promise<TableData[]> {
     if (!this.db) {
       throw new Error("Database not initialized");
     }
 
     // Base SELECT query
     let query = `
       SELECT 
-        p.year, 
-        p.paper_name, 
-        p.part_no, 
-        p.type, 
-        p.manufacturer, 
-        p.data_type, 
-        p.testing_location, 
-        p.testing_type,  
+        p.*, 
         GROUP_CONCAT(a.name, ', ') AS author
       FROM 
         paper p
@@ -354,13 +545,13 @@ export class DatabaseController {
 
     console.log(query);
 
-    return new Promise<RadData[]>(async (resolve, reject) => {
+    return new Promise<TableData[]>(async (resolve, reject) => {
       try {
         const result = await this.db.all(query, params);
         console.log("Query executed successfully:");
 
         // Map rows to RadData format
-        const radData: RadData[] = result.map((row) => ({
+        const radData: TableData[] = result.map((row) => ({
           ...row,
           author: row.author ? row.author.split(", ") : [],
         }));

server/src/routes/cascade-router.ts

@@ -1,6 +1,6 @@
 import express, { Request, Response, Router } from "express";
 import { DatabaseController } from "../database-controller";
-import { GetQuery, RadData, Testing } from "../types";
+import { GetQuery, TableData, Testing } from "../types";
 import authenticateJWT from "../auth/jwt-auth";
 
 
@@ -30,7 +30,7 @@ export default function cascadeRouter(
   router.post("/tableRequest", (req: Request, res: Response) => {
     try {
       getFilteredRows(requestFromJSON(req.body), dbController).then(
-        (result: RadData[]) => {
+        (result: TableData[]) => {
           res.send(responseToJSON(result));
         },
       );
@@ -45,14 +45,14 @@ export default function cascadeRouter(
 function getFilteredRows(
   getData: GetQuery,
   dbcontroller: DatabaseController,
-): Promise<RadData[]> {
+): Promise<TableData[]> {
   return dbcontroller.getFilteredData(getData);
 }
 
 function requestFromJSON(body: any) {
   return body as GetQuery;
 }
 
-function responseToJSON(radDataArray: RadData[]): string {
+function responseToJSON(radDataArray: TableData[]): string {
   return JSON.stringify(radDataArray, null, 2); // null and 2 prettify the JSON
 }