boilerforge 1.1.3 → 1.2.0

package/src/lib/prompter.ts

@@ -1,201 +0,0 @@
-import chalk from 'chalk';
-import { prompt } from 'enquirer';
-
-type QuestionResponse<Q extends Question> = Q extends InputQuestion
-    ? string
-    : Q extends SelectQuestion
-      ? string
-      : Q extends RadioQuestion
-        ? boolean
-        : Q extends MultiselectQuestion
-          ? string[]
-          : never;
-
-type ResponseShape<T extends readonly Question[]> = {
-    [K in T[number] as K['name']]: QuestionResponse<K>;
-};
-
-type QuestionType = 'input' | 'radio' | 'select' | 'multiselect';
-
-type QuestionDescription = {
-    message: string;
-    default?: string;
-};
-
-type MultiselectChoice = {
-    name: string;
-    message: string;
-};
-
-type QuestionMap = {
-    input: InputQuestion;
-    select: SelectQuestion;
-    multiselect: MultiselectQuestion;
-    radio: RadioQuestion;
-};
-
-type PromptMap = {
-    input: InputPrompt;
-    select: SelectPrompt;
-    multiselect: MultiselectPrompt;
-    radio: RadioPrompt;
-};
-
-type QuestionHandler = {
-    [K in keyof QuestionMap]: (question: QuestionMap[K]) => PromptMap[K];
-};
-
-interface BaseQuestion {
-    type: QuestionType;
-    name: string;
-    description?: QuestionDescription;
-    skip?: boolean;
-    validate?: (value: string) => boolean | string;
-}
-
-interface SelectQuestion extends BaseQuestion {
-    type: 'select';
-    choices: readonly string[];
-    default: number;
-}
-
-interface MultiselectQuestion extends BaseQuestion {
-    type: 'multiselect';
-    choices: readonly MultiselectChoice[];
-    default: number;
-}
-
-interface InputQuestion extends BaseQuestion {
-    type: 'input';
-    default: string;
-}
-
-interface RadioQuestion extends BaseQuestion {
-    type: 'radio';
-    enabled: string;
-    disabled: string;
-    default: boolean;
-}
-
-interface InputPrompt {
-    type: 'input';
-    name: string;
-    message: string;
-    initial: string;
-}
-
-interface SelectPrompt {
-    type: 'select';
-    name: string;
-    message: string;
-    choices: readonly string[];
-    initial: number;
-}
-
-interface MultiselectPrompt {
-    type: 'multiselect';
-    name: string;
-    message: string;
-    choices: readonly MultiselectChoice[];
-    initial: number;
-}
-
-interface RadioPrompt {
-    type: 'toggle';
-    name: string;
-    message: string;
-    enabled: string;
-    disabled: string;
-    initial: boolean;
-}
-
-export type Question =
-    | InputQuestion
-    | SelectQuestion
-    | RadioQuestion
-    | MultiselectQuestion;
-
-export type PromptObject =
-    | InputPrompt
-    | SelectPrompt
-    | RadioPrompt
-    | MultiselectPrompt;
-
-export class Prompter<T extends readonly Question[] = Question[]> {
-    questions: T;
-
-    constructor(questions?: T) {
-        this.questions = (questions ?? []) as T;
-    }
-
-    addQuestion<Q extends Question>(question: Q): Prompter<[...T, Q]> {
-        return new Prompter<[...T, Q]>([...this.questions, question]);
-    }
-
-    buildPrompt(): PromptObject[] {
-        const baseBuilder = <T extends Question>(
-            question: T,
-        ): {
-            type: T['type'];
-            name: string;
-            message: string;
-            validate?: (value: string) => boolean | string;
-        } => ({
-            type: question.type,
-            name: question.name,
-            message:
-                chalk.cyan(question.description?.message) +
-                (question.description?.default
-                    ? chalk.gray(` (${question.description.default})`)
-                    : ''),
-            validate: question.validate
-                ? (value) => {
-                      const result = question.validate?.(value);
-                      if (typeof result === 'boolean') return result;
-                      return chalk.redBright(result);
-                  }
-                : undefined,
-        });
-
-        const questionHandler: QuestionHandler = {
-            input: (question: InputQuestion) => ({
-                ...baseBuilder(question),
-                initial: question.default,
-            }),
-            select: (question: SelectQuestion) => ({
-                ...baseBuilder(question),
-                choices: question.choices,
-                initial: question.default,
-            }),
-            multiselect: (question: MultiselectQuestion) => ({
-                ...baseBuilder(question),
-                choices: question.choices,
-                initial: question.default,
-            }),
-            radio: (question: RadioQuestion) => ({
-                ...baseBuilder(question),
-                type: 'toggle',
-                enabled: question.enabled,
-                disabled: question.disabled,
-                initial: question.default,
-            }),
-        };
-
-        const prompts: PromptObject[] = [];
-
-        this.questions.forEach((question) => {
-            const handler = questionHandler[question.type] as (
-                q: typeof question,
-            ) => PromptObject;
-
-            !question.skip && prompts.push(handler(question));
-        });
-
-        return prompts;
-    }
-
-    async prompt(): Promise<ResponseShape<T>> {
-        const prompts = this.buildPrompt();
-        return (await prompt(prompts)) as ResponseShape<T>;
-    }
-}

