Release 22 May

.env.example

@@ -2,4 +2,5 @@ DATABASE_URL=
 WHITELISTED_ORIGINS=
 TUNNEL_DOMAINS=
 JWT_SECRET=
-VERIFICATION_LEVEL="device" # "orb" or "device", default is "device"
+ENABLE_VOTE_NORMALIZATION=
+VERIFICATION_LEVEL="device" # "orb" or "device", default is "device"

prisma/migrations/20250503203644_add_poll_status/migration.sql

@@ -0,0 +1,5 @@
+-- CreateEnum
+CREATE TYPE "PollStatus" AS ENUM ('DRAFT', 'PUBLISHED');
+
+-- AlterTable
+ALTER TABLE "Poll" ADD COLUMN     "status" "PollStatus" NOT NULL DEFAULT 'PUBLISHED';

prisma/migrations/20250503214151_make_poll_fields_optional/migration.sql

@@ -0,0 +1,4 @@
+-- AlterTable
+ALTER TABLE "Poll" ALTER COLUMN "title" DROP NOT NULL,
+ALTER COLUMN "startDate" DROP NOT NULL,
+ALTER COLUMN "endDate" DROP NOT NULL;

prisma/migrations/20250512113354_add_generated_normalized_votes/migration.sql

@@ -0,0 +1,109 @@
+-- First drop the existing trigger that might be using these functions
+DROP TRIGGER IF EXISTS normalize_weights_trigger ON "Vote";
+
+-- Drop existing functions for clean recreation
+DROP FUNCTION IF EXISTS update_normalized_weights();
+DROP FUNCTION IF EXISTS json_normalize_weights(jsonb, integer);
+
+-- Recreate the normalize weights function with IMMUTABLE
+CREATE OR REPLACE FUNCTION json_normalize_weights(weight_distribution JSONB, voting_power INTEGER)
+RETURNS JSONB AS $$
+DECLARE
+  total NUMERIC := 0;
+  weight NUMERIC;
+  key TEXT;
+  normalized_weights JSONB := '{}'::JSONB;
+  normalized_total NUMERIC := 0;
+  diff INTEGER;
+  first_nonzero_key TEXT := NULL;
+BEGIN
+  -- First check if input is a valid JSON object
+  IF weight_distribution IS NULL OR jsonb_typeof(weight_distribution) != 'object' THEN
+    -- Return empty object if input is not a valid object
+    RETURN '{}'::JSONB;
+  END IF;
+
+  -- Calculate total weights
+  FOR key, weight IN SELECT * FROM jsonb_each_text(weight_distribution)
+  LOOP
+    total := total + weight::NUMERIC;
+  END LOOP;
+
+  -- If total is 0 or already equals target, return original
+  IF total = 0 OR total = voting_power THEN
+    RETURN weight_distribution;
+  END IF;
+
+  -- Normalize each weight
+  FOR key, weight IN SELECT * FROM jsonb_each_text(weight_distribution)
+  LOOP
+    -- Formula: normalizedValue = (weightValue / sumOfAllWeights) * voting_power
+    -- Round to integer to avoid fractional weights
+    normalized_weights := normalized_weights || 
+      jsonb_build_object(key, ROUND((weight::NUMERIC / total) * voting_power));
+
+    -- Keep track of first non-zero value to adjust if necessary
+    IF first_nonzero_key IS NULL AND weight::NUMERIC > 0 THEN
+      first_nonzero_key := key;
+    END IF;
+  END LOOP;
+
+  -- Check if rounding caused total to drift from target
+  SELECT SUM(value::NUMERIC) INTO normalized_total FROM jsonb_each_text(normalized_weights);
+
+  IF normalized_total != voting_power AND first_nonzero_key IS NOT NULL THEN
+    diff := voting_power - normalized_total;
+    normalized_weights := jsonb_set(
+      normalized_weights, 
+      ARRAY[first_nonzero_key], 
+      to_jsonb((normalized_weights->>first_nonzero_key)::NUMERIC + diff)
+    );
+  END IF;
+
+  RETURN normalized_weights;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+-- Make sure calculate_normalized_quadratic_weights is immutable
+DROP FUNCTION IF EXISTS calculate_normalized_quadratic_weights(jsonb);
+
+CREATE OR REPLACE FUNCTION calculate_normalized_quadratic_weights(weights JSONB)
+RETURNS JSONB AS $$
+DECLARE
+  weight NUMERIC;
+  key TEXT;
+  quadratic_weights JSONB := '{}'::JSONB;
+BEGIN
+  -- Calculate quadratic weights for each value
+  FOR key, weight IN SELECT * FROM jsonb_each_text(weights)
+  LOOP
+    -- Formula: quadraticWeight = sqrt(weight)
+    quadratic_weights := quadratic_weights || 
+      jsonb_build_object(key, ROUND(SQRT(weight::NUMERIC), 2));
+  END LOOP;
+
+  RETURN quadratic_weights;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
+
+-- Only drop and recreate the columns we're interested in
+ALTER TABLE "Vote" DROP COLUMN IF EXISTS "normalizedWeightDistribution";
+ALTER TABLE "Vote" DROP COLUMN IF EXISTS "normalizedQuadraticWeights";
+
+-- Add generated columns
+ALTER TABLE "Vote" ADD COLUMN "normalizedWeightDistribution" JSONB 
+  GENERATED ALWAYS AS (json_normalize_weights("weightDistribution", "votingPower")) STORED;
+
+ALTER TABLE "Vote" ADD COLUMN "normalizedQuadraticWeights" JSONB 
+  GENERATED ALWAYS AS (calculate_normalized_quadratic_weights(json_normalize_weights("weightDistribution", "votingPower"))) STORED;
+
+-- Comment explaining usage
+COMMENT ON FUNCTION json_normalize_weights IS 
+  'Normalizes a JSON weight distribution so values sum to the specified voting power. 
+   Usage: SELECT json_normalize_weights(''{"option1": 10, "option2": 15}'', 100)
+   Returns: {"option1": 40, "option2": 60}';
+
+COMMENT ON FUNCTION calculate_normalized_quadratic_weights IS
+  'Calculates quadratic weights from linear weights.
+   Usage: SELECT calculate_normalized_quadratic_weights(''{"option1": 40, "option2": 60}'')
+   Returns: {"option1": 6.32, "option2": 7.75}'; 

