@ahmadubaidillah/cli 1.1.0 → 1.1.2

package/dist/templates/templates/saas/files/src/core/errors.ts

@@ -0,0 +1,39 @@
+import { Context } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+
+export class AppError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number = 400,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'AppError';
+  }
+}
+
+export const errorHandler = (err: Error, c: Context) => {
+  if (err instanceof AppError) {
+    return c.json({
+      success: false,
+      error: {
+        message: err.message,
+        code: err.code,
+      }
+    }, err.statusCode as any);
+  }
+
+  if (err instanceof HTTPException) {
+    return err.getResponse();
+  }
+
+  console.error('[Unhandled Error]:', err);
+  
+  return c.json({
+    success: false,
+    error: {
+      message: 'Internal Server Error',
+      code: 'INTERNAL_ERROR',
+    }
+  }, 500);
+};

package/dist/templates/templates/saas/files/src/modules/users/repositories/user.repository.ts

@@ -0,0 +1,25 @@
+import { User, CreateUserInput } from '../validators/user.validator';
+
+export class UserRepository {
+  // In a real app, this would use Drizzle or Prisma
+  // For the template, we show the pattern
+  
+  async findById(id: string): Promise<User | null> {
+    console.log(`[UserRepository] Finding user by id: ${id}`);
+    return null; 
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    console.log(`[UserRepository] Finding user by email: ${email}`);
+    return null;
+  }
+
+  async create(data: CreateUserInput): Promise<User> {
+    console.log(`[UserRepository] Creating user:`, data);
+    return {
+      id: crypto.randomUUID(),
+      ...data,
+      createdAt: new Date(),
+    };
+  }
+}

package/dist/templates/templates/saas/files/src/modules/users/routes/user.routes.ts

@@ -0,0 +1,33 @@
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { createUserSchema } from '../validators/user.validator';
+import { UserService } from '../services/user.service';
+import { UserRepository } from '../repositories/user.repository';
+
+const userRoutes = new Hono();
+
+// Dependency Injection (Pattern manual for template)
+const userRepository = new UserRepository();
+const userService = new UserService(userRepository);
+
+userRoutes.post('/register', zValidator('json', createUserSchema), async (c) => {
+  const data = c.req.valid('json');
+  const user = await userService.registerUser(data);
+  
+  return c.json({
+    success: true,
+    data: user
+  }, 201);
+});
+
+userRoutes.get('/:id', async (c) => {
+  const id = c.req.param('id');
+  const user = await userService.getUserProfile(id);
+  
+  return c.json({
+    success: true,
+    data: user
+  });
+});
+
+export { userRoutes };

package/dist/templates/templates/saas/files/src/modules/users/services/user.service.ts

@@ -0,0 +1,24 @@
+import { UserRepository } from '../repositories/user.repository';
+import { CreateUserInput, User } from '../validators/user.validator';
+import { AppError } from '../../../core/errors';
+
+export class UserService {
+  constructor(private userRepository: UserRepository) {}
+
+  async registerUser(data: CreateUserInput): Promise<User> {
+    const existing = await this.userRepository.findByEmail(data.email);
+    if (existing) {
+      throw new AppError('User with this email already exists', 409, 'USER_EXISTS');
+    }
+
+    return this.userRepository.create(data);
+  }
+
+  async getUserProfile(id: string): Promise<User> {
+    const user = await this.userRepository.findById(id);
+    if (!user) {
+      throw new AppError('User not found', 404, 'USER_NOT_FOUND');
+    }
+    return user;
+  }
+}

package/dist/templates/templates/saas/files/src/modules/users/validators/user.validator.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const userSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().min(2),
+  createdAt: z.date(),
+});
+
+export type User = z.infer<typeof userSchema>;
+
+export const createUserSchema = userSchema.pick({
+  email: true,
+  name: true,
+});
+
+export type CreateUserInput = z.infer<typeof createUserSchema>;

package/dist/templates/templates/saas/files/tests/e2e/basic.spec.ts

@@ -0,0 +1,13 @@
+import { test, expect } from '@playwright/test';
+
+test('has title', async ({ page }) => {
+  await page.goto('/');
+  await expect(page).toHaveTitle(/DevForge/);
+});
+
+test('api is running', async ({ request }) => {
+  const response = await request.get('/');
+  expect(response.ok()).toBeTruthy();
+  const body = await response.json();
+  expect(body.status).toBe('running');
+});

package/dist/templates/templates/saas/template.config.json

@@ -0,0 +1,26 @@
+{
+  "name": "saas",
+  "description": "Multi-tenant SaaS application",
+  "stack": {
+    "runtime": "bun",
+    "backend": "hono",
+    "frontend": "solidjs",
+    "database": "postgres"
+  },
+  "supportedPlugins": [
+    "admin-panel",
+    "openapi",
+    "websocket",
+    "queue",
+    "openapi",
+    "websocket",
+    "queue",
+    "auth",
+    "payment",
+    "email",
+    "analytics",
+    "search",
+    "file-upload",
+    "github-actions"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahmadubaidillah/cli",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "The elite modular boilerplate engine for agentic applications.",
   "repository": {
     "type": "git",
@@ -16,7 +16,7 @@
     "devforge-cli": "dist/bin.js"
   },
   "dependencies": {
-    "@ahmadubaidillah/core": "^1.1.0",
+    "@ahmadubaidillah/core": "^1.1.2",
     "@inquirer/prompts": "latest",
     "chalk": "latest",
     "commander": "latest",