package/src/lib/task.ts

@@ -1,41 +0,0 @@
-export type TaskHandler = (...args: unknown[]) => Promise<unknown> | unknown;
-
-export interface TaskProps {
-    title: string;
-    task?: TaskHandler;
-    enabled?: TaskHandler;
-    subTasks?: Task[];
-    concurrent?: boolean;
-    rollback?: TaskHandler;
-    exitOnError?: boolean;
-}
-
-export class Task {
-    title: string;
-    task: TaskHandler;
-    enabled?: TaskHandler;
-    subTasks: Task[];
-    concurrent: boolean;
-    rollback?: TaskHandler;
-    exitOnError?: boolean;
-
-    constructor(taskProps: TaskProps) {
-        const {
-            title,
-            task,
-            enabled,
-            subTasks,
-            concurrent,
-            rollback,
-            exitOnError,
-        } = taskProps;
-
-        this.title = title;
-        this.task = task ?? (() => {});
-        this.enabled = enabled;
-        this.subTasks = subTasks ?? [];
-        this.concurrent = concurrent ?? false;
-        this.rollback = rollback;
-        this.exitOnError = exitOnError ?? true;
-    }
-}

package/src/templates/create-node-app/index.ts

@@ -1,306 +0,0 @@
-import { sep } from 'path';
-import { File } from '../../lib/file';
-import {
-    NodejsProject,
-    NodejsProjectProps,
-    ProjectDependency,
-    Resource,
-} from '../../lib/project';
-import { Prompter } from '../../lib/prompter';
-import { Task } from '../../lib/task';
-import { execCmd } from '../../utils/exec-cmd';
-import { getGitConfiguration, getGitVersion } from '../utils/git';
-import {
-    getLockFileName,
-    getPackageManagerVersion,
-    installDependencies,
-} from '../utils/package-manager';
-import { getReadmeContent } from '../utils/readme';
-import { getEditorConfigContent } from './resource/editor-config';
-import { getEslintContent } from './resource/eslint';
-import { getGitIgnoreContent } from './resource/gitignore';
-import { getPackageJsonContent } from './resource/package-json';
-import {
-    getPrettierIgnoreContent,
-    getPrettierrcContent,
-} from './resource/prettier';
-import { getProjectDeps } from './resource/project-deps';
-import { srcFileContent } from './resource/project-files';
-import { getTsConfigContent } from './resource/tsconfig';
-import { Regex } from '../../utils';
-
-export class CreateNodeApp extends NodejsProject {
-    constructor(props: NodejsProjectProps) {
-        super(props);
-        this.isTypescript = false;
-        this.isEslintPrettier = false;
-        this.configureCliCommand();
-    }
-
-    async setup(): Promise<CreateNodeApp> {
-        // creating the tasks
-        const {
-            systemCheckTask,
-            setupProjectTask,
-            installDepsTask,
-            gitInitTask,
-        } = this.buildTasks(getProjectDeps(this));
-
-        this.tasks = [
-            systemCheckTask,
-            setupProjectTask,
-            installDepsTask,
-            gitInitTask,
-        ];
-
-        await this.bootstrap();
-
-        return this;
-    }
-
-    buildTasks(projectDeps: ProjectDependency): {
-        systemCheckTask: Task;
-        setupProjectTask: Task;
-        installDepsTask: Task;
-        gitInitTask: Task;
-    } {
-        // verify git
-        const verifyGitTask = new Task({
-            title: 'Checking Git availability',
-            task: async () => {
-                this.systemCheck.git = {
-                    version: await getGitVersion(),
-                };
-            },
-        });
-
-        // git configuration (user.name & user.email)
-        const verifyGitConfigTask = new Task({
-            title: 'Checking Git config (user.name & user.email)',
-            enabled: () => !!this.systemCheck.git,
-            task: async () => {
-                const gitConfig = await getGitConfiguration({
-                    global: true,
-                });
-
-                if (!gitConfig) return;
-
-                const username = gitConfig['user.name'];
-                const email = gitConfig['user.email'];
-
-                username &&
-                    email &&
-                    (this.systemCheck.git = {
-                        ...this.systemCheck.git,
-                        configuration: {
-                            username,
-                            email,
-                        },
-                    });
-            },
-        });
-
-        // verify package manager
-        const verifyPkgManagerTask = new Task({
-            title: `Verifying ${this.packageManager} availability`,
-            task: async () => {
-                const pkgManagerVersion = await getPackageManagerVersion(
-                    this.packageManager,
-                );
-
-                if (!pkgManagerVersion)
-                    throw new Error(`${this.packageManager} is not installed`);
-
-                this.packageManagerVersion = pkgManagerVersion;
-                this.systemCheck.packageManager = `${this.packageManager}@${pkgManagerVersion}`;
-            },
-        });
-
-        // checking system requirements
-        const systemCheckTask = new Task({
-            title: 'Verifying System Requirements',
-            subTasks: [
-                verifyGitTask,
-                verifyGitConfigTask,
-                verifyPkgManagerTask,
-            ],
-        });
-
-        // creating the project dir
-        const setupProjectTask = new Task({
-            title: `Scaffolding ${this.name} project`,
-            task: async () => {
-                const resourceFileContent: Resource[] = [
-                    getGitIgnoreContent(),
-                    getEditorConfigContent(),
-                    ...(this.enabledEslintPrettier
-                        ? [getEslintContent(this), getPrettierrcContent()]
-                        : []),
-                    getPackageJsonContent(this),
-                    getPrettierIgnoreContent(),
-                    ...(this.enabledTypescript ? [getTsConfigContent()] : []),
-                    getReadmeContent(this),
-                    srcFileContent(this),
-                ];
-
-                this.files = resourceFileContent.map(
-                    ({ filename, content }) =>
-                        new File(filename, {
-                            dirPath: this.projectPath,
-                            content: `${content.trim()}\n`,
-                        }),
-                );
-
-                await Promise.all(this.files.map((file) => file.create()));
-            },
-            rollback: () => {
-                this.files.map((file) => file.delete());
-            },
-        });
-
-        // installing dependencies
-        const installDepsTask = new Task({
-            title: `Installing dependencies`,
-            task: async () => {
-                await installDependencies(
-                    this.projectPath,
-                    this.packageManager,
-                    projectDeps,
-                );
-            },
-            rollback: async () => {
-                await execCmd(`rm -rf node_modules`, {
-                    cwd: this.projectPath,
-                    throwError: false,
-                });
-
-                const lockFile = getLockFileName(this.packageManager);
-
-                lockFile &&
-                    (await execCmd(`rm ${lockFile}`, {
-                        cwd: this.projectPath,
-                        throwError: false,
-                    }));
-            },
-        });
-
-        // initialize git
-        const gitInitTask = new Task({
-            title: 'Initializing git',
-            enabled: () => !!this.systemCheck.git?.version,
-            task: async () => {
-                await execCmd('git init', {
-                    cwd: this.projectPath,
-                });
-
-                const { username, email } =
-                    this.systemCheck.git?.configuration ?? {};
-
-                username &&
-                    email &&
-                    (await execCmd('git commit -am"✨ Initial project setup"', {
-                        cwd: this.projectPath,
-                    }));
-            },
-            rollback: async () =>
-                this.systemCheck.git?.version &&
-                (await execCmd(`rm -rf .git`, {
-                    cwd: this.projectPath,
-                    throwError: false,
-                })),
-        });
-
-        return {
-            systemCheckTask,
-            setupProjectTask,
-            installDepsTask,
-            gitInitTask,
-        };
-    }
-
-    async configureCliCommand(): Promise<CreateNodeApp> {
-        this.program
-            .command('create-node-app')
-            .description('Create simple node.js app')
-            .argument('[name]', 'name of the project', '')
-            .action(async (name) => {
-                this.name = name;
-                await this.promptUser();
-                await this.setup();
-            });
-
-        return this;
-    }
-
-    async promptUser(): Promise<void> {
-        const prompter = new Prompter([
-            {
-                type: 'input',
-                name: 'name',
-                default: '',
-                description: {
-                    message: 'Project name',
-                    default: process.cwd().split(sep).slice(-1)[0],
-                },
-                validate: (value) =>
-                    !value.length || Regex.PROJECT_NAME.test(value)
-                        ? true
-                        : 'Invalid project name',
-                skip: !!this.name.length,
-            },
-            {
-                type: 'input',
-                name: 'description',
-                default: '',
-                description: { message: 'Description' },
-            },
-            {
-                type: 'input',
-                name: 'version',
-                default: '0.0.1',
-                description: { message: 'Version' },
-                validate: (value) =>
-                    Regex.VERSION.test(value) ? true : 'Invalid version',
-            },
-            {
-                type: 'input',
-                name: 'author',
-                default: '',
-                description: { message: 'Author' },
-            },
-            {
-                type: 'select',
-                name: 'packageManager',
-                choices: ['npm', 'yarn', 'pnpm'],
-                default: 0,
-                description: { message: 'Package manager', default: 'npm' },
-            },
-            {
-                type: 'radio',
-                name: 'isTypescript',
-                enabled: 'Yes',
-                disabled: 'No',
-                default: true,
-                description: { message: 'Use TypeScript' },
-            },
-            {
-                type: 'radio',
-                name: 'isEslintPrettier',
-                enabled: 'Yes',
-                disabled: 'No',
-                default: true,
-                description: { message: 'Use ESLint & Prettier formatting' },
-            },
-        ] as const);
-
-        const { isEslintPrettier, isTypescript, ...restResponse } =
-            await prompter.prompt();
-
-        this.configureProject({
-            ...restResponse,
-        });
-
-        this.isTypescript = isTypescript;
-        this.isEslintPrettier = isEslintPrettier;
-    }
-}

