sparkzen 1.1.2 → 1.2.0

package/dist/cli/index.js

@@ -1,16 +1,72 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 
-// src/cli/commands/init.ts
-import { execSync } from "child_process";
+// package.json
+var name = "sparkzen";
+var version = "1.2.0";
+
+// src/cli/commands/app/build.ts
 import { Command } from "commander";
+import { bgGreenBright, bold } from "logfy-x";
+import { execSync } from "child_process";
+var build = new Command().name("build").description("Build the project").action(() => {
+  const projectPath = process.cwd();
+  console.log(`${bgGreenBright(bold(" \u{1F4E6} BUILD "))} Building the project...
+`);
+  execSync(`npx tsup`, {
+    cwd: projectPath,
+    stdio: "inherit",
+    shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+  });
+  console.log(`
+${bgGreenBright(bold(" \u2705 BUILD "))} Build completed successfully!
+`);
+});
+var build_default = build;
+
+// src/cli/commands/app/dev.ts
+import { Command as Command2 } from "commander";
+import { bgBlue, bold as bold2 } from "logfy-x";
+import { execSync as execSync2 } from "child_process";
+import path from "path";
+var dev = new Command2().name("dev").description("Run the project in development mode").action(() => {
+  const projectPath = process.cwd();
+  const tsxPath = path.join(projectPath, "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
+  console.log(`
+${bgBlue(bold2(" \u{1F680} DEV  "))} Starting development server...
+`);
+  execSync2(`${tsxPath} watch src/index.ts`, {
+    cwd: projectPath,
+    stdio: "inherit",
+    shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+  });
+});
+var dev_default = dev;
+
+// src/cli/commands/app/start.ts
+import { Command as Command3 } from "commander";
+import { execSync as execSync3 } from "child_process";
+var start = new Command3().name("start").description("Run the project in production mode").action(() => {
+  process.env.NODE_ENV = "production";
+  const projectPath = process.cwd();
+  execSync3(`node dist/index.js`, {
+    cwd: projectPath,
+    stdio: "inherit",
+    shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+  });
+});
+var start_default = start;
+
+// src/cli/commands/init.ts
+import { Command as Command4 } from "commander";
 import degit from "degit";
 import enquirer from "enquirer";
 import fs from "fs-extra";
-import { bgBlue, blue, bold, error, logfy, success } from "logfy-x";
-import path from "path";
+import { bgBlue as bgBlue2, blue, bold as bold3, error, logfy, success } from "logfy-x";
+import { execSync as execSync4 } from "child_process";
+import path2 from "path";
 var { prompt } = enquirer;
 var promptOptions = async () => {
   const terminalWidth = process.stdout.columns || 80;
@@ -21,7 +77,7 @@ var promptOptions = async () => {
     const half = Math.floor(available / 2);
     const left = " ".repeat(half);
     const right = " ".repeat(available - half);
-    return bgBlue(left) + text + bgBlue(right);
+    return bgBlue2(left) + text + bgBlue2(right);
   };
   logfy(`
 ${padFor(line1)}
@@ -33,7 +89,7 @@ ${padFor(line2)}
       name: "projectName",
       message: "Project name:",
       required: true,
-      validate: (v) => v && v.trim() ? true : "Please enter a project name"
+      validate: (v) => v?.trim() ? true : "Please enter a project name"
     },
     {
       type: "select",
@@ -53,10 +109,10 @@ ${padFor(line2)}
 };
 var cloneProjectTemplate = async (projectName, targetPath) => {
   console.log(`
-${bgBlue(bold(" \u{1F4C1} CREATING "))} ${projectName}`);
-  await fs.mkdirp(path.dirname(targetPath));
+${bgBlue2(bold3(" \u{1F4C1} CREATING "))} ${projectName}`);
+  await fs.mkdirp(path2.dirname(targetPath));
   console.log(`
-${bgBlue(bold(" \u{1F501} COPYING "))} Default template`);
+${bgBlue2(bold3(" \u{1F501} COPYING "))} Default template`);
   const template = degit("MatheusSantos360/sparkzen-templates/default", {
     cache: false,
     force: true
@@ -66,7 +122,7 @@ ${bgBlue(bold(" \u{1F501} COPYING "))} Default template`);
   } catch (err) {
     throw new Error(`Failed to clone template: ${err.message}`);
   }
