boilerforge 1.0.0

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

@@ -0,0 +1,306 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,62 @@
+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/gitignore.ts

@@ -0,0 +1,155 @@
+import { Resource } from '../../../lib/project';
+
+const gitignore = `
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+# build or bundles
+build/**/*
+
+# Ignore built ts files
+dist/**/*
+`;
+
+export const getGitIgnoreContent = (): Resource => {
+    const filename = '.gitignore';
+
+    return {
+        filename,
+        content: gitignore,
+    };
+};

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

@@ -0,0 +1,57 @@
+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),
+    };
+};

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

@@ -0,0 +1,45 @@
+import { Resource } from '../../../lib/project';
+
+const prettierignore = `
+.gitignore
+.editorconfig
+*.json
+
+node_modules/
+
+# build or bundles
+build/
+
+# Ignore built js files
+dist/
+`;
+
+export const getPrettierrcContent = (): Resource => {
+    const prettierrcJson = {
+        printWidth: 80,
+        tabWidth: 4,
+        useTabs: false,
+        semi: true,
+        singleQuote: true,
+        quoteProps: 'as-needed',
+        trailingComma: 'all',
+        arrowParens: 'always',
+        parser: 'typescript',
+        proseWrap: 'always',
+        endOfLine: 'auto',
+        embeddedLanguageFormatting: 'auto',
+        singleAttributePerLine: true,
+    };
+
+    return {
+        filename: '.prettierrc.json',
+        content: JSON.stringify(prettierrcJson, null, 4),
+    };
+};
+
+export const getPrettierIgnoreContent = (): Resource => {
+    return {
+        filename: '.prettierignore',
+        content: prettierignore,
+    };
+};

package/src/templates/create-node-app/resource/project-deps.ts

@@ -0,0 +1,30 @@
+import { NodejsProject, ProjectDependency } from '../../../lib/project';
+
+export const getProjectDeps = (project: NodejsProject): ProjectDependency => {
+    const { enabledEslintPrettier, enabledTypescript } = project;
+
+    const esLintPrettierDeps = enabledEslintPrettier
+        ? [
+              '@eslint/js',
+              'eslint',
+              'globals',
+              'prettier',
+              ...(enabledTypescript
+                  ? [
+                        '@typescript-eslint/eslint-plugin',
+                        '@typescript-eslint/parser',
+                        'typescript-eslint',
+                    ]
+                  : []),
+          ]
+        : [];
+
+    const tsDeps = enabledTypescript
+        ? ['@types/node', 'ts-node', 'typescript', 'rimraf']
+        : [];
+
+    return {
+        dependencies: [],
+        devDependencies: [...esLintPrettierDeps, ...tsDeps],
+    };
+};

package/src/templates/create-node-app/resource/project-files.ts

@@ -0,0 +1,17 @@
+import { NodejsProject, Resource } from '../../../lib/project';
+
+export const srcFileContent = (project: NodejsProject): Resource => {
+    const filename = `src/index.${project.enabledTypescript ? 'ts' : 'js'}`;
+    const content = `
+async function main() {
+    console.log('Hello from ${project.name}');
+}
+
+main().catch((error) => console.error(error));
+`;
+
+    return {
+        filename,
+        content,
+    };
+};