create-warlock 5.34.2 → 5.35.0

package/templates/warlock/src/app/shared/utils/format-http-error-response.ts

@@ -0,0 +1,53 @@
+import type { HttpErrorResponseContext } from "@warlock.js/core";
+
+const statusCodes: Record<number, string> = {
+  400: "badRequest",
+  401: "unauthorized",
+  403: "forbidden",
+  404: "notFound",
+  409: "conflict",
+  422: "validationFailed",
+  429: "tooManyRequests",
+};
+
+/** Convert framework JSON errors to the project's public error contract. */
+export function formatHttpErrorResponse({
+  status,
+  body,
+  requestId,
+  appError,
+}: HttpErrorResponseContext) {
+  if (appError) {
+    return {
+      error: { code: appError.code, message: appError.publicMessage },
+      ...(appError.details === undefined ? {} : { details: appError.details }),
+      requestId,
+    };
+  }
+  const source = isRecord(body) ? body : {};
+  const error = isRecord(source.error) ? source.error : {};
+  const serverFault = status >= 500;
+  const code = serverFault
+    ? "serverError"
+    : (text(error.code) ?? text(source.errorCode) ?? statusCodes[status] ?? "requestFailed");
+  const message = serverFault
+    ? "Internal server error."
+    : (text(error.message) ?? text(source.message) ?? text(source.error) ?? "Request failed.");
+  // Only deliberately public details belong here. Never include a 5xx payload
+  // or the development-only stack attached by the framework error funnel.
+  const details = serverFault ? undefined : (source.details ?? source.errors ?? source.payload);
+
+  return {
+    error: { code, message },
+    ...(details === undefined ? {} : { details }),
+    requestId,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/templates/warlock/src/app/users/commands/hello-world.command.ts

@@ -1,8 +1,9 @@
 import { command } from "@warlock.js/core";
+import { log } from "@warlock.js/logger";
 
 export default command({
   name: "hello.world",
   action: () => {
-    console.log("Hello World Guys!");
+    log.info("users", "hello.world", "Hello World!");
   },
 });

package/templates/warlock/src/app/users/controllers/create-new-user.controller.ts

@@ -1,4 +1,5 @@
 import { type GuardedRequestHandler } from "app/auth/requests/guarded.request";
+import { UserResource } from "app/users/resources/user.resource";
 import { User } from "../models/user";
 import { createUserSchema, type CreateUserSchema } from "../schema/create-user.schema";
 
@@ -6,7 +7,11 @@ export const createNewUserController: GuardedRequestHandler<CreateUserSchema> =
   request,
   response,
 }) => {
-  const file = request.file("image")!;
+  const file = request.file("image");
+
+  if (!file) {
+    return response.badRequest({ error: { code: "imageRequired", message: "Image is required." } });
+  }
 
   const output = await file.save("images");
 
@@ -25,3 +30,10 @@ export const createNewUserController: GuardedRequestHandler<CreateUserSchema> =
 createNewUserController.validation = {
   schema: createUserSchema,
 };
+
+createNewUserController.responseSchema = {
+  201: { body: { message: "string", user: UserResource } },
+  422: { body: { error: { code: "string", message: "string" }, requestId: "string" } },
+  500: { body: { error: { code: "string", message: "string" }, requestId: "string" } },
+  400: { body: { error: { code: "string", message: "string" }, requestId: "string" } },
+};

package/templates/warlock/src/app/users/controllers/list-users.controller.ts

@@ -1,4 +1,5 @@
 import { type GuardedRequestHandler } from "app/auth/requests/guarded.request";
+import { UserResource } from "app/users/resources/user.resource";
 import { usersRepository } from "../repositories/users.repository";
 import { listUsersSchema, type ListUsersSchema } from "../schema/list-users.schema";
 
@@ -6,10 +7,15 @@ export const listUsersController: GuardedRequestHandler<ListUsersSchema> = async
   request,
   response,
 }) => {
-  const users = await usersRepository.listCached(request.validated());
+  const { id, ...filters } = request.validated();
+  const { data: users, pagination } = await usersRepository.listCached({
+    ...filters,
+    publicId: id,
+  });
 
   return response.success({
     users,
+    pagination,
   });
 };
 
@@ -18,3 +24,20 @@ listUsersController.description = "List Users Controller";
 listUsersController.validation = {
   schema: listUsersSchema,
 };
