.then(function () {
return fs.exists(testPath)
})
.map(function(p) { return fs.exists(p); }))
.then(path => {
tmpPath = path;
return fsp.exists(tmpPath);
})
.then(function() {
return fs.exists(readmePath);
})
beforeEach(() => fsp.exists('test/tmp/.git/hooks/commit-msg')
.then(exists => {
if(exists) {
return fsp.unlink('test/tmp/.git/hooks/commit-msg');
}
}));
return retry(function () {
return fs.exists(packageDir).then(function (nodeModulesExists) {
expect(nodeModulesExists).to.be.false;
});
});
(() => __awaiter(this, void 0, void 0, function* () {
const electronPrebuiltPath = argv.e ? path.resolve(process.cwd(), argv.e) : electron_locater_1.locateElectronPrebuilt();
let electronPrebuiltVersion = argv.v;
if (!electronPrebuiltVersion) {
try {
if (!electronPrebuiltPath)
throw new Error("electron-prebuilt not found");
const pkgJson = require(path.join(electronPrebuiltPath, 'package.json'));
electronPrebuiltVersion = pkgJson.version;
}
catch (e) {
throw new Error('Unable to find electron-prebuilt\'s version number, either install it or specify an explicit version');
}
}
let rootDirectory = argv.m;
if (!rootDirectory) {
// NB: We assume here that we're going to rebuild the immediate parent's
// node modules, which might not always be the case but it's at least a
// good guess
rootDirectory = path.resolve(__dirname, '../../..');
if (!(yield fs.exists(rootDirectory)) || !(yield fs.exists(path.resolve(rootDirectory, 'package.json')))) {
// Then we try the CWD
rootDirectory = process.cwd();
if (!(yield fs.exists(rootDirectory)) || !(yield fs.exists(path.resolve(rootDirectory, 'package.json')))) {
throw new Error('Unable to find parent node_modules directory, specify it via --module-dir, E.g. "--module-dir ." for the current directory');
}
}
}
else {
rootDirectory = path.resolve(process.cwd(), rootDirectory);
}
let modulesDone = 0;
let moduleTotal = 0;
const rebuildSpinner = ora('Searching dependency tree').start();
let lastModuleName;
const redraw = (moduleName) => {
if (moduleName)
lastModuleName = moduleName;
if (argv.p) {
rebuildSpinner.text = `Building modules: ${modulesDone}/${moduleTotal}`;
}
else {
rebuildSpinner.text = `Building module: ${lastModuleName}, Completed: ${modulesDone}`;
}
};
const rebuilder = rebuild_1.rebuild(rootDirectory, electronPrebuiltVersion, argv.a || process.arch, argv.w ? argv.w.split(',') : [], argv.f, argv.d, argv.t ? argv.t.split(',') : ['prod', 'dev'], argv.p ? 'parallel' : (argv.s ? 'sequential' : undefined));
const lifecycle = rebuilder.lifecycle;
lifecycle.on('module-found', (moduleName) => {
moduleTotal += 1;
redraw(moduleName);
});
lifecycle.on('module-done', () => {
modulesDone += 1;
redraw();
});
try {
yield rebuilder;
}
catch (err) {
rebuildSpinner.text = 'Rebuild Failed';
rebuildSpinner.fail();
throw err;
}
rebuildSpinner.text = 'Rebuild Complete';
rebuildSpinner.succeed();
}))();
co(function * () {
/* command-line option parsing */
let argv = yargs
.usage("Usage: $0 [-v] [-w] [--ui=<dir>] [--db=<file>]")
.count("v").alias("v", "verbose")
.describe("v", "verbose output (repeatable)")
.string("U").nargs("U", 1).alias("U", "ui").default("U", path.join(__dirname, "ui"))
.describe("U", "user interface directory")
.string("D").nargs("D", 1).alias("D", "db").default("D", path.join(__dirname, "app-db.json"))
.describe("D", "database file")
.string("H").alias("H", "host").nargs("H", 1).default("H", "127.0.0.1")
.describe("H", "host name to listen on")
.string("P").alias("P", "port").nargs("P", 1).default("P", "8888")
.describe("P", "TCP port to listen on")
.boolean("s").alias("s", "ssl").default("s", false)
.describe("s", "speak SSL/TLS on host/port")
.string("k").alias("k", "key").default("k", path.join(__dirname, "./app-tls-key.pem"))
.describe("k", "use private key for SSL/TLS")
.string("c").alias("c", "cert").default("c", path.join(__dirname, "./app-tls-crt.pem"))
.describe("c", "use X.509 certificate for SSL/TLS")
.boolean("t").alias("t", "traffic").default("t", false)
.describe("t", "perform traffic accounting")
.string("p").alias("p", "password").default("p", "admin")
.describe("p", "password of superuser")
.help("h").alias("h", "help").default("h", false)
.describe("h", "show usage help")
.boolean("V").alias("V", "version").default("V", false)
.describe("V", "show program version")
.strict()
.showHelpOnFail(true)
.demand(0)
.parse(process.argv.slice(2))
/* short-circuit some options */
if (argv.version) {
process.stderr.write(`${Package.name} ${Package.version} <${Package.homepage}>\n`)
process.stderr.write(`${Package.description}\n`)
process.stderr.write(`Copyright (c) ${Package.author.name} <${Package.author.url}>\n`)
process.stderr.write(`Licensed under ${Package.license} <http://spdx.org/licenses/${Package.license}.html>\n`)
process.exit(0)
}
/* force color output */
chalk.enabled = true
/* utility function for verbose output */
const verbose = (level, msg) => {
if (level <= argv.verbose)
process.stderr.write(`${msg}\n`)
}
/* drop a command-line headline */
verbose(1, "++ starting " + chalk.bold(Package.description))
/* establish connection to database */
const db = {
query (...args) {
return AlaSQL.promise(...args)
},
queryOne (...args) {
return this.query(...args).then((result) => {
if (result.length > 1)
throw new Error("more than one result found")
return (result.length === 1 ? result[0] : null)
})
}
}
let exists = yield fs.exists(argv.D)
if (!exists) {
/* on-the-fly provide database */
let password = yield pbkdf2.hash(argv.p, 10, "sha256")
password = password.toString("hex")
yield db.query(`
CREATE FILESTORAGE DATABASE db("${argv.D}");
ATTACH FILESTORAGE DATABASE db("${argv.D}");
USE DATABASE db;
CREATE TABLE users (username TEXT PRIMARY KEY, password TEXT);
CREATE TABLE items (name TEXT PRIMARY KEY, val TEXT);
INSERT INTO users VALUES ("admin", ?);`, [ password ])
}
else
yield db.query(`
ATTACH FILESTORAGE DATABASE db("${argv.D}");
USE DATABASE db;`)
/* establish a new server context */
var server = new HAPI.Server()
/* create underlying HTTP/HTTPS listener */
let listener
if (argv.ssl) {
let key = yield fs.readFile(argv.key, "utf8")
let crt = yield fs.readFile(argv.cert, "utf8")
listener = Http2.createServer({ key: key, cert: crt })
}
else
listener = http.createServer()
if (!listener.address)
listener.address = function () { return this._server.address() }
/* configure the listening socket */
let hapiOpts = {
listener: listener,
address: argv.host,
port: argv.port
}
if (argv.ssl)
hapiOpts.tls = true
server.connection(hapiOpts)
/* register HAPI plugins */
let register = Bluebird.promisify(server.register, { context: server })
yield register({ register: Inert })
yield register({ register: Auth })
yield register({ register: HAPIBoom })
yield register({ register: HAPIDucky })
yield register({ register: HAPIHeader, options: { Server: `${Package.name}/${Package.version}` }})
yield register({ register: HAPIWebSocket })
yield register({ register: HAPICo })
if (argv.t)
yield register({ register: HAPITraffic })
/* log all requests */
server.on("tail", (request) => {
let traffic = argv.t ? request.traffic() : null
let ws = request.websocket()
let protocol =
(ws ? `WebSocket/${ws.ws.protocolVersion}+` : "") +
`HTTP/${request.raw.req.httpVersion}`
verbose(2, "-- request: " +
"remote=" + chalk.blue(`${request.info.remoteAddress}:${request.info.remotePort}`) + ", " +
"method=" + chalk.blue(request.method.toUpperCase()) + ", " +
"url=" + chalk.blue(request.url.path) + ", " +
"protocol=" + chalk.blue(protocol) + ", " +
"response=" + chalk.blue(request.response.statusCode) +
(argv.t ? ", " +
"recv=" + chalk.blue(traffic.recvPayload) + "/" + chalk.blue(traffic.recvRaw) + ", " +
"sent=" + chalk.blue(traffic.sentPayload) + "/" + chalk.blue(traffic.sentRaw) + ", " +
"duration=" + chalk.blue(traffic.timeDuration) : "")
)
})
/* prepare for JSONWebToken (JWT) authentication */
let result = yield db.queryOne(`SELECT password FROM users WHERE username = "******"`)
if (result === null)
throw new Error("admin user not found")
let jwtKey = result.password
server.register(require("hapi-auth-jwt2"), (err) => {
if (err)
throw new Error(err)
server.auth.strategy("jwt", "jwt", {
key: jwtKey,
verifyOptions: { algorithms: [ "HS256" ] },
urlKey: "token",
cookieKey: "token",
tokenType: "JWT",
validateFunc: (decoded, request, callback) => {
db.queryOne("SELECT 1 FROM users WHERE username = ?", [ decoded.id ]).then((result) => {
return callback(null, result !== null, decoded)
})
}
})
})
/* display network interaction information */
const displayListenHint = ([ scheme, proto ]) => {
let url = `${scheme}://${argv.host}:${argv.port}`
verbose(1, `-- listen on ${chalk.blue(url)} (${proto})`)
}
displayListenHint(argv.ssl ?
[ "https", "HTTP/{1.0,1.1,2.0} + SSL/TLS" ] :
[ "http", "HTTP/{1.0,1.1}" ])
displayListenHint(argv.ssl ?
[ "wss", "WebSockets + SSL/TLS" ] :
[ "ws", "WebSockets" ])
/* load all modules */
let ctx = { argv, db, server, verbose, jwtKey }
let mods = yield glob("./app-mod-*.js")
mods.forEach((mod) => {
require(mod)(ctx)
})
/* fire up server */
yield Bluebird.promisify(server.start, { context: server })()
/* gracefully handle server shutdown */
const hookInto = (signal) => {
process.on(signal, () => {
verbose(2, `-- received ${signal} signal`)
verbose(2, "-- shutting down service")
server.root.stop({ timeout: 1 * 2000 }, () => {
verbose(1, "++ shutting down " + chalk.bold(Package.description))
process.exit(0)
})
})
}
let signals = [ "SIGINT", "SIGTERM" ]
signals.forEach((signal) => hookInto(signal))
}).catch((err) => {
/**
* render cdnex
* @return {Promise/object} It depends... should decouple this.
*/
export default async function render (options = {}) {
try {
if (!options.args) {
options.args = []
}
if (!options.validate && options.validate !== false) {
options.validate = true
}
if (options.validate && !validator.isURL(options.url)) {
throw new Error(`${options.url} is not a valid domain name.`)
}
let input
let isDir
if (options.src) { /* input data was passed through as string */
if (options.input) {
throw new Error('dont specify both input and src. only choose one!')
}
input = options.src
} else { /* input is a file/dirname, read from disk */
input = options.input || options.args[0]
if (!input) throw new Error('no input file or directory was specified.')
const exists = await fs.exists(input)
if (!exists) throw new Error(`"${input}" does not exist!`)
const stats = await fs.lstat(input)
isDir = stats.isDirectory()
}
let cdnexed
if (isDir) {
options.pattern = options.pattern || '/**/*.{html,css}'
if (options.pattern.charAt(0) !== '/') {
options.pattern = '/' + options.pattern
}
const files = await dn(glob)(path.resolve(input) + options.pattern)
cdnexed = await Promise.all(
files.map(async (file) => {
try {
cdnexed = await prepend(file, options)
return { file, cdnexed }
} catch (err) {
return Promise.reject(err)
}
})
)
} else {
cdnexed = await prepend(input, options)
}
if (options.output) {
/* warn if overwriting */
let outputExists = await fs.exists(options.output)
if (outputExists) {
/* doesnt really exist if its just an empty directory */
outputExists = (await dn(glob)(`${options.output}/**/*`, {
nodir: true
})).length > 0
}
if (outputExists && !options.force && options.args.length > 0) {
/* ask if they want to overwrite */
const { overwrite } = await dn(inquirer.prompt, (a) => [null, a])([{
type: 'confirm',
name: 'overwrite',
message: chalk.yellow(`${options.output} already exists. overwrite?`)
}])
/* abort if they dont */
if (!overwrite) {
throw new Error(chalk.red('change your output and try again.'))
}
} else if (outputExists && options.args.length === 0 && !options.force) {
throw new Error('output already exists')
}
/* output to file(s) */
if (typeof cdnexed === 'object') {
await fs.ensureDir(options.output)
await Promise.all(cdnexed.map((obj) => {
/* generate output filename */
obj.output = obj.file.replace(input, options.output)
/* log paths without the cwd */
if (!options.quiet) {
console.log('rendering',
obj.file.replace(process.cwd() + '/', ''), 'to',
obj.output.replace(process.cwd() + '/', '')
)
}
return fs.writeFile(obj.output, obj.cdnexed)
}))
} else {
/* output to a single file */
if (!options.quiet) {
console.log(`rendering ${input} to ${options.output}`)
}
await fs.writeFile(options.output, cdnexed)
}
} else {
/* no output, just return it */
return cdnexed
}
} catch (err) {
return Promise.reject(err)
}
}