apiforge-cli 1.0.1

package/README.md

@@ -0,0 +1,10 @@
+# APIForge 🚀
+
+API generator with ready-made templates for quickly creating projects.
+
+APIForge lets you create different types of APIs using a single command.
+
+## Installation
+
+```bash
+npm install -g apiforge

package/bin/apiforge.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { createProject } from "../lib/create.js";
+
+const args = process.argv.slice(2);
+
+if (args[0] === "-create") {
+  const type = args[1];
+  const name = args[2];
+
+  if (!type || !name) {
+    console.log("Uso: apiforge -create <tipo> <nombre>");
+    process.exit(1);
+  }
+
+  createProject(type, name);
+} else {
+  console.log("Comando no reconocido");
+}

package/lib/create.js

@@ -0,0 +1,24 @@
+import fs from "fs-extra";
+import path from "path";
+
+export function createProject(type, name) {
+  const template = path.join(
+    process.cwd(),
+    "templates",
+    type
+  );
+
+  const destination = path.join(
+    process.cwd(),
+    name
+  );
+
+  if (!fs.existsSync(template)) {
+    console.log("Plantilla no encontrada");
+    return;
+  }
+
+  fs.copySync(template, destination);
+
+  console.log(`Proyecto creado: ${name}`);
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+"name": "apiforge-cli",
+"version": "1.0.1",
+"description": "CLI for automatically creating APIs",
+"type": "module",
+"bin": {
+"apiforge": "./bin/apiforge.js"
+
+},
+"dependencies": {
+"chalk": "^5.0.0",
+"commander": "^12.0.0",
+"fs-extra": "^11.0.0"
+
+}
+}

package/templates/auth/index.js

@@ -0,0 +1,67 @@
+import express from "express";
+import jwt from "jsonwebtoken";
+import bcrypt from "bcrypt";
+
+const app = express();
+
+app.use(express.json());
+
+const SECRET = "apiforge-secret";
+
+const users = [];
+
+app.post("/register", async (req, res) => {
+
+  const password = await bcrypt.hash(
+    req.body.password,
+    10
+  );
+
+  users.push({
+    username: req.body.username,
+    password,
+    role: "user"
+  });
+
+  res.json({
+    created: true
+  });
+
+});
+
+app.post("/login", async (req, res) => {
+
+  const user = users.find(
+    u => u.username === req.body.username
+  );
+
+  if (!user) {
+    return res.status(404).json({
+      error: "User not found"
+    });
+  }
+
+  const token = jwt.sign(
+    {
+      username: user.username,
+      role: user.role
+    },
+    SECRET
+  );
+
+  res.json({
+    token
+  });
+
+});
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "Auth API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("Auth API funcionando");
+});

package/templates/auth/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "auth-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "bcrypt": "^5.1.1"
+  }
+}

package/templates/cors/index.js

@@ -0,0 +1,18 @@
+import express from "express";
+import cors from "cors";
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "CORS API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("CORS API funcionando");
+});

package/templates/cors/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "cors-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "cors": "^2.8.5"
+  }
+}

package/templates/crud/index.js

@@ -0,0 +1,37 @@
+import express from "express";
+
+const app = express();
+
+app.use(express.json());
+
+let users = [];
+
+app.get("/users", (req, res) => {
+  res.json(users);
+});
+
+app.post("/users", (req, res) => {
+  const user = req.body;
+  users.push(user);
+
+  res.json({
+    created: true,
+    user
+  });
+});
+
+app.put("/users/:id", (req, res) => {
+  users[req.params.id] = req.body;
+
+  res.json({
+    updated: true
+  });
+});
+
+app.delete("/users/:id", (req, res) => {
+  users.splice(req.params.id, 1);
+
+  res.json({
+    deleted: true
+  });
+});

package/templates/crud/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "crud-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0"
+  }
+}

package/templates/firebase/index.js

@@ -0,0 +1,15 @@
+import { onRequest } from "firebase-functions/v2/https";
+import express from "express";
+
+const app = express();
+
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "Firebase Functions API",
+    status: "online"
+  });
+});
+
+export const api = onRequest(app);

package/templates/firebase/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "firebase-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "firebase-functions": "^6.0.0",
+    "express": "^5.0.0"
+  }
+}

package/templates/graphql/index.js

@@ -0,0 +1,32 @@
+import express from "express";
+import { graphqlHTTP } from "express-graphql";
+import {
+  buildSchema
+} from "graphql";
+
+const app = express();
+
+const schema = buildSchema(`
+  type Query {
+    hello: String
+  }
+`);
+
+const root = {
+  hello() {
+    return "GraphQL API funcionando";
+  }
+};
+
+app.use(
+  "/graphql",
+  graphqlHTTP({
+    schema,
+    rootValue: root,
+    graphiql: true
+  })
+);
+
+app.listen(3000, () => {
+  console.log("GraphQL API lista");
+});

package/templates/graphql/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "graphql-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "graphql": "^16.0.0",
+    "express-graphql": "^0.12.0"
+  }
+}

package/templates/jwt/index.js

@@ -0,0 +1,33 @@
+import express from "express";
+import jwt from "jsonwebtoken";
+
+const app = express();
+
+app.use(express.json());
+
+const SECRET = "apiforge-secret";
+
+app.post("/login", (req, res) => {
+  const { user } = req.body;
+
+  const token = jwt.sign(
+    { user },
+    SECRET,
+    { expiresIn: "1h" }
+  );
+
+  res.json({
+    token
+  });
+});
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "JWT API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("JWT API funcionando");
+});

package/templates/jwt/package.json

@@ -0,0 +1,10 @@
+cat > templates/jwt/index.js{
+  "name": "jwt-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "jsonwebtoken": "^9.0.2"
+  }
+}

package/templates/mongodb/index.js

@@ -0,0 +1,26 @@
+import express from "express";
+import mongoose from "mongoose";
+
+const app = express();
+
+app.use(express.json());
+
+mongoose.connect("mongodb://127.0.0.1:27017/apiforge");
+
+const User = mongoose.model(
+  "User",
+  new mongoose.Schema({
+    name: String
+  })
+);
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "MongoDB API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("MongoDB API funcionando");
+});

package/templates/mongodb/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "mongodb-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "mongoose": "^8.0.0"
+  }
+}

package/templates/mysql/index.js

@@ -0,0 +1,27 @@
+import express from "express";
+import mysql from "mysql2/promise";
+
+const app = express();
+
+app.use(express.json());
+
+const db = await mysql.createConnection({
+  host: "localhost",
+  user: "root",
+  password: "",
+  database: "apiforge"
+});
+
+app.get("/", async (req, res) => {
+  const [rows] = await db.query("SELECT NOW() AS serverTime");
+
+  res.json({
+    api: "MySQL API",
+    status: "online",
+    serverTime: rows[0].serverTime
+  });
+});
+
+app.listen(3000, () => {
+  console.log("MySQL API funcionando");
+});

package/templates/mysql/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "mysql-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "mysql2": "^3.0.0"
+  }
+}

package/templates/netlify/netlify/functions/index.js

@@ -0,0 +1,14 @@
+export async function handler(event) {
+
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      api: "Netlify Functions API",
+      status: "online"
+    })
+  };
+
+}

package/templates/netlify/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "netlify-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "netlify/functions/index.js",
+  "dependencies": {}
+}

package/templates/oauth2/index.js

@@ -0,0 +1,28 @@
+import express from "express";
+import passport from "passport";
+import { Strategy as OAuth2Strategy } from "passport-oauth2";
+
+const app = express();
+
+passport.use(new OAuth2Strategy({
+  authorizationURL: "https://example.com/oauth/authorize",
+  tokenURL: "https://example.com/oauth/token",
+  clientID: "CLIENT_ID",
+  clientSecret: "CLIENT_SECRET",
+  callbackURL: "/auth/callback"
+}, (accessToken, refreshToken, profile, done) => {
+  return done(null, { accessToken });
+}));
+
+app.use(passport.initialize());
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "OAuth2 API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("OAuth2 API funcionando");
+});

package/templates/oauth2/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "oauth2-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "passport": "^0.7.0",
+    "passport-oauth2": "^1.8.0"
+  }
+}

package/templates/postgres/index.js

@@ -0,0 +1,30 @@
+import express from "express";
+import { Client } from "pg";
+
+const app = express();
+
+app.use(express.json());
+
+const db = new Client({
+  host: "localhost",
+  port: 5432,
+  user: "postgres",
+  password: "password",
+  database: "apiforge"
+});
+
+await db.connect();
+
+app.get("/", async (req, res) => {
+  const result = await db.query("SELECT NOW()");
+
+  res.json({
+    api: "PostgreSQL API",
+    status: "online",
+    serverTime: result.rows[0].now
+  });
+});
+
+app.listen(3000, () => {
+  console.log("PostgreSQL API funcionando");
+});

package/templates/postgres/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "postgres-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "pg": "^8.13.0"
+  }
+}

package/templates/ratelimit/index.js

@@ -0,0 +1,24 @@
+import express from "express";
+import rateLimit from "express-rate-limit";
+
+const app = express();
+
+app.use(express.json());
+
+const limiter = rateLimit({
+  windowMs: 60 * 1000,
+  max: 10
+});
+
+app.use(limiter);
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "Rate Limit API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("Rate Limit API funcionando");
+});

package/templates/ratelimit/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "ratelimit-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "express-rate-limit": "^7.0.0"
+  }
+}

package/templates/receiver/index.js

@@ -0,0 +1,30 @@
+import express from "express";
+
+const app = express();
+
+app.use(express.json());
+
+app.post("/api/data", (req, res) => {
+
+  console.log("Datos recibidos:");
+  console.log(req.body);
+
+  res.json({
+    success: true,
+    received: req.body
+  });
+
+});
+
+app.get("/", (req, res) => {
+
+  res.json({
+    api: "HTTP Receiver",
+    status: "online"
+  });
+
+});
+
+app.listen(3000, () => {
+  console.log("Receiver API en puerto 3000");
+});

package/templates/receiver/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "receiver-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0"
+  }
+}

package/templates/rest/index.js

@@ -0,0 +1,22 @@
+import express from "express";
+
+ const app = express();
+
+ app.use(express.json());
+
+ app.get("/", (req, res) => {
+   res.json({
+     api: "REST API",
+     status: "online"
+   });
+ });
+
+ app.post("/api/data", (req, res) => {
+   res.json({
+     received: req.body
+   });
+ });
+
+ app.listen(3000, () => {
+   console.log("REST API on port 3000");
+ });

package/templates/rest/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "rest-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0"
+  }
+}

package/templates/sqlite/index.js

@@ -0,0 +1,23 @@
+import express from "express";
+import sqlite3 from "sqlite3";
+
+const app = express();
+
+app.use(express.json());
+
+const db = new sqlite3.Database("database.db");
+
+db.serialize(() => {
+  db.run("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)");
+});
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "SQLite API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("SQLite API funcionando");
+});

package/templates/sqlite/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "sqlite-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "sqlite3": "^5.1.7"
+  }
+}

package/templates/swagger/index.js

@@ -0,0 +1,33 @@
+import express from "express";
+import swaggerUi from "swagger-ui-express";
+import swaggerJsdoc from "swagger-jsdoc";
+
+const app = express();
+
+const swaggerSpec = swaggerJsdoc({
+  definition: {
+    openapi: "3.0.0",
+    info: {
+      title: "APIForge API",
+      version: "1.0.0"
+    }
+  },
+  apis: []
+});
+
+app.use(
+  "/docs",
+  swaggerUi.serve,
+  swaggerUi.setup(swaggerSpec)
+);
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "Swagger API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("Swagger API funcionando");
+});

package/templates/swagger/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "swagger-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "swagger-ui-express": "^5.0.0",
+    "swagger-jsdoc": "^6.2.0"
+  }
+}

package/templates/typescript/index.ts

@@ -0,0 +1,16 @@
+import express from "express";
+
+const app = express();
+
+app.use(express.json());
+
+app.get("/", (req, res) => {
+  res.json({
+    api: "TypeScript API",
+    status: "online"
+  });
+});
+
+app.listen(3000, () => {
+  console.log("TypeScript API funcionando");
+});

package/templates/typescript/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "typescript-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "dependencies": {
+    "express": "^5.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0",
+    "@types/express": "^5.0.0"
+  }
+}

package/templates/upload/index.js

@@ -0,0 +1,30 @@
+import express from "express";
+import multer from "multer";
+
+const app = express();
+
+const upload = multer({
+  dest: "uploads/"
+});
+
+app.post("/upload", upload.single("file"), (req, res) => {
+
+  res.json({
+    success: true,
+    file: req.file
+  });
+
+});
+
+app.get("/", (req, res) => {
+
+  res.json({
+    api: "Upload API",
+    status: "online"
+  });
+
+});
+
+app.listen(3000, () => {
+  console.log("Upload API funcionando");
+});

package/templates/upload/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "upload-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "multer": "^2.0.0"
+  }
+}

package/templates/vercel/api/index.js

@@ -0,0 +1,8 @@
+export default function handler(req, res) {
+
+  res.status(200).json({
+    api: "Vercel API",
+    status: "online"
+  });
+
+}

package/templates/vercel/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "vercel-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "api/index.js",
+  "dependencies": {
+    "@vercel/node": "^3.0.0"
+  }
+}

package/templates/websocket/index.js

@@ -0,0 +1,28 @@
+import express from "express";
+import { WebSocketServer } from "ws";
+
+const app = express();
+
+const server = app.listen(3000, () => {
+  console.log("WebSocket API en puerto 3000");
+});
+
+const wss = new WebSocketServer({
+  server
+});
+
+wss.on("connection", (socket) => {
+
+  socket.send("Conectado al WebSocket");
+
+  socket.on("message", (message) => {
+
+    console.log("Mensaje:", message.toString());
+
+    socket.send(
+      "Recibido: " + message
+    );
+
+  });
+
+});

package/templates/websocket/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "websocket-api",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "express": "^5.0.0",
+    "ws": "^8.0.0"
+  }
+}

package/templates/workers/index.js

@@ -0,0 +1,17 @@
+export default {
+  async fetch(request) {
+
+    return new Response(
+      JSON.stringify({
+        api: "Cloudflare Workers API",
+        status: "online"
+      }),
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+
+  }
+};

package/templates/workers/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "workers-api",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "dependencies": {}
+}