New() — fiber Function Reference

Architecture documentation for the New() function in idempotency.go from the fiber codebase.

Function go FiberCore Adapters

Entity Profile

FiberCore→ Adapters→ New() — fiber Function Reference

Dependency Diagram

graph TD
  df2e93b5_a489_dbc5_46e6_10b8272183fb["New()"]
  315a9fa0_19cb_7602_60d2_16dbe20cf673["idempotency.go"]
  df2e93b5_a489_dbc5_46e6_10b8272183fb -->|defined in| 315a9fa0_19cb_7602_60d2_16dbe20cf673
  style df2e93b5_a489_dbc5_46e6_10b8272183fb fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

middleware/idempotency/idempotency.go lines 43–186

func New(config ...Config) fiber.Handler {
	// Set default config
	cfg := configDefault(config...)

	redactKeys := !cfg.DisableValueRedaction

	maskKey := func(key string) string {
		if redactKeys {
			return redactedKey
		}
		return key
	}

	keepResponseHeadersMap := make(map[string]struct{}, len(cfg.KeepResponseHeaders))
	for _, h := range cfg.KeepResponseHeaders {
		// CopyString is needed because utils.ToLower uses UnsafeString
		// and map keys must be immutable
		keepResponseHeadersMap[utils.CopyString(utils.ToLower(h))] = struct{}{}
	}

	maybeWriteCachedResponse := func(c fiber.Ctx, key string) (bool, error) {
		if val, err := cfg.Storage.GetWithContext(c, key); err != nil {
			return false, fmt.Errorf("failed to read response: %w", err)
		} else if val != nil {
			var res response
			if _, err := res.UnmarshalMsg(val); err != nil {
				return false, fmt.Errorf("failed to unmarshal response: %w", err)
			}

			_ = c.Status(res.StatusCode)

			for header, vals := range res.Headers {
				for _, val := range vals {
					c.RequestCtx().Response.Header.Add(header, val)
				}
			}

			if len(res.Body) != 0 {
				if err := c.Send(res.Body); err != nil {
					return true, err
				}
			}

			_ = c.Locals(localsKeyIsFromCache, true)

			return true, nil
		}

		return false, nil
	}

	return func(c fiber.Ctx) error {
		// Don't execute middleware if Next returns true
		if cfg.Next != nil && cfg.Next(c) {
			return c.Next()
		}

		// Don't execute middleware if the idempotency key is empty
		if c.Get(cfg.KeyHeader) == "" {
			return c.Next()
		}

		// Validate key
		key := utils.CopyString(c.Get(cfg.KeyHeader))
		if err := cfg.KeyHeaderValidate(key); err != nil {
			return err
		}

		// First-pass: if the idempotency key is in the storage, get and return the response
		if ok, err := maybeWriteCachedResponse(c, key); err != nil {
			return fmt.Errorf("failed to write cached response at fastpath: %w", err)
		} else if ok {
			return nil
		}

		if err := cfg.Lock.Lock(key); err != nil {
			return fmt.Errorf("failed to lock: %w", err)
		}
		defer func() {
			if err := cfg.Lock.Unlock(key); err != nil {
				log.Errorf("[IDEMPOTENCY] failed to unlock key %q: %v", maskKey(key), err)