sparkzen 0.0.3 → 1.0.1

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command4 } from "commander";
+
+// src/cli/commands/init.ts
+import { execSync } from "child_process";
+import { Command } 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";
+var { prompt } = enquirer;
+var promptOptions = async () => {
+  const terminalWidth = process.stdout.columns || 80;
+  const line1 = "  \u{1F680}  Welcome to SparkZen! \u{1F680}  ";
+  const line2 = "  Let's set up your new project.   ";
+  const padFor = (text) => {
+    const available = Math.max(0, terminalWidth - text.length);
+    const half = Math.floor(available / 2);
+    const left = " ".repeat(half);
+    const right = " ".repeat(available - half);
+    return bgBlue(left) + text + bgBlue(right);
+  };
+  logfy(`
+${padFor(line1)}
+${padFor(line2)}
+`, { style: "bold blue -underline" });
+  const answers = await prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      required: true,
+      validate: (v) => v && v.trim() ? true : "Please enter a project name"
+    },
+    {
+      type: "select",
+      name: "packageManager",
+      message: "Package manager:",
+      choices: ["npm", "pnpm", "yarn", "bun"],
+      initial: 0
+    },
+    {
+      type: "confirm",
+      name: "installNow",
+      message: "Do you want to install dependencies now?",
+      initial: true
+    }
+  ]);
+  return answers;
+};
+var cloneProjectTemplate = async (projectName, targetPath) => {
+  console.log(`
+${bgBlue(bold(" \u{1F4C1} CREATING "))} ${projectName}`);
+  await fs.mkdirp(path.dirname(targetPath));
+  console.log(`
+${bgBlue(bold(" \u{1F501} COPYING "))} Default template`);
+  const template = degit("MatheusSantos360/sparkzen-templates/default", {
+    cache: false,
+    force: true
+  });
+  try {
+    await template.clone(targetPath);
+  } catch (err) {
+    throw new Error(`Failed to clone template: ${err.message}`);
+  }
+  const pkgJsonPath = path.join(targetPath, "package.json");
+  if (!await fs.pathExists(pkgJsonPath)) {
+    error("NOT FOUND", "package.json not found in the template.");
+    return;
+  }
+  try {
+    const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, "utf-8"));
+    pkgJson.name = projectName;
+    await fs.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+  } catch (err) {
+    error("ERROR", `Failed to update package.json: ${err.message}`);
+  }
+};
+var installDependencies = (packageManager, targetPath) => {
+  console.log(`
+${bgBlue(bold(" \u26A1 DEPENDENCIES "))} Installing with ${blue(packageManager)}:
+`);
+  try {
+    execSync(`${packageManager} install`, {
+      cwd: targetPath,
+      stdio: "inherit",
+      shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+    });
+  } catch (err) {
+    throw new Error(`Dependency install failed: ${err.message}`);
+  }
+};
+var init = new Command().name("init").description("Initialize a new SparkZen project").action(async () => {
+  try {
+    const { projectName, packageManager, installNow } = await promptOptions();
+    const targetPath = path.resolve(process.cwd(), projectName);
+    await cloneProjectTemplate(projectName, targetPath);
+    if (installNow) {
+      installDependencies(packageManager, targetPath);
+    }
+    console.log();
+    success("CREATED!", `Project "${blue(projectName)}" has been created successfully.`);
+    console.log(`
+${bgBlue(bold(" \u{1F525} NEXT STEPS "))} To get started:
+`);
+    console.log(`    cd ${blue(projectName)}`);
+    console.log(`    ${blue(packageManager)} run ${blue("dev")}
+`);
+  } catch (err) {
+    error("ERROR", err.message);
+    process.exit(1);
+  }
+});
+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";
+import path3 from "path";
+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...
+`);
+  const tsupPath = path3.join(process.cwd(), "node_modules", ".bin", "tsup");
+  execSync3(`${tsupPath} src/index.ts --format esm --dts --out-dir dist`, {
+    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);
+}
+
+// package.json
+var name = "sparkzen";
+var version = "1.0.1";
+
+// src/cli/index.ts
+var program = new Command4();
+program.name(name).description("SparkZen CLI").version(version);
+registerCommands(program);
+program.parse();

package/dist/index.d.ts

@@ -1,3 +1,40 @@
-declare const add: (a: number, b: number) => number;
+import * as fastify from 'fastify';
+import { FastifyRequest, FastifyReply } from 'fastify';
+import * as http from 'http';
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
+import { TSchema, Static } from '@sinclair/typebox';
+export { Static, Type as T } from '@sinclair/typebox';
 
-export { add };
+declare function sparkzen(): Promise<fastify.FastifyInstance<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, fastify.FastifyBaseLogger, TypeBoxTypeProvider>>;
+
+type RouteSchema = {
+    params?: TSchema;
+    body?: TSchema;
+    querystring?: TSchema;
+    headers?: TSchema;
+    response?: Record<number, TSchema>;
+};
+type ResponsePayload<Schema extends RouteSchema, Status extends number> = Schema["response"] extends Record<number, TSchema> ? Status extends keyof Schema["response"] ? Static<Schema["response"][Status]> : unknown : unknown;
+type ResponseKeys<Schema extends RouteSchema> = Schema["response"] extends Record<number, TSchema> ? keyof Schema["response"] & number : number;
+type TypedReply<Schema extends RouteSchema> = Omit<FastifyReply, "send" | "status"> & {
+    status: <Status extends ResponseKeys<Schema>>(statusCode: Status) => {
+        send: (payload: ResponsePayload<Schema, Status>) => FastifyReply;
+    };
+};
+type Handler<Schema extends RouteSchema = {}> = (request: FastifyRequest<{
+    Params: Schema["params"] extends TSchema ? Static<Schema["params"]> : {};
+    Body: Schema["body"] extends TSchema ? Static<Schema["body"]> : {};
+    Querystring: Schema["querystring"] extends TSchema ? Static<Schema["querystring"]> : {};
+    Headers: Schema["headers"] extends TSchema ? Static<Schema["headers"]> : {};
+}>, reply: TypedReply<Schema>) => void | Promise<void>;
+
+type EnsureSchema<S> = S extends TSchema ? S : never;
+type MiddlewareFunction<Schema extends RouteSchema = RouteSchema> = (request: FastifyRequest<{
+    Params: Schema["params"] extends TSchema ? Static<EnsureSchema<Schema["params"]>> : {};
+    Body: Schema["body"] extends TSchema ? Static<EnsureSchema<Schema["body"]>> : {};
+    Querystring: Schema["querystring"] extends TSchema ? Static<EnsureSchema<Schema["querystring"]>> : {};
+    Headers: Schema["headers"] extends TSchema ? Static<EnsureSchema<Schema["headers"]>> : {};
+}>, 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 };

package/dist/index.js

@@ -1,30 +1,118 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+// src/core/sparkzen.ts
+import fastify from "fastify";
+import { bgBlueBright as bgBlueBright2, bgGreenBright, blue, bold as bold3, dim as dim3, error } from "logfy-x";
+
+// src/core/routing/isValidRoute.ts
+var isValidRoute = (routeModule) => {
+  return routeModule && typeof routeModule === "object" && typeof routeModule.default === "function";
+};
+
+// src/core/routing/getRouteURL.ts
+import path from "path";
+var getRouteUrl = (filePath) => {
+  const production = process.env.NODE_ENV === "production";
+  const basePath = production ? process.cwd() : path.join(process.cwd(), "src", "routes");
+  let routePath = filePath.replace(basePath, "").replace(/\\/g, "/").replace(/\.(js|ts)$/, "");
+  const segments = routePath.split("/");
+  segments.pop();
+  routePath = segments.join("/");
+  routePath = routePath.replace(/\[(\w+)\]/g, ":$1");
+  return `/api${routePath}`.replace(/\/+/g, "/");
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// 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);
+  const methodColors = {
+    get: "green",
+    post: "yellow",
+    put: "blue",
+    delete: "red",
+    patch: "magenta"
+  };
+  const routeOptions = {
+    ...routeModule,
+    method,
+    url: routeURL,
+    handler: routeModule.default,
+    preHandler: routeModule.middlewares
+  };
+  app.route(routeOptions);
+  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";
+import path2 from "path";
+
+// src/core/routing/dynamicImport.ts
+var dynamicImport = async (modulePath) => {
+  return await import(modulePath);
+};
+
+// src/core/loadRoutes.ts
+import { bgRedBright, bold as bold2, dim as dim2, red } from "logfy-x";
+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) : path2.join(currentDir, "src", "routes"));
+  const items = await fs.readdir(routesPath, { withFileTypes: true });
+  for (const item of items) {
+    const itemPath = path2.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)}`);
+      }
+    }
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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() {
+  sparkzenBanner("INITIALIZING API", bgBlueBright2);
+  const app = fastify().withTypeProvider();
+  sparkzenBanner("LOADING ROUTES", bgGreenBright);
+  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);
+    }
+  };
+  return app;
+}
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  add: () => add
-});
-module.exports = __toCommonJS(index_exports);
-var add = (a, b) => a + b;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  add
-});
+import { Type } from "@sinclair/typebox";
+var index_default = sparkzen;
+export {
+  Type as T,
+  index_default as default
+};

