@basicbenframework/core 0.1.0

package/src/validation/index.js

@@ -0,0 +1,436 @@
+/**
+ * Validation system.
+ * Simple, composable validation with async support.
+ */
+
+import { db } from '../db/index.js'
+
+/**
+ * Validate data against rules
+ *
+ * @param {Object} data - Data to validate
+ * @param {Object} schema - Validation schema { field: [rules] }
+ * @returns {ValidationResult}
+ *
+ * @example
+ * const result = await validate(req.body, {
+ *   email: [rules.required, rules.email],
+ *   password: [rules.required, rules.min(8)]
+ * })
+ *
+ * if (result.fails()) {
+ *   return res.status(422).json({ errors: result.errors })
+ * }
+ */
+export async function validate(data, schema) {
+  const errors = {}
+
+  for (const [field, fieldRules] of Object.entries(schema)) {
+    const value = data[field]
+    const fieldErrors = []
+
+    for (const rule of fieldRules) {
+      // Skip remaining rules if field is optional and empty
+      if (rule === rules.optional) {
+        if (isEmpty(value)) break
+        continue
+      }
+
+      const error = await rule(value, field, data)
+
+      if (error) {
+        fieldErrors.push(error)
+        // Stop on first error for this field
+        break
+      }
+    }
+
+    if (fieldErrors.length > 0) {
+      errors[field] = fieldErrors
+    }
+  }
+
+  return new ValidationResult(errors)
+}
+
+/**
+ * Validation result class
+ */
+class ValidationResult {
+  constructor(errors) {
+    this.errors = errors
+  }
+
+  /**
+   * Check if validation failed
+   */
+  fails() {
+    return Object.keys(this.errors).length > 0
+  }
+
+  /**
+   * Check if validation passed
+   */
+  passes() {
+    return !this.fails()
+  }
+
+  /**
+   * Get first error for a field
+   */
+  first(field) {
+    return this.errors[field]?.[0] || null
+  }
+
+  /**
+   * Get all errors as flat array
+   */
+  all() {
+    const flat = []
+    for (const [field, messages] of Object.entries(this.errors)) {
+      for (const message of messages) {
+        flat.push({ field, message })
+      }
+    }
+    return flat
+  }
+}
+
+/**
+ * Built-in validation rules
+ */
+export const rules = {
+  /**
+   * Field is required
+   */
+  required: (value, field) => {
+    if (isEmpty(value)) {
+      return `${field} is required`
+    }
+    return null
+  },
+
+  /**
+   * Field is optional (stops validation chain if empty)
+   */
+  optional: 'optional', // Marker, handled specially in validate()
+
+  /**
+   * Must be a string
+   */
+  string: (value, field) => {
+    if (value !== undefined && value !== null && typeof value !== 'string') {
+      return `${field} must be a string`
+    }
+    return null
+  },
+
+  /**
+   * Must be a number or numeric string
+   */
+  numeric: (value, field) => {
+    if (value !== undefined && value !== null && isNaN(Number(value))) {
+      return `${field} must be a number`
+    }
+    return null
+  },
+
+  /**
+   * Must be an integer
+   */
+  integer: (value, field) => {
+    if (value !== undefined && value !== null && !Number.isInteger(Number(value))) {
+      return `${field} must be an integer`
+    }
+    return null
+  },
+
+  /**
+   * Must be a boolean
+   */
+  boolean: (value, field) => {
+    if (value !== undefined && value !== null && typeof value !== 'boolean') {
+      return `${field} must be a boolean`
+    }
+    return null
+  },
+
+  /**
+   * Must be an array
+   */
+  array: (value, field) => {
+    if (value !== undefined && value !== null && !Array.isArray(value)) {
+      return `${field} must be an array`
+    }
+    return null
+  },
+
+  /**
+   * Must be a valid email
+   */
+  email: (value, field) => {
+    if (isEmpty(value)) return null
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailRegex.test(value)) {
+      return `${field} must be a valid email`
+    }
+    return null
+  },
+
+  /**
+   * Must be a valid URL
+   */
+  url: (value, field) => {
+    if (isEmpty(value)) return null
+    try {
+      new URL(value)
+      return null
+    } catch {
+      return `${field} must be a valid URL`
+    }
+  },
+
+  /**
+   * Minimum length (string) or value (number)
+   */
+  min: (minValue) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (typeof value === 'string' && value.length < minValue) {
+      return `${field} must be at least ${minValue} characters`
+    }
+    if (typeof value === 'number' && value < minValue) {
+      return `${field} must be at least ${minValue}`
+    }
+    return null
+  },
+
+  /**
+   * Maximum length (string) or value (number)
+   */
+  max: (maxValue) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (typeof value === 'string' && value.length > maxValue) {
+      return `${field} must be at most ${maxValue} characters`
+    }
+    if (typeof value === 'number' && value > maxValue) {
+      return `${field} must be at most ${maxValue}`
+    }
+    return null
+  },
+
+  /**
+   * Value must be between min and max (inclusive)
+   */
+  between: (min, max) => (value, field) => {
+    if (isEmpty(value)) return null
+    const num = Number(value)
+    if (isNaN(num) || num < min || num > max) {
+      return `${field} must be between ${min} and ${max}`
+    }
+    return null
+  },
+
+  /**
+   * Value must be in allowed list
+   */
+  in: (...allowed) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (!allowed.includes(value)) {
+      return `${field} must be one of: ${allowed.join(', ')}`
+    }
+    return null
+  },
+
+  /**
+   * Value must not be in disallowed list
+   */
+  notIn: (...disallowed) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (disallowed.includes(value)) {
+      return `${field} must not be one of: ${disallowed.join(', ')}`
+    }
+    return null
+  },
+
+  /**
+   * Must match regex pattern
+   */
+  regex: (pattern) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (!pattern.test(value)) {
+      return `${field} format is invalid`
+    }
+    return null
+  },
+
+  /**
+   * Must match another field (e.g., password confirmation)
+   */
+  confirmed: (confirmField) => (value, field, data) => {
+    const confirmFieldName = confirmField || `${field}_confirmation`
+    if (value !== data[confirmFieldName]) {
+      return `${field} confirmation does not match`
+    }
+    return null
+  },
+
+  /**
+   * Must be different from another field
+   */
+  different: (otherField) => (value, field, data) => {
+    if (value === data[otherField]) {
+      return `${field} must be different from ${otherField}`
+    }
+    return null
+  },
+
+  /**
+   * String must match exact length
+   */
+  length: (len) => (value, field) => {
+    if (isEmpty(value)) return null
+    if (typeof value === 'string' && value.length !== len) {
+      return `${field} must be exactly ${len} characters`
+    }
+    return null
+  },
+
+  /**
+   * Must be alphanumeric
+   */
+  alphanumeric: (value, field) => {
+    if (isEmpty(value)) return null
+    if (!/^[a-zA-Z0-9]+$/.test(value)) {
+      return `${field} must contain only letters and numbers`
+    }
+    return null
+  },
+
+  /**
+   * Must be alpha only
+   */
+  alpha: (value, field) => {
+    if (isEmpty(value)) return null
+    if (!/^[a-zA-Z]+$/.test(value)) {
+      return `${field} must contain only letters`
+    }
+    return null
+  },
+
+  /**
+   * Must be a valid date
+   */
+  date: (value, field) => {
+    if (isEmpty(value)) return null
+    const date = new Date(value)
+    if (isNaN(date.getTime())) {
+      return `${field} must be a valid date`
+    }
+    return null
+  },
+
+  /**
+   * Date must be before another date
+   */
+  before: (dateStr) => (value, field) => {
+    if (isEmpty(value)) return null
+    const date = new Date(value)
+    const beforeDate = new Date(dateStr)
+    if (date >= beforeDate) {
+      return `${field} must be before ${dateStr}`
+    }
+    return null
+  },
+
+  /**
+   * Date must be after another date
+   */
+  after: (dateStr) => (value, field) => {
+    if (isEmpty(value)) return null
+    const date = new Date(value)
+    const afterDate = new Date(dateStr)
+    if (date <= afterDate) {
+      return `${field} must be after ${dateStr}`
+    }
+    return null
+  },
+
+  /**
+   * Value must be unique in database table
+   *
+   * @param {string} table - Table name
+   * @param {string} [column] - Column name (defaults to field name)
+   * @param {number|string} [exceptId] - ID to exclude (for updates)
+   *
+   * @example
+   * // Check email is unique
+   * email: [rules.unique('users')]
+   *
+   * // Check email is unique, excluding current user
+   * email: [rules.unique('users', 'email', userId)]
+   */
+  unique: (table, column, exceptId) => async (value, field) => {
+    if (isEmpty(value)) return null
+
+    const col = column || field
+    const query = await db.table(table)
+
+    query.where(col, value)
+
+    if (exceptId !== undefined) {
+      query.where('id', '!=', exceptId)
+    }
+
+    const exists = await query.exists()
+
+    if (exists) {
+      return `${field} has already been taken`
+    }
+    return null
+  },
+
+  /**
+   * Value must exist in database table
+   *
+   * @param {string} table - Table name
+   * @param {string} [column] - Column name (defaults to 'id')
+   *
+   * @example
+   * // Check user_id exists in users table
+   * user_id: [rules.exists('users')]
+   *
+   * // Check category exists by slug
+   * category: [rules.exists('categories', 'slug')]
+   */
+  exists: (table, column = 'id') => async (value, field) => {
+    if (isEmpty(value)) return null
+
+    const query = await db.table(table)
+    const exists = await query.where(column, value).exists()
+
+    if (!exists) {
+      return `${field} does not exist`
+    }
+    return null
+  }
+}
+
+/**
+ * Check if value is empty
+ */
+function isEmpty(value) {
+  return value === undefined || value === null || value === ''
+}
+
+/**
+ * Create custom rule with custom message
+ */
+export function rule(validator, message) {
+  return async (value, field, data) => {
+    const result = await validator(value, field, data)
+    if (result === false) {
+      return typeof message === 'function' ? message(field, value) : message
+    }
+    return null
+  }
+}

