@basicbenframework/create 0.1.0

package/template/src/controllers/AuthController.js

@@ -0,0 +1,81 @@
+import { validate, rules } from '@basicbenframework/core/validation'
+import { signJwt, verifyJwt, hashPassword, verifyPassword } from '@basicbenframework/core/auth'
+import { User } from '../models/User.js'
+
+export const AuthController = {
+  async register(req, res) {
+    const result = await validate(req.body, {
+      name: [rules.required, rules.string, rules.min(2)],
+      email: [rules.required, rules.email],
+      password: [rules.required, rules.min(8)]
+    })
+
+    if (result.fails()) {
+      return res.json({ errors: result.errors }, 422)
+    }
+
+    const { name, email, password } = req.body
+
+    // Check if email exists
+    const existing = await User.findByEmail(email)
+    if (existing) {
+      return res.json({ error: 'Email already registered' }, 400)
+    }
+
+    // Create user
+    const user = await User.create({
+      name,
+      email,
+      password: await hashPassword(password)
+    })
+
+    // Generate token
+    const token = signJwt({ userId: user.id }, process.env.APP_KEY, { expiresIn: '7d' })
+
+    res.json({
+      user: { id: user.id, name: user.name, email: user.email },
+      token
+    })
+  },
+
+  async login(req, res) {
+    const { email, password } = req.body
+
+    if (!email || !password) {
+      return res.json({ error: 'Email and password required' }, 400)
+    }
+
+    const user = await User.findByEmail(email)
+    if (!user || !(await verifyPassword(password, user.password))) {
+      return res.json({ error: 'Invalid credentials' }, 401)
+    }
+
+    const token = signJwt({ userId: user.id }, process.env.APP_KEY, { expiresIn: '7d' })
+
+    res.json({
+      user: { id: user.id, name: user.name, email: user.email },
+      token
+    })
+  },
+
+  async user(req, res) {
+    const token = req.headers.authorization?.replace('Bearer ', '')
+    if (!token) {
+      return res.json({ error: 'No token provided' }, 401)
+    }
+
+    const payload = verifyJwt(token, process.env.APP_KEY)
+    if (!payload) {
+      return res.json({ error: 'Invalid token' }, 401)
+    }
+
+    const user = await User.find(payload.userId)
+    if (!user) {
+      return res.json({ error: 'User not found' }, 404)
+    }
+
+    res.json({
+      user: { id: user.id, name: user.name, email: user.email }
+    })
+  }
+}

package/template/src/controllers/HomeController.js

@@ -0,0 +1,17 @@
+/**
+ * Home Controller
+ *
+ * Handles basic application endpoints.
+ */
+
+export const HomeController = {
+  /**
+   * Hello endpoint
+   */
+  hello: async (req, res) => {
+    res.json({
+      message: 'Welcome to BasicBen!',
+      timestamp: new Date().toISOString()
+    })
+  }
+}

package/template/src/controllers/PostController.js