-  const pkgJsonPath = path.join(targetPath, "package.json");
+  const pkgJsonPath = path2.join(targetPath, "package.json");
   if (!await fs.pathExists(pkgJsonPath)) {
     error("NOT FOUND", "package.json not found in the template.");
     return;
@@ -81,10 +137,10 @@ ${bgBlue(bold(" \u{1F501} COPYING "))} Default template`);
 };
 var installDependencies = (packageManager, targetPath) => {
   console.log(`
-${bgBlue(bold(" \u26A1 DEPENDENCIES "))} Installing with ${blue(packageManager)}:
+${bgBlue2(bold3(" \u26A1 DEPENDENCIES "))} Installing with ${blue(packageManager)}:
 `);
   try {
-    execSync(`${packageManager} install`, {
+    execSync4(`${packageManager} install`, {
       cwd: targetPath,
       stdio: "inherit",
       shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
@@ -93,10 +149,10 @@ ${bgBlue(bold(" \u26A1 DEPENDENCIES "))} Installing with ${blue(packageManager)}
     throw new Error(`Dependency install failed: ${err.message}`);
   }
 };
-var init = new Command().name("init").description("Initialize a new SparkZen project").action(async () => {
+var init = new Command4().name("init").description("Initialize a new SparkZen project").action(async () => {
   try {
     const { projectName, packageManager, installNow } = await promptOptions();
-    const targetPath = path.resolve(process.cwd(), projectName);
+    const targetPath = path2.resolve(process.cwd(), projectName);
     await cloneProjectTemplate(projectName, targetPath);
     if (installNow) {
       installDependencies(packageManager, targetPath);
@@ -104,7 +160,7 @@ var init = new Command().name("init").description("Initialize a new SparkZen pro
     console.log();
     success("CREATED!", `Project "${blue(projectName)}" has been created successfully.`);
     console.log(`
-${bgBlue(bold(" \u{1F525} NEXT STEPS "))} To get started:
+${bgBlue2(bold3(" \u{1F525} NEXT STEPS "))} To get started:
 `);
     console.log(`    cd ${blue(projectName)}`);
     console.log(`    ${blue(packageManager)} run ${blue("dev")}
@@ -116,57 +172,16 @@ ${bgBlue(bold(" \u{1F525} NEXT STEPS "))} To get started:
 });
 var init_default = init;
 
-// src/cli/commands/dev.ts
-import { execSync as execSync2 } from "child_process";
-import { Command as Command2 } from "commander";
-import { bgBlue as bgBlue2, bold as bold2 } from "logfy-x";
-import path2 from "path";
-var dev = new Command2().name("dev").description("Run the project in development mode").action(() => {
-  const projectPath = process.cwd();
-  const tsxPath = path2.join(projectPath, "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
-  console.log(`
-${bgBlue2(bold2(" \u{1F680} DEV  "))} Starting development server...
-`);
-  execSync2(`${tsxPath} watch src/index.ts`, {
-    cwd: projectPath,
-    stdio: "inherit",
-    shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
-  });
-});
-var dev_default = dev;
-
-// src/cli/commands/build.ts
-import { execSync as execSync3 } from "child_process";
-import { Command as Command3 } from "commander";
-import { bgGreenBright, bold as bold3 } from "logfy-x";
-var build = new Command3().name("build").description("Build the project").action(() => {
-  const projectPath = process.cwd();
-  console.log(`${bgGreenBright(bold3(" \u{1F4E6} BUILD "))} Building the project...
-`);
-  execSync3(`npx tsup`, {
-    cwd: projectPath,
-    stdio: "inherit",
-    shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
-  });
-  console.log(`
-${bgGreenBright(bold3(" \u2705 BUILD "))} Build completed successfully!
-`);
-});
-var build_default = build;
-
 // src/cli/commands.ts
 function registerCommands(program2) {
   program2.addCommand(init_default);
   program2.addCommand(dev_default);
   program2.addCommand(build_default);
+  program2.addCommand(start_default);
 }
 
-// package.json
-var name = "sparkzen";
-var version = "1.1.2";
-
 // src/cli/index.ts
-var program = new Command4();
+var program = new Command5();
 program.name(name).description("SparkZen CLI").version(version);
 registerCommands(program);
 program.parse();

package/dist/index.d.ts

@@ -37,4 +37,9 @@ type MiddlewareFunction<Schema extends RouteSchema = RouteSchema> = (request: Fa
 }>, reply: TypedReply<Schema>, done: () => void) => void | Promise<void>;
 type Middleware<Schema extends RouteSchema = RouteSchema> = MiddlewareFunction<Schema> | MiddlewareFunction<Schema>[];
 
