phos 1.0.3 → 1.2.0

package/README.md

@@ -10,7 +10,7 @@ Full-stack interactive project generator CLI
 [![Node.js Version](https://img.shields.io/node/v/phos)](https://nodejs.org)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
-**Version 1.0.3 - Production Release** 🎉
+**Version 1.2.0 - Production Release** 🎉
 
 [View on npmjs.com](https://www.npmjs.com/package/phos)
 
@@ -278,6 +278,8 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 Phos follows [semantic versioning](https://semver.org/).
 
+- **1.2.0** - Minor release (backend API architecture)
+- **1.1.0** - Minor release (new features, non-breaking changes)
 - **1.0.3** - Patch release (template path fix)
 - **1.0.2** - Patch release (template missing fix)
 - **1.0.1** - Patch release (bug fixes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phos",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Full-stack interactive project generator CLI - Phos",
   "type": "module",
   "bin": {

package/src/templates/backend/elysia/src/api/user_api.ts

@@ -0,0 +1,313 @@
+import { Elysia, t } from "elysia";
+import { userService } from "../service/user_service";
+import { validateString, validateCreateUserDto, validateUpdateUserDto } from "../function/helper";
+import type { ApiResponse, UserResponse } from "../types/user_type";
+
+export const userApi = new Elysia({ prefix: "/users" })
+  .get(
+    "/",
+    async () => {
+      try {
+        const users = await userService.getAllUsers();
+        return {
+          success: true,
+          data: users,
+          message: "Users retrieved successfully",
+        } as ApiResponse<UserResponse[]>;
+      } catch (error) {
+        throw {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      detail: {
+        tags: ["Users"],
+        summary: "Get all users",
+        description: "Retrieve all active users from the database",
+      },
+    }
+  )
+
+  .get(
+    "/:id",
+    async ({ params, set }) => {
+      try {
+        const id = parseInt(params.id);
+        if (isNaN(id) || id <= 0) {
+          set.status = 400;
+          throw new Error("Invalid user ID");
+        }
+
+        const user = await userService.getUserById(id);
+        if (!user) {
+          set.status = 404;
+          throw new Error("User not found");
+        }
+
+        return {
+          success: true,
+          data: user,
+          message: "User retrieved successfully",
+        } as ApiResponse<UserResponse>;
+      } catch (error) {
+        throw {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      params: t.Object({
+        id: t.String(),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Get user by ID",
+        description: "Retrieve a specific user by their ID",
+      },
+    }
+  )
+
+  .get(
+    "/search/:keyword",
+    async ({ params }) => {
+      try {
+        const keyword = params.keyword;
+        if (!validateString(keyword, 1, 100)) {
+          throw new Error("Search keyword must be between 1 and 100 characters");
+        }
+
+        const users = await userService.searchUsers(keyword);
+        return {
+          success: true,
+          data: users,
+          message: "Users retrieved successfully",
+        } as ApiResponse<UserResponse[]>;
+      } catch (error) {
+        throw {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      params: t.Object({
+        keyword: t.String(),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Search users",
+        description: "Search for users by email, username, or full name",
+      },
+    }
+  )
+
+  .post(
+    "/",
+    async ({ body, set }) => {
+      try {
+        const validatedData = validateCreateUserDto(body);
+        const user = await userService.createUser(validatedData);
+        set.status = 201;
+        return {
+          success: true,
+          data: user,
+          message: "User created successfully",
+        } as ApiResponse<UserResponse>;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("already exists") || errorMessage.includes("already taken")) {
+          set.status = 409;
+        } else if (errorMessage.includes("Validation error")) {
+          set.status = 400;
+        } else {
+          set.status = 400;
+        }
+        throw {
+          success: false,
+          error: errorMessage,
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      body: t.Object({
+        email: t.String(),
+        username: t.String(),
+        full_name: t.String(),
+        password: t.String(),
+        avatar_url: t.Optional(t.String()),
+        bio: t.Optional(t.String()),
+        role: t.Optional(t.String()),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Create a new user",
+        description: "Create a new user with the provided data",
+      },
+    }
+  )
+
+  .put(
+    "/:id",
+    async ({ params, body, set }) => {
+      try {
+        const id = parseInt(params.id);
+        if (isNaN(id) || id <= 0) {
+          set.status = 400;
+          throw new Error("Invalid user ID");
+        }
+
+        const validatedData = validateUpdateUserDto(body);
+        const user = await userService.updateUser(id, validatedData);
+        if (!user) {
+          set.status = 404;
+          throw new Error("User not found");
+        }
+
+        return {
+          success: true,
+          data: user,
+          message: "User updated successfully",
+        } as ApiResponse<UserResponse>;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("already in use") || errorMessage.includes("already taken")) {
+          set.status = 409;
+        } else if (errorMessage.includes("not found")) {
+          set.status = 404;
+        } else if (errorMessage.includes("Validation error")) {
+          set.status = 400;
+        } else {
+          set.status = 400;
+        }
+        throw {
+          success: false,
+          error: errorMessage,
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      params: t.Object({
+        id: t.String(),
+      }),
+      body: t.Object({
+        email: t.Optional(t.String()),
+        username: t.Optional(t.String()),
+        full_name: t.Optional(t.String()),
+        password: t.Optional(t.String()),
+        avatar_url: t.Optional(t.String()),
+        bio: t.Optional(t.String()),
+        role: t.Optional(t.String()),
+        is_active: t.Optional(t.Boolean()),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Update a user",
+        description: "Update an existing user's information",
+      },
+    }
+  )
+
+  .delete(
+    "/:id",
+    async ({ params, set }) => {
+      try {
+        const id = parseInt(params.id);
+        if (isNaN(id) || id <= 0) {
+          set.status = 400;
+          throw new Error("Invalid user ID");
+        }
+
+        const deleted = await userService.deleteUser(id);
+        if (!deleted) {
+          set.status = 404;
+          throw new Error("User not found");
+        }
+
+        return {
+          success: true,
+          message: "User deleted successfully",
+        } as ApiResponse<never>;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("not found")) {
+          set.status = 404;
+        } else {
+          set.status = 400;
+        }
+        throw {
+          success: false,
+          error: errorMessage,
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      params: t.Object({
+        id: t.String(),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Delete a user",
+        description: "Permanently delete a user from the database",
+      },
+    }
+  )
+
+  .post(
+    "/:id/soft-delete",
+    async ({ params, set }) => {
+      try {
+        const id = parseInt(params.id);
+        if (isNaN(id) || id <= 0) {
+          set.status = 400;
+          throw new Error("Invalid user ID");
+        }
+
+        const user = await userService.softDeleteUser(id);
+        if (!user) {
+          set.status = 404;
+          throw new Error("User not found");
+        }
+
+        return {
+          success: true,
+          data: user,
+          message: "User soft deleted successfully",
+        } as ApiResponse<UserResponse>;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("not found")) {
+          set.status = 404;
+        } else {
+          set.status = 400;
+        }
+        throw {
+          success: false,
+          error: errorMessage,
+        } as ApiResponse<never>;
+      }
+    },
+    {
+      params: t.Object({
+        id: t.String(),
+      }),
+      detail: {
+        tags: ["Users"],
+        summary: "Soft delete a user",
+        description: "Deactivate a user without permanently deleting them",
+      },
+    }
+  )
+
+  .onError(({ error, set }) => {
+    if (error && typeof error === "object" && "success" in error) {
+      return error;
+    }
+    set.status = 500;
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Internal server error",
+    } as ApiResponse<never>;
+  });

package/src/templates/backend/elysia/src/function/helper.ts

@@ -0,0 +1,111 @@
+import type { CreateUserDto, UpdateUserDto } from "../types/user_type";
+
+export function validateEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export function validateString(value: any, minLength: number = 1, maxLength: number = 255): boolean {
+  return typeof value === "string" && value.length >= minLength && value.length <= maxLength;
+}
+
+export function validateBoolean(value: any): boolean {
+  return typeof value === "boolean";
+}
+
+export function validateCreateUserDto(data: any): CreateUserDto {
+  const errors: string[] = [];
+
+  if (!validateEmail(data.email)) {
+    errors.push("Invalid email format");
+  }
+
+  if (!validateString(data.username, 3, 100)) {
+    errors.push("Username must be between 3 and 100 characters");
+  }
+
+  if (!validateString(data.full_name, 1, 255)) {
+    errors.push("Full name must be between 1 and 255 characters");
+  }
+
+  if (!validateString(data.password, 6, 255)) {
+    errors.push("Password must be at least 6 characters");
+  }
+
+  if (data.avatar_url !== undefined && data.avatar_url !== null && !validateString(data.avatar_url, 1, 1000)) {
+    errors.push("Avatar URL must be a valid string");
+  }
+
+  if (data.bio !== undefined && data.bio !== null && !validateString(data.bio, 1, 1000)) {
+    errors.push("Bio must be a valid string");
+  }
+
+  if (data.role !== undefined && data.role !== null && !validateString(data.role, 1, 50)) {
+    errors.push("Role must be a valid string");
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Validation error: ${errors.join(", ")}`);
+  }
+
+  return {
+    email: data.email,
+    username: data.username,
+    full_name: data.full_name,
+    password: data.password,
+    avatar_url: data.avatar_url ?? null,
+    bio: data.bio ?? null,
+    role: data.role ?? "user",
+  };
+}
+
+export function validateUpdateUserDto(data: any): UpdateUserDto {
+  const errors: string[] = [];
+
+  if (data.email !== undefined && !validateEmail(data.email)) {
+    errors.push("Invalid email format");
+  }
+
+  if (data.username !== undefined && !validateString(data.username, 3, 100)) {
+    errors.push("Username must be between 3 and 100 characters");
+  }
+
+  if (data.full_name !== undefined && !validateString(data.full_name, 1, 255)) {
+    errors.push("Full name must be between 1 and 255 characters");
+  }
+
+  if (data.password !== undefined && !validateString(data.password, 6, 255)) {
+    errors.push("Password must be at least 6 characters");
+  }
+
+  if (data.avatar_url !== undefined && !validateString(data.avatar_url, 1, 1000) && data.avatar_url !== null) {
+    errors.push("Avatar URL must be a valid string or null");
+  }
+
+  if (data.bio !== undefined && !validateString(data.bio, 1, 1000) && data.bio !== null) {
+    errors.push("Bio must be a valid string or null");
+  }
+
+  if (data.role !== undefined && !validateString(data.role, 1, 50)) {
+    errors.push("Role must be a valid string");
+  }
+
+  if (data.is_active !== undefined && !validateBoolean(data.is_active)) {
+    errors.push("is_active must be a boolean");
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Validation error: ${errors.join(", ")}`);
+  }
+
+  return {
+    email: data.email,
+    username: data.username,
+    full_name: data.full_name,
+    password: data.password,
+    avatar_url: data.avatar_url,
+    bio: data.bio,
+    role: data.role,
+    is_active: data.is_active,
+  };
+}

package/src/templates/backend/elysia/src/service/user_service.ts

@@ -0,0 +1,109 @@
+import * as UserSQL from "../sql/user_sql";
+import type { User, CreateUserDto, UpdateUserDto, UserResponse } from "../types/user_type";
+
+export class UserService {
+  async getAllUsers(): Promise<UserResponse[]> {
+    const users = await UserSQL.getUsers();
+    return users.map(this.mapToResponse);
+  }
+
+  async getUserById(id: number): Promise<UserResponse | null> {
+    const user = await UserSQL.getUserById(id);
+    if (!user) return null;
+    return this.mapToResponse(user);
+  }
+
+  async getUserByEmail(email: string): Promise<User | null> {
+    return await UserSQL.getUserByEmail(email);
+  }
+
+  async getUserByUsername(username: string): Promise<User | null> {
+    return await UserSQL.getUserByUsername(username);
+  }
+
+  async createUser(data: CreateUserDto): Promise<UserResponse> {
+    const existingUser = await UserSQL.getUserByEmail(data.email);
+    if (existingUser) {
+      throw new Error("User with this email already exists");
+    }
+
+    const existingUsername = await UserSQL.getUserByUsername(data.username);
+    if (existingUsername) {
+      throw new Error("Username already taken");
+    }
+
+    const user = await UserSQL.createUser(data);
+    return this.mapToResponse(user);
+  }
+
+  async updateUser(id: number, data: UpdateUserDto): Promise<UserResponse | null> {
+    const existingUser = await UserSQL.getUserById(id);
+    if (!existingUser) {
+      throw new Error("User not found");
+    }
+
+    if (data.email) {
+      const emailUser = await UserSQL.getUserByEmail(data.email);
+      if (emailUser && emailUser.id !== id) {
+        throw new Error("Email already in use");
+      }
+    }
+
+    if (data.username) {
+      const usernameUser = await UserSQL.getUserByUsername(data.username);
+      if (usernameUser && usernameUser.id !== id) {
+        throw new Error("Username already taken");
+      }
+    }
+
+    const filteredData = Object.fromEntries(
+      Object.entries(data).filter(([_, value]) => value !== undefined)
+    ) as UpdateUserDto;
+
+    const user = await UserSQL.updateUser(id, filteredData);
+    if (!user) return null;
+    return this.mapToResponse(user);
+  }
+
+  async deleteUser(id: number): Promise<boolean> {
+    const existingUser = await UserSQL.getUserById(id);
+    if (!existingUser) {
+      throw new Error("User not found");
+    }
+
+    return await UserSQL.deleteUser(id);
+  }
+
+  async softDeleteUser(id: number): Promise<UserResponse | null> {
+    const existingUser = await UserSQL.getUserById(id);
+    if (!existingUser) {
+      throw new Error("User not found");
+    }
+
+    const user = await UserSQL.softDeleteUser(id);
+    if (!user) return null;
+    return this.mapToResponse(user);
+  }
+
+  async searchUsers(keyword: string): Promise<UserResponse[]> {
+    const users = await UserSQL.searchUsers(keyword);
+    return users.map(this.mapToResponse);
+  }
+
+  private mapToResponse(user: User): UserResponse {
+    return {
+      id: user.id,
+      email: user.email,
+      username: user.username,
+      full_name: user.full_name,
+      avatar_url: user.avatar_url,
+      bio: user.bio,
+      role: user.role,
+      is_active: user.is_active,
+      created_at: user.created_at,
+      updated_at: user.updated_at,
+    };
+  }
+}
+
+export const userService = new UserService();