create-nattyjs 0.0.1-beta.69 → 0.0.1-beta.71

package/src/functions/cli-theme.js

@@ -0,0 +1,81 @@
+import path from "path";
+import { bold, cyan, dim, green, yellow } from "kolorist";
+
+export function printIntro() {
+    console.log("");
+    console.log(bold(cyan("NattyJS Create")));
+    console.log(dim("Scaffold a typed API or a fullstack workspace."));
+    console.log("");
+}
+
+export function formatTemplateChoice(template) {
+    const titleColor = template.id === "api-only" ? green : cyan;
+    const badge = template.id === "api-only" ? green("API") : cyan("FULLSTACK");
+    return {
+        title: `${bold(titleColor(template.title))} ${dim(badge)}`,
+        description: dim(template.description),
+    };
+}
+
+export function formatLayoutChoice(layout) {
+    const isRecommended = layout.recommended === true;
+    const title = isRecommended
+        ? `${bold(green(layout.title))} ${dim("(recommended)")}`
+        : bold(cyan(layout.title));
+
+    return {
+        title,
+        description: dim(layout.description),
+    };
+}
+
+export function formatWorkspaceChoice(workspace) {
+    const isRecommended = workspace.recommended === true;
+    const title = isRecommended
+        ? `${bold(yellow(workspace.title))} ${dim("(recommended)")}`
+        : bold(cyan(workspace.title));
+
+    return {
+        title,
+        description: dim(workspace.description),
+    };
+}
+
+export function formatSuccessSummary({
+    cwd,
+    root,
+    packageManager,
+    template,
+    workspace,
+    includeExamples,
+}) {
+    const activePackageManager = packageManager;
+    const relativeRoot = root === cwd ? "." : path.relative(cwd, root);
+    const isStandalone = workspace?.id === "standalone";
+
+    console.log("");
+    console.log(`${bold(green("Success"))} ${dim("Project scaffolded.")}`);
+    console.log(`${bold("Location")} ${relativeRoot}`);
+    console.log(`${bold("Template")} ${template.title}`);
+    if (workspace) {
+        console.log(`${bold("Layout")} ${workspace.title}`);
+    }
+    console.log(`${bold("Examples")} ${includeExamples ? "Yes" : "No"}`);
+    console.log("");
+    console.log(bold(cyan("Next Steps")));
+    if (root !== cwd) {
+        console.log(`  cd ${relativeRoot}`);
+    }
+    if (activePackageManager === "yarn") {
+        console.log("  yarn");
+        console.log("  yarn dev");
+        console.log("");
+        return;
+    }
+    console.log(`  ${activePackageManager} install`);
+    if (isStandalone) {
+        console.log(`  ${activePackageManager} run install:apps`);
+    }
+    console.log(`  ${activePackageManager} run dev`);
+    console.log("");
+}

package/src/functions/file-system.js

@@ -0,0 +1,96 @@
+import fs from "fs";
+import path from "path";
+
+const renameFiles = {
+    _gitignore: ".gitignore",
+};
+
+export function readJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+export function isEmpty(dirPath) {
+    const files = fs.readdirSync(dirPath);
+    return files.length === 0 || (files.length === 1 && files[0] === ".git");
+}
+
+export function emptyDir(dir) {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
+
+    for (const file of fs.readdirSync(dir)) {
+        const absolutePath = path.resolve(dir, file);
+        if (fs.lstatSync(absolutePath).isDirectory()) {
+            emptyDir(absolutePath);
+            fs.rmdirSync(absolutePath);
+        } else {
+            fs.unlinkSync(absolutePath);
+        }
+    }
+}
+
+export function copy(src, dest) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        copyDir(src, dest);
+        return;
+    }
+
+    fs.copyFileSync(src, dest);
+}
+
+export function copyDir(srcDir, destDir) {
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const file of fs.readdirSync(srcDir)) {
+        const srcFile = path.resolve(srcDir, file);
+        const destFile = path.resolve(destDir, file);
+        copy(srcFile, destFile);
+    }
+}
+
+export function shouldSkipTemplateFile(relativePath, template, includeExamples) {
+    if (includeExamples) {
+        return false;
+    }
+
+    const excludedPaths = template.exampleExcludedPaths || [];
+    return excludedPaths.some((excludedPath) => {
+        return relativePath === excludedPath || relativePath.startsWith(`${excludedPath}${path.sep}`);
+    });
+}
+
+export function copyTemplateContents(templateDir, root, template, includeExamples) {
+    const entries = fs.readdirSync(templateDir);
+    for (const entry of entries) {
+        if (entry === "package.json") {
+            continue;
+        }
+
+        if (entry === template.exampleOverlayDir) {
+            continue;
+        }
+
+        if (shouldSkipTemplateFile(entry, template, includeExamples)) {
+            continue;
+        }
+
+        const sourcePath = path.join(templateDir, entry);
+        const targetPath = renameFiles[entry]
+            ? path.join(root, renameFiles[entry])
+            : path.join(root, entry);
+
+        copy(sourcePath, targetPath);
+    }
+
+    if (includeExamples && template.exampleOverlayDir) {
+        const overlayDir = path.join(templateDir, template.exampleOverlayDir);
+        if (fs.existsSync(overlayDir)) {
+            copyDir(overlayDir, root);
+        }
+    }
+}

