chore: add slonik validation and transformation interceptors (#64)

* chore: add slonik validation and transformation interceptors

* chore: add response types for validation

* chore(services): adjust types and return objects for validation

* chore(routes): use response type in drafts, proposals, and votes

* chore(database): change 'email' column name for validation

* chore: adjust types in test helpers for validation

* chore: add countSchema to count queries for validation

* fix: remove type assertion from helper function queries

* fix(database): use custom type parser for dates

* chore: use param objects for proposals, drafts, and votes services

* fix(drafts): remove 'optional' from types

Author: randomontherun

database/db_init.sql

@@ -57,7 +57,7 @@ CREATE TABLE if NOT EXISTS drafts (
      id SERIAL PRIMARY KEY,
      created TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL,
      updated TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL,
-     email TEXT NOT NULL
+     voter_email TEXT NOT NULL
 );
 
 CREATE OR REPLACE TRIGGER set_updated

database/index.ts

@@ -1,14 +1,35 @@
 import { DatabasePool, sql } from 'slonik';
 import { 
-	createPool, 
+	createPool,
+    type Interceptor,
+    type QueryResultRow,
+    SchemaValidationError
 } from 'slonik';
+import {
+  createFieldNameTransformationInterceptor
+} from 'slonik-interceptor-field-name-transformation';
 
 const DB_URL = process.env.DB_URL || 'postgres://postgres:postgres@db:5432/postgres';
 const CA_CERT = process.env.CA_CERT
 let pool: DatabasePool;
 
+const customTypeParsers = [
+  {
+    name: 'timestamptz',
+    parse: (value: string) => {
+      return value;
+    }
+  }
+];
+
 const baseConfig = {
-  typeParsers:[]
+  interceptors: [
+    createFieldNameTransformationInterceptor({
+      format: 'CAMEL_CASE'
+    }),
+    createResultParserInterceptor()
+  ],
+  typeParsers: customTypeParsers
 }
 
 const envConfigs: {[env:string]:{}} = {
@@ -48,3 +69,33 @@ export async function resetDatabase(){
     async (connection) => await connection.query(sql.unsafe`TRUNCATE votes CASCADE`)
   )
 }
+
+function createResultParserInterceptor(): Interceptor {
+  return {
+    // If you are not going to transform results using Zod, then you should use `afterQueryExecution` instead.
+    // Future versions of Zod will provide a more efficient parser when parsing without transformations.
+    // You can even combine the two – use `afterQueryExecution` to validate results, and (conditionally)
+    // transform results as needed in `transformRow`.
+    transformRow: async (executionContext, actualQuery, row) => {
+      const { log, resultParser } = executionContext;
+
+      if (!resultParser) {
+        return row;
+      }
+
+      // It is recommended (but not required) to parse async to avoid blocking the event loop during validation
+      const validationResult = await resultParser.safeParseAsync(row);
+
+      if (!validationResult.success) {
+        console.log('Validation failed:', validationResult.error.issues);
+        throw new SchemaValidationError(
+            actualQuery,
+            row,
+            validationResult.error.issues
+        );
+      }
+
+      return validationResult.data as QueryResultRow;
+    },
+  };
+}

helpers.ts

@@ -1,5 +1,5 @@
 import { SchemaValidationError } from "slonik";
-import { AnyZodObject, ZodError } from "zod";
+import { AnyZodObject, ZodError, z } from "zod";
 import { Request, Response, NextFunction } from "express";
 
 export function formatQueryErrorResponse(e: SchemaValidationError) {

package-lock.json

@@ -19,6 +19,7 @@
     "jsonwebtoken": "9.0.2",
     "slonik": "^40.2.1",
     "slonik-utilities": "^2.0.2",
+    "slonik-interceptor-field-name-transformation": "40.2.4",
     "zod": "^3.22.4"
   },
   "devDependencies": {

package.json

@@ -2,7 +2,7 @@ import express from "express";
 import DraftsService from '../services/drafts';
 import { SchemaValidationError } from 'slonik';
 import {filterNullValues, formatQueryErrorResponse, validateRequest} from '../helpers';
-import {PendingDraft, DraftUpdate, Draft} from '../types/draft';
+import {PendingDraft, DraftUpdate, DraftResponse} from '../types/draft';
 import { z } from "zod";
 
 const router = express.Router();
@@ -56,10 +56,15 @@ router.get("/", validateRequest(IndexRequest), async (req, res) => {
   try {
     if (recordId) {
       let draft = await DraftsService.show(recordId);
-      draft = filterNullValues(draft) as Draft
+      draft = filterNullValues(draft) as DraftResponse
       return res.status(200).json(draft);
     } else {
-      let drafts = await DraftsService.index(req.user.userEmail, type, cursor, limit);
+      let drafts = await DraftsService.index({
+        email: req.user.userEmail,
+        type,
+        cursor,
+        limit
+      });
       if (drafts.length === 0) {
         return res.status(404).json({ message: 'No drafts found' });
       }
@@ -68,7 +73,7 @@ router.get("/", validateRequest(IndexRequest), async (req, res) => {
         drafts = drafts.slice(0, limit);
         nextCursor = (cursor ?? 0) + limit;
       }
-      const filteredDrafts = drafts.map(filterNullValues) as Draft[]
+      const filteredDrafts = drafts.map(filterNullValues) as DraftResponse[]
       const response  = {
         limit: limit || drafts.length,
         drafts: filteredDrafts,
@@ -91,8 +96,11 @@ router.post("/", validateRequest(PostRequest), async (req, res) => {
   const validationResult = req.validated.body as PendingDraft
 
   try{
-    let draft = await DraftsService.store(validationResult, req.user.userEmail);
-    draft = filterNullValues(draft) as Draft
+    let draft = await DraftsService.store({
+      data: validationResult,
+      email: req.user.userEmail
+    });
+    draft = filterNullValues(draft) as DraftResponse
 
     return res.status(201).json(draft);
   }catch(e){
@@ -105,7 +113,7 @@ router.put("/", validateRequest(PutRequest), async (req, res) => {
   const { recordId } = req.validated.query as RecordQuery;
   const validationResult = req.validated.body as PendingDraft;
   try {
-    const draft = await DraftsService.update(recordId, validationResult);
+    const draft = await DraftsService.update({ id: recordId, data: validationResult });
     return res.status(200).json(draft);
   } catch (e) {
     if (e instanceof Error && e.message.includes('Draft not found')) {
@@ -120,7 +128,7 @@ router.patch("/", validateRequest(PatchRequest), async (req, res) => {
   const { recordId } = req.validated.query as RecordQuery;
   const validationResult = req.validated.body as DraftUpdate;
   try {
-    const draft = await DraftsService.update(recordId, validationResult);
+    const draft = await DraftsService.update({ id: recordId, data: validationResult });
     return res.status(200).json(draft);
   } catch (e) {
     if (e instanceof Error && e.message.includes('Draft not found')) {

routes/drafts.ts

@@ -2,7 +2,7 @@ import express from 'express';
 import ProposalsService from '../services/proposals';
 import { SchemaValidationError } from 'slonik';
 import { NotFoundError, filterNullValues, formatQueryErrorResponse, validateRequest } from '../helpers';
-import { PendingProposal, Proposal } from '../types/proposal';
+import { PendingProposal, ProposalResponse } from '../types/proposal';
 import VotesRouter from "./votes";
 import { z } from "zod";
 
@@ -42,10 +42,16 @@ router.get("/", validateRequest(IndexRequest), async (req, res) => {
   try {
     if (recordId) {
       let proposal = await ProposalsService.show(recordId);
-      proposal = filterNullValues(proposal) as Proposal
+      proposal = filterNullValues(proposal) as ProposalResponse
       return res.status(200).json(proposal);
     } else {
-      let proposals = await ProposalsService.index(type, status, cursor, limit, req.user.userEmail);
+      let proposals = await ProposalsService.index({
+        type: type,
+        status: status,
+        cursor: cursor,
+        limit: limit,
+        userEmail: req.user.userEmail
+      });
       if (proposals.length === 0) {
         return res.status(404).json({ message: 'No proposals found' });
       }
@@ -54,7 +60,7 @@ router.get("/", validateRequest(IndexRequest), async (req, res) => {
         proposals = proposals.slice(0, limit); // Remove the extra draft
         nextCursor = (cursor ?? 0) + limit;
       }
-      proposals = proposals.map(filterNullValues) as Proposal[]
+      proposals = proposals.map(filterNullValues) as ProposalResponse[]
       const response = {
         limit: limit || proposals.length,
         proposals: proposals,
@@ -79,8 +85,12 @@ router.post("/", validateRequest(PostRequest), async (req, res) => {
   const validationResult = req.validated.body as PendingProposal
 
   try {
-    let proposal = await ProposalsService.store(validationResult, req.user.userFullName, req.user.userEmail);
-    proposal = filterNullValues(proposal) as Proposal
+    let proposal = await ProposalsService.store({
+      data: validationResult,
+      author: req.user.userFullName,
+      email: req.user.userEmail
+    });
+    proposal = filterNullValues(proposal) as ProposalResponse
     return res.status(201).json(proposal);
   } catch (e) {
     console.log(e)

routes/proposals.ts

@@ -1,7 +1,7 @@
 import express from "express";
 import VotesService from '../services/votes';
 import {filterNullValues, validateRequest} from '../helpers';
-import {PendingVote, Vote} from '../types/vote';
+import {PendingVote, VoteResponse} from '../types/vote';
 import { z } from "zod";
 
 const router = express.Router();
@@ -28,9 +28,14 @@ router.post("/", validateRequest(PostRequest), async (req, res) => {
   const { recordId } = req.validated.query as RecordQuery
   const validationResult = req.validated.body as PendingVote
 
+  console.log('Received data for storing vote:', { recordId, validationResult, userEmail: req.user.userEmail });
+
   try{
-    let vote = await VotesService.store(validationResult, recordId, req.user.userEmail);
-    vote = filterNullValues(vote) as Vote;
+    let vote = await VotesService.store({
+      data: validationResult,
+      recordId,
+      email: req.user.userEmail});
+    vote = filterNullValues(vote) as VoteResponse;
     return res.status(201).json(vote);
   }catch(e){
     console.log(e)
@@ -41,7 +46,7 @@ router.post("/", validateRequest(PostRequest), async (req, res) => {
 router.delete("/", validateRequest(DeleteRequest), async (req, res) => {
   const { recordId } = req.validated.query as RecordQuery
   try {
-    const rowCount = await VotesService.destroy(recordId, req.user.userEmail);
+    const rowCount = await VotesService.destroy({ recordId, email: req.user.userEmail });
     if (rowCount === 0) {
       return res.status(404).json({message: 'Vote not found'})
     }

routes/votes.ts

@@ -1,19 +1,35 @@
 import { getPool } from '../database';
 import { sql} from 'slonik';
 import {update as slonikUpdate} from 'slonik-utilities';
-import {Draft, DraftBody, DraftUpdate, PendingDraft} from '../types/draft';
+import {Draft, DraftBody, DraftResponse, DraftUpdate, PendingDraft} from '../types/draft';
 import {filterNullValues} from "../helpers";
-import {number} from "zod";
 import { faker } from "@faker-js/faker";
 
-async function index(email: string, type?: string, cursor?: number, limit?: number): Promise<readonly Draft[]> {
+interface IndexParams {
+	email: string;
+	type?: string;
+	cursor?: number;
+	limit?: number;
+}
+
+interface StoreParams {
+	data: DraftUpdate;
+	email: string;
+}
+
+interface UpdateParams {
+	id: number;
+	data: DraftBody;
+}
+
+async function index({ email, type, cursor, limit }: IndexParams): Promise<readonly DraftResponse[]> {
 	const pool = await getPool();
 	return await pool.connect(async (connection) => {
 		const adjustedLimit = limit ? limit + 1 : null;
-		const rows = await connection.any(sql.type(Draft)`
+		const rows = await connection.any(sql.type(DraftResponse)`
 		SELECT id, created, updated, title, summary, description, type 
 		FROM drafts
-		WHERE email = ${email}
+		WHERE voter_email = ${email}
 		${type ? sql.fragment`AND type = ${type}` : sql.fragment``}
 		ORDER BY id 
 		OFFSET ${cursor ?? null} 
@@ -23,22 +39,23 @@ async function index(email: string, type?: string, cursor?: number, limit?: numb
 	});
 }
 
-async function store(data: DraftUpdate, email: string): Promise<Draft> {
+async function store({ data, email }: StoreParams): Promise<DraftResponse> {
 	const pool = await getPool();
 	return await pool.connect(async (connection) => {
 		const draft = await connection.one(sql.type(Draft)`
-		INSERT INTO drafts (title, summary, description, type, email) 
+		INSERT INTO drafts (title, summary, description, type, voter_email) 
 		VALUES (${data.title ?? null}, ${data.summary ?? null}, ${data.description ?? null}, ${data.type ?? null}, ${email}) 
-		RETURNING id, created, updated, title, summary, description, type;`)
+		RETURNING *;`)
 
-		return draft;
+		const { voterEmail, ...rest } = draft
+		return rest;
 	});
 }
 
-async function show(id: number): Promise<Draft> {
+async function show(id: number): Promise<DraftResponse> {
 	const pool = await getPool();
 	return await pool.connect(async (connection) => {
-		const draft = await connection.maybeOne(sql.type(Draft)`
+		const draft = await connection.maybeOne(sql.type(DraftResponse)`
 		SELECT id, created, updated, title, summary, description, type 
 		FROM drafts 
 		WHERE id = ${id};`)
@@ -48,7 +65,7 @@ async function show(id: number): Promise<Draft> {
 	});
 }
 
-async function update(id: number, data: DraftBody): Promise<Draft> {
+async function update({ id, data }: UpdateParams): Promise<Draft> {
 	const pool = await getPool();
 	return await pool.connect(async (connection) => {
 		const result = await slonikUpdate(
@@ -81,7 +98,7 @@ async function destroy(id: number) {
 async function count(): Promise<number> {
 	const pool = await getPool();
 	return await pool.connect(async (connection) => {
-		const result = await connection.oneFirst(sql.type(number())`
+		const result = await connection.oneFirst(sql.unsafe`
         SELECT COUNT(*) FROM drafts;`);
 		return Number(result);
 	});