@aime-aatrick/create-fullstack-template 1.0.5 → 1.0.8

package/bin/create-fullstack-template.mjs

@@ -2,8 +2,9 @@
 
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile, copyFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { spawn } from "node:child_process";
 import degit from "degit";
@@ -58,10 +59,167 @@ const askPackageManager = async (rl) => {
   return "pnpm";
 };
 
+const readIfExists = async (path) => {
+  if (!existsSync(path)) return null;
+  return readFile(path, "utf8");
+};
+
+const shouldIgnoreRelativePath = (relativePath) => {
+  const normalized = relativePath.replaceAll("\\", "/");
+  if (
+    normalized === ".env" ||
+    normalized === ".env.local" ||
+    normalized === ".env.example" ||
+    normalized === "backend/.env" ||
+    normalized === "backend/.env.example" ||
+    normalized === "frontend/.env.local" ||
+    normalized === "frontend/.env.example"
+  ) {
+    return true;
+  }
+
+  const ignoredPathParts = [".git", "node_modules", ".next", "dist", "coverage", ".turbo"];
+  return ignoredPathParts.some(
+    (part) => normalized === part || normalized.startsWith(`${part}/`) || normalized.includes(`/${part}/`),
+  );
+};
+
+const syncTemplateTree = async (sourceDir, destinationDir, options) => {
+  const { force } = options;
+  const stats = {
+    copied: 0,
+    updated: 0,
+    skipped: 0,
+  };
+
+  const walk = async (sourcePath, destinationPath, relativePath = "") => {
+    if (shouldIgnoreRelativePath(relativePath)) return;
+
+    const sourceStat = await stat(sourcePath);
+    if (sourceStat.isDirectory()) {
+      if (!existsSync(destinationPath)) {
+        await mkdir(destinationPath, { recursive: true });
+      }
+      const entries = await readdir(sourcePath, { withFileTypes: true });
+      for (const entry of entries) {
+        const childSource = join(sourcePath, entry.name);
+        const childDestination = join(destinationPath, entry.name);
+        const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        await walk(childSource, childDestination, childRelative);
+      }
+      return;
+    }
+
+    if (!existsSync(destinationPath)) {
+      await mkdir(dirname(destinationPath), { recursive: true });
+      await copyFile(sourcePath, destinationPath);
+      stats.copied += 1;
+      return;
+    }
+
+    const sourceContent = await readFile(sourcePath);
+    const destinationContent = await readFile(destinationPath);
+    if (sourceContent.equals(destinationContent)) return;
+
+    if (!force) {
+      stats.skipped += 1;
+      return;
+    }
+
+    await writeFile(destinationPath, sourceContent);
+    stats.updated += 1;
+  };
+
+  await walk(sourceDir, destinationDir);
+  return stats;
+};
+
+const runUpdate = async (args) => {
+  const force = args.includes("--force");
+  const targetArg = args.find((value) => !value.startsWith("--")) || ".";
+  const targetDir = resolve(process.cwd(), targetArg);
+
+  if (!existsSync(targetDir)) {
+    throw new Error(`Target folder does not exist: ${targetDir}`);
+  }
+
+  const backendExists = existsSync(join(targetDir, "backend"));
+  const frontendExists = existsSync(join(targetDir, "frontend"));
+  if (!backendExists && !frontendExists) {
+    throw new Error(
+      'Target does not look like a generated project. Expected "backend" and/or "frontend" folders.',
+    );
+  }
+
+  const tempRoot = await mkdtemp(join(tmpdir(), "fullstack-template-update-"));
+  const templateDir = join(tempRoot, "template");
+
+  try {
+    console.log(`\nFetching latest template from ${REPO} ...`);
+    const emitter = degit(REPO, { cache: false, force: true, verbose: true });
+    await emitter.clone(templateDir);
+
+    await rm(join(templateDir, "create-fullstack-template"), { recursive: true, force: true });
+    await rm(join(templateDir, ".github"), { recursive: true, force: true });
+
+    const total = { copied: 0, updated: 0, skipped: 0 };
+
+    if (backendExists && existsSync(join(templateDir, "backend"))) {
+      console.log("Updating backend files...");
+      const backendStats = await syncTemplateTree(
+        join(templateDir, "backend"),
+        join(targetDir, "backend"),
+        { force },
+      );
+      total.copied += backendStats.copied;
+      total.updated += backendStats.updated;
+      total.skipped += backendStats.skipped;
+    }
+
+    if (frontendExists && existsSync(join(templateDir, "frontend"))) {
+      console.log("Updating frontend files...");
+      const frontendStats = await syncTemplateTree(
+        join(templateDir, "frontend"),
+        join(targetDir, "frontend"),
+        { force },
+      );
+      total.copied += frontendStats.copied;
+      total.updated += frontendStats.updated;
+      total.skipped += frontendStats.skipped;
+    }
+
+    const templateReadme = await readIfExists(join(templateDir, "README.md"));
+    if (templateReadme && (force || !existsSync(join(targetDir, "README.md")))) {
+      const readmeExists = existsSync(join(targetDir, "README.md"));
+      await writeFile(join(targetDir, "README.md"), templateReadme, "utf8");
+      if (readmeExists) {
+        total.updated += 1;
+      } else {
+        total.copied += 1;
+      }
+    } else if (templateReadme) {
+      total.skipped += 1;
+    }
+
+    console.log("\nUpdate complete.");
+    console.log(`- Copied new files: ${total.copied}`);
+    console.log(`- Updated files: ${total.updated}`);
+    console.log(`- Skipped conflicts (use --force to overwrite): ${total.skipped}`);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+};
+
 const main = async () => {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
 
   try {
+    const command = process.argv[2];
+    if (command === "update") {
+      await runUpdate(process.argv.slice(3));
+      return;
+    }
+
     const argName = process.argv[2];
     const projectName =
       argName || (await rl.question("Project name (folder): ")).trim();
@@ -115,6 +273,10 @@ const main = async () => {
     const emitter = degit(REPO, { cache: false, force: true, verbose: true });
     await emitter.clone(targetDir);
 
+    // Remove template-maintenance folders that should not ship in generated apps.
+    await rm(join(targetDir, "create-fullstack-template"), { recursive: true, force: true });
+    await rm(join(targetDir, ".github"), { recursive: true, force: true });
+
     if (mode === "backend") {
       await rm(join(targetDir, "frontend"), { recursive: true, force: true });
     } else if (mode === "frontend") {
@@ -189,13 +351,22 @@ const main = async () => {
     if (hasFrontend) {
       let frontendEnv = await readEnvTemplate(
         frontendEnvExample,
-        ["NEXT_PUBLIC_API_URL=http://localhost:3000", ""].join("\n"),
+        [
+          "NEXT_PUBLIC_API_URL=http://localhost:3000",
+          "NEXT_PUBLIC_DESIGN_MODE=false",
+          "",
+        ].join("\n"),
       );
       frontendEnv = setEnvValue(
         frontendEnv,
         "NEXT_PUBLIC_API_URL",
         `http://localhost:${backendPort}`,
       );
+      frontendEnv = setEnvValue(
+        frontendEnv,
+        "NEXT_PUBLIC_DESIGN_MODE",
+        mode === "frontend" ? "true" : "false",
+      );
       await writeFile(frontendEnvPath, frontendEnv, "utf8");
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aime-aatrick/create-fullstack-template",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "Interactive installer for the fullstack template",
   "type": "module",
   "license": "MIT",