create-vitnode-app 1.2.0-canary.9 → 2.0.0-canary.10

package/dist/src/helpers/get-package-manager-from-root.js

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+export const getPackageManagerFromRoot = (rootPath) => {
+    try {
+        const packageJsonPath = join(rootPath, "package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.packageManager) {
+            return packageJson.packageManager.split("@")[0];
+        }
+        return "npm";
+    }
+    catch {
+        return "npm";
+    }
+};

package/dist/src/helpers/get-vitnode-package-version.js

@@ -0,0 +1,9 @@
+import { readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const getVitnodePackageVersion = async () => {
+    const cliPkg = JSON.parse(await readFile(join(__dirname, "..", "..", "..", "package.json"), "utf-8"));
+    return `^${cliPkg.version}`;
+};

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

@@ -0,0 +1,38 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { spawnCommand } from "./spawn-command.js";
+export const DEFAULT_GIT_BRANCH = "main";
+const runGit = async (args, cwd) => new Promise(resolve => {
+    const child = spawnCommand("git", args, { cwd, stdio: "ignore" });
+    child.on("error", () => {
+        resolve(false);
+    });
+    child.on("close", code => {
+        resolve(code === 0);
+    });
+});
+export const initGitRepository = async ({ root, branch = DEFAULT_GIT_BRANCH, commitMessage = "Initial commit from Create VitNode App", }) => {
+    if (!(await runGit(["--version"], root))) {
+        return "git-unavailable";
+    }
+    if (await runGit(["rev-parse", "--is-inside-work-tree"], root)) {
+        return "already-in-repository";
+    }
+    const removeGitDirectory = async () => {
+        await rm(join(root, ".git"), { force: true, recursive: true });
+    };
+    const initialized = (await runGit(["init", "--initial-branch", branch], root)) ||
+        ((await runGit(["init"], root)) &&
+            (await runGit(["symbolic-ref", "HEAD", `refs/heads/${branch}`], root)));
+    if (!initialized) {
+        await removeGitDirectory();
+        return "failed";
+    }
+    const committed = (await runGit(["add", "-A"], root)) &&
+        (await runGit(["commit", "-m", commitMessage], root));
+    if (!committed) {
+        await removeGitDirectory();
+        return "failed";
+    }
+    return "created";
+};

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

@@ -0,0 +1,33 @@
+import color from "picocolors";
+import { spawnCommand } from "./spawn-command.js";
+export const generateMigrationsVitnode = async ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split("@")[0];
+    const args = ["vitnode", "migrate", "--generate"];
+    await new Promise((resolve, reject) => {
+        let output = "";
+        const child = spawnCommand(packageManager, args, {
+            cwd,
+            env: process.env,
+            stdio: "pipe",
+        });
+        child.stdout?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.on("error", error => {
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}\nRun "${packageManager} vitnode db:prepare" in the new project once your database is running.`));
+        });
+        child.on("close", code => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            if (output.trim().length > 0) {
+                console.error(color.red(output.trim()));
+            }
+            reject(new Error(`"${packageManager} vitnode migrate --generate" exited with code ${String(code)}. Your project was created - run "${packageManager} dev" once your database is running and it will migrate itself.`));
+        });
+    });
+};

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

@@ -1,30 +1,70 @@
-import { spawn } from 'child_process';
-import color from 'picocolors';
-import { getOnline } from './is-online.js';
-export const installDependencies = async ({ packageManager: pm, }) => {
-    const packageManager = pm.split('@')[0];
+import consoleColor from "picocolors";
+import { getOnline } from "./is-online.js";
+import { spawnCommand } from "./spawn-command.js";
+function printInstallErrorSuggestions(stderr, color) {
+    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."));
+    }
+}
+export const installDependencies = async ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split("@")[0];
     const isOnline = await getOnline();
-    const args = packageManager === 'npm' ? ['install', '--force'] : ['install'];
+    const args = ["install"];
     if (!isOnline) {
-        console.log(color.yellow('You appear to be offline.\nFalling back to the local cache.'));
-        args.push('--offline');
+        console.log(consoleColor.yellow("You appear to be offline.\nFalling back to the local cache."));
+        args.push("--offline");
     }
     return new Promise((resolve, reject) => {
-        const child = spawn(packageManager, args, {
-            stdio: 'ignore',
+        let stdout = "";
+        let stderr = "";
+        const child = spawnCommand(packageManager, args, {
+            stdio: "pipe",
+            cwd,
             env: {
                 ...process.env,
-                ADBLOCK: '1',
-                NODE_ENV: 'development',
-                DISABLE_OPENCOLLECTIVE: '1',
+                ADBLOCK: "1",
+                NODE_ENV: "development",
+                DISABLE_OPENCOLLECTIVE: "1",
             },
         });
-        child.on('close', code => {
+        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) {
-                reject({ command: `${packageManager} ${args.join(' ')}` });
+                console.error(consoleColor.red(`\n❌ Installation failed with exit code: ${code}`));
+                if (stderr) {
+                    console.error(consoleColor.red("Error output:"));
+                    console.error(stderr);
+                }
+                if (stdout) {
+                    console.log(consoleColor.yellow("Standard output:"));
+                    console.log(stdout);
+                }
+                printInstallErrorSuggestions(stderr, consoleColor);
+                reject(new Error(`Failed to install dependencies using ${packageManager}. Exit code: ${code}\n${stderr || stdout}`));
                 return;
             }
             resolve();
         });
+        child.on("error", error => {
+            console.error(consoleColor.red(`❌ Failed to start ${packageManager}:`), error.message);
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}`));
+        });
     });
 };

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

