neatnode 3.3.2 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neatnode",
-  "version": "3.3.2",
+  "version": "3.4.0",
   "description": "Plug & Play Node.js backend starter templates — build REST APIs, socket servers, and more in seconds.",
   "bin": {
     "neatnode": "bin/index.js"
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "axios": "^1.13.2",
-    "extract-zip": "^2.0.1",
+    "decompress": "^4.2.1",
     "fs-extra": "^11.3.2",
     "inquirer": "^12.10.0"
   },
@@ -54,4 +54,4 @@
     "eslint": "^9.0.0",
     "globals": "^15.0.0"
   }
-}
+}

package/src/actions/createProject.js

@@ -1,76 +1,107 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { fileURLToPath } from "url";
 import { copyTemplate } from "../utils/copyTemplate.js";
-import { cleanupTemplateMarkers, removeCrud, removeCrudModule, removeCrudReferences } from "./removeCRUD.js";
-import { downloadTemplate } from "../utils/downloadRepoTemplateByVersionTags.js";
+import {
+  cleanupTemplateMarkers,
+  removeCrud,
+  removeCrudModule,
+  removeCrudReferences,
+} from "./removeCRUD.js";
+import { downloadTemplate, getPackageVersion } from "../utils/downloadRepoTemplateByVersionTags.js";
 import { addEnv } from "./addEnv.js";
