create-sprint 0.0.1 → 0.0.3

package/bin/cli.js

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+import { select, input, confirm } from "@inquirer/prompts";
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+const args = process.argv.slice(2);
+const hasHelp = args.includes("--help") || args.includes("-h");
+const hasTs = args.includes("--ts") || args.includes("--typescript");
+const hasJs = args.includes("--js") || args.includes("--javascript");
+const hasName = args.indexOf("--name");
+const projectNameArg = hasName !== -1 ? args[hasName + 1] : null;
+const useCurrentDirArg = args.includes("--current");
+const skipInstallArg = args.includes("--no-install");
+const telemetryArg = args.includes("--telemetry") ? args[args.indexOf("--telemetry") + 1] : null;
+const useDockerArg = args.includes("--docker");
+if (hasHelp) {
+    console.log("\n🚀 Sprint - Quickly API Framework\n");
+    console.log("Usage: sprint [options]");
+    console.log("\nOptions:");
+    console.log("  --ts, --typescript      Create TypeScript project");
+    console.log("  --js, --javascript     Create JavaScript project");
+    console.log("  --name <name>          Project name (use '.' for current directory)");
+    console.log("  --no-install           Skip automatic dependency installation");
+    console.log("  --telemetry <type>     Telemetry: none, sentry, glitchtip, discord");
+    console.log("  --docker               Add Docker support");
+    console.log("  --help, -h            Show this help message");
+    console.log("\nExamples:");
+    console.log("  sprint                 Interactive mode");
+    console.log("  sprint --ts            Create TypeScript project");
+    console.log("  sprint --ts --name my-api");
+    console.log("  sprint --js --name . --telemetry sentry --docker\n");
+    process.exit(0);
+}
+async function main() {
+    console.log("\n🚀 Welcome to Sprint - Quickly API Framework\n");
+    let projectName;
+    let language;
+    if (projectNameArg) {
+        projectName = projectNameArg;
+    }
+    else if (useCurrentDirArg) {
+        projectName = ".";
+    }
+    else {
+        projectName = await getProjectName();
+    }
+    if (hasTs) {
+        language = "typescript";
+    }
+    else if (hasJs) {
+        language = "javascript";
+    }
+    else {
+        language = await selectLanguage();
+    }
+    console.log(`\n✅ Creating Sprint project: ${projectName === "." ? "current directory" : projectName} with ${language === "typescript" ? "TypeScript" : "JavaScript"}\n`);
+    await createProject(projectName, language);
+    console.log("\n✅ Project created successfully!");
+    let installDeps = true;
+    if (!skipInstallArg) {
+        installDeps = await confirm({
+            message: "Do you want to install dependencies now?",
+            default: true,
+        });
+    }
+    if (installDeps) {
+        console.log("\n📦 Installing dependencies...\n");
+        const targetDir = projectName === "." ? process.cwd() : join(process.cwd(), projectName);
+        try {
+            execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+            console.log("\n✅ Dependencies installed successfully!");
+        }
+        catch (error) {
+            console.error("\n❌ Error installing dependencies. Please run 'npm install' manually.");
+        }
+    }
+    console.log("\n📦 Next steps:");
+    const cdCmd = projectName === "." ? "" : `cd ${projectName} && `;
+    if (!installDeps) {
+        console.log(`   ${cdCmd}npm install`);
+    }
+    console.log(`   ${cdCmd}npm run dev`);
+    console.log("\n");
+}
+async function getProjectName() {
+    const name = await input({
+        message: "Enter project name:",
+        validate: (value) => {
+            if (!value.trim())
+                return "Please enter a project name";
+            return true;
+        },
+    });
+    return name;
+}
+async function selectLanguage() {
+    const language = await select({
+        message: "Select your preferred language:",
+        choices: [
+            {
+                name: "TypeScript",
+                value: "typescript",
+                description: "Recommended - Type safety and better developer experience",
+            },
+            {
+                name: "JavaScript",
+                value: "javascript",
+                description: "Vanilla JavaScript for simpler projects",
+            },
+        ],
+    });
+    return language;
+}
+async function selectTelemetry() {
+    const telemetry = await select({
+        message: "Select error tracking/telemetry solution:",
+        choices: [
+            {
+                name: "None",
+                value: "none",
+                description: "No error tracking integration",
+            },
+            {
+                name: "Sentry",
+                value: "sentry",
+                description: "Full-featured error tracking (free tier available)",
+            },
+            {
+                name: "GlitchTip",
+                value: "glitchtip",
+                description: "Simple error tracking, can be self-hosted",
+            },
+            {
+                name: "Discord Webhook",
+                value: "discord",
+                description: "Send error notifications to Discord channel",
+            },
+        ],
+    });
+    return telemetry;
+}
+async function createProject(projectName, language) {
+    const isCurrentDir = projectName === ".";
+    const targetDir = isCurrentDir ? process.cwd() : join(process.cwd(), projectName);
+    if (!isCurrentDir && existsSync(targetDir)) {
+        console.error(`Error: Directory ${projectName} already exists`);
+        process.exit(1);
+    }
+    if (!isCurrentDir) {
+        await mkdir(targetDir, { recursive: true });
+    }
+    let telemetry = "none";
+    if (telemetryArg && ["sentry", "glitchtip", "discord", "none"].includes(telemetryArg)) {
+        telemetry = telemetryArg;
+    }
+    else if (!hasTs && !hasJs) {
+        telemetry = await selectTelemetry();
+    }
+    let useDocker = useDockerArg;
+    if (!useDocker && !hasTs && !hasJs) {
+        useDocker = await confirm({
+            message: "Do you want to add Docker support?",
+            default: false,
+        });
+    }
+    let pkgJson;
+    if (language === "typescript") {
+        pkgJson = getTypeScriptPackageJson(projectName, telemetry);
+    }
+    else {
+        pkgJson = getJavaScriptPackageJson(projectName, telemetry);
+    }
+    await writeFile(join(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2));
+    if (language === "typescript") {
+        await writeFile(join(targetDir, "tsconfig.json"), getTsConfig());
+        await writeFile(join(targetDir, "vite.config.ts"), getViteConfig());
+    }
+    const srcDir = join(targetDir, "src");
+    await mkdir(srcDir, { recursive: true });
+    await mkdir(join(srcDir, "middlewares"), { recursive: true });
+    await mkdir(join(srcDir, "routes"), { recursive: true });
+    await mkdir(join(srcDir, "controllers"), { recursive: true });
+    await writeFile(join(srcDir, "middlewares", ".gitkeep"), "");
+    await writeFile(join(srcDir, "controllers", ".gitkeep"), "");
+    await writeFile(join(srcDir, "index." + (language === "typescript" ? "ts" : "js")), getMainFile(language, telemetry));
+    await writeFile(join(srcDir, "routes", "home." + (language === "typescript" ? "ts" : "js")), getHomeRoute(language));
+    if (language === "typescript") {
+        await writeFile(join(srcDir, "app." + (language === "typescript" ? "ts" : "js")), getAppFile(language, telemetry));
+    }
+    await writeFile(join(targetDir, ".env.example"), getEnvExample(telemetry));
+    await writeFile(join(targetDir, ".env"), "");
+    if (telemetry !== "none") {
+        await writeFile(join(targetDir, "sprint.config.js"), getSprintConfig(telemetry));
+    }
+    await writeFile(join(targetDir, ".gitignore"), getGitignore(language));
+    if (useDocker) {
+        await writeFile(join(targetDir, "Dockerfile"), getDockerfile(language));
+        await writeFile(join(targetDir, "docker-compose.yml"), getDockerCompose(language));
+        await writeFile(join(targetDir, ".dockerignore"), getDockerIgnore());
+    }
+}
+function getTypeScriptPackageJson(name, telemetry) {
+    const deps = {
+        "sprint-es": "^0.0.24",
+        dotenv: "^17.0.0",
+    };
+    const devDeps = {
+        "@types/node": "^22.0.0",
+        "tsx": "^4.19.0",
+        typescript: "^5.6.0",
+        vite: "^6.0.0",
+    };
+    if (telemetry === "sentry") {
+        deps["@sentry/node"] = "^8.0.0";
+    }
+    else if (telemetry === "glitchtip") {
+        deps["@sentry/node"] = "^8.0.0";
+    }
+    else if (telemetry === "discord") {
+        deps["axios"] = "^1.6.0";
+    }
+    return {
+        name: name === "." ? "sprint-app" : name,
+        version: "0.0.1",
+        description: "Sprint API",
+        main: "dist/index.js",
+        scripts: {
+            build: "vite build",
+            start: "node dist/index.js --prod",
+            dev: "vite --dev",
+        },
+        dependencies: deps,
+        devDependencies: devDeps,
+    };
+}
+function getJavaScriptPackageJson(name, telemetry) {
+    const deps = {
+        "sprint-es": "^0.0.24",
+        dotenv: "^17.0.0",
+    };
+    if (telemetry === "sentry") {
+        deps["@sentry/node"] = "^8.0.0";
+    }
+    else if (telemetry === "glitchtip") {
+        deps["@sentry/node"] = "^8.0.0";
+    }
+    else if (telemetry === "discord") {
+        deps["axios"] = "^1.6.0";
+    }
+    return {
+        name: name === "." ? "sprint-app" : name,
+        version: "0.0.1",
+        description: "Sprint API",
+        main: "src/index.js",
+        type: "module",
+        scripts: {
+            start: "node src/index.js --prod",
+            dev: "node --watch src/index.js --dev",
+        },
+        dependencies: deps,
+    };
+}
+function getTsConfig() {
+    return JSON.stringify({
+        compilerOptions: {
+            target: "ES2020",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            lib: ["ES2020"],
+            outDir: "./dist",
+            rootDir: "./src",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            declaration: true,
+            declarationMap: true,
+            sourceMap: true,
+            tabWidth: 4,
+        },
+        include: ["src/**/*"],
+        exclude: ["node_modules", "dist"],
+    }, null, 2);
+}
+function getViteConfig() {
+    return `import { defineConfig } from "vite";
+import { resolve } from "path";
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: resolve(__dirname, "src/index.ts"),
+            formats: ["es"],
+            fileName: "index",
+        },
+        outDir: "dist",
+        rollupOptions: {
+            external: ["sprint-es", "express", "cors", "morgan", "serve-favicon", "dotenv"],
+        },
+        target: "ES2020",
+    },
+    resolve: {
+        alias: {
+            "@": resolve(__dirname, "src"),
+        },
+    },
+});
+`;
+}
+function getMainFile(language, telemetry) {
+    const hasTelemetry = telemetry !== "none";
+    if (language === "typescript") {
+        let code = `import Sprint from "sprint-es";
+import dotenv from "dotenv";
+import homeRouter from "./routes/home";
+
+dotenv.config();
+
+`;
+        if (hasTelemetry) {
+            code += getTelemetryImport(language, telemetry);
+        }
+        code += `const app = new Sprint({
+    port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
+    favicon: process.env.FAVICON || undefined,
+    bodyParser: {
+        limit: "10mb"
+    }
+});
+
+app.use(homeRouter);
+
+app.listen();
+`;
+        return code;
+    }
+    let code = `import Sprint from "sprint-es";
+import dotenv from "dotenv";
+import homeRouter from "./routes/home";
+
+dotenv.config();
+
+`;
+    if (hasTelemetry) {
+        code += getTelemetryImport(language, telemetry);
+    }
+    code += `const app = new Sprint({
+    port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
+    favicon: process.env.FAVICON || undefined,
+    bodyParser: {
+        limit: "10mb"
+    }
+});
+
+app.use(homeRouter);
+
+app.listen();
+`;
+    return code;
+}
+function getTelemetryImport(language, telemetry) {
+    if (telemetry === "sentry" || telemetry === "glitchtip") {
+        return `import * as Sentry from "@sentry/node";
+
+Sentry.init({
+    dsn: process.env.SENTRY_DSN,
+    integrations: [
+        Sentry.httpIntegration(),
+    ],
+});
+
+`;
+    }
+    else if (telemetry === "discord") {
+        return `import axios from "axios";
+
+const discordWebhook = process.env.DISCORD_WEBHOOK_URL;
+
+async function sendDiscordError(error, req) {
+    if (!discordWebhook) return;
+
+    const embed = {
+        title: "🚨 Error in Sprint API",
+        description: \`\${error.message}\`,
+        color: 16711680,
+        fields: [
+            {
+                name: "Method",
+                value: req.method,
+                inline: true,
+            },
+            {
+                name: "URL",
+                value: req.url,
+                inline: true,
+            },
+            {
+                name: "Stack",
+                value: error.stack?.split("\\n").slice(0, 5).join("\\n") || "No stack trace",
+            },
+        ],
+        timestamp: new Date().toISOString(),
+    };
+
+    try {
+        await axios.post(discordWebhook, {
+            embeds: [embed],
+        });
+    } catch (e) {
+        console.error("Failed to send Discord webhook:", e.message);
+    }
+}
+
+`;
+    }
+    return "";
+}
+function getAppFile(language, telemetry) {
+    if (language === "typescript") {
+        return `import type { SprintOptions } from "sprint-es";
+
+export const options: SprintOptions = {
+    port: 3000,
+    bodyParser: {
+        limit: "10mb"
+    }
+};
+`;
+    }
+    return "";
+}
+function getEnvExample(telemetry) {
+    let env = `PORT=3000
+FAVICON=./public/favicon.ico
+NODE_ENV=development
+`;
+    if (telemetry === "sentry" || telemetry === "glitchtip") {
+        env += `
+# Sentry / GlitchTip (use GlitchTip DSN for self-hosted)
+SENTRY_DSN=
+`;
+    }
+    else if (telemetry === "discord") {
+        env += `
+# Discord Webhook URL for error notifications
+DISCORD_WEBHOOK_URL=
+`;
+    }
+    return env;
+}
+function getSprintConfig(telemetry) {
+    if (telemetry === "discord") {
+        return `export default {
+    errorHandler: async (error, req, res) => {
+        console.error(error);
+        
+        if (process.env.DISCORD_WEBHOOK_URL && res.socket.server) {
+            const axios = await import("axios");
+            const embed = {
+                title: "🚨 Error in Sprint API",
+                description: error.message,
+                color: 16711680,
+                fields: [
+                    {
+                        name: "Method",
+                        value: req.method,
+                        inline: true,
+                    },
+                    {
+                        name: "URL",
+                        value: req.url,
+                        inline: true,
+                    },
+                    {
+                        name: "Stack",
+                        value: error.stack?.split("\\n").slice(0, 5).join("\\n") || "No stack",
+                    },
+                ],
+                timestamp: new Date().toISOString(),
+            };
+            
+            try {
+                await axios.default.post(process.env.DISCORD_WEBHOOK_URL, {
+                    embeds: [embed],
+                });
+            } catch (e) {
+                console.error("Discord webhook error:", e.message);
+            }
+        }
+        
+        res.status(500).json({ error: "Internal server error" });
+    }
+};
+`;
+    }
+    return "";
+}
+function getHomeRoute(language) {
+    if (language === "typescript") {
+        return `import { Router } from "sprint-es";
+
+const router = Router();
+
+router.get("/", (req, res) => {
+    res.json({
+        message: "Hello World",
+        status: "ok"
+    });
+});
+
+export default router;
+`;
+    }
+    return `import { Router } from "sprint-es";
+
+const router = Router();
+
+router.get("/", (req, res) => {
+    res.json({
+        message: "Hello World",
+        status: "ok"
+    });
+});
+
+export default router;
+`;
+}
+function getDockerfile(language) {
+    if (language === "typescript") {
+        return `FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+
+RUN npm run build
+
+EXPOSE 3000
+
+CMD ["npm", "start"]
+`;
+    }
+    return `FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+
+EXPOSE 3000
+
+CMD ["npm", "start"]
+`;
+}
+function getDockerCompose(language) {
+    if (language === "typescript") {
+        return `version: "3.8"
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    restart: unless-stopped
+`;
+    }
+    return `version: "3.8"
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+    restart: unless-stopped
+`;
+}
+function getGitignore(language) {
+    return `# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build
+dist/
+build/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs/
+*.log
+
+# Test
+coverage/
+
+# Temporary
+tmp/
+temp/
+`;
+}
+function getDockerIgnore() {
+    return `node_modules
+npm-debug.log
+.env
+.env.local
+.git
+.gitignore
+README.md
+dist
+build
+coverage
+.vscode
+.idea
+*.log
+tmp
+temp
+`;
+}
+main().catch(console.error);