jsgui3-server 0.0.81 → 0.0.84

package/resources/_old_website-resource.js

@@ -0,0 +1,507 @@
+/**
+ * Created by James on 29/07/2014.
+ */
+
+// 2022 - Seems a little uncertain about what it is for, and what it does has grown over time.
+
+
+
+// A Website abstraction and a Website_Publisher seem like a good way forward.
+
+
+// Want to make a near future release have a web publishing system that is easier to use as well as more
+// powerful.
+
+// Publishing static sites, rendering and compiling.
+
+// Represents (and is?) a website itself, and its representation available through the Resource system.
+
+
+// Want to get the core resources working and tested.
+//  Want to run a clock website / service to start with.
+//  The server could have a clock, while clients could connect to it and share the information.
+//  Could also experiment with P2P distribution of the data.
+//  A clock is also useful because it contains time signals so we can see how long it takes for data to reach various machines.
+
+// A web resource in particular?
+// Any need for an HTML resource?
+//  Probably not - have web resource handle HTML and websockets.
+
+// Resources could also have events which objects can listen to.
+//  Programmatic objects can listen.
+//  The resources may broadcast to whatever is listening.
+
+// Also, maintaining one connection stream, communicating with multiple resources - could connect through a Resource Pool, or maybe there
+//  could be a Multi Resource Publisher that publishes a bunch of resources.
+
+// The Application router at the moment sending requests to resources.
+//  I am thinking that rather than doing that, the requests should be handled by a resource publisher that interacts with the resource and publishes it over HTTP.
+
+// Resources in general won't handle HTTP requests, though they will have the capability.
+//  More likely that a resource, when it is served online, will be served using a Resource Publisher (which is itself a resource), which handles HTTP implementation details that would otherwise have
+//  to be repeated between resources.
+
+//define(["./jsgui-lang-util", './abstract-resource'], function(jsgui, AR) {
+
+// Do this not with AMD?
+
+// May need Website_Data_Resource
+//  Would be configured within the node app, client has maximum autoconfig from connecting to the server, and integration with client-side controls.
+//  With the DB admin, it's about returining queries (maybe from RAM) about table data.
+//  /data/then the api?
+
+// Respond to both data HTTP requests and websocket connections.
+
+// HTTP data request -> response seems like the most important step now.
+
+// An fs Resource would be of use for file system browser.
+//  Could have a client-side fs resource that connects to a veriety of services, could have one that connects to the server-side fs resource.
+
+// Need to connect a data-providing resource to the UI component in cases where it's not secure to do so automatically.
+//  It would be much more secure to bring up an NTP provision service automatically than a file system one. Don't want to take that risk now.
+//
+
+// Possibly WebPack could be considered such a resource? Or find a different type for that type of resource?
+
+// Compilation_Resource and Compiler_Resource...
+
+
+// Maybe should do more to represent a website on a server.
+// Maybe it needs more docs, being rather critical.
+
+
+
+
+var Site_Images = require("./website-image-resource");
+
+//console.log('1) Site_Images', Site_Images);
+
+var jsgui = require("jsgui3-html");
+const { each, get_a_sig, is_defined, tof } = jsgui;
+
+//var Web_Resource = require('./website-resource');
+const Resource = jsgui.Resource;
+const Router = jsgui.Router;
+//const Evented_Class = jsgui.Evented_Class;
+
+const Resource_Pool = require("./server-resource-pool");
+//var Resource_Web_Admin = require('../web-admin');
+
+const Site_JavaScript = require("./website-javascript-resource");
+//console.log('1) Site_JavaScript', Site_JavaScript);
+const Site_CSS = require("./website-css-resource");
+const Site_Static_HTML = require("./website-static-html-resource");
+//var DB_Web_Resource = require('../../web/db-resource-postgres');
+//var database_resource_factory = require('../../db/resource/factory');
+
+const Resource_Publisher = require("../publishing/resource-publisher");
+const Observable_Publisher = require("../publishing/observable-publisher");
+const Function_Publisher = require("../publishing/function-publisher");
+//const Data_Resource = require("./data-resource");
+
+// Proxy_Server_Resource possibly.
+//  Note that the client should be able to access a Proxy_Server_Resource if needed.
+//   Could just send request onwards and do same for response.
+//    Buffering rate-limiting proxies too though?
+
+
+//  May help with FirstPoint_Server.
+
+// Could move the publishing parts to Website_Resource_Publisher perhaps.
+
+
+
+// Maybe worth just having a Website object.
+//  Then the Website_Resource can encapsulate that.
+
+// Better if this wraps the Website object?
+
+// A Website has its own Website Resource Pool?
+
+// Make Website_Resource into the wrapper that wraps Website?
+// Or we don't need that, just use HTTP_Website_Publisher.
+
+// A lot of important functionality here though...
+//  Creating the various resources to add to the website resource pool on the server.
+
+// But it's going to be the publishers rather than the resources processing HTTP requests.
+//  Change of architecture.
+
+
+// Maybe won't need the variety of resources.
+//  May be simpler to program for.
+// Will initially be more compilation & bundling oriented
+//  Then will send those pieces of data to the relevant HTTP handlers.
+//  Less wrapped in Resource classes and terminology.
+//  Will be able to publish functionality as Resource should I want to.
+
+
+
+
+
+
+
+class Website_Resource extends Resource {
+  constructor(spec = {}) {
+
+    throw 'Stop - Discontinued - look for alternatives for the moment.';
+
+    super(spec);
+    // A bit of a special resource here because it has its own resource_pool.
+    let resource_pool = new Resource_Pool({
+      name: "Website Resource Pool"
+    });
+    this.resource_pool = resource_pool;
+    let database_spec = spec.database;
+    let web_database_resource;
+
+    if (database_spec) {
+      database_spec.name = database_spec.name || database_spec.database_name;
+      let database_resource = database_resource_factory(database_spec);
+      database_resource.start();
+      // should start automatically when in the pool?
+      //  does the pool need to be told to start?
+      // Though probably don't want to start the resource on initialization.
+      resource_pool.add(database_resource);
+      web_database_resource = new DB_Web_Resource({
+        database: database_resource,
+        meta: {
+          name: "Web DB",
+          pool: resource_pool
+        }
+      });
+    }
+
+    // Quite a generalised interface it seems.
+    if (web_database_resource) {
+      resource_pool.add(web_database_resource);
+    }
+
+    var router = new Router({
+      name: "Site Router"
+    });
+
+    this.router = router;
+
+    var spec_web_admin = {
+      //'web_database': web_database_resource,
+      meta: {
+        name: "Web Admin"
+      }
+      
+    };
+    // Possibly run web admin from within the web resource itself?
+    //  The web admin could use its own website resource.
+
+    //if (web_database_resource) {
+    //  spec_web_admin.web_database = web_database_resource;
+    //}
+
+    var img_resource = new Site_Images({
+      //'meta': {
+      name: "Site Images",
+      pool: resource_pool
+      // }
+    });
+
+    // Seems like site JS is / will use a compilation resource.
+
+    var js_resource = new Site_JavaScript({
+      //'meta': {
+      name: "Site JavaScript",
+      pool: resource_pool
+      //}
+    });
+
+    // Also want a static HTML server.
+    //  Would serve index.html by default I think???
+    //   Probably with the static or simplest settings.
+
+    var static_html_resource;
+
+    if (spec === "static") {
+      static_html_resource = new Site_Static_HTML({
+        //'meta': {
+        name: "Static HTML",
+        pool: resource_pool
+        //}
+      });
+      resource_pool.push(static_html_resource);
+      // Perhaps set it up with the specific files (automatically)?
+      //  Probably with the index.html
+    }
+    var css_resource = new Site_CSS({
+      //'meta': {
+      name: "Site CSS",
+      pool: resource_pool
+      //}
+    });
+
+    js_resource.on('extracted-controls-css', str_extracted_css => {
+      css_resource.serve_str_css('controls.css', str_extracted_css);
+      // Will serve this as controls.css
+      //  Separate HTTP request, will get more CSS for the moment.
+
+    });
+
+
+    // And this can make a few other resources, like the compilation resource.
+    //  Website resource could include compilation resources?
+    //  But maybe they will be included on the server
+    //   May need some processor rationing with compilations taking place.
+
+
+    // javascript and css resources.
+    resource_pool.push(router);
+    resource_pool.push(img_resource);
+    resource_pool.push(js_resource);
+    resource_pool.push(css_resource);
+    //resource_pool.push(data_resource);
+
+    // anything ending in .css as well.
+    //  Routing maybe wouldn't work like that.
+    //router.set_route('*.css', css_resource, css_resource.process);
+
+    router.set_route("css/*", css_resource, css_resource.process);
+    router.set_route("js/*", js_resource, js_resource.process);
+    // As well as this, it could get the JavaScript resource to serve the JavaScript from the app's js directory.
+    js_resource.serve_directory("js");
+    router.set_route("i/*", img_resource, img_resource.process);
+    router.set_route("img/*", img_resource, img_resource.process);
+    router.set_route("imgs/*", img_resource, img_resource.process);
+    router.set_route("images/*", img_resource, img_resource.process);
+    this.map_resource_publishers = this.map_resource_publishers || {};
+    router.set_route("resources/:resource_name/*", this, (req, res) => {
+      let { url, method } = req;
+      let s_url = url.split("/");
+      let resource_short_name = s_url[2];
+      let resource_publisher = this.map_resource_publishers[resource_short_name];
+      if (resource_publisher) {
+        resource_publisher.handle_http(req, res);
+      }
+    });
+    if (!is_defined(spec)) spec = {};
+    this.resource_pool = resource_pool;
+  }
+
+  publishing_get_pub(item) {
+    let pub;
+    if (item instanceof jsgui.Resource) {
+      pub = new Resource_Publisher({
+        resource: item
+      });
+    } else {
+      // if its a function
+      //  return that function call to the response.
+      let t_item = typeof item;
+      if (t_item === "function") {
+        // Function_Call_Publisher
+        // could respec this.
+        // And the Function_Publisher operates through the Publisher API. Not sure what that is right now though.
+
+        pub = new Function_Publisher({
+            fn: item
+        });
+        //this.map_resource_publishers[published_name] = pub;
+        // 
+      } else {
+        if (item.next && item.complete && item.error) {
+          // assuming observable
+          // Observable publisher
+          //  One way sending...
+          //console.log('using Observable_Publisher');
+          pub = new Observable_Publisher({
+              obs: item
+          });
+          // or not a resource publisher, an observable publisher.
+          //this.map_resource_publishers = this.map_resource_publishers || {};
+          //this.map_resource_publishers[published_name] = obs_pub;
+
+          //console.log('2) this', this);
+          //console.log('this.map_resource_publishers', this.map_resource_publishers);
+          //console.trace();
+        } else {
+          console.log("item", item);
+          throw "Unrecognised item type. Possibly node module versions are wrong / have not been linked fully.";
+        }
+      }
+      //if (item instanceof Evented_Class) {
+    }
+    return pub;
+  }
+
+  // publish within resources?
+  publish(published_name, item, schema) {
+    let sig = get_a_sig(arguments),
+      a = arguments,
+      l = a.length;
+    const single = (published_name, item) => {
+      if (item instanceof jsgui.Resource) {
+        let resource_publisher = new Resource_Publisher({
+          resource: item,
+          name: published_name
+        });
+        this.map_resource_publishers[published_name] = resource_publisher;
+
+        item.name = item.name || published_name;
+        // add that resource!
+        //  (to the pool?)
+        //console.log('item', item);
+        this.resource_pool.add(item);
+
+        //console.log('Object.keys(this.map_resource_publishers)', Object.keys(this.map_resource_publishers));
+      } else {
+        // if its a function
+        //  return that function call to the response.
+        let t_item = typeof item;
+        if (t_item === "function") {
+          // Function_Call_Publisher
+          // could respec this.
+
+          // And the Function_Publisher operates through the Publisher API. Not sure what that is right now though.
+          //   directly attaching the resource publishers?
+          let pub = new Function_Publisher({
+              fn: item,
+              schema: schema
+          });
+          this.map_resource_publishers[published_name] = pub;
+          // 
+
+        } else {
+          if (item.next && item.complete && item.error) {
+            let obs_pub = new Observable_Publisher({
+                obs: item,
+                schema: schema
+            });
+            this.map_resource_publishers[published_name] = obs_pub;
+          } else {
+            console.log("item", item);
+            throw "Unrecognised item type. Possibly node module versions are wrong / have not been linked fully.";
+          }
+        }
+        //if (item instanceof Evented_Class) {
+      }
+    };
+
+    if (sig === "[o]") {
+        each(a[0], (v, i) => {
+            single(i, v);
+        })
+    } else {
+
+        single(published_name, item);
+    }
+  }
+
+  get resource_names() {
+    //console.log('this.resource_pool', this.resource_pool);
+    return this.resource_pool.resource_names;
+  }
+
+  get_resource(resource_name) {
+    var resource_pool = this.resource_pool;
+    return resource_pool.get_resource(resource_name);
+  }
+
+  get def_resource_publishers() {
+    const res = {};
+    each(this.map_resource_publishers, (rp, name) => {
+
+        let def = {
+            name: name,
+            type: rp.type
+        }
+        res[name] = def;
+        if (rp.type === 'function') {
+            if (rp.schema) def.schema = rp.schema;
+        }
+    });
+    return res;
+  }
+
+  start(callback) {
+    var resource_pool = this.resource_pool;
+    resource_pool.start(callback);
+  }
+
+  meets_requirements() {
+    // Likely will be part of Status
+
+    //return false;
+
+    return true;
+  }
+
+  // Needs to be able to process HTTP requests. A bit like the Router in that way.
+  process(req, res) {
+    //console.log('website process request req.url', req.url);
+    //throw 'stop';
+
+    var remoteAddress = req.connection.remoteAddress;
+    var router = this.router;
+    var res_process = router.process(req, res);
+
+    // Likely will need to make this more advanced, possibly to suit a spec.
+    //  Website_Resource_Publisher may be the best place to deal with this.
+
+    // Gives it to the router to process.
+    //  Possibly we need a Control_Publisher?
+    //   To publish a Control at an address on the web.
+
+    console.log('Website_Resource !!res_process', !!res_process);
+
+    // Need more HTTP request to response handlers.
+    //  Or just HTTP handlers really.
+    //  They may be best accessed by the router though.
+    //   Make a decent function abstraction for them next time I need an HTTP handler.
+
+
+
+
+
+
+
+
+
+    if (res_process === false) {
+      if (req.url === "/") {
+        // Seems like too much of a special case.
+
+        // Send this to the static HTML processing system.
+
+        /*
+
+        var static_html_resource = this.resource_pool.get_resource(
+          "Static HTML"
+        );
+        //console.log('static_html_resource', static_html_resource);
+        // And lets get the static resource to process it
+        if (static_html_resource) {
+          static_html_resource.process(req, res);
+        }
+        */
+
+        // Show the default page. ???
+
+        //console.log('deprecated functionality');
+        //throw 'stop';
+
+        res.writeHead(404, {
+          "Content-Type": "text/plain"
+        });
+        res.write("404 Not Found\n");
+        res.end();
+
+      } else {
+        // show a 404
+        res.writeHead(404, {
+          "Content-Type": "text/plain"
+        });
+        res.write("404 Not Found\n");
+        res.end();
+      }
+    }
+  }
+}
+
+module.exports = Website_Resource;