@@ -0,0 +1,86 @@
+import { validate, rules } from '@basicbenframework/core/validation'
+import { Post } from '../models/Post.js'
+
+export const PostController = {
+  async index(req, res) {
+    const posts = await Post.findByUser(req.userId)
+    res.json({ posts })
+  },
+
+  async show(req, res) {
+    const post = await Post.find(req.params.id)
+    if (!post || post.user_id !== req.userId) {
+      return res.json({ error: 'Post not found' }, 404)
+    }
+    res.json({ post })
+  },
+
+  async store(req, res) {
+    const result = await validate(req.body, {
+      title: [rules.required, rules.string, rules.min(3), rules.max(200)],
+      content: [rules.required, rules.string, rules.min(10)]
+    })
+
+    if (result.fails()) {
+      return res.json({ errors: result.errors }, 422)
+    }
+
+    const { title, content, published } = req.body
+    const post = await Post.create({
+      user_id: req.userId,
+      title,
+      content,
+      published: published || false
+    })
+
+    res.json({ post }, 201)
+  },
+
+  async update(req, res) {
+    const post = await Post.find(req.params.id)
+    if (!post || post.user_id !== req.userId) {
+      return res.json({ error: 'Post not found' }, 404)
+    }
+
+    const result = await validate(req.body, {
+      title: [rules.required, rules.string, rules.min(3), rules.max(200)],
+      content: [rules.required, rules.string, rules.min(10)]
+    })
+
+    if (result.fails()) {
+      return res.json({ errors: result.errors }, 422)
+    }
+
+    const { title, content, published } = req.body
+    const updated = await Post.update(req.params.id, {
+      title,
+      content,
+      published: published ? 1 : 0
+    })
+
+    res.json({ post: updated })
+  },
+
+  async destroy(req, res) {
+    const post = await Post.find(req.params.id)
+    if (!post || post.user_id !== req.userId) {
+      return res.json({ error: 'Post not found' }, 404)
+    }
+
+    await Post.delete(req.params.id)
+    res.json({ message: 'Post deleted' })
+  },
+
+  async feed(req, res) {
+    const posts = await Post.findPublished()
+    res.json({ posts })
+  },
+
+  async feedShow(req, res) {
+    const post = await Post.findPublishedById(req.params.id)
+    if (!post) {
+      return res.json({ error: 'Post not found' }, 404)
+    }
+    res.json({ post })
+  }
+}

package/template/src/controllers/ProfileController.js

@@ -0,0 +1,66 @@
+import { validate, rules } from '@basicbenframework/core/validation'
+import { User } from '../models/User.js'
+import { createHash } from 'node:crypto'
+
+function hashPassword(password) {
+  return createHash('sha256').update(password).digest('hex')
+}
+
+export const ProfileController = {
+  async show(req, res) {
+    const user = await User.find(req.userId)
+    if (!user) {
+      return res.json({ error: 'User not found' }, 404)
+    }
+    res.json({
+      user: { id: user.id, name: user.name, email: user.email, created_at: user.created_at }
+    })
+  },
+
+  async update(req, res) {
+    const result = await validate(req.body, {
+      name: [rules.required, rules.string, rules.min(2)],
+      email: [rules.required, rules.email]
+    })
+
+    if (result.fails()) {
+      return res.json({ errors: result.errors }, 422)
+    }
+
+    const { name, email } = req.body
+    const user = await User.find(req.userId)
+
+    if (email !== user.email) {
+      const existing = await User.findByEmail(email)
+      if (existing) {
+        return res.json({ error: 'Email already taken' }, 400)
+      }
+    }
+
+    const updated = await User.update(req.userId, { name, email })
+    res.json({
+      user: { id: updated.id, name: updated.name, email: updated.email }
+    })
+  },
+
+  async changePassword(req, res) {
+    const result = await validate(req.body, {
+      currentPassword: [rules.required],
+      newPassword: [rules.required, rules.min(8)]
+    })
+
+    if (result.fails()) {
+      return res.json({ errors: result.errors }, 422)
+    }
+
+    const { currentPassword, newPassword } = req.body
+    const user = await User.find(req.userId)
+
+    if (user.password !== hashPassword(currentPassword)) {
+      return res.json({ error: 'Current password is incorrect' }, 400)
+    }
+
+    await User.update(req.userId, { password: hashPassword(newPassword) })
+    res.json({ message: 'Password updated successfully' })
+  }
+}

package/template/src/helpers/api.js

@@ -0,0 +1,24 @@
+export const api = async (path, options = {}) => {
+  const token = localStorage.getItem('token')
+  let res
+  try {
+    res = await fetch(path, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        ...options.headers
+      }
+    })
+  } catch {
+    throw new Error('Unable to connect to server')
+  }
+  let data
+  try {
+    data = await res.json()
+  } catch {
+    throw new Error(res.ok ? 'Invalid response from server' : `Server error (${res.status})`)
+  }
+  if (!res.ok) throw new Error(data.error || Object.values(data.errors || {})[0]?.[0] || 'Request failed')
+  return data
+}

package/template/src/main.jsx

@@ -0,0 +1,9 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './routes/App.jsx'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+)