@@ -1,31 +1,30 @@
-import { lstatSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import colors from 'picocolors';
+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',
+        ".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'));
+    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) {
@@ -42,7 +41,7 @@ export function isFolderEmpty(root, name) {
                 console.log(file);
             }
         }
-        console.log('\nEither try using a new directory name, or remove the files listed above.\n');
+        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

@@ -1,9 +1,21 @@
-import { execSync } from 'child_process';
-import { lookup } from 'dns/promises';
-import { URL } from 'url';
+import { execSync } from "node:child_process";
+import { lookup } from "node:dns/promises";
+import { URL } from "node:url";
+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;
+    }
+}
 export async function getOnline() {
     try {
-        await lookup('registry.yarnpkg.com');
+        await lookup("registry.yarnpkg.com");
         return true;
     }
     catch {
@@ -24,15 +36,3 @@ export async function getOnline() {
         }
     }
 }
-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

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

package/dist/src/helpers/spawn-command.js

@@ -0,0 +1,7 @@
+import { spawn } from "node:child_process";
+export const spawnCommand = (command, args = [], options = {}) => {
+    const spawnOptions = { ...options, shell: false };
+    return process.platform === "win32"
+        ? spawn("cmd.exe", ["/c", command, ...args], spawnOptions)
+        : spawn(command, args, spawnOptions);
+};

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

