Merge pull request #9 from JerryImMouse/each-route

Route to process each extra record and delete fields

Author: JerryImMouse

src/database/generic.ts

@@ -238,6 +238,17 @@ export class RecordExtra implements IRecordExtra {
         return new RecordExtra(db, res.record_id, res.json, res.id);
     }
 
+    public static async findAll<T extends IDatabase>(db: T): Promise<RecordExtra[]> {
+        const res = await db.selectAll<IRecordExtra>(RecordExtra._tableName);
+
+        const resObjects: RecordExtra[] = [];
+        res?.forEach(obj => {
+            resObjects.push(new RecordExtra(db, obj.record_id, obj.json, obj.id))
+        })
+
+        return resObjects;
+    }
+
     public static async create<T extends IDatabase>(db: T, record_id: number, json: string): Promise<RecordExtra> {
         const recordExists = await db.select<IRecordExtra>(RecordExtra._tableName, 'record_id', record_id);
 

src/database/postgres.ts

@@ -124,6 +124,10 @@ export class PostgresDatabase implements IDatabase {
         return this.selectOrOnly(table, {[key]: value});
     }
 
+    public selectAll<T>(table: string): Promise<T[] | null> {
+        return this.selectOrOnly(table, {});
+    }
+
     public async selectOrOnly<T>(table: string, data: Record<string, string | number>): Promise<T | null> {
         const columns = Object.keys(data);
         const values = Object.values(data);
@@ -145,6 +149,27 @@ export class PostgresDatabase implements IDatabase {
         }
     }
 
+    public async selectOr<T>(table: string, data: Record<string, string | number>): Promise<T[] | null> {
+        const columns = Object.keys(data);
+        const values = Object.values(data);
+
+        const conditions = columns.map((column, idx) => `${column} = $${idx + 1}`).join(" OR ");
+        const query = columns.length !== 0 ? `SELECT * FROM ${table} WHERE ${conditions}` : `SELECT * FROM ${table};`;
+
+        try {
+            const result = await this._connection.query(query, values);
+
+            if (result.rows.length > 0) {
+                return result.rows as T[];
+            }
+
+            return null;
+        } catch (err) {
+            this._handleError(query, err);
+            return null;
+        }
+    }
+
     public async selectLimitOffsetLike<T>(
         table: string, 
         offset: number, 

src/database/sqlite.ts

@@ -135,6 +135,10 @@ export class SqliteDatabase implements IDatabase {
         return this.selectOrOnly(table, {[key]: value});
     }
 
+    public selectAll<T>(table: string): Promise<T[] | null> {
+        return this.selectOr(table, {});
+    }
+
     public selectOrOnly<T>(table: string, data: Record<string, string | number>): Promise<T | null> {
         const columns = Object.keys(data);
         const values = Object.values(data);
@@ -154,6 +158,25 @@ export class SqliteDatabase implements IDatabase {
         })
     }
 
+    public selectOr<T>(table: string, data: Record<string, string | number>): Promise<T[] | null> {
+        const columns = Object.keys(data);
+        const values = Object.values(data);
+
+        const conditions = columns.map(column => `${column} = ?`).join(" OR ");
+        const query = columns.length !== 0 ? `SELECT * FROM ${table} WHERE ${conditions}` : `SELECT * FROM ${table};`;
+
+        return new Promise((resolve, reject) => {
+            this._connection.all(query, values, (err, rows) => {
+                if (!this._handleError(query, err)) {
+                    reject(false);
+                    return;
+                }
+
+                resolve(rows ? rows as T[] : null);
+            })
+        })
+    }
+
     // i really don't like how I called it, but.. okay
     public selectLimitOffsetLike<T>(
         table: string, 

src/types/database.d.ts

@@ -2,8 +2,10 @@ export interface IDatabase {
     init(): Promise<boolean>;
     execute(sql: string, params: (string | number)[]): Promise<boolean>;
     select<T>(table: string, key: string, value: string | number): Promise<T | null>;
+    selectAll<T>(table: string): Promise<T[] | null>;
     selectLimitOffsetLike<T>(table: string, offset: number, limit: number, data: Record<string, string | number> | undefined = undefined): Promise<T[] | null>;
     selectOrOnly<T>(table: string, data: Record<string, string | number>): Promise<T | null>
+    selectOr<T>(table: string, data: Record<string, string | number>): Promise<T[] | null>
     upsert(table: string, data: Record<string, string | number>): Promise<number | null>;
 
     delete(table: string, key: string, value: string | number): Promise<boolean>;

src/web/controllers/api.ts

@@ -4,9 +4,11 @@ import { findRecordByBody, findRecordByQuery, validateToken } from '../middlewar
 import { WebHelpers } from '../helpers';
 import { RecordExtendedRequest } from '../../types/web';
 import { Database, RecordExtra } from '../../database/generic';
+import { Logger } from '../../logging';
 
 const apiStuff = [checkApiToken, findRecordByQuery, validateToken];
 const dbImpl = Database.getDbImpl();
+const log = Logger.get();
 
 /// Here is the format
 /// getMETHODNAME - GET /api/METHODNAME
@@ -20,6 +22,9 @@ export class ApiController {
         router.get('/extra', [checkApiToken, findRecordByQuery], this.getExtraData);
         router.patch('/extra', [checkApiToken, findRecordByQuery], this.patchExtraData);
         router.post('/delete', [checkApiToken, findRecordByBody], this.postDelete);
+
+        router.delete('/each/extra', [checkApiToken], this.deleteEachExtraData);
+
         router.get('/link', this.getLink);
         return router;
     }
@@ -74,6 +79,7 @@ export class ApiController {
         }
 
         res.status(200).contentType('application/json').send(record.extra.json); // manually set content-type because our `json` field is a json str already
+        log.debug(`Returned extra data for ${record.discord_uid}`, JSON.parse(record.extra.json));
     }
 
     public static async patchExtraData(req: RecordExtendedRequest, res: Response) {
@@ -91,6 +97,35 @@ export class ApiController {
         record.extra.json = merged;
 
         await record.extra.save();
+        
+        res.status(200).send();
+        log.debug(`Set extra data for ${record.discord_uid}`, JSON.parse(record.extra.json));
+    }
+
+    public static async deleteEachExtraData(req: Request, res: Response) {
+        const fields = req.body['fields'] as string[] | undefined;
+        if (!fields) {
+            res.status(400).json({error: "Fields is not supplied"});
+            return;
+        }
+
+        const allRecords = await RecordExtra.findAll(dbImpl);
+
+        for (const record of allRecords) {
+            try {
+                const jsonData = JSON.parse(record.json);
+                
+                fields.forEach(field => {
+                    delete jsonData[field];
+                });
+
+                record.json = JSON.stringify(jsonData);
+                await record.save();
+            } catch (error) {
+                console.error("Failed to process record:", error);
+            }
+        }
+
         res.status(200).send();
     }