package/resources/compile/server-resource-compilation.js

@@ -0,0 +1,41 @@
+
+// Will make use of features already in jsgui to handle / do compilation.
+
+
+// Want compilation to be handled lower level within the jsgui system.
+//  jsgui.compile(code, compilation_options);
+
+// jsgui compiler toolkit could go in lang-tools or even lang-mini.
+//  there is also the jsx compiler, should be similar to call to Babel.
+
+
+// Handling rust => wasm compilation will be nice too.
+// And other languages that compile to WASM, such as C and C++.
+
+// Much of it will require HD space.
+//  Want to wrap that in a convenient interface that could be upgraded to RAM drive,
+//   network RAM drive etc.
+
+// May need to install / verify installation of necessary compilers, eg cargo, gcc.
+
+// And specific compilation / compiler resources?
+//  As resources, the management of their access will be controlled (maybe made available remotely) programatically.
+
+// Want babel, esbuild
+// Also rust.
+// Rust to integrated WASM would be very nice.
+//  Being able to write rust files that seamlessly connect with JS files.
+//   Or even integrating Rust code within a js file....
+//    or xjs?
+
+
+
+
+
+
+
+
+
+
+
+

package/resources/data-resource.js

@@ -1,3 +1,11 @@
+// Change name to HTTP_Resource?
+
+// May be worth doing more on local / remote transformation resources.
+//  Even loading the remote code to run locally where applicable.
+
+
+// HTTP_Resource seems like a better name as it processes an HTTP request.
+
 
 var path = require('path'),
     fs = require('fs'),
