@warlock.js/core 5.30.0 → 5.32.0

package/skills/model-factories/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: model-factories
+description: 'Deterministic model factories for tests and seeders — `defineFactory(Model, (seed) => attributes)` with `make()`, `makeMany(n)`, `create()`, `create(n)`, `createMany(n)`, named states via `.state()` / `.with()`, and a faker-free seed (`seed.text`, `seed.email`, `seed.uuid`, `seed.date`, `seed.number`, `seed.pick`). Triggers: `defineFactory`, `Factory`, `FactorySeed`, `resetFactorySequences`, `userFactory`; "test fixtures", "create test users", "factory states", "deterministic test data", "build a request body for a test". Typical import `import { defineFactory } from "@warlock.js/core/tests"`. Skip: seeding a real database for development — the `write-seeder` topic; fakes — the `test-fakes` topic.'
+---
+
+# Warlock — model factories
+
+A factory turns a sequence number into attributes. The n-th record a factory builds is the same on every run — no faker, no randomness — so snapshots and assertions stay stable.
+
+## Define one per model
+
+```ts title="src/app/users/tests/user.factory.ts"
+import { Model } from "@warlock.js/cascade";
+import { defineFactory } from "@warlock.js/core/tests";
+
+// Your model; in an app this is `import { User } from "app/users/models/user"`.
+type UserSchema = { name: string; email: string; password: string; emailVerifiedAt?: Date };
+
+export class User extends Model<UserSchema> {
+  public static table = "users";
+}
+
+export const userFactory = defineFactory(User, (seed) => ({
+  name: seed.text("User"), // "User 1", "User 2", ...
+  email: seed.email(), // "user1@example.test", ...
+  password: "test-password",
+}))
+  .state("unverified", () => ({ emailVerifiedAt: undefined }))
+  .state("named", (seed) => ({ name: `Named ${seed.sequence}` }));
+```
+
+Attributes are typed by the model's schema (`Partial` of it, as `Model.create()` takes). Keep factories next to the module's tests.
+
+## Use it
+
+```ts
+// with: import { expectJson, testPost } from "@warlock.js/core/tests";
+//       import { userFactory } from "./user.factory";
+it("registers a user from a factory-built body", async () => {
+  const body = userFactory.make({ email: "ada@example.test" }); // attributes only, no database
+
+  const response = await testPost("/auth/register", body);
+
+  expect((await expectJson<{ user: { email: string } }>(response, 201)).user.email).toBe(
+    "ada@example.test",
+  );
+});
+
+it("lists users", async () => {
+  await userFactory.create(3); // three saved users, in order
+  await userFactory.with("unverified", "named").create();
+});
+```
+
+| Call                        | Returns            | Database |
+| --------------------------- | ------------------ | -------- |
+| `make(overrides?)`          | attributes         | no       |
+| `makeMany(n, overrides?)`   | attributes[]       | no       |
+| `create(overrides?)`        | `Promise<Model>`   | yes      |
+| `create(n, overrides?)`     | `Promise<Model[]>` | yes      |
+| `createMany(n, overrides?)` | `Promise<Model[]>` | yes      |
+| `with(...states)`           | a derived factory  | —        |
+| `state(name, fn)`           | the same factory   | —        |
+| `resetSequence()`           | —                  | —        |
+
+`create()` goes through the model's own `create()`, so casts, defaults, hooks and events run exactly as in the app. Overrides are a partial or a function of the seed: `make((seed) => ({ name: `Custom ${seed.sequence}` }))`. States apply in order on top of the definition, then the overrides. A derived factory shares the base sequence.
+
+## The seed
+
+| Member               | Value                                                  |
+| -------------------- | ------------------------------------------------------ |
+| `sequence`           | 1 for the first record the factory builds, then 2, ... |
+| `index`              | position within the current `makeMany` / `createMany`  |
+| `text(prefix?)`      | `"<prefix> <sequence>"`                                |
+| `email(prefix?)`     | `"<prefix><sequence>@example.test"` (default `user`)   |
+| `uuid()`             | `00000000-0000-4000-8000-<sequence, 12 digits>`        |
+| `date(offsetDays?)`  | 2026-01-01T00:00:00Z plus `offsetDays` days            |
+| `number(min?, max?)` | an integer in `[min, max]`, cycling with the sequence  |
+| `pick(values)`       | one of `values`, cycling with the sequence             |
+
+`resetFactorySequences()` restarts every factory — call it in `beforeEach` when a test asserts exact values.
+
+## Gotchas
+
+- **Unique columns.** `seed.email()` is unique per factory sequence, not across test files; a database shared between files needs cleanup or `resetFactorySequences()` plus truncation, otherwise a second file collides on `user1@example.test`.
+- **`make()` never touches the database.** It returns attributes, not a model instance — use it for request bodies and pure-logic tests.
+- **An unknown state throws** and lists the defined ones.
+
+## See also
+
+- The `test-fakes` topic — fakes for mail, queue, cache, storage, clock and ids.
+- The `write-seeder` topic — seeding a development database.