package/package.json

@@ -1,22 +1,43 @@
 {
   "name": "sparkzen",
+  "version": "1.0.1",
   "license": "MIT",
-  "version": "0.0.3",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "author": "Matheus dos Santos Paixão",
+  "type": "module",
   "private": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./dist/cli/index.js",
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@fastify/type-provider-typebox": "^6.1.0",
+    "@sinclair/typebox": "^0.34.41",
+    "commander": "^14.0.2",
+    "degit": "^2.8.4",
+    "enquirer": "^2.4.1",
+    "fastify": "^5.6.1",
+    "fs-extra": "^11.3.2",
+    "logfy-x": "^1.0.3"
+  },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",
+    "@types/degit": "^2.8.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.9.2",
     "tsup": "^8.5.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.6.3",
+    "vitest": "^4.0.6"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "release": "pnpm run build && changeset publish",
-    "lint": "tsc"
+    "build": "tsup src/index.ts src/cli/index.ts --format esm --dts --out-dir dist",
+    "dev": "tsup src/index.ts src/cli/index.ts --format esm --dts --watch --out-dir dist",
+    "lint": "tsc --noEmit",
+    "test": "vitest",
+    "release": "pnpm run build && changeset publish"
   }
 }

package/.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

package/.changeset/config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
-  "changelog": "@changesets/cli/changelog",
-  "commit": false,
-  "fixed": [],
-  "linked": [],
-  "access": "restricted",
-  "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
-}

