fix: backend app.ts & configs

Author: imiskii

backend/ipfs/IPFSClient.ts

@@ -12,7 +12,7 @@ import { MemoryBlockstore } from 'blockstore-core'
 import { MemoryDatastore } from 'datastore-core'
 import { httpGatewayRouting } from '@helia/routers'
 import { trustlessGateway } from '@helia/block-brokers'
-import { kuboBlockBroker } from './KuboBlockBroker'
+import { kuboBlockBroker } from './KuboBlockBroker.ts'
 import { CID } from 'multiformats/cid'
 import { PinataSDK } from 'pinata'
 
@@ -37,13 +37,18 @@ export type IPFSConfig = {
   pinataImagesGroupId?: string // For PRODUCTION mode, required
 } 
 
-export interface IPFSClient {
+export interface IPFSClientInterface {
   uploadBytes: (data: Uint8Array) => Promise<string>
   downloadBytes: (cid: string) => Promise<Uint8Array>
+  uploadJson: (data: JSON) => Promise<string>
+  downloadJson: (cid: string) => Promise<JSON>
+  uploadFile: (file: File) => Promise<string>
+  downloadFile: (cid: string) => Promise<Blob>
+  delete: (cid: string) => Promise<void>
   close: () => Promise<void>
 }
 
-export class HeliaIPFSClient implements IPFSClient {
+export class IPFSClient implements IPFSClientInterface {
   private config: IPFSConfig
   private helia: any
   private pinata: PinataSDK | null = null

backend/ipfs/TaskBoardIPFS.ts

@@ -6,20 +6,20 @@
  */
 
 
-import { HeliaIPFSClient, IPFSMode } from './IPFSClient'
-import { Task } from '../../objects/BoardTask'
-const dotenv = require('dotenv')
+import { IPFSClient, IPFSMode } from './IPFSClient.ts'
+import { Task } from '../../objects/BoardTask.ts'
+import dotenv from 'dotenv'
 
 // Load env variables
 dotenv.config()
 
 // Singletone pattern
-export class TaskBoardIPFS {
+export default class TaskBoardIPFS {
   private static instance: TaskBoardIPFS
-  private ipfs: HeliaIPFSClient
+  private ipfs: IPFSClient
 
   private constructor () {
-    this.ipfs = new HeliaIPFSClient({
+    this.ipfs = new IPFSClient({
       mode: (process.env.IPFS_STORAGE_MODE! as IPFSMode) || IPFSMode.DEVELOPMENT,
       localIPFSApiUrl: process.env.IPFS_LOCAL_API_URL!,
       localIPFSGatewayUrl: process.env.IPFS_LOCAL_GATEWAY_URL!,
@@ -44,43 +44,41 @@ export class TaskBoardIPFS {
    * @returns identifier of task
    * @throws if upload was not successful.
    */
-  public async publishTask(task: Task): Promise<string> {
-    try {
-      const taskData = JSON.stringify(task.toJSON())
-      const taskBytes = new TextEncoder().encode(taskData)
-      const cid = await this.ipfs.uploadBytes(taskBytes)
-      task.ipfsCid = cid
-      task.createdAt = Date.now()
-
-      console.log(`Task "${task.title}" published to IPFS, CID: ${cid}`)
-      return cid
-    } catch (error) {
-      console.error('Failed to publish task:', error)
-      throw new Error(`Failed to publish task "${task.title}": ${error}`)
-    }
+  public async addTask(task: Task): Promise<string> {
+    const cid = await this.ipfs.uploadJson(task.toJSON() as JSON)
+    task.ipfsCid = cid
+    task.createdAt = Date.now()
+    return cid
   }
 
   /**
-   * Download task from IPFS
+   * Download tasks from IPFS
    * @param cid identifier of task
    * @returns object representing the received task.
    * @throws if download was not successful.
    */
-  public async loadTaskFromIPFS(cid: string): Promise<Task> {
-    try {
-      const taskBytes = await this.ipfs.downloadBytes(cid)
-      const taskData = JSON.parse(new TextDecoder().decode(taskBytes))
-      const task = Task.fromJSON(taskData)
-      
-      task.ipfsCid = cid
+  public async getTasks(limit: number, offset: number, filters?: Partial<Task>): Promise<Task[]> {
+    let tasks: Task[] = []
 
-      console.log(`Task "${task.title}" loaded from IPFS, CID: ${cid}`)
-      return task
-    } catch (error) {
-      console.error('Failed to load task from IPFS:', error)
-      throw new Error(`Failed to load task from IPFS ${cid}: ${error}`)
+    // TODO: fetch taskIDs from DB based on filters, limit and offset
+    /*
+    for (const cid in cids) {
+      const jsonTask = await this.ipfs.downloadJson(cid)
+      const task = Task.fromJSON(jsonTask)
+      task.ipfsCid = cid
+      tasks.push(task)
     }
+    */
+    return tasks
   }
 
-  /// TODO: Unpin task from IPFS
+  /**
+   * Delete task from IPFS
+   * @param cid identifier of task
+   * @throws if deletion was not successful.
+   */
+  public async deleteTask(cid: string): Promise<void> {
+    // TODO: DB adjustments
+    await this.ipfs.delete(cid)
+  }
 }

backend/package.json

@@ -1,11 +1,11 @@
 {
   "name": "backend",
   "version": "1.0.0",
-  "main": "index.js",
+  "main": "app.js",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "compile-schemas": "json2ts -i schemas -o types"
+    "dev": "node --loader ts-node/esm src/app.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [],
   "author": "",
@@ -27,6 +27,7 @@
   "devDependencies": {
     "@types/node": "^24.3.0",
     "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
     "typescript": "^5.9.2"
   }
 }

backend/src/TaskManager.ts

@@ -1,45 +1,53 @@
-import Fastify from "fastify";
+import Fastify from "fastify"
 import fastifySwagger from '@fastify/swagger'
 import fastifySwaggerUi from '@fastify/swagger-ui'
-const dotenv = require('dotenv')
+import dotenv from 'dotenv'
+
+import taskRoutes from './routes/taskRoutes.ts';
 
 // Load env variables
 dotenv.config()
 
 
-const app = Fastify({ logger: true })
+async function buildApp() {
+  const app = Fastify({ logger: true })
 
-// Swagger for API documentation
-app.register(fastifySwagger, {
-  swagger: {
-    info: {
-      title: 'CTF Backend API',
-      description: 'API docs for CTF challenge backend',
-      version: '0.1.0'
+  // Swagger for API documentation
+  app.register(fastifySwagger, {
+    swagger: {
+      info: {
+        title: 'CTF Backend API',
+        description: 'API docs for CTF challenge backend',
+        version: '0.1.0'
+      }
     }
-  }
-})
+  })
+
+  app.register(fastifySwaggerUi, {
+    routePrefix: '/docs',
+    uiConfig: { docExpansion: 'full', deepLinking: false }
+  })
 
-app.register(fastifySwaggerUi, {
-  routePrefix: '/docs',
-  uiConfig: { docExpansion: 'full', deepLinking: false }
-})
 
+  // Register routes
+  app.register(taskRoutes, { prefix: '/api' })
 
-// Register routes
-import taskRoutes from "./routes/taskRoutes";
-app.register(taskRoutes, { prefix: '/api' })
+  // Error handler (good practice)
+  app.setErrorHandler((error, request, reply) => {
+    app.log.error(error)
+    reply.status(500).send({ error: 'Internal Server Error' })
+  })
+  
+  return app
+}
 
 // Start server
-const start = async () => {
-  try {
-    await app.listen({ port: Number(process.env.SERVER_PORT) || 3000, host: '0.0.0.0' })
-    app.log.info(`Server running on port ${process.env.SERVER_PORT || 3000}`)    
-  } catch (err) {
+const app = await buildApp()
+app.listen({ port: 3000, host: '0.0.0.0' })
+  .then((address) => {
+    app.log.info(`Server listening at ${address}`)
+  })
+  .catch((err) => {
     app.log.error(err)
     process.exit(1)
-  }
-}
-
-
-start()
+})

backend/src/app.ts

@@ -1,40 +1,73 @@
 import { type FastifyReply, type FastifyRequest } from 'fastify';
 import { type Static } from '@sinclair/typebox'
-import { TaskSchema } from '../schemas/taskSchema'
-import TaskManager from '../TaskManager'
-import { Task } from '../../../objects/BoardTask';
+import { TaskSchema } from '../schemas/taskSchema.ts'
+import TaskBoardIPFS from '../../ipfs/TaskBoardIPFS.ts'
+import { Task } from '../../../objects/BoardTask.ts';
 
 type TaskBody = Static<typeof TaskSchema>
 
-const IPFS = new TaskManager()
+const IPFS = TaskBoardIPFS.getInstance()
 
 export async function createTaskController(
   request: FastifyRequest<{ Body: TaskBody }>,
   reply: FastifyReply
 ) {
-  const task = new Task(request.body)
-  const cid = await IPFS.addTask(task)
-  reply.code(201).send({ ...task.toJSON(), createdAt: task.createdAt, ipfsCid: cid })
+  try {
+    const task = new Task(request.body)
+    const cid = await IPFS.addTask(task)
+    return reply.code(201).send({ ...task.toJSON(), createdAt: task.createdAt, ipfsCid: cid })
+  } catch (error) {
+    request.log.error(error)
+    return reply.code(500).send({ 
+      error: 'Failed to create task',
+      message: 'Could not create task. Please try again later.'
+    })
+  }
+  
 }
 
 
 export async function getTasksController(
   request: FastifyRequest<{ Querystring: { limit?: number; offset?: number; difficulty?: string } }>,
   reply: FastifyReply
 ) {
-  const { limit = 10, offset = 0, difficulty } = request.query
-  const filters: any = {}
-  if (difficulty) filters.difficulty = difficulty
+  try {
+    const { limit = 10, offset = 0, difficulty } = request.query
+    const filters: any = {}
+    if (difficulty) filters.difficulty = difficulty
 
-  const tasks = await IPFS.getTasks(limit, offset, filters)
-  reply.send(tasks.map(t => ({ ...t.toJSON(), createdAt: t.createdAt, ipfsCid: t.ipfsCid })))
+    const tasks = await IPFS.getTasks(limit, offset, filters)
+
+    if (tasks.length === 0) {
+      return reply.code(404).send({
+        error: 'No tasks found',
+        message: 'No tasks match the provided criteria.'
+      })
+    } else {
+      reply.code(200).send(tasks.map(t => ({ ...t.toJSON(), createdAt: t.createdAt, ipfsCid: t.ipfsCid })))
+    }
+  } catch (error) {
+    reply.code(500).send({
+      error: 'Failed to fetch tasks',
+      message: 'Could not retrieve tasks. Please try again later.'
+    }) 
+  }
 }
 
 
 export async function deleteTaskController(
   request: FastifyRequest<{ Params: { cid: string } }>,
   reply: FastifyReply
 ) {
-  await IPFS.deleteTask(request.params.cid)
-  reply.code(204).send()
+  try {
+    const { cid } = request.params
+    await IPFS.deleteTask(cid)
+    return reply.code(204).send()
+  } catch (error) {
+    request.log.error(error)
+    return reply.code(500).send({
+      error: 'Failed to delete task',
+      message: 'Could not delete task. Please try again later.'
+    })
+  }
 }

backend/src/controllers/taskController.ts

@@ -1,6 +1,6 @@
 import { type FastifyPluginAsync } from 'fastify';
-import { TaskResponseSchema, TaskSchema } from '../schemas/taskSchema'
-import { createTaskController, deleteTaskController, getTasksController } from '../controllers/taskController'
+import { TaskResponseSchema, TaskSchema } from '../schemas/taskSchema.ts'
+import { createTaskController, deleteTaskController, getTasksController } from '../controllers/taskController.ts'
 
 const taskRoutes: FastifyPluginAsync = async (app) => {
 

backend/src/routes/taskRoutes.ts

@@ -11,6 +11,8 @@
     "moduleResolution": "node",
     "esModuleInterop": true,
     "target": "esnext",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
     "types": [],
     // For nodejs:
     "lib": ["esnext"],