create-warlock 3.0.17 → 3.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-warlock",
-    "version": "3.0.17",
+    "version": "3.0.18",
     "main": "./esm/index.js",
     "license": "MIT",
     "type": "module",

package/templates/warlock/AGENTS.md

@@ -0,0 +1,11 @@
+# Agent Guidelines
+
+## Module Creation
+
+When creating a new module, refer to the comprehensive guide in [docs/new-module.md](../docs/new-module.md) for:
+- Complete directory structure
+- Detailed explanations of each folder and file
+- Code examples and best practices
+- Auto-imported files (main.ts, routes.ts, utils/locales.ts, events/)
+- Validation patterns with TypeScript type inference
+- Controller, service, repository patterns

package/templates/warlock/docs/new-module.md

@@ -0,0 +1,447 @@
+# Create a new module
+
+Each module should consist of the following structure:
+
+```
+src/app/[module-name]/
+├── main.ts                      # Entry point (auto-imported by Warlock.js)
+├── routes.ts                    # Main routing file (auto-imported by Warlock.js)
+├── controllers/                 # Request handlers
+│   ├── [feature]/              # Grouped by feature (e.g., auth, profile)
+│   │   └── *.controller.ts
+│   └── [module].restful.ts     # RESTful resource controller (optional)
+├── services/                    # Business logic layer
+│   ├── *.service.ts
+│   └── mail/                   # Email services (optional, can be separate folder or files)
+│       └── *.ts
+├── repositories/                # Data access layer
+│   └── [resource].repository.ts
+├── models/                      # Database models
+│   └── [model-name]/
+│       ├── index.ts
+│       ├── [model-name].model.ts
+│       └── migrations/
+│           └── [date]_[model-name].migration.ts
+├── validation/                  # Request validation schemas
+│   ├── index.ts                # Simple validations (if all in one file)
+│   └── *.validation.ts         # Individual validation files
+├── output/                      # Response output transformers
+│   └── *.output.ts
+├── events/                      # Event handlers/listeners (auto-imported by Warlock.js)
+│   └── *.ts
+├── components/                  # Reusable components for use within mails
+│   └── *.ts
+├── types/                       # TypeScript type definitions
+│   └── *.ts
+└── utils/                       # Module-specific utilities
+    ├── locales.ts              # Translations (auto-imported by Warlock.js)
+    └── flags.ts                # Constants/flags
+```
+
+## Directory Structure Details
+
+### 1. main.ts (Auto-imported)
+Entry point file that is automatically imported by Warlock.js when the module loads. Use this for module initialization, event listeners, or setup code that should run when the module is loaded.
+
+**Example:**
+```typescript
+import { onceConnected } from "@warlock.js/cascade";
+
+// This function will be called once the app is connected to the database
+onceConnected(async () => {
+  // Module initialization code
+  // Register event listeners
+  // Setup module-specific configurations
+});
+```
+
+### 2. routes.ts (Auto-imported)
+Main routing file that defines all module endpoints. This file is automatically imported by Warlock.js. Use router guards (`guarded`, `guardedAdmin`, `guardedGuest`, etc.) to protect routes.
+
+**Example:**
+```typescript
+import { router } from "@warlock.js/core";
+import { guarded, guardedGuest } from "app/utils/router";
+import { createAccountController } from "./controllers/auth/create-account.controller";
+import { myProfile } from "./controllers/profile/my-profile.controller";
+
+guardedGuest(() => {
+  router.post("/register", createAccountController);
+});
+
+guarded(() => {
+  router.get("/me", myProfile);
+});
+```
+
+### 3. controllers/
+Request handlers that process HTTP requests. Organize controllers by feature (e.g., `auth/`, `profile/`).
+
+**Controller Structure:**
+```typescript
+import type { Request, RequestHandler, Response } from "@warlock.js/core";
+import { someService } from "app/[module]/services/some.service";
+import { someSchema } from "app/[module]/validation/some.validation";
+
+export const someController: RequestHandler = async (
+  request: Request,
+  response: Response,
+) => {
+  const data = await someService(request.validated());
+  return response.success({ data });
+};
+
+someController.validation = {
+  schema: someSchema,
+};
+```
+
+**For RESTful Resources:**
+```typescript
+import { Restful, type RouteResource, v } from "@warlock.js/core";
+import { SomeModel } from "../models/some";
+import { someRepository } from "../repositories/some.repository";
+
+class RestfulSome extends Restful<SomeModel> implements RouteResource {
+  protected repository = someRepository;
+  
+  public validation: RouteResource["validation"] = {
+    create: {
+      schema: v.object({
+        name: v.string().required(),
+      }),
+    },
+  };
+}
+
+export const restfulSome = new RestfulSome();
+```
+
+### 4. services/
+Business logic layer. Services handle the core functionality and interact with repositories.
+
+**Service Structure:**
+```typescript
+import type { SomeModel } from "app/[module]/models/some";
+import { someRepository } from "app/[module]/repositories/some.repository";
+
+export async function someService(
+  data: Record<string, any>,
+): Promise<SomeModel> {
+  return await someRepository.create(data);
+}
+```
+
+### 5. repositories/
+Data access layer that extends `RepositoryManager`. Handles database queries and filtering.
+
+**Repository Structure:**
+```typescript
+import type { FilterByOptions, RepositoryOptions } from "@warlock.js/core";
+import { RepositoryManager } from "@warlock.js/core";
+import { SomeModel } from "../models/some";
+
+export class SomeRepository extends RepositoryManager<SomeModel> {
+  public model = SomeModel;
+
+  protected defaultOptions: RepositoryOptions = this.withDefaultOptions({});
+
+  protected filterBy: FilterByOptions = this.withDefaultFilters({
+    name: "like",
+    isActive: "bool",
+  });
+}
+
+export const someRepository = new SomeRepository();
+```
+
+### 6. models/
+Database models that extend base model classes (e.g., `Model`, `Auth`). Include migrations in the `migrations/` subdirectory.
+
+**Model Structure:**
+```typescript
+import { Model } from "@warlock.js/core";
+import type { Casts, Document } from "@warlock.js/core";
+import { SomeOutput } from "../../output/some.output";
+
+export class SomeModel extends Model {
+  public static collection = "somes";
+  public static output = SomeOutput;
+  
+  public syncWith = [];
+
+  public defaultValue: Document = {
+    isActive: true,
+  };
+
+  protected casts: Casts = {
+    name: "string",
+    isActive: "boolean",
+  };
+
+  public embedded = ["id", "name"];
+}
+```
+
+### 7. validation/
+Validation schemas using the `@warlock.js/core` validation system. **All validation schemas must be in the validation folder** to be used with `request.validated()` and TypeScript type inference.
+
+**Important Rules:**
+- If a module has simple validations, use `index.ts` to export all schemas
+- If validations are complex or numerous, use separate `.validation.ts` files
+- Always export the schema and its inferred type
+- Pass the inferred type as generic to `Request<Model, ValidationType>`
+- Use `Infer<typeof schema>` (similar to Zod) to generate TypeScript types
+
+**Simple Validation (index.ts):**
+```typescript
+import { v, type Infer } from "@warlock.js/core";
+
+export const createSchema = v.object({
+  name: v.string().minLength(2).required(),
+});
+
+export const updateSchema = v.object({
+  name: v.string().minLength(2).optional(),
+});
+
+export type CreateData = Infer<typeof createSchema>;
+export type UpdateData = Infer<typeof updateSchema>;
+```
+
+**Individual Validation Files:**
+```typescript
+// validation/create-account.validation.ts
+import { v, type Infer } from "@warlock.js/core";
+
+export const createAccountSchema = v.object({
+  name: v.string().minLength(2).required(),
+  email: v.string().email().required(),
+  password: v.string().minLength(8).required().strongPassword(),
+});
+
+export type CreateAccountData = Infer<typeof createAccountSchema>;
+```
+
+**Usage in Controller:**
+```typescript
+import type { Request, RequestHandler, Response } from "@warlock.js/core";
+import type { User } from "app/[module]/models/user";
+import { createAccountSchema, type CreateAccountData } from "app/[module]/validation/create-account.validation";
+
+export const createAccountController: RequestHandler = async (
+  request: Request<User, CreateAccountData>,
+  response: Response,
+) => {
+  // request.validated() is now typed as CreateAccountData
+  const data = request.validated();
+  // ...
+};
+
+createAccountController.validation = {
+  schema: createAccountSchema,
+};
+```
+
+### 8. output/
+Response output transformers that define what data is returned to clients.
+
+**Output Structure:**
+```typescript
+import { Output, type FinalOutput } from "@warlock.js/core";
+import { withBaseOutputDetails } from "app/utils/output";
+
+export class SomeOutput extends Output {
+  protected output: FinalOutput = withBaseOutputDetails({
+    name: "string",
+    email: "string",
+  });
+}
+```
+
+### 9. events/ (Auto-imported)
+Event handlers and listeners for model events or application events. **All files in this folder are automatically imported by Warlock.js** - no need to manually import them elsewhere.
+
+**Event Structure:**
+```typescript
+import { Response } from "@warlock.js/core";
+
+export function someEventHandler(response: Response) {
+  // Event handling logic
+}
+
+Response.on("sending", someEventHandler);
+```
+
+**Note:** Files in the `events/` folder are auto-imported, similar to `routes.ts`, `main.ts`, and `utils/locales.ts`. Just create the file and it will be loaded automatically.
+
+### 10. services/mail/ (or separate mail/ folder)
+Email service functions for sending notifications. **Mail files should be suffixed with `.mail.ts`** (e.g., `welcome.mail.ts`, `reset-password.mail.ts`).
+
+You can organize mail services either as:
+- Files in `services/mail/` folder (if you have multiple mail-related services) - **Recommended**
+- Individual files in `services/` folder (if you have few mail services)
+- A separate `mail/` folder at module root (legacy pattern, still supported)
+
+**Mail Structure:**
+```typescript
+// services/mail/welcome.mail.ts
+import { sendMail } from "@warlock.js/core";
+import type { SomeModel } from "../models/some";
+import { SomeEmailComponent } from "../components/some-email.component";
+
+export default async function sendWelcomeEmail(model: SomeModel) {
+  await sendMail({
+    to: model.get("email"),
+    subject: "Subject",
+    html: SomeEmailComponent({ name: model.get("name") }),
+  });
+}
+```
+
+**Recommendation:** Use `services/mail/` folder for better organization when you have multiple mail templates, and always suffix mail files with `.mail.ts`.
+
+### 11. components/
+Reusable components for use within email templates. These are typically functions that return HTML strings or React-like components that can be used in mail services.
+
+**Component Structure:**
+```typescript
+export function WelcomeEmailComponent(data: { name: string; email: string }) {
+  return `
+    <div>
+      <h1>Welcome, ${data.name}!</h1>
+      <p>Your email: ${data.email}</p>
+    </div>
+  `;
+}
+```
+
+**Usage in Mail:**
+```typescript
+import { sendMail } from "@warlock.js/core";
+import { WelcomeEmailComponent } from "../components/welcome-email.component";
+
+export default async function sendWelcomeEmail(user: User) {
+  await sendMail({
+    to: user.get("email"),
+    subject: "Welcome",
+    html: WelcomeEmailComponent({ 
+      name: user.get("name"), 
+      email: user.get("email") 
+    }),
+  });
+}
+```
+
+### 12. types/
+TypeScript type definitions specific to the module. Use this folder for:
+- Request/response types
+- Service parameter types
+- Module-specific interfaces
+- Type utilities
+
+**Types Structure:**
+```typescript
+// types/user.types.ts
+export interface UserPreferences {
+  theme: "light" | "dark";
+  notifications: boolean;
+}
+
+export type UserRole = "admin" | "user" | "guest";
+```
+
+### 13. utils/
+Module-specific utility functions. **Must include `locales.ts`** which is automatically imported by Warlock.js.
+
+**utils/locales.ts (Auto-imported):**
+```typescript
+import { groupedTranslations } from "@mongez/localization";
+
+groupedTranslations("moduleName", {
+  key1: {
+    en: "English translation",
+    ar: "Arabic translation",
+  },
+  invalidCredentials: {
+    en: "Invalid credentials",
+    ar: "بيانات الدخول غير صحيحة",
+  },
+});
+```
+
+**utils/flags.ts (Constants):**
+```typescript
+// Module-specific constants and flags
+export const USER_STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+} as const;
+
+export const USER_ROLES = {
+  ADMIN: "admin",
+  USER: "user",
+  GUEST: "guest",
+} as const;
+```
+
+**Other Utilities:**
+```typescript
+// utils/helpers.ts or similar
+export function formatUserName(user: User): string {
+  return `${user.get("firstName")} ${user.get("lastName")}`;
+}
+```
+
+**Note:** The `utils/locales.ts` file is automatically imported by Warlock.js, similar to `routes.ts`, `main.ts`, and files in the `events/` folder.
+
+## Best Practices
+
+1. **Naming Conventions:**
+   - Use kebab-case for file names
+   - Use PascalCase for class names
+   - Use camelCase for functions and variables
+
+2. **Controller Organization:**
+   - Group related controllers in subdirectories (e.g., `auth/`, `profile/`)
+   - Keep controllers thin - delegate business logic to services
+
+3. **Service Layer:**
+   - Services should contain reusable business logic
+   - Services interact with repositories, not directly with models
+
+4. **Repository Pattern:**
+   - All database operations should go through repositories
+   - Define filter options in the repository class
+
+5. **Validation:**
+   - **All validation schemas must be in the `validation/` folder**
+   - Always attach validation to controllers using `controller.validation = { schema }`
+   - Export TypeScript types from validation files using `Infer<typeof schema>`
+   - Use the inferred type as a generic parameter in `Request<Model, ValidationType>`
+   - Use `index.ts` for simple validations, separate `.validation.ts` files for complex ones
+
+6. **Models:**
+   - Define casts for all fields
+   - Specify embedded fields for performance
+   - Include default values when needed
+
+7. **Routes:**
+   - Use appropriate guards (`guarded`, `guardedAdmin`, `guardedGuest`)
+   - Group related routes together
+   - Use RESTful resources when appropriate
+   - Routes file is auto-imported by Warlock.js
+
+8. **Auto-imported Files:**
+   - `main.ts` - Module entry point
+   - `routes.ts` - Route definitions
+   - `utils/locales.ts` - Translations
+   - All files in `events/` folder - Event handlers
+   - No need to manually import these files elsewhere
+
+9. **Organization:**
+   - Keep mail services organized: use `services/mail/` folder if multiple, or individual files in `services/` if few
+   - Use `components/` folder for reusable email components
+   - Define module-specific types in `types/` folder
+   - Use `utils/flags.ts` for constants and configuration flags