package/src/vite/config.js

@@ -0,0 +1,49 @@
+/**
+ * BasicBen Vite configuration.
+ * Provides base config with API proxy and React plugin.
+ */
+
+import react from '@vitejs/plugin-react'
+
+/**
+ * Create Vite config with BasicBen defaults
+ *
+ * @param {Object} options - Override options
+ * @returns {Object} Vite config
+ */
+export function defineConfig(options = {}) {
+  const apiPort = process.env.VITE_API_PORT || 3001
+
+  return {
+    plugins: [
+      react(),
+      ...(options.plugins || [])
+    ],
+
+    server: {
+      port: 3000,
+      strictPort: true,
+      proxy: {
+        '/api': {
+          target: `http://localhost:${apiPort}`,
+          changeOrigin: true
+        },
+        ...options.proxy
+      },
+      ...options.server
+    },
+
+    build: {
+      outDir: 'dist/client',
+      ...options.build
+    },
+
+    // Merge any additional options
+    ...options
+  }
+}
+
+/**
+ * Default export for direct use in vite.config.js
+ */
+export default defineConfig()

package/stubs/controller.stub

@@ -0,0 +1,48 @@
+/**
+ * {{Name}}Controller
+ */
+
+export const {{Name}}Controller = {
+  /**
+   * List all {{pluralLower}}
+   * GET /{{pluralLower}}
+   */
+  index: async (req, res) => {
+    res.json({ message: '{{Name}} index' })
+  },
+
+  /**
+   * Show a single {{lower}}
+   * GET /{{pluralLower}}/:id
+   */
+  show: async (req, res) => {
+    const { id } = req.params
+    res.json({ message: `{{Name}} show ${id}` })
+  },
+
+  /**
+   * Create a new {{lower}}
+   * POST /{{pluralLower}}
+   */
+  create: async (req, res) => {
+    res.status(201).json({ message: '{{Name}} created' })
+  },
+
+  /**
+   * Update a {{lower}}
+   * PUT /{{pluralLower}}/:id
+   */
+  update: async (req, res) => {
+    const { id } = req.params
+    res.json({ message: `{{Name}} updated ${id}` })
+  },
+
+  /**
+   * Delete a {{lower}}
+   * DELETE /{{pluralLower}}/:id
+   */
+  destroy: async (req, res) => {
+    const { id } = req.params
+    res.status(204).send()
+  }
+}

