Enhanced type-safety

[paulcsmith]

This is a work in progress document with some rough ideas. It might not be implemented until after 1.0, depending on time. I want to get it out there though in case people are interested or have ideas

Custom types for IDs in models

Instead of returning an Int for the model id, it would return a class that wraps the integer:

user = UserQuery.first
user.id # User::Id instead of Int
user.id.value # Return the actual int

This will enable better error messages and preventing more bugs because LuckyRecord can restrict querying to the correct types. This will be especially valuable when paired with better types in Lucky routing

Routing

Once ids are wrapped in types we can do cool stuff like this:

class Projects::Tasks::Show < BrowserAction
  get "/tasks/:task_id/users/:id", task_id: Task::Id, id: User::ID do
    TaskQuery.find(id) # This would raise a helpful error: "Can't use User::ID. Did you mean to pass in a Task::ID?
  end
end

Of course, Lucky would also be able to infer this route and the types automatically:

class Projects::Tasks::Show < BrowserAction
  # Infers the route and type restrictions from above
  route do
  end
end

You can override type restrictions when inferring:

class Projects::CompletedTasks::Show < BrowserAction
  # Need to specify the type because Lucky would infer that the id should be `CompletedTask::Id`
  route id: Task::Id do
    # render things
  end
end

Wrapper types for simple values in models

class User < BaseModel
  table :users do
    column name : String, wrap_in: Name # wrap_in is optional! It is not always worth the extra ceremony
  end
end

This will create a wrapper class called User::Name that wraps the string. Use it like this:

user = UserQuery.first
user.name # Returns User::Name object
user.name.value # Returns the string

Why do this?

It allows for more specific type signatures, which prevent errors and help make it incredibly easy to figure out what the method expects:

class WelcomeText
  def initialize(@name : User::Name)
  end

  def message
    p "Hi there #{@name}"
  end
end

The wrapper types implement to_s that just delegates to the wrapped value. So:

user = UserQuery.new.name("Jane")
user.name.to_s # "Jane"

That way it is easy to work with in HTML pages and when interpolating into strings

Allow wrapping return value of any method

It might be helpful to allow wrapping values from any class.

class UserFacade
  wrap name, in: Name
  property name
end

More to come

I'll add more ideas here as they come. Feel free to comment with ideas for enhancing type-safety in other ways.

[jwoertink]

I really like this. One thing to keep in mind with wrapping the IDs is that they could potentially be a UUID, or some custom String. Like our IDs look like 1857344000e5726f64. I guess the other thing is that depending on how you defined your tables, they could be Int32 or Int64.

Being able to type the URLs is awesome! I know that would solve a lot of issues we have in our rails app currently. We deal with a lot of really bad data, so constantly having to make sure things look right before using them is a huge pain.

[richrines]

Is it possible to use a non int32 type today for the id field? Totally fine with monkey patching for the time being if a solution exists

[waghanza]

@richrines sure, and it could be a suitable use-case, for example, if you grab from many source (ETL engine for example)
https://starkandwayne.com/blog/uuid-primary-keys-in-postgresql/