Use macro for redis connection binding in rate-limit store

Agent-Logs-Url: https://github.com/cl-sdk/wst/sessions/2c0d4f62-c4fe-49c2-a925-07238fb1818e

Co-authored-by: diasbruno <362368+diasbruno@users.noreply.github.com>

Author: Copilot

rate-limit/redis-store.lisp

@@ -5,11 +5,7 @@
 This backend implements the wst.rate-limit.store protocol using Redis hash
 entries with fields:
   - \"count\" : current request count
-  - \"start\" : window start time (universal-time)
-
-Redis access is delegated to COMMAND-FN, allowing integration with any Redis
-client library. COMMAND-FN receives command name as a string followed by
-command arguments.")
+  - \"start\" : window start time (universal-time)")
   (:export
    #:redis-store))
 
@@ -20,29 +16,27 @@ command arguments.")
                :initform "wst:rate-limit:"
                :reader redis-store-key-prefix)
    (window-seconds :initarg :window-seconds
-                    :initform nil
-                    :reader redis-store-window-seconds)
+                   :initform nil
+                   :reader redis-store-window-seconds)
    (connection :initarg :connection
                :initform nil
-               :reader redis-store-connection)
-   (connection-fn :initarg :connection-fn
-                  :initform (lambda (store thunk)
-                              (let ((connection (redis-store-connection store)))
-                                (unless connection
-                                  (error "No Redis connection configured. Pass a CL-REDIS connection via :connection when creating the store."))
-                                (let ((redis:*connection* connection))
-                                  (funcall thunk))))
-                  :reader redis-store-connection-fn))
+               :reader redis-store-connection))
   (:documentation "Redis-backed implementation of the rate-limit store protocol.
 
 Slots:
 - KEY-PREFIX: string prefix used to namespace Redis keys.
 - WINDOW-SECONDS: optional TTL set on each saved key via EXPIRE.
-- CONNECTION: CL-REDIS connection object used as REDIS:*CONNECTION*.
-- CONNECTION-FN: function called as (connection-fn store thunk) to execute Redis calls."))
+- CONNECTION: CL-REDIS connection object used as REDIS:*CONNECTION*."))
 
-(defun redis-store--with-connection (store thunk)
-  (funcall (redis-store-connection-fn store) store thunk))
+(defmacro redis-store--with-connection ((store) &body body)
+  (let ((store-var (gensym))
+        (connection-var (gensym)))
+    `(let* ((,store-var ,store)
+            (,connection-var (redis-store-connection ,store-var)))
+       (unless ,connection-var
+         (error "No Redis connection configured. Pass a CL-REDIS connection via :connection when creating the store."))
+       (let ((redis:*connection* ,connection-var))
+         ,@body))))
 
 (defun redis-store--key (store key)
   (format nil "~a~a" (redis-store-key-prefix store) (write-to-string key :readably t)))
@@ -58,8 +52,8 @@ Slots:
 
 (defmethod io.github.cl-sdk.wst.rate-limit.store:fetch-window ((store redis-store) key)
   (let* ((redis-key (redis-store--key store key))
-         (reply (redis-store--with-connection store
-                  (lambda () (redis:hmget redis-key "count" "start"))))
+         (reply (redis-store--with-connection (store)
+                                              (redis:red-hmget redis-key "count" "start")))
          (count-raw (and (listp reply) (first reply)))
          (start-raw (and (listp reply) (second reply)))
          (count (redis-store--integer-or-nil count-raw))
@@ -71,16 +65,15 @@ Slots:
 (defmethod io.github.cl-sdk.wst.rate-limit.store:save-window ((store redis-store) key count start-time)
   (let* ((redis-key (redis-store--key store key))
          (ttl (redis-store-window-seconds store)))
-    (redis-store--with-connection store
-      (lambda ()
-        (redis:hmset redis-key
-                     "count" (write-to-string count)
-                     "start" (write-to-string start-time))))
+    (redis-store--with-connection (store)
+                                  (redis:red-hmset redis-key
+                                                   "count" (write-to-string count)
+                                                   "start" (write-to-string start-time)))
     (when (and ttl (plusp ttl))
-      (redis-store--with-connection store
-        (lambda () (redis:expire redis-key ttl))))
+      (redis-store--with-connection (store)
+                                    (redis:red-expire redis-key ttl)))
     t))
 
-(defmethod wst.rate-limit.store:delete-window ((store redis-store) key)
-  (redis-store--with-connection store
-    (lambda () (redis:del (redis-store--key store key)))))
+(defmethod io.github.cl-sdk.wst.rate-limit.store:delete-window ((store redis-store) key)
+  (redis-store--with-connection (store)
+                                (redis:red-del (redis-store--key store key))))

t/rate-limit-redis-store-tests.lisp

@@ -12,38 +12,38 @@
   (let ((records (make-hash-table :test #'equal))
         (expiries (make-hash-table :test #'equal)))
     (values
-      records
-      expiries)))
+     records
+     expiries)))
 
 (defun ensure-rate-limit-entry (records key)
   (or (gethash key records)
       (setf (gethash key records) (make-hash-table :test #'equal))))
 
 (defmacro with-mocked-rate-limit-redis ((records expiries) &body body)
-  `(let* ((hmget-original (symbol-function 'redis:hmget))
-          (hmset-original (symbol-function 'redis:hmset))
-          (expire-original (symbol-function 'redis:expire))
-          (del-original (symbol-function 'redis:del)))
+  `(let* ((hmget-original (symbol-function 'redis:red-hmget))
+          (hmset-original (symbol-function 'redis:red-hmset))
+          (expire-original (symbol-function 'redis:red-expire))
+          (del-original (symbol-function 'redis:red-del)))
      (unwind-protect
           (progn
-            (setf (symbol-function 'redis:hmget)
+            (setf (symbol-function 'redis:red-hmget)
                   (lambda (key field &rest fields)
                     (let* ((entry (gethash key ,records))
                            (wanted-fields (cons field fields)))
                       (mapcar (lambda (field-name)
                                 (and entry (gethash field-name entry)))
                               wanted-fields)))
-                  (symbol-function 'redis:hmset)
+                  (symbol-function 'redis:red-hmset)
                   (lambda (key &rest fields-and-values)
                     (let ((entry (ensure-rate-limit-entry ,records key)))
                       (loop for (field value) on fields-and-values by #'cddr
                             do (setf (gethash field entry) value)))
                     "OK")
-                  (symbol-function 'redis:expire)
+                  (symbol-function 'redis:red-expire)
                   (lambda (key ttl)
                     (setf (gethash key ,expiries) ttl)
                     t)
-                  (symbol-function 'redis:del)
+                  (symbol-function 'redis:red-del)
                   (lambda (key &rest keys)
                     (let ((removed 0))
                       (dolist (k (cons key keys) removed)
@@ -52,17 +52,17 @@
                         (remhash k ,records)
                         (remhash k ,expiries)))))
             ,@body)
-       (setf (symbol-function 'redis:hmget) hmget-original
-             (symbol-function 'redis:hmset) hmset-original
-             (symbol-function 'redis:expire) expire-original
-             (symbol-function 'redis:del) del-original))))
+       (setf (symbol-function 'redis:red-hmget) hmget-original
+             (symbol-function 'redis:red-hmset) hmset-original
+             (symbol-function 'redis:red-expire) expire-original
+             (symbol-function 'redis:red-del) del-original))))
 
 (5am:def-test redis-rate-limit-store-roundtrip ()
   (multiple-value-bind (records expiries)
       (make-rate-limit-fake-redis)
     (declare (ignore _records _expiries))
     (let ((store (make-instance 'io.github.cl-sdk.wst.rate-limit.redis-store:redis-store
-                                :command-fn command-fn)))
+                                :connection (make-rate-limit-fake-redis))))
       (multiple-value-bind (count start)
           (io.github.cl-sdk.wst.rate-limit.store:fetch-window store :client-a)
         (5am:is-false count)
@@ -83,7 +83,7 @@
       (make-rate-limit-fake-redis)
     (declare (ignore _records))
     (let ((store (make-instance 'io.github.cl-sdk.wst.rate-limit.redis-store:redis-store
-                                :command-fn command-fn
-                                :window-seconds 42)))
+                                :window-seconds 42
+                                :connection (make-rate-limit-fake-redis))))
       (io.github.cl-sdk.wst.rate-limit.store:save-window store :client-b 1 2000)
       (5am:is (= 42 (gethash "wst:rate-limit::CLIENT-B" expiries)))))) ; key uses WRITE-TO-STRING on :CLIENT-B