package/template/src/middleware/auth.js

@@ -0,0 +1,16 @@
+import { verifyJwt } from '@basicbenframework/core/auth'
+
+export const auth = async (req, res, next) => {
+  const token = req.headers.authorization?.replace('Bearer ', '')
+  if (!token) {
+    return res.json({ error: 'Unauthorized' }, 401)
+  }
+
+  const payload = verifyJwt(token, process.env.APP_KEY)
+  if (!payload) {
+    return res.json({ error: 'Invalid token' }, 401)
+  }
+
+  req.userId = payload.userId
+  next()
+}

package/template/src/models/Post.js

@@ -0,0 +1,63 @@
+import { getDb } from '@basicbenframework/core/db'
+
+export const Post = {
+  async all() {
+    const db = await getDb()
+    return db.all('SELECT * FROM posts ORDER BY created_at DESC')
+  },
+
+  async find(id) {
+    const db = await getDb()
+    return db.get('SELECT * FROM posts WHERE id = ?', [id])
+  },
+
+  async findByUser(userId) {
+    const db = await getDb()
+    return db.all('SELECT * FROM posts WHERE user_id = ? ORDER BY created_at DESC', [userId])
+  },
+
+  async findPublished() {
+    const db = await getDb()
+    return db.all(`
+      SELECT posts.*, users.name as author_name
+      FROM posts
+      JOIN users ON posts.user_id = users.id
+      WHERE posts.published = 1
+      ORDER BY posts.created_at DESC
+    `)
+  },
+
+  async findPublishedById(id) {
+    const db = await getDb()
+    return db.get(`
+      SELECT posts.*, users.name as author_name
+      FROM posts
+      JOIN users ON posts.user_id = users.id
+      WHERE posts.id = ? AND posts.published = 1
+    `, [id])
+  },
+
+  async create(data) {
+    const db = await getDb()
+    const result = await db.run(
+      'INSERT INTO posts (user_id, title, content, published) VALUES (?, ?, ?, ?)',
+      [data.user_id, data.title, data.content, data.published ? 1 : 0]
+    )
+    return { id: result.lastInsertRowid, ...data }
+  },
+
+  async update(id, data) {
+    const db = await getDb()
+    const fields = Object.keys(data).map(k => `${k} = ?`).join(', ')
+    await db.run(
+      `UPDATE posts SET ${fields}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`,
+      [...Object.values(data), id]
+    )
+    return this.find(id)
+  },
+
+  async delete(id) {
+    const db = await getDb()
+    return db.run('DELETE FROM posts WHERE id = ?', [id])
+  }
+}

package/template/src/models/User.js

@@ -0,0 +1,42 @@
+import { getDb } from '@basicbenframework/core/db'
+
+export const User = {
+  async all() {
+    const db = await getDb()
+    return db.all('SELECT * FROM users')
+  },
+
+  async find(id) {
+    const db = await getDb()
+    return db.get('SELECT * FROM users WHERE id = ?', [id])
+  },
+
+  async findByEmail(email) {
+    const db = await getDb()
+    return db.get('SELECT * FROM users WHERE email = ?', [email])
+  },
+
+  async create(data) {
+    const db = await getDb()
+    const result = await db.run(
+      'INSERT INTO users (name, email, password) VALUES (?, ?, ?)',
+      [data.name, data.email, data.password]
+    )
+    return { id: result.lastInsertRowid, ...data }
+  },
+
+  async update(id, data) {
+    const db = await getDb()
+    const fields = Object.keys(data).map(k => `${k} = ?`).join(', ')
+    await db.run(
+      `UPDATE users SET ${fields} WHERE id = ?`,
+      [...Object.values(data), id]
+    )
+    return this.find(id)
+  },
+
+  async delete(id) {
+    const db = await getDb()
+    return db.run('DELETE FROM users WHERE id = ?', [id])
+  }
+}

package/template/src/routes/App.jsx

