313 lines
14 KiB
Elm
313 lines
14 KiB
Elm
module AddRoute exposing (run)
|
|
|
|
import BackendTask
|
|
import Cli.Option as Option
|
|
import Cli.OptionsParser as OptionsParser
|
|
import Cli.Program as Program
|
|
import Elm
|
|
import Elm.Annotation as Type
|
|
import Elm.Case
|
|
import Elm.Declare
|
|
import Elm.Let
|
|
import Elm.Op
|
|
import Gen.BackendTask
|
|
import Gen.Effect as Effect
|
|
import Gen.FatalError
|
|
import Gen.Form as Form
|
|
import Gen.Form.FieldView as FieldView
|
|
import Gen.Html as Html
|
|
import Gen.Html.Attributes as Attr
|
|
import Gen.Json.Encode
|
|
import Gen.List
|
|
import Gen.Maybe
|
|
import Gen.Pages.Form as PagesForm
|
|
import Gen.Pages.Script
|
|
import Gen.Server.Request as Request
|
|
import Gen.Server.Response as Response
|
|
import Gen.View
|
|
import Pages.Script as Script exposing (Script)
|
|
import Scaffold.Form
|
|
import Scaffold.Route exposing (Type(..))
|
|
|
|
|
|
type alias CliOptions =
|
|
{ moduleName : List String
|
|
, fields : List ( String, Scaffold.Form.Kind )
|
|
}
|
|
|
|
|
|
run : Script
|
|
run =
|
|
Script.withCliOptions program
|
|
(\cliOptions ->
|
|
cliOptions
|
|
|> createFile
|
|
|> Script.writeFile
|
|
|> BackendTask.allowFatal
|
|
)
|
|
|
|
|
|
program : Program.Config CliOptions
|
|
program =
|
|
Program.config
|
|
|> Program.add
|
|
(OptionsParser.build CliOptions
|
|
|> OptionsParser.with (Option.requiredPositionalArg "module" |> Scaffold.Route.moduleNameCliArg)
|
|
|> OptionsParser.withRestArgs Scaffold.Form.restArgsParser
|
|
)
|
|
|
|
|
|
createFile : CliOptions -> { path : String, body : String }
|
|
createFile { moduleName, fields } =
|
|
let
|
|
formHelpers :
|
|
Maybe
|
|
{ formHandlers : Elm.Expression
|
|
, form : Elm.Expression
|
|
, declarations : List Elm.Declaration
|
|
}
|
|
formHelpers =
|
|
Scaffold.Form.provide
|
|
{ fields = fields
|
|
, elmCssView = False
|
|
, view =
|
|
\{ formState, params } ->
|
|
Elm.Let.letIn
|
|
(\fieldView ->
|
|
Elm.list
|
|
((params
|
|
|> List.map
|
|
(\{ name, kind, param } ->
|
|
fieldView (Elm.string name) param
|
|
)
|
|
)
|
|
++ [ Elm.ifThen formState.submitting
|
|
(Html.button
|
|
[ Attr.disabled True
|
|
]
|
|
[ Html.text "Submitting..."
|
|
]
|
|
)
|
|
(Html.button []
|
|
[ Html.text "Submit"
|
|
]
|
|
)
|
|
]
|
|
)
|
|
)
|
|
|> Elm.Let.fn2 "fieldView"
|
|
( "label", Type.string |> Just )
|
|
( "field", Nothing )
|
|
(\label field ->
|
|
Html.div []
|
|
[ Html.label []
|
|
[ Html.call_.text (Elm.Op.append label (Elm.string " "))
|
|
, field |> FieldView.input []
|
|
, errorsView.call formState.errors field
|
|
]
|
|
]
|
|
)
|
|
|> Elm.Let.toExpression
|
|
}
|
|
in
|
|
Scaffold.Route.serverRender
|
|
{ moduleName = moduleName
|
|
, action =
|
|
( Alias
|
|
(Type.record
|
|
(case formHelpers of
|
|
Just _ ->
|
|
[ ( "errors", Type.namedWith [ "Form" ] "ServerResponse" [ Type.string ] )
|
|
]
|
|
|
|
Nothing ->
|
|
[]
|
|
)
|
|
)
|
|
, \routeParams request ->
|
|
formHelpers
|
|
|> Maybe.map
|
|
(\justFormHelp ->
|
|
Request.formData justFormHelp.formHandlers request
|
|
|> Gen.Maybe.call_.map
|
|
(Elm.fn ( "formData", Nothing )
|
|
(\formData ->
|
|
Elm.Case.tuple formData
|
|
"response"
|
|
"parsedForm"
|
|
(\response parsedForm ->
|
|
Elm.Case.custom parsedForm
|
|
Type.int
|
|
[ Elm.Case.branch1 "Form.Valid"
|
|
( "validatedForm", Type.int )
|
|
(\validatedForm ->
|
|
Elm.Case.custom validatedForm
|
|
Type.int
|
|
[ Elm.Case.branch1 "Action"
|
|
( "parsed", Type.int )
|
|
(\parsed ->
|
|
Scaffold.Form.recordEncoder parsed fields
|
|
|> Gen.Json.Encode.encode 2
|
|
|> Gen.Pages.Script.call_.log
|
|
|> Gen.BackendTask.call_.map
|
|
(Elm.fn ( "_", Nothing )
|
|
(\_ ->
|
|
Response.render
|
|
(Elm.record
|
|
[ ( "errors", response )
|
|
]
|
|
)
|
|
)
|
|
)
|
|
)
|
|
]
|
|
)
|
|
, Elm.Case.branch2 "Form.Invalid"
|
|
( "parsed", Type.int )
|
|
( "error", Type.int )
|
|
(\_ _ ->
|
|
"Form validations did not succeed!"
|
|
|> Gen.Pages.Script.log
|
|
|> Gen.BackendTask.call_.map
|
|
(Elm.fn ( "_", Nothing )
|
|
(\_ ->
|
|
Response.render
|
|
(Elm.record
|
|
[ ( "errors", response )
|
|
]
|
|
)
|
|
)
|
|
)
|
|
)
|
|
]
|
|
)
|
|
)
|
|
)
|
|
|> Gen.Maybe.withDefault
|
|
(Gen.BackendTask.fail
|
|
(Gen.FatalError.fromString "Expected form post")
|
|
)
|
|
)
|
|
|> Maybe.withDefault
|
|
(Gen.BackendTask.succeed
|
|
(Response.render
|
|
(Elm.record [])
|
|
)
|
|
)
|
|
)
|
|
, data =
|
|
( Alias (Type.record [])
|
|
, \routeParams request ->
|
|
Gen.BackendTask.succeed
|
|
(Response.render
|
|
(Elm.record [])
|
|
)
|
|
)
|
|
, head = \app -> Elm.list []
|
|
}
|
|
|> Scaffold.Route.addDeclarations
|
|
(formHelpers
|
|
|> Maybe.map .declarations
|
|
|> Maybe.map ((::) errorsView.declaration)
|
|
|> Maybe.withDefault []
|
|
)
|
|
|> Scaffold.Route.buildWithLocalState
|
|
{ view =
|
|
\{ shared, model, app } ->
|
|
Gen.View.make_.view
|
|
{ title = moduleName |> String.join "." |> Elm.string
|
|
, body =
|
|
Elm.list
|
|
(case formHelpers of
|
|
Just justFormHelp ->
|
|
[ Html.h2 [] [ Html.text "Form" ]
|
|
, justFormHelp.form
|
|
|> PagesForm.call_.renderHtml
|
|
(Elm.list [])
|
|
(Form.options "form"
|
|
|> Form.withServerResponse
|
|
(app
|
|
|> Elm.get "action"
|
|
|> Gen.Maybe.map (Elm.get "errors")
|
|
)
|
|
)
|
|
app
|
|
]
|
|
|
|
Nothing ->
|
|
[ Html.h2 [] [ Html.text "New Page" ]
|
|
]
|
|
)
|
|
}
|
|
, update =
|
|
\{ shared, app, msg, model } ->
|
|
Elm.Case.custom msg
|
|
(Type.named [] "Msg")
|
|
[ Elm.Case.branch0 "NoOp"
|
|
(Elm.tuple model
|
|
Effect.none
|
|
)
|
|
]
|
|
, init =
|
|
\{ shared, app } ->
|
|
Elm.tuple (Elm.record []) Effect.none
|
|
, subscriptions =
|
|
\{ routeParams, path, shared, model } ->
|
|
Elm.val "Sub.none"
|
|
, model =
|
|
Alias (Type.record [])
|
|
, msg =
|
|
Custom [ Elm.variant "NoOp" ]
|
|
}
|
|
|
|
|
|
errorsView :
|
|
{ declaration : Elm.Declaration
|
|
, call : Elm.Expression -> Elm.Expression -> Elm.Expression
|
|
, callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression
|
|
, value : List String -> Elm.Expression
|
|
}
|
|
errorsView =
|
|
Elm.Declare.fn2 "errorsView"
|
|
( "errors", Type.namedWith [ "Form" ] "Errors" [ Type.string ] |> Just )
|
|
( "field"
|
|
, Type.namedWith [ "Form", "Validation" ]
|
|
"Field"
|
|
[ Type.string
|
|
, Type.var "parsed"
|
|
, Type.var "kind"
|
|
]
|
|
|> Just
|
|
)
|
|
(\errors field ->
|
|
Elm.ifThen
|
|
(Gen.List.call_.isEmpty (Form.errorsForField field errors))
|
|
(Html.div [] [])
|
|
(Html.div
|
|
[]
|
|
[ Html.call_.ul (Elm.list [])
|
|
(Gen.List.call_.map
|
|
(Elm.fn ( "error", Nothing )
|
|
(\error ->
|
|
Html.li
|
|
[ Attr.style "color" "red"
|
|
]
|
|
[ Html.call_.text error
|
|
]
|
|
)
|
|
)
|
|
(Form.errorsForField field errors)
|
|
)
|
|
]
|
|
)
|
|
|> Elm.withType
|
|
(Type.namedWith [ "Html" ]
|
|
"Html"
|
|
[ Type.namedWith
|
|
[ "PagesMsg" ]
|
|
"PagesMsg"
|
|
[ Type.named [] "Msg" ]
|
|
]
|
|
)
|
|
)
|