package/templates/warlock/package.json

@@ -25,17 +25,17 @@
         "@mongez/collection": "^1.2.0",
         "@mongez/encryption": "^1.0.4",
         "@mongez/fs": "^3.0.5",
-        "@mongez/reinforcements": "^2.3.10",
+        "@mongez/reinforcements": "^2.3.12",
         "@mongez/localization": "^3.0.0",
         "@mongez/dotenv": "^1.1.9",
         "@mongez/config": "^1.0.26",
         "@mongez/supportive-is": "^2.0.4",
-        "@warlock.js/auth": "3.0.17",
-        "@warlock.js/cache": "3.0.17",
-        "@warlock.js/cascade": "3.0.17",
-        "@warlock.js/core": "3.0.17",
-        "@warlock.js/logger": "3.0.17",
-        "@warlock.js/seal": "3.0.17",
+        "@warlock.js/auth": "3.0.18",
+        "@warlock.js/cache": "3.0.18",
+        "@warlock.js/cascade": "3.0.18",
+        "@warlock.js/core": "3.0.18",
+        "@warlock.js/logger": "3.0.18",
+        "@warlock.js/seal": "3.0.18",
         "@faker-js/faker": "^9.2.0",
         "dayjs": "^1.11.13"
     },

package/templates/warlock/src/app/posts/controllers/create-post.controller.ts

