onyxframework / http Goto Github PK

params do
  type stripe_source : String, key: :stripeSource
end

So, a request of ?stripeSource=foo would propagate params with params[:stripe_source].

Old:

params do
  param :email, String, validate: {regex: /@/, size: (5..64)}
  param :password, String, validate: {size: (8..64)}
end

New:

params do
  type email : String, validate: {regex: /@/, size: (5..64)}
  type password : String, validate: {size: (8..64)}
end

Pros:

• Canonical type definition
• Highlighting
• Neat indentation (notice how params is indented with type 😏)
• Editors do not offer param on typing within def call, this is annoying

RFC on keyword though!

Old:

halt!(409, {error: "User already exists"}) if existing_user

New:

break(409, {error: "User already exists"}) if existing_user

Pros:

• Highlighting

See https://github.com/spider-gazelle/action-controller/blob/master/src/action-controller/server.cr#L71

Because they're so good.

🤔

For some strange reason application/json; charset=utf-8 turns into application/json in Action response despite of

https://github.com/vladfaust/prism/blob/0b25665dc6e4b20f2ad159e751af32c593309c9c/src/prism/action.cr#L112

https://github.com/vladfaust/prism/blob/0b25665dc6e4b20f2ad159e751af32c593309c9c/src/prism/action.cr#L124

Need to investigate.

https://github.com/vladfaust/prism/blob/b11a008d894675646ba6984211c1cf78928a64fc/src/prism/proc_handler.cr#L20
https://github.com/vladfaust/prism/blob/b11a008d894675646ba6984211c1cf78928a64fc/src/prism/router.cr#L99

class MyLogger < Rest::Logger
  def content(context)
    params = context.request.query_params.to_h
    somehow_modify_params # For example, cut some sensitive data
    context.request.path + modified_params # By default it's context.resource
  end
end

# GET /path?foo=<#> 1s

or even

logger = Rest::Logger.new do |env|
  context.request.path
end

# GET /path 1s

param :name, validate: {size: {gte: 3}}

It's a nice alternative to {size: (3..Float32::INFINITY)}.

• Params
• Auth

Because some apps may find it redundant.

• crystal-lang/crystal#6500
• crystal-lang/crystal#6241 Unrelated
• crystal-lang/crystal#6453 Unrelated

Crystal is growing. I spend so much effort on Prism to make web-development a joy, but seems like I'm the one who's using Prism in production. Let's change it!

• Remind that the GitHub README is for the master branch
• Tell that features appear along my needs and I'm open for issues and PRs
• Prism needs a website
  • Fancy landing page
  • Docs either on GitBook or VuePress
• Adapt for developers new to Crystal
  • Benchmarks with other languages
  • Common frameworks code comparison
  • Note about "catch bugs in development, not in production"
  • Tell about websockets built-in
• Adapt for Crystal developers looking for a better web framework
  • Tell about Prism modularity when you decide what to include
  • Tell about Prism object-oriented approach when where are no global configuration objects which allows to have multiple servers and routers in one application
  • Tell about versatile callbacks system
  • Tell about strict params typecasting which reduces amount of code and improves security drastically
  • Tell about versatile authentication module
• Add project template

See crystal-lang/crystal#6108

Because it may look like an error.

Composition over inheritance!

Ideal code would be:

struct MyAction
  include Prism::Action
  include Prism::Params
  include Prism::Auth
  
  auth!

  params do
    param :foo, Int32
  end
  
  def call
    # ...
  end
end

That said, following must be implemented:

• Prism::Action includes Callbacks and they do actually work (see crystal-lang/crystal#1104 (comment))
• MyAction can be an abstract struct and callbacks should work in this case as well
• Prism::Params and Prism::Auth included along with Prism::Action automatically inject those before callbacks Introduce Prism::Action::Params & Prism::Action::Auth, which is more straightforward IMO

It's more commonly used and much clearer IMO. I'm also thinking of less_than: 42 and greater_than_or_equal: 5, but their lengths are terrifying

Before 46e9ec7 (it used Router::Cacher):

faust@mi:~/Projects/prism$ crystal bench/router.cr --release --no-debug

Begin benchmarking router...
Running static paths...

simply cached router with static path   2.72M (367.77ns) (±17.02%)  207 B/op        fastest
   non-cached router with static path   1.41M (706.98ns) (± 8.20%)  496 B/op   1.92× slower

Running dynamic paths (random from 10000 known paths)...

simply cached router with dynamic paths 954.07k (  1.05µs) (±11.87%)   848 B/op        fastest
   non-cached router with dynamic paths 701.96k (  1.42µs) (±16.06%)  1296 B/op   1.36× slower

Running absolutely random paths (caching is useless)...

simply cached router with random paths 279.56k (  3.58µs) (±20.55%)  1449 B/op   2.09× slower
   non-cached router with random paths 584.69k (  1.71µs) (±19.35%)  1365 B/op        fastest

✔️ Done benchmarking router

After 46e9ec7:

faust@mi:~/Projects/prism$ crystal bench/router.cr --release --no-debug
  with static path    3.0M (333.73ns) (± 8.66%)   194 B/op        fastest
with dynamic paths 777.92k (  1.29µs) (±12.42%)  1400 B/op   3.85× slower
 with random paths 628.63k (  1.59µs) (± 8.63%)  1317 B/op   4.77× slower

Prism is famous for its strict params typing allowing nesting and array params as well. I'm proud of that and it's initially has been a goal for this project - typed params.

I know that other frameworks lack in this type of functionality and I'd like to extract it into a separate shard.

@paulsmith said that it would be better to make Params a class and make all params accessible by a method (e.g. params.user.email). Also there was a thought of making it abstract so it works not only with HTTP params, but with other data inputs.

How do you see an ideal shard for such a functionality? Take your time, see the code (start from https://github.com/vladfaust/prism/blob/master/src/prism/params.cr).

/cc @drujensen

Currently this does not compile:

params do
  param :"my-param", String?
end

With following error:

Syntax error in expanded macro: define_params_tuple:9: expected ')' or named argument, not g

          g-recaptcha-response: String
          ^

Which is kinda expected.

I'm guessing there's a straightforward way of handling this but everything I end up with feels a little overcomplicated or sloppy, typically via HTTP::Cookies and the Set-Cookie header. Is there a nicer way of handling this?

Would this a good candidate for a documentation example? Or even some kind of helper module?

shards install
Fetching https://github.com/atomframework/web.git
Error shard name (prism) doesn't match dependency name (atom-web)

See samueleaton/raze#8

Running the basic example:

require "prism"

struct KnockKnock
  include Prism::Action
  include Prism::Action::Params

  params do
    param :who, String
    param :times, Int32, validate: {max: 10}
  end

  def call
    params[:times].times do
      text("Knock-knock #{who}\n")
    end
  end
end

router = Prism::Router.new do
  get "/:who", KnockKnock
end

logger = Logger.new(STDOUT)
log_handler = Prism::LogHandler.new(logger)
handlers = [log_handler, router]

server = Prism::Server.new(handlers, logger)
server.bind_tcp(8000)
server.listen

#  INFO -- :   Prism::Server is listening on http://127.0.0.1:5000...

Results in a error:

Error in src/simple_app.cr:4: Prism::Action is not a module, it's a struct

  include Prism::Action

Crystal Info

$ crystal -v
Crystal 0.26.0 [eeb53c506] (2018-08-09)

LLVM: 4.0.0
Default target: x86_64-unknown-linux-gnu

crystal-lang/crystal#5286 is fixed

For apis it would make sense to be able to handle the param erros manually so one can respond with json that can be parsed on the client side.

See https://stackoverflow.com/questions/50774451/how-to-free-memory-allocated-for-some-structure-in-crystal-manually

Currently Rest::Logger logs a ws request only when it's closed.

Proposal:

1. Log when a web socket is opened;
2. Log when it is closed.

https://github.com/vladfaust/prism/blob/f9d9a236ec325834073a677c744bd6b95d4bb07f/src/prism/action/params.cr#L20

These halts should cast an object to JSON and change content type:

halt!(409, {error: "Something went wrong"})
halt!(403, PaymentError.new)

Are there any benchmarks for Prism?

Should check incoming request's scheme and organize the routing tree with /ws instead of current /get.

This will allow to place websocket actions under the same routes. 👍

Current:

def before
  super
  some_code
end

Proposed:

before do
  some_code
end

before do
  another_code
end

A program could potentially have many ways to initialize types from String, e.g. Int32 could be initialized like Int32.from_s("one") in some code.

I should rename from_s to something like from_string_param or maybe introduce initializers which accept String.

Cast String to Array or Hash, e.g:

params do
  param :ids, Array(String)
end

The issue is that different content types have different ways to pass arrays (and hashes). Moreover, there is no single standard of how-to... 🤔

https://github.com/vladfaust/prism/blob/f9d9a236ec325834073a677c744bd6b95d4bb07f/src/prism/handlers/router.cr#L48

https://github.com/vladfaust/prism/blob/f9d9a236ec325834073a677c744bd6b95d4bb07f/src/prism/handlers/logger.cr#L27

Change to

if context.request.headers.includes_word?("Upgrade", "Websocket")