-export { type Handler, type Middleware, type MiddlewareFunction, sparkzen as default };
+type Config = {
+    routePrefix?: string;
+    errorMessage?: string;
+};
+
+export { type Config, type Handler, type Middleware, type MiddlewareFunction, sparkzen as default };

package/dist/index.js

@@ -1,36 +1,126 @@
 // src/core/sparkzen.ts
 import fastify from "fastify";
-import { bgBlueBright as bgBlueBright2, bgGreenBright, blue, bold as bold3, dim as dim3, error } from "logfy-x";
+import { bgBlueBright as bgBlueBright2, bgGreenBright as bgGreenBright2 } from "logfy-x";
+
+// src/core/functions/errorHandler.ts
+import { dim, error } from "logfy-x";
+var errorHandler = (err, _request, reply) => {
+  reply.status(500).send({ error: "Internal Server Error", message: "There was an error. Please, try again." });
+  const failedRoutePath = err.stack?.split("(")[1].split(")")[0] || "(No path identified)";
+  error(`${err.name} ${dim(failedRoutePath)}`, [`Route Path: ${failedRoutePath}`, `Message: ${err.message}`, `Stack: ${err.stack}`]);
+};
+
+// src/core/functions/getConfig.ts
+import { exists } from "fs-extra";
+import path from "path";
+import { pathToFileURL } from "url";
+
+// src/core/defaultConfig.ts
+var defaultConfig = {
+  routePrefix: "/",
+  errorMessage: "Something went wrong. Please, try again later."
+};
+
+// src/core/package.ts
+var packageConfigs = {
+  configFileName: `sparkzen.config.${process.env.NODE_ENV === "production" ? "js" : "ts"}`
+};
+
+// src/core/functions/getConfig.ts
+var config = defaultConfig;
+var getConfig = async () => {
+  return config;
+};
+var setConfig = async () => {
+  if (await configFileExists()) {
+    const fileConfig = await import(pathToFileURL(path.resolve(process.cwd(), packageConfigs.configFileName)).href);
+    config = { ...defaultConfig, ...fileConfig.config };
+  }
+};
+var configFileExists = async () => {
+  const filePath = path.resolve(process.cwd(), packageConfigs.configFileName);
+  return await exists(filePath);
+};
+
+// src/core/functions/manageListen.ts
+import { bgGreenBright, blue, bold as bold2, error as error2 } from "logfy-x";
+
+// src/core/functions/sparkzenBanner.ts
+import { bold, dim as dim2 } from "logfy-x";
+var sparkzenBanner = (message, color) => {
+  const tag = color(bold(" SPARKZEN "));
+  const line = dim2("\u2500".repeat(10 * 2 + message.length + 2));
+  console.log(`
+${tag} ${bold(message)} ${tag}
+${line}`);
+};
+
+// src/core/functions/manageListen.ts
+var manageListen = (app) => {
+  const originalListen = app.listen.bind(app);
+  app.listen = async function(options) {
+    try {
+      sparkzenBanner("STARTING SERVER", bgGreenBright);
+      const result = await originalListen(options);
+      const runningAt = `http://localhost:${options?.port}`;
+      console.log(`${bgGreenBright(bold2(" SERVER "))} Running at: ${blue(runningAt)}
+`);
+      return result;
+    } catch (err) {
+      error2("ERROR", err.name + `: ${err.message}
+
+${err.stack}`);
+    }
+  };
+};
+
+// src/core/loadRoutes.ts
+import fs from "fs/promises";
+import path3 from "path";
+
+// src/core/routing/processFile.ts
+import { bgRedBright, bold as bold4, dim as dim5, red } from "logfy-x";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/core/routing/dynamicImport.ts
+var dynamicImport = async (modulePath) => {
+  return await import(modulePath);
+};
 
 // src/core/routing/isValidRoute.ts
 var isValidRoute = (routeModule) => {
   return routeModule && typeof routeModule === "object" && typeof routeModule.default === "function";
 };
 
