chore: fixed types naming

2025-04-14 12:45:59 +03:00 · 2025-04-14 12:45:59 +03:00 · 4a7b9f194c
commit 4a7b9f194c
parent 079b5958ef
20 changed files with 162 additions and 172 deletions
--- a/src/index.ts
+++ b/src/index.ts
@ -10,7 +10,7 @@ import {
  spiritsRouter,
  coffeeRouter
 } from './routes'
-import { Routes } from './types'
+import { Route } from './types'

 dotenv.config()

@ -19,13 +19,13 @@ const port = process.env.PORT || 3000

 connectToDatabase()
  .then(() => {
-    app.use(Routes.Users, usersRouter)
-    app.use(Routes.NostrEvents, nostrRouter)
-    app.use(Routes.Reviews, reviewsRouter)
-    app.use(Routes.Wines, winesRouter)
-    app.use(Routes.Sake, sakeRouter)
-    app.use(Routes.Spirits, spiritsRouter)
-    app.use(Routes.Coffee, coffeeRouter)
+    app.use(Route.Users, usersRouter)
+    app.use(Route.NostrEvents, nostrRouter)
+    app.use(Route.Reviews, reviewsRouter)
+    app.use(Route.Wines, winesRouter)
+    app.use(Route.Sake, sakeRouter)
+    app.use(Route.Spirits, spiritsRouter)
+    app.use(Route.Coffee, coffeeRouter)

    app.listen(port, () => {
      console.log(`Server started at http://localhost:${port}`)
--- a/src/models/sake.ts
+++ b/src/models/sake.ts
@ -2,9 +2,9 @@ import { ObjectId } from 'mongodb'
 import {
  SakeDesignation,
  SakeStarter,
-  VintageOptions,
-  SakeCharacteristics,
-  StandardDrinks,
+  VintageOption,
+  SakeCharacteristic,
+  StandardDrink,
  SakeVolume,
  RiceVarietal,
  SakeYeastStrain,
@ -24,15 +24,15 @@ export class Sake {
    public producerId: ObjectId, // product producer
    public designation: SakeDesignation, // table, pure, blended
    public polishRate: number, // %
-    public characteristics: SakeCharacteristics[],
+    public characteristics: SakeCharacteristic[],
    public starter: SakeStarter, // sake starter
    public yeastStrain: SakeYeastStrain,
    public volume: SakeVolume, // bottle volume
    public alcohol: number, // alcohol percentage
-    public standardDrinks: StandardDrinks, // number representing an amount of standard drinks per bottle per 100ml
+    public standardDrinks: StandardDrink, // number representing an amount of standard drinks per bottle per 100ml
    public riceVarietal: RiceVarietal[], // if more than one, list as 'blend'
    public koji: SakeKoji, // if more than one, list as 'blend'
-    public vintage: number | VintageOptions, // year, nv (non-vintage) or mv (multi-vintage)
+    public vintage: number | VintageOption, // year, nv (non-vintage) or mv (multi-vintage)
    public RRPamount: number, // 20
    public RRPcurrency: CurrencyCode, // USD
    public description: string, // detailed description of the product
--- a/src/models/spirit.ts
+++ b/src/models/spirit.ts
@ -3,10 +3,10 @@ import {
  SpiritType,
  SpiritVariant,
  Ingredient,
-  VintageOptions,
-  StandardDrinks,
+  VintageOption,
+  StandardDrink,
  SpiritVolume,
-  SpiritCharacteristics
+  SpiritCharacteristic
 } from '../types'
 import { Alpha2Code } from 'i18n-iso-countries'
 import { CurrencyCode } from 'currency-codes-ts/dist/types'
@ -22,12 +22,12 @@ export class Spirit {
    public producerId: ObjectId, // product producer
    public type: SpiritType, // spirit type
    public variant: SpiritVariant, // vodka, rum, liqueur cream, etc
-    public characteristics: SpiritCharacteristics, // light aromatic, textural, fruit forward, structural & savoury, powerful
+    public characteristics: SpiritCharacteristic, // light aromatic, textural, fruit forward, structural & savoury, powerful
    public ingredients: Ingredient[], // an array of ingredients(flavouring)
    public volume: SpiritVolume, // bottle volume
    public alcohol: number, // alcohol percentage
-    public vintage: number | VintageOptions, // year, nv (non-vintage) or mv (multi-vintage)
-    public standardDrinks: StandardDrinks, // an amount of standard drinks per 100ml and bottle in AU, UK and US
+    public vintage: number | VintageOption, // year, nv (non-vintage) or mv (multi-vintage)
+    public standardDrinks: StandardDrink, // an amount of standard drinks per 100ml and bottle in AU, UK and US
    public RRPamount: number, // 20
    public RRPcurrency: CurrencyCode, // USD
    public description: string, // detailed description of the product
--- a/src/models/wine.ts
+++ b/src/models/wine.ts
@ -3,8 +3,8 @@ import {
  WineType,
  Viticulture,
  BottleClosure,
-  VintageOptions,
-  StandardDrinks,
+  VintageOption,
+  StandardDrink,
  WineRegion,
  WineVolume,
  WineStyle,
@ -35,10 +35,10 @@ export class Wine {
    public name: string, // label
    public producerId: ObjectId, // product producer
    public grapeVarietal: GrapeVarietal[], // if more than one, list as 'blend'
-    public vintage: number | VintageOptions, // year, nv (non-vintage) or mv (multi-vintage)
+    public vintage: number | VintageOption, // year, nv (non-vintage) or mv (multi-vintage)
    public volume: WineVolume, // bottle volume
    public alcohol: number, // alcohol percentage
-    public standardDrinks: StandardDrinks, // an amount of standard drinks per 100ml and bottle in AU, UK and US
+    public standardDrinks: StandardDrink, // an amount of standard drinks per 100ml and bottle in AU, UK and US
    public viticulture: Viticulture, // viticulture
    public sulfites: number, // parts per million
    public filtered: boolean, // is wine filtered (fined (egg or fish))
--- a/src/routes/sake.router.ts
+++ b/src/routes/sake.router.ts
@ -10,7 +10,7 @@ import {
  volumeToMl
 } from '../utils'
 import Joi from 'joi'
-import { DBcollections, ProductType } from '../types'
+import { DBcollection, ProductType } from '../types'

 export const sakeRouter = express.Router()

@ -51,7 +51,7 @@ sakeRouter.post('/', async (req: Request, res: Response) => {
      productCodeEAN,
      productCodeUPC,
      productCodeSKU,
-      DBcollections.Sake,
+      DBcollection.Sake,
      ProductType.Sake
    )

@ -60,7 +60,7 @@ sakeRouter.post('/', async (req: Request, res: Response) => {
      volumeToMl(sake.volume)
    )

-    const result = await collections[DBcollections.Sake]?.insertOne(sake)
+    const result = await collections[DBcollection.Sake]?.insertOne(sake)

    handleReqSuccess(res, result, ProductType.Spirit)
  } catch (error: unknown) {
--- a/src/routes/spirits.router.ts
+++ b/src/routes/spirits.router.ts
@ -10,7 +10,7 @@ import {
  volumeToMl
 } from '../utils'
 import Joi from 'joi'
-import { DBcollections, ProductType } from '../types'
+import { DBcollection, ProductType } from '../types'

 export const spiritsRouter = express.Router()

@ -50,7 +50,7 @@ spiritsRouter.post('/', async (req: Request, res: Response) => {
      productCodeEAN,
      productCodeUPC,
      productCodeSKU,
-      DBcollections.Spirits,
+      DBcollection.Spirits,
      ProductType.Spirit
    )

@ -59,7 +59,7 @@ spiritsRouter.post('/', async (req: Request, res: Response) => {
      volumeToMl(spirit.volume)
    )

-    const result = await collections[DBcollections.Spirits]?.insertOne(spirit)
+    const result = await collections[DBcollection.Spirits]?.insertOne(spirit)

    handleReqSuccess(res, result, ProductType.Spirit)
  } catch (error: unknown) {
--- a/src/routes/wines.router.ts
+++ b/src/routes/wines.router.ts
@ -10,7 +10,7 @@ import {
  volumeToMl
 } from '../utils'
 import Joi from 'joi'
-import { DBcollections, ProductType } from '../types'
+import { DBcollection, ProductType } from '../types'

 export const winesRouter = express.Router()

@ -19,7 +19,7 @@ winesRouter.use(express.json())
 // GET
 winesRouter.get('/', async (_req: Request, res: Response) => {
  try {
-    const wines = await collections[DBcollections.Wines]?.find({}).toArray()
+    const wines = await collections[DBcollection.Wines]?.find({}).toArray()

    res.status(200).send(wines)
  } catch (error: unknown) {
@ -51,7 +51,7 @@ winesRouter.post('/', async (req: Request, res: Response) => {
      productCodeEAN,
      productCodeUPC,
      productCodeSKU,
-      DBcollections.Wines,
+      DBcollection.Wines,
      ProductType.Wine
    )

@ -60,7 +60,7 @@ winesRouter.post('/', async (req: Request, res: Response) => {
      volumeToMl(wine.volume)
    )

-    const result = await collections[DBcollections.Wines]?.insertOne(wine)
+    const result = await collections[DBcollection.Wines]?.insertOne(wine)

    handleReqSuccess(res, result, ProductType.Wine)
  } catch (error: unknown) {
--- a/src/services/database.service.ts
+++ b/src/services/database.service.ts
@ -1,16 +1,16 @@
 import * as mongoDB from 'mongodb'
 import * as dotenv from 'dotenv'
-import { DBcollections } from '../types'
+import { DBcollection } from '../types'

 // Global Variables
 export const collections: {
-  [DBcollections.Users]?: mongoDB.Collection
-  [DBcollections.NostrEvents]?: mongoDB.Collection
-  [DBcollections.Reviews]?: mongoDB.Collection
-  [DBcollections.Wines]?: mongoDB.Collection
-  [DBcollections.Sake]?: mongoDB.Collection
-  [DBcollections.Spirits]?: mongoDB.Collection
-  [DBcollections.Coffee]?: mongoDB.Collection
+  [DBcollection.Users]?: mongoDB.Collection
+  [DBcollection.NostrEvents]?: mongoDB.Collection
+  [DBcollection.Reviews]?: mongoDB.Collection
+  [DBcollection.Wines]?: mongoDB.Collection
+  [DBcollection.Sake]?: mongoDB.Collection
+  [DBcollection.Spirits]?: mongoDB.Collection
+  [DBcollection.Coffee]?: mongoDB.Collection
 } = {}

 // Initialize Connection
@ -29,20 +29,20 @@ export async function connectToDatabase() {

  const db: mongoDB.Db = client.db(process.env.DB_NAME)

-  const usersCollection: mongoDB.Collection = db.collection(DBcollections.Users)
+  const usersCollection: mongoDB.Collection = db.collection(DBcollection.Users)
  const nostrEventsCollection: mongoDB.Collection = db.collection(
-    DBcollections.NostrEvents
+    DBcollection.NostrEvents
  )
  const reviewsCollection: mongoDB.Collection = db.collection(
-    DBcollections.Reviews
+    DBcollection.Reviews
  )
-  const winesCollection: mongoDB.Collection = db.collection(DBcollections.Wines)
-  const sakeCollection: mongoDB.Collection = db.collection(DBcollections.Sake)
+  const winesCollection: mongoDB.Collection = db.collection(DBcollection.Wines)
+  const sakeCollection: mongoDB.Collection = db.collection(DBcollection.Sake)
  const spiritsCollection: mongoDB.Collection = db.collection(
-    DBcollections.Spirits
+    DBcollection.Spirits
  )
  const coffeeCollection: mongoDB.Collection = db.collection(
-    DBcollections.Coffee
+    DBcollection.Coffee
  )

  collections.users = usersCollection
--- a/src/types/database.ts
+++ b/src/types/database.ts
@ -1,4 +1,4 @@
-export enum DBcollections {
+export enum DBcollection {
  Users = 'users',
  NostrEvents = 'nostrEvents',
  Reviews = 'reviews',
--- a/src/types/product.ts
+++ b/src/types/product.ts
@ -61,20 +61,16 @@ export enum Ingredient {
  Walnut = 'Walnut'
 }

-export enum VintageOptions {
+export enum VintageOption {
  NV = 'NV',
  MV = 'MV'
 }

-export interface StandardDrinks {
+export interface StandardDrink {
  '100ml': { AU: number; UK: number; US: number }
  bottle: { AU: number; UK: number; US: number }
 }

-export enum RatingOptions {
-  NoScore = 'NS'
-}
-
 export enum ProductType {
  Wine = 'Wine',
  Spirit = 'Spirit',
--- a/src/types/routes.ts
+++ b/src/types/routes.ts
@ -1,4 +1,4 @@
-export enum Routes {
+export enum Route {
  Users = '/users',
  NostrEvents = '/nostr',
  Reviews = '/reviews',
--- a/src/types/sake.ts
+++ b/src/types/sake.ts
@ -80,7 +80,7 @@ export interface SakePolishMin {
  min: number
 }

-export enum SakeCharacteristics {
+export enum SakeCharacteristic {
  LightAndRefreshing = 'Light and Refreshing',
  CleanAndCrisp = 'Clean and Crisp',
  FruityAndAromatic = 'Fruity and Aromatic',
--- a/src/types/spirit.ts
+++ b/src/types/spirit.ts
@ -42,7 +42,7 @@ export enum SpiritVolume {
  '1L' = '1L'
 }

-export enum SpiritCharacteristics {
+export enum SpiritCharacteristic {
  LightAndNeutral = 'Light and Neutral',
  FruityAndAromatic = 'Fruity and Aromatic',
  HerbalAndBotanical = 'Herbal and Botanical',
@ -51,7 +51,7 @@ export enum SpiritCharacteristics {
  RichAndFullBodied = 'Rich and Full-Bodied'
 }

-export enum WhiteSpiritVariants {
+export enum WhiteSpiritVariant {
  Absinthe = 'Absinthe',
  Pastis = 'Pastis',
  Vodka = 'Vodka',
@ -67,7 +67,7 @@ export enum WhiteSpiritVariants {
  Arrack = 'Arrack'
 }

-export enum DarkSpiritVariants {
+export enum DarkSpiritVariant {
  Absinthe = 'Absinthe',
  Brandy = 'Brandy',
  Calvados = 'Calvados',
@ -80,7 +80,7 @@ export enum DarkSpiritVariants {
  Whiskey = 'Whiskey'
 }

-export enum LiqueursSpiritVariants {
+export enum LiqueursSpiritVariant {
  Amaro = 'Amaro',
  Coffee = 'Coffee',
  Cream = 'Cream',
--- a/src/utils/alcohol.ts
+++ b/src/utils/alcohol.ts
@ -1,10 +1,10 @@
-import { SakeVolume, SpiritVolume, StandardDrinks, WineVolume } from '../types'
+import { SakeVolume, SpiritVolume, StandardDrink, WineVolume } from '../types'
 import { roundToOneDecimal } from './'

 export const alcoholToStandardDrinks = (
  alcohol: number,
  bottle: number
-): StandardDrinks => {
+): StandardDrink => {
  const UK100ml = roundToOneDecimal(10 * alcohol)
  const AU100ml = roundToOneDecimal(7.91 * alcohol)
  const US100ml = roundToOneDecimal(5.64 * alcohol)
--- a/src/utils/spirit.ts
+++ b/src/utils/spirit.ts
@ -1,30 +1,27 @@
 import {
-  SpiritCharacteristics,
+  SpiritCharacteristic,
  SpiritType,
-  WhiteSpiritVariants,
-  DarkSpiritVariants,
-  LiqueursSpiritVariants
+  WhiteSpiritVariant,
+  DarkSpiritVariant,
+  LiqueursSpiritVariant
 } from '../types'

 // TODO: improve types
 export const spiritVariantMap: {
  [key in SpiritType]:
    | {
-        [key in WhiteSpiritVariants]: (string | { [key: string]: string[] })[]
+        [key in WhiteSpiritVariant]: (string | { [key: string]: string[] })[]
      }
    | {
-        [key in DarkSpiritVariants]: (string | { [key: string]: string[] })[]
+        [key in DarkSpiritVariant]: (string | { [key: string]: string[] })[]
      }
    | {
-        [key in LiqueursSpiritVariants]: (
-          | string
-          | { [key: string]: string[] }
-        )[]
+        [key in LiqueursSpiritVariant]: (string | { [key: string]: string[] })[]
      }
 } = {
  [SpiritType.White]: {
-    [WhiteSpiritVariants.Absinthe]: ['Blanche'],
-    [WhiteSpiritVariants.Pastis]: [
+    [WhiteSpiritVariant.Absinthe]: ['Blanche'],
+    [WhiteSpiritVariant.Pastis]: [
      'Anise',
      'Fennel',
      'Licorice Root',
@ -36,7 +33,7 @@ export const spiritVariantMap: {
      'Cinnamon',
      'Clove'
    ],
-    [WhiteSpiritVariants.Vodka]: [
+    [WhiteSpiritVariant.Vodka]: [
      'Wheat',
      'Rye',
      'Corn',
@ -46,12 +43,12 @@ export const spiritVariantMap: {
      'Fruits',
      'Grains'
    ],
-    [WhiteSpiritVariants.Genever]: [
+    [WhiteSpiritVariant.Genever]: [
      {
        Young: ['Juniper']
      }
    ],
-    [WhiteSpiritVariants.Gin]: [
+    [WhiteSpiritVariant.Gin]: [
      {
        'London Dry': [
          'Juniper',
@ -68,11 +65,11 @@ export const spiritVariantMap: {
      },
      'Plymouth'
    ],
-    [WhiteSpiritVariants.Mezcal]: [
+    [WhiteSpiritVariant.Mezcal]: [
      { Joven: ['Espadín', 'Tepeztate', 'Tequilana (blue)', 'Tobalá'] }
    ],
-    [WhiteSpiritVariants.Rum]: ['Blanco', 'Cachaça', 'Platino', 'Agricole'],
-    [WhiteSpiritVariants.EauDeVie]: [
+    [WhiteSpiritVariant.Rum]: ['Blanco', 'Cachaça', 'Platino', 'Agricole'],
+    [WhiteSpiritVariant.EauDeVie]: [
      'Apple',
      'Blackcurrant',
      'Butterscotch',
@ -81,27 +78,27 @@ export const spiritVariantMap: {
      'Plum',
      'Raspberries'
    ],
-    [WhiteSpiritVariants.Grappa]: ['Marc', 'Pisco'],
-    [WhiteSpiritVariants.Baijiu]: [
+    [WhiteSpiritVariant.Grappa]: ['Marc', 'Pisco'],
+    [WhiteSpiritVariant.Baijiu]: [
      'Sorghum',
      'Wheat',
      'Barley',
      'Rice',
      'Millet'
    ],
-    [WhiteSpiritVariants.Soju]: [
+    [WhiteSpiritVariant.Soju]: [
      'Barley',
      'Brown sugar',
      'Buckwheat',
      'Rice',
      'Sweet Potato'
    ],
-    [WhiteSpiritVariants.Aquavit]: [],
-    [WhiteSpiritVariants.Arrack]: []
+    [WhiteSpiritVariant.Aquavit]: [],
+    [WhiteSpiritVariant.Arrack]: []
  },
  [SpiritType.Dark]: {
-    [DarkSpiritVariants.Absinthe]: ['Jaune', 'Verte'],
-    [DarkSpiritVariants.Brandy]: [
+    [DarkSpiritVariant.Absinthe]: ['Jaune', 'Verte'],
+    [DarkSpiritVariant.Brandy]: [
      {
        Grape: [
          'VS',
@ -114,14 +111,11 @@ export const spiritVariantMap: {
        ]
      }
    ],
-    [DarkSpiritVariants.Calvados]: ['Apple', 'Pear'],
-    [DarkSpiritVariants.Chartreuse]: ['Green', 'Yellow'],
-    [DarkSpiritVariants.Genever]: [
-      { Old: ['Juniper'] },
-      { Coren: ['Juniper'] }
-    ],
-    [DarkSpiritVariants.Mezcal]: ['Reposado', 'Abuelo', 'Añejo', 'Extra Añejo'],
-    [DarkSpiritVariants.Rum]: [
+    [DarkSpiritVariant.Calvados]: ['Apple', 'Pear'],
+    [DarkSpiritVariant.Chartreuse]: ['Green', 'Yellow'],
+    [DarkSpiritVariant.Genever]: [{ Old: ['Juniper'] }, { Coren: ['Juniper'] }],
+    [DarkSpiritVariant.Mezcal]: ['Reposado', 'Abuelo', 'Añejo', 'Extra Añejo'],
+    [DarkSpiritVariant.Rum]: [
      {
        Sugar: [
          'Cachaca (amarela/ouro)',
@ -133,8 +127,8 @@ export const spiritVariantMap: {
        ]
      }
    ],
-    [DarkSpiritVariants.Slivovitz]: [],
-    [DarkSpiritVariants.Whiskey]: [
+    [DarkSpiritVariant.Slivovitz]: [],
+    [DarkSpiritVariant.Whiskey]: [
      'Barley',
      'Rye',
      'Wheat',
@ -142,18 +136,18 @@ export const spiritVariantMap: {
      'Oat',
      'Rice'
    ],
-    [DarkSpiritVariants.Arrack]: []
+    [DarkSpiritVariant.Arrack]: []
  },
  [SpiritType.Liqueurs]: {
-    [LiqueursSpiritVariants.Amaro]: [],
-    [LiqueursSpiritVariants.Coffee]: [],
-    [LiqueursSpiritVariants.Cream]: [
+    [LiqueursSpiritVariant.Amaro]: [],
+    [LiqueursSpiritVariant.Coffee]: [],
+    [LiqueursSpiritVariant.Cream]: [
      'Egg (Advocaat)',
      'Rum',
      'Strawberry',
      'Whiskey (Baileys etc)'
    ],
-    [LiqueursSpiritVariants.Creme]: [
+    [LiqueursSpiritVariant.Creme]: [
      'Almond',
      'Banana',
      'Blackcurrant',
@ -162,8 +156,8 @@ export const spiritVariantMap: {
      'Sour Cherry',
      'Violet'
    ],
-    [LiqueursSpiritVariants.Flowers]: ['Rose', 'Violet', 'Elderflower'],
-    [LiqueursSpiritVariants.Fruit]: [
+    [LiqueursSpiritVariant.Flowers]: ['Rose', 'Violet', 'Elderflower'],
+    [LiqueursSpiritVariant.Fruit]: [
      'Blackcurrant',
      'Lemon',
      'Melon',
@ -173,7 +167,7 @@ export const spiritVariantMap: {
      'Raspberry',
      'Yuzu'
    ],
-    [LiqueursSpiritVariants.Herb]: [
+    [LiqueursSpiritVariant.Herb]: [
      'Anise',
      'Dom Benedictine',
      'Bitters',
@ -182,8 +176,8 @@ export const spiritVariantMap: {
      'Metaxa',
      'Mint'
    ],
-    [LiqueursSpiritVariants.Honey]: ['Licor 43', 'Rum', 'Vodka', 'Whiskey'],
-    [LiqueursSpiritVariants.Nut]: [
+    [LiqueursSpiritVariant.Honey]: ['Licor 43', 'Rum', 'Vodka', 'Whiskey'],
+    [LiqueursSpiritVariant.Nut]: [
      'Almond',
      'Apricot Kernel',
      'Hazelnut',
@ -196,62 +190,62 @@ export const spiritVariantMap: {
 }

 export const spiritCharacteristicsMap: {
-  [key in SpiritCharacteristics]: string[]
+  [key in SpiritCharacteristic]: string[]
 } = {
-  [SpiritCharacteristics.LightAndNeutral]: [
-    WhiteSpiritVariants.Mezcal,
-    WhiteSpiritVariants.Soju,
-    WhiteSpiritVariants.Vodka,
-    WhiteSpiritVariants.Rum,
-    WhiteSpiritVariants.Aquavit
+  [SpiritCharacteristic.LightAndNeutral]: [
+    WhiteSpiritVariant.Mezcal,
+    WhiteSpiritVariant.Soju,
+    WhiteSpiritVariant.Vodka,
+    WhiteSpiritVariant.Rum,
+    WhiteSpiritVariant.Aquavit
  ],
-  [SpiritCharacteristics.FruityAndAromatic]: [
-    WhiteSpiritVariants.Rum,
-    DarkSpiritVariants.Calvados,
-    WhiteSpiritVariants.EauDeVie,
-    LiqueursSpiritVariants.Fruit,
-    WhiteSpiritVariants.Gin,
-    WhiteSpiritVariants.Grappa
+  [SpiritCharacteristic.FruityAndAromatic]: [
+    WhiteSpiritVariant.Rum,
+    DarkSpiritVariant.Calvados,
+    WhiteSpiritVariant.EauDeVie,
+    LiqueursSpiritVariant.Fruit,
+    WhiteSpiritVariant.Gin,
+    WhiteSpiritVariant.Grappa
  ],
-  [SpiritCharacteristics.HerbalAndBotanical]: [
-    WhiteSpiritVariants.Absinthe,
-    DarkSpiritVariants.Absinthe,
-    LiqueursSpiritVariants.Amaro,
-    WhiteSpiritVariants.Genever,
-    DarkSpiritVariants.Genever,
-    WhiteSpiritVariants.Gin,
-    WhiteSpiritVariants.Pastis,
-    DarkSpiritVariants.Chartreuse,
-    WhiteSpiritVariants.Aquavit
+  [SpiritCharacteristic.HerbalAndBotanical]: [
+    WhiteSpiritVariant.Absinthe,
+    DarkSpiritVariant.Absinthe,
+    LiqueursSpiritVariant.Amaro,
+    WhiteSpiritVariant.Genever,
+    DarkSpiritVariant.Genever,
+    WhiteSpiritVariant.Gin,
+    WhiteSpiritVariant.Pastis,
+    DarkSpiritVariant.Chartreuse,
+    WhiteSpiritVariant.Aquavit
  ],

-  [SpiritCharacteristics.SweetAndSyrupy]: [
-    DarkSpiritVariants.Brandy,
-    LiqueursSpiritVariants.Cream,
-    LiqueursSpiritVariants.Creme,
-    DarkSpiritVariants.Rum,
-    LiqueursSpiritVariants.Nut
+  [SpiritCharacteristic.SweetAndSyrupy]: [
+    DarkSpiritVariant.Brandy,
+    LiqueursSpiritVariant.Cream,
+    LiqueursSpiritVariant.Creme,
+    DarkSpiritVariant.Rum,
+    LiqueursSpiritVariant.Nut
  ],
-  [SpiritCharacteristics.SmokyAndSpicy]: [
-    WhiteSpiritVariants.Baijiu,
-    DarkSpiritVariants.Rum,
-    WhiteSpiritVariants.Gin,
-    WhiteSpiritVariants.EauDeVie,
-    DarkSpiritVariants.Mezcal,
-    DarkSpiritVariants.Whiskey,
-    LiqueursSpiritVariants.Cream,
-    LiqueursSpiritVariants.Honey,
-    WhiteSpiritVariants.Arrack,
-    DarkSpiritVariants.Arrack
+  [SpiritCharacteristic.SmokyAndSpicy]: [
+    WhiteSpiritVariant.Baijiu,
+    DarkSpiritVariant.Rum,
+    WhiteSpiritVariant.Gin,
+    WhiteSpiritVariant.EauDeVie,
+    DarkSpiritVariant.Mezcal,
+    DarkSpiritVariant.Whiskey,
+    LiqueursSpiritVariant.Cream,
+    LiqueursSpiritVariant.Honey,
+    WhiteSpiritVariant.Arrack,
+    DarkSpiritVariant.Arrack
  ],
-  [SpiritCharacteristics.RichAndFullBodied]: [
-    WhiteSpiritVariants.Baijiu,
-    DarkSpiritVariants.Brandy,
-    DarkSpiritVariants.Rum,
-    WhiteSpiritVariants.Grappa,
-    WhiteSpiritVariants.EauDeVie,
-    LiqueursSpiritVariants.Cream,
-    LiqueursSpiritVariants.Honey,
-    DarkSpiritVariants.Whiskey
+  [SpiritCharacteristic.RichAndFullBodied]: [
+    WhiteSpiritVariant.Baijiu,
+    DarkSpiritVariant.Brandy,
+    DarkSpiritVariant.Rum,
+    WhiteSpiritVariant.Grappa,
+    WhiteSpiritVariant.EauDeVie,
+    LiqueursSpiritVariant.Cream,
+    LiqueursSpiritVariant.Honey,
+    DarkSpiritVariant.Whiskey
  ]
 }
--- a/src/utils/validation/product.ts
+++ b/src/utils/validation/product.ts
@ -1,11 +1,11 @@
 import { collections } from '../../services/database.service'
-import { DBcollections, ProductType } from '../../types'
+import { DBcollection, ProductType } from '../../types'

 export const productCodeValidation = async (
  ean: string,
  upc: string,
  sku: string,
-  collection: DBcollections,
+  collection: DBcollection,
  productType: ProductType
 ) => {
  if (!ean && !upc && !sku) {
--- a/src/utils/validation/review.ts
+++ b/src/utils/validation/review.ts
@ -1,5 +1,5 @@
 import Joi from 'joi'
-import { RatingOptions } from '../../types'
+import { RatingOption } from '../../types'

 export const reviewValidation = (data: unknown): Joi.ValidationResult =>
  Joi.object({
@ -7,7 +7,7 @@ export const reviewValidation = (data: unknown): Joi.ValidationResult =>
    productId: Joi.string().required(),
    rating: Joi.alternatives()
      .try(
-        Joi.string().valid(...Object.values(RatingOptions)),
+        Joi.string().valid(...Object.values(RatingOption)),
        Joi.number().min(84).max(100)
      )
      .required(),
--- a/src/utils/validation/sake.ts
+++ b/src/utils/validation/sake.ts
@ -1,7 +1,7 @@
 import Joi from 'joi'
 import {
  SakeDesignation,
-  SakeCharacteristics,
+  SakeCharacteristic,
  SakeVolume,
  SakeStarter,
  RiceVarietal,
@ -118,7 +118,7 @@ export const sakeValidation = (data: unknown): Joi.ValidationResult =>
      })
      .required(),
    characteristics: Joi.array()
-      .items(Joi.string().valid(...Object.values(SakeCharacteristics)))
+      .items(Joi.string().valid(...Object.values(SakeCharacteristic)))
      .required(),
    starter: Joi.string().valid(...Object.values(SakeStarter)),
    yeastStrain: Joi.string()
--- a/src/utils/validation/spirit.ts
+++ b/src/utils/validation/spirit.ts
@ -3,7 +3,7 @@ import {
  Ingredient,
  SpiritType,
  SpiritVolume,
-  SpiritCharacteristics
+  SpiritCharacteristic
 } from '../../types'
 import { isObject, spiritVariantMap, spiritCharacteristicsMap } from '../'
 import {
@ -234,11 +234,11 @@ export const spiritValidation = (data: unknown): Joi.ValidationResult =>
    characteristics: Joi.array()
      .items(
        Joi.string().custom((characteristic, helper) => {
-          if (!Object.values(SpiritCharacteristics).includes(characteristic)) {
+          if (!Object.values(SpiritCharacteristic).includes(characteristic)) {
            return helper.message({
              custom: Joi.expression(
                `"${characteristic}" is not a valid characteristic. Valid options are [${Object.values(
-                  SpiritCharacteristics
+                  SpiritCharacteristic
                )
                  .map((option) => `"${option}"`)
                  .join(', ')}]`
@ -257,12 +257,12 @@ export const spiritValidation = (data: unknown): Joi.ValidationResult =>
              : Object.keys(spiritVariant)[0]

          const variantsInCharacteristic =
-            spiritCharacteristicsMap[characteristic as SpiritCharacteristics]
+            spiritCharacteristicsMap[characteristic as SpiritCharacteristic]

          const characteristicsInVariant = Object.keys(
            spiritCharacteristicsMap
          ).filter((char) =>
-            spiritCharacteristicsMap[char as SpiritCharacteristics].includes(
+            spiritCharacteristicsMap[char as SpiritCharacteristic].includes(
              spiritVariantName
            )
          )
--- a/src/utils/validation/validations.ts
+++ b/src/utils/validation/validations.ts
@ -1,9 +1,9 @@
 import Joi from 'joi'
-import { VintageOptions } from '../../types'
+import { VintageOption } from '../../types'

 export const vintageValidation = Joi.alternatives()
  .try(
-    Joi.string().valid(...Object.values(VintageOptions)),
+    Joi.string().valid(...Object.values(VintageOption)),
    Joi.number().min(1700).max(new Date().getFullYear())
  )
  .required()