create-tateru-cli/lib/index.js

Create basic Tateru CLI project from template files

#!/usr/bin/env node
"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 node_path_1 = __importDefault(require("node:path"));
const promises_1 = require("node:fs/promises");
const node_fs_1 = require("node:fs");
const promises_2 = __importDefault(require("node:readline/promises"));
const cli_1 = require("./cli/cli");
const renameFiles = {
    _gitignore: '.gitignore',
};
const getTemplatePath = (template) => {
    return node_path_1.default.resolve(__dirname, '..', 'templates', `template-${template}`);
};
const getDestinationPath = (directory) => {
    return node_path_1.default.resolve(process.cwd(), directory);
};
const validateInputs = (template, directory) => {
    if (!template) {
        throw new Error('Error: Template name is required.');
    }
    if (!directory) {
        throw new Error('Error: Destination directory is required.');
    }
};
const ensureDirectoryEmpty = (directory) => __awaiter(void 0, void 0, void 0, function* () {
    if ((0, node_fs_1.existsSync)(directory)) {
        const files = yield (0, promises_1.readdir)(directory);
        if (files.length > 0) {
            const rl = promises_2.default.createInterface({
                input: process.stdin,
                output: process.stdout,
            });
            const answer = yield rl.question(`Warning: Destination directory "${directory}" is not empty. Do you want to continue? (y/N): `);
            rl.close();
            if (answer.toLowerCase() !== 'y') {
                throw new Error('Operation aborted.');
            }
        }
    }
    else {
        yield (0, promises_1.mkdir)(directory, { recursive: true });
    }
});
const copyTemplateFiltered = (src, dest) => __awaiter(void 0, void 0, void 0, function* () {
    const stats = yield (0, promises_1.stat)(src);
    if (stats.isDirectory()) {
        yield (0, promises_1.mkdir)(dest, { recursive: true });
        const entries = yield (0, promises_1.readdir)(src);
        for (const entry of entries) {
            const srcPath = node_path_1.default.join(src, entry);
            const destPath = node_path_1.default.join(dest, renameFiles[entry] || entry);
            yield copyTemplateFiltered(srcPath, destPath);
        }
    }
    else {
        yield (0, promises_1.copyFile)(src, dest);
    }
});
const copyTemplate = (templatePath, destinationPath) => __awaiter(void 0, void 0, void 0, function* () {
    try {
        yield copyTemplateFiltered(templatePath, destinationPath);
    }
    catch (error) {
        throw new Error([
            'Error copying template:',
            error.message,
        ].toString());
    }
});
const beginMessage = (template, directory) => {
    return `
Copying template "${template}" to destination "${directory}"...
`;
};
const doneMessage = (directory) => {
    return `
Done. Template successfully copied. Now run:

cd ${directory}
npm install
npm run dev
`;
};
const init = () => __awaiter(void 0, void 0, void 0, function* () {
    try {
        const result = yield (0, cli_1.commands)(node_path_1.default.resolve(__dirname, '..'));
        if (!result) {
            process.exit(0);
            return;
        }
        const { template, directory } = result;
        validateInputs(template, directory);
        console.log(beginMessage(template, directory));
        const templatePath = getTemplatePath(template);
        const destinationPath = getDestinationPath(directory);
        if (!(0, node_fs_1.existsSync)(templatePath)) {
            throw new Error(`Error: Template "${template}" not found.`);
        }
        yield ensureDirectoryEmpty(destinationPath);
        yield copyTemplate(templatePath, destinationPath);
        console.log(doneMessage(directory));
    }
    catch (error) {
        console.error('Unexpected error:', error.message);
        process.exit(1);
    }
});
init();