package/src/functions/package-manager.js

@@ -0,0 +1,9 @@
+export function pkgFromUserAgent(userAgent) {
+    if (!userAgent) {
+        return undefined;
+    }
+
+    const pkgSpec = userAgent.split(" ")[0];
+    const [name, version] = pkgSpec.split("/");
+    return { name, version };
+}

package/src/functions/package-name.js

@@ -0,0 +1,12 @@
+export function isValidPackageName(projectName) {
+    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(projectName);
+}
+
+export function toValidPackageName(projectName) {
+    return projectName
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/^[._]/, "")
+        .replace(/[^a-z0-9-~]+/g, "-");
+}

package/src/functions/prompt-project-options.js

@@ -0,0 +1,156 @@
+import fs from "fs";
+import path from "path";
+import prompts from "prompts";
+import { red, reset } from "kolorist";
+import {
+    getWorkspaceById,
+    isFullstackTemplate,
+    MONOREPO_WORKSPACE_DEFINITIONS,
+    PROJECT_LAYOUT_DEFINITIONS,
+} from "../const/workspace-definitions.js";
+import { formatLayoutChoice, formatTemplateChoice, formatWorkspaceChoice } from "./cli-theme.js";
+import { isEmpty } from "./file-system.js";
+import { isValidPackageName, toValidPackageName } from "./package-name.js";
+
+export async function resolveProjectOptions({
+    argv,
+    defaultProjectName,
+    selectedTemplate,
+    templateDefinitions,
+    examplesFlagProvided,
+}) {
+    let targetDir = typeof argv._[0] === "string" ? argv._[0].trim() : "";
+    let selectedWorkspace = getWorkspaceById(argv.workspace);
+    let activeTemplate = selectedTemplate;
+
+    try {
+        const response = await prompts(
+            [
+                {
+                    type: targetDir ? null : "text",
+                    name: "projectName",
+                    message: reset("Project name:"),
+                    initial: defaultProjectName,
+                    validate: (value) => {
+                        const trimmed = value.trim();
+                        return trimmed.length > 0 || "Project name is required";
+                    },
+                    onState: (state) => {
+                        targetDir = state.value.trim() || defaultProjectName;
+                    },
+                },
+                {
+                    type: () => {
+                        return !targetDir || !fs.existsSync(targetDir) || isEmpty(targetDir) ? null : "confirm";
+                    },
+                    name: "overwrite",
+                    message: () => {
+                        const label = targetDir === "." ? "Current directory" : `Target directory "${targetDir}"`;
+                        return `${label} is not empty. Remove existing files and continue?`;
+                    },
+                    initial: false,
+                },
+                {
+                    type: (_, { overwrite } = {}) => {
+                        if (overwrite === false) {
+                            throw new Error(`${red("x")} Operation cancelled`);
+                        }
+                        return null;
+                    },
+                    name: "overwriteChecker",
+                },
+                {
+                    type: () => (isValidPackageName(path.basename(targetDir || defaultProjectName)) ? null : "text"),
+                    name: "packageName",
+                    message: reset("Package name:"),
+                    initial: () => toValidPackageName(path.basename(targetDir || defaultProjectName)),
+                    validate: (value) => isValidPackageName(value) || "Invalid package.json name",
+                },
+                {
+                    type: selectedTemplate ? null : "select",
+                    name: "templateId",
+                    message: reset("Select a template:"),
+                    choices: templateDefinitions.map((template) => {
+                        const formattedChoice = formatTemplateChoice(template);
+                        return {
+                            title: formattedChoice.title,
+                            description: formattedChoice.description,
+                            value: template.id,
+                        };
+                    }),
+                    onState: (state) => {
+                        activeTemplate =
+                            templateDefinitions.find((template) => template.id === state.value) ||
+                            selectedTemplate;
+                    },
+                },
+                {
+                    type: (_, values) => {
+                        activeTemplate =
+                            selectedTemplate ||
+                            templateDefinitions.find((template) => template.id === values.templateId);
+                        return !selectedWorkspace && isFullstackTemplate(activeTemplate) ? "select" : null;
+                    },
+                    name: "projectLayout",
+                    message: reset("Select project shape:"),
+                    choices: PROJECT_LAYOUT_DEFINITIONS.map((layout) => {
+                        const formattedChoice = formatLayoutChoice(layout);
+                        return {
+                            title: formattedChoice.title,
+                            description: formattedChoice.description,
+                            value: layout.id,
+                        };
+                    }),
+                    initial: 0,
+                },
+                {
+                    type: (_, values) => {
+                        activeTemplate =
+                            selectedTemplate ||
+                            templateDefinitions.find((template) => template.id === values.templateId);
+                        if (selectedWorkspace || !isFullstackTemplate(activeTemplate)) {
+                            return null;
+                        }
+                        return values.projectLayout === "monorepo" ? "select" : null;
+                    },
+                    name: "workspaceSetup",
+                    message: reset("Select monorepo tool:"),
+                    choices: MONOREPO_WORKSPACE_DEFINITIONS.map((workspace) => {
+                        const formattedChoice = formatWorkspaceChoice(workspace);
+                        return {
+                            title: formattedChoice.title,
+                            description: formattedChoice.description,
+                            value: workspace.id,
+                        };
+                    }),
+                    initial: 0,
+                },
+                {
+                    type: examplesFlagProvided ? null : "toggle",
+                    name: "includeExamples",
+                    message: reset("Include examples?"),
+                    initial: true,
+                    active: "Yes",
+                    inactive: "No",
+                },
+            ],
+            {
+                onCancel: () => {
+                    throw new Error(`${red("x")} Operation cancelled`);
+                },
+            }
+        );
+
+        const resolvedTemplate =
+            activeTemplate ||
+            templateDefinitions.find((template) => template.id === response.templateId);
+        if (isFullstackTemplate(resolvedTemplate) && !selectedWorkspace && response.projectLayout === "standalone") {
+            response.workspaceSetup = "standalone";
+        }
+
+        return response;
+    } catch (error) {
+        console.log(error.message);
+        return undefined;
+    }
+}

