utopia-ui/app/src/api/itemsApi.ts

/* eslint-disable @typescript-eslint/no-non-null-assertion */
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-unsafe-member-access */
/* eslint-disable no-console */
/* eslint-disable @typescript-eslint/no-unsafe-argument */
import { createItem, deleteItem, readItem, readItems, updateItem } from '@directus/sdk'

import { directusClient } from './directus'

import type { MyCollections } from './directus'
import type { ItemsApi } from 'utopia-ui'

// Fields to request when fetching items to include all relational data
const ITEM_FIELDS = [
  '*',
  'secrets.*',
  'to.*',
  'relations.*',
  'user_created.*',
  'markerIcon.*',
  { offers: ['*'], needs: ['*'], gallery: ['*.*'] } as any,
]

export class itemsApi<T> implements ItemsApi<T> {
  collectionName: keyof MyCollections
  filter: any
  layerId: string | undefined
  mapId: string | undefined
  customParameter: any

  constructor(
    collectionName: keyof MyCollections,
    layerId?: string,
    mapId?: string,
    filter?: any,
    customParameter?: any,
  ) {
    this.collectionName = collectionName
    if (filter) this.filter = filter
    else this.filter = {}
    this.layerId = layerId
    if (layerId) {
      this.filter = { ...filter, ...{ layer: { id: { _eq: layerId } } } }
    }
    this.mapId = mapId
    if (mapId) {
      this.filter = { ...filter, ...{ map: { id: { _eq: mapId } } } }
    }
    if (customParameter) this.customParameter = customParameter
  }

  async getItems(): Promise<T[]> {
    try {
      const result = await directusClient.request<T[]>(
        readItems(this.collectionName as never, {
          fields: ITEM_FIELDS,
          filter: this.filter,
          limit: -1,
        }),
      )

      return result
    } catch (error: any) {
      console.error(error)
      if (error.errors?.[0]?.message) {
        throw new Error(error.errors[0].message)
      } else {
        throw error
      }
    }
  }

  async getItem(id: string): Promise<T> {
    try {
      const result = await directusClient.request(
        readItem(this.collectionName as never, id, {
          fields: ITEM_FIELDS,
        }),
      )
      return result as T
    } catch (error: any) {
      console.log(error)
      if (error.errors[0]?.message) throw error.errors[0].message
      else throw error
    }
  }

  async createItem(item: T & { id?: string }): Promise<T> {
    try {
      const result = await directusClient.request(
        createItem(
          this.collectionName,
          {
            ...item,
            ...(this.customParameter && this.customParameter),
            ...(this.layerId && { layer: this.layerId }),
            ...(this.mapId && { map: this.mapId }),
          },
          {
            fields: ITEM_FIELDS,
          },
        ),
      )
      return result as T
    } catch (error: any) {
      console.log(error)
      if (error.errors[0]?.message) throw error.errors[0].message
      else throw error
    }
  }

  async updateItem(item: T & { id?: string }): Promise<T> {
    try {
      const result = await directusClient.request(
        updateItem(this.collectionName, item.id!, item, {
          fields: ITEM_FIELDS,
        }),
      )
      return result as T
    } catch (error: any) {
      console.log(error)
      if (error.errors[0].message) throw error.errors[0].message
      else throw error
    }
  }

  async deleteItem(id: string): Promise<boolean> {
    try {
      await directusClient.request(deleteItem(this.collectionName, id))
      return true
    } catch (error: any) {
      console.log(error)
      if (error.errors[0].message) throw error.errors[0].message
      else throw error
    }
  }
}