1 files changed, 78 insertions, 101 deletions

diff --git a/app/Controllers/Http/RecipeController.ts b/app/Controllers/Http/RecipeController.ts
index 5186a11..e43bcf8 100644
--- a/app/Controllers/Http/RecipeController.ts
+++ b/app/Controllers/Http/RecipeController.ts
@@ -1,13 +1,13 @@
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import fs from 'fs-extra';
-import Application from '@ioc:Adonis/Core/Application';
-import path from 'node:path';
-import Recipe from 'App/Models/Recipe';
-import { isCreationEnabled } from 'Config/app';
-import { validator, schema, rules } from '@ioc:Adonis/Core/Validator';
-import targz from 'targz';
-import semver from 'semver';
-import Drive from '@ioc:Adonis/Core/Drive';
+import type { HttpContext } from '@adonisjs/core/http'
+import fs from 'fs-extra'
+import { app } from '@adonisjs/core/services/app'
+import path from 'node:path'
+import Recipe from '#app/Models/Recipe'
+import { isCreationEnabled } from '#config/app'
+import { validator, schema, rules } from '@adonisjs/validator'
+import targz from 'targz'
+import semver from 'semver'
+import Drive from '@ioc:Adonis/Core/Drive'
 
 // TODO: This file needs to be refactored and cleaned up to include types
 
@@ -18,17 +18,17 @@ const createSchema = schema.create({
   //   author: 'required|accepted',
   author: schema.string(),
   svg: schema.string([rules.url()]),
-});
+})
 
 const searchSchema = schema.create({
   needle: schema.string(),
-});
+})
 
 const downloadSchema = schema.create({
   // TODO: Check if this is correct
   //   recipe: 'required|accepted',
   recipe: schema.string(),
-});
+})
 
 const compress = (src: string, dest: string) =>
   new Promise((resolve, reject) => {
@@ -37,87 +37,76 @@ const compress = (src: string, dest: string) =>
         src,
         dest,
       },
-      err => {
+      (err) => {
         if (err) {
-          reject(err);
+          reject(err)
         } else {
-          resolve(dest);
+          resolve(dest)
         }
-      },
-    );
-  });
+      }
+    )
+  })
 
 export default class RecipesController {
   // List official and custom recipes
-  public async list({ response }: HttpContextContract) {
-    const officialRecipes = fs.readJsonSync(
-      path.join(Application.appRoot, 'recipes', 'all.json'),
-    );
-    const customRecipesArray = await Recipe.all();
-    const customRecipes = customRecipesArray.map(recipe => ({
+  public async list({ response }: HttpContext) {
+    const officialRecipes = fs.readJsonSync(path.join(app.appRoot, 'recipes', 'all.json'))
+    const customRecipesArray = await Recipe.all()
+    const customRecipes = customRecipesArray.map((recipe) => ({
       id: recipe.recipeId,
       name: recipe.name,
-      ...(typeof recipe.data === 'string'
-        ? JSON.parse(recipe.data)
-        : recipe.data),
-    }));
+      ...(typeof recipe.data === 'string' ? JSON.parse(recipe.data) : recipe.data),
+    }))
 
-    const recipes = [...officialRecipes, ...customRecipes];
+    const recipes = [...officialRecipes, ...customRecipes]
 
-    return response.send(recipes);
+    return response.send(recipes)
   }
 
   // TODO: Test this endpoint
   // Create a new recipe using the new.html page
-  public async create({ request, response }: HttpContextContract) {
+  public async create({ request, response }: HttpContext) {
     // Check if recipe creation is enabled
     if (isCreationEnabled === 'false') {
-      return response.send(
-        'This server doesn\'t allow the creation of new recipes.',
-      );
+      return response.send("This server doesn't allow the creation of new recipes.")
     }
 
     // Validate user input
-    let data;
+    let data
     try {
-      data = await request.validate({ schema: createSchema });
+      data = await request.validate({ schema: createSchema })
     } catch (error) {
       return response.status(401).send({
         message: 'Invalid POST arguments',
         messages: error.messages,
         status: 401,
-      });
+      })
     }
 
     if (!data.id) {
-      return response.send('Please provide an ID');
+      return response.send('Please provide an ID')
     }
 
     // Check for invalid characters
     if (/\.+/.test(data.id) || /\/+/.test(data.id)) {
-      return response.send(
-        'Invalid recipe name. Your recipe name may not contain "." or "/"',
-      );
+      return response.send('Invalid recipe name. Your recipe name may not contain "." or "/"')
     }
 
     // Clear temporary recipe folder
-    await fs.emptyDir(Application.tmpPath('recipe'));
+    await fs.emptyDir(app.tmpPath('recipe'))
 
     // Move uploaded files to temporary path
-    const files = request.file('files');
+    const files = request.file('files')
     if (!files) {
-      return response.abort('Error processsing files.');
+      return response.abort('Error processsing files.')
     }
-    await files.move(Application.tmpPath('recipe'));
+    await files.move(app.tmpPath('recipe'))
 
     // Compress files to .tar.gz file
-    const source = Application.tmpPath('recipe');
-    const destination = path.join(
-      Application.appRoot,
-      `/recipes/archives/${data.id}.tar.gz`,
-    );
+    const source = app.tmpPath('recipe')
+    const destination = path.join(app.appRoot, `/recipes/archives/${data.id}.tar.gz`)
 
-    compress(source, destination);
+    compress(source, destination)
 
     // Create recipe in db
     await Recipe.create({
@@ -132,123 +121,111 @@ export default class RecipesController {
           svg: data.svg,
         },
       }),
-    });
+    })
 
