Scala + Slick + Accord - Benutzerdefinierte Wertklasse funktioniert nicht. Nur ein schlechter Ansatz?

Question

Ich bin immer noch ziemlich neu zu Scala und mit Slick suchen.

Ich freue mich auch auf Accord (github.com/wix/accord) zur Validierung.

Accords Validierung scheint auf Objekte als Ganzes zu sein, aber ich möchte in der Lage sein, Validatoren für Feldtypen zu definieren, also habe ich über Typ-Aliasing mit Wertklassen gedacht, so dass ich Validierungen einfach wiederverwenden kann verschiedene Fallklassen, die diese Feldtypen verwenden.

Also habe ich folgendes festgelegt:

object FieldTypes { 
    implicit class ID(val i: Int) extends AnyVal 
    implicit class UserPassword(val s: String) extends AnyVal 
    implicit class Email(val s: String) extends AnyVal 
    implicit class Name(val s: String) extends AnyVal 
    implicit class OrgName(val s: String) extends AnyVal 
    implicit class OrgAlias(val s: String) extends AnyVal 
} 

package object validators { 
    implicit val passwordValidator = validator[UserPassword] { _.length is between(8,255) } 
    implicit val emailValidator = validator[Email] { _ is notEmpty } 
    implicit val nameValidator = validator[Name] { _ is notEmpty } 
    implicit val orgNameValidator = validator[OrgName] { _ is notEmpty } 
    implicit val teamNameValidator = validator[TeamName] { _ is notEmpty } 
} 

case object Records { 
    import FieldTypes._ 

    case class OrganizationRecord(id: ID, uuid: UUID, name: OrgName, alias: OrgAlias) 
    case class UserRecord(id: ID, uuid: UUID, email: Email, password: UserPassword, name: Name) 
    case class UserToOrganizationRecord(userId: ID, organizationId: ID) 
} 

class Tables(implicit val p: JdbcProfile) { 
    import FieldTypes._ 
    import p.api._ 


    implicit object JodaMapping extends GenericJodaSupport(p) 

    case class LiftedOrganizationRecord(id: Rep[ID], uuid: Rep[UUID], name: Rep[OrgName], alias: Rep[OrgAlias]) 
    implicit object OrganizationRecordShape extends CaseClassShape(LiftedOrganizationRecord.tupled, OrganizationRecord.tupled) 

    class Organizations(tag: Tag) extends Table[OrganizationRecord](tag, "organizations") { 
    def id = column[ID]("id", O.PrimaryKey) 
    def uuid = column[UUID]("uuid", O.Length(36, varying=false)) 
    def name = column[OrgName]("name", O.Length(32, varying=true)) 
    def alias = column[OrgAlias]("alias", O.Length(32, varying=true)) 
    def * = LiftedOrganizationRecord(id, uuid, name, alias) 
    } 
    val organizations = TableQuery[Organizations] 
} 

Leider habe ich eindeutig falsch verstehen oder die Macht der Scala impliziten Konvertierungen überschätzen. Mein passwordValidator scheint nicht zu erkennen, dass es eine length Eigenschaft zu gibt und meine * Deklaration auf meiner Organizations Tabelle scheint nicht zu glauben, dass sie der in LiftedOrganizationRecord definierten Form entspricht.

Mache ich hier im Großen und Ganzen etwas Dummes? Sollte ich nicht einmal versuchen, diese Art von benutzerdefinierten Typen zu verwenden, und stattdessen einfach Standardtypen verwenden, um meine Validatoren besser zu definieren? Oder ist das eine gute Art, Dinge zu tun, aber ich habe einfach etwas Einfaches vergessen?

Jeder Rat würde wirklich geschätzt werden!

Answer 1

Dank einiger hilfreicher Leute auf dem scala gitter channel erkannte ich, dass der Hauptfehler ein Missverständnis der Konvertierungsrichtung für Wertklassen war. Ich hatte es als ValueClass -> WrappedValueType verstanden, aber es ist tatsächlich WrappedValueType -> ValueClass. So sah Slick zum Beispiel nicht ID als Int.