@@ -0,0 +1,22 @@
+import type { Request, RequestHandler, Response } from "@warlock.js/core";
+import type { Post } from "app/posts/models/post";
+import { createPostService } from "app/posts/services/posts.service";
+import {
+  createPostSchema,
+  type CreatePostData,
+} from "app/posts/validation/create-post.validation";
+
+export const createPostController: RequestHandler = async (
+  request: Request<Post, CreatePostData>,
+  response: Response,
+) => {
+  const post = await createPostService(request.validated());
+
+  return response.success({
+    post,
+  });
+};
+
+createPostController.validation = {
+  schema: createPostSchema,
+};

package/templates/warlock/src/app/posts/controllers/get-all-posts.controller.ts

@@ -0,0 +1,13 @@
+import type { RequestHandler, Response } from "@warlock.js/core";
+import { getAllPostsService } from "app/posts/services/posts.service";
+
+export const getAllPostsController: RequestHandler = async (
+  request,
+  response: Response,
+) => {
+  const posts = await getAllPostsService();
+
+  return response.success({
+    posts,
+  });
+};

package/templates/warlock/src/app/posts/controllers/get-post.controller.ts

@@ -0,0 +1,28 @@
+import type { Request, RequestHandler, Response } from "@warlock.js/core";
+import type { Post } from "app/posts/models/post";
+import { getPostByIdService } from "app/posts/services/posts.service";
+import {
+  getPostSchema,
+  type GetPostData,
+} from "app/posts/validation/get-post.validation";
+
+export const getPostController: RequestHandler = async (
+  request: Request<Post, GetPostData>,
+  response: Response,
+) => {
+  const post = await getPostByIdService(request.int("id"));
+
+  if (!post) {
+    return response.notFound({
+      error: "Post Not found",
+    });
+  }
+
+  return response.success({
+    post,
+  });
+};
+
+getPostController.validation = {
+  schema: getPostSchema,
+};