package/stubs/middleware-auth.stub

@@ -0,0 +1,29 @@
+/**
+ * Auth middleware
+ *
+ * Verifies JWT token from Authorization header.
+ * Adds user payload to req.user if valid.
+ */
+
+import { verifyJwt } from 'basicben/auth'
+
+export default async (req, res, next) => {
+  const authHeader = req.headers.authorization
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    res.statusCode = 401
+    return res.json({ error: 'No token provided' })
+  }
+
+  const token = authHeader.slice(7) // Remove 'Bearer '
+
+  const payload = verifyJwt(token, process.env.APP_KEY)
+
+  if (!payload) {
+    res.statusCode = 401
+    return res.json({ error: 'Invalid or expired token' })
+  }
+
+  req.user = payload
+  next()
+}

package/stubs/middleware.stub

@@ -0,0 +1,9 @@
+/**
+ * {{Name}} middleware
+ */
+
+export default async (req, res, next) => {
+  // Add your middleware logic here
+
+  next()
+}

package/stubs/migration.stub

@@ -0,0 +1,17 @@
+/**
+ * Migration: {{description}}
+ */
+
+export const up = async (db) => {
+  await db.exec(`
+    CREATE TABLE {{tableName}} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `)
+}
+
+export const down = async (db) => {
+  await db.exec('DROP TABLE IF EXISTS {{tableName}}')
+}