@@ -0,0 +1,38 @@
+import { createClientApp } from '@basicbenframework/core/client'
+import { AppLayout } from '../client/layouts/AppLayout'
+import { AuthLayout } from '../client/layouts/AuthLayout'
+import { DocsLayout } from '../client/layouts/DocsLayout'
+import { Home } from '../client/pages/Home'
+import { Auth } from '../client/pages/Auth'
+import { Feed } from '../client/pages/Feed'
+import { FeedPost } from '../client/pages/FeedPost'
+import { Posts } from '../client/pages/Posts'
+import { PostForm } from '../client/pages/PostForm'
+import { Profile } from '../client/pages/Profile'
+import { GettingStarted } from '../client/pages/GettingStarted'
+import { Database } from '../client/pages/Database'
+import { Routing } from '../client/pages/Routing'
+import { Authentication } from '../client/pages/Authentication'
+import { Validation } from '../client/pages/Validation'
+import { Testing } from '../client/pages/Testing'
+
+export default createClientApp({
+  layout: AppLayout,
+  routes: {
+    '/': Home,
+    '/login': { component: Auth, layout: AuthLayout, guest: true },
+    '/register': { component: Auth, layout: AuthLayout, guest: true },
+    '/feed': Feed,
+    '/feed/:id': FeedPost,
+    '/posts': { component: Posts, auth: true },
+    '/posts/new': { component: PostForm, auth: true },
+    '/posts/:id/edit': { component: PostForm, auth: true },
+    '/profile': { component: Profile, auth: true },
+    '/docs': { component: GettingStarted, layout: DocsLayout },
+    '/docs/routing': { component: Routing, layout: DocsLayout },
+    '/docs/database': { component: Database, layout: DocsLayout },
+    '/docs/authentication': { component: Authentication, layout: DocsLayout },
+    '/docs/validation': { component: Validation, layout: DocsLayout },
+    '/docs/testing': { component: Testing, layout: DocsLayout },
+  }
+})

package/template/src/routes/api/auth.js

@@ -0,0 +1,7 @@
+import { AuthController } from '../../controllers/AuthController.js'
+
+export default (router) => {
+  router.post('/api/auth/register', AuthController.register)
+  router.post('/api/auth/login', AuthController.login)
+  router.get('/api/user', AuthController.user)
+}

package/template/src/routes/api/posts.js

@@ -0,0 +1,15 @@
+import { PostController } from '../../controllers/PostController.js'
+import { auth } from '../../middleware/auth.js'
+
+export default (router) => {
+  // Public feed routes
+  router.get('/api/feed', PostController.feed)
+  router.get('/api/feed/:id', PostController.feedShow)
+
+  // Authenticated post routes
+  router.get('/api/posts', auth, PostController.index)
+  router.post('/api/posts', auth, PostController.store)
+  router.get('/api/posts/:id', auth, PostController.show)
+  router.put('/api/posts/:id', auth, PostController.update)
+  router.delete('/api/posts/:id', auth, PostController.destroy)
+}

package/template/src/routes/api/profile.js

@@ -0,0 +1,8 @@
+import { ProfileController } from '../../controllers/ProfileController.js'
+import { auth } from '../../middleware/auth.js'
+
+export default (router) => {
+  router.get('/api/profile', auth, ProfileController.show)
+  router.put('/api/profile', auth, ProfileController.update)
+  router.put('/api/profile/password', auth, ProfileController.changePassword)
+}

package/template/src/server/index.js

@@ -0,0 +1,16 @@
+/**
+ * Server entry point (optional)
+ *
+ * Delete this file to use the default server.
+ * Customize here for websockets, custom middleware, etc.
+ */
+
+import { createServer } from '@basicbenframework/core/server'
+
+const app = await createServer()
+
+const port = process.env.PORT || 3001
+
+app.listen(port, () => {
+  console.log(`Server running at http://localhost:${port}`)
+})

package/template/vite.config.js

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: parseInt(process.env.VITE_PORT || 3000),
+    proxy: {
+      '/api': {
+        target: `http://localhost:${process.env.PORT || 3001}`,
+        changeOrigin: true
+      }
+    }
+  },
+  build: {
+    outDir: 'dist/client'
+  }
+})