package/src/functions/render-package-jsons.js

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+import { getVersionRegistry } from "../const/version-registry.js";
+import { applyStandaloneSetup, applyWorkspaceSetup } from "./render-workspace.js";
+
+const DEPENDENCY_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+
+function collectPackageJsonPaths(root) {
+    const packageJsonPaths = [];
+
+    function walk(currentPath) {
+        for (const entry of fs.readdirSync(currentPath, { withFileTypes: true })) {
+            if (entry.name === "node_modules") {
+                continue;
+            }
+
+            const absolutePath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                walk(absolutePath);
+                continue;
+            }
+
+            if (entry.isFile() && entry.name === "package.json") {
+                packageJsonPaths.push(absolutePath);
+            }
+        }
+    }
+
+    walk(root);
+    return packageJsonPaths;
+}
+
+function updateDependencyVersions(packageJson, versionRegistry) {
+    for (const fieldName of DEPENDENCY_FIELDS) {
+        const dependencyMap = packageJson[fieldName];
+        if (!dependencyMap) {
+            continue;
+        }
+
+        for (const dependencyName of Object.keys(dependencyMap)) {
+            if (versionRegistry.versions[dependencyName]) {
+                dependencyMap[dependencyName] = versionRegistry.versions[dependencyName];
+            }
+        }
+    }
+}
+
+export function renderProjectPackageJsons({
+    root,
+    packageBaseDir,
+    packageName,
+    isFullstack,
+    workspaceSetup,
+}) {
+    const versionRegistry = getVersionRegistry(packageBaseDir);
+    if (isFullstack && workspaceSetup === "standalone") {
+        const rootPackageJsonPath = path.join(root, "package.json");
+        const rootPackageJson = JSON.parse(fs.readFileSync(rootPackageJsonPath, "utf8"));
+        updateDependencyVersions(rootPackageJson, versionRegistry);
+        rootPackageJson.name = packageName;
+        applyStandaloneSetup({
+            root,
+            rootPackageJson,
+            versionRegistry,
+        });
+        fs.writeFileSync(rootPackageJsonPath, JSON.stringify(rootPackageJson, null, 2), "utf8");
+    }
+
+    const packageJsonPaths = collectPackageJsonPaths(root);
+    const rootPackageJsonPath = path.join(root, "package.json");
+
+    for (const packageJsonPath of packageJsonPaths) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+        updateDependencyVersions(packageJson, versionRegistry);
+
+        if (packageJsonPath === rootPackageJsonPath) {
+            packageJson.name = packageName;
+            if (isFullstack) {
+                if (workspaceSetup !== "standalone") {
+                    applyWorkspaceSetup({
+                        root,
+                        rootPackageJson: packageJson,
+                        workspaceSetup,
+                        versionRegistry,
+                    });
+                }
+            }
+        }
+
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
+    }
+}