		@@ -6,3 +6,3 @@ //Parse standard server command line parameters
		const DefConfig = {
		webPort: 4000,
		uiPort: 4000,
		clifPort: 4100,
		@@ -19,3 +19,3 @@ clifNP: 4200,
		, yargs = require('yargs')
		.alias('e','webPort') .default('webPort', d.webPort) //Serve client SPA's at this port
		.alias('e','uiPort') .default('uiPort', d.uiPort) //Serve client SPA's at this port
		.alias('i','clifPort') .default('clifPort', d.clifPort) //Websocket port to control layer interface
		@@ -22,0 +22,0 @@ .alias('q','clifNP') .default('clifNP', d.clifNP) //Noise-protocol port for control layer interface

lib/dispatch.js

		//Dispatch action and report interactions to the appropriate service function
		//Copyright WyattERP.org; See license in root of this package
		// -----------------------------------------------------------------------------
		//TODO:
		//- Make sure each instance is garbage collected upon user connection closing (test)
		//- Make a better connCode that can't collide or be guessed
		//-
		const StringHash = require('string-hash')
		const { Language } = require('wyseman')
		var connectionCount = 0
		@@ -36,4 +41,4 @@
		this.handle = function(msg, sender) { //Process action request coming from UI client
		let {id, action, view, name, data} = msg
		log.debug("Got user request:", id, view, name, action, data)
		let {id, action, view, name, data, language} = msg
		log.debug("Got user request:", id, language, view, name, action, data, 'opt:', JSON.stringify(data.options))
		if (action != 'action' \|\| !(view in actions) \|\| !(name in actions[view])) return false
		@@ -43,8 +48,25 @@ let actList = actions[view] //Look up the specs for this action
		, reportCache = this.reportList[id]
		, lang = { //For querying language tags
		view: (...args) => Language.view(language, ...args),
		message: (...args) => Language.message(language, view, ...args)
		}

		//log.debug("L:", Language.messages(language, view))
		if (!controlFunc) return false //No report found, so abort
		if (!reportCache) {
		if (reportCache) {
		reportCache.data = data //Freshen options, keys from latest request
		} else {
		let idHash = StringHash(id)
		, resPath = this.path + '/' + idHash
		reportCache = {view, name, data, controlFunc, idHash, db:this.db, path:this.path, resPath}
		reportCache = {
		view,
		name,
		data,
		controlFunc,
		idHash,
		lang,
		resPath,
		db: this.db,
		path: this.path
		}
		}
		@@ -54,3 +76,3 @@
		if (controlFunc(reportCache, (error, data)=>{ //Generate the report
		log.debug(' report generated:', error, 'data:', data)
		log.trace(' report generated:', error, 'data:', data)
		// Object.assign(data, {path:this.path, file:ViewerFile})
		@@ -57,0 +79,0 @@ sender({id, view, action, name, data, error}) //And return it

lib/spaserver.js

		@@ -13,3 +13,3 @@ //Launch http service to serve applications to the browser
		const DefConfig = {
		webPort: 4000,
		uiPort: 4000,
		expApp: Express(),
		@@ -24,6 +24,6 @@ pubDir: Path.join(__dirname, '..', 'pub'),
		let d = Object.assign({}, DefConfig, config)
		log.trace("SPA Server:", d.webPort, d.pubDir, d.wyclif)
		log.trace("SPA Server:", d.uiPort, d.pubDir, d.wyclif)
		this.expApp = d.expApp

		if (Boolean(d.webPort)) {
		if (Boolean(d.uiPort)) {
		this.server = d.credentials ? Https.createServer(d.credentials, d.expApp) : Http.createServer(d.expApp)
		@@ -48,4 +48,4 @@
		})
		this.server.listen(d.webPort)
		//log.debug("Serving client SPAs at port:", d.webPort)
		this.server.listen(d.uiPort)
		//log.debug("Serving client SPAs at port:", d.uiPort)
		} //if
		@@ -52,0 +52,0 @@ } //constructor

package.json

		{
		"name": "wyclif",
		"version": "1.0.17",
		"version": "1.0.18",
		"description": "WyattERP Control Layer InterFace",
		@@ -5,0 +5,0 @@ "main": "lib/index.js",

README.md

		## Wyclif: WyattERP Component Layer InterFace server

		WyattERP consists of a set of tools for building Enterprise Resource Planning
		software. This just means tools for running your business like accounting,
		software. This just means tools for running a business like accounting,
		contact management, billing, payroll and so forth.

		The idea behind WyattERP is to be able to generate applications very quickly
		by just defining your operating parameters in a data dictionary. Then the apps
		The intent is to be able to generate applications quickly by defining
		operating parameters in a data dictionary. Then applications can
		essentially build themselves on the fly as users configure their screen to
		access the various tables and views you have defined.

		WyCLIf is the Control Layer Interface. This means it is a server process where
		the front end, or GUI interacts. It also contains a https server to deliver
		the application itself (Single Page Application, or SPI) to the user's browser.
		Then, that SPI connects via a web socket on a different port (and possibly a
		different server) to interact with the control and model layers.
		WyCLIf implements the Control Layer Interface. This means it is a server-side
		process through which the front end, or GUI interacts. It also contains a https
		server to deliver the application itself (Single Page Application, or SPA) to the
		user's browser. Then, that SPA connects via a web socket on a different port
		(and possibly a different server) to interact with the control and model layers.

		This is an example server. In an actual production deployment, your ERP may
		This is an example server. In an actual production deployment, your ERP may be
		a custom server that does more than this one. But your server can call the
		functionality of this basic template, and then add the additional services on.
		functionality of this basic template, and then add additional services.

		## WyattERP Components:
		### WyattERP Components

		Wylib:
		- UI components, implemented in Vue.js
		- Browser UI components, implemented in Vue.js
		- JS modules to support the UI
		@@ -31,8 +31,9 @@ - UI portal to Wyseman socket to access data dictionary and control layer
		- CLI: Schema authoring and deployment, schema version control
		- Socket handler: query builder, action launcher
		- Report lookup if a dispatcher and lookup table is provided
		- User connection handler: query builder, action launcher
		- Provides API for user applications whether web or mobile
		- Calls Wyclif dispatcher for actions not defined in the database

		Wyselib:
		- Chunks of schema and data dictionary definitions
		- Macros and support functions for building the schema
		- Macros and support functions for building schemas
		- Typically a subset of your eventual complete site schema
		@@ -42,8 +43,31 @@ - gnucash importer to run with the reference schema
		Wyclif:
		- SPI server: Can also be invoked from your production server
		- Includes /clientinfo ajax server needed for authorization/login
		- SPA server: Can also be invoked from your production server
		- Includes /clientinfo server consulted during authorization/login
		- Server support routines, can be called independently
		- Report dispatcher for associated actions described in data dictionary
		- Report dispatcher for custom actions and reports
		- report-bundle
		- wysegi-bundle
		- wyatt-bundle: generic ERP app, gnucash replacement
		- wyatt-bundle: generic ERP app (not yet implemented)

		### Control Layer Function
		A user interface connects to the control layer via websocket to the
		Wyseman module. Much of the API is sipmly SQL commands encoded into
		a JSON structure. For such commands, Wyseman simply decodes the SQL,
		builds a query and sends it to the database. Results are returned to
		the user process marked with the same unique identifier the application
		sent with the originating query.

		In addition to regular SQL queries, the user process can send actions.
		An action invokes a report or function implemented in the control layer.
		It is much like a query, except it can do much more complex things.
		For example, it might build a PDF report or set up a live html page
		the user can interact with. It can really do anything or return anything
		the app may be prepared to deal with.

		Because Wyselib may supply certain basic parts of a schema, it may also
		supply certain action handlers. A production ERP system will likely
		also have a number of action handlers it will supply. All these
		handlers get registered into a structure and supplied to a dispatcher.
		When actions come from the UI, the dispatcher can look them up and
		determine which function is responsible for handling the requested
		action.

pki/README