-    return response.send('Created new recipe');
+    return response.send('Created new recipe')
   }
 
   // Search official and custom recipes
-  public async search({ request, response }: HttpContextContract) {
+  public async search({ request, response }: HttpContext) {
     // Validate user input
-    let data;
+    let data
     try {
-      data = await request.validate({ schema: searchSchema });
+      data = await request.validate({ schema: searchSchema })
     } catch (error) {
       return response.status(401).send({
         message: 'Please provide a needle',
         messages: error.messages,
         status: 401,
-      });
+      })
     }
 
-    const { needle } = data;
+    const { needle } = data
 
     // Get results
-    let results;
+    let results
 
     if (needle === 'ferdium:custom') {
-      const dbResults = await Recipe.all();
-      results = dbResults.map(recipe => ({
+      const dbResults = await Recipe.all()
+      results = dbResults.map((recipe) => ({
         id: recipe.recipeId,
         name: recipe.name,
-        ...(typeof recipe.data === 'string'
-          ? JSON.parse(recipe.data)
-          : recipe.data),
-      }));
+        ...(typeof recipe.data === 'string' ? JSON.parse(recipe.data) : recipe.data),
+      }))
     } else {
-      const localResultsArray = await Recipe.query().where(
-        'name',
-        'LIKE',
-        `%${needle}%`,
-      );
-      results = localResultsArray.map(recipe => ({
+      const localResultsArray = await Recipe.query().where('name', 'LIKE', `%${needle}%`)
+      results = localResultsArray.map((recipe) => ({
         id: recipe.recipeId,
         name: recipe.name,
-        ...(typeof recipe.data === 'string'
-          ? JSON.parse(recipe.data)
-          : recipe.data),
-      }));
+        ...(typeof recipe.data === 'string' ? JSON.parse(recipe.data) : recipe.data),
+      }))
     }
 
-    return response.send(results);
+    return response.send(results)
   }
 
-  public popularRecipes({ response }: HttpContextContract) {
+  public popularRecipes({ response }: HttpContext) {
     return response.send(
       fs
-        .readJsonSync(path.join(Application.appRoot, 'recipes', 'all.json'))
+        .readJsonSync(path.join(app.appRoot, 'recipes', 'all.json'))
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        .filter((recipe: any) => recipe.featured),
-    );
+        .filter((recipe: any) => recipe.featured)
+    )
   }
 
   // TODO: test this endpoint
-  public update({ request, response }: HttpContextContract) {
-    const updates = [];
-    const recipes = request.all();
-    const allJson = fs.readJsonSync(
-      path.join(Application.appRoot, 'recipes', 'all.json'),
-    );
+  public update({ request, response }: HttpContext) {
+    const updates = []
+    const recipes = request.all()
+    const allJson = fs.readJsonSync(path.join(app.appRoot, 'recipes', 'all.json'))
 
     for (const recipe of Object.keys(recipes)) {
-      const version = recipes[recipe];
+      const version = recipes[recipe]
 
       // Find recipe in local recipe repository
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const localRecipe = allJson.find((r: any) => r.id === recipe);
+      const localRecipe = allJson.find((r: any) => r.id === recipe)
       if (localRecipe && semver.lt(version, localRecipe.version)) {
-        updates.push(recipe);
+        updates.push(recipe)
       }
     }
 
-    return response.send(updates);
+    return response.send(updates)
   }
 
   // TODO: test this endpoint
   // Download a recipe
-  public async download({ response, params }: HttpContextContract) {
+  public async download({ response, params }: HttpContext) {
     // Validate user input
-    let data;
+    let data
     try {
       data = await validator.validate({
         data: params,
         schema: downloadSchema,
-      });
+      })
     } catch (error) {
       return response.status(401).send({
         message: 'Please provide a recipe ID',
         messages: error.messages,
         status: 401,
-      });
+      })
     }
 
-    const service = data.recipe;
+    const service = data.recipe
 
     // Check for invalid characters
     if (/\.+/.test(service) || /\/+/.test(service)) {
-      return response.send('Invalid recipe name');
+      return response.send('Invalid recipe name')
     }
 
     // Check if recipe exists in recipes folder
     if (await Drive.exists(`${service}.tar.gz`)) {
-      return response
-        .type('.tar.gz')
-        .send(await Drive.get(`${service}.tar.gz`));
+      return response.type('.tar.gz').send(await Drive.get(`${service}.tar.gz`))
     }
 
     return response.status(400).send({
       message: 'Recipe not found',
       code: 'recipe-not-found',
-    });
+    })
   }
 }