+import { generateNeatNodeConfig } from "../templates/config.js";
+import { updatePackageJson } from "../utils/updatePackageJson.js";
+
+export async function createProject({
+  projectName,
+  repoPath,
+  includeCrud,
+  crudName,
+  langKey,
+  isModular,
+  tempConfig,
+}) {
+  // Project configuration based on user choices
+  const projectConfig = {
+    language: langKey === "ts" ? "typescript" : "javascript",
+    architecture: isModular ? "modular" : "mvc",
+    database: {
+      provider: "mongodb",
+      client: "mongoose",
+    },
+    tempConfig,
+    validation: langKey === "ts" ? "zod" : "joi",
+    srcDir: "src",
+    langKey,
+  };
+
+  const neatnodeVersion = getPackageVersion();
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export async function createProject({ projectName, repoPath, includeCrud, crudName, langKey, isModular }) {
   try {
-    const targetPath = projectName === "."
-      ? process.cwd()
-      : path.join(process.cwd(), projectName);
+    const targetPath =
+      projectName === "."
+        ? process.cwd()
+        : path.join(process.cwd(), projectName);
 
+    // Check if the target directory already exists
     if (fs.existsSync(targetPath) && projectName !== ".") {
       console.error(`❌ Folder "${projectName}" already exists.`);
       process.exit(1);
     }
 
+    // Create the project folder if the project name is not "."
     if (projectName !== ".") {
       console.log("Creating project folder...");
       fs.mkdirSync(targetPath);
     }
 
+    // Download the template from the specified repository path
     console.log("Downloading template...");
     const localTemplatePath = await downloadTemplate(repoPath);
 
+    // Copy the template files to the target directory and replace placeholders
     await copyTemplate(localTemplatePath, targetPath, {
-      "project-name": projectName === "." ? path.basename(process.cwd()) : projectName,
-      "author": os.userInfo().username || "author",
+      "project-name":
+        projectName === "." ? path.basename(process.cwd()) : projectName,
+      author: os.userInfo().username || "author",
+    });
+
+    await updatePackageJson({
+      targetPath,
+      neatnodeVersion,
     });
 
+    // Generate the Neatnode configuration file based on the user's choices
+    await generateNeatNodeConfig({
+      targetPath,
+      ...projectConfig,
+    });
+
+    // Add environment variables to the project
     await addEnv({ targetPath });
 
+    // Handle CRUD removal if the user chose not to include it
     if (!includeCrud && crudName) {
       console.log("🗑 Removing CRUD files...");
 
       if (isModular) {
         removeCrudModule(targetPath, crudName);
-
-        removeCrudReferences(
-          path.join(targetPath, "src", `routes/index.route.${langKey}`)
-        );
       }
 
       removeCrud(targetPath, crudName, langKey);
 
       removeCrudReferences(
-        path.join(targetPath, "src", `app.${langKey}`)
+        path.join(targetPath, "src", "routes", `index.route.${langKey}`),
       );
     }
 
-    // ALWAYS CLEANUP MARKERS
+    // Cleanup template markers
     cleanupTemplateMarkers(
-      path.join(targetPath, "src", `app.${langKey}`)
+      path.join(targetPath, "src", "routes", `index.route.${langKey}`),
     );
-
-    if (isModular) {
-      cleanupTemplateMarkers(
-        path.join(targetPath, "src", `routes/index.route.${langKey}`)
-      );
-    }
-
-    console.log(`\n✅ Project "${projectName}" created successfully!\n`);
-
   } catch (err) {
     console.error("❌ Failed to create project:", err);
     process.exit(1);
   }
 }
-
-

package/src/cli.js

@@ -2,6 +2,7 @@
 import inquirer from "inquirer";
 import templates from "./config/templates.js";
 import { createProject } from "./actions/createProject.js";
+import { generate } from "./commands/generate.js";
 
 async function main() {
   console.log("\n🚀 Welcome to NeatNode CLI!\n");
@@ -59,7 +60,6 @@ async function main() {
     isModular = architecture === "modular";
 
     chosen.repoPath = chosen.architecture[architecture];
-
   }
 
   // STEP 4 — CRUD Optional (only for some templates)
@@ -126,10 +126,12 @@ async function main() {
     crudName,
     langKey,
     isModular,
+    tempConfig: chosen.config,
   });
 
-
-  console.log(`\n✅ Project "${projectName}" created successfully using "${chosen.name}".\n`);
+  console.log(
+    `\n✅ Project "${projectName}" created successfully using "${chosen.name}".\n`,
+  );
 
   console.log("Next steps:");
   console.log(`  cd ${projectName}`);
@@ -137,11 +139,23 @@ async function main() {
   console.log("  npm run dev\n");
 
   console.log("🎉 Happy Coding!\n");
+}
 
+async function run() {
+  const args = process.argv.slice(2);
+  const force = args.includes("--force");
 
+  if (args[0] === "g" || args[0] === "generate") {
+    return generate({
+      type: args[1],
+      name: args[2],
+      force,
+    });
+  }
 
+  return main();
 }
 
-main().catch((err) => {
+run().catch((err) => {
   console.error("❌ Error:", err.message || err);
 });

package/src/commands/generate.js

@@ -0,0 +1,21 @@
+import { generateResource } from "../generators/resource.js";
+import { loadConfig } from "../utils/loadConfig.js";
+
+export async function generate({ type, name, force }) {
+  if (!type) {
+    throw new Error("Missing generator type.");
+  }
+
+  if (!name) {
+    throw new Error("Missing resource name.");
+  }
+  const config = await loadConfig();
+
+  switch (type) {
+    case "resource":
+      return generateResource({ name, config, force });
+
+    default:
+      throw new Error(`Unknown generator: "${type}"`);
+  }
+}

package/src/config/fileDefinitions.js

@@ -0,0 +1,104 @@
+import path from "path";
+
+export const FILE_DEFINITIONS = [
+  // controller
+  {
+    type: "controller",
+
+    template: "controller.hbs",
+
+    output(config, name, ext) {
+      if (config.architecture === "mvc") {
+        return path.join(
+          config.srcDir,
+          "controllers",
+          `${name}.controller.${ext}`,
+        );
+      }
+
+      return path.join(
+        config.srcDir,
+        "modules",
+        name,
+        `${name}.controller.${ext}`,
+      );
+    },
+  },
+
+  // service
+  {
+    type: "service",
+
+    template: "service.hbs",
+
+    output(config, name, ext) {
+      if (config.architecture === "mvc") {
+        return path.join(config.srcDir, "services", `${name}.service.${ext}`);
+      }
+
+      return path.join(
+        config.srcDir,
+        "modules",
+        name,
+        `${name}.service.${ext}`,
+      );
+    },
+  },
+
+  // route
+  {
+    type: "route",
+
+    template: "route.hbs",
+
+    output(config, name, ext) {
+      if (config.architecture === "mvc") {
+        return path.join(config.srcDir, "routes", `${name}.route.${ext}`);
+      }
+
+      return path.join(config.srcDir, "modules", name, `${name}.route.${ext}`);
+    },
+
+  },
+
+  // validation
+  {
+    type: "validation",
+
+    template: "validation.hbs",
+
+    output(config, name, ext) {
+      if (config.architecture === "mvc") {
+        return path.join(
+          config.srcDir,
+          "validations",
+          `${name}.validation.${ext}`,
+        );
+      }
+
+      return path.join(
+        config.srcDir,
+        "modules",
+        name,
+        `${name}.validation.${ext}`,
+      );
+    },
+  },
+
+  // model
+  {
+    type: "model",
+
+    template: "model.hbs",
+
+    database: "mongoose",
+
+    output(config, name, ext) {
+      if (config.architecture === "mvc") {
+        return path.join(config.srcDir, "models", `${name}.model.${ext}`);
+      }
+
+      return path.join(config.srcDir, "modules", name, `${name}.model.${ext}`);
+    },
+  },
+];

package/src/config/templates.js

@@ -1,19 +1,73 @@
 export default {
+  // javascript templates
   js: [
-    { name: "Basic Express", repoPath: "templates/js/express-basic" },
+    // basic express template
+    {
+      name: "Basic Express",
+      repoPath: "templates/js/express-basic",
+      config: {
+        template: "basic",
+        features: {
+          resourceGenerator: false,
+        },
+      },
+    },
+
+    // rest api template
     {
       name: "REST API",
       architecture: {
         mvc: "templates/js/express-rest-api",
-        modular: "templates/js/express-modular-rest-api"
-      }
+        modular: "templates/js/express-modular-rest-api",
+      },
+      config: {
+        template: "rest-api",
+        features: {
+          resourceGenerator: true,
+        },
+      },
+    },
+
+    // socket.io template
+    {
+      name: "Socket.IO",
+      repoPath: "templates/js/express-socket",
+      config: {
+        template: "socket",
+        features: {
+          resourceGenerator: false,
+        },
+      },
     },
-    { name: "Socket.IO", repoPath: "templates/js/express-socket" },
   ],
 
+  // typescript templates
   ts: [
-    { name: "Basic Express (TS)", repoPath: "templates/ts/basic-express" },
-    { name: "REST API (TS)", repoPath: "templates/ts/express-rest-api", isModular: true },
+    // basic express template
+    {
+      name: "Basic Express (TS)",
+      repoPath: "templates/ts/basic-express",
+      config: {
+        template: "basic",
+        features: {
+          resourceGenerator: false,
+        },
+      },
+    },
+
+    // rest api template
+    {
+      name: "REST API (TS)",
+      repoPath: "templates/ts/express-rest-api",
+      isModular: true,
+      config: {
+        template: "rest-api",
+        features: {
+          resourceGenerator: true,
+        },
+      },
+    },
+
     // { name: "Socket.IO (TS)", repoPath: "templates/ts/express-socket" },
   ],
 };

package/src/generators/resource.js

@@ -0,0 +1,77 @@
+import { buildContext } from "../utils/buildContext.js";
+import { buildGenerationPlan } from "../utils/buildGenerationPlan.js";
+import { renderTemplate } from "../utils/renderTemplate.js";
+import { writeFile } from "../utils/writeFile.js";
+import { updateRouteRegistry } from "./updateRouteRegistry.js";
+import path from "path";
+import fs from "fs";
+import { validateRouteRegistry } from "./verifyRouteRegistry.js";
+
+export async function generateResource({ name, config, force }) {
+  const files = ["controller", "service", "route", "validation", "model"];
+
+  if (!config.features.resourceGenerator) {
+    console.error(
+      `❌ The "${config.template}" template does not support resource generation.`,
+    );
+    process.exit(1);
+  }
+
+  const context = buildContext(name, config);
+
+  const plan = buildGenerationPlan({
+    config,
+    context,
+    files,
+  });
+
+  const createdFiles = [];
+
+  // Check if any of the files in the plan already exist
+  if (!force) {
+    for (const file of plan) {
+      if (fs.existsSync(file.output)) {
+        console.error(`❌ ${path.basename(file.output)} already exists.`);
+
+        console.log("\nUse --force to overwrite existing files.");
+
+        process.exit(1);
+      }
+    }
+  }
+
+  // Validate the route registry before proceeding with file generation
+  validateRouteRegistry({
+    targetPath: process.cwd(),
+    config,
+  });
+
+  // Generate files based on the plan
+  for (const file of plan) {
+    const content = renderTemplate(file.template, context);
+
+    await writeFile(file.output, content, { overwrite: force });
+
+    createdFiles.push(file.output);
+  }
+
+  // Update the route registry after generating files
+  updateRouteRegistry({
+    targetPath: process.cwd(),
+    context,
+    config,
+  });
+
+  console.log();
+
+  for (const file of createdFiles) {
+    console.log(`✔ Created ${path.basename(file)}`);
+  }
+
+  console.log();
+  console.log("✔ Updated routes/index.route.js");
+  console.log();
+  console.log(`✨ Resource "${name}" generated successfully.`);
+
+  return plan;
+}

package/src/generators/updateRouteRegistry.js

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+
+export function updateRouteRegistry({ targetPath, context, config }) {
+  const extension = config.language === "typescript" ? "ts" : "js";
+
+  const routeRegistry = path.join(
+    targetPath,
+    config.srcDir,
+    "routes",
+    `index.route.${extension}`,
+  );
+
+  let content = fs.readFileSync(routeRegistry, "utf8");
+
+  // Check for markers
+  const IMPORT_MARKER = "/* <NEATNODE_IMPORTS> */";
+  const ROUTE_MARKER = "/* <NEATNODE_ROUTES> */";
+
+  // Generate import and route statements based on architecture
+  const moduleImport = `import ${context.camelName}Route from "../modules/${context.rawName}/${context.rawName}.route.${extension}";`;
+  const mvcImport = `import ${context.camelName}Route from "./${context.rawName}.route.${extension}";`;
+
+  const importStatement =
+    config.architecture === "modular" ? moduleImport : mvcImport;
+
+  const routeStatement = `router.use("/${context.pluralName}", ${context.camelName}Route);`;
+
+  // Prevent duplicate imports
+  if (!content.includes(importStatement)) {
+    content = content.replace(
+      IMPORT_MARKER,
+      `${importStatement}\n${IMPORT_MARKER}`,
+    );
+  }
+
+  // Prevent duplicate routes
+  if (!content.includes(routeStatement)) {
+    content = content.replace(
+      ROUTE_MARKER,
+      `${routeStatement}\n${ROUTE_MARKER}`,
+    );
+  }
+
+  fs.writeFileSync(routeRegistry, content, "utf8");
+}

package/src/generators/verifyRouteRegistry.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+
+export function validateRouteRegistry({ targetPath, config }) {
+  const extension = config.language === "typescript" ? "ts" : "js";
+
+  const routeRegistry = path.join(
+    targetPath,
+    config.srcDir,
+    "routes",
+    `index.route.${extension}`,
+  );
+
+  let content = fs.readFileSync(routeRegistry, "utf8");
+
+  // Check for markers
+  const IMPORT_MARKER = "/* <NEATNODE_IMPORTS> */";
+  const ROUTE_MARKER = "/* <NEATNODE_ROUTES> */";
+
+  // If the markers are not found, throw an error and exit the process
+  if (!content.includes(IMPORT_MARKER) || !content.includes(ROUTE_MARKER)) {
+    console.error(`
+❌ NeatNode route markers were not found.
+
+Expected markers in:
+
+${routeRegistry}
+${IMPORT_MARKER}
+${ROUTE_MARKER}
+
+Please restore them before generating resources.
+`);
+
+    process.exit(1);
+  }
+}

package/src/templates/config.js

@@ -0,0 +1,39 @@
+import fs from "fs";
+import path from "path";
+
+export async function generateNeatNodeConfig({
+  targetPath,
+  language,
+  architecture,
+  validation,
+  langKey,
+  database,
+  srcDir,
+  tempConfig,
+}) {
+  const { provider, client } = database;
+
+  const content = `export default {
+  template: "${tempConfig.template}",
+
+  language: "${language}",
+  architecture: "${architecture}",
+
+  database: {
+    provider: "${provider}",
+    client: "${client}"
+  },
+  features: {
+    resourceGenerator: ${tempConfig.features.resourceGenerator},
+  },
+  
+  validation: "${validation}",
+  srcDir: "${srcDir}",
+};
+`;
+
+  fs.writeFileSync(
+    path.join(targetPath, `neatnode.config.${langKey}`),
+    content,
+  );
+}

package/src/templates/javascript/controller.hbs

@@ -0,0 +1,14 @@
+import { StatusCodes } from "http-status-codes";
+import { get{{pascalName}}Service } from "{{serviceImport}}{{camelName}}.service.js";
+import sendResponse from "{{utilsImport}}ApiResponse.js";
+import CatchAsync from "{{utilsImport}}CatchAsync.js";
+
+export const get{{pascalName}} = CatchAsync(async (req, res) => {
+
+    const {{camelName}} = await get{{pascalName}}Service(req.params.id);
+
+    sendResponse(res, StatusCodes.OK, "{{pascalName}} fetched successfully",
+        {{camelName}},
+    );
+
+});

package/src/templates/javascript/mongoose/model.hbs

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+
+const {{camelName}}Schema = new mongoose.Schema(
+  {
+    // Define your schema fields here
+  },
+  { timestamps: true }
+);
+
+const {{pascalName}} = mongoose.model("{{pascalName}}", {{camelName}}Schema);
+
+export default {{pascalName}};

package/src/templates/javascript/route.hbs

@@ -0,0 +1,8 @@
+import express from "express";
+import { get{{pascalName}} } from "{{controllerImport}}{{camelName}}.controller.js";
+
+const router = express.Router();
+
+router.get("/", get{{pascalName}});
+
+export default router;

package/src/templates/javascript/service.hbs

@@ -0,0 +1,16 @@
+import { StatusCodes } from "http-status-codes";
+import {{pascalName}} from "{{modelImport}}{{camelName}}.model.js";
+import ApiError from "{{utilsImport}}ApiError.js";
+
+export const get{{pascalName}}Service = async (id) => {
+  const {{camelName}} = await {{pascalName}}.findById(id);
+
+  if (!{{camelName}}) {
+    throw new ApiError(
+      StatusCodes.NOT_FOUND,
+      "{{pascalName}} not found"
+    );
+  }
+
+  return {{camelName}};
+};

package/src/templates/javascript/validation.hbs

@@ -0,0 +1,5 @@
+import joi from "joi";
+
+export const create{{pascalName}}Schema = joi.object({
+
+});

package/src/templates/typescript/controller.hbs

@@ -0,0 +1,14 @@
+import type { Request, Response } from "express";
+import { StatusCodes } from "http-status-codes";
+import { get{{pascalName}}Service } from "{{serviceImport}}{{camelName}}.service.js";
+import sendResponse from "{{utilsImport}}ApiResponse.js";
+import CatchAsync from "{{utilsImport}}CatchAsync.js";
+
+export const get{{pascalName}} = CatchAsync(async (req: Request, res: Response) => {
+    const {{camelName}} = await get{{pascalName}}Service(req.params.id);
+
+    sendResponse(res, StatusCodes.OK, "{{pascalName}} fetched successfully",
+        {{camelName}},
+    );
+
+});

package/src/templates/typescript/mongoose/model.hbs

@@ -0,0 +1,16 @@
+import mongoose, { type Model, Schema, type InferSchemaType } from "mongoose";
+
+const {{camelName}}Schema = new Schema(
+  {
+    // Define your schema fields here
+  },
+  {
+    timestamps: true,
+    versionKey: false,
+  },
+);
+
+type {{pascalName}}Document = InferSchemaType<typeof {{camelName}}Schema>;
+type {{pascalName}}Model = Model<{{pascalName}}Document>;
+
+export const {{pascalName}} = mongoose.model<{{pascalName}}Document, {{pascalName}}Model>("{{pascalName}}", {{camelName}}Schema);

package/src/templates/typescript/route.hbs

@@ -0,0 +1,9 @@
+import { Router } from "express";
+
+import { get{{pascalName}} } from "{{controllerImport}}{{camelName}}.controller.js";
+
+const router = Router();
+
+router.get("/", get{{pascalName}});
+
+export default router;

package/src/templates/typescript/service.hbs

@@ -0,0 +1,17 @@
+import ApiError from "{{utilsImport}}ApiError.js";
+import { {{pascalName}} } from "{{modelImport}}{{camelName}}.model.js";
+
+export const get{{pascalName}}Service = async (id: string) => {
+
+    const {{camelName}} = await {{pascalName}}.findById(id);
+
+    if (!{{camelName}}) {
+        throw new ApiError(
+            StatusCodes.NOT_FOUND,
+            "{{pascalName}} not found"
+        );
+    }
+
+    return {{camelName}};
+
+};

package/src/templates/typescript/validation.hbs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const create{{pascalName}}Schema = z.object({
+
+});

package/src/utils/buildContext.js

@@ -0,0 +1,66 @@
+function buildImportPaths(config) {
+  if (config.architecture === "mvc") {
+    return {
+      // Resource imports
+      serviceImport: "../services/",
+      controllerImport: "../controllers/",
+      validationImport: "../schemas/",
+      modelImport: "../models/",
+
+      // Shared imports
+      utilsImport: "../utils/",
+      middlewareImport: "../middleware/",
+      configImport: "../config/",
+    };
+  }
+
+  return {
+    // Resource imports
+    serviceImport: "./",
+    controllerImport: "./",
+    validationImport: "./",
+    modelImport: "./",
+
+    // Shared imports
+    utilsImport: "../../shared/utils/",
+    middlewareImport: "../../core/middleware/",
+    configImport: "../../core/config/",
+  };
+}
+
+function toPascalCase(value) {
+  return value
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+}
+
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function toKebabCase(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_/g, "-");
+}
+
+export function buildContext(name, config) {
+  const camelName = toCamelCase(name);
+  const pascalName = toPascalCase(name);
+  const kebabName = toKebabCase(name);
+
+  return {
+    name,
+    rawName: name,
+
+    camelName,
+    pascalName,
+    kebabName,
+
+    pluralName: `${kebabName}s`,
+    camelPluralName: `${camelName}s`,
+    pascalPluralName: `${pascalName}s`,
+    ...buildImportPaths(config),
+  };
+}

package/src/utils/buildGenerationPlan.js

@@ -0,0 +1,23 @@
+import { FILE_DEFINITIONS } from "../config/fileDefinitions.js";
+
+export function buildGenerationPlan({ config, context, files }) {
+  const extension = config.language === "typescript" ? "ts" : "js";
+
+  const fileDefinitions = files
+    .map((type) => FILE_DEFINITIONS.find((file) => file.type === type))
+    .filter(Boolean)
+    .filter((file) => {
+      if (!file.database) return true;
+
+      return file.database === config.database.client;
+    })
+    .map((file) => ({
+      type: file.type,
+      template: file.database
+        ? `${config.language}/${config.database.client}/${file.template}`
+        : `${config.language}/${file.template}`,
+      output: file.output(config, context.camelName, extension),
+    }));
+
+  return fileDefinitions;
+}

package/src/utils/downloadRepoTemplateByVersionTags.js

@@ -1,9 +1,9 @@
 import axios from "axios";
-import extract from "extract-zip";
 import fs from "fs";
 import path from "path";
 import os from "os";
 import { fileURLToPath } from "url";
+import decompress from "decompress";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -11,13 +11,13 @@ const __dirname = path.dirname(__filename);
 const owner = "aakash-gupta02";
 const repo = "NeatNode";
 
-const getPackageVersion = () => {
+export const getPackageVersion = () => {
   try {
     const pkgPath = path.resolve(__dirname, "../../package.json");
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
     return pkg.version;
   } catch {
-    return null;
+    throw new Error("Failed to read NeatNode package version.");
   }
 };
 
@@ -56,8 +56,7 @@ const downloadFromRef = async ({ repoPath, ref, refType }) => {
   });
 
   fs.writeFileSync(tempZip, response.data);
-  await extract(tempZip, { dir: tempExtractDir });
-
+  await decompress(tempZip, tempExtractDir);
   const extractedRootDir = fs
     .readdirSync(tempExtractDir, { withFileTypes: true })
     .find((entry) => entry.isDirectory());

package/src/utils/loadConfig.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+export async function loadConfig() {
+  const cwd = process.cwd();
+
+  const possibleConfigs = [
+    "neatnode.config.js",
+    "neatnode.config.ts",
+  ];
+
+  let configPath = null;
+
+  for (const file of possibleConfigs) {
+    const fullPath = path.join(cwd, file);
+
+    if (fs.existsSync(fullPath)) {
+      configPath = fullPath;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    throw new Error(
+      "No neatnode.config.js or neatnode.config.ts found."
+    );
+  }
+
+  const config = await import(pathToFileURL(configPath).href);
+
+  return config.default;
+}

package/src/utils/renderTemplate.js

@@ -0,0 +1,20 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TEMPLATE_ROOT = path.join(__dirname, "../templates");
+
+export function renderTemplate(templatePath, context) {
+  const fullPath = path.join(TEMPLATE_ROOT, templatePath);
+
+  let content = fs.readFileSync(fullPath, "utf8");
+
+  for (const [key, value] of Object.entries(context)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+
+  return content;
+}

package/src/utils/updatePackageJson.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+
+export function updatePackageJson({
+  targetPath,
+  neatnodeVersion,
+}) {
+  const packageJsonPath = path.join(targetPath, "package.json");
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, "utf8"),
+  );
+
+  packageJson.devDependencies = {
+    ...packageJson.devDependencies,
+    neatnode: `^${neatnodeVersion}`,
+  };
+
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + "\n",
+    "utf8",
+  );
+}

package/src/utils/writeFile.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+import path from "path";
+
+export async function writeFile(filePath, content, options = {}) {
+  const { overwrite = false } = options;
+
+  if (fs.existsSync(filePath) && !overwrite) {
+    throw new Error(`File already exists: ${path.basename(filePath)}`);
+  }
+
+  await fs.promises.mkdir(path.dirname(filePath), {
+    recursive: true,
+  });
+
+  await fs.promises.writeFile(filePath, content);
+}