create-vitnode-app 1.2.0-canary.3 → 1.2.0-canary.31

package/dist/src/create/create-vitnode.js

@@ -0,0 +1,70 @@
+import { existsSync } from 'fs';
+import { copyFile, cp, mkdir, readFile, rename, writeFile } from 'fs/promises';
+import ora from 'ora';
+import { dirname, join } from 'path';
+import color from 'picocolors';
+import { fileURLToPath } from 'url';
+import { generateMigrationsVitnode, initFilesVitnode, } from '../helpers/init-vitnode.js';
+import { installDependencies } from '../helpers/install-dependencies.js';
+import { isFolderEmpty } from '../helpers/is-folder-empty.js';
+import { createPackageJSON } from './create-package-json.js';
+export const createVitNode = async ({ root, appName, packageManager, eslint, install, docker, }) => {
+    const spinner = ora(`Creating a new VitNode app in ${color.green(root)}. Using ${color.green(packageManager)}...`).start();
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const templatePath = join(__dirname, '..', '..', '..', 'copy-of-vitnode-app');
+    if (!existsSync(templatePath)) {
+        spinner.fail(`\n${color.red('Error!')} Template path ${color.cyan(templatePath)} does not exist.`);
+        process.exit(1);
+    }
+    await mkdir(root, { recursive: true });
+    if (!isFolderEmpty(root, appName)) {
+        process.exit(1);
+    }
+    spinner.text = 'Copying files...';
+    await cp(join(templatePath, 'root'), root, {
+        recursive: true,
+    });
+    if (eslint) {
+        spinner.text = 'Copying eslint files...';
+        await cp(join(templatePath, 'eslint'), root, {
+            recursive: true,
+        });
+    }
+    spinner.text = 'Renaming special files...';
+    await rename(join(root, '.gitignore_template'), join(root, '.gitignore'));
+    spinner.text = 'Creating package.json...';
+    await createPackageJSON({
+        root,
+        appName,
+        packageManager,
+        eslint,
+        docker,
+    });
+    if (docker) {
+        spinner.text = 'Copying docker files...';
+        await copyFile(join(templatePath, 'docker', 'docker-compose.yml'), join(root, 'docker-compose.yml'));
+        const dockerComposePath = join(root, 'docker-compose.yml');
+        const dockerComposeContent = await readFile(dockerComposePath, 'utf-8');
+        const updatedContent = dockerComposeContent.replace(/vitnode_postgres_dev/g, `${appName}_vitnode_postgres_dev`);
+        await writeFile(dockerComposePath, updatedContent);
+    }
+    if (install) {
+        spinner.text = 'Installing dependencies...';
+        await installDependencies({
+            packageManager,
+            cwd: root,
+        });
+        spinner.text = 'Initializing VitNode files...';
+        initFilesVitnode({
+            packageManager,
+            cwd: root,
+        });
+        spinner.text = 'Generating migrations...';
+        generateMigrationsVitnode({
+            packageManager,
+            cwd: root,
+        });
+    }
+    spinner.succeed(`${color.green('Success!')} Created ${color.cyan(appName)} at ${color.cyan(root)}`);
+};

package/dist/src/helpers/get-available-package-managers.js

@@ -0,0 +1,24 @@
+import { exec } from 'child_process';
+export const execShellCommand = async (cmd) => {
+    return new Promise(resolve => {
+        exec(cmd, (error, stdout, stderr) => {
+            if (error) {
+                resolve(undefined);
+            }
+            const result = stdout ? stdout : stderr;
+            resolve(result.replace(/\s+/g, ''));
+        });
+    });
+};
+export const getAvailablePackageManagers = async () => {
+    const [npm, pnpm, bun] = await Promise.all([
+        execShellCommand('npm --version'),
+        execShellCommand('pnpm --version'),
+        execShellCommand('bun --version'),
+    ]);
+    return {
+        pnpm,
+        npm,
+        bun,
+    };
+};

package/dist/src/helpers/get-package-json.js

@@ -0,0 +1,2 @@
+import { readFileSync } from 'fs';
+export const packageJson = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf-8'));

package/dist/src/helpers/init-vitnode.js

@@ -0,0 +1,15 @@
+import { spawn } from 'child_process';
+export const initFilesVitnode = ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split('@')[0];
+    const args = ['vitnode', 'prepare-plugins'];
+    spawn(packageManager, args, {
+        cwd,
+    });
+};
+export const generateMigrationsVitnode = ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split('@')[0];
+    const args = ['vitnode', 'migrate', '--generate'];
+    spawn(packageManager, args, {
+        cwd,
+    });
+};

