express-starter/scripts/init.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const child_process_1 = require("child_process");
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const util_1 = __importDefault(require("util"));
const MAX_BUFFER = 10 * Math.pow(2, 20);
function exec(command, stdout, stderr) {
    return new Promise((resolve, reject) => {
        try {
            let stdoutbuf = '';
            let stderrbuf = '';
            // EXEC CHILD PROCESS
            const p = child_process_1.exec(command, { maxBuffer: MAX_BUFFER }, (err, out) => {
                if (err)
                    return reject(err);
                if (stdoutbuf.length > 0 && typeof stdout === 'function')
                    stdout(stdoutbuf);
                if (stderrbuf.length > 0 && typeof stderr === 'function')
                    stderr(stderrbuf);
                resolve(out);
            });
            // PIPE STDOUT
            if (typeof stdout === 'function') {
                p.stdout.on('data', chunk => {
                    stdoutbuf += chunk;
                    let i = -1;
                    while ((i = stdoutbuf.indexOf('\n')) >= 0) {
                        const line = stdoutbuf.substring(0, i);
                        stdoutbuf = stdoutbuf.substring(i + 1);
                        if (typeof stdout === 'function') {
                            stdout(line);
                        }
                    }
                });
            }
            else if (typeof stdout !== 'undefined') {
                p.stdout.pipe(stdout);
            }
            // PIPE STDERR
            if (typeof stderr === 'function') {
                p.stderr.on('data', chunk => {
                    stderrbuf += chunk;
                    let i = -1;
                    while ((i = stderrbuf.indexOf('\n')) >= 0) {
                        const line = stderrbuf.substring(0, i);
                        stderrbuf = stderrbuf.substring(i + 1);
                        if (typeof stderr === 'function') {
                            stderr(line);
                        }
                    }
                });
            }
            else if (typeof stderr !== 'undefined') {
                p.stderr.pipe(stderr);
            }
        }
        catch (err) {
            reject(err);
        }
    });
}
exports.exec = exec;
const cli = {
    blue: v => `\x1b[34m${v}\x1b[0m`,
    green: v => `\x1b[32m${v}\x1b[0m`,
    yellow: v => `\x1b[33m${v}\x1b[0m`,
    red: v => `\x1b[31m${v}\x1b[0m`
};
function readFile(path, encoding = 'utf8') {
    return __awaiter(this, void 0, void 0, function* () {
        return new Promise((resolve, reject) => {
            fs_1.default.readFile(path, { encoding }, (err, data) => {
                if (err)
                    return reject(err);
                try {
                    resolve(data.toString());
                }
                catch (e) {
                    reject(e);
                }
            });
        });
    });
}
function readJsonFile(path, encoding = 'utf8') {
    return __awaiter(this, void 0, void 0, function* () {
        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
            try {
                resolve(JSON.parse(yield readFile(path, encoding)));
            }
            catch (e) {
                reject(e);
            }
        }));
    });
}
(() => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const projectRootDir = path_1.default.resolve(process.cwd());
        if (!fs_1.default.existsSync(path_1.default.resolve(projectRootDir, 'package.json'))) {
            console.log(cli.blue('[INFO]'), 'Not an NPM project yet - initializing...');
            yield exec('npm init -y', process.stdout, process.stderr);
        }
        const cloneDir = path_1.default.resolve(projectRootDir, '.clone');
        if (fs_1.default.existsSync(cloneDir)) {
            console.log(cli.blue('[WARNING]'), `There's an old .clone directory. Removing first...`);
            yield util_1.default.promisify(fs_1.default.rm)(cloneDir, { force: true, recursive: true });
        }
        console.log(cli.blue('[INFO]'), 'Cloning boilerplate repository (via SSH)...');
        yield exec(`git clone ssh://git@bitbucket.siriusonline.de:7999/tsc/express-starter.git "${cloneDir}"`, process.stdout, process.stderr);
        let pkgJson = yield readJsonFile(path_1.default.resolve(cloneDir, 'package.json'));
        console.log(cli.blue('[INFO]'), 'Installing module dependencies...');
        let dependencies = Object.keys(pkgJson.dependencies).join('" "');
        yield exec(`npm install "${dependencies}"`, process.stdout, process.stderr);
        dependencies = Object.keys(pkgJson.devDependencies).join('" "');
        yield exec(`npm install --save-dev "${dependencies}"`, process.stdout, process.stderr);
        console.log(cli.blue('[INFO]'), 'Copying project files...');
        const copyFiles = ['.env', '.gitignore', '.prettierrc.js', 'tsconfig.json', '.vscode/settings.json', 'src', 'public', 'private'];
        for (const cpFile of copyFiles) {
            const sourceFile = path_1.default.resolve(cloneDir, cpFile);
            const targetFile = path_1.default.resolve(projectRootDir, cpFile);
            const targetDir = path_1.default.dirname(targetFile);
            if (!fs_1.default.existsSync(targetDir)) {
                yield util_1.default.promisify(fs_1.default.mkdir)(targetDir, { recursive: true, mode: 0o777 });
            }
            const stat = yield util_1.default.promisify(fs_1.default.stat)(sourceFile);
            if (stat.isFile()) {
                yield util_1.default.promisify(fs_1.default.copyFile)(sourceFile, targetFile);
            }
            else {
                yield exec(`cp -r "${sourceFile}" "${targetFile}"`);
            }
        }
        console.log(cli.blue('[INFO]'), 'Creating startup script');
        pkgJson = yield readJsonFile(path_1.default.resolve(projectRootDir, 'package.json'));
        pkgJson.scripts = Object.assign(Object.assign({}, pkgJson.scripts), { build: 'tsc -b', start: 'npm run build && node dist/index.js' });
        yield util_1.default.promisify(fs_1.default.writeFile)(path_1.default.resolve(projectRootDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
        console.log(cli.blue('[INFO]'), 'Creating chat data directory');
        yield util_1.default.promisify(fs_1.default.mkdir)(path_1.default.resolve(projectRootDir, 'chatdata'));
        console.log(cli.blue('[INFO]'), 'Cleanup: Removing .clone directory...');
        yield util_1.default.promisify(fs_1.default.rm)(cloneDir, { force: true, recursive: true });
        console.log();
        console.log(cli.green('[SUCCESS] You can now start your express server with `npm start`'));
        process.exit(0);
    }
    catch (e) {
        console.error(e);
        process.exit(1);
    }
}))();