Server-side cookies in JavaScript SDK

    type CookieData = {
      name: string;
      value: string;
    };
    
    type CookiesReqData = {
      options: {
        expires?: Date;
        maxAge?: number;
        path?: string;
        domain?: string;
        sameSite?: 'Lax' | 'Strict' | 'None';
        secure?: boolean;
        httpOnly?: boolean;
      };
      cookies: CookieData[];
    };
    
    type RequestData = CookiesReqData;
    
    const ALLOWED_COOKIES = [
      'rl_user_id',
      'rl_trait',
      'rl_anonymous_id',
      'rl_group_id',
      'rl_group_trait',
      'rl_page_init_referrer',
      'rl_page_init_referring_domain',
      'rl_session',
      'rl_auth_token'
    ];
    
    const encode = (value: string) => {
      try {
        return encodeURIComponent(value);
      } catch (err) {
        return undefined;
      }
    };
    
    const generateCookieStrings = (data: RequestData): string[] => {
      try {
        const { cookies, options } = data;
        return cookies.filter((cookie: CookieData) => ALLOWED_COOKIES.includes(cookie.name)).map((cookie: CookieData) => {
          let cookieStr = `${encode(cookie.name)}=${encode(cookie.value)}`;
          let opts = { ...options }; // Clone options to avoid modifying the original object
    
          if (cookie.value === '') {
            opts.maxAge = -10 * 60 * 1000; // Set negative to ensure cookie is deleted
          }
    
          if (opts.maxAge) {
            opts.expires = new Date(+new Date() + opts.maxAge);
          }
    
          if (opts.path) cookieStr += `; Path=${opts.path}`;
          if (opts.domain) cookieStr += `; Domain=${opts.domain}`;
          if (opts.expires) cookieStr += `; Expires=${opts.expires.toUTCString()}`;
          if (opts.sameSite) cookieStr += `; SameSite=${opts.sameSite}`;
          if (opts.secure) cookieStr += '; Secure';
    
          return cookieStr;
        });
      } catch (err) {
        return [];
      }
    };
    
    export default function cookieRequestHandler(
      req: NextApiRequest,
      res: NextApiResponse
    ) {
      const requestData: RequestData = req.body;
      const cookieStrings = generateCookieStrings(requestData);
      cookieStrings.forEach(cookieStr => {
        res.append('Set-Cookie', cookieStr);
      });
      res.status(200);
    }

    $allowedCookies = [
        'rl_user_id', 'rl_trait', 'rl_anonymous_id', 'rl_group_id', 
        'rl_group_trait', 'rl_page_init_referrer', 'rl_page_init_referring_domain', 
        'rl_session', 'rl_auth_token'
    ];
    
    function isAllowedCookie($name) {
        return in_array($name, $GLOBALS['allowedCookies']);
    }
    
    function setCookiesFromRequest($data) {
        $cookies = $data['cookies'];
        $options = $data['options'];
    
        foreach ($cookies as $cookie) {
            if (!isAllowedCookie($cookie['name'])) {
                continue;
            }
    
            $cookieOptions = []; // Array to hold cookie-specific options
            $maxAge = $cookie['maxAge'];
    
            if ($cookie['value'] === '') {
                $maxAge = -10 * 60; // Set negative to ensure cookie is deleted
            }
    
            $expires = $cookie['expires'];
            if (isset($maxAge)) {
                $expires = time() + $maxAge;
            }
    
            // Set each option only if it's explicitly provided
            if (isset($expires)) {
                $cookieOptions['expires'] = $expires;
            }
            if (isset($options['path'])) {
                $cookieOptions['path'] = $options['path'];
            }
            if (isset($options['domain'])) {
                $cookieOptions['domain'] = $options['domain'];
            }
            if (isset($options['secure'])) {
                $cookieOptions['secure'] = $options['secure'];
            }
            if (isset($options['sameSite'])) {
                $cookieOptions['samesite'] = $options['sameSite'];
            }
    
            setcookie($cookie['name'], $cookie['value'], $cookieOptions);
        }
    }
    
    function cookieRequestHandler() {
        $jsonData = json_decode(file_get_contents('php://input'), true);
        setCookiesFromRequest($jsonData);
    }

    ALLOWED_COOKIES = [
      'rl_user_id', 'rl_trait', 'rl_anonymous_id', 'rl_group_id', 
      'rl_group_trait', 'rl_page_init_referrer', 'rl_page_init_referring_domain', 
      'rl_session', 'rl_auth_token'
    ].freeze
    
    def cookie_request_handler
      data = JSON.parse(request.body.read)
      cookies_data = data['cookies']
      options = data['options'].symbolize_keys
      cookies_data.each do |cookie|
        next unless ALLOWED_COOKIES.include?(cookie['name'])
    
        # Set max_age to a negative value if the cookie should be deleted
        max_age = cookie['value'].blank? ? -10 * 60 : (options[:maxAge] || 0)
        
        # Calculate expiration time directly based on max_age
        expires = Time.current + max_age.seconds
    
        cookie_options = {
          value: value,
          max_age: max_age,
          expires: expires,
          path: options[:path],
          domain: options[:domain],
          secure: options[:secure],
          httponly: options.fetch(:httpOnly, false),
          same_site: options[:sameSite]
        }
        cookies[cookie['name']] = cookie_options
      end
      head :ok
    end

    import (
        "encoding/json"
        "net/http"
        "time"
    )
    
    var allowedCookies = []string{
        "rl_user_id", "rl_trait", "rl_anonymous_id", "rl_group_id",
        "rl_group_trait", "rl_page_init_referrer", "rl_page_init_referring_domain",
        "rl_session", "rl_auth_token",
    }
    
    func isAllowedCookie(name string) bool {
        for _, allowed := range allowedCookies {
            if allowed == name {
                return true
            }
        }
        return false
    }
    
    func parseSameSite(s string) http.SameSite {
        switch s {
        case "Strict":
            return http.SameSiteStrictMode
        case "Lax":
            return http.SameSiteLaxMode
        default:
            return http.SameSiteDefaultMode
        }
    }
    
    func cookieRequestHandler(w http.ResponseWriter, r *http.Request) {
        var data struct {
            Cookies []struct {
                Name  string `json:"name"`
                Value string `json:"value"`
            } `json:"cookies"`
            Options struct {
                MaxAge   *int   `json:"maxAge"`
                Path     string `json:"path"`
                Domain   string `json:"domain"`
                SameSite string `json:"sameSite"`
                Secure   bool   `json:"secure"`
            } `json:"options"`
        }
        json.NewDecoder(r.Body).Decode(&data)
        for _, cookie := range data.Cookies {
            if !isAllowedCookie(cookie.Name) {
                continue
            }
            var expires time.Time := nil
            var maxAge := data.Options.MaxAge
            if cookie.Value == "" {
                maxAge = -600
            }
            if maxAge != nil {
                expires = time.Now().Add(time.Duration(*maxAge) * time.Second)
            }
    
            http.SetCookie(w, &http.Cookie{
                Name:     cookie.Name,
                Value:    cookie.Value,
                Expires:  expires,
                MaxAge:   maxAge,
                Path:     data.Options.Path,
                Domain:   data.Options.Domain,
                Secure:   data.Options.Secure,
                SameSite: parseSameSite(data.Options.SameSite),
            })
        }
        w.WriteHeader(http.StatusOK)
    }