boilerforge 1.0.2 → 1.2.0-dev.1

package/src/lib/file.ts

@@ -1,159 +0,0 @@
-import {
-    createReadStream,
-    createWriteStream,
-    existsSync,
-    mkdirSync,
-    readdirSync,
-    rmdirSync,
-    unlinkSync,
-    writeFileSync,
-} from 'fs';
-import { join, sep } from 'path';
-
-import { logger } from '../utils/logger';
-
-export class File {
-    private fileName: string;
-    private filePath: string;
-    private fileExtension?: string;
-    private dirPath: string;
-    private contextPath: string;
-    private relativeDirPath: string;
-    private relativeFilePath: string;
-    private content?: string;
-
-    constructor(
-        filePath: string,
-        fileOptions?: { dirPath?: string; content?: string },
-    ) {
-        const { content = '', dirPath } = fileOptions ?? {};
-
-        const filePathSplit = filePath.split('/');
-
-        const relativeDirPath = join(
-            ...filePathSplit.slice(0, filePathSplit.length - 1),
-        );
-
-        const fileName = filePathSplit[filePathSplit.length - 1];
-
-        this.contextPath = dirPath ?? __dirname;
-        this.fileName = fileName;
-        this.content = content;
-        this.dirPath = join(
-            this.contextPath,
-            relativeDirPath.length ? relativeDirPath : __dirname,
-        );
-        this.filePath = join(this.dirPath, fileName);
-        this.fileExtension = fileName.split('.').at(1);
-        this.relativeDirPath = relativeDirPath;
-        this.relativeFilePath = join(relativeDirPath, fileName);
-    }
-
-    get getFileName(): string {
-        return this.fileName;
-    }
-
-    get getFilePath(): string {
-        return this.filePath;
-    }
-
-    get getFileExtension(): string | undefined {
-        return this.fileExtension;
-    }
-
-    get getDirPath(): string {
-        return this.dirPath;
-    }
-
-    get getContextPath(): string {
-        return this.contextPath;
-    }
-
-    get getRelativeDirPath(): string {
-        return this.relativeDirPath;
-    }
-
-    get getRelativeFilePath(): string {
-        return this.relativeFilePath;
-    }
-
-    create(content?: string) {
-        try {
-            mkdirSync(this.dirPath, { recursive: true });
-            writeFileSync(
-                this.filePath,
-                content || this.content || '',
-                'utf-8',
-            );
-        } catch (error) {
-            logger.err(
-                `Error while creating the file: ${this.filePath}, ${(error as Error).message}`,
-            );
-
-            throw new Error(`Error while creating the file ${this.filePath}`);
-        }
-    }
-
-    isExists() {
-        return existsSync(this.filePath);
-    }
-
-    delete() {
-        if (!this.isExists())
-            throw new Error(`File does not exists: ${this.filePath}`);
-
-        try {
-            unlinkSync(this.filePath);
-            this.deleteDir();
-        } catch (error) {
-            logger.err(
-                `Error while deleting the file: ${this.filePath}, ${(error as Error).message}`,
-            );
-
-            throw new Error(`Error while deleting the file ${this.filePath}`);
-        }
-    }
-
-    async createFrom(file: File) {
-        if (!file.isExists())
-            throw new Error(
-                `File to copy from does not exist: ${file.getFilePath}`,
-            );
-
-        if (this.isExists())
-            throw new Error(`File already exists: ${this.filePath}`);
-
-        await new Promise((resolve, reject) => {
-            const readStream = createReadStream(file.getFilePath, 'utf-8');
-            const writeStream = createWriteStream(this.filePath);
-
-            readStream.pipe(writeStream);
-
-            readStream.on('error', reject);
-            writeStream.on('error', reject);
-            writeStream.on('finish', () => resolve);
-        });
-    }
-
-    private deleteDir() {
-        try {
-            const dirs = this.relativeDirPath.split(sep);
-
-            for (let i = dirs.length; i > 0; i--) {
-                const dirPath = join(this.contextPath, ...dirs.slice(0, i));
-
-                if (readdirSync(dirPath).length) break;
-
-                rmdirSync(dirPath);
-            }
-        } catch (error) {
-            logger.err(
-                `Error while deleting the dirs: ${this.relativeDirPath}, ${(error as Error).message}`,
-            );
-
-            throw new Error(
-                `Error while deleting the dirs: ${this.relativeDirPath}`,
-            );
-        }
-    }
-}

package/src/lib/project.ts