package/src/templates/create-node-app/resource/editor-config.ts

@@ -1,24 +0,0 @@
-import { Resource } from '../../../lib/project';
-
-const content = `
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.yml]
-indent_style = space
-indent_size = 2
-`;
-
-export const getEditorConfigContent = (): Resource => {
-    return {
-        filename: '.editorconfig',
-        content,
-    };
-};

package/src/templates/create-node-app/resource/eslint.ts

@@ -1,62 +0,0 @@
-import { NodejsProject, Resource } from '../../../lib/project';
-
-const eslintTsContent = `
-import js from "@eslint/js";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-import eslintPluginTs from '@typescript-eslint/eslint-plugin';
-import { defineConfig } from "eslint/config";
-
-export default defineConfig([
-    { files: ["**/*.{js,mjs,cjs,ts}"], plugins: { js }, extends: ["js/recommended"] },
-    { files: ["**/*.{js,mjs,cjs,ts}"], languageOptions: { globals: globals.node } },
-    tseslint.configs.recommended,
-    {
-        plugins: {
-            '@typescript-eslint': eslintPluginTs,
-        },
-        rules: {
-            "@typescript-eslint/no-namespace": "off",
-            "@typescript-eslint/no-empty-interface": "off",
-            "@typescript-eslint/no-empty-object-type": "off",
-            "@typescript-eslint/no-unused-expressions": "off"
-        }
-    },
-    { ignores: ["node_modules/*", "dist/*"] },
-]);
-`;
-
-const eslintJsContent = `
-import js from "@eslint/js";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-import eslintPluginTs from '@typescript-eslint/eslint-plugin';
-import { defineConfig } from "eslint/config";
-
-export default defineConfig([
-    { files: ["**/*.{js,mjs,cjs,ts}"], plugins: { js }, extends: ["js/recommended"] },
-    { files: ["**/*.{js,mjs,cjs,ts}"], languageOptions: { globals: globals.node } },
-    tseslint.configs.recommended,
-    {
-        plugins: {
-            '@typescript-eslint': eslintPluginTs,
-        },
-        rules: {
-            "@typescript-eslint/no-namespace": "off",
-            "@typescript-eslint/no-empty-interface": "off",
-            "@typescript-eslint/no-empty-object-type": "off",
-            "@typescript-eslint/no-unused-expressions": "off"
-        }
-    },
-    { ignores: ["node_modules/*", "dist/*"] },
-]);
-`;
-
-export const getEslintContent = (project: NodejsProject): Resource => {
-    const filename = 'eslint.config.mjs';
-
-    return {
-        filename,
-        content: project.enabledTypescript ? eslintTsContent : eslintJsContent,
-    };
-};