package/stubs/model.stub

@@ -0,0 +1,77 @@
+/**
+ * {{Name}} model
+ */
+
+import { db } from 'basicben'
+
+export const {{Name}} = {
+  /**
+   * Table name
+   */
+  table: '{{tableName}}',
+
+  /**
+   * Columns that can be mass-assigned.
+   * Add column names here to allow them in create/update operations.
+   */
+  fillable: [
+    // 'name',
+    // 'email',
+  ],
+
+  /**
+   * Get all {{pluralLower}}
+   */
+  all: async () => {
+    return (await db.table('{{tableName}}')).get()
+  },
+
+  /**
+   * Find {{lower}} by ID
+   */
+  find: async (id) => {
+    return (await db.table('{{tableName}}')).find(id)
+  },
+
+  /**
+   * Create a new {{lower}}
+   *
+   * Uses mass assignment protection - only columns in `fillable` are allowed.
+   */
+  create: async (data) => {
+    return (await db.table('{{tableName}}'))
+      .only(...{{Name}}.fillable)
+      .insert(data)
+  },
+
+  /**
+   * Update a {{lower}}
+   *
+   * Uses mass assignment protection - only columns in `fillable` are allowed.
+   */
+  update: async (id, data) => {
+    return (await db.table('{{tableName}}'))
+      .only(...{{Name}}.fillable)
+      .where('id', id)
+      .update(data)
+  },
+
+  /**
+   * Delete a {{lower}}
+   */
+  destroy: async (id) => {
+    return (await db.table('{{tableName}}'))
+      .where('id', id)
+      .delete()
+  },
+
+  /**
+   * Query builder for custom queries.
+   *
+   * @example
+   * const active = await {{Name}}.query().where('active', true).get()
+   */
+  query: async () => {
+    return db.table('{{tableName}}')
+  }
+}

package/stubs/route.stub

@@ -0,0 +1,13 @@
+/**
+ * {{Name}} routes
+ */
+
+import { {{Name}}Controller } from '../controllers/{{Name}}Controller.js'
+
+export default (router) => {
+  router.get('/{{pluralLower}}', {{Name}}Controller.index)
+  router.get('/{{pluralLower}}/:id', {{Name}}Controller.show)
+  router.post('/{{pluralLower}}', {{Name}}Controller.create)
+  router.put('/{{pluralLower}}/:id', {{Name}}Controller.update)
+  router.delete('/{{pluralLower}}/:id', {{Name}}Controller.destroy)
+}

package/stubs/seed.stub

@@ -0,0 +1,16 @@
+/**
+ * {{name}} seeder
+ * Run with: basicben seed {{lower}}
+ */
+
+import { db } from 'basicben'
+
+export async function seed() {
+  // Example: Insert sample data
+  // await (await db.table('{{tableName}}')).insert({
+  //   name: 'Sample',
+  //   created_at: new Date().toISOString()
+  // })
+
+  console.log('{{name}} seeder completed')
+}

package/stubs/vite.config.stub

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