Nested Entity

[jerbaroo]

Have you considered support for nested Entity, where one Haskell value can be transformed into multiple DB rows?

Example:

data Employee = Employee
  { name :: Text
  , age :: Int
  , boss :: Maybe Employee
  } deriving Generic

The nested Employee can be turned into a foreign key to the other row.

[thma]

Hi @jerbaroo, excellent question!

Luckily that is already possible but it is not stated explicitely in the documentation.

I just created a TestCase that demonstrates how your Employee data type can be handled.
https://github.com/thma/generic-persistence/blob/main/test/SelfReferenceSpec.hs
I added a few comments to explain the 'magic' going on.

If you have further questions or requirements, just let me know.
I'll close this issue once I'll have updated the documentation accordingly

[jerbaroo]

Thanks for the quick response @thma , and also for updating the documentation! Please disregard my previous comment I deleted.

I do wonder if it can be made slighly more ergonomic for the user, so they don't have to write so much code? Since the aim of the library is to derive things via generics.

[thma]

I‘ll have a deeper Look at that. Making standard mapping topics Like 1:1, 1:n references (including self- references Like in your employee Type) easier to define, is definitely an important aim of the library.

but it will be a tough cookie…

[jerbaroo]

I once prototyped a library with similar functionality to generic-persistence. Managed to do the transformation of nested data types to SQL, but it was the reverse direction that was more difficult and I never finished that..

While better solutions might be possible, the transformation to SQL was done something like in the code below (I have tried to reduce it to merely show the general approach). After converting to this "storable" representation as I called it, then there was another pass to flatten out the nested datatypes.

-- | A field's value that can be converted to storable representation.
class ToSValue a where
  toSValue :: a -> SValue

instance ToSValue Bool   where toSValue = SValuePrim . PrimNotNull . PrimBool
instance ToSValue Int    where toSValue = SValuePrim . PrimNotNull . PrimInt
instance ToSValue String where toSValue = SValuePrim . PrimNotNull . PrimString

-- | Convert a nested entity to storable representation.
instance {-# OVERLAPPABLE #-} Entity a => ToSValue a where
  toSValue a = SValueDataType $
    SDataType ((tableKey @a, rowKey a), (toSFields a))

-- | Types that can be converted to storable representation.
class Entity a where
  rowKey :: a -> RowKey

  tableKey :: TableKey
  default tableKey :: Typeable a => TableKey
  tableKey = TableKey $ show $ typeRep $ Proxy @a

  toSFields :: a -> [SField]
  -- Default implementation via Generics HERE.

newtype ColumnKey = ColumnKey String deriving (Eq, Ord, Read, Show, Generic)
newtype RowKey    = RowKey    String deriving (Eq, Ord, Read, Show, Generic)
newtype TableKey  = TableKey  String deriving (Eq, Ord, Read, Show, Generic)
type    Ref       = (TableKey, RowKey)

data PrimNotNull =
    PrimBool   Bool
  | PrimInt    Int
  | PrimString String
  deriving (Eq, Ord, Read, Show, Generic)

-- | One cell in an SQL table: a value, a reference, or NULL.
data Prim = PrimNotNull PrimNotNull | PrimNull | PrimRef RowKey
  deriving (Eq, Ord, Read, Show, Generic)

-- | Storable representation of one field's value.
data SValue =
    SValuePrim Prim
  | SValueDataType SDataType -- Nested datatype.
  deriving (Eq, Generic, Show)

-- | Storable representation of ONE field.
type SField = (ColumnKey, SValue)

-- | A storable representation of a data type (type and fields).
newtype SDataType = SDataType (Ref, [SField])
  deriving (Eq, Generic, Show)