package/.github/workflows/main.yml

@@ -1,35 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - "**"
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Lint
-        run: pnpm run lint
-
-      - name: Build
-        run: pnpm run build

package/.github/workflows/publish.yml

@@ -1,45 +0,0 @@
-name: Publish
-
-on:
-  workflow_run:
-    workflows: ["CI"]
-    branches: [main]
-    types: [completed]
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  publish:
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Create Release Pull Request or Publish
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          publish: pnpm run release
-        env:
-          GITHUB_TOKEN: ${{ secrets.MY_GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -1,13 +0,0 @@
-# my-package
-
-## 0.0.3
-
-### Patch Changes
-
-- ec69145: Publish!
-
-## 0.0.2
-
-### Patch Changes
-
-- 59c2b5e: Added the add function.

package/dist/index.d.mts

@@ -1,3 +0,0 @@
-declare const add: (a: number, b: number) => number;
-
-export { add };

package/dist/index.mjs

@@ -1,5 +0,0 @@
-// src/index.ts
-var add = (a, b) => a + b;
-export {
-  add
-};

package/src/index.ts

@@ -1 +0,0 @@
-export const add = (a: number, b: number) => a + b; // Publish!!

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "target": "es2022",
-    "verbatimModuleSyntax": true,
-    "allowJs": true,
-    "resolveJsonModule": true,
-    "moduleDetection": "force",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "moduleResolution": "Bundler",
-    "module": "ESNext",
-    "noEmit": true
-  }
-}