sparkzen 0.0.3 → 1.0.0

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,109 @@
+#!/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 path from "path";
+var { prompt } = enquirer;
+var init = new Command().name("init").description("Initialize a new SparkZen project").action(async () => {
+  const { projectName, packageManager, installNow } = await prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      required: true
+    },
+    {
+      type: "select",
+      name: "packageManager",
+      message: "Package manager:",
+      choices: ["npm", "pnpm", "yarn", "bun"]
+    },
+    {
+      type: "confirm",
+      name: "installNow",
+      message: "Do you want to install dependencies now?",
+      initial: true
+    }
+  ]);
+  const targetPath = path.resolve(process.cwd(), projectName);
+  console.log("\u{1F4C1} Creating project folder...");
+  await fs.mkdir(targetPath, { recursive: true });
+  console.log("\u{1F4E6} Copying template...");
+  const template = degit("MatheusSantos360/sparkzen-templates/default", {
+    cache: false,
+    force: true
+  });
+  await template.clone(projectName);
+  const pkgJsonPath = path.join(targetPath, "package.json");
+  const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, "utf-8"));
+  pkgJson.name = projectName;
+  await fs.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+  console.log(`
+\u{1F680} Project "${projectName}" created successfully!`);
+  if (installNow) {
+    console.log(`\u26A1 Installing dependencies with ${packageManager}...`);
+    execSync(`${packageManager} install`, {
+      cwd: targetPath,
+      stdio: "inherit",
+      shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+    });
+  }
+  console.log(`\u2705 Project ${projectName} created successfully!`);
+  console.log(`
+Next steps:
+  cd ${projectName}
+  ${packageManager} run dev`);
+});
+var init_default = init;
+
+// src/cli/commands/dev.ts
+import { execSync as execSync2 } from "child_process";
+import { Command as Command2 } from "commander";
+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", "tsx");
+  console.log("\u{1F680} Starting dev 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 path3 from "path";
+var build = new Command3().name("build").description("Build the project").action(() => {
+  const projectPath = process.cwd();
+  console.log("\u{1F680} 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"
+  });
+});
+var build_default = build;
+
+// src/cli/commands.ts
+function registerCommands(program2) {
+  program2.addCommand(init_default);
+  program2.addCommand(dev_default);
+  program2.addCommand(build_default);
+}
+
+// src/cli/index.ts
+var program = new Command4();
+program.name("sparkzen").description("SparkZen CLI").version("1.0.0");
+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,85 @@
-"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";
+
+// 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
+var registerRoute = (app, routeModule, method, finalPath) => {
+  const routeURL = getRouteUrl(finalPath);
+  console.log(`Registering route: [${method.toUpperCase()}] ${routeURL}`);
+  const routeOptions = {
+    ...routeModule,
+    method,
+    url: routeURL,
+    handler: routeModule.default,
+    preHandler: routeModule.middlewares
+  };
+  app.route(routeOptions);
+};
+
+// 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
+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.warn(`Invalid route module: ${modulePath}`);
+      }
+    }
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/sparkzen.ts
+async function sparkzen() {
+  const app = fastify().withTypeProvider();
+  await loadRoutes(app);
+  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,42 @@
 {
   "name": "sparkzen",
+  "version": "1.0.0",
   "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"
+  },
   "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
-  }
-}