jsgui3-server 0.0.82 → 0.0.85

package/publishing/http-publisher.js

@@ -0,0 +1,52 @@
+const { Publisher } = require('jsgui3-html');
+
+// Could have this as the general purpose HTTP publishing component / system / part of the system.
+
+
+
+// Some kind of mapping between what the response asks for and the functions to get the results along with the parameters to call them with.
+
+
+
+class HTTP_Publisher extends Publisher {
+    constructor(spec) {
+        super(spec)
+
+        /*
+        this.handle_http = (req, res) => {
+            
+            
+
+        }
+        */
+    }
+    handle_http(req, res) {
+        console.trace();
+        throw 'HTTP_Publisher: Use handle_http of subclass.';
+        // Determine input content type (if any)
+        // Headers, auth
+        //  Then get more of a programmatic model of what it requires to be done.
+        // 
+
+
+        // Use the app router to determine where the request is to go.
+
+        const do_response = () => {
+            res.writeHead(200, {
+                //'Content-Type': 'text/event-stream',
+                'Transfer-Encoding': 'chunked',
+                //'Trailer': 'Content-MD5'
+            });
+            res.write('OK\n');
+            let obs2_handler = data => {
+                //console.log('data', data);
+                let s_data = JSON.stringify(data);
+                //res.write(s_data + '\n');
+                res.write('event: message\ndata:' + s_data + '\n\n');
+            }
+            obs2.on('next', obs2_handler);
+        }
+    }
+}
+
+module.exports = HTTP_Publisher;

package/publishing/{resource-publisher.js → http-resource-publisher.js}

@@ -12,11 +12,30 @@ const multiparty = require('multiparty');
 // More observable systems?
 //  Making use of ofp could be very useful in various cases.
 //  mfp in some parts first?
