create-nara 0.1.0 → 0.1.2

package/dist/template.js

@@ -16,10 +16,26 @@ export async function setupProject(options) {
     if (fs.existsSync(modeTemplateDir)) {
         copyDir(modeTemplateDir, targetDir);
     }
-    // 3. Ensure required directories exist
+    // 3. Copy feature-specific templates
+    const featuresDir = path.join(templatesDir, 'features');
+    for (const feature of features) {
+        const featureDir = path.join(featuresDir, feature);
+        if (fs.existsSync(featureDir)) {
+            copyDir(featureDir, targetDir);
+        }
+    }
+    // 4. Ensure required directories exist
     fs.mkdirSync(path.join(targetDir, 'app/controllers'), { recursive: true });
     fs.mkdirSync(path.join(targetDir, 'app/models'), { recursive: true });
-    // 4. Generate package.json (dynamic content)
+    // Create database directory if db feature is selected
+    if (features.includes('db')) {
+        fs.mkdirSync(path.join(targetDir, 'database'), { recursive: true });
+    }
+    // Create uploads directory if uploads feature is selected
+    if (features.includes('uploads')) {
+        fs.mkdirSync(path.join(targetDir, 'uploads'), { recursive: true });
+    }
+    // 5. Generate package.json (dynamic content)
     const pkg = createPackageJson(projectName, mode, features);
     fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2));
 }
