Add docs from gofiber/fiber@aedffa1

Author: github-actions[bot]

docs/core/middleware/cache.md

@@ -6,6 +6,8 @@ id: cache
 
 Cache middleware for [Fiber](https://github.com/gofiber/fiber) that intercepts responses and stores the body, `Content-Type`, and status code under a key derived from the request path and method. Special thanks to [@codemicro](https://github.com/codemicro/fiber-cache) for contributing this middleware to Fiber core.
 
+By default, cached responses expire after five minutes and the middleware stores up to 1 MB of response bodies.
+
 Request directives
 
 - `Cache-Control: no-cache` returns the latest response while still caching it, so the status is always `miss`.
@@ -67,7 +69,7 @@ app.Use(cache.New(cache.Config{
         return fiber.Query[bool](c, "noCache")
     },
     Expiration: 30 * time.Minute,
-    CacheControl: true,
+    DisableCacheControl: true,
 }))
 ```
 
@@ -107,33 +109,33 @@ app.Use(cache.New(cache.Config{
 | Property             | Type                                           | Description                                                                                                                                                                                                                                                                                                    | Default                                                          |
 | :------------------- | :--------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------- |
 | Next                 | `func(fiber.Ctx) bool`                         | Next defines a function that is executed before creating the cache entry and can be used to execute the request without cache creation. If an entry already exists, it will be used. If you want to completely bypass the cache functionality in certain cases, you should use the [skip middleware](skip.md). | `nil`                                                            |
-| Expiration           | `time.Duration`                                | Expiration is the time that a cached response will live.                                                                                                                                                                                                                                                       | `1 * time.Minute`                                                |
+| Expiration           | `time.Duration`                                | Expiration is the time that a cached response will live. | `5 * time.Minute`                                                |
 | CacheHeader          | `string`                                       | CacheHeader is the header on the response header that indicates the cache status, with the possible return values "hit," "miss," or "unreachable."                                                                                                                                                             | `X-Cache`                                                        |
-| CacheControl         | `bool`                                         | CacheControl enables client-side caching if set to true.                                                                                                                                                                                                                                                       | `false`                                                          |
-| CacheInvalidator     | `func(fiber.Ctx) bool`                         | CacheInvalidator defines a function that is executed before checking the cache entry. It can be used to invalidate the existing cache manually by returning true.                                                                                                                                              | `nil`                                                            |
-| KeyGenerator         | `func(fiber.Ctx) string`                       | Key allows you to generate custom keys. The HTTP method is appended automatically.                                                                                                                                                                                                                                                                        | `func(c fiber.Ctx) string { return utils.CopyString(c.Path()) }` |
+| DisableCacheControl  | `bool`                                          | DisableCacheControl omits the `Cache-Control` header when set to `true`. | `false`                                                         |
+| CacheInvalidator     | `func(fiber.Ctx) bool`                         | CacheInvalidator defines a function that is executed before checking the cache entry. It can be used to invalidate the existing cache manually by returning true. | `nil`                                                            |
+| KeyGenerator         | `func(fiber.Ctx) string`                       | KeyGenerator allows you to generate custom keys. The HTTP method is appended automatically. | `func(c fiber.Ctx) string { return utils.CopyString(c.Path()) }` |
 | ExpirationGenerator  | `func(fiber.Ctx, *cache.Config) time.Duration` | ExpirationGenerator allows you to generate custom expiration keys based on the request.                                                                                                                                                                                                                        | `nil`                                                            |
 | Storage              | `fiber.Storage`                                | Storage is used to store the state of the middleware.                                                                                                                                                                                                                                                            | In-memory store                                                  |
 | StoreResponseHeaders | `bool`                                         | StoreResponseHeaders allows you to store additional headers generated by next middlewares & handler.                                                                                                                                                                                                           | `false`                                                          |
-| MaxBytes             | `uint`                                         | MaxBytes is the maximum number of bytes of response bodies simultaneously stored in cache.                                                                                                                                                                                                                     | `0` (No limit)                                                   |
+| MaxBytes             | `uint`                                         | MaxBytes is the maximum number of bytes of response bodies simultaneously stored in cache. | `1 * 1024 * 1024` (~1 MB)                                                  |
 | Methods              | `[]string`                                     | Methods specifies the HTTP methods to cache.                                                                                                                                                                                                                                                                   | `[]string{fiber.MethodGet, fiber.MethodHead}`                    |
 
 ## Default Config
 
 ```go
 var ConfigDefault = Config{
     Next:         nil,
-    Expiration:   1 * time.Minute,
+    Expiration:   5 * time.Minute,
     CacheHeader:  "X-Cache",
-    CacheControl: false,
+    DisableCacheControl: false,
     CacheInvalidator: nil,
     KeyGenerator: func(c fiber.Ctx) string {
         return utils.CopyString(c.Path())
     },
     ExpirationGenerator:  nil,
     StoreResponseHeaders: false,
     Storage:              nil,
-    MaxBytes:             0,
+    MaxBytes:             1 * 1024 * 1024,
     Methods: []string{fiber.MethodGet, fiber.MethodHead},
 }
 ```