package/skills/process-image/SKILL.md

@@ -37,16 +37,16 @@ Adds `sharp` to your dependencies. Skip it and the first `new Image(...)` throws
 ## Constructors
 
 ```ts
-new Image("./avatar.jpg")            // path
-new Image(buffer)                     // Buffer
-new Image(uint8Array)                 // Uint8Array
-new Image(arrayBuffer)                // ArrayBuffer
-new Image(existingSharpInstance)      // wrap a sharp.Sharp you already built
+new Image("./avatar.jpg"); // path
+new Image(buffer); // Buffer
+new Image(uint8Array); // Uint8Array
+new Image(arrayBuffer); // ArrayBuffer
+new Image(existingSharpInstance); // wrap a sharp.Sharp you already built
 
 // Or via static factories:
 Image.fromFile("./avatar.jpg");
 Image.fromBuffer(buffer);
-await Image.fromUrl("https://example.com/photo.jpg");   // @mongez/http under the hood
+await Image.fromUrl("https://example.com/photo.jpg"); // @mongez/http under the hood
 ```
 
 `Image.fromUrl(...)` is the only async factory — it fetches the URL via `@mongez/http` (`responseType: "arrayBuffer"`), then wraps the bytes. The rest are synchronous.
@@ -55,25 +55,25 @@ await Image.fromUrl("https://example.com/photo.jpg");   // @mongez/http under th
 
 Every method returns `this` so calls chain. Transforms are descriptors; nothing runs until the output method.
 
-| Method                                       | Effect                                                                       |
-| -------------------------------------------- | ---------------------------------------------------------------------------- |
-| `.resize({ width?, height?, fit?, ... })`    | sharp resize — accepts the full `sharp.ResizeOptions` shape                  |
-| `.crop({ left, top, width, height })`        | extract a region                                                             |
-| `.rotate(deg)`                               | clockwise rotation                                                           |
-| `.flip()`                                    | mirror vertically (top↔bottom)                                               |
-| `.flop()`                                    | mirror horizontally (left↔right)                                             |
-| `.blur(sigma)`                               | gaussian blur (sigma is required, must be ≥ 0.3 — throws otherwise)          |
-| `.sharpen(options?)`                         | sharp's sharpen                                                              |
-| `.grayscale()` / `.blackAndWhite()`          | grayscale (aliases)                                                          |
-| `.tint(color)`                               | color tint                                                                   |
-| `.negate(options?)`                          | invert colors                                                                |
-| `.opacity(value)`                            | 0–100, applied via composite                                                 |
-| `.trim(options?)`                            | trim borders                                                                 |
-| `.watermark(image, options?)`                | overlay one watermark — two positional args (`image` accepts the same inputs as the constructor, plus another `Image`; `options` is `sharp.OverlayOptions`) |
-| `.watermarks([{ image, options }, ...])`     | overlay many — one `WatermarkConfig` object (`{ image, options }`) per entry  |
-| `.format(format)`                            | output format — `"jpeg"`, `"png"`, `"webp"`, `"avif"`, `"tiff"`, `"heif"`, ... |
-| `.quality(1–100)`                            | lossy formats only (`jpeg` / `webp` / `avif` / `tiff` / `heif`); ignored otherwise |
-| `.apply(options)`                            | apply many transforms in one call, in a fixed canonical order                |
+| Method                                    | Effect                                                                                                                                                      |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `.resize({ width?, height?, fit?, ... })` | sharp resize — accepts the full `sharp.ResizeOptions` shape                                                                                                 |
+| `.crop({ left, top, width, height })`     | extract a region                                                                                                                                            |
+| `.rotate(deg)`                            | clockwise rotation                                                                                                                                          |
+| `.flip()`                                 | mirror vertically (top↔bottom)                                                                                                                              |
+| `.flop()`                                 | mirror horizontally (left↔right)                                                                                                                            |
+| `.blur(sigma)`                            | gaussian blur (sigma is required, must be ≥ 0.3 — throws otherwise)                                                                                         |
+| `.sharpen(options?)`                      | sharp's sharpen                                                                                                                                             |
+| `.grayscale()` / `.blackAndWhite()`       | grayscale (aliases)                                                                                                                                         |
+| `.tint(color)`                            | color tint                                                                                                                                                  |
+| `.negate(options?)`                       | invert colors                                                                                                                                               |
+| `.opacity(value)`                         | 0–100, applied via composite                                                                                                                                |
+| `.trim(options?)`                         | trim borders                                                                                                                                                |
+| `.watermark(image, options?)`             | overlay one watermark — two positional args (`image` accepts the same inputs as the constructor, plus another `Image`; `options` is `sharp.OverlayOptions`) |
+| `.watermarks([{ image, options }, ...])`  | overlay many — one `WatermarkConfig` object (`{ image, options }`) per entry                                                                                |
+| `.format(format)`                         | output format — `"jpeg"`, `"png"`, `"webp"`, `"avif"`, `"tiff"`, `"heif"`, ...                                                                              |
+| `.quality(1–100)`                         | lossy formats only (`jpeg` / `webp` / `avif` / `tiff` / `heif`); ignored otherwise                                                                          |
+| `.apply(options)`                         | apply many transforms in one call, in a fixed canonical order                                                                                               |
 
 `apply(options)` accepts an `ImageTransformOptions` object — every transform above as a key. Useful when transforms come from config or a request payload.
 