@@ -63,6 +79,20 @@ function createPackageJson(name, mode, features) {
     if (features.includes('db')) {
         pkg.dependencies['knex'] = '^3.1.0';
         pkg.dependencies['better-sqlite3'] = '^11.0.0';
+        pkg.devDependencies['@types/better-sqlite3'] = '^7.6.0';
+        pkg.scripts['db:migrate'] = 'knex migrate:latest';
+        pkg.scripts['db:rollback'] = 'knex migrate:rollback';
+        pkg.scripts['db:make'] = 'knex migrate:make';
+    }
+    if (features.includes('auth')) {
+        pkg.dependencies['bcrypt'] = '^5.1.0';
+        pkg.dependencies['jsonwebtoken'] = '^9.0.0';
+        pkg.devDependencies['@types/bcrypt'] = '^5.0.0';
+        pkg.devDependencies['@types/jsonwebtoken'] = '^9.0.0';
+    }
+    if (features.includes('uploads')) {
+        pkg.dependencies['sharp'] = '^0.33.0';
+        pkg.devDependencies['@types/sharp'] = '^0.32.0';
     }
     return pkg;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nara",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI to scaffold NARA projects",
   "type": "module",
   "bin": {

package/templates/features/auth/app/controllers/AuthController.ts

@@ -0,0 +1,65 @@
+import { BaseController, jsonSuccess, jsonError, ValidationError } from '@nara-web/core';
+import type { NaraRequest, NaraResponse } from '@nara-web/core';
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+
+export class AuthController extends BaseController {
+  async login(req: NaraRequest, res: NaraResponse) {
+    const { email, password } = await req.json();
+
+    if (!email || !password) {
+      throw new ValidationError({ email: ['Email and password are required'] });
+    }
+
+    // TODO: Replace with your actual user lookup
+    // const user = await User.findByEmail(email);
+    // if (!user || !await bcrypt.compare(password, user.password)) {
+    //   return jsonError(res, 'Invalid credentials', 401);
+    // }
+
+    // Example: Generate JWT token
+    const token = jwt.sign({ userId: 1, email }, JWT_SECRET, { expiresIn: '7d' });
+
+    return jsonSuccess(res, { token, message: 'Login successful' });
+  }
+
+  async register(req: NaraRequest, res: NaraResponse) {
+    const { name, email, password } = await req.json();
+
+    if (!name || !email || !password) {
+      throw new ValidationError({
+        name: !name ? ['Name is required'] : [],
+        email: !email ? ['Email is required'] : [],
+        password: !password ? ['Password is required'] : [],
+      });
+    }
+
+    // Hash password
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    // TODO: Replace with your actual user creation
+    // const user = await User.create({ name, email, password: hashedPassword });
+
+    const token = jwt.sign({ userId: 1, email }, JWT_SECRET, { expiresIn: '7d' });
+
+    return jsonSuccess(res, { token, message: 'Registration successful' }, 201);
+  }
+
+  async me(req: NaraRequest, res: NaraResponse) {
+    // TODO: Get user from JWT token in auth middleware
+    const user = req.user;
+
+    if (!user) {
+      return jsonError(res, 'Unauthorized', 401);
+    }
+
+    return jsonSuccess(res, { user });
+  }
+
+  async logout(req: NaraRequest, res: NaraResponse) {
+    // For JWT, logout is typically handled client-side by removing the token
+    return jsonSuccess(res, { message: 'Logged out successfully' });
+  }
+}

package/templates/features/auth/app/middlewares/auth.ts

@@ -0,0 +1,23 @@
+import type { NaraRequest, NaraResponse } from '@nara-web/core';
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+
+export function authMiddleware(req: NaraRequest, res: NaraResponse, next: () => void) {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    res.status(401).json({ error: 'Unauthorized' });
+    return;
+  }
+
+  const token = authHeader.substring(7);
+
+  try {
+    const decoded = jwt.verify(token, JWT_SECRET) as { userId: number; email: string };
+    req.user = { id: decoded.userId, email: decoded.email, name: '' };
+    next();
+  } catch (error) {
+    res.status(401).json({ error: 'Invalid token' });
+  }
+}

package/templates/features/auth/routes/auth.ts

@@ -0,0 +1,15 @@
+import type { NaraApp } from '@nara-web/core';
+import { AuthController } from '../app/controllers/AuthController.js';
+import { authMiddleware } from '../app/middlewares/auth.js';
+
+export function registerAuthRoutes(app: NaraApp) {
+  const auth = new AuthController();
+
+  // Public routes
+  app.post('/api/auth/login', (req, res) => auth.login(req, res));
+  app.post('/api/auth/register', (req, res) => auth.register(req, res));
+
+  // Protected routes
+  app.get('/api/auth/me', authMiddleware, (req, res) => auth.me(req, res));
+  app.post('/api/auth/logout', authMiddleware, (req, res) => auth.logout(req, res));
+}

package/templates/features/db/app/config/database.ts

@@ -0,0 +1,16 @@
+import Knex from 'knex';
+
+const config = {
+  client: 'better-sqlite3',
+  connection: {
+    filename: './database/dev.sqlite3',
+  },
+  useNullAsDefault: true,
+  migrations: {
+    directory: './migrations',
+    extension: 'ts',
+  },
+};
+
+export const db = Knex(config);
+export default config;

package/templates/features/db/app/models/User.ts

@@ -0,0 +1,40 @@
+import { db } from '../app/config/database.js';
+
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+  password: string;
+  role: string;
+  email_verified_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export class UserModel {
+  static tableName = 'users';
+
+  static async findById(id: number): Promise<User | undefined> {
+    return db(this.tableName).where({ id }).first();
+  }
+
+  static async findByEmail(email: string): Promise<User | undefined> {
+    return db(this.tableName).where({ email }).first();
+  }
+
+  static async create(data: Partial<User>): Promise<number[]> {
+    return db(this.tableName).insert(data);
+  }
+
+  static async update(id: number, data: Partial<User>): Promise<number> {
+    return db(this.tableName).where({ id }).update(data);
+  }
+
+  static async delete(id: number): Promise<number> {
+    return db(this.tableName).where({ id }).delete();
+  }
+
+  static async all(): Promise<User[]> {
+    return db(this.tableName).select('*');
+  }
+}

package/templates/features/db/knexfile.ts

@@ -0,0 +1,28 @@
+import type { Knex } from 'knex';
+
+const config: { [key: string]: Knex.Config } = {
+  development: {
+    client: 'better-sqlite3',
+    connection: {
+      filename: './database/dev.sqlite3',
+    },
+    useNullAsDefault: true,
+    migrations: {
+      directory: './migrations',
+      extension: 'ts',
+    },
+  },
+
+  production: {
+    client: 'better-sqlite3',
+    connection: {
+      filename: './database/production.sqlite3',
+    },
+    useNullAsDefault: true,
+    migrations: {
+      directory: './migrations',
+    },
+  },
+};
+
+export default config;

package/templates/features/db/migrations/20240101000001_create_users.ts

@@ -0,0 +1,17 @@
+import type { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('users', (table) => {
+    table.increments('id').primary();
+    table.string('name').notNullable();
+    table.string('email').notNullable().unique();
+    table.string('password').notNullable();
+    table.string('role').defaultTo('user');
+    table.timestamp('email_verified_at').nullable();
+    table.timestamps(true, true);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists('users');
+}

package/templates/features/uploads/app/controllers/UploadController.ts

@@ -0,0 +1,62 @@
+import { BaseController, jsonSuccess, jsonError } from '@nara-web/core';
+import type { NaraRequest, NaraResponse } from '@nara-web/core';
+import sharp from 'sharp';
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+const UPLOAD_DIR = './uploads';
+
+export class UploadController extends BaseController {
+  constructor() {
+    super();
+    // Ensure upload directory exists
+    if (!fs.existsSync(UPLOAD_DIR)) {
+      fs.mkdirSync(UPLOAD_DIR, { recursive: true });
+    }
+  }
+
+  async upload(req: NaraRequest, res: NaraResponse) {
+    try {
+      const contentType = req.headers['content-type'] || '';
+
+      if (!contentType.includes('multipart/form-data')) {
+        return jsonError(res, 'Content-Type must be multipart/form-data', 400);
+      }
+
+      // Get raw body as buffer
+      const buffer = await req.buffer();
+
+      // Generate unique filename
+      const filename = `${crypto.randomUUID()}.webp`;
+      const filepath = path.join(UPLOAD_DIR, filename);
+
+      // Process and save image with sharp
+      await sharp(buffer)
+        .resize(1920, 1080, { fit: 'inside', withoutEnlargement: true })
+        .webp({ quality: 80 })
+        .toFile(filepath);
+
+      return jsonSuccess(res, {
+        filename,
+        path: `/uploads/${filename}`,
+        message: 'File uploaded successfully',
+      }, 201);
+    } catch (error) {
+      console.error('Upload error:', error);
+      return jsonError(res, 'Failed to upload file', 500);
+    }
+  }
+
+  async delete(req: NaraRequest, res: NaraResponse) {
+    const { filename } = req.params;
+    const filepath = path.join(UPLOAD_DIR, filename);
+
+    if (!fs.existsSync(filepath)) {
+      return jsonError(res, 'File not found', 404);
+    }
+
+    fs.unlinkSync(filepath);
+    return jsonSuccess(res, { message: 'File deleted successfully' });
+  }
+}

package/templates/features/uploads/routes/uploads.ts

@@ -0,0 +1,9 @@
+import type { NaraApp } from '@nara-web/core';
+import { UploadController } from '../app/controllers/UploadController.js';
+
+export function registerUploadRoutes(app: NaraApp) {
+  const upload = new UploadController();
+
+  app.post('/api/uploads', (req, res) => upload.upload(req, res));
+  app.delete('/api/uploads/:filename', (req, res) => upload.delete(req, res));
+}