debug;
28 |
29 | public PubSub pubsub;
30 |
31 | public Config() {
32 | // use the default main layout
33 | this.mainLayout = new MainLayout() {
34 | @Override
35 | public UndeadTemplate render(PageTitle pageTitle, String csrfToken, UndeadTemplate content) {
36 | return MainLayout.super.render(pageTitle, csrfToken, content);
37 | }
38 | };
39 | // default PubSub to MemPubSub
40 | this.pubsub = MemPubSub.INSTANCE;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/Context.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | import run.undead.event.UndeadEvent;
4 | import run.undead.event.UndeadInfo;
5 | import run.undead.view.View;
6 | import run.undead.template.MainLayout;
7 |
8 | /**
9 | * Context abstracts the underlying transport mechanism (i.e. HTTP or WebSocket) for a
10 | * {@link View} and provides common functionality and metadata to extend the behavior
11 | * of the {@link View} instance.
12 | */
13 | public interface Context {
14 | // TODO:
15 | // support tempAssign (perhaps a @TempAssign annotation on a property?)
16 | // support pushPatch, pushRedirect,
17 | // how do we inject services into this object?
18 | // uploads: allowUpload, cancelUpload, consumeUploadedEntries, uploadedEntries
19 |
20 | /**
21 | * id is the unique id of the Undead {@link View} instance
22 | */
23 | String id();
24 |
25 | /**
26 | * connected is true if connected to a websocket, false for http request
27 | */
28 | default Boolean connected() {
29 | return false;
30 | }
31 |
32 | /**
33 | * url is the URL for this {@link View}
34 | */
35 | String url();
36 |
37 | /**
38 | * pageTitle updates the `` tag of the {@link View} page. Requires using the
39 | * {@link MainLayout#liveTitle} helper in rendering the page.
40 | */
41 | default void pageTitle(String newTitle) {
42 | // noop by default
43 | }
44 |
45 | /**
46 | * pushEvent pushes an event to the client. Requires either the client javascript
47 | * to have a {@code window.addEventListener} defined for that event or a client
48 | * {@code Hook} to be defined and to be listening for the event via {@code this.handleEvent} callback.
49 | */
50 | default void pushEvent(UndeadEvent event){
51 | // noop by default
52 | }
53 |
54 | /**
55 | * sendInfo sends an internal server message to this {@link View} instance. The
56 | * {@link View} must implement the {@link View#handleInfo(Context, UndeadInfo)} callback
57 | * to handle the info message.
58 | */
59 | default void sendInfo(UndeadInfo info) {
60 | // noop by default
61 | }
62 |
63 | void redirect(String url);
64 |
65 | /**
66 | * subscribe subscribes the {@link View} to the given topic. The {@link View} must
67 | * implement the {@link View#handleInfo(Context, UndeadInfo)} callback to handle the
68 | * info messages for the topic.
69 | * @param topic the topic to subscribe to
70 | */
71 | default void subscribe(String topic) {
72 | // noop by default
73 | }
74 |
75 | /**
76 | * unsubscribe unsubscribes the {@link View} from the given topic.
77 | * @param topic the topic to unsubscribe from
78 | */
79 | default void unsubscribe(String topic) {
80 | // noop by default
81 | }
82 |
83 | /**
84 | * publish publishes the given data to the given topic.
85 | * @param topic the topic to publish to
86 | * @param data the data to publish
87 | */
88 | default void publish(String topic, String data) {
89 | // noop by default
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/HttpContext.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | /**
4 | * HttpContext implements the {@link Context} interface for the HTTP request
5 | * lifecycle.
6 | */
7 | public class HttpContext implements Context {
8 | private final String id;
9 | private final String url;
10 |
11 | public String redirect;
12 |
13 | public HttpContext(String id, String url) {
14 | this.id = id;
15 | this.url = url;
16 | }
17 |
18 | @Override
19 | public String id() {
20 | return this.id;
21 | }
22 |
23 | @Override
24 | public String url() {
25 | return this.url;
26 | }
27 |
28 | @Override
29 | public void redirect(String url) {
30 | this.redirect = url;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/HttpHandler.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | import okhttp3.HttpUrl;
4 | import run.undead.handle.http.RequestAdaptor;
5 | import run.undead.template.*;
6 | import run.undead.view.Meta;
7 | import run.undead.view.View;
8 |
9 | import java.util.HashMap;
10 | import java.util.UUID;
11 |
12 | /**
13 | * HttpHandler handles the HTTP request lifecycle for a {@link View} and either
14 | * returns the rendered HTML or redirects the request.
15 | */
16 | public class HttpHandler {
17 |
18 | /**
19 | * Handle the HTTP request lifecycle for a {@link View} and either
20 | * return the rendered HTML or redirect the request.
21 | * @param view the {@link View} to render
22 | * @param mainLayout the {@link MainLayout} to render the {@link View} inside
23 | * @param adaptor the {@link RequestAdaptor} to pull data from the HTTP request
24 | * @param pageTitle the {@link PageTitle} to pass to the {@link MainLayout}
25 | * @param wrapperTemplate the optional {@link WrapperTemplate} to render the {@link View} inside
26 | * @return the rendered HTML or null if the request was redirected
27 | */
28 | static public String handle(
29 | View view,
30 | MainLayout mainLayout,
31 | RequestAdaptor adaptor,
32 | PageTitle pageTitle,
33 | WrapperTemplate wrapperTemplate
34 | ) {
35 |
36 | // new viewId for each request
37 | var viewId = UUID.randomUUID().toString();
38 |
39 | // extract csrf token from session data or generate it if it doesn't exist
40 | var sessionData = adaptor.sessionData();
41 | var csrfToken = (String) sessionData.get("_csrf_token");
42 | if (csrfToken == null) {
43 | csrfToken = UUID.randomUUID().toString();
44 | sessionData.put("_csrf_token", csrfToken);
45 | }
46 |
47 | var ctx = new HttpContext(viewId, adaptor.url());
48 |
49 | // execute the `LiveView`'s `mount` function, passing in the data from the HTTP request
50 | var params = new HashMap<>();
51 | params.put("_csrf_token", csrfToken);
52 | params.put("_mounts", -1);
53 | params.putAll(adaptor.pathParams());
54 | params.putAll(adaptor.queryParams());
55 |
56 | // Step 1: call mount
57 | view.mount(ctx, sessionData, params);//socket, sessionData, params
58 |
59 | // handle redirects in mount
60 | if (ctx.redirect != null) {
61 | adaptor.willRedirect(ctx.redirect);
62 | return null;
63 | }
64 |
65 | // Step 2: call handleParams
66 | var url = HttpUrl.parse(adaptor.url());
67 | view.handleParams(ctx, url.uri(), params);
68 |
69 | // handle redirects in handleParams
70 | if (ctx.redirect != null) {
71 | adaptor.willRedirect(ctx.redirect);
72 | return null;
73 | }
74 |
75 | // Step 3: call render
76 | var meta = new Meta();
77 | // TODO implement Components
78 | var tmpl = view.render(meta);
79 |
80 | // TODO implement serialization
81 | var serializedSession = "";//await serDe.serialize({ ...sessionData });
82 |
83 | // TODO implement tracking of statics
84 | var serializedStatics = "";//serDe.serialize({ ...view.statics });
85 |
86 | // check if there is a WrapperTemplate and render the View inside it
87 | var content = tmpl;
88 | if (wrapperTemplate != null) {
89 | content = wrapperTemplate.render(sessionData, content);
90 | }
91 |
92 | // render the root container of the View
93 | var rootContent = Undead.HTML. """
94 | <div
95 | data-phx-main="true"
96 | data-phx-session="\{ serializedSession }"
97 | data-phx-static="\{ serializedStatics }"
98 | id="ud-\{ viewId }">
99 | \{ Directive.NoEscape(content) }
100 | </div>
101 | """ ;
102 |
103 | // render the main layout with the View inside
104 | var pageTmpl = mainLayout.render(pageTitle, csrfToken, rootContent);
105 |
106 | // serialize the View to HTML
107 | return pageTmpl.toString();
108 | }
109 | }
110 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/WsContext.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | import run.undead.event.SimpleUndeadInfo;
4 | import run.undead.event.UndeadEvent;
5 | import run.undead.event.UndeadInfo;
6 | import run.undead.protocol.Reply;
7 | import run.undead.pubsub.PubSub;
8 | import run.undead.template.UndeadTemplate;
9 | import run.undead.view.Meta;
10 | import run.undead.view.View;
11 |
12 | import java.util.List;
13 | import java.util.Map;
14 | import java.util.concurrent.ConcurrentHashMap;
15 |
16 | /**
17 | * WsContext is an implementation of the {@link Context} for the WebSocket
18 | * lifecycle.
19 | */
20 | public class WsContext implements Context {
21 | protected String id;
22 | protected String url;
23 | protected View view;
24 | protected String joinRef;
25 | protected String msgRef;
26 | protected String csrfToken;
27 | protected String redirect;
28 | protected WsSender sender;
29 | protected Map<String, String> subs; // topic to subId
30 | protected PubSub pubsub;
31 | protected UndeadTemplate lastTmpl;
32 | protected List<UndeadEvent> events;
33 | protected String title;
34 |
35 | public WsContext(String id, String url, View view) {
36 | this.id = id;
37 | this.url = url;
38 | this.view = view;
39 | this.subs = new ConcurrentHashMap<>();
40 | }
41 |
42 | @Override
43 | public String id() {
44 | return this.id;
45 | }
46 |
47 | @Override
48 | public String url() {
49 | return this.url;
50 | }
51 |
52 | @Override
53 | public Boolean connected() {
54 | return true;
55 | }
56 |
57 | @Override
58 | public void pageTitle(String newTitle) {
59 | this.title = newTitle;
60 | }
61 |
62 | @Override
63 | public void pushEvent(UndeadEvent event) {
64 | this.events.add(event);
65 | }
66 |
67 | @Override
68 | public void sendInfo(UndeadInfo info) {
69 | this.view.handleInfo(this, info);
70 | var content = this.view.render(new Meta());
71 | this.sender.send(Reply.diff(this.id, diffParts(content)));
72 | }
73 |
74 | @Override
75 | public void redirect(String url) {
76 | this.redirect = url;
77 | }
78 |
79 | @Override
80 | public void subscribe(String topic) {
81 | if(this.pubsub == null) {
82 | throw new RuntimeException("pubsub not set");
83 | }
84 | // check if already subscribed
85 | if(this.subs.containsKey(topic)) {
86 | return;
87 | }
88 | var subId = this.pubsub.subscribe(topic, (t, m) -> {
89 | this.sendInfo(new SimpleUndeadInfo(t, m));
90 | });
91 | // save topic to sub mapping
92 | this.subs.put(topic, subId);
93 | }
94 |
95 | @Override
96 | public void unsubscribe(String topic) {
97 | if(this.pubsub == null) {
98 | throw new RuntimeException("pubsub not set");
99 | }
100 | // check if we have a subId for this topic
101 | if(!this.subs.containsKey(topic)) {
102 | return;
103 | }
104 | this.pubsub.unsubscribe(this.subs.get(topic));
105 | }
106 |
107 | @Override
108 | public void publish(String topic, String data) {
109 | if(this.pubsub == null) {
110 | throw new RuntimeException("pubsub not set");
111 | }
112 | this.pubsub.publish(topic, data);
113 | }
114 |
115 | public void handleClose() {
116 | if(this.pubsub != null) {
117 | for(var topic : subs.keySet()) {
118 | this.unsubscribe(topic);
119 | }
120 | }
121 | if (this.view != null) {
122 | this.view.shutdown();
123 | }
124 | }
125 |
126 | public void handleError(Object err) {
127 | // TODO send something to client to reload?
128 | this.handleClose();
129 | }
130 |
131 | /**
132 | * diffParts takes the new template and diffs it with the last template (if there was one)
133 | * and returns the diff "parts" to send to the client. Additionally, this method will
134 | * add the title and events to the parts if they are set.
135 | * @param newTmpl the new template to diff with the last template
136 | * @return the diff "parts" to send to the client
137 | */
138 | public Map<String, Object> diffParts(UndeadTemplate newTmpl) {
139 | var oldTmpl = this.lastTmpl;
140 | this.lastTmpl = newTmpl;
141 | var parts = newTmpl.toParts();
142 | // if we have an old template diff with new template
143 | if(oldTmpl != null) {
144 | parts = UndeadTemplate.diff(oldTmpl.toParts(), newTmpl.toParts());
145 | }
146 | // add title if set
147 | if(this.title != null) {
148 | parts.put("t", this.title);
149 | this.title = null;
150 | }
151 | // add events if set
152 | if(this.events != null) {
153 | parts.put("e", this.events);
154 | this.events = null;
155 | }
156 | return parts;
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/WsHandler.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | import com.google.common.base.Strings;
4 | import run.undead.config.Config;
5 | import run.undead.event.SimpleUndeadEvent;
6 | import run.undead.protocol.MsgParser;
7 | import run.undead.protocol.Reply;
8 | import run.undead.template.UndeadTemplate;
9 | import run.undead.url.Values;
10 | import run.undead.view.Meta;
11 | import okhttp3.HttpUrl;
12 | import run.undead.view.View;
13 |
14 | import java.util.Map;
15 |
16 | /**
17 | * WsHandler handles the websocket request lifecycle for a {@link View}
18 | */
19 | public class WsHandler {
20 | private final Config undeadConfig;
21 | private WsSender wsSender;
22 | private WsContext context;
23 |
24 | public WsHandler(Config undeadConfig) {
25 | this.undeadConfig = undeadConfig;
26 | }
27 |
28 | public void setWsSender(WsSender wsSender) {
29 | this.wsSender = wsSender;
30 | }
31 |
32 | public void handleMessage(String message) throws Exception {
33 | var msg = new MsgParser().parseJSON(message);
34 | switch (msg.event()) {
35 | case "heartbeat":
36 | wsSender.send(Reply.heartbeat(msg));
37 | break;
38 | case "phx_join":
39 | // check if topic starts with "lv:" or "lvu:"
40 | // "lv:" is a live view join
41 | // "lvu:" is a live view upload join
42 | var prefix = msg.topic().split(":");
43 | switch (prefix[0]) {
44 | case "lv":
45 | // for "lv" joins the payload should include a "url" or "redirect" key
46 | // from which we can to look up the View
47 | var urlStr = "";
48 | if (msg.payload().containsKey("url")) {
49 | urlStr = (String) msg.payload().get("url");
50 | } else if (msg.payload().containsKey("redirect")) {
51 | urlStr = (String) msg.payload().get("redirect");
52 | } else {
53 | throw new RuntimeException("no url or redirect key found in payload");
54 | }
55 | // extract the path from the URL and match it using the route matcher
56 | var url = HttpUrl.parse(urlStr);
57 | var path = url.encodedPath();
58 | var view = undeadConfig.routeMatcher.matches(path);
59 | if (view == null) {
60 | throw new RuntimeException("unable to find view for path:" + path + " url:" + urlStr);
61 | }
62 |
63 | // get data from params
64 | var params = (Map) msg.payload().get("params");
65 | if (params == null) {
66 | throw new RuntimeException("params not present in payload");
67 | }
68 |
69 | // TODO decode session
70 | var session = (String) msg.payload().get("session");
71 | // TODO pull path params from url
72 | var pathParams = undeadConfig.routeMatcher.pathParams(path);
73 | // merge path params into params
74 | params.putAll(pathParams);
75 |
76 | // setup WS context
77 | context = new WsContext(msg.topic(), urlStr, view);
78 | context.joinRef = msg.joinRef();
79 | context.msgRef = msg.msgRef();
80 | context.csrfToken = (String) params.get("_csrf_token");
81 | context.view = view;
82 | context.sender = wsSender;
83 | context.pubsub = undeadConfig.pubsub;
84 | // TODO get session data and params
85 |
86 | // lv: join messages get a mount => handleParams => render
87 | view.mount(context, Map.of(), params);
88 | view.handleParams(context, url.uri(), params);
89 | var content = view.render(new Meta());
90 |
91 | // instead of serializing as HTML string, we send back the parts data structure
92 | wsSender.send(Reply.rendered(msg, context.diffParts(content)));
93 | break;
94 | // TODO case "lvu" i.e. uploads
95 | default: // unknown phx_join topic
96 | throw new RuntimeException("unknown phx_join topic");
97 | }
98 | break;
99 | case "event":
100 | // determine type of event and further details
101 | var payloadEventType = (String) msg.payload().get("type");
102 | var payloadEvent = (String) msg.payload().get("event");
103 | // TODO handle components
104 | // var cid = (String)msg.payload().get("cid");
105 | UndeadTemplate tmpl;
106 | switch (payloadEventType) {
107 | case "click":
108 | case "keyup":
109 | case "keydown":
110 | case "blur":
111 | case "focus":
112 | case "hook":
113 | // get value from payload with should be a map
114 | var payloadValues = Values.from((Map<String, String>) msg.payload().get("value"));
115 | // convert the value map to a url.Values
116 |
117 | // check if the click is a lv:clear-flash event
118 | // which does not invoke HandleEvent but should
119 | // set the flash value to "" and send a responseDiff
120 | if (payloadEventType.equals("lv:clear-flash")) {
121 | var flashKey = payloadValues.get("key");
122 | // TODO implement clear flash
123 | throw new RuntimeException("clear flash not implemented");
124 | } else {
125 | // handle the event
126 | this.context.view.handleEvent(context, new SimpleUndeadEvent(payloadEvent, payloadValues));
127 | }
128 | break;
129 | case "form":
130 | // for form events the payload value is a string that needs to be parsed into the data
131 | var values = Values.from((String) msg.payload().get("value"));
132 | // handle uploads before calling calling handleEvent
133 | // TODO uploads
134 | this.context.view.handleEvent(context, new SimpleUndeadEvent(payloadEvent, values));
135 | break;
136 | default:
137 | throw new RuntimeException("unknown event type:" + payloadEventType);
138 | }
139 | // check if we have a redirect
140 | if (context != null && !Strings.isNullOrEmpty(context.redirect)) {
141 | wsSender.send(Reply.redirect(msg, context.redirect));
142 | break;
143 | }
144 | // otherwise rerender
145 | var content = context.view.render(new Meta());
146 | wsSender.send(Reply.replyDiff(msg, context.diffParts(content)));
147 | break;
148 | default:
149 | throw new RuntimeException("unhandled event:" + msg.event());
150 | }
151 | }
152 |
153 | public void handleError(Object error) {
154 | if (this.context != null) {
155 | this.context.handleError(error);
156 | }
157 | }
158 |
159 | public void handleClose() {
160 | if (this.context != null) {
161 | this.context.handleClose();
162 | }
163 | }
164 |
165 |
166 |
167 | }
168 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/context/WsSender.java:
--------------------------------------------------------------------------------
1 | package run.undead.context;
2 |
3 | /**
4 | * WsSender is an interface for sending String data to the websocket client.
5 | */
6 | public interface WsSender {
7 |
8 | /**
9 | * Send string data to the client over the websocket.
10 | * @param data the data to send
11 | */
12 | void send(String data);
13 | }
14 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/event/SimpleUndeadEvent.java:
--------------------------------------------------------------------------------
1 | package run.undead.event;
2 |
3 | import run.undead.url.Values;
4 |
5 | /**
6 | * SimpleUndeadEvent is a simple implementation of {@link UndeadEvent} that is used internally by Undead.
7 | * @param type the type of the event
8 | * @param data the data associated with the event
9 | */
10 | public record SimpleUndeadEvent(String type, Values data) implements UndeadEvent {
11 | }
12 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/event/SimpleUndeadInfo.java:
--------------------------------------------------------------------------------
1 | package run.undead.event;
2 |
3 | /**
4 | * SimpleUndeadInfo is a simple implementation of {@link UndeadInfo} that is used internally by Undead.
5 | * @param type the type of the event
6 | * @param data the String data associated with the event
7 | */
8 | public record SimpleUndeadInfo(String type, String data) implements UndeadInfo {
9 | }
10 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/event/UndeadEvent.java:
--------------------------------------------------------------------------------
1 | package run.undead.event;
2 |
3 | import run.undead.js.JS;
4 | import run.undead.url.Values;
5 | import run.undead.template.UndeadTemplate;
6 | import run.undead.view.View;
7 |
8 | /**
9 | * UndeadEvent is the interface for all events that are received from the browser. Events are automatically
10 | * sent to the server when an element with a <code>ud-</code> attribute's event is triggered from an element
11 | * in an {@link UndeadTemplate}.
12 | *
13 | * @see UndeadTemplate
14 | * @see View
15 | * @see JS
16 | */
17 | public interface UndeadEvent {
18 | /**
19 | * type is the type of the event. For example, if a button has a <code>ud-click="my-event"</code> attribute,
20 | * then the type of the event will be <code>my-event</code>.
21 | * @return the type of the event
22 | */
23 | String type();
24 |
25 | /**
26 | * data contains the {@link Values} associated with the event. For example, if a button has a
27 | * <code>ud-value-foo="bar"</code> attribute, then the data of the event will contain a key/value
28 | * pairs of <code>foo</code> to <code>bar</code>.
29 | * @return the data associated with the event
30 | */
31 | Values data();
32 | }
33 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/event/UndeadInfo.java:
--------------------------------------------------------------------------------
1 | package run.undead.event;
2 |
3 | import run.undead.context.Context;
4 |
5 | /**
6 | * UndeadInfo is the interface for all events that are from the server (either from a {@link Context#sendInfo(UndeadInfo)}
7 | * or from a pub/sub subscription. Since this data comes directly from another server side process, Undead
8 | * does not parse it or otherwise modify. It is up to the developer to parse the data and handle it appropriately.
9 | */
10 | public interface UndeadInfo {
11 |
12 | /**
13 | * type is the type of info event
14 | * @return the type of the info event
15 | */
16 | String type();
17 |
18 | /**
19 | * data is the String data associated with the info
20 | * @return the String data
21 | */
22 | String data();
23 | }
24 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/form/Form.java:
--------------------------------------------------------------------------------
1 | package run.undead.form;
2 |
3 | import com.fasterxml.jackson.databind.DeserializationFeature;
4 | import com.fasterxml.jackson.databind.ObjectMapper;
5 | import com.google.common.base.Strings;
6 | import run.undead.url.Values;
7 | import jakarta.validation.Validation;
8 | import jakarta.validation.Validator;
9 | import org.hibernate.validator.messageinterpolation.ParameterMessageInterpolator;
10 | import run.undead.view.View;
11 |
12 | import java.util.*;
13 |
14 | /**
15 | * Form makes it dead easy to validate and bind form data to a model in Undead.
16 | * Currently, this requires the use <a href="https://beanvalidation.org/">Jakarta Bean Validation (JSR 380)</a>
17 | * annotations to validate the model. Form handles mapping the form data to the model automatically
18 | * and providing a easy-to-use API for rendering form inputs and error messages.
19 | * <p>
20 | * Here is an example {@link View} that uses Form:
21 | * <pre>{@code
22 | * // first define UserModel with Jakarta Bean Validation annotations
23 | * public record UserModel(@NotBlank String name, @NotBlank @Email String email) { }
24 | * }</pre>
25 | *
26 | * Then define a view that uses this model and form:
27 | * {@code
28 | * public class UndeadUserForm implements View {
29 | *
30 | * private Form<UserModel> form;
31 | * private UserModel user;
32 | *
33 | * public UndeadUserForm() {
34 | * this.form = new Form<>(UserModel.class, new Values());
35 | * }
36 | *
37 | * @Override
38 | * public void handleEvent(Socket socket, UndeadEvent event) {
39 | * if (event.type().equals("validate")) {
40 | * // just update the form with the data from the event
41 | * // which will trigger validations and update the form state
42 | * this.form.update(event.data(), event.type());
43 | * return;
44 | * }
45 | * if (event.type().equals("submit")) {
46 | * this.form.update(event.data(), event.type());
47 | * // if form is valid, "save" user and reset form
48 | * if (this.form.valid()) {
49 | * this.user = this.form.model();
50 | * this.form = new Form<>(UserModel.class, new Values());
51 | * }
52 | * }
53 | * }
54 | *
55 | * @Override
56 | * public UndeadTemplate render(Meta meta) {
57 | * // NOTE the <code>ud-change="validate"</code> and <code>ud-submit="submit"</code> attributes
58 | * // on the form element. These are used to trigger the form validation and submission events
59 | * return HTML. """
60 | * <form class="form" ud-change="validate" ud-submit="submit">
61 | * <div class="flex flex-col space-y-4 mx-4 w-[250px]">
62 | * <h2 class="text-2xl">User Form</h2>
63 | * <label for="name">Name</label>
64 | * \{ TextInput(form, "name", "input input-bordered") }
65 | * \{ ErrorMsg(form, "name") }
66 | * <label for="email">Email</label>
67 | * \{ TextInput(form, "email", "input input-bordered") }
68 | * \{ ErrorMsg(form, "email") }
69 | * <button \{ If(!form.valid(), HTML." disabled", EMPTY) } class="btn btn-primary" type="submit">Submit</button>
70 | * </div>
71 | * </form>
72 | * """ ;
73 | * }
74 | * }
75 | * </p>
76 | * <p>
77 | * The view above uses the following helper tags to render the form inputs and error messages:
78 | * <pre>{@code
79 | * public class Input {
80 | * public static UndeadTemplate TextInput(Form form, String name, String... classes) {
81 | * var value = form.data().get(name);
82 | * var classesString = "";
83 | * for (var clazz : classes) {
84 | * classesString += clazz + " ";
85 | * }
86 | * return Directive.HTML. """
87 | * <input type="text" id="\{ name }" name="\{ name }" value="\{ value }" class="\{ classesString }" />
88 | * """ ;
89 | * }
90 | * public static UndeadTemplate ErrorMsg(Form form, String name) {
91 | * var error = form.errorFor(name);
92 | * if (Strings.isNullOrEmpty(error)) {
93 | * return Directive.EMPTY;
94 | * }
95 | * return Directive.HTML. """
96 | * <div class="text-sm text-error">\{ error }</div>
97 | * """ ;
98 | * }
99 | * }
100 | * }</pre>
101 | * </p>
102 | *
103 | * @param <T> the type of the model to which the form data is bound.
104 | *
105 | */
106 | public class Form<T> {
107 |
108 | private final ObjectMapper mapper;
109 | private final Validator validator;
110 | private final Values values;
111 | private final Values changes;
112 | private final Class clazz;
113 | private String action;
114 | private final Set<String> touched;
115 | private T model;
116 | private Map<String, String> errors;
117 |
118 | /**
119 | * Create a new, empty form with the given model.
120 | * @param clazz the class of the model to bind the form data to
121 | */
122 | public Form(Class clazz) {
123 | this(clazz, new Values());
124 | }
125 |
126 | /**
127 | * Create a new form with the given model and initial values.
128 | * @param clazz the class of the model to bind the form data to
129 | * @param initial the initial values for the form which can be empty
130 | */
131 | public Form(Class clazz, Values initial) {
132 | this.mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
133 | this.validator = Validation.byDefaultProvider()
134 | .configure()
135 | .messageInterpolator(new ParameterMessageInterpolator())
136 | .buildValidatorFactory()
137 | .getValidator();
138 | this.touched = new HashSet<>();
139 | this.values = initial;
140 | this.changes = new Values();
141 | this.clazz = clazz;
142 | this.errors = new HashMap<>();
143 | this.model = (T) mapper.convertValue(values.asMap(), clazz);
144 | }
145 |
146 | /**
147 | * Updates the form with new values and an action. If the action is
148 | * null or empty, the form will not be validated (valid() will return true)
149 | * regardless of whether or not there are errors.
150 | * @param newValues the new values to update the form with
151 | * @param action the action to validate the form with
152 | */
153 | public void update(Values newValues, String action) {
154 | this.action = action;
155 |
156 | // merge old and new data and calculate changes
157 | newValues.asMap().forEach((k, v) -> {
158 | if (values.get(k) == null || !values.get(k).equals(v)) {
159 | switch (v) {
160 | case String s -> changes.add(k, s);
161 | case List l -> {
162 | for (Object o : l) {
163 | changes.add(k, String.valueOf(o));
164 | }
165 | }
166 | // throw error?
167 | default -> changes.add(k, String.valueOf(v));
168 | }
169 | }
170 | values.set(k, v);
171 | });
172 | // handle case where _target is set but the newData does not contain the _target field
173 | // this happens in the case of a checkbox that is unchecked
174 | var target = newValues.get("_target");
175 | if (target != null && newValues.get(target) == null) {
176 | values.delete(target);
177 | changes.add(target, "");
178 | }
179 | // validate if action is not empty
180 | if (!Strings.isNullOrEmpty(action)) {
181 | // map values to model
182 | model = (T) mapper.convertValue(values.asMap(), clazz);
183 | // validate model
184 | var violations = validator.validate(model);
185 | // convert violations to errors
186 | errors = new HashMap<>();
187 | for (var v : violations) {
188 | errors.put(v.getPropertyPath().toString(), v.getMessage());
189 | }
190 |
191 | // if we get a _target field in the form, use it to indicate which fields were touched
192 | // if not, assume all fields in input were touched and all fields
193 | // with errors were touched
194 | if (target != null) {
195 | this.touched.add(target);
196 | } else {
197 | for (var k : values.asMap().keySet()) {
198 | this.touched.add(k);
199 | }
200 | for (var e : errors.keySet()) {
201 | this.touched.add(e);
202 | }
203 | }
204 | }
205 | }
206 |
207 | /**
208 | * Returns the errors for the form.
209 | * @return the errors for the form mapped by field name
210 | */
211 | public Map<String, String> errors() {
212 | return this.errors;
213 | }
214 |
215 | /**
216 | * Returns the error for the given field name.
217 | * @param key the field name to get the error for
218 | * @return the error for the given field name or null if there is no error
219 | */
220 | public String errorFor(String key) {
221 | if (errors == null || errors.get(key) == null || touched == null || !touched.contains(key) || valid()) {
222 | return null;
223 | }
224 | return this.errors.get(key);
225 | }
226 |
227 | /**
228 | * Returns the latest model for the form with the form data bound to it.
229 | * @return the latest model for the form as type T
230 | */
231 | public T model() {
232 | return this.model;
233 | }
234 |
235 | /**
236 | * Returns the changes for the form, that is, the fields that have changed
237 | * since it was initialized and their current values.
238 | * @return the changes for the form mapped by field name
239 | */
240 | public Map<String, Object> changes() {
241 | return this.changes.asMap();
242 | }
243 |
244 | /**
245 | * Returns the values for the form, that is, the last set of values that were
246 | * passed to the form.
247 | * @return the {@link Values} for the form
248 | */
249 | public Values data() {
250 | return this.values;
251 | }
252 |
253 | /**
254 | * Returns whether or not the form is "valid". A form is valid if there has been an update
255 | * with an non-null or empty action and there are no errors on any of the fields that have been
256 | * touched (i.e. attempted to be changed) since the last update.
257 | * @return true if the form is valid, false otherwise
258 | */
259 | public boolean valid() {
260 | // no action or empty errors means is always valid
261 | if (Strings.isNullOrEmpty(action) || errors().isEmpty() || touched.isEmpty()) {
262 | return true;
263 | }
264 | // if nothing was touched the changeset is valid
265 | // regardless of whether or not there are errors
266 | // otherwise, only check for errors on touched fields
267 | // and return false if there are any errors
268 | for (String k : touched) {
269 | if (errors().containsKey(k)) {
270 | return false;
271 | }
272 | }
273 | return true;
274 | }
275 | }
276 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/handle/http/RequestAdaptor.java:
--------------------------------------------------------------------------------
1 | package run.undead.handle.http;
2 |
3 | import java.util.Map;
4 |
5 | /**
6 | * RequestAdaptor is an interface for adapting the HTTP request from a server
7 | * framework to the Undead render lifecycle. This normalizes the HTTP request
8 | * so that the Undead render lifecycle can be used with any server framework that
9 | * can adapt its request to this interface.
10 | */
11 | public interface RequestAdaptor {
12 |
13 | /**
14 | * The session data from the HTTP request
15 | * @return a Map of session data
16 | */
17 | Map sessionData();
18 |
19 | /**
20 | * The URL of the HTTP request
21 | * @return the URL
22 | */
23 | String url();
24 |
25 | /**
26 | * The path of the HTTP request
27 | * @return the path
28 | */
29 | String path();
30 |
31 | /**
32 | * The path parameters of the HTTP request
33 | * @return a Map of path parameters
34 | */
35 | Map pathParams();
36 |
37 | /**
38 | * The query parameters of the HTTP request
39 | * @return a Map of query parameters
40 | */
41 | Map queryParams();
42 |
43 | /**
44 | * A callback to deliver redirect URLs to the server framework
45 | * @param destURL
46 | */
47 | void willRedirect(String destURL);
48 | }
49 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/JavalinRequestAdaptor.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin;
2 |
3 | import run.undead.handle.http.RequestAdaptor;
4 | import io.javalin.http.Context;
5 |
6 | import java.util.List;
7 | import java.util.Map;
8 |
9 | /**
10 | * JavalinRequestAdaptor is an implementation of {@link RequestAdaptor} for Javalin
11 | * HTTP requests.
12 | */
13 | public class JavalinRequestAdaptor implements RequestAdaptor {
14 | private final Context ctx;
15 | private String redirectURL;
16 |
17 | public JavalinRequestAdaptor(Context ctx) {
18 | this.ctx = ctx;
19 | }
20 |
21 | @Override
22 | public Map<String, Object> sessionData() {
23 | return this.ctx.sessionAttributeMap();
24 | }
25 |
26 | @Override
27 | public String url() {
28 | return this.ctx.url();
29 | }
30 |
31 | @Override
32 | public String path() {
33 | return this.ctx.path();
34 | }
35 |
36 | @Override
37 | public Map<String, String> pathParams() {
38 | return ctx.pathParamMap();
39 | }
40 |
41 | @Override
42 | public Map<String, List<String>> queryParams() {
43 | return ctx.queryParamMap();
44 | }
45 |
46 | @Override
47 | public void willRedirect(String destURL) {
48 | this.redirectURL = destURL;
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/JavalinRouteMatcher.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin;
2 |
3 | import run.undead.view.RouteMatcher;
4 | import run.undead.view.View;
5 | import io.javalin.config.RoutingConfig;
6 | import io.javalin.routing.PathParser;
7 |
8 | import java.util.LinkedHashMap;
9 | import java.util.Map;
10 |
11 | /**
12 | * JavalinRouteMatcher is an implementation of {@link RouteMatcher} for Javalin.
13 | */
14 | public class JavalinRouteMatcher implements RouteMatcher {
15 | private final RoutingConfig routingConfig;
16 | private final Map<String, Class> routeRegistry;
17 |
18 | /**
19 | * JavalinRouteMatcher creates a new JavalinRouteMatcher with the given {@link RoutingConfig}
20 | * for the Javalin server.
21 | * @param routingConfig the {@link RoutingConfig} for the Javalin server
22 | */
23 | public JavalinRouteMatcher(RoutingConfig routingConfig) {
24 | this.routingConfig = routingConfig;
25 | this.routeRegistry = new LinkedHashMap(); // order matters
26 | }
27 |
28 | @Override
29 | public Map pathParams(String path) {
30 | // first find the matching path regex in the routeRegistry
31 | String pathRegex = null;
32 | for (var entry : this.routeRegistry.entrySet()) {
33 | var parser = new PathParser(entry.getKey(), this.routingConfig);
34 | if (parser.matches(path)) {
35 | pathRegex = entry.getKey();
36 | break;
37 | }
38 | }
39 | if (pathRegex == null) {
40 | throw new RuntimeException("unable to find matching path regex for path:" + path);
41 | }
42 | // now extract the path params
43 | var parser = new PathParser(pathRegex, this.routingConfig);
44 | return parser.extractPathParams(path);
45 | }
46 |
47 | @Override
48 | public View matches(String path) {
49 | // iterate through map keys trying to find a match using PathParser
50 | for (var entry : this.routeRegistry.entrySet()) {
51 | var parser = new PathParser(entry.getKey(), this.routingConfig);
52 | if (parser.matches(path)) {
53 | try {
54 | return (View) entry.getValue().newInstance();
55 | } catch (Exception e) {
56 | throw new RuntimeException(e);
57 | }
58 | }
59 | }
60 | return null;
61 | }
62 |
63 | @Override
64 | public void addRoute(String pathRegex, View view) {
65 | this.routeRegistry.put(pathRegex, view.getClass());
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/JavalinWsAdaptor.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin;
2 |
3 | import run.undead.config.Config;
4 | import run.undead.context.WsHandler;
5 | import io.javalin.websocket.WsConfig;
6 | import run.undead.view.View;
7 |
8 | import java.time.Duration;
9 | import java.time.temporal.ChronoUnit;
10 | import java.util.Map;
11 | import java.util.concurrent.ConcurrentHashMap;
12 |
13 | /**
14 | * JavalinWsAdaptor connects Javalin websockets to the Undead {@link WsHandler} which
15 | * handles the websocket lifecycle of the Undead {@link View}.
16 | */
17 | public class JavalinWsAdaptor {
18 |
19 | private final Map<String, WsHandler> handlerRegistry = new ConcurrentHashMap<>();
20 | private final Config undeadConf;
21 |
22 | public JavalinWsAdaptor(Config undeadConf, WsConfig wsConfig) {
23 | this.undeadConf = undeadConf;
24 | wsConfig.onConnect(ctx -> {
25 | // client sends heartbeat every 30 seconds which is the default idleTimeout,
26 | // therefore we need to extend default idle timeout to longer
27 | ctx.session.setIdleTimeout(Duration.of(45, ChronoUnit.SECONDS));
28 | });
29 | wsConfig.onError(ctx -> {
30 | var handler = getHandler(ctx.getSessionId());
31 | if(handler == null) {
32 | return;
33 | }
34 | handler.setWsSender(new JavalinWsSender(ctx));
35 | // give socket a chance to handle error
36 | handler.handleError(ctx.error());
37 | clearHandler(ctx.getSessionId());
38 | });
39 | wsConfig.onClose(ctx -> {
40 | var handler = getHandler(ctx.getSessionId());
41 | if(handler == null) {
42 | return;
43 | }
44 | // give socket a chance to handle close / cleanup
45 | handler.handleClose();
46 | clearHandler(ctx.getSessionId());
47 | });
48 | wsConfig.onMessage(ctx -> {
49 | if(undeadConf.debug != null) {
50 | undeadConf.debug.accept("Raw ws message: " + ctx.message());
51 | }
52 | var handler = getOrCreateHandler(ctx.getSessionId());
53 | handler.setWsSender(new JavalinWsSender(ctx));
54 | handler.handleMessage(ctx.message());
55 | });
56 | }
57 |
58 | private WsHandler getHandler(String sessionId) {
59 | return handlerRegistry.get(sessionId);
60 | }
61 |
62 | private WsHandler getOrCreateHandler(String sessionId) {
63 | return handlerRegistry.computeIfAbsent(sessionId, k -> new WsHandler(undeadConf));
64 | }
65 |
66 | private void clearHandler(String sessionId) {
67 | handlerRegistry.remove(sessionId);
68 | }
69 |
70 | }
71 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/JavalinWsSender.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin;
2 |
3 | import run.undead.context.WsSender;
4 | import io.javalin.websocket.WsContext;
5 |
6 | /**
7 | * JavalinWsSender is an implementation of {@link WsSender} for Javalin websockets.
8 | */
9 | public class JavalinWsSender implements WsSender {
10 | private final WsContext ws;
11 |
12 | public JavalinWsSender(WsContext ws) {
13 | this.ws = ws;
14 | }
15 |
16 | @Override
17 | public void send(String data) {
18 | ws.send(data);
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/UndeadHandler.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin;
2 |
3 | import run.undead.config.Config;
4 | import run.undead.context.HttpHandler;
5 | import run.undead.template.PageTitle;
6 | import run.undead.view.View;
7 | import io.javalin.http.Context;
8 | import io.javalin.http.Handler;
9 | import org.jetbrains.annotations.NotNull;
10 |
11 | /**
12 | * A Javalin {@link Handler} that handles the HTTP request lifecycle of Undead {@link View}s
13 | */
14 | public class UndeadHandler implements Handler {
15 | private final Config config;
16 | private final View view;
17 | private PageTitle pageTitle;
18 |
19 | /**
20 | * Constructs a new {@link UndeadHandler} with the given {@link Config} and {@link View}.
21 | * @param config the {@link Config} to use
22 | * @param view the {@link View} to render
23 | */
24 | public UndeadHandler(Config config, View view) {
25 | this.config = config;
26 | this.view = view;
27 | this.pageTitle = new PageTitle();
28 | }
29 |
30 | public View view() {
31 | return this.view;
32 | }
33 |
34 | public UndeadHandler withPageTitleConfig(PageTitle config) {
35 | this.pageTitle = config;
36 | return this;
37 | }
38 |
39 | @Override
40 | public void handle(@NotNull Context ctx) throws Exception {
41 | var res = HttpHandler.handle(
42 | this.view.getClass().newInstance(),
43 | this.config.mainLayout,
44 | new JavalinRequestAdaptor(ctx),
45 | this.pageTitle,
46 | this.config.wrapperTemplate
47 | );
48 | ctx.contentType("text/html");
49 | ctx.result(res);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/main/java/run/undead/javalin/example/Server.java:
--------------------------------------------------------------------------------
1 | package run.undead.javalin.example;
2 |
3 | import io.javalin.Javalin;
4 | import io.javalin.http.staticfiles.Location;
5 | import run.undead.config.Config;
6 | import run.undead.javalin.example.view.UndeadCounter;
7 | import run.undead.javalin.example.view.UndeadSalesDashboard;
8 | import run.undead.javalin.example.view.UndeadUserForm;
9 | import run.undead.javalin.example.view.UndeadVolumeControl;
10 | import run.undead.javalin.example.view.tags.ExCard;
11 |
12 | import java.util.List;
13 |
14 | import static run.undead.template.Directive.For;
15 | import static run.undead.template.Undead.HTML;
16 |
17 | /**
18 | * Server is a simple Javalin server that uses Undead to render rich, dynamic views.
19 | */
20 | public class Server {
21 | public static void main(String[] args) {
22 |
23 | var undeadConf = new Config();
24 | var app = new UndeadJavalin(Javalin.create(config ->
25 | // register static file locations for the Undead client javascript
26 | config.staticFiles.add(staticFileConfig -> {
27 | staticFileConfig.directory = "/public/js";
28 | staticFileConfig.location = Location.CLASSPATH;
29 | staticFileConfig.hostedPath = "/js";
30 | })
31 | ), undeadConf)
32 | // use the UndeadJavalin instance to register Undead Views to routes
33 | .undead("/count", new UndeadCounter())
34 | .undead("/count/{start}", new UndeadCounter())
35 | .undead("/dashboard", new UndeadSalesDashboard())
36 | .undead("/user/new", new UndeadUserForm())
37 | .undead("/volume", new UndeadVolumeControl())
38 | .javalin() // get the underlying Javalin instance from UndeadJavalin
39 | .get("/", ctx -> {
40 |
41 | var examples = List.of(
42 | new ExCard("Counter", "A simple counter that can be incremented and decremented.", "/count"),
43 | new ExCard("Sales Dashboard", "A sales dashboard that shows sales data in a chart.", "/dashboard"),
44 | new ExCard("User Form", "A user form that shows how easy it is to use forms.", "/user/new"),
45 | new ExCard("Volume Control", "A Kotlin-based volume control that shows how to use a keyboard input.", "/volume")
46 | );
47 | var html = HTML."""
48 | <!DOCTYPE html>
49 | <html lang="en">
50 | <head>
51 | <meta charset="utf-8" />
52 | <meta http-equiv="X-UA-Compatible" content="IE=edge" />
53 | <meta name="viewport" content="width=device-width, initial-scale=1.0" />
54 | <title>Undead Examples
55 |
56 |
57 |
58 |
59 |
60 |
63 |
64 | \{ For(examples, ex -> ex.render()) }
65 |
66 |
67 |