package/templates/warlock/src/app/posts/models/index.ts

@@ -1 +1 @@
-export * from "./post.model";
+export * from "./post";

package/templates/warlock/src/app/posts/models/post/index.ts

@@ -0,0 +1 @@
+export * from "./post.model";

package/templates/warlock/src/app/posts/models/{post.model.ts → post/post.model.ts}

@@ -1,5 +1,5 @@
 import { Model, type Casts } from "@warlock.js/cascade";
-import { PostOutput } from "../output/post.output";
+import { PostOutput } from "../../output/post.output";
 
 export class Post extends Model {
   /**
@@ -12,6 +12,11 @@ export class Post extends Model {
    */
   public static output = PostOutput;
 
+  /**
+   * {@inheritDoc}
+   */
+  public syncWith = [];
+
   /**
    * Casts
    */
@@ -19,4 +24,9 @@ export class Post extends Model {
     title: "string",
     content: "string",
   };
+
+  /**
+   * {@inheritDoc}
+   */
+  public embedded = ["id", "title"];
 }

package/templates/warlock/src/app/posts/output/post.output.ts

@@ -1,13 +1,12 @@
-import { type FinalOutput, Output } from "@warlock.js/core";
+import { Output, type FinalOutput } from "@warlock.js/core";
+import { withBaseOutputDetails } from "app/utils/output";
 
 export class PostOutput extends Output {
   /**
    * {@inheritdoc}
    */
-  protected output: FinalOutput = {
-    id: "int",
+  protected output: FinalOutput = withBaseOutputDetails({
     title: "string",
     content: "string",
-    createdAt: "date",
-  };
+  });
 }

