figlotech-core v1.0.11
figlotech-core
A simple framework for building micro-apps that serve both as command line tools and as web handlers at the same time, using the exact same code
This is a simple framework based (but not entirely) on the Unix philosophy. The framework consists on writing implementations of FthApp. An FthApp is the concept of a very basic simple application that is able to do its deeds with an argument array, an input stream and an output stream With this skeleton, the same FthApp can be executed both on the command line directly or as a route handler within a WebHost and it should work perfectly fine on both scenarios
To run the WebHost
const fi = require('figlotech-core')
const FthWebHost = fi.FthWebHost
let server = new FthWebHost()
server.autoImport('./app')
server.addStaticHandler('./public')
server.start(3000)
// autoImport will load all FthApps recursively on the given folder and use as handlers or middlewares
// addStaticHandler adds built-in static files middleware and serves given folder as static
To write a basic FthApp
const fi = require('figlotech-core')
const FthApp = fi.FthApp
class MyBasicApp extends FthApp {
constructor() {
super()
}
_main(args) {
this.output.write(`Hi ${args['name']}, how's it going?`)
}
}
FthApp.register(module, MyBasicApp)
// this function both exports this class for require()
// and executes this app if its called directly
If you call it directly with
node ./MyBasicApp.js --name figloalds
this will output
"Hi Figloalds, how's it going?"
If you call it from a webhost with
path.to:3000/MyBasicApp?name=figloalds
this will output the same
"Hi Figloalds, how's it going?"
The In-depth Anatomy of an FthApp
An FthApp represents a simple executable "thing" that doesn't care about the rest of the application, all it cares are it's arguments, it's input stream and it's output stream And the FthApp doesn't even care where these arguments, inputStream and outputStream are coming from, it just does what it does. Dependency Injection is a Work-in-Progress
const FthApp = require('figlotech-core').FthApp
class CsvToJson extends FthApp {
constructor() {
super()
this.acceptMethods = ['POST']
}
get doc() {
return 'Converts a CSV file input to JSON using the first line as headers'
}
get _inputArguments() {
return [
{ long: 'separator', short: 's', help: 'Character separator' }
]
}
_main(args) {
let inputText = this.readInputToString()
let brokenInput = inputText.split('\n')
if(brokenInput && brokenInput.length) {
let separator
let startIndex = 0
if(brokenInput[0].startsWith('sep=')) {
separator = brokenInput[0].substring(4,1)
startIndex = 1
} else {
separator = args['separator'] || ','
}
// could make argument mandatory with
// this.requireArgs(['separator'])
let headers = brokenInput[startIndex].split(separator)
this.output.write('[')
for(let i = startIndex+1; i < brokenInput.length; i++) {
let vals = brokenInput[i].split(separator)
let obj = {}
for(let j = 0; j < headers.length; j++) {
obj[headers[j]] = vals[j]
}
this.output.write(JSON.stringify(obj))
this.output.write(i < brokenInput.length-1 ? ',' : '')
}
this.output.write(']')
this.output.end()
}
}
}
FthApp.register(module, CsvToJson)
/**
USAGES
- POST http://somewhere.to/subfolder/CsvToJson?separator=,
- cat file.csv | node CsvToJson > file.json
- node CsvToJson -f file.csv -o file.json
NOTE
When called via command line, the -f and -o options are automatically added to redirect iostreams to filestreams
FthApp 101:
this.input | An input stream
this.output | An output stream
args (in main) | An object containing the arguments you received.
get _inputArguments | (getter in class) Allows you to specify simple console input arguments, like so:
Eg:
get _inputArguments() {
return [
{ long: 'name', short: 'n', help: 'The name to be gret' }
// Passing --name Figloalds or -n Figloalds will feed args['name']
// The http-get variable name will also be fed into args['name']
]
}
Utils from base class:
sendFile(fileName) | Write the contents of a file to this.output
async tunnelTo(url) | Pipes a HTTP-GET request to this.output
async get(url) | Just suggar syntax for http get request, retv is a stream
async post(url, data) | More suggar syntax, don't mind it
async readInputToString() | Reads this.input and writes it to a string. Retv is said string
async readInputToObject() | Same as the previous one but wrapped in a JSON.parse. retv is an object. Or a bigass error
*/
How can FthApp be executed
1 - By directly executing its javascript file. Eg node ./MyBasicApp.js
- The FthApp basics will execute the _main() function - Args will come from the command line - The input stream is defaulted to stdin, unless -in/--input is specified - The output stream is defaulted to stdout, unless -out/--output is specified 2 - By using this FthApp as a WebHandler in FthWebHost
The WebHost class will call _main() on FthApp
- The args will come from HTTP-GET variables
- The input stream will be set to the Request body
- The output stream will be set to the Response
in conclusion
figlotech-core is a simple framework for building mixed micro-services that can serve as excellent command line tools and http handlers at the same time, changing not a single line of code.