create-lyrajs 1.1.2 → 2.0.0

package/template/src/controller/ErrorController.ts

@@ -0,0 +1,126 @@
+import { Controller, Get, HTTP_STATUS, Route } from "@lyra-js/core"
+
+/**
+ * ErrorController - Handles HTTP error responses
+ *
+ * This controller provides error handling routes that can be called by the error handler.
+ * Each route can also be accessed directly for testing (e.g., GET /error/404?message=Custom+message)
+ *
+ * The errorHandler will redirect to these routes when errors occur.
+ * You can customize these methods to render custom error pages or return custom JSON responses.
+ */
+@Route({ path: "/error" })
+export class ErrorController extends Controller {
+  /**
+   * Handle 404 Not Found errors
+   * Access: GET /error/404
+   */
+  @Get("/404")
+  handle404(): void {
+    this.res.status(HTTP_STATUS.NOT_FOUND).json({
+      error: "Not Found",
+      message: "The requested resource was not found",
+      statusCode: HTTP_STATUS.NOT_FOUND,
+      path: this.req.url
+    })
+
+    // Example: Use SSR to render a custom 404 page
+    // this.render('errors/404.ejs', {
+    //     message: 'Page not found',
+    //     url: this.req.url
+    // });
+  }
+
+  /**
+   * Handle 500 Internal Server Error
+   * Access: GET /error/500
+   */
+  @Get("/500")
+  handle500(): void {
+    this.res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({
+      error: "Internal Server Error",
+      message: "An unexpected error occurred",
+      statusCode: HTTP_STATUS.INTERNAL_SERVER_ERROR
+    })
+
+    // Example: Use SSR to render a custom error page
+    // this.render('errors/500.ejs', {
+    //     message: 'Something went wrong'
+    // });
+  }
+
+  /**
+   * Handle 401 Unauthorized errors
+   * Access: GET /error/401
+   */
+  @Get("/401")
+  handle401(): void {
+    this.res.status(HTTP_STATUS.UNAUTHORIZED).json({
+      error: "Unauthorized",
+      message: "Authentication is required",
+      statusCode: HTTP_STATUS.UNAUTHORIZED
+    })
+
+    // Example: Use SSR to render a custom login page
+    // this.render('errors/401.ejs', {
+    //     message: 'Please log in to continue'
+    // });
+  }
+
+  /**
+   * Handle 403 Forbidden errors
+   * Access: GET /error/403
+   */
+  @Get("/403")
+  handle403(): void {
+    this.res.status(HTTP_STATUS.FORBIDDEN).json({
+      error: "Forbidden",
+      message: "You don't have permission to access this resource",
+      statusCode: HTTP_STATUS.FORBIDDEN
+    })
+
+    // Example: Use SSR to render a custom forbidden page
+    // this.render('errors/403.ejs', {
+    //     message: 'Access denied'
+    // });
+  }
+
+  /**
+   * Handle 400 Bad Request errors
+   * Access: GET /error/400
+   */
+  @Get("/400")
+  handle400(): void {
+    this.res.status(HTTP_STATUS.BAD_REQUEST).json({
+      error: "Bad Request",
+      message: "The request was invalid",
+      statusCode: HTTP_STATUS.BAD_REQUEST
+    })
+  }
+
+  /**
+   * Handle 409 Conflict errors
+   * Access: GET /error/409
+   */
+  @Get("/409")
+  handle409(): void {
+    this.res.status(HTTP_STATUS.CONFLICT).json({
+      error: "Conflict",
+      message: "The request conflicts with current state",
+      statusCode: HTTP_STATUS.CONFLICT
+    })
+  }
+
+  /**
+   * Handle 422 Unprocessable Entity errors
+   * Access: GET /error/422
+   */
+  @Get("/422")
+  handle422(): void {
+    this.res.status(HTTP_STATUS.UNPROCESSABLE_ENTITY).json({
+      error: "Unprocessable Entity",
+      errors: "Validation failed",
+      statusCode: HTTP_STATUS.UNPROCESSABLE_ENTITY
+    })
+  }
+}

package/template/src/controller/ExampleController.ts

@@ -0,0 +1,28 @@
+import { Controller, Get, NextFunction, Request, Response, Route } from "@lyra-js/core"
+
+/**
+ * Example controller using decorator-based routing
+ * Decorators provide a modern, declarative way to define routes directly in your controller classes
+ * Routes are automatically discovered and registered - no manual route file registration needed
+ */
+@Route({ path: "/example" })
+export class ExampleController extends Controller {
+  /**
+   * SSR endpoint using decorator-based routing
+   * The @Get decorator automatically registers this method as a GET route at /example/ssr
+   * Uses this.render() (instance method) for server-side rendering
+   */
+  @Get({ path: "/ssr" })
+  async exampleSsrRouteMethod(req: Request, res: Response, next: NextFunction) {
+    try {
+      await this.render("ExampleRender.tsx", {
+        title: "Server-Side Rendering with Decorator-Based Routing",
+        content:
+          "This page is rendered using the modern decorator-based approach in LyraJS. The @Route and @Get decorators automatically register this endpoint without requiring manual route file configuration. The this.render() instance method handles server-side template rendering, generating complete HTML pages that are SEO-friendly and load faster for users. Decorators make your code cleaner, more maintainable, and self-documenting.",
+        documentationUrl: "https://lyrajs.dev/"
+      })
+    } catch (error) {
+      next(error)
+    }
+  }
+}

package/template/src/controller/ExampleStaticController.ts

@@ -0,0 +1,40 @@
+import { Controller, NextFunction, Request, Response } from "@lyra-js/core"
+
+export class ExampleStaticController extends Controller {
+  /**
+   * Example JSON API endpoint using static method approach
+   * This demonstrates returning JSON data from a traditional static controller method
+   */
+  static exampleRouteMethod(req: Request, res: Response, next: NextFunction) {
+    try {
+      const exampleItem = {
+        id: 1,
+        title: "Static Controller Method Example",
+        content:
+          "This response is generated by a static controller method. Static methods are the traditional approach for defining route handlers in LyraJS, registered manually in route files. This endpoint returns JSON data, making it suitable for REST APIs consumed by frontend applications or mobile apps."
+      }
+
+      res.status(200).json({ message: "Item fetched successfully", exampleItem })
+    } catch (error) {
+      next(error)
+    }
+  }
+
+  /**
+   * Example SSR endpoint using static method approach
+   * This demonstrates server-side rendering with Controller.renderStatic()
+   * The rendered HTML is sent directly to the browser
+   */
+  static async exampleSsrRouteMethod(req: Request, res: Response, next: NextFunction) {
+    try {
+      await Controller.renderStatic(res, "ExampleRender.tsx", {
+        title: "Server-Side Rendering with Static Controllers",
+        content:
+          "This page is rendered on the server using the Controller.renderStatic() method from a traditional static controller. The HTML is generated server-side and sent to your browser, providing faster initial page loads and better SEO. Static methods require manual route registration in your route files (e.g., src/router/routes/*.ts).",
+        documentationUrl: "https://lyrajs.dev/"
+      })
+    } catch (error) {
+      next(error)
+    }
+  }
+}

package/template/src/controller/UserController.ts

@@ -1,37 +1,48 @@
-import {AccessControl, AuthenticatedRequest, UnauthorizedException, ValidationException, Validator} from "@lyra-js/core"
-import bcrypt from "bcrypt"
-import { NextFunction, Request, Response } from "express"
+import {
+  AccessControl,
+  Controller,
+  Delete,
+  Get,
+  isAuthenticated,
+  Patch,
+  Post,
+  Route,
+  UnauthorizedException,
+  ValidationException,
+  Validator
+} from "@lyra-js/core"
 
 import { User } from "@entity/User"
-import { userRepository } from "@repository/UserRepository"
 
-export class UserController {
-  static list = async (req: AuthenticatedRequest<Request>, res: Response, next: NextFunction): Promise<void> => {
+@Route({ path: "/user", middlewares: [isAuthenticated] })
+export class UserController extends Controller {
+  @Get({ path: "/all" })
+  async list(): Promise<void> {
     try {
-      const users = (await userRepository.findAll()).map((user: User) => {
-        delete user?.password
-        return user
+      const users = (await this.userRepository.findAll()).map((user: User) => {
+        const { password: _password, ...userWithoutPassword } = user
+        return userWithoutPassword
       })
-      res.status(200).json({ message: "Users fetched successfully", users })
+      this.res.status(200).json({ message: "Users fetched successfully", users })
     } catch (error) {
-      next(error)
+      this.next(error)
     }
   }
 
-  static read = async (req: AuthenticatedRequest<Request>, res: Response, next: NextFunction) => {
+  @Get({ path: "/:user", resolve: { user: User } })
+  async read(user: User) {
     try {
-      const { id } = req.params
-      const user = await userRepository.find(id)
-      delete user?.password
-      res.status(200).json({ message: "User fetched successfully", user })
+      const { password: _password, ...userWithoutPassword } = user
+      this.res.status(200).json({ message: "User fetched successfully", user: userWithoutPassword })
     } catch (error) {
-      next(error)
+      this.next(error)
     }
   }
 
-  static create = async (req: AuthenticatedRequest<Request>, res: Response, next: NextFunction) => {
+  @Post({ path: "/" })
+  async create() {
     try {
-      const { data }: { data: User } = req.body
+      const { data }: { data: User } = this.req.body
 
       if (!data.email || !data.password || !data.firstname || !data.lastname || !data.username) {
         new ValidationException("All fields are required.")
@@ -51,7 +62,7 @@ export class UserController {
         )
       }
 
-      const isEmailUsed = await userRepository.findOneBy({ email: data.email })
+      const isEmailUsed = await this.userRepository.findOneBy({ email: data.email })
 
       if (isEmailUsed) {
         throw new Error("Email already in use")
@@ -62,7 +73,7 @@ export class UserController {
       }
 
       const user = new User()
-      const hashedPassword = await bcrypt.hash(data.password, 10)
+      const hashedPassword = await this.bcrypt.hash(data.password, 10)
 
       user.username = data.username
       user.firstname = data.firstname
@@ -71,40 +82,48 @@ export class UserController {
       user.password = hashedPassword
       user.role = "ROLE_USER"
 
-      await userRepository.save(data)
-      res.status(201).json({ message: "User created successfully" })
+      await this.userRepository.save(data)
+      this.res.status(201).json({ message: "User created successfully" })
     } catch (error) {
-      next(error)
+      this.next(error)
     }
   }
 
-  static update = async (req: AuthenticatedRequest<Request>, res: Response, next: NextFunction) => {
+  @Patch({ path: "/:user", resolve: { user: User } })
+  async update(user: User) {
     try {
-      const { data }: { data: User } = req.body
-      const user = await userRepository.find(data.id)
-      if (!user) res.status(404).json({ message: "User not found" })
-      delete user?.password
-      delete user?.email
-      user.updated_at = new Date()
-      if (AccessControl.hasRoleHigherThan(req.user, user.role)) delete user.role
-      if (user) await userRepository.save(data)
-      res.status(200).json({ message: "Users updated successfully" })
+      const { data }: { data: User } = this.req.body
+      if (!user) return this.res.status(404).json({ message: "User not found" })
+      if (!AccessControl.isOwner(this.req.user, user.id) && !AccessControl.hasRoleHigherThan(this.req.user, user.role))
+        throw new UnauthorizedException()
+
+      // Remove sensitive fields from data
+      const { password: _password, email: _email, role, ...updateData } = data
+
+      // Keep role if user doesn't have higher privileges
+      const finalData = AccessControl.hasRoleHigherThan(this.req.user, user.role) ? updateData : { ...updateData, role }
+
+      finalData.updated_at = new Date()
+      await this.userRepository.save(finalData)
+      this.res.status(200).json({ message: "Users updated successfully" })
     } catch (error) {
-      next(error)
+      this.next(error)
     }
   }
 
-  static delete = async (req: AuthenticatedRequest<Request>, res: Response, next: NextFunction) => {
+  @Delete({ path: "/:id" })
+  async delete() {
     try {
-      const { id } = req.params
-      const user = await userRepository.find(id)
-      if (!user) res.status(404).json({ message: "User not found" })
-      if (!AccessControl.isOwner(req.user, user.id) && !AccessControl.hasRoleHigherThan(req.user, user.role)) throw new UnauthorizedException()
-      if (!user?.id) res.status(400).json({ message: "Invalid user id" })
-      if (user?.id && id) await userRepository.delete(id)
-      res.status(200).json({ message: "User deleted successfully" })
+      const { id } = this.req.params
+      const user = await this.userRepository.find(id)
+      if (!user) return this.res.status(404).json({ message: "User not found" })
+      if (!AccessControl.isOwner(this.req.user, user.id) && !AccessControl.hasRoleHigherThan(this.req.user, user.role))
+        throw new UnauthorizedException()
+      if (!user?.id) this.res.status(400).json({ message: "Invalid user id" })
+      if (user?.id && id) await this.userRepository.delete(id)
+      this.res.status(200).json({ message: "User deleted successfully" })
     } catch (error) {
-      next(error)
+      this.next(error)
     }
   }
 }

package/template/src/fixtures/{AppFixtures.ts → UserFixtures.ts}

@@ -1,9 +1,8 @@
-import bcrypt from "bcrypt"
+import { Fixture } from "@lyra-js/core"
 
 import { User } from "@entity/User"
-import { userRepository } from "@repository/UserRepository"
 
-export class AppFixtures {
+export class UserFixtures extends Fixture {
   private users = [
     {
       username: "Mithrandil",
@@ -34,7 +33,7 @@ export class AppFixtures {
 
   private loadUsers = async () => {
     for (const u of this.users) {
-      const hashedPassword = await bcrypt.hash(u.password, 10)
+      const hashedPassword = await this.bcrypt.hash(u.password, 10)
       const user = new User()
       user.username = u.username
       user.firstname = u.firstname
@@ -43,7 +42,7 @@ export class AppFixtures {
       user.password = hashedPassword
       user.created_at = new Date()
       user.updated_at = new Date()
-      await userRepository.save(user)
+      await this.userRepository.save(user)
     }
   }
 }

package/template/src/jobs/ExampleJob.ts

@@ -0,0 +1,63 @@
+import { Job, JobBase, Schedule } from "@lyra-js/core"
+
+/**
+ * ExampleJob - Demonstrates scheduled job functionality
+ * Jobs can have multiple scheduled methods with different recurrency patterns
+ * Access injected dependencies: this.userRepository, this.emailService, etc.
+ */
+@Job()
+export class ExampleJob extends JobBase {
+  /**
+   * Example: Daily report that runs every day at 9:00 AM
+   * Uncomment to enable this scheduler
+   */
+  @Schedule({ recurrency: "0 9 * * *", enabled: false })
+  async sendDailyReport() {
+    console.log("Sending daily report...")
+    // Your logic here
+    // Example: const users = await this.userRepository.findAll();
+  }
+
+  /**
+   * Example: Weekly cleanup that runs every Monday at 2:00 AM
+   * Uncomment to enable this scheduler
+   */
+  // @Schedule({ recurrency: '0 2 * * 1', enabled: false })
+  // async weeklyCleanup() {
+  //   console.log('Running weekly cleanup...');
+  //   // Your logic here
+  // }
+
+  /**
+   * Example: Monthly summary on the 1st of each month at midnight
+   * Uncomment to enable this scheduler
+   */
+  // @Schedule({ recurrency: '0 0 1 * *', enabled: false })
+  // async monthlySummary() {
+  //   console.log('Generating monthly summary...');
+  //   // Your logic here
+  // }
+
+  /**
+   * Lifecycle hook - called when the job is initialized
+   */
+  async onInit() {
+    // console.log("ExampleJob initialized")
+  }
+
+  /**
+   * Lifecycle hook - called before each scheduled method execution
+   */
+  async beforeExecute() {
+    // Add common logic before each job execution
+    // Example: Set up database transaction, log execution start, etc.
+  }
+
+  /**
+   * Lifecycle hook - called after each scheduled method execution
+   */
+  async afterExecute() {
+    // Add common logic after each job execution
+    // Example: Commit transaction, log execution end, cleanup, etc.
+  }
+}

package/template/src/middleware/YourMiddleware.ts

@@ -1,4 +1,4 @@
-import { NextFunction, Request, Response } from "express"
+import { NextFunction, Request, Response } from "@lyra-js/core"
 
 export const YourMiddleware = (req: Request, res: Response, next: NextFunction) => {
   console.log("Your middleware checks or does something here...")

package/template/src/repository/UserRepository.ts

@@ -1,10 +1,9 @@
 import { Repository } from "@lyra-js/core"
+
 import { User } from "@entity/User"
 
-class UserRepository extends Repository<User> {
+export class UserRepository extends Repository<User> {
   constructor() {
     super(User)
   }
 }
-
-export const userRepository = new UserRepository()

package/template/src/router/index.ts

@@ -1,14 +1,7 @@
-import { Response, Router } from "express"
+import { createRouter } from "@lyra-js/core"
 
-import { Config } from "@lyra-js/core"
 import { routes } from "@router/routes"
 
-const routerBasePath = new Config().get("router.base_path")
+export const router = createRouter()
 
-export const router = Router()
-
-router.use(routerBasePath, routes)
-
-router.get("/", (req, res: Response) => {
-  res.send("Nothing here...")
-})
+router.use(routes)

package/template/src/router/routes/exampleRoutes.ts

@@ -0,0 +1,7 @@
+import { ExampleStaticController as ExampleController } from "@controller/ExampleStaticController"
+import { createRouter } from "@lyra-js/core"
+
+export const exampleRoutes = createRouter()
+
+exampleRoutes.get("/item", ExampleController.exampleRouteMethod)
+exampleRoutes.get("/ssr-static", ExampleController.exampleSsrRouteMethod)

package/template/src/router/routes/index.ts

@@ -1,9 +1,7 @@
-import { Router } from "express"
+import { createRouter } from "@lyra-js/core"
 
-import { authRoutes } from "./authRoutes"
-import { userRoutes } from "./userRoutes"
+import { exampleRoutes } from "./exampleRoutes"
 
-export const routes = Router()
+export const routes = createRouter()
 
-routes.use("/auth", authRoutes)
-routes.use("/user", userRoutes)
+routes.use("/example", exampleRoutes)

package/template/src/server.ts

@@ -1,12 +1,11 @@
-import cookieParser from "cookie-parser"
-import cors from "cors"
+import "reflect-metadata"
+
+import { Config, cors, createServer, LyraConsole, SecurityConfig } from "@lyra-js/core"
+import bcrypt from "bcrypt"
 import * as dotenv from "dotenv"
-import express from "express"
+import jwt from "jsonwebtoken"
 import * as process from "node:process"
 
-import { router } from "@app/router"
-import { Config, SecurityConfig, LyraConsole, accessMiddleware, errorHandler, httpRequestMiddleware } from "@lyra-js/core"
-
 dotenv.config()
 
 process.env.TZ = process.env.TZ || "Europe/Paris"
@@ -14,32 +13,44 @@ process.env.TZ = process.env.TZ || "Europe/Paris"
 const params = new Config().get("parameters")
 const securityConfig = new SecurityConfig().getConfig()
 
-const port = process.env.PORT
-const app = express()
+const port = process.env.PORT ? parseInt(process.env.PORT) : 3333
+const app = createServer()
+
+// Server settings
+app.setSetting("trust proxy", false)
+app.setSetting("request max size", securityConfig.limits.request_max_size || "10mb")
+app.setSetting("ssr", {
+  engine: "jsx", // Default template engine (support tsx and jsx files)
+  templates: "./src/templates", // Path to templates directory
+  options: {} // Engine-specific options (optional)
+})
+
+// Register third-party libraries for dependency injection
+app.register(bcrypt, "bcrypt")
+app.register(jwt, "jwt")
 
-app.set("trust proxy", false)
-app.use(cookieParser())
-app.use(express.json({ limit: securityConfig.limits.request_max_size || "10mb" }))
-app.use(express.urlencoded({ limit: securityConfig.limits.request_max_size || "10mb", extended: true }))
+// CORS middleware
 app.use(
   cors({
     origin: `${process.env.CLIENT_APP_URL}`,
     credentials: true
   })
 )
-app.use(httpRequestMiddleware)
-app.use(accessMiddleware)
-app.use(router)
-app.use(errorHandler)
-
-app.listen(port, (err?: Error) => {
-  if (err) {
-    LyraConsole.error("Error starting server:", err.message)
-  } else {
-    LyraConsole.info(
-      `${params.api_name} v${params.api_version}`,
-      `Server running at ${params.api_host}:${params.api_port}`,
-      ""
-    )
-  }
+
+// Enable scheduler (optional) - uncomment to activate scheduled jobs
+// Jobs are auto-discovered from src/jobs directory
+// Only schedules with enabled: true will run
+// app.enableScheduler({ timezone: "UTC" })
+
+app.serveStatic("/assets", {
+  root: "public/assets"
+})
+
+// Controllers are auto-discovered and registered from src/controller directory
+// Repositories and Services are auto-injected via DIContainer
+app.listen(port, () => {
+  LyraConsole.info(
+    `${params.api_name} v${params.api_version}`,
+    `Server running at ${params.api_host}:${params.api_port}`
+  )
 })

package/template/src/services/YourService.ts

@@ -1,4 +1,6 @@
-export class YourService {
+import { Service } from "@lyra-js/core"
+
+export class YourService extends Service {
   exemple() {
     console.log("Here is a method of your service...")
   }

package/template/src/templates/ExampleRender.tsx

@@ -0,0 +1,20 @@
+import { Base } from "@app/templates/layout/Base"
+
+export default function ExampleRender({
+  title,
+  content,
+  documentationUrl
+}: {
+  title: string
+  content: string
+  documentationUrl: string
+}) {
+  return (
+    <Base>
+      <section>
+        <h1>{title}</h1>
+        <p>{content}</p>
+      </section>
+    </Base>
+  )
+}