package/src/templates/create-node-app/resource/package-json.ts

@@ -1,57 +0,0 @@
-import { NodejsProject, Resource } from '../../../lib/project';
-import { PackageManager } from '../../utils/package-manager';
-
-export const getPackageJsonContent = (project: NodejsProject): Resource => {
-    const { name, author, description, packageManager, version } = project;
-
-    const ci = `${packageManager} ${packageManager === PackageManager.NPM ? 'ci' : 'install --frozen-lockfile'}`;
-
-    const prebuildScript = [`${packageManager} run clean`];
-
-    project.enabledEslintPrettier &&
-        prebuildScript.push(
-            `${packageManager} run lint`,
-            `${packageManager} run format`,
-        );
-
-    const packageJson = {
-        name,
-        version,
-        description,
-        author,
-        license: 'ISC',
-        packageManager: project.getPackageManager(),
-        main: project.enabledTypescript ? 'dist/' : 'src/',
-        scripts: {
-            ci,
-            ...(project.enabledTypescript
-                ? {
-                      clean: 'rimraf dist',
-                      build: 'tsc',
-                      dev: 'ts-node src/',
-                      prebuild: prebuildScript.join(' && '),
-                      start: 'node dist/',
-                      ...(project.enabledEslintPrettier
-                          ? {
-                                lint: 'eslint --ext .js,.ts .',
-                                format: 'prettier --write "**/*.+(js|ts)"',
-                            }
-                          : {}),
-                  }
-                : {
-                      start: 'node src/',
-                      ...(project.enabledEslintPrettier
-                          ? {
-                                lint: 'eslint --ext .js .',
-                                format: 'prettier --write "**/*.+(js)"',
-                            }
-                          : {}),
-                  }),
-        },
-    };
-
-    return {
-        filename: 'package.json',
-        content: JSON.stringify(packageJson, null, 4),
-    };
-};