+// src/core/routing/registerRoute.ts
+import * as colors from "logfy-x";
+import { bgBlueBright, dim as dim4, error as error3 } from "logfy-x";
+
 // src/core/routing/getRouteURL.ts
-import path from "path";
-var getRouteUrl = (filePath) => {
+import path2 from "path";
+var getRouteUrl = async (filePath) => {
+  const { routePrefix } = await getConfig();
   const production = process.env.NODE_ENV === "production";
-  const basePath = production ? process.cwd() : path.join(process.cwd(), "src", "routes");
+  const basePath = production ? process.cwd() : path2.join(process.cwd(), "src", "routes");
   let routePath = filePath.replace(basePath, "").replaceAll("\\", "/").replace(/\.(js|ts)$/, "");
   const segments = routePath.split("/");
   segments.pop();
   routePath = segments.join("/");
-  routePath = routePath.replace(/\[(\w+)\]/g, ":$1");
-  return `/api${routePath}`.replace(/\/+/g, "/").replaceAll("dist/routes/", "");
+  routePath = routePath.replaceAll(/\[(\w+)\]/g, ":$1");
+  return `${routePrefix}${routePath}`.replaceAll(/\/+/g, "/").replaceAll("dist/routes/", "");
 };
 
 // src/core/routing/registerRoute.ts
-import { bgBlueBright } from "logfy-x";
-import * as colors from "logfy-x";
-var registerRoute = (app, routeModule, method, finalPath) => {
-  const routeURL = getRouteUrl(finalPath);
+var registerRoute = async (app, routeModule, method, finalPath) => {
+  const routeURL = await getRouteUrl(finalPath);
   const methodColors = {
     get: "green",
     post: "yellow",
     put: "blue",
     delete: "red",
-    patch: "magenta"
+    patch: "magentaBright",
+    head: "green",
+    options: "magentaBright"
   };
   const routeOptions = {
     ...routeModule,
@@ -39,73 +129,64 @@ var registerRoute = (app, routeModule, method, finalPath) => {
     handler: routeModule.default,
     preHandler: routeModule.middlewares
   };
-  app.route(routeOptions);
+  try {
+    app.route(routeOptions);
+  } catch (err) {
+    const routeError = err;
+    console.log();
+    error3(`${routeError.name} ${dim4(finalPath)}`, [
+      `Route Path: ${finalPath}`,
+      `API Path: ${colors.blue(routeURL)}`,
+      `Message: ${routeError.message}`,
+      `Code: ${routeError.code}`,
+      `Stack: ${routeError.stack}`
+    ]);
+  }
   console.log(bgBlueBright(colors.bold(` ROUTE `)) + ` ${colors[methodColors[method]](method.toUpperCase())} ${routeURL} ${colors.dim(finalPath)}`);
 };
 
-// src/core/loadRoutes.ts
-import { pathToFileURL } from "url";
-import fs from "fs/promises";
-
-// src/core/routing/dynamicImport.ts
-var dynamicImport = async (modulePath) => {
-  return await import(modulePath);
+// src/core/routing/processFile.ts
+var processFile = async (app, item, filePath) => {
+  const production = process.env.NODE_ENV === "production";
+  const ext = production ? ".js" : ".ts";
+  const finalPath = production ? filePath.replace(/\.ts$/, ".js") : filePath;
+  const modulePath = pathToFileURL2(finalPath).href;
+  const modulePathWithQuery = production ? modulePath : `${modulePath}?t=${Date.now()}`;
+  const routeModule = await dynamicImport(modulePathWithQuery);
+  if (isValidRoute(routeModule)) {
+    const method = item.name.replace(new RegExp(`${ext}$`), "").toLowerCase();
+    await registerRoute(app, routeModule, method, finalPath);
+  } else {
+    console.log(bgRedBright(bold4(` ROUTE `)) + ` ${red("Invalid Route (No handler exported)")} ${dim5(finalPath)}`);
+  }
 };
 
 // src/core/loadRoutes.ts
-import { bgRedBright, bold as bold2, dim as dim2, red } from "logfy-x";
-import path2 from "path";
 var loadRoutes = async (app, directory) => {
   const production = process.env.NODE_ENV === "production";
-  const ext = production ? ".js" : ".ts";
   const currentDir = process.cwd();
-  const routesPath = directory || (production ? path2.join(currentDir, "dist", "routes") : path2.join(currentDir, "src", "routes"));
+  const routesPath = directory || (production ? path3.join(currentDir, "dist", "routes") : path3.join(currentDir, "src", "routes"));
   const items = await fs.readdir(routesPath, { withFileTypes: true });
   for (const item of items) {
-    const itemPath = path2.join(routesPath, item.name);
+    const itemPath = path3.join(routesPath, item.name);
     if (item.isDirectory()) {
       await loadRoutes(app, itemPath);
     } else if (item.isFile() && item.name.endsWith(production ? ".js" : ".ts")) {
-      const finalPath = production ? itemPath.replace(/\.ts$/, ".js") : itemPath;
-      const modulePath = pathToFileURL(finalPath).href;
-      const modulePathWithQuery = production ? modulePath : `${modulePath}?t=${Date.now()}`;
-      const routeModule = await dynamicImport(modulePathWithQuery);
-      if (isValidRoute(routeModule)) {
-        const method = item.name.replace(new RegExp(`${ext}$`), "").toLowerCase();
-        registerRoute(app, routeModule, method, finalPath);
-      } else {
-        console.log(bgRedBright(bold2(` ROUTE `)) + ` ${red("Invalid Route (No handler exported)")} ${dim2(finalPath)}`);
-      }
+      await processFile(app, item, itemPath);
     }
   }
 };
 
 // src/core/sparkzen.ts
-function sparkzenBanner(message, color) {
-  const tag = color(bold3(" SPARKZEN "));
-  const line = dim3("\u2500".repeat(10 * 2 + message.length + 2));
-  console.log(`
-${tag} ${bold3(message)} ${tag}
-${line}`);
-}
 async function sparkzen() {
+  await setConfig();
   sparkzenBanner("INITIALIZING API", bgBlueBright2);
   const app = fastify().withTypeProvider();
-  sparkzenBanner("LOADING ROUTES", bgGreenBright);
+  sparkzenBanner("LOADING ROUTES", bgGreenBright2);
   await loadRoutes(app);
   console.log();
-  const originalListen = app.listen.bind(app);
-  app.listen = async function(opts) {
-    try {
-      sparkzenBanner("STARTING SERVER", bgGreenBright);
-      const result = await originalListen(opts);
-      console.log(`${bgGreenBright(bold3(" SERVER "))} Running at: ${blue(`http://localhost:${opts.port}`)}
-`);
-      return result;
-    } catch (err) {
-      error("ERROR", err.message);
-    }
-  };
+  manageListen(app);
+  app.setErrorHandler(errorHandler);
   return app;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparkzen",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "license": "MIT",
   "author": "Matheus dos Santos Paixão",
   "type": "module",