package/templates/warlock/src/app/posts/repositories/posts.repository.ts

@@ -0,0 +1,26 @@
+import type { FilterByOptions, RepositoryOptions } from "@warlock.js/core";
+import { RepositoryManager } from "@warlock.js/core";
+
+import { Post } from "../models/post";
+
+export class PostsRepository extends RepositoryManager<Post> {
+  /**
+   * {@inheritDoc}
+   */
+  public model = Post;
+
+  /**
+   * List default options
+   */
+  protected defaultOptions: RepositoryOptions = this.withDefaultOptions({});
+
+  /**
+   * Filter By options
+   */
+  protected filterBy: FilterByOptions = this.withDefaultFilters({
+    title: "like",
+    author: ["int", "createdBy.id"],
+  });
+}
+
+export const postsRepository = new PostsRepository();

package/templates/warlock/src/app/posts/routes.ts

@@ -1,12 +1,12 @@
 import { router } from "@warlock.js/core";
-import { guarded } from "../utils/router";
-import { createNewPostRequest } from "./controllers/create-new-post.request";
-import { getAllPostsRequest } from "./controllers/get-all-posts.request";
-import { getPostRequest } from "./controllers/get-post.request";
+import { guarded } from "app/utils/router";
+import { createPostController } from "./controllers/create-post.controller";
+import { getAllPostsController } from "./controllers/get-all-posts.controller";
+import { getPostController } from "./controllers/get-post.controller";
 