+
+listUsersController.responseSchema = {
+  200: {
+    body: {
+      users: [UserResource],
+      pagination: {
+        limit: "number",
+        result: "number",
+        page: "number",
+        total: "number",
+        pages: "number",
+      },
+    },
+  },
+  422: { body: { error: { code: "string", message: "string" }, requestId: "string" } },
+  500: { body: { error: { code: "string", message: "string" }, requestId: "string" } },
+};

package/templates/warlock/src/app/users/models/user/migrations/11-12-2025_23-58-03-user.migration.ts

@@ -2,6 +2,7 @@ import { json, Migration, string, timestamp } from "@warlock.js/cascade";
 import { User } from "../user.model";
 
 export default Migration.create(User, {
+  publicId: string(36).unique(),
   name: string(255),
   email: string(255).unique(),
   password: string(255),

package/templates/warlock/src/app/users/models/user/user.model.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { Auth } from "@warlock.js/auth";
 import { RegisterModel } from "@warlock.js/cascade";
 import { useHashedPassword } from "@warlock.js/core";
@@ -5,6 +6,10 @@ import { v, type Infer } from "@warlock.js/seal";
 import { UserResource } from "app/users/resources/user.resource";
 
 export const userSchema = v.object({
+  publicId: v
+    .string()
+    .uuid()
+    .default(() => randomUUID()),
   name: v.string(),
   email: v.email().requiredIfEmpty("id"),
   // Required at the controller layer (`create-user.schema.ts`) on

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

@@ -5,7 +5,7 @@ import { User } from "../models/user";
 export type UserFilter = {
   email?: string;
   name?: string;
-  id?: string;
+  publicId?: string;
 };
 
 export type UsersListOptions = RepositoryOptions & UserFilter;
@@ -14,7 +14,7 @@ class UsersRepository extends RepositoryManager<User, UserFilter> {
   public source = User;
 
   public filterBy: FilterRules = {
-    id: "=",
+    publicId: "=",
     name: "like",
     email: "=",
   };

package/templates/warlock/src/app/users/resources/user.resource.ts

@@ -2,7 +2,7 @@ import { defineResource } from "@warlock.js/core";
 
 export const UserResource = defineResource({
   schema: {
-    id: "number",
+    id: ["publicId", "string"],
     name: "string",
     email: "string",
     image: "storageUrl",

package/templates/warlock/src/app/users/schema/list-users.schema.ts

@@ -5,7 +5,7 @@ import { v, type Infer } from "@warlock.js/seal";
  * smuggled operator (`?email[$ne]=`) never reaches the repository filters.
  */
 export const listUsersSchema = v.object({
-  id: v.string().optional(),
+  id: v.string().uuid().optional(),
   name: v.string().max(100).optional(),
   email: v.string().max(255).optional(),
   page: v.numeric().min(1).optional(),

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

@@ -1,10 +1,16 @@
 import type { HttpConfigurations } from "@warlock.js/core";
 import { env } from "@warlock.js/core";
+import { formatHttpErrorResponse } from "../app/shared/utils/format-http-error-response";
 
 const httpConfigurations: HttpConfigurations = {
   port: env("HTTP_PORT", 3000),
   host: env("HTTP_HOST", "localhost"),
   log: true,
+  // errorMapper classifies thrown non-HttpErrors; it cannot shape returned
+  // validation, not-found, or rate-limit responses. Format all JSON errors at
+  // the transport boundary, including Fastify's early rejections.
+  errorMapper: () => ({ status: 500 }),
+  errorResponse: formatHttpErrorResponse,
   fileUploadLimit: 12 * 1024 * 1024 * 1024,
   rateLimit: {
     max: 260,

package/templates/warlock/src/web/home/components/contact-field.tsx

@@ -0,0 +1,18 @@
+import { useContactField } from "../hooks/use-contact-field";
+import type { ContactFieldProps } from "../types/contact-controls.type";
+
+export default function ContactField({ label, multiline, rows, ...props }: ContactFieldProps) {
+  const { error, getErrorProps, inputProps, id } = useContactField(props, rows);
+
+  return (
+    <label htmlFor={id}>
+      <span>{label}</span>
+      {multiline ? <textarea {...inputProps} /> : <input {...inputProps} />}
+      {error ? (
+        <small className="warlock-field-error" {...getErrorProps()}>
+          {error}
+        </small>
+      ) : null}
+    </label>
+  );
+}

package/templates/warlock/src/web/home/components/contact-section.tsx

@@ -1,38 +1,14 @@
 import { Form } from "@mongez/react-form";
-import { changeLocaleCode, useLocale, useTextDirection, useTrans } from "@warlock.js/web";
-import { useState } from "react";
 import { contactSchema } from "../../../shared/contact.schema";
 import { useContactForm } from "../hooks/use-contact-form";
-import { ContactField, ContactSubmitButton } from "./contact-form-controls";
+import { useContactLocale } from "../hooks/use-contact-locale";
+import ContactField from "./contact-field";
+import ContactSubmitButton from "./contact-submit-button";
 
-export function ContactSection() {
+export default function ContactSection() {
   const { status: contactStatus, submitContact } = useContactForm();
-  const locale = useLocale();
-  const direction = useTextDirection();
-  const translate = useTrans();
-  const [isSwitchingLocale, setIsSwitchingLocale] = useState(false);
-  const [localeError, setLocaleError] = useState("");
+  const { direction, translate, isSwitchingLocale, localeError, toggleLocale } = useContactLocale();
 
-  /**
-   * Switch locale via the framework's `changeLocaleCode` — no reload, no
-   * manual cookie write. The control is disabled while the request is in
-   * flight, and a rejection leaves the current locale in place while
-   * surfacing an error instead of throwing.
-   */
-  async function toggleLocale() {
-    const nextLocale = locale === "en" ? "ar" : "en";
-
-    setIsSwitchingLocale(true);
-    setLocaleError("");
-
-    try {
-      await changeLocaleCode(nextLocale);
-    } catch (error) {
-      setLocaleError(error instanceof Error ? error.message : "Could not update the locale.");
-    } finally {
-      setIsSwitchingLocale(false);
-    }
-  }
   return (
     <section className="warlock-section warlock-contact" id="contact" dir={direction}>
       <div className="warlock-contact-copy">

package/templates/warlock/src/web/home/components/contact-submit-button.tsx

@@ -0,0 +1,16 @@
+import { useContactSubmitButton } from "../hooks/use-contact-submit-button";
+import type { ContactSubmitButtonProps } from "../types/contact-controls.type";
+
+export default function ContactSubmitButton({
+  idleLabel,
+  submittingLabel,
+}: ContactSubmitButtonProps) {
+  const { disabled, isSubmitting } = useContactSubmitButton();
+
+  return (
+    <button className="warlock-contact-submit" type="submit" disabled={disabled}>
+      {isSubmitting ? submittingLabel : idleLabel}
+      <span aria-hidden="true">→</span>
+    </button>
+  );
+}

package/templates/warlock/src/web/home/hooks/use-contact-field.ts

@@ -0,0 +1,9 @@
+import { useFormControl, type FormControlProps } from "@mongez/react-form";
+
+/** Keep control identity, validation and DOM wiring in one hook. */
+export function useContactField(props: FormControlProps, rows?: number) {
+  const { error, getErrorProps, getInputProps, id } = useFormControl(props);
+  const inputProps = getInputProps(rows ? { rows } : undefined);
+
+  return { error, getErrorProps, id, inputProps };
+}

package/templates/warlock/src/web/home/hooks/use-contact-form.ts

@@ -7,15 +7,12 @@ type ContactValues = InferFormValues<typeof contactSchema>;
 
 type ContactResponse = {
   message: string;
-  received: {
-    email: string;
-    characters: number;
-  };
 };
 
 type ContactErrorBody = {
-  message?: string;
-  errors?: unknown;
+  error?: { code: string; message: string };
+  details?: unknown;
+  requestId?: string;
 };
 
 type ContactStatus = {
@@ -44,12 +41,12 @@ export function useContactForm() {
 
       if (!response.ok) {
         if (response.status === 422) {
-          setFormErrors({ body }, form);
+          setFormErrors({ body: { errors: body.details } }, form);
         }
 
         setStatus({
           state: "error",
-          message: body.message || "The request was not accepted.",
+          message: body.error?.message || "The request was not accepted.",
         });
         return;
       }

package/templates/warlock/src/web/home/hooks/use-contact-locale.ts

@@ -0,0 +1,34 @@
+import { changeLocaleCode, useLocale, useTextDirection, useTrans } from "@warlock.js/web";
+import { useState } from "react";
+
+/** Own the contact section's locale switch and recoverable error state. */
+export function useContactLocale() {
+  const locale = useLocale();
+  const direction = useTextDirection();
+  const translate = useTrans();
+  const [isSwitchingLocale, setIsSwitchingLocale] = useState(false);
+  const [localeError, setLocaleError] = useState("");
+
+  /**
+   * Switch locale via the framework's `changeLocaleCode` — no reload, no
+   * manual cookie write. The control is disabled while the request is in
+   * flight, and a rejection leaves the current locale in place while
+   * surfacing an error instead of throwing.
+   */
+  async function toggleLocale() {
+    const nextLocale = locale === "en" ? "ar" : "en";
+
+    setIsSwitchingLocale(true);
+    setLocaleError("");
+
+    try {
+      await changeLocaleCode(nextLocale);
+    } catch (error) {
+      setLocaleError(error instanceof Error ? error.message : "Could not update the locale.");
+    } finally {
+      setIsSwitchingLocale(false);
+    }
+  }
+
+  return { direction, translate, isSwitchingLocale, localeError, toggleLocale };
+}

package/templates/warlock/src/web/home/hooks/use-contact-submit-button.ts

@@ -0,0 +1,6 @@
+import { useSubmitButton } from "@mongez/react-form";
+
+/** Read submission state from the owning Mongez form. */
+export function useContactSubmitButton() {
+  return useSubmitButton();
+}

package/templates/warlock/src/web/home/index.page.tsx

@@ -1,5 +1,5 @@
 import type { PageProps } from "@warlock.js/web";
-import { ContactSection } from "./components/contact-section";
+import ContactSection from "./components/contact-section";
 import { ContentSections } from "./components/content-sections";
 import { HeroSection } from "./components/hero-section";
 import { HomeFooter } from "./components/home-footer";

package/templates/warlock/src/web/home/types/contact-controls.type.ts

@@ -0,0 +1,13 @@
+import type { FormControlProps } from "@mongez/react-form";
+import type { ReactNode } from "react";
+
+export type ContactFieldProps = FormControlProps & {
+  label: ReactNode;
+  multiline?: boolean;
+  rows?: number;
+};
+
+export type ContactSubmitButtonProps = {
+  idleLabel: ReactNode;
+  submittingLabel: ReactNode;
+};

package/templates/warlock/src/web/shared/utils/set-form-errors.ts

@@ -31,7 +31,9 @@ export function setFormErrors(
 
     if (Array.isArray(errors)) {
       for (const issue of errors) {
-        if (!isRecord(issue)) continue;
+        if (!isRecord(issue)) {
+          continue;
+        }
 
         const input = issue[inputKey];
         const message = issue[errorKey];

package/templates/warlock/warlock.config.ts

@@ -6,6 +6,7 @@ import {
 import { defineConfig } from "@warlock.js/core";
 
 export default defineConfig({
+  build: { budgets: { page: { js: "150kb", css: "50kb" }, mode: "error" } },
   cli: {
     commands: [registerJWTSecretGeneratorCommand(), registerAuthCleanupCommand()],
   },

package/templates/warlock/src/web/home/components/contact-form-controls.tsx

@@ -1,42 +0,0 @@
-import { useFormControl, useSubmitButton, type FormControlProps } from "@mongez/react-form";
-import { type ReactNode } from "react";
-
-type ContactFieldProps = FormControlProps & {
-  label: ReactNode;
-  multiline?: boolean;
-  rows?: number;
-};
-
-export function ContactField({ label, multiline, rows, ...props }: ContactFieldProps) {
-  const { error, getErrorProps, getInputProps, id } = useFormControl(props);
-  const inputProps = getInputProps(rows ? { rows } : undefined);
-
-  return (
-    <label htmlFor={id}>
-      <span>{label}</span>
-      {multiline ? <textarea {...inputProps} /> : <input {...inputProps} />}
-      {error ? (
-        <small className="warlock-field-error" {...getErrorProps()}>
-          {error}
-        </small>
-      ) : null}
-    </label>
-  );
-}
-
-export function ContactSubmitButton({
-  idleLabel,
-  submittingLabel,
-}: {
-  idleLabel: ReactNode;
-  submittingLabel: ReactNode;
-}) {
-  const { disabled, isSubmitting } = useSubmitButton();
-
-  return (
-    <button className="warlock-contact-submit" type="submit" disabled={disabled}>
-      {isSubmitting ? submittingLabel : idleLabel}
-      <span aria-hidden="true">→</span>
-    </button>
-  );
-}