prisma/migrations/20250514122507_add_created_at_to_user_schema/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP;

prisma/schema.prisma

@@ -14,6 +14,7 @@ model User {
   profilePicture         String?
   pollsCreatedCount      Int          @default(0)
   pollsParticipatedCount Int          @default(0)
+  createdAt              DateTime     @default(now())
   createdPolls           Poll[]       @relation("PollAuthor")
   actions                UserAction[]
   votes                  Vote[]
@@ -33,35 +34,43 @@ model UserAction {
 model Poll {
   pollId           Int                      @id @default(autoincrement())
   authorUserId     Int
-  title            String
+  title            String?
   description      String?
   options          String[]
   creationDate     DateTime                 @default(now())
-  startDate        DateTime
-  endDate          DateTime
+  startDate        DateTime?
+  endDate          DateTime?
   tags             String[]
   isAnonymous      Boolean                  @default(false)
   participantCount Int                      @default(0)
   voteResults      Json
   searchVector     Unsupported("tsvector")?
+  status           PollStatus               @default(PUBLISHED)
   author           User                     @relation("PollAuthor", fields: [authorUserId], references: [id])
   userAction       UserAction[]
   votes            Vote[]
 }
 
 model Vote {
-  voteID             String @id @default(uuid())
-  userId             Int
-  pollId             Int
-  votingPower        Int
-  weightDistribution Json
-  proof              String
-  quadraticWeights   Json?  @default(dbgenerated("calculate_quadratic_weights(\"weightDistribution\")"))
-  poll               Poll   @relation(fields: [pollId], references: [pollId], onDelete: Cascade)
-  user               User   @relation(fields: [userId], references: [id])
+  voteID                       String @id @default(uuid())
+  userId                       Int
+  pollId                       Int
+  votingPower                  Int
+  weightDistribution           Json
+  proof                        String
+  quadraticWeights             Json?  @default(dbgenerated("calculate_quadratic_weights(\"weightDistribution\")"))
+  normalizedWeightDistribution Json?  @default(dbgenerated("json_normalize_weights(\"weightDistribution\", \"votingPower\")"))
+  normalizedQuadraticWeights   Json?  @default(dbgenerated("calculate_normalized_quadratic_weights(json_normalize_weights(\"weightDistribution\", \"votingPower\"))"))
+  poll                         Poll   @relation(fields: [pollId], references: [pollId], onDelete: Cascade)
+  user                         User   @relation(fields: [userId], references: [id])
 }
 
 enum ActionType {
   CREATED
   VOTED
 }
+
+enum PollStatus {
+  DRAFT
+  PUBLISHED
+}

src/app.module.ts

@@ -4,12 +4,13 @@ import { AppService } from './app.service';
 import { DatabaseService } from './database/database.service';
 import { DatabaseModule } from './database/database.module';
 import { PollModule } from './poll/poll.module';
+import { VoteModule } from './vote/vote.module';
 import { AuthModule } from './auth/auth.module';
 import { AuthService } from './auth/auth.service';
 import { UserModule } from './user/user.module';
 
 @Module({
-  imports: [DatabaseModule, PollModule, UserModule, AuthModule],
+  imports: [DatabaseModule, PollModule, VoteModule, UserModule, AuthModule],
   controllers: [AppController],
   providers: [AppService, DatabaseService, AuthService],
 })

src/common/common.dto.ts

@@ -0,0 +1,15 @@
+import { IsDateString, IsOptional, IsString, Matches } from 'class-validator';
+
+export class GetCountDto {
+  @IsOptional()
+  @IsString()
+  @Matches(/^\d{4}-\d{2}-\d{2}$/)
+  @IsDateString({ strict: true })
+  from?: string;
+
+  @IsOptional()
+  @IsString()
+  @Matches(/^\d{4}-\d{2}-\d{2}$/)
+  @IsDateString({ strict: true })
+  to?: string;
+}

src/poll/Poll.dto.ts

@@ -9,7 +9,9 @@ import {
   IsOptional,
   IsString,
   Min,
+  Validate,
 } from 'class-validator';
+import { IsPositiveInteger } from '../common/validators';
 
 export class CreatePollDto {
   @IsString()
@@ -43,6 +45,43 @@ export class CreatePollDto {
   isAnonymous?: boolean;
 }
 
+export class DraftPollDto {
+  @IsOptional()
+  @IsString()
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  options?: string[];
+
+  @IsOptional()
+  @IsDateString()
+  startDate?: string;
+
+  @IsOptional()
+  @IsDateString()
+  endDate?: string;
+
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  tags?: string[];
+
+  @IsOptional()
+  @IsBoolean()
+  isAnonymous?: boolean;
+
+  @IsOptional()
+  @Validate(IsPositiveInteger)
+  @Transform(({ value }) => (value ? parseInt(value, 10) : undefined))
+  pollId?: number;
+}
+
 export class GetPollsDto {
   @IsString()
   @IsOptional()
@@ -83,3 +122,10 @@ export class GetPollsDto {
   @IsEnum(['asc', 'desc'])
   sortOrder?: 'asc' | 'desc';
 }
+
+export class GetPollVotesDto {
+  @IsInt()
+  @Type(() => Number)
+  @IsNotEmpty()
+  pollId: number;
+}

src/poll/poll.controller.ts

@@ -4,12 +4,15 @@ import {
   Delete,
   Get,
   Param,
+  Patch,
   Post,
   Query,
 } from '@nestjs/common';
-import { CreatePollDto, GetPollsDto } from './Poll.dto';
-import { PollService } from './poll.service';
 import { User } from 'src/auth/user.decorator';
+import { CreatePollDto, DraftPollDto, GetPollsDto } from './Poll.dto';
+import { PollService } from './poll.service';
+import { Public } from 'src/auth/jwt-auth.guard';
+import { GetCountDto } from '../common/common.dto';
 
 @Controller('poll')
 export class PollController {
@@ -23,6 +26,19 @@ export class PollController {
     return await this.pollService.createPoll(dto, worldID);
   }
 
+  @Patch('draft')
+  async patchDraftPoll(
+    @Body() dto: DraftPollDto,
+    @User('worldID') worldID: string,
+  ) {
+    return await this.pollService.patchDraftPoll(dto, worldID);
+  }
+
+  @Get('draft')
+  async getDraftPoll(@User('worldID') worldID: string) {
+    return await this.pollService.getUserDraftPoll(worldID);
+  }
+
   @Get()
   async getPolls(
     @Query() query: GetPollsDto,
@@ -31,11 +47,22 @@ export class PollController {
     return await this.pollService.getPolls(query, worldID);
   }
 
+  @Get('count')
+  @Public()
+  async getPollsCount(@Query() query: GetCountDto): Promise<number> {
+    return await this.pollService.getPollsCount(query);
+  }
+
   @Get(':id')
   async getPollDetails(@Param('id') id: number) {
     return await this.pollService.getPollDetails(Number(id));
   }
 
+  @Get(':id/votes')
+  async getPollVotes(@Param('id') id: number) {
+    return await this.pollService.getPollVotes(Number(id));
+  }
+
   @Delete(':id')
   async deletePoll(@Param('id') id: number, @User('worldID') worldID: string) {
     const poll = await this.pollService.deletePoll(Number(id), worldID);