package/dist/src/helpers/install-dependencies.js

@@ -0,0 +1,67 @@
+import { spawn } from 'child_process';
+import color from 'picocolors';
+import { getOnline } from './is-online.js';
+export const installDependencies = async ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split('@')[0];
+    const isOnline = await getOnline();
+    const args = ['install'];
+    if (!isOnline) {
+        console.log(color.yellow('You appear to be offline.\nFalling back to the local cache.'));
+        args.push('--offline');
+    }
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        const child = spawn(packageManager, args, {
+            stdio: 'pipe',
+            cwd,
+            env: {
+                ...process.env,
+                ADBLOCK: '1',
+                NODE_ENV: 'development',
+                DISABLE_OPENCOLLECTIVE: '1',
+            },
+        });
+        child.stdout?.on('data', (data) => {
+            const output = data.toString();
+            stdout += output;
+        });
+        child.stderr?.on('data', (data) => {
+            const output = data.toString();
+            stderr += output;
+        });
+        child.on('close', code => {
+            if (code !== 0) {
+                console.error(color.red(`\n❌ Installation failed with exit code: ${code}`));
+                if (stderr) {
+                    console.error(color.red('Error output:'));
+                    console.error(stderr);
+                }
+                if (stdout) {
+                    console.log(color.yellow('Standard output:'));
+                    console.log(stdout);
+                }
+                if (stderr.includes('ENOTFOUND') || stderr.includes('network')) {
+                    console.error(color.yellow('💡 Network error detected. Please check your internet connection.'));
+                }
+                else if (stderr.includes('EACCES') ||
+                    stderr.includes('permission denied')) {
+                    console.error(color.yellow('💡 Permission error detected. Try running with elevated privileges or check file permissions.'));
+                }
+                else if (stderr.includes('ENOSPC')) {
+                    console.error(color.yellow('💡 Disk space error detected. Please free up some disk space.'));
+                }
+                else if (stderr.includes('ERR_PNPM_PEER_DEP_ISSUES')) {
+                    console.error(color.yellow('💡 Peer dependency issues detected. Consider using --force flag or resolve conflicts manually.'));
+                }
+                reject(new Error(`Failed to install dependencies using ${packageManager}. Exit code: ${code}\n${stderr || stdout}`));
+                return;
+            }
+            resolve();
+        });
+        child.on('error', error => {
+            console.error(color.red(`❌ Failed to start ${packageManager}:`), error.message);
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}`));
+        });
+    });
+};

package/dist/src/helpers/is-folder-empty.js

@@ -0,0 +1,49 @@
+import { lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import colors from 'picocolors';
+export function isFolderEmpty(root, name) {
+    const validFiles = [
+        '.DS_Store',
+        '.git',
+        '.gitattributes',
+        '.gitignore',
+        '.gitlab-ci.yml',
+        '.hg',
+        '.hgcheck',
+        '.hgignore',
+        '.idea',
+        '.npmignore',
+        '.travis.yml',
+        'LICENSE',
+        'Thumbs.db',
+        'docs',
+        'mkdocs.yml',
+        'npm-debug.log',
+        'yarn-debug.log',
+        'yarn-error.log',
+        'yarnrc.yml',
+        '.yarn',
+    ];
+    const conflicts = readdirSync(root).filter(file => !validFiles.includes(file) &&
+        !file.endsWith('.iml'));
+    if (conflicts.length > 0) {
+        console.log(`The directory ${colors.green(name)} contains files that could conflict:\n`);
+        for (const file of conflicts) {
+            try {
+                const stats = lstatSync(join(root, file));
+                if (stats.isDirectory()) {
+                    console.log(`${colors.blue(file)}/`);
+                }
+                else {
+                    console.log(file);
+                }
+            }
+            catch {
+                console.log(file);
+            }
+        }
+        console.log('\nEither try using a new directory name, or remove the files listed above.\n');
+        return false;
+    }
+    return true;
+}

package/dist/src/helpers/is-online.js

@@ -0,0 +1,38 @@
+import { execSync } from 'child_process';
+import { lookup } from 'dns/promises';
+import { URL } from 'url';
+export async function getOnline() {
+    try {
+        await lookup('registry.yarnpkg.com');
+        return true;
+    }
+    catch {
+        const proxy = getProxy();
+        if (!proxy) {
+            return false;
+        }
+        const { hostname } = new URL(proxy);
+        if (!hostname) {
+            return false;
+        }
+        try {
+            await lookup(hostname);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function getProxy() {
+    if (process.env.https_proxy) {
+        return process.env.https_proxy;
+    }
+    try {
+        const httpsProxy = execSync('npm config get https-proxy').toString().trim();
+        return httpsProxy !== 'null' ? httpsProxy : undefined;
+    }
+    catch {
+        return;
+    }
+}

package/dist/src/helpers/is-writeable.js

@@ -0,0 +1,11 @@
+import { W_OK } from 'constants';
+import { access } from 'fs/promises';
+export async function isWriteable(directory) {
+    try {
+        await access(directory, W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/helpers/packages-json.js

@@ -0,0 +1 @@
+export {};

package/dist/src/helpers/validate-pkg.js

@@ -0,0 +1,14 @@
+import validateProjectName from 'validate-npm-package-name';
+export const validateNpmName = ({ name, }) => {
+    const nameValidation = validateProjectName(name);
+    if (nameValidation.validForNewPackages) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        problems: [
+            ...(nameValidation.errors ?? []),
+            ...(nameValidation.warnings ?? []),
+        ],
+    };
+};

package/dist/src/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { input } from '@inquirer/prompts';
+import { Command, Option } from 'commander';
+import { basename, resolve } from 'path';
+import color from 'picocolors';
+import { createVitNode } from './create/create-vitnode.js';
+import { packageJson } from './helpers/get-package-json.js';
+import { validateNpmName } from './helpers/validate-pkg.js';
+import { createPlugin } from './plugin/index.js';
+import { createQuestionsCli } from './questions.js';
+import { validationProject } from './validation.js';
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 20) {
+    console.error(color.red(`\nError: VitNode requires Node.js version 20 or higher.\nYou are currently using Node.js ${process.versions.node}\n`));
+    process.exit(1);
+}
+process.on('uncaughtException', (error) => {
+    if (error.name === 'ExitPromptError') {
+        console.log(color.dim('👋 VitNode setup cancelled - see you next time!'));
+        process.exit(0);
+    }
+    console.error(color.red('An unexpected error occurred:'));
+    console.error(color.red(error.stack ?? error.message));
+    process.exit(1);
+});
+const init = async () => {
+    let projectPath = '';
+    const program = new Command()
+        .version(packageJson.version)
+        .argument('[project-directory]')
+        .usage(`${color.green('[project-directory]')} [options]`)
+        .action(name => {
+        projectPath = name;
+    });
+    program.addOption(new Option('--package-manager <package-manager>', 'Specify the package manager to use').choices(['npm', 'pnpm', 'bun']));
+    program.option('--eslint', 'Initialize with eslint config.');
+    program.option('--skip-install', 'Skip installing packages after initializing the project.');
+    program.option('--plugin', 'Enable plugin mode.');
+    program.parse(process.argv);
+    const opts = program.opts();
+    if (opts.plugin) {
+        await createPlugin(projectPath);
+        return;
+    }
+    if (!projectPath) {
+        projectPath = await input({
+            message: 'What is your project named?',
+            default: 'my-vitnode',
+            validate: (name) => {
+                const validation = validateNpmName({ name: basename(resolve(name)) });
+                if (validation.valid)
+                    return true;
+                return `Invalid project name: ${validation.problems[0]}`;
+            },
+        });
+    }
+    const { appName, root } = await validationProject(projectPath);
+    const options = await createQuestionsCli(program);
+    await createVitNode({
+        appName,
+        root,
+        ...options,
+    });
+};
+await init();

package/dist/src/plugin/index.js

@@ -0,0 +1,18 @@
+import { input } from '@inquirer/prompts';
+import { basename, resolve } from 'path';
+import { validateNpmName } from '../helpers/validate-pkg.js';
+export const createPlugin = async (projectPath) => {
+    let name = projectPath;
+    if (!name) {
+        name = await input({
+            message: 'What is your plugin named?',
+            default: 'my-vitnode-plugin',
+            validate: (name) => {
+                const validation = validateNpmName({ name: basename(resolve(name)) });
+                if (validation.valid)
+                    return true;
+                return `Invalid plugin name: ${validation.problems[0]}`;
+            },
+        });
+    }
+};

package/dist/src/prepare/prepare.js

@@ -0,0 +1,16 @@
+import { existsSync } from 'fs';
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+const prepare = async () => {
+    const toRootPath = join(process.cwd(), 'copy-of-vitnode-app');
+    if (!existsSync(toRootPath)) {
+        await mkdir(toRootPath);
+    }
+    const fromRootPath = join(process.cwd(), '..', '..', 'apps', 'docs');
+    if (!existsSync(fromRootPath)) {
+        console.error(`\x1b[31mThe path ${fromRootPath} does not exist. Please check the directory structure.\x1b[0m`);
+        process.exit(1);
+    }
+    console.log(`Project path: ${fromRootPath}`);
+};
+void prepare();

package/dist/src/questions.js

@@ -0,0 +1,52 @@
+import { select } from '@inquirer/prompts';
+import { confirm } from '@inquirer/prompts';
+import color from 'picocolors';
+import { getAvailablePackageManagers } from './helpers/get-available-package-managers.js';
+export const createQuestionsCli = async (program) => {
+    const optionsFromProgram = program.opts();
+    const options = {
+        packageManager: optionsFromProgram.packageManager,
+        eslint: optionsFromProgram.eslint,
+        install: !optionsFromProgram.skipInstall,
+        docker: optionsFromProgram.docker,
+    };
+    if (!optionsFromProgram.packageManager) {
+        const availablePackageManagers = await getAvailablePackageManagers();
+        options.packageManager = await select({
+            message: `Which ${color.blue('package manager')} do you want to use?`,
+            choices: [
+                {
+                    name: `npm${availablePackageManagers.npm ? `@${availablePackageManagers.npm}` : ''}`,
+                    value: 'npm',
+                    disabled: !availablePackageManagers.npm,
+                },
+                {
+                    name: `pnpm${availablePackageManagers.pnpm ? `@${availablePackageManagers.pnpm}` : ''}`,
+                    value: 'pnpm',
+                    disabled: !availablePackageManagers.pnpm,
+                },
+                {
+                    name: `bun${availablePackageManagers.bun ? `@${availablePackageManagers.bun}` : ''}`,
+                    value: 'bun',
+                    disabled: !availablePackageManagers.bun,
+                },
+            ],
+        });
+    }
+    if (optionsFromProgram.eslint === undefined) {
+        options.eslint = await confirm({
+            message: `Would you like to use ${color.blue('ESLint')}?`,
+        });
+    }
+    if (optionsFromProgram.docker === undefined) {
+        options.docker = await confirm({
+            message: `Would you like to use ${color.blue('Docker Container')}?`,
+        });
+    }
+    if (optionsFromProgram.skipInstall === undefined) {
+        options.install = await confirm({
+            message: `Would you like to ${color.blue('Install dependencies')}?`,
+        });
+    }
+    return options;
+};

package/dist/src/validation.js

@@ -0,0 +1,40 @@
+import { program } from 'commander';
+import { existsSync } from 'fs';
+import { basename, dirname, resolve } from 'path';
+import color from 'picocolors';
+import { isFolderEmpty } from './helpers/is-folder-empty.js';
+import { isWriteable } from './helpers/is-writeable.js';
+import { validateNpmName } from './helpers/validate-pkg.js';
+export const validationProject = async (projectPath) => {
+    if (!projectPath) {
+        console.log('\nPlease specify the project directory:\n' +
+            `  ${color.cyan(program.name())} ${color.green('<project-directory>')}\n` +
+            'For example:\n' +
+            `  ${color.cyan(program.name())} ${color.green('my-vitnode-app')}\n\n` +
+            `Run ${color.cyan(`${program.name()} --help`)} to see all options.`);
+        process.exit(1);
+    }
+    const resolvedProjectPath = resolve(projectPath);
+    const projectName = basename(resolvedProjectPath);
+    const validation = validateNpmName({ name: projectName });
+    if (!validation.valid) {
+        console.error(`Could not create a project called ${color.red(`"${projectName}"`)} because of npm naming restrictions:`);
+        validation.problems.forEach(p => {
+            console.error(`${color.red(color.bold('*'))} ${p}`);
+        });
+        process.exit(1);
+    }
+    const root = resolve(resolvedProjectPath);
+    const appName = basename(root);
+    const folderExists = existsSync(root);
+    if (folderExists && !isFolderEmpty(root, appName)) {
+        console.error('The specified directory is not empty.');
+        process.exit(1);
+    }
+    if (!(await isWriteable(dirname(root)))) {
+        console.error('The application path is not writable, please check folder permissions and try again.');
+        console.error('It is likely you do not have write permissions for this folder.');
+        process.exit(1);
+    }
+    return { appName, root };
+};