webspresso 0.0.10 → 0.0.12

package/README.md

@@ -73,6 +73,8 @@ webspresso new my-app --no-tailwind
 - Asks if you want to install in the current directory
 - If current directory is not empty, shows a warning
 - Prompts for project name (defaults to current folder name)
+- Asks if you will use a database (SQLite, PostgreSQL, or MySQL)
+- If yes, adds the appropriate driver to `package.json` and creates `webspresso.db.js` config
 - After project creation, asks if you want to install dependencies
 - If yes, runs `npm install` and `npm run build:css`
 - Then asks if you want to start the development server
@@ -96,6 +98,43 @@ webspresso new my-app
 
 **Note:** When dev server starts with Tailwind CSS, it automatically runs `watch:css` in the background to watch for CSS changes.
 
+**Database Selection:**
+During project creation, you'll be asked if you want to use a database:
+- **SQLite** (better-sqlite3) - Recommended for development and small projects
+- **PostgreSQL** (pg) - For production applications
+- **MySQL** (mysql2) - Alternative SQL database
+
+If you select a database:
+- The appropriate driver is added to `package.json` dependencies
+- `webspresso.db.js` config file is created with proper settings
+- `migrations/` directory is created
+- `models/` directory is created
+- `DATABASE_URL` is added to `.env.example` with a template
+
+**Seed Data Generation:**
+After selecting a database, you'll be asked if you want to generate seed data:
+- If yes, `@faker-js/faker` is added to dependencies
+- `seeds/` directory is created with `seeds/index.js`
+- `npm run seed` script is added to `package.json`
+- The seed script automatically detects models in `models/` directory and generates fake data based on their schemas
+
+To run seeds after creating models:
+```bash
+npm run seed
+```
+
+The seed script will:
+- Load all models from `models/` directory
+- Generate 10 fake records per model (by default)
+- Use smart field detection based on column names (email, name, title, etc.)
+
+You can always add database support later by:
+1. Installing the driver: `npm install better-sqlite3` (or `pg`, `mysql2`)
+2. Creating `webspresso.db.js` config file
+3. Adding `DATABASE_URL` to your `.env` file
+4. Creating `models/` directory and defining your models
+5. Optionally adding seed support: `npm install @faker-js/faker` and creating `seeds/index.js`
+
 Options:
 - `-i, --install` - Auto run `npm install` and `npm run build:css` (non-interactive)
 - `--no-tailwind` - Skip Tailwind CSS setup
@@ -676,6 +715,17 @@ The `fsy` object is available in all templates:
 {{ fsy.prettyBytes(1024) }}
 {{ fsy.prettyMs(5000) }}
 