@@ -1,211 +0,0 @@
-import { Command } from 'commander';
-import { Listr, ListrTaskWrapper } from 'listr2';
-import { dirname, join, sep } from 'path';
-import { logger } from '../utils/logger';
-import { File } from './file';
-import { Task } from './task';
-
-export interface GitCheck {
-    version?: string;
-    configuration?: {
-        username: string;
-        email: string;
-    };
-}
-
-export interface SystemCheck {
-    git?: GitCheck;
-    packageManager?: string;
-}
-
-export interface ProjectDependency {
-    devDependencies: string[];
-    dependencies: string[];
-}
-
-export interface Resource {
-    filename: string;
-    content: string;
-}
-
-export interface ProjectProps {
-    name: string;
-    packageManager: string;
-    description?: string;
-    version?: string;
-    author?: string;
-}
-
-export interface BootstrapProps extends Partial<ProjectProps> {
-    program: Command;
-    showSubTasks?: boolean;
-    showErrorMessage?: boolean;
-}
-
-export interface NodejsProjectProps extends BootstrapProps {}
-
-export abstract class Project {
-    name: string = '';
-    description: string = '';
-    version: string = '';
-    author: string = '';
-    projectPath: string = '';
-    parentDirPath: string = '';
-    packageManager: string = '';
-    packageManagerVersion: string = '';
-
-    protected configureProject(projectProps: Partial<ProjectProps>) {
-        const {
-            name = this.name,
-            description,
-            version = '0.0.1',
-            author,
-            packageManager = '',
-        } = projectProps;
-
-        const cwd = process.cwd();
-
-        this.name = !name.length ? cwd.split(sep).slice(-1)[0] : name;
-        this.description = description?.length
-            ? description
-            : `Node.js application for ${this.name}`;
-        this.version = version;
-        this.author = author ?? '';
-        this.packageManager = packageManager;
-        this.projectPath = join(cwd, name.length ? name : '');
-        this.parentDirPath = name.length ? cwd : dirname(cwd);
-        this.packageManagerVersion = '';
-    }
-
-    getPackageManager() {
-        return `${this.packageManager}@${this.packageManagerVersion}`;
-    }
-}
-
-export abstract class Bootstrap extends Project {
-    protected tasks: Task[];
-    protected executedTasks: Task[];
-    protected showSubTasks?: boolean;
-    protected showErrorMessage?: boolean;
-    protected taskExecutor: Listr;
-    protected systemCheck: SystemCheck;
-    protected files: File[];
-    protected program: Command;
-    protected cmdExecutedFromDir: string;
-
-    constructor(props: BootstrapProps) {
-        super();
-        this.tasks = [];
-        this.executedTasks = [];
-        this.showSubTasks = props.showSubTasks ?? true;
-        this.showErrorMessage = props.showErrorMessage ?? false;
-        this.taskExecutor = new Listr([]);
-        this.systemCheck = {};
-        this.files = [];
-        this.program = props.program;
-        this.cmdExecutedFromDir = process.cwd();
-        this.configureProject(props);
-    }
-
-    private async buildListrTask(
-        taskHandler: Task,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ): Promise<{ title: string; task: any; enabled?: any }> {
-        if (!taskHandler.subTasks.length) {
-            return {
-                title: taskHandler.title,
-                enabled: taskHandler.enabled,
-                task: async () => {
-                    await taskHandler.task();
-                    this.executedTasks.push(taskHandler);
-                },
-            };
-        }
-
-        return {
-            title: taskHandler.title,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            task: async (_: any, task: ListrTaskWrapper<any, any, any>) => {
-                await taskHandler.task();
-                this.executedTasks.push(taskHandler);
-
-                const subTasks = [];
-                for (const subTask of taskHandler.subTasks) {
-                    subTasks.push(await this.buildListrTask(subTask));
-                }
-
-                return task.newListr([...subTasks], {
-                    exitOnError: taskHandler.exitOnError,
-                    concurrent: taskHandler.concurrent,
-                });
-            },
-        };
-    }
-
-    async bootstrap(): Promise<void> {
-        try {
-            const listrTasks = await Promise.all(
-                this.tasks.map(
-                    async (taskHandler) =>
-                        await this.buildListrTask(taskHandler),
-                ),
-            );
-
-            this.taskExecutor.add(listrTasks);
-            this.taskExecutor.options = {
-                rendererOptions: {
-                    showErrorMessage: this.showErrorMessage,
-                    showSubtasks: this.showSubTasks,
-                },
-            };
-            await this.taskExecutor.run();
-        } catch (error) {
-            logger.err(error);
-
-            const rollbacks = this.tasks
-                .map(({ rollback }) => rollback)
-                .reverse();
-
-            await Promise.all(
-                rollbacks.map(
-                    async (rollback) => rollback && (await rollback()),
-                ),
-            );
-        }
-    }
-
-    async setup(): Promise<Bootstrap> {
-        throw new Error('Not Implemented');
-    }
-
-    async configureCliCommand(): Promise<Bootstrap> {
-        throw new Error('Not Implemented');
-    }
-
-    async promptUser() {
-        throw new Error('Not Implemented');
-    }
-
-    getSystemCheck() {
-        return this.systemCheck;
-    }
-}
-
-export abstract class NodejsProject extends Bootstrap {
-    protected isTypescript: boolean;
-    protected isEslintPrettier: boolean;
-
-    constructor(nodejsProjectProps: NodejsProjectProps) {
-        super(nodejsProjectProps);
-        this.isTypescript = false;
-        this.isEslintPrettier = false;
-    }
-
-    get enabledTypescript() {
-        return this.isTypescript;
-    }
-
-    get enabledEslintPrettier() {
-        return this.isEslintPrettier;
-    }
-}

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;
-    }
-}