-router.get("/posts", getAllPostsRequest);
-router.get("/posts/:id", getPostRequest);
+router.get("/posts", getAllPostsController);
+router.get("/posts/:id", getPostController);
 
 guarded(() => {
-  router.post("/posts", createNewPostRequest);
+  router.post("/posts", createPostController);
 });

package/templates/warlock/src/app/posts/services/posts.service.ts

@@ -0,0 +1,28 @@
+import type { PaginationListing } from "@warlock.js/cascade";
+import type { Post } from "app/posts/models/post";
+import { postsRepository } from "app/posts/repositories/posts.repository";
+import type { CreatePostData } from "app/posts/validation/create-post.validation";
+import type { PostsListsParams } from "../types";
+
+/**
+ * Create a new post
+ */
+export async function createPostService(data: CreatePostData): Promise<Post> {
+  return await postsRepository.create(data);
+}
+
+/**
+ * Get all posts
+ */
+export async function getAllPostsService(
+  params: PostsListsParams = {},
+): Promise<PaginationListing<Post>> {
+  return await postsRepository.list(params);
+}
+
+/**
+ * Get a single post by ID
+ */
+export async function getPostByIdService(id: number): Promise<Post | null> {
+  return await postsRepository.findActiveCached(id);
+}

package/templates/warlock/src/app/posts/types/index.ts

@@ -0,0 +1,6 @@
+export type PostsListsParams = {
+  page?: number;
+  limit?: number;
+  author?: number; // author id
+  title?: string;
+};

package/templates/warlock/src/app/posts/utils/locales.ts

@@ -0,0 +1,8 @@
+import { groupedTranslations } from "@mongez/localization";
+
+groupedTranslations("posts", {
+  postNotFound: {
+    en: "Post Not found",
+    ar: "المنشور غير موجود",
+  },
+});

package/templates/warlock/src/app/posts/validation/create-post.validation.ts

@@ -0,0 +1,8 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const createPostSchema = v.object({
+  title: v.string().required().minLength(4),
+  content: v.string().required(),
+});
+
+export type CreatePostData = Infer<typeof createPostSchema>;

package/templates/warlock/src/app/posts/validation/get-post.validation.ts

@@ -0,0 +1,7 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const getPostSchema = v.object({
+  id: v.int().required(),
+});
+
+export type GetPostData = Infer<typeof getPostSchema>;

package/templates/warlock/src/app/users/controllers/auth/create-account.controller.ts

@@ -1,16 +1,14 @@
 import type { Request, RequestHandler, Response } from "@warlock.js/core";
-import { createAccountService } from "app/users/services/account.service";
+import type { User } from "app/users/models/user";
+import { createAccountService } from "app/users/services/create-account.service";
 import { loginUserService } from "app/users/services/login.service";