@@ -1,4 +1,4 @@
-import validateProjectName from 'validate-npm-package-name';
+import validateProjectName from "validate-npm-package-name";
 export const validateNpmName = ({ name, }) => {
     const nameValidation = validateProjectName(name);
     if (nameValidation.validForNewPackages) {

package/dist/src/helpers/with-If.js

@@ -0,0 +1 @@
+export const withIf = (cond, obj) => (cond ? obj : {});

package/dist/src/index.js

@@ -1,51 +1,55 @@
 #!/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);
+import { input } from "@inquirer/prompts";
+import { Command, Option } from "commander";
+import { basename, resolve } from "node: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.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("An unexpected error occurred:"));
     console.error(color.red(error.stack ?? error.message));
     process.exit(1);
 });
 const init = async () => {
-    let projectPath = '';
+    let projectPath = "";
     const program = new Command()
-        .version(packageJson.version)
-        .argument('[project-directory]')
-        .usage(`${color.green('[project-directory]')} [options]`)
+        .version(packageJson.version ?? "0.1.0")
+        .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.addOption(new Option("--package-manager <package-manager>", "Specify the package manager to use").choices(["npm", "pnpm", "bun"]));
+    program.option("--eslint", "Initialize with ESLint & Prettier config.");
+    program.option("--skip-install", "Skip installing packages after initializing the project.");
+    program.option("--skip-git", "Skip initializing a git repository in the project.");
+    program.addOption(new Option("--mode <mode>", "What type of app do you want to create?").choices(["singleApp", "apiMonorepo", "onlyApi"]));
+    program.option("--monorepo", "Create project with monorepo structure.");
+    program.option("--docker", "Initialize with Docker support.");
+    program.option("--plugin", "Create a plugin.");
     program.parse(process.argv);
     const opts = program.opts();
     if (opts.plugin) {
-        await createPlugin(projectPath);
+        await createPlugin({ projectPath, program });
         return;
     }
     if (!projectPath) {
         projectPath = await input({
-            message: 'What is your project named?',
-            default: 'my-vitnode',
+            message: "What is your project named?",
+            default: "my-vitnode",
             validate: (name) => {
                 const validation = validateNpmName({ name: basename(resolve(name)) });
                 if (validation.valid)

package/dist/src/plugin/create/add-plugin-to-config.js

@@ -0,0 +1,231 @@
+import { readdir, readFile, writeFile } from "fs/promises";
+import { basename, dirname, join } from "path";
+import { pluginApiVariableName, pluginVariableName, } from "./route-templates.js";
+const SKIPPED_DIRECTORIES = new Set([
+    ".git",
+    ".next",
+    ".nitro",
+    ".output",
+    ".turbo",
+    ".vercel",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+]);
+const CONFIG_BUILDERS = {
+    "vitnode.api.config.ts": {
+        builder: "buildApiConfig",
+        subpath: "config.api",
+    },
+    "vitnode.config.ts": { builder: "buildConfig", subpath: "config" },
+};
+const endOfStringLiteral = (source, start) => {
+    const quote = source[start];
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+            index += 2;
+            continue;
+        }
+        if (char === quote)
+            return index + 1;
+        index += 1;
+    }
+    return source.length;
+};
+const closingBracketOf = (source, open) => {
+    let depth = 0;
+    let index = open;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === "/" && source[index + 1] === "/") {
+            const newline = source.indexOf("\n", index);
+            index = newline === -1 ? source.length : newline;
+            continue;
+        }
+        if (char === "/" && source[index + 1] === "*") {
+            const end = source.indexOf("*/", index + 2);
+            index = end === -1 ? source.length : end + 2;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            index = endOfStringLiteral(source, index);
+            continue;
+        }
+        if (char === "[" || char === "(" || char === "{") {
+            depth += 1;
+        }
+        else if (char === "]" || char === ")" || char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return char === "]" ? index : -1;
+        }
+        index += 1;
+    }
+    return -1;
+};
+const findPluginsArray = (source, from) => {
+    const key = /\bplugins\s*:\s*\[/g;
+    key.lastIndex = from;
+    const match = key.exec(source);
+    if (!match)
+        return null;
+    const open = match.index + match[0].length - 1;
+    const close = closingBracketOf(source, open);
+    return close === -1 ? null : { close, open };
+};
+const readImports = (source) => {
+    const statements = [];
+    let offset = 0;
+    let open = null;
+    for (const line of source.split("\n")) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        open ??= /^import\b/.test(line)
+            ? { isType: /^import\s+type\b/.test(line), start: lineStart }
+            : null;
+        if (!open)
+            continue;
+        const specifier = /\bfrom\s+['"]([^'"]+)['"]/.exec(line)?.[1] ??
+            /^import\s+['"]([^'"]+)['"]/.exec(line)?.[1];
+        if (specifier === undefined)
+            continue;
+        const end = lineStart + line.length;
+        statements.push({
+            end,
+            isType: open.isType,
+            specifier,
+            start: open.start,
+            text: source.slice(open.start, end),
+        });
+        open = null;
+    }
+    return statements;
+};
+const importStyleOf = (source) => {
+    const match = /\bfrom\s+(['"])[^'"\n]+\1(;?)/.exec(source);
+    return { quote: match?.[1] ?? '"', semicolon: match?.[2] ?? ";" };
+};
+const withImport = (source, { factory, module }) => {
+    const { quote, semicolon } = importStyleOf(source);
+    const statement = `import { ${factory} } from ${quote}${module}${quote}${semicolon}`;
+    const imports = readImports(source);
+    if (imports.length === 0) {
+        return `${statement}\n\n${source}`;
+    }
+    const before = imports.find(entry => !entry.isType && entry.specifier > module);
+    if (before) {
+        return `${source.slice(0, before.start)}${statement}\n${source.slice(before.start)}`;
+    }
+    const last = imports[imports.length - 1];
+    return `${source.slice(0, last.end)}\n${statement}${source.slice(last.end)}`;
+};
+const withEntry = (source, { close, open }, call) => {
+    const body = source.slice(open + 1, close);
+    const head = source.slice(0, open + 1);
+    const tail = source.slice(close);
+    if (body.trim() === "") {
+        if (!body.includes("\n"))
+            return `${head}${call}${tail}`;
+        const indent = /\n([ \t]*)$/.exec(body)?.[1] ?? "";
+        return `${head}\n${indent}  ${call},${body}${tail}`;
+    }
+    if (!body.includes("\n")) {
+        const separator = body.trimEnd().endsWith(",") ? " " : ", ";
+        return `${head}${body}${separator}${call}${tail}`;
+    }
+    const entries = body.trimEnd();
+    const trailing = body.slice(entries.length);
+    const indent = /^[ \t]*(?=\S)/m.exec(body.slice(body.indexOf("\n") + 1))?.[0] ?? "  ";
+    const comma = entries.endsWith(",") ? "" : ",";
+    return `${head}${entries}${comma}\n${indent}${call},${trailing}${tail}`;
+};
+export const registerPluginInSource = (source, { builder, factory, module }) => {
+    const builderAt = source.indexOf(`${builder}(`);
+    if (builderAt === -1)
+        return { source, status: "no-config-call" };
+    const range = findPluginsArray(source, builderAt);
+    if (!range)
+        return { source, status: "no-plugins-array" };
+    const called = new RegExp(`\\b${factory}\\s*\\(`);
+    const hasEntry = called.test(source.slice(range.open + 1, range.close));
+    const hasImport = readImports(source).some(entry => entry.specifier === module &&
+        new RegExp(`\\b${factory}\\b`).test(entry.text));
+    if (hasEntry && hasImport)
+        return { source, status: "already-registered" };
+    const withCall = hasEntry ? source : withEntry(source, range, `${factory}()`);
+    return {
+        source: hasImport ? withCall : withImport(withCall, { factory, module }),
+        status: "registered",
+    };
+};
+const readEntries = async (dir) => {
+    try {
+        return await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
+const findConfigFiles = async (dir, skipDir, results = []) => {
+    for (const entry of await readEntries(dir)) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (SKIPPED_DIRECTORIES.has(entry.name) || fullPath === skipDir)
+                continue;
+            await findConfigFiles(fullPath, skipDir, results);
+            continue;
+        }
+        if (entry.isFile() && CONFIG_BUILDERS[entry.name]) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+};
+const ownedByVitNodePackage = async (file, rootPath) => {
+    let current = dirname(file);
+    while (current.startsWith(rootPath)) {
+        try {
+            const pkg = JSON.parse(await readFile(join(current, "package.json"), "utf-8"));
+            return Boolean(pkg.dependencies?.["@vitnode/core"] ??
+                pkg.devDependencies?.["@vitnode/core"]);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return false;
+            current = parent;
+        }
+    }
+    return false;
+};
+export const addPluginToConfig = async ({ pluginName, pluginPath, rootPath, }) => {
+    const files = await findConfigFiles(rootPath, pluginPath);
+    const registrations = [];
+    for (const file of files.sort()) {
+        if (!(await ownedByVitNodePackage(file, rootPath)))
+            continue;
+        const target = CONFIG_BUILDERS[basename(file)];
+        const isApi = target.subpath === "config.api";
+        try {
+            const source = await readFile(file, "utf-8");
+            const { source: next, status } = registerPluginInSource(source, {
+                builder: target.builder,
+                factory: isApi
+                    ? pluginApiVariableName(pluginName)
+                    : pluginVariableName(pluginName),
+                module: `${pluginName}/${target.subpath}`,
+            });
+            if (status === "registered") {
+                await writeFile(file, next, "utf-8");
+            }
+            registrations.push({ file, status });
+        }
+        catch {
+            continue;
+        }
+    }
+    return registrations;
+};