@@ -82,10 +82,10 @@ Every method returns `this` so calls chain. Transforms are descriptors; nothing
 Each of these fires the pipeline exactly once and returns the result. Subsequent calls run the pipeline again (operations aren't memoised).
 
 ```ts
-await image.save("./output.webp");          // write to disk; returns the absolute path
-const buffer = await image.toBuffer();      // → Buffer
-const base64 = await image.toBase64();      // → "iVBORw0KGgo..."
-const dataUrl = await image.toDataUrl();    // → "data:image/webp;base64,..."
+await image.save("./output.webp"); // write to disk; returns the absolute path
+const buffer = await image.toBuffer(); // → Buffer
+const base64 = await image.toBase64(); // → "iVBORw0KGgo..."
+const dataUrl = await image.toDataUrl(); // → "data:image/webp;base64,..."
 ```
 
 ## Common patterns
@@ -93,7 +93,9 @@ const dataUrl = await image.toDataUrl();    // → "data:image/webp;base64,..."
 ### Resize an uploaded avatar to two sizes
 
 ```ts
-import { Image } from "@warlock.js/core";
+import { Image, type UploadedFile } from "@warlock.js/core";
+
+declare const uploadedAvatar: UploadedFile; // e.g. request.validated().avatar
 
 const buffer = await uploadedAvatar.buffer();
 

package/skills/register-route/SKILL.md

@@ -90,9 +90,9 @@ Projects with `@warlock.js/auth` usually define a `guarded(...)` helper in `src/
 import { guarded } from "app/shared/utils/router";
 
 router.prefix("/products", () => {
-  router.get("/", listProductsController);             // public
+  router.get("/", listProductsController); // public
   guarded(() => {
-    router.post("/", createProductController);          // requires logged-in user
+    router.post("/", createProductController); // requires logged-in user
     router.delete("/:id", removeProductController);
   });
 });
@@ -100,17 +100,27 @@ router.prefix("/products", () => {
 
 If `guarded` doesn't exist in your project yet, see the shared utility convention in the `warlock-conventions` topic.
 
+### A mutating route with no guard — say so with `public: true`
+
+```ts
+// src/app/contact/routes.ts
+router.post("/api/contact", contactController, { public: true });
+```
+
+`public: true` changes nothing at runtime; it records that the missing guard is deliberate, so reviewers, `warlock check` and route tooling can tell a decision from an omission. `warlock make endpoint --public` writes it (the `make-endpoint` topic).
+
 ## RESTful resource chain
 
 For a standard CRUD resource, `router.route(path)` returns a builder with five named slots:
 
 ```ts
-router.route("/products")
-  .list(listProductsController)        // GET    /products
-  .show(getProductController)          // GET    /products/:id
-  .create(createProductController)     // POST   /products
-  .update(updateProductController)     // PUT    /products/:id
-  .destroy(removeProductController);   // DELETE /products/:id
+router
+  .route("/products")
+  .list(listProductsController) // GET    /products
+  .show(getProductController) // GET    /products/:id
+  .create(createProductController) // POST   /products
+  .update(updateProductController) // PUT    /products/:id
+  .destroy(removeProductController); // DELETE /products/:id
 ```
 
 Each method returns the builder so you can chain. Methods you don't call don't register. Pair with `guarded`/`group` the same way as plain routes.
@@ -143,8 +153,8 @@ guarded(() => {
 
 ```ts
 router.prefix("/auth", () => {
-  router.post("/login", loginController);
-  router.post("/register", registerController);
+  router.post("/login", loginController, { public: true });
+  router.post("/register", registerController, { public: true });
   guarded(() => {
     router.post("/logout", logoutController);
     router.get("/me", meController);
@@ -152,6 +162,41 @@ router.prefix("/auth", () => {
 });
 ```
 
+### Mutating routes: guard them or say `public: true`
+
+Every POST/PUT/PATCH/DELETE route either runs auth middleware (on the route, its
+builder, or an enclosing group such as `guarded()`) or is marked `public: true`.
+`warlock dev` warns once per route about mutating routes with neither, and
+`warlock check` reports the same from source as `WL9006` before the app runs.
+The check reads source, not runtime markers: a guard counts when its name
+contains `auth` or `guard`, or when it is a constant initialised with
+`markAuthGuard()` in the same file. A differently-named guard imported from
+another file needs a `// warlock-check-ignore WL9006` comment on its route.
+
+```ts
+import { markAuthGuard, router, type Middleware, type RequestHandler } from "@warlock.js/core";
+
+const stripeWebhookController: RequestHandler = async ({ response }) =>
+  response.success({ received: true });
+const importController: RequestHandler = async ({ response }) => response.success({ queued: true });
+
+// Open on purpose: a webhook signed by the provider.
+router.group({ prefix: "/webhooks", public: true }, () => {
+  router.post("/stripe", stripeWebhookController);
+});
+
+// A hand-written guard whose name has no "auth"/"guard" in it.
+const requireApiKey: Middleware = markAuthGuard(async ({ request, response }) => {
+  if (request.headers["x-api-key"] !== process.env.API_KEY) return response.unauthorized();
+});
+
+router.post("/imports", importController, { middleware: [requireApiKey] });
+```
+
+`public` changes nothing at runtime. `authMiddleware()` marks itself (its
+`{ optional: true }` form does not count). Silence the warning app-wide with
+`http.warnUnguardedRoutes: false`; page routes are never reported.
+
 ### Multiple paths on one handler
 
 ```ts
@@ -168,6 +213,60 @@ router.post("/accounts/credentials", accountsController.store, {
 
 Request log entries otherwise include the body as received (before validation), so rejected fields would be logged too.
 
+## Static directories and public files
+
+```ts
+router.directory({ root: Application.publicPath, prefix: "/assets/" });
+```
+
+Static routes are queued at scan time after HTTP plugin hooks. `@fastify/static` itself loads only on
+the first static file request, even with an existing public folder; concurrent
+first requests share initialization. The upstream sender retains ranges, caching,
+listings, precompressed files, `allowedPath` and `setHeaders` behavior. The
+`setHeaders` callback receives the real Fastify reply.
+
+`wildcard: false` still enumerates exact file routes at boot, so files added later
+follow the application's ordinary fallback until restart. The directory globber
+loads at boot only for this option; the upstream sender enumerates those roots
+again on the first request, which can be noticeable for large directories. The public folder uses
+`storage.publicRoot` (default `public/`) and `storage.publicPrefix` (default
+`/public/`); `false` disables it and missing folders add no routes. Its
+`reply.sendFile`/`reply.download` decorators are lazy too. `router.directory`
+keeps `decorateReply: false` for additional mounts. Initialization failures reach
+the application's normal error handler.
+
+Global rate limits apply to application routes and web page routes in
+production and development. Defaults are 60 requests/minute per IP in one shared
+bucket across routes and pages. Behind a reverse proxy, configure trusted
+`http.trustProxy` addresses or a suitable `http.rateLimit.keyGenerator`, and
+review `max` before upgrading. `http.rateLimit.global: false` disables blanket
+quotas while retaining explicit route limits. Built-in health/readiness probes
+are exempt unless `http.health.rateLimit: true` opts them into the global policy.
+
+Static files are exempt from the global limiter by default: the public folder,
+every `router.directory()` mount and `router.file()` / `cachedFile()` / `files()` /
+`cachedFiles()` routes (and the web build's assets). `http.rateLimit.staticFiles:
+true` counts them all; a mount can decide for itself:
+
+```ts
+import { rootPath, router } from "@warlock.js/core";
+
+router.directory({ root: rootPath("storage/exports"), prefix: "/exports/" }, { rateLimit: true });
+router.directory(
+  { root: rootPath("storage/reports"), prefix: "/reports/" },
+  { rateLimit: { max: 20, timeWindow: 60_000 } },
+);
+router.file("/price-list.pdf", rootPath("storage/price-list.pdf"), 300, { rateLimit: true });
+```
+
+Exempt one application route with `rateLimit: false` (or
+`serverOptions: { config: { rateLimit: false } }`); development's wildcard
+dispatcher honours both exactly as production does:
+
+```ts
+router.get("/webhooks/status", webhookStatusController, { rateLimit: false });
+```
+
 ## Gotchas
 
 - **Never import `routes.ts`.** The framework auto-loads it. Importing causes a double-registration error.

package/skills/report-framework-issue.md

@@ -0,0 +1,154 @@
+# Report a Warlock.js framework issue
+
+Use this topic when behavior contradicts the installed version's docs or skills,
+a crash originates inside `@warlock.js/*`, or a needed framework capability is
+missing. Framework reports belong at <https://github.com/warlockjs/framework>.
+
+## Confirm and search first
+
+1. Reduce the problem to a minimal reproduction in a clean, generic app. Isolate
+   application logic, third-party packages and configuration mistakes; a stack
+   frame in the framework alone does not prove a framework bug.
+2. Read the **installed version's** package `CHANGELOG.md` and skills. Confirm
+   that the documented API exists in that version and check whether a later
+   release already addresses it. For a feature, describe the missing capability
+   and why the documented APIs or an app-level workaround are insufficient.
+3. Run `warlock doctor --json` (see `warlock-doctor.md`). Fix app/environment
+   findings first. If boot fails, retain only the sanitized failure; `warlock
+   issue` itself does not boot the app.
+4. Search existing reports, including closed issues, using distinctive public
+   terms. If a matching issue exists, show its link and help draft a useful
+   follow-up instead of opening a duplicate. Ask before posting that follow-up.
+
+```bash
+gh issue list -R warlockjs/framework --state all --search "public error or capability"
+```
+
+Without GitHub CLI, use
+<https://github.com/warlockjs/framework/issues?q=is%3Aissue> and enter those terms.
+
+## Collect and protect
+
+```bash
+warlock issue --type bug --title "Public description of the failure"
+warlock issue --type feature --title "Public description of the capability" --json
+```
+
+Collect affected package names and **installed versions**, Node and package
+manager versions, OS/architecture, TypeScript version, the reviewed `warlock
+issue` environment output, a minimal reproduction with exact steps, expected
+versus actual behavior, and relevant sanitized logs / `warlock doctor --json`
+output. If a tool cannot run or there are no relevant logs, explain why.
+
+**Never paste secrets, tokens, `.env` contents, customer data, proprietary code or
+private app names** into titles, bodies, logs, screenshots, repro repositories,
+search queries or URLs. Replace the original app with a minimal generic repro.
+Review even generated environment output and stack traces; remove local paths,
+hostnames and identifying details. The command reads installed package metadata
+and a static config summary; it never reads `.env` or executes the app/config.
+Do not attach the app's full config or diagnostic report without sanitizing it.
+
+## Draft and get consent
+
+Choose one template below, replace every prompt with concrete evidence, and
+write the sanitized body to a local UTF-8 file such as `framework-issue.md`.
+**Always show the complete drafted title and body to the user and explicitly ask
+before filing.** Generating a draft or URL is not consent to publish. If the user
+requests edits, show the revised draft and obtain approval for that version.
+
+### Bug body
+
+```markdown
+### Summary
+
+Public description of the framework failure and affected packages.
+
+### Environment / warlock issue output
+
+Reviewed environment output: installed @warlock.js package versions, Node,
+package manager + version, OS/arch, TypeScript, static config summary.
+
+### Minimal reproduction
+
+Public minimal code or repro link, setup commands and exact steps.
+
+### Expected behavior
+
+What should happen, with the installed version's docs/skills reference.
+
+### Actual / current behavior
+
+What happens instead, including the error and impact.
+
+### Sanitized logs / doctor output
+
+Relevant logs and warlock doctor --json, or why unavailable / not applicable.
+
+### Checks
+
+- [ ] Searched existing issues and checked installed-version CHANGELOG and skills.
+- [ ] Removed secrets, tokens, .env, customer data, proprietary code and private app names.
+- [ ] User reviewed this complete draft and approved filing.
+```
+
+### Feature request body
+
+```markdown
+### Problem / use case
+
+Public description of the missing framework capability and affected packages.
+
+### Environment / warlock issue output
+
+Reviewed environment output: installed @warlock.js package versions, Node,
+package manager + version, OS/arch, TypeScript, static config summary.
+
+### Minimal reproduction
+
+Minimal public example of the capability that cannot currently be expressed.
+
+### Proposed behavior
+
+Desired API/behavior, with an example and why it belongs in the framework.
+
+### Actual / current behavior
+
+Current limitation and relevant installed-version docs/skills.
+
+### Alternatives considered
+
+Existing APIs, app-level workarounds and their limitations.
+
+### Sanitized logs / doctor output
+
+Relevant logs and warlock doctor --json, or why unavailable / not applicable.
+
+### Checks
+
+- [ ] Searched existing issues and checked installed-version CHANGELOG and skills.
+- [ ] Removed secrets, tokens, .env, customer data, proprietary code and private app names.
+- [ ] User reviewed this complete draft and approved filing.
+```
+
+Only check a box after completing that step, including obtaining consent.
+
+## File the approved draft
+
+Check `gh --version` and `gh auth status --hostname github.com`. If GitHub CLI is
+available and authenticated, **after approval** run:
+
+```bash
+gh issue create -R warlockjs/framework --title "Approved public title" --body-file framework-issue.md
+```
+
+Return the created issue's link. If GitHub CLI is unavailable or unauthenticated,
+give the user the pre-filled new-issue URL printed by `warlock issue` together
+with the approved body. The URL selects `bug.yml` or `feature.yml` and prefills
+the environment field; the user must complete the remaining form fields. URLs
+are capped at 7,500 characters and may include a truncation note: restore the
+remaining reviewed output manually. Never claim the issue was filed from merely
+printing or opening a URL. `warlock issue` never sends anything itself.
+
+GitHub CLI flags: [list](https://cli.github.com/manual/gh_issue_list),
+[create](https://cli.github.com/manual/gh_issue_create),
+[authentication](https://cli.github.com/manual/gh_auth_status).

package/skills/request-memo/SKILL.md

@@ -12,7 +12,7 @@ description: 'Memoize async work for one HTTP request with `requestMemo<T>(key,
 From `core/src/http/context/request-memo.ts`:
 
 ```ts
-export function requestMemo<T>(key: string, fn: () => Promise<T>): Promise<T>
+export function requestMemo<T>(key: string, fn: () => Promise<T>): Promise<T>;
 ```
 
 Import it from the package root:

package/skills/request-tracing/SKILL.md

@@ -181,11 +181,12 @@ own extra guard — the check is already there.
 
 ```ts
 // src/config/http.ts
+import { env, type HttpConfigurations } from "@warlock.js/core";
 import { log } from "@warlock.js/logger";
 
 const SLOW_MS = 200;
 
-export default {
+const httpConfig: HttpConfigurations = {
   tracing: {
     enabled: env("TRACING_ENABLED") === "true",
     hooks: [
@@ -206,6 +207,8 @@ export default {
     ],
   },
 };
+
+export default httpConfig;
 ```
 
 ## Gotchas