+const HTTP_Publisher = require('./http-publisher');
 
 
+// For publishing a resource, implying resources don't themselves need http handling.
+
+// maybe a handle-http js file may help that will do things in a rather general purpose way?
+//  But it more seems as though we need to set the routing. Then we could assign such handlers from the router.
+
+// Possibly there should be a Website_Router Resource?
+//  Or a resource wrapper.
+
+
+
+
+// Could extend a JSON_Publisher. Resource_JSON_Publisher possibly.
+class Resource_Publisher extends HTTP_Publisher {
+
+    // Make this able to publish any resource?
+    //  But I don't think this is going to publish a Website Resource as a Website.
+    //  There is now the specialised HTTP_Website_Publisher.
+
 
-class Resource_Publisher {
     constructor(spec) {
+        super(spec);
         this.resource = spec.resource;
         // Don't make a new server interface by default.
         this.name = spec.name;

package/publishing/http-webpage-publisher.js

@@ -0,0 +1,112 @@
+
+
+// A publisher handles HTTP requests.
+
+// This is going to take over some of the responsibilities of the old website resource, which was unfocused code that was
+//  doing some of the main / most important parts of serving the website.
+
+
+const HTTP_Publisher = require('./http-publisher');
+const {obs} = require('fnl');
+
+// Named observables?
+/*
+
+obs((next, complete, error) => {
+
+*/
+
+
+// HTTP_Webpage_Publisher could be interesting.
+//  The Website Publisher could make use of some of its functionality.
+
+// Handling HTTP / bundling for a specific page could be cool.
+
+// A Webpage Publisher may be simpler and better to work on in the short term.
+//  Maybe would not need to be (as) concerned with routing.
+//  Could be useful for publishing a SPA of course, kind of a website but as a single page.
+
+// Should have more concerning bundling / compilation.
+
+
+// There could be 'bundle' functionality for the webpage.
+
+// The webpage itself could know what client js it needs to use.
+
+// Seems like bundling a specified webpage earlier on in the process makes sense.
+
+// And a Bundler as well?
+//  Perhaps HTTP_Webpage_Bundler would be an important class to have here.
+//   Considering how it could be interchangable from the publisher if it's a different class.
+
+
+
+class HTTP_Webpage_Publisher extends HTTP_Publisher {
+
+    // Website generally serves JS from a single address.
+    //  Webpage could have its specific JS.
+
+    constructor(spec = {}) {
+        super(spec)
+
+        // A website property.
+
+        let webpage;
+        if (spec.webpage) webpage = spec.webpage;
+        Object.defineProperty(this, 'webpage', {
+            get() {
+                return webpage;
+            }
+        });
+
+        // Probably best to come up with a bundle here, or at an early stage.
+
+        // .prepare_bundle?
+
+        // .prepare_bundle would be a good function to have here.
+
+
+
+        // .bundle?
+        //   seems clearest that we will be getting / preparing multiple files.
+
+        // Bundling and compiling web content seems like a better thing to get working before serving (or attempting to serve) it.
+        // .build?
+
+    }
+    handle_http(req, res) {
+
+
+        // returning an observable would make sense.
+        //  so other parts of the server could observe the request being processed.
+
+
+
+
+        // This may be quite concerned with ensuring the bundle before handling any http requests to provide it or parts of it.
+        //  Could even unit test before running deployed code.
+
+        // Could get info on what needs to be bundled from the webpage object itself.
+        //  A Webpage objects could have 'requirements', or 'build requirements'.
+
+
+
+
+
+
+
+
+
+        console.log('HTTP_Webpage_Publisher handle_http');
+        //console.log('req', req);
+
+
+        // May have bundle already prepared anyway.
+        //  Possibly the Website or the Website_Resource could do the bundling / building.
+        //  Could even bundle into a ZIP file :)
+
+        throw 'NYI';
+    }
+}
+
+module.exports = HTTP_Webpage_Publisher;

package/publishing/http-website-publisher.js

@@ -0,0 +1,271 @@
+
+
+// A publisher handles HTTP requests.
+
+// This is going to take over some of the responsibilities of the old website resource, which was unfocused code that was
+//  doing some of the main / most important parts of serving the website.
+
+const {each, Router} = require('jsgui3-html');
+const HTTP_Publisher = require('./http-publisher');
+const {obs} = require('fnl');
+
+
+const Webpage_Bundler = require('./../bundler/webpage-bundler');
+
+
+// Now it's the very basics of a website publisher. Quite flexible but could do with more.
+//  Better integration with bundler
+//  Rendering webpages that are dynamic and therefore not bundled (eg user specific content).
+//   Though the js could be bundled. Maybe some of the controls could be bundled? Or semi-bundled?
+
+
+
+// HTTP_Webpage_Publisher could be interesting.
+//  The Website Publisher could make use of some of its functionality.
+
+
+// Handling HTTP / bundling for a specific page could be cool.
+
+// A Webpage Publisher may be simpler and better to work on in the short term.
+//  Maybe would not need to be (as) concerned with routing.
+//  Could be useful for publishing a SPA of course, kind of a website but as a single page.
+
+// This seems more like the server router these days
+//  The main server router seems to pass everything to this - maybe that will change.
+
+class HTTP_Website_Publisher extends HTTP_Publisher {
+
+    // Website generally serves JS from a single address.
+    //  Webpage could have its specific JS.
+
+    constructor(spec = {}) {
+        super(spec)
+        // A website property.
+
+        let website;
+        if (spec.website) website = spec.website;
+        Object.defineProperty(this, 'website', {
+            get() {
+                return website;
+            }
+        });
+
+        let router = new Router();
+        Object.defineProperty(this, 'router', {
+            get() {
+                return router;
+            }
+        });
+
+        let disk_path_client_js;
+        if (spec.disk_path_client_js) disk_path_client_js = spec.disk_path_client_js;
+        Object.defineProperty(this, 'disk_path_client_js', {
+            get() {
+                return disk_path_client_js;
+            }
+        });
+
+        // And this could be an observable too.
+
+        // May get admin pages working on a slightly lower level.
+        //  Makes sense as they are for administering other pages (mostly).
+
+        console.log('http-website-publisher disk_path_client_js', disk_path_client_js);
+        //throw 'stop';
+
+        // This could be an observable that acts sequentially and async.
+
+        const setup_website_publishing = (website) => {
+
+            return obs(async(next, complete, error) => {
+
+                for (const page in website.pages) {
+
+                    const opts_bundling = {};
+                    if (disk_path_client_js) opts_bundling.disk_path_client_js = disk_path_client_js;
+    
+                    const obs_bundling = await Webpage_Bundler.bundle_web_page(page, opts_bundling);
+                    //console.log('doing bundling');
+                    console.log('obs_bundling', obs_bundling);
+
+                    throw 'stop';
+    
+
+                    const old = () => {
+                        obs_bundling.on('complete', res => {
+                            //console.log('obs_bundling res', res);
+                            const bundle = res;
+                            //console.log('bundle._arr.length', bundle._arr.length);
+                            //console.log('Object.keys(bundle)', Object.keys(bundle));
+        
+                            if (bundle._arr.length === 1) {
+                                // And check it's HTML inside...?
+        
+                                const bundled_item = bundle._arr[0];
+                                //console.log('bundled_item', bundled_item);
+        
+                                if (bundled_item['content-type']) {
+                                    const ct = bundled_item['content-type'];
+                                    if (ct === 'text/html') {
+                                        const http_serve_html = (req, res) => {
+                                            res.writeHead(200, {
+                                                'Content-Type': 'text/html'
+                                            });
+                                            res.end(bundled_item.value, 'utf-8');
+                                        }
+                                        router.set_route(bundled_item.path, (req, res) => {
+                                            http_serve_html(req, res);
+                                        });
+                                    } else {
+                                        throw 'NYI';
+                                    }
+        
+                                } else {
+                                    throw 'NYI';
+                                }
+        
+                                // need to create / use the handler for it here.
+                                //  will have various http handler functions to reference and use.
+                                //  will have details of http handling in other files.
+        
+                                // Maybe use an HTML publisher for this? (if it's HTML).
+                                //  Or publisher by mime type (lookup).
+        
+                                // create http handler function....
+        
+                                
+        
+                            } else {
+        
+                                // Multiple items at multiple paths....
+        
+                                each(bundle, item => {
+                                    //console.log('item', item);
+                                    //console.log('item.path', item.path, item['content-type']);
+        
+                                    if (item['content-type']) {
+                                        const ct = item['content-type'];
+                                        if (ct === 'text/html') {
+                                            const http_serve_html = (req, res) => {
+                                                res.writeHead(200, {
+                                                    'Content-Type': 'text/html'
+                                                });
+                                                res.end(item.value, 'utf-8');
+                                            }
+                                            router.set_route(item.path, (req, res) => {
+                                                http_serve_html(req, res);
+                                            });
+                                        } else {
+                                            const http_serve_any = (req, res) => {
+                                                res.writeHead(200, {
+                                                    'Content-Type': ct
+                                                });
+                                                res.end(item.value, 'utf-8');
+                                            }
+                                            router.set_route(item.path, (req, res) => {
+                                                http_serve_any(req, res);
+                                            });
+        
+                                            //throw 'NYI';
+                                        }
+            
+                                    } else {
+                                        throw 'NYI';
+                                    }
+        
+                                })
+        
+                                //console.trace();
+                                //throw 'NYI';
+                            }
+                        })
+                    }
+
+                    
+
+
+
+
+                    //console.log(`${property}: ${object[property]}`);
+                }
+
+
+            });
+            // put pages into a router here...
+            //  however, may need to be on the lookout for other content that needs to be bundled with each page in the site.
+
+            // Now let's try bundling an active JS client.
+            // May need to compile / render JSGUI Controls to HTML / full HTML pages.
+
+            // And unspecified pages such as admin pages?
+
+            
+            //throw 'NYI';
+        }
+        if (website) {
+            setup_website_publishing(website);
+        } else {
+            this.raise('ready');
+        }
+
+        // Create a router for the website if it does not already have one.
+        //  Or maybe not....
+
+        // Do we already know all of the pages in the website?
+        //  Maybe there are dynamic pages.
+
+        // Probably best to come up with a bundle here, or at an early stage.
+
+        // .prepare_bundle?
+
+        // .bundle?
+        //   seems clearest that we will be getting / preparing multiple files.
+
+        // Bundling and compiling web content seems like a better thing to get working before serving (or attempting to serve) it.
+        // .build?
+
+    }
+    handle_http(req, res) {
+
+        // Called from a different context? Doubt we want that.
+        // Now called strangely, without context.
+
+        const {website, router} = this;
+
+        //console.log('HTTP_Website_Publisher handle_http');
+        //console.log('Object.keys(req)', Object.keys(req));
+        //console.log('Object.keys(req.headers)', Object.keys(req.headers));
+
+        const {url, method, statusCode, httpVersion} = req;
+        const accept_encoding = req.headers['accept-encoding'];
+        const {host} = req.headers;
+
+        //console.log('[httpVersion, host, url, statusCode, method, accept_endoding]', [httpVersion, host, url, statusCode, method, accept_encoding]);
+
+
+        //console.log('router', router);
+        //console.log('this.router', this.router);
+        //console.log('this', this);
+        //console.trace();
+        router.process(req, res);
+
+        // can then get the port from after the : in the host.
+
+        //router.set_route(url,)
+
+
+
+        // But then the website itself, does it have a router?
+        //  It (probably) should.
+
+        // Possibly the publisher has the router for the website.
+
+        // May have bundle already prepared anyway.
+        //  Possibly the Website or the Website_Resource could do the bundling / building.
+        //  Could even bundle into a ZIP file :)
+
+        //throw 'NYI';
+    }
+}
+
+module.exports = HTTP_Website_Publisher;

package/publishing/notes.md

@@ -1,5 +1,6 @@
 Function publishing, and some other sorts of publishing, should maybe be contained in another module / set of modules.
 May need to work without all the HTML and Control things for some applications.
 
+Will have more of an abundance of mid-level HTTP publishing code.
 
 

package/resources/README.md

@@ -0,0 +1,16 @@
+Resources are a way to wrap a thing / process
+For the moment some have handle_http functions
+
+Resources will be more about encapsulation of functionality
+So a resource is a mostly known quality of programmatic unit.
+
+Resources may be wrapped / published in other things.
+
+The Resource class / subclass itself contains and represents some other
+piece of functionality in most cases.
+
+More general purpose, or otherwise specific, non-Resource code
+can then be wrapped in a Resource. In many cases the code in the Resource
+class wraps some other code that does something specific.
+
+