@@ -37,6 +45,12 @@ var Collection = jsgui.Collection;
 // Ideally want it like image keys, then options for max size and also quality.
 //  
 
+// Data_HTTP_Resource ?
+
+// Handled with request+response.
+//  What about data that needs to be in page load?
+
+// Maybe assume resources always deal with data?
 
 class Data_Resource extends Resource {
 

package/resources/fs-resource.js

@@ -10,6 +10,8 @@
  Resource, JeSuisXML, Cookies, fs2) {
  */
 
+// A RAM FS may be of use here too. Cross-platform, simple to use.
+
 var libpath = require('path'),
     fs = require('fs'),
     url = require('url'),
@@ -22,7 +24,6 @@ var libpath = require('path'),
     Cookies = require('cookies'),
     fs2 = require('../fs2');
 
-
     /*
 
 var stringify = jsgui.stringify,
@@ -50,12 +51,9 @@ const fnlfs = require('fnlfs');
 // Cloud_FS_Resource
 // SFTP_FS_Resource
 
-
 // Publishing an FS resource would enable a directory browsing app.
 //  File_Tree, and connect to the client-side Data_Resource.
 
-
-
 const {
     is_directory, dir_contents
 } = fnlfs;

package/resources/jsbuilder/babel/deep_iterate/deep_iterate_babel.js

@@ -533,6 +533,9 @@ const deep_iterate_babel_node_$INTERNAL = (babel_node, depth, path, common, call
             } else if (type === 'Super') {
                 return deep_iterate_babel_super_node(babel_node, depth, path, common, callback);
             } else {
+
+                // Need to make this handle a template literal too.
+
                 console.log('');
                 console.log('type', type);
                 console.log('');

package/resources/jsbuilder/test/test_ast_node.js

@@ -9,7 +9,7 @@
 
 // Load a JS file into an OO structure
 
-const JS_File = require('..//JS_File/JS_File');
+const JS_File = require('../JS_File/JS_File');
 //const JS_File_Comprehension = require('../JS_File_Comprehension');
 const path = require('path');
 const fs = require('fs');

package/resources/jsbuilder/test/test_js_file.js

@@ -33,7 +33,7 @@
 
 
 
-const JS_File = require('..//JS_File/JS_File');
+const JS_File = require('../JS_File/JS_File');
 //const JS_File_Comprehension = require('../JS_File_Comprehension');
 const path = require('path');
 const fs = require('fs');
@@ -48,7 +48,7 @@ const test_js_file = () => {
     // stream the file in.
     const lm_path = '../../../../../tools/lang-mini/lang-mini.js'
     const lt_path = '../../../../../tools/lang-tools/lang.js'
-    const fnl_path = '../../../../../tools/fnl/fnl.js'
+    const fnl_path = require.resolve('fnl');
     const filecomp_path = '../JS_File_Comprehension.js';
     const jsfile_path = '../JS_File/JS_File.js';
     const jsbuilder_path = '../JS_Builder.js';

package/resources/jsbuilder/test/test_project.js

@@ -27,6 +27,7 @@ const test_lang_mini_project = () => {
     // Worth working with a lower level part of jsgui, such as lang-mini.
     //  lang-mini itself has an external reference.
     // stream the file in.
+    throw 'STOP';
     const lm_path = '../../../../../tools/lang-mini/lang-mini.js'
     
     //const file_path = '../JS_File.js';

package/resources/notes.txt

@@ -0,0 +1,11 @@
+from jsgui3-html
+
+jsgui.Resource = require('./resource/resource');
+jsgui.Resource_Pool = require('./resource/pool');
+jsgui.Resource.Data_KV = require('./resource/data-kv-resource');
+jsgui.Resource.Data_Transform = require('./resource/data-transform-resource');
+
+
+Want a really simple search & replace type template system for the moment.
+
+Integrating react into the server at various levels would help.

package/resources/server-installed-tools.js

@@ -0,0 +1,29 @@
+
+
+var jsgui = require("jsgui3-html");
+const { each, get_a_sig, is_defined, tof } = jsgui;
+
+//var Web_Resource = require('./website-resource');
+const Resource = jsgui.Resource;
+// Proxy_Server_Resource possibly.
+//  Note that the client should be able to access a Proxy_Server_Resource if needed.
+//   Could just send request onwards and do same for response.
+//    Buffering rate-limiting proxies too though?
+
+
+//  May help with FirstPoint_Server.
+
+// Could move the publishing parts to Website_Resource_Publisher perhaps.
+
+
+
+
+
+
+class Server_Installed_Tools extends Resource {
+  constructor(spec = {}) {
+    super(spec);
+  }
+}
+
+module.exports = Server_Installed_Tools;