+{# Date/Time helpers (dayjs) #}
+{{ fsy.dateFormat(post.created_at, 'YYYY-MM-DD HH:mm') }}
+{{ fsy.dateFromNow(post.created_at) }} {# "2 hours ago" #}
+{{ fsy.dateAgo(post.created_at) }} {# "2 hours ago" #}
+{{ fsy.dateUntil(event.date) }} {# "in 2 hours" #}
+{{ fsy.date(post.created_at).format('MMMM D, YYYY') }} {# Full dayjs API #}
+{% if fsy.dateIsBefore(post.created_at, fsy.date()) %}Published{% endif %}
+{{ fsy.dateDiff(post.created_at, fsy.date(), 'day') }} days ago
+{{ fsy.dateAdd(post.created_at, 7, 'day').format('YYYY-MM-DD') }}
+{{ fsy.dateStartOf(post.created_at, 'month').format('YYYY-MM-DD') }}
+
 {# Environment #}
 {% if fsy.isDev() %}Dev mode{% endif %}
 
@@ -1040,6 +1090,32 @@ npm install better-sqlite3
 
 ### Database Seeding
 
+**CLI Command:**
+
+The easiest way to seed your database is using the CLI command:
+
+```bash
+# Run seeds (requires seeds/index.js)
+webspresso seed
+
+# Setup seed files if they don't exist
+webspresso seed --setup
+
+# Use custom database config
+webspresso seed --config ./custom-db-config.js
+
+# Use different environment
+webspresso seed --env production
+```
+
+The `webspresso seed` command:
+- Automatically loads all models from `models/` directory
+- Generates fake data based on model schemas
+- Creates 10 records per model by default
+- Uses smart field detection for appropriate fake data
+
+**Manual Setup:**
+
 Generate fake data for testing and development using `@faker-js/faker`:
 
 ```bash

package/bin/webspresso.js

@@ -9,7 +9,7 @@ const { program } = require('commander');
 const inquirer = require('inquirer');
 const fs = require('fs');
 const path = require('path');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 
 program
   .name('webspresso')
@@ -121,6 +121,43 @@ program
     
     console.log(`\n🚀 Creating new Webspresso project: ${projectName}\n`);
     
+    // Ask about database
+    const { useDatabase, databaseType } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useDatabase',
+        message: 'Will you use a database?',
+        default: false
+      },
+      {
+        type: 'list',
+        name: 'databaseType',
+        message: 'Which database?',
+        choices: [
+          { name: 'SQLite (better-sqlite3)', value: 'better-sqlite3' },
+          { name: 'PostgreSQL (pg)', value: 'pg' },
+          { name: 'MySQL (mysql2)', value: 'mysql2' },
+          { name: 'None', value: null }
+        ],
+        default: 'better-sqlite3',
+        when: (answers) => answers.useDatabase
+      }
+    ]);
+    
+    // Ask about seed data if database is selected
+    let useSeed = false;
+    if (useDatabase && databaseType) {
+      const { generateSeed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'generateSeed',
+          message: 'Generate seed data based on existing models?',
+          default: false
+        }
+      ]);
+      useSeed = generateSeed;
+    }
+    
     // Create directory structure (skip root if using current dir)
     if (!useCurrentDir) {
       fs.mkdirSync(projectPath, { recursive: true });
@@ -130,6 +167,11 @@ program
     fs.mkdirSync(path.join(projectPath, 'views'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'public'), { recursive: true });
     
+    // Create models directory if database is selected
+    if (useDatabase && databaseType) {
+      fs.mkdirSync(path.join(projectPath, 'models'), { recursive: true });
+    }
+    
     // Create package.json
     const packageJson = {
       name: projectName,
@@ -146,6 +188,23 @@ program
       }
     };
     
+    // Add database driver if selected
+    if (useDatabase && databaseType) {
+      const dbDrivers = {
+        'better-sqlite3': '^9.0.0',
+        'pg': '^8.0.0',
+        'mysql2': '^3.0.0'
+      };
+      
+      packageJson.dependencies[databaseType] = dbDrivers[databaseType];
+    }
+    
+    // Add faker if seed is selected
+    if (useSeed) {
+      packageJson.dependencies['@faker-js/faker'] = '^8.0.0';
+      packageJson.scripts.seed = 'node seeds/index.js';
+    }
+    
     fs.writeFileSync(
       path.join(projectPath, 'package.json'),
       JSON.stringify(packageJson, null, 2) + '\n'
@@ -172,15 +231,186 @@ app.listen(PORT, () => {
     fs.writeFileSync(path.join(projectPath, 'server.js'), serverJs);
     
     // Create .env.example
-    const envExample = `PORT=3000
+    let envExample = `PORT=3000
 NODE_ENV=development
 DEFAULT_LOCALE=en
 SUPPORTED_LOCALES=en,tr
 BASE_URL=http://localhost:3000
 `;
     
+    if (useDatabase && databaseType) {
+      if (databaseType === 'better-sqlite3') {
+        envExample += `DATABASE_URL=sqlite:./database.sqlite
+`;
+      } else if (databaseType === 'pg') {
+        envExample += `DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+`;
+      } else if (databaseType === 'mysql2') {
+        envExample += `DATABASE_URL=mysql://user:password@localhost:3306/dbname
+`;
+      }
+    }
+    
     fs.writeFileSync(path.join(projectPath, '.env.example'), envExample);
     
+    // Create database config if database is selected
+    if (useDatabase && databaseType) {
+      let dbConfig = '';
+      
+      if (databaseType === 'better-sqlite3') {
+        dbConfig = `module.exports = {
+  client: 'better-sqlite3',
+  connection: {
+    filename: process.env.DATABASE_URL?.replace('sqlite:', '') || './database.sqlite'
+  },
+  migrations: {
+    directory: './migrations',
+    tableName: 'knex_migrations',
+  },
+  useNullAsDefault: true
+};
+`;
+      } else if (databaseType === 'pg') {
+        dbConfig = `module.exports = {
+  client: 'pg',
+  connection: process.env.DATABASE_URL,
+  migrations: {
+    directory: './migrations',
+    tableName: 'knex_migrations',
+  },
+  pool: {
+    min: 2,
+    max: 10
+  }
+};
+`;
+      } else if (databaseType === 'mysql2') {
+        dbConfig = `module.exports = {
+  client: 'mysql2',
+  connection: process.env.DATABASE_URL,
+  migrations: {
+    directory: './migrations',
+    tableName: 'knex_migrations',
+  },
+  pool: {
+    min: 2,
+    max: 10
+  }
+};
+`;
+      }
+      
+      fs.writeFileSync(path.join(projectPath, 'webspresso.db.js'), dbConfig);
+      
+      // Create migrations directory
+      fs.mkdirSync(path.join(projectPath, 'migrations'), { recursive: true });
+    }
+    
+    // Create seed files if seed is selected
+    if (useSeed) {
+      fs.mkdirSync(path.join(projectPath, 'seeds'), { recursive: true });
+      
+      const seedIndex = `require('dotenv').config();
+const { faker } = require('@faker-js/faker');
+const path = require('path');
+const fs = require('fs');
+const { createDatabase, getAllModels } = require('webspresso/orm');
+const dbConfig = require('./webspresso.db.js');
+
+const db = createDatabase(dbConfig);
+const seeder = db.seeder(faker);
+
+/**
+ * Load all models from models/ directory
+ */
+function loadModels() {
+  const modelsDir = path.join(__dirname, 'models');
+  
+  if (!fs.existsSync(modelsDir)) {
+    return [];
+  }
+  
+  const modelFiles = fs.readdirSync(modelsDir)
+    .filter(file => file.endsWith('.js') && !file.startsWith('_'));
+  
+  const loadedModels = [];
+  for (const file of modelFiles) {
+    try {
+      require(path.join(modelsDir, file));
+      loadedModels.push(file);
+    } catch (error) {
+      console.warn(\`⚠️  Failed to load model from \${file}:\`, error.message);
+    }
+  }
+  
+  return loadedModels;
+}
+
+/**
+ * Seed database with fake data
+ * This script automatically detects models in the models/ directory
+ * and generates seed data based on their schemas.
+ */
+async function runSeeds() {
+  try {
+    console.log('🌱 Starting seed process...');
+    
+    // Load all models
+    const loadedFiles = loadModels();
+    
+    if (loadedFiles.length === 0) {
+      console.log('⚠️  No model files found in models/ directory.');
+      console.log('   Create models first, then run: npm run seed');
+      await db.knex.destroy();
+      return;
+    }
+    
+    // Get all registered models
+    const models = getAllModels();
+    
+    if (models.size === 0) {
+      console.log('⚠️  No models registered. Make sure your model files export models using defineModel().');
+      await db.knex.destroy();
+      return;
+    }
+    
+    console.log(\`📦 Found \${models.size} model(s):\`);
+    for (const [name] of models) {
+      console.log(\`   - \${name}\`);
+    }
+    
+    // Seed each model
+    const results = {};
+    for (const [modelName, model] of models) {
+      console.log(\`\\n🌱 Seeding \${modelName}...\`);
+      
+      // Default count: 10 records per model
+      const count = 10;
+      const records = await seeder.seed(modelName, count);
+      results[modelName] = records.length;
+      
+      console.log(\`✅ Created \${records.length} \${modelName} record(s)\`);
+    }
+    
+    console.log(\`\\n✨ Seed completed! Created:\`);
+    for (const [modelName, count] of Object.entries(results)) {
+      console.log(\`   - \${count} \${modelName} record(s)\`);
+    }
+    
+    await db.knex.destroy();
+  } catch (error) {
+    console.error('❌ Seed failed:', error);
+    await db.knex.destroy().catch(() => {});
+    process.exit(1);
+  }
+}
+
+runSeeds();
+`;
+      
+      fs.writeFileSync(path.join(projectPath, 'seeds', 'index.js'), seedIndex);
+    }
+    
     // Create .gitignore
     const gitignore = `node_modules/
 .env
@@ -1242,6 +1472,232 @@ exports.down = function(knex) {
 `;
 }
 
+// seed command
+program
+  .command('seed')
+  .description('Run database seeders to populate database with fake data')
+  .option('-c, --config <path>', 'Path to database config file')
+  .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+  .option('--setup', 'Setup seed files if they don\'t exist')
+  .action(async (options) => {
+    // Check if it's a Webspresso project
+    if (!fs.existsSync(path.join(process.cwd(), 'server.js')) && 
+        !fs.existsSync(path.join(process.cwd(), 'pages'))) {
+      console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+      process.exit(1);
+    }
+
+    // Check for faker
+    let faker;
+    try {
+      faker = require('@faker-js/faker');
+    } catch {
+      console.error('❌ @faker-js/faker not installed.');
+      
+      // Check if it's in package.json
+      const packageJsonPath = path.join(process.cwd(), 'package.json');
+      let shouldInstall = false;
+      
+      if (fs.existsSync(packageJsonPath)) {
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+          const hasFaker = packageJson.dependencies?.['@faker-js/faker'] || 
+                          packageJson.devDependencies?.['@faker-js/faker'];
+          
+          if (hasFaker) {
+            console.log('   @faker-js/faker is in package.json but not installed.');
+            console.log('   Run: npm install');
+            process.exit(1);
+          } else {
+            // Ask if user wants to install it
+            const { install } = await inquirer.prompt([
+              {
+                type: 'confirm',
+                name: 'install',
+                message: 'Install @faker-js/faker now?',
+                default: true
+              }
+            ]);
+            
+            if (install) {
+              shouldInstall = true;
+            } else {
+              console.log('   Install it manually with: npm install @faker-js/faker');
+              process.exit(1);
+            }
+          }
+        } catch (err) {
+          console.log('   Install it with: npm install @faker-js/faker');
+          process.exit(1);
+        }
+      } else {
+        console.log('   Install it with: npm install @faker-js/faker');
+        process.exit(1);
+      }
+      
+      // Install faker if user confirmed
+      if (shouldInstall) {
+        console.log('\n📦 Installing @faker-js/faker...\n');
+        try {
+          execSync('npm install @faker-js/faker', {
+            stdio: 'inherit',
+            cwd: process.cwd()
+          });
+          console.log('\n✅ @faker-js/faker installed successfully!\n');
+          
+          // Try to require again
+          faker = require('@faker-js/faker');
+        } catch (err) {
+          console.error('\n❌ Failed to install @faker-js/faker:', err.message);
+          console.log('   Install it manually with: npm install @faker-js/faker');
+          process.exit(1);
+        }
+      }
+    }
+
+    // Load database config
+    const { config, path: configPath } = loadDbConfig(options.config);
+    console.log(`\n📦 Using config: ${configPath}`);
+    console.log(`   Environment: ${options.env}\n`);
+
+    // Check if models directory exists
+    const modelsDir = path.join(process.cwd(), 'models');
+    if (!fs.existsSync(modelsDir)) {
+      console.error('❌ models/ directory not found.');
+      console.log('   Create models first, then run: webspresso seed');
+      process.exit(1);
+    }
+
+    // Check if seeds directory exists
+    const seedsDir = path.join(process.cwd(), 'seeds');
+    const seedIndexPath = path.join(seedsDir, 'index.js');
+    
+    if (!fs.existsSync(seedsDir) || !fs.existsSync(seedIndexPath)) {
+      if (options.setup) {
+        console.log('📝 Setting up seed files...\n');
+        
+        // Create seeds directory
+        if (!fs.existsSync(seedsDir)) {
+          fs.mkdirSync(seedsDir, { recursive: true });
+        }
+        
+        // Create seed index file
+        const seedIndex = `require('dotenv').config();
+const { faker } = require('@faker-js/faker');
+const path = require('path');
+const fs = require('fs');
+const { createDatabase, getAllModels } = require('webspresso/orm');
+const dbConfig = require('../webspresso.db.js');
+
+const db = createDatabase(dbConfig);
+const seeder = db.seeder(faker);
+
+/**
+ * Load all models from models/ directory
+ */
+function loadModels() {
+  const modelsDir = path.join(__dirname, '..', 'models');
+  
+  if (!fs.existsSync(modelsDir)) {
+    return [];
+  }
+  
+  const modelFiles = fs.readdirSync(modelsDir)
+    .filter(file => file.endsWith('.js') && !file.startsWith('_'));
+  
+  const loadedModels = [];
+  for (const file of modelFiles) {
+    try {
+      require(path.join(modelsDir, file));
+      loadedModels.push(file);
+    } catch (error) {
+      console.warn(\`⚠️  Failed to load model from \${file}:\`, error.message);
+    }
+  }
+  
+  return loadedModels;
+}
+
+/**
+ * Seed database with fake data
+ * This script automatically detects models in the models/ directory
+ * and generates seed data based on their schemas.
+ */
+async function runSeeds() {
+  try {
+    console.log('🌱 Starting seed process...');
+    
+    // Load all models
+    const loadedFiles = loadModels();
+    
+    if (loadedFiles.length === 0) {
+      console.log('⚠️  No model files found in models/ directory.');
+      console.log('   Create models first, then run: webspresso seed');
+      await db.knex.destroy();
+      return;
+    }
+    
+    // Get all registered models
+    const models = getAllModels();
+    
+    if (models.size === 0) {
+      console.log('⚠️  No models registered. Make sure your model files export models using defineModel().');
+      await db.knex.destroy();
+      return;
+    }
+    
+    console.log(\`📦 Found \${models.size} model(s):\`);
+    for (const [name] of models) {
+      console.log(\`   - \${name}\`);
+    }
+    
+    // Seed each model
+    const results = {};
+    for (const [modelName, model] of models) {
+      console.log(\`\\n🌱 Seeding \${modelName}...\`);
+      
+      // Default count: 10 records per model
+      const count = 10;
+      const records = await seeder.seed(modelName, count);
+      results[modelName] = records.length;
+      
+      console.log(\`✅ Created \${records.length} \${modelName} record(s)\`);
+    }
+    
+    console.log(\`\\n✨ Seed completed! Created:\`);
+    for (const [modelName, count] of Object.entries(results)) {
+      console.log(\`   - \${count} \${modelName} record(s)\`);
+    }
+    
+    await db.knex.destroy();
+  } catch (error) {
+    console.error('❌ Seed failed:', error);
+    await db.knex.destroy().catch(() => {});
+    process.exit(1);
+  }
+}
+
+runSeeds();
+`;
+        
+        fs.writeFileSync(seedIndexPath, seedIndex);
+        console.log('✅ Seed files created!\n');
+      } else {
+        console.error('❌ seeds/index.js not found.');
+        console.log('   Run with --setup flag to create seed files: webspresso seed --setup');
+        process.exit(1);
+      }
+    }
+
+    // Run the seed script
+    try {
+      require(seedIndexPath);
+    } catch (error) {
+      console.error('❌ Failed to run seed:', error.message);
+      process.exit(1);
+    }
+  });
+
 // Parse arguments
 program.parse();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webspresso",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Minimal, production-ready SSR framework for Node.js with file-based routing, Nunjucks templating, built-in i18n, and CLI tooling",
   "main": "index.js",
   "bin": {
@@ -38,6 +38,7 @@
   ],
   "dependencies": {
     "commander": "^11.1.0",
+    "dayjs": "^1.11.19",
     "express": "^4.18.2",
     "helmet": "^7.2.0",
     "inquirer": "^8.2.6",
@@ -46,11 +47,11 @@
     "zod": "^3.23.0"
   },
   "peerDependencies": {
+    "@faker-js/faker": "^9.0.0",
+    "better-sqlite3": "^9.0.0",
     "dotenv": "^16.0.0",
-    "pg": "^8.0.0",
     "mysql2": "^3.0.0",
-    "better-sqlite3": "^9.0.0",
-    "@faker-js/faker": "^9.0.0"
+    "pg": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "dotenv": {

package/src/helpers.js

@@ -6,6 +6,17 @@
 const querystring = require('querystring');
 const fs = require('fs');
 const path = require('path');
+const dayjs = require('dayjs');
+const relativeTime = require('dayjs/plugin/relativeTime');
+const utc = require('dayjs/plugin/utc');
+const timezone = require('dayjs/plugin/timezone');
+const customParseFormat = require('dayjs/plugin/customParseFormat');
+
+// Extend dayjs with plugins
+dayjs.extend(relativeTime);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
 
 /**
  * Asset Manager - handles asset paths, versioning, and manifest
@@ -419,6 +430,157 @@ function createHelpers(ctx) {
      */
     img(src, alt = '', attrs = {}) {
       return getAssetManager().img(src, alt, attrs);
+    },
+
+    /**
+     * Date/time helpers using dayjs
+     */
+    
+    /**
+     * Create a dayjs instance from a date
+     * @param {string|Date|number} date - Date to parse
+     * @param {string} format - Optional format string
+     * @returns {Object} dayjs instance
+     */
+    date(date, format) {
+      if (!date) return dayjs();
+      if (format) {
+        return dayjs(date, format);
+      }
+      return dayjs(date);
+    },
+
+    /**
+     * Format a date
+     * @param {string|Date|number} date - Date to format
+     * @param {string} format - Format string (default: 'YYYY-MM-DD')
+     * @returns {string}
+     */
+    dateFormat(date, format = 'YYYY-MM-DD') {
+      if (!date) return '';
+      return dayjs(date).format(format);
+    },
+
+    /**
+     * Get relative time (e.g., "2 hours ago")
+     * @param {string|Date|number} date - Date to format
+     * @returns {string}
+     */
+    dateFromNow(date) {
+      if (!date) return '';
+      return dayjs(date).fromNow();
+    },
+
+    /**
+     * Get time ago (e.g., "2 hours ago")
+     * @param {string|Date|number} date - Date to format
+     * @returns {string}
+     */
+    dateAgo(date) {
+      if (!date) return '';
+      return dayjs(date).fromNow();
+    },
+
+    /**
+     * Get time until (e.g., "in 2 hours")
+     * @param {string|Date|number} date - Date to format
+     * @returns {string}
+     */
+    dateUntil(date) {
+      if (!date) return '';
+      return dayjs(date).toNow();
+    },
+
+    /**
+     * Check if date is before another date
+     * @param {string|Date|number} date1 - First date
+     * @param {string|Date|number} date2 - Second date
+     * @returns {boolean}
+     */
+    dateIsBefore(date1, date2) {
+      if (!date1 || !date2) return false;
+      return dayjs(date1).isBefore(date2);
+    },
+
+    /**
+     * Check if date is after another date
+     * @param {string|Date|number} date1 - First date
+     * @param {string|Date|number} date2 - Second date
+     * @returns {boolean}
+     */
+    dateIsAfter(date1, date2) {
+      if (!date1 || !date2) return false;
+      return dayjs(date1).isAfter(date2);
+    },
+
+    /**
+     * Check if date is same as another date
+     * @param {string|Date|number} date1 - First date
+     * @param {string|Date|number} date2 - Second date
+     * @param {string} unit - Unit to compare (day, month, year, etc.)
+     * @returns {boolean}
+     */
+    dateIsSame(date1, date2, unit = 'day') {
+      if (!date1 || !date2) return false;
+      return dayjs(date1).isSame(date2, unit);
+    },
+
+    /**
+     * Get difference between two dates
+     * @param {string|Date|number} date1 - First date
+     * @param {string|Date|number} date2 - Second date
+     * @param {string} unit - Unit (day, month, year, hour, minute, second)
+     * @returns {number}
+     */
+    dateDiff(date1, date2, unit = 'day') {
+      if (!date1 || !date2) return 0;
+      return dayjs(date1).diff(date2, unit);
+    },
+
+    /**
+     * Add time to a date
+     * @param {string|Date|number} date - Date to add to
+     * @param {number} amount - Amount to add
+     * @param {string} unit - Unit (day, month, year, hour, minute, second)
+     * @returns {Object} dayjs instance
+     */
+    dateAdd(date, amount, unit = 'day') {
+      if (!date) return dayjs();
+      return dayjs(date).add(amount, unit);
+    },
+
+    /**
+     * Subtract time from a date
+     * @param {string|Date|number} date - Date to subtract from
+     * @param {number} amount - Amount to subtract
+     * @param {string} unit - Unit (day, month, year, hour, minute, second)
+     * @returns {Object} dayjs instance
+     */
+    dateSubtract(date, amount, unit = 'day') {
+      if (!date) return dayjs();
+      return dayjs(date).subtract(amount, unit);
+    },
+
+    /**
+     * Get start of a time period
+     * @param {string|Date|number} date - Date
+     * @param {string} unit - Unit (day, month, year, week)
+     * @returns {Object} dayjs instance
+     */
+    dateStartOf(date, unit = 'day') {
+      if (!date) return dayjs();
+      return dayjs(date).startOf(unit);
+    },
+
+    /**
+     * Get end of a time period
+     * @param {string|Date|number} date - Date
+     * @param {string} unit - Unit (day, month, year, week)
+     * @returns {Object} dayjs instance
+     */
+    dateEndOf(date, unit = 'day') {
+      if (!date) return dayjs();
+      return dayjs(date).endOf(unit);
     }
   };
 }