256 lines
10 KiB
JavaScript
256 lines
10 KiB
JavaScript
import express from 'express';
|
|
import cors from 'cors';
|
|
import pg from 'pg';
|
|
import bcrypt from 'bcryptjs';
|
|
import jwt from 'jsonwebtoken';
|
|
import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
|
|
import { join, dirname } from 'path';
|
|
import { fileURLToPath } from 'url';
|
|
import { config } from 'dotenv';
|
|
import serveStatic from 'serve-static';
|
|
|
|
config();
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
const DATA_DIR = join(__dirname, 'data');
|
|
const DIST_DIR = join(__dirname, '..', 'dist');
|
|
mkdirSync(DATA_DIR, { recursive: true });
|
|
|
|
const app = express();
|
|
app.use(cors());
|
|
app.use(express.json());
|
|
|
|
const { Pool } = pg;
|
|
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
|
|
|
|
const JWT_SECRET = process.env.JWT_SECRET || 'stackpilot-dev-secret';
|
|
|
|
// ============ AUTH MIDDLEWARE ============
|
|
function authMiddleware(req, res, next) {
|
|
const token = req.headers.authorization?.replace('Bearer ', '');
|
|
if (!token) return res.status(401).json({ error: 'Authentication required' });
|
|
try {
|
|
req.user = jwt.verify(token, JWT_SECRET);
|
|
next();
|
|
} catch (e) {
|
|
res.status(401).json({ error: 'Invalid token' });
|
|
}
|
|
}
|
|
|
|
function optionalAuth(req, res, next) {
|
|
const token = req.headers.authorization?.replace('Bearer ', '');
|
|
if (token) {
|
|
try { req.user = jwt.verify(token, JWT_SECRET); } catch (e) {}
|
|
}
|
|
next();
|
|
}
|
|
|
|
// ============ AUTH ROUTES ============
|
|
app.post('/api/auth/register', async (req, res) => {
|
|
const { username, email, password, display_name } = req.body;
|
|
if (!username || !email || !password) {
|
|
return res.status(400).json({ error: 'username, email, and password required' });
|
|
}
|
|
if (password.length < 6) {
|
|
return res.status(400).json({ error: 'Password must be at least 6 characters' });
|
|
}
|
|
try {
|
|
const hash = await bcrypt.hash(password, 10);
|
|
const result = await pool.query(
|
|
'INSERT INTO users (username, email, password_hash, display_name) VALUES ($1, $2, $3, $4) RETURNING id, username, email, display_name, created_at',
|
|
[username, email, hash, display_name || username]
|
|
);
|
|
const user = result.rows[0];
|
|
const token = jwt.sign({ id: user.id, username: user.username }, JWT_SECRET, { expiresIn: '30d' });
|
|
res.json({ user, token });
|
|
} catch (e) {
|
|
if (e.code === '23505') {
|
|
return res.status(409).json({ error: 'Username or email already exists' });
|
|
}
|
|
res.status(500).json({ error: 'Registration failed' });
|
|
}
|
|
});
|
|
|
|
app.post('/api/auth/login', async (req, res) => {
|
|
const { email, password } = req.body;
|
|
if (!email || !password) {
|
|
return res.status(400).json({ error: 'email and password required' });
|
|
}
|
|
try {
|
|
const result = await pool.query('SELECT * FROM users WHERE email = $1', [email]);
|
|
const user = result.rows[0];
|
|
if (!user || !(await bcrypt.compare(password, user.password_hash))) {
|
|
return res.status(401).json({ error: 'Invalid email or password' });
|
|
}
|
|
const token = jwt.sign({ id: user.id, username: user.username }, JWT_SECRET, { expiresIn: '30d' });
|
|
res.json({
|
|
user: { id: user.id, username: user.username, email: user.email, display_name: user.display_name },
|
|
token
|
|
});
|
|
} catch (e) {
|
|
res.status(500).json({ error: 'Login failed' });
|
|
}
|
|
});
|
|
|
|
app.get('/api/auth/me', authMiddleware, async (req, res) => {
|
|
const result = await pool.query('SELECT id, username, email, display_name, avatar_url, created_at FROM users WHERE id = $1', [req.user.id]);
|
|
if (result.rows.length === 0) return res.status(404).json({ error: 'User not found' });
|
|
res.json(result.rows[0]);
|
|
});
|
|
|
|
// ============ COMMUNITY STACKS (GALLERY) ============
|
|
app.get('/api/stacks', optionalAuth, async (req, res) => {
|
|
const { sort = 'stars', search, tag, limit = 20, offset = 0 } = req.query;
|
|
let query = 'SELECT s.*, u.username, u.display_name FROM stacks s JOIN users u ON s.user_id = u.id WHERE s.is_public = true';
|
|
const params = [];
|
|
let paramIdx = 1;
|
|
|
|
if (search) {
|
|
query += ` AND (s.name ILIKE $${paramIdx} OR s.description ILIKE $${paramIdx})`;
|
|
params.push(`%${search}%`);
|
|
paramIdx++;
|
|
}
|
|
if (tag) {
|
|
query += ` AND $${paramIdx} = ANY(s.tags)`;
|
|
params.push(tag);
|
|
paramIdx++;
|
|
}
|
|
|
|
const orderMap = { stars: 'stars DESC', downloads: 'downloads DESC', recent: 'created_at DESC' };
|
|
query += ` ORDER BY ${orderMap[sort] || 'stars DESC'}`;
|
|
query += ` LIMIT $${paramIdx} OFFSET $${paramIdx + 1}`;
|
|
params.push(limit, offset);
|
|
|
|
const result = await pool.query(query, params);
|
|
|
|
// If user is logged in, mark which ones they've starred
|
|
if (req.user) {
|
|
const starResult = await pool.query('SELECT stack_id FROM stars WHERE user_id = $1', [req.user.id]);
|
|
const starred = new Set(starResult.rows.map(r => r.stack_id));
|
|
result.rows.forEach(s => { s.starred_by_me = starred.has(s.id); });
|
|
}
|
|
|
|
res.json(result.rows);
|
|
});
|
|
|
|
app.get('/api/stacks/:id', optionalAuth, async (req, res) => {
|
|
const result = await pool.query(
|
|
'SELECT s.*, u.username, u.display_name FROM stacks s JOIN users u ON s.user_id = u.id WHERE s.id = $1',
|
|
[req.params.id]
|
|
);
|
|
if (result.rows.length === 0) return res.status(404).json({ error: 'Stack not found' });
|
|
const stack = result.rows[0];
|
|
if (!stack.is_public && (!req.user || req.user.id !== stack.user_id)) {
|
|
return res.status(404).json({ error: 'Stack not found' });
|
|
}
|
|
res.json(stack);
|
|
});
|
|
|
|
app.post('/api/stacks', authMiddleware, async (req, res) => {
|
|
const { name, description, apps, config: stackConfig, tags, is_public = true } = req.body;
|
|
if (!name || !apps || !Array.isArray(apps) || apps.length === 0) {
|
|
return res.status(400).json({ error: 'name and apps array required' });
|
|
}
|
|
const result = await pool.query(
|
|
'INSERT INTO stacks (user_id, name, description, apps, config, tags, is_public) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *',
|
|
[req.user.id, name, description || '', apps, stackConfig || {}, tags || [], is_public]
|
|
);
|
|
res.json(result.rows[0]);
|
|
});
|
|
|
|
app.put('/api/stacks/:id', authMiddleware, async (req, res) => {
|
|
const { name, description, apps, config: stackConfig, tags, is_public } = req.body;
|
|
const existing = await pool.query('SELECT * FROM stacks WHERE id = $1 AND user_id = $2', [req.params.id, req.user.id]);
|
|
if (existing.rows.length === 0) return res.status(404).json({ error: 'Stack not found or not yours' });
|
|
|
|
const result = await pool.query(
|
|
'UPDATE stacks SET name = COALESCE($1, name), description = COALESCE($2, description), apps = COALESCE($3, apps), config = COALESCE($4, config), tags = COALESCE($5, tags), is_public = COALESCE($6, is_public), updated_at = NOW() WHERE id = $7 RETURNING *',
|
|
[name, description, apps, stackConfig, tags, is_public, req.params.id]
|
|
);
|
|
res.json(result.rows[0]);
|
|
});
|
|
|
|
app.delete('/api/stacks/:id', authMiddleware, async (req, res) => {
|
|
await pool.query('DELETE FROM stars WHERE stack_id = $1', [req.params.id]);
|
|
const result = await pool.query('DELETE FROM stacks WHERE id = $1 AND user_id = $2 RETURNING id', [req.params.id, req.user.id]);
|
|
if (result.rows.length === 0) return res.status(404).json({ error: 'Stack not found or not yours' });
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
// Star/unstar
|
|
app.post('/api/stacks/:id/star', authMiddleware, async (req, res) => {
|
|
try {
|
|
await pool.query('INSERT INTO stars (user_id, stack_id) VALUES ($1, $2)', [req.user.id, req.params.id]);
|
|
await pool.query('UPDATE stacks SET stars = stars + 1 WHERE id = $1', [req.params.id]);
|
|
res.json({ starred: true });
|
|
} catch (e) {
|
|
if (e.code === '23505') {
|
|
// Already starred — unstar
|
|
await pool.query('DELETE FROM stars WHERE user_id = $1 AND stack_id = $2', [req.user.id, req.params.id]);
|
|
await pool.query('UPDATE stacks SET stars = GREATEST(stars - 1, 0) WHERE id = $1', [req.params.id]);
|
|
res.json({ starred: false });
|
|
} else {
|
|
res.status(500).json({ error: 'Failed to star' });
|
|
}
|
|
}
|
|
});
|
|
|
|
// Track stack download
|
|
app.post('/api/stacks/:id/download', async (req, res) => {
|
|
await pool.query('UPDATE stacks SET downloads = downloads + 1 WHERE id = $1', [req.params.id]);
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
// My stacks
|
|
app.get('/api/my/stacks', authMiddleware, async (req, res) => {
|
|
const result = await pool.query('SELECT * FROM stacks WHERE user_id = $1 ORDER BY updated_at DESC', [req.user.id]);
|
|
res.json(result.rows);
|
|
});
|
|
|
|
// ============ ANALYTICS (from before) ============
|
|
const POPULARITY_FILE = join(DATA_DIR, 'popularity.json');
|
|
const DOWNLOADS_FILE = join(DATA_DIR, 'downloads.json');
|
|
|
|
function loadJson(path, fallback) { return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : fallback; }
|
|
function saveJson(path, data) { writeFileSync(path, JSON.stringify(data, null, 2)); }
|
|
|
|
app.post('/api/analytics/download', (req, res) => {
|
|
const { apps, timestamp } = req.body;
|
|
if (!apps || !Array.isArray(apps)) return res.status(400).json({ error: 'apps array required' });
|
|
const popularity = loadJson(POPULARITY_FILE, {});
|
|
for (const appId of apps) { popularity[appId] = (popularity[appId] || 0) + 1; }
|
|
saveJson(POPULARITY_FILE, popularity);
|
|
const downloads = loadJson(DOWNLOADS_FILE, { total: 0, history: [] });
|
|
downloads.total += 1;
|
|
downloads.history.push({ timestamp: timestamp || new Date().toISOString(), apps, count: apps.length });
|
|
if (downloads.history.length > 10000) downloads.history = downloads.history.slice(-10000);
|
|
saveJson(DOWNLOADS_FILE, downloads);
|
|
res.json({ ok: true, total_downloads: downloads.total });
|
|
});
|
|
|
|
app.get('/api/analytics/popularity', (req, res) => { res.json(loadJson(POPULARITY_FILE, {})); });
|
|
|
|
app.get('/api/analytics/stats', (req, res) => {
|
|
const popularity = loadJson(POPULARITY_FILE, {});
|
|
const downloads = loadJson(DOWNLOADS_FILE, { total: 0, history: [] });
|
|
const sorted = Object.entries(popularity).sort((a, b) => b[1] - a[1]);
|
|
res.json({
|
|
total_downloads: downloads.total,
|
|
unique_apps_selected: sorted.length,
|
|
top_20: sorted.slice(0, 20).map(([id, count]) => ({ id, count })),
|
|
recent: downloads.history.slice(-10).reverse(),
|
|
});
|
|
});
|
|
|
|
// ============ STATIC FILES + SPA FALLBACK ============
|
|
app.use(serveStatic(DIST_DIR));
|
|
app.get('*', (req, res) => {
|
|
if (!req.path.startsWith('/api')) {
|
|
res.sendFile(join(DIST_DIR, 'index.html'));
|
|
}
|
|
});
|
|
|
|
// ============ START ============
|
|
const PORT = process.env.PORT || 3052;
|
|
app.listen(PORT, () => { console.log(`StackPilot running on port ${PORT}`); });
|