-import {
-  createAccountSchema,
-  type CreateAccountData,
-} from "app/users/validation/create-account.validation";
+import { createAccountSchema } from "app/users/validation/create-account.validation";
 
 export const createAccountController: RequestHandler = async (
-  request: Request<CreateAccountData>,
+  request: Request<User>,
   response: Response,
 ) => {
-  const user = await createAccountService(request.validated());
+  const user = await createAccountService(request.validated()); //
 
   request.guest = request.user;
   request.user = user;

package/templates/warlock/src/app/users/controllers/profile/change-password.controller.ts

@@ -17,7 +17,7 @@ export default async function changePassword(
 changePassword.validation = {
   schema: v.object({
     password: v.string().minLength(8).required(),
-    confirmPassword: v.string().required().matches("password"),
+    confirmPassword: v.string().required().sameAs("password").omit(),
   }),
   validate: (request: Request<User>, response: Response) => {
     const user = request.user;

package/templates/warlock/src/app/users/services/{account.service.ts → create-account.service.ts}

@@ -1,6 +1,6 @@
 import { Random } from "@mongez/reinforcements";
 import type { User } from "app/users/models/user";
-import usersRepository from "app/users/repositories/users-repository";
+import { usersRepository } from "app/users/repositories/users.repository";
 
 /**
  * Create a new user account

package/templates/warlock/src/app/users/services/login.service.ts

@@ -6,13 +6,11 @@ import type { User } from "app/users/models/user";
 export async function loginUserService(user: User): Promise<{
   user: any;
   accessToken: string;
-  userType: string;
 }> {
   const accessToken = await user.generateAccessToken();
-  
+
   return {
     user: await user.toJSON(),
     accessToken: accessToken,
-    userType: user.userType,
   };
 }

package/templates/warlock/src/app/users/validation/create-account.validation.ts

@@ -4,7 +4,7 @@ export const createAccountSchema = v.object({
   name: v.string().minLength(2).required(),
   email: v.string().email().required(),
   password: v.string().minLength(8).required().strongPassword(),
-  confirmPassword: v.string().minLength(8).required().saveAs("password"),
+  confirmPassword: v.string().minLength(8).required().sameAs("password").omit(),
 });
 
 export type CreateAccountData = Infer<typeof createAccountSchema>;

package/templates/warlock/src/config/validation.ts

@@ -68,7 +68,7 @@ const validationConfigurations: ValidationConfigurations = {
     image: ImageRule,
   },
   keys: {
-    response: "messages",
+    response: "errors",
     inputKey: "key",
     inputError: "error",
     inputErrors: "errors",

package/templates/warlock/src/app/posts/controllers/create-new-post.request.ts

@@ -1,26 +0,0 @@
-import {
-  v,
-  type Request,
-  type RequestHandler,
-  type Response,
-} from "@warlock.js/core";
-import { Post } from "../models";
-
-export const createNewPostRequest: RequestHandler = async (
-  request: Request,
-  response: Response,
-) => {
-  const post = await Post.create(request.validated());
-
-  return response.success({
-    message: "Post created successfully",
-    post,
-  });
-};
-
-createNewPostRequest.validation = {
-  schema: v.object({
-    title: v.string().required().minLength(4),
-    content: v.string().required(),
-  }),
-};

package/templates/warlock/src/app/posts/controllers/get-all-posts.request.ts

@@ -1,17 +0,0 @@
-import {
-  type Request,
-  type RequestHandler,
-  type Response,
-} from "@warlock.js/core";
-import { Post } from "../models";
-
-export const getAllPostsRequest: RequestHandler = async (
-  request: Request,
-  response: Response,
-) => {
-  const posts = await Post.list();
-
-  return response.success({
-    posts,
-  });
-};

package/templates/warlock/src/app/posts/controllers/get-post.request.ts

@@ -1,37 +0,0 @@
-import {
-  v,
-  type Request,
-  type RequestHandler,
-  type Response,
-} from "@warlock.js/core";
-import { Post } from "../models";
-
-export const getPostRequest: RequestHandler = async (
-  request: Request,
-  response: Response,
-) => {
-  // 👇 look at the custom validation function
-  const post: Post = request.post;
-
-  return response.success({
-    post,
-  });
-};
-
-getPostRequest.validation = {
-  schema: v.object({
-    id: v.int().required(),
-  }),
-  validate: async (request: Request, response: Response) => {
-    const post = await Post.find(request.int("id"));
-
-    if (!post) {
-      return response.notFound({
-        error: "Post Not found",
-      });
-    }
-
-    // inject the post into the request object
-    request.post = post;
-  },
-};

package/templates/warlock/src/app/uploads/routes.ts

@@ -1,27 +0,0 @@
-import {
-  deleteFile,
-  getUploadedFile,
-  getUploadedFileUsingHash,
-  router,
-  uploadChunkedFiles,
-  uploadFiles,
-} from "@warlock.js/core";
-import { adminPath, guarded } from "app/utils/router";
-
-guarded(() => {
-  // Upload files
-  router.post(["/uploads", adminPath("/uploads")], uploadFiles);
-  // Upload chunked files
-  router.post(
-    ["/uploads/chunks", adminPath("/uploads/chunks")],
-    uploadChunkedFiles,
-  );
-  // Delete file by hash from the database
-  router.delete(["/uploads/:hash", adminPath("/uploads/:hash")], deleteFile);
-});
-
-// Please note that the uploaded files should not be grouped in protected middleware i.e guarded with JWT
-// Get uploaded file using the file path directly
-router.get("/uploads/*", getUploadedFile);
-// Get uploaded file using hash
-router.get("/uploads/:hash", getUploadedFileUsingHash);