// STRYKE-REDIS — REDIS / VALKEY CLIENT FOR STRYKE // KV + LISTS + SETS + HASHES + ZSETS + PUB/SUB + SCAN

Contents

• Install
• Quick start: use Redis
• Connection options
• API reference (full surface)
• Pure helpers (no connection)
• FFI layer
• Examples
• Tests & dev workflow
• Troubleshooting
• Why a package, not a builtin
• Layout
• Sibling packages

Install

# from a release (no rustc on the consumer machine)
s pkg install -g github.com/MenkeTechnologies/stryke-redis

# from a local checkout
cd ~/projects/stryke-redis
cargo build --release            # produces target/release/libstryke_redis.{dylib,so}
s pkg install -g .               # cdylib lands in ~/.stryke/store/redis@<version>/

# one-liner
make install

The cdylib is dlopened in-process on first use Redis — no helper-binary fork per call. Any stryke script that declares use Redis resolves the package automatically.

-g installs globally with no project requirement — it means "no project needed", not a redundant store marker. s pkg install without -g resolves the current project's stryke.toml dependencies and is unrelated to installing this package itself. After install the cdylib lands in ~/.stryke/store/redis@<version>/.

Quick start: use Redis

use Redis

# Connection is read from $REDIS_URL, else defaults to 127.0.0.1:6379.
$ENV{REDIS_URL} = "redis://localhost:6379/0"

Redis::set "greeting", "hello from stryke"
p Redis::get "greeting"

Redis::mset { a => 1, b => 2, c => 3 }
p Redis::mget ["a", "b", "c"]              # ("1","2","3")

# TTL.
Redis::set "session:42", "...", ex => 3600
p Redis::ttl "session:42"

# Counters.
val $n = Redis::incr "page-views", by => 5

# Lists / queues.
Redis::lpush "events", ["a", "b", "c"]
val @recent = Redis::lrange "events", 0, 9
val $next   = Redis::rpop  "events"        # FIFO consumption

# Sets / dedup.
Redis::sadd "seen-users", ["alice", "bob"]
p Redis::sismember "seen-users", "alice"   # 1

# Hash = JSON-friendly objects.
Redis::hmset "user:42", { name => "alice", role => "admin", score => 100 }
val $u = Redis::hgetall "user:42"
p "$u->{name} ($u->{role})"

# Sorted set = leaderboard.
Redis::zadd "leaderboard", { alice => 100, bob => 200 }
val @top = Redis::zrange "leaderboard", 0, 9, withscores => 1, rev => 1

# Pub/sub publish.
Redis::publish "events", "new user signed up"

# SCAN — non-blocking iteration.
val @keys = Redis::scan match => "session:*", count => 100

# Server.
p to_json Redis::info section => "memory"
p Redis::dbsize
Redis::flushdb confirm => 1                # destructive — must pass confirm flag

The complete surface is documented in the API reference below. Source of truth: lib/Redis.stk in this repo.

Connection options

Every Redis::* op accepts %opts as its final argument. When %opts carries no connection fields, the connection is read from $REDIS_URL, else it defaults to 127.0.0.1:6379, db 0. The cdylib caches one redis::Connection per (url, db, tls, username, password) tuple for the life of the process — back-to-back calls with the same options reuse the same TCP socket, no handshake-per-call.

# inline overrides on any op
Redis::set "rate-limit:user-42", "1",
    url => "rediss://prod:secret@host:6380/0", ex => 60, nx => 1

# compose from parts
val %prod = ( host => "prod.example.com", port => 6380, db => 1, password => "secret", tls => 1 )
Redis::get "foo", %prod

# or set once in the environment
$ENV{REDIS_URL} = "redis://localhost:6379/0"
val %conn = ( url => $ENV{REDIS_URL} )
Redis::set "k", "v", %conn

API reference (full surface)

All 166 connection-backed commands, grouped by Redis data type. Each name is a Redis::<name> function whose final argument is an optional %opts dict (connection fields plus per-command flags). Pure helpers that need no connection are listed separately.

KV & strings

get · set (opts: ex, px, nx, xx) · del · exists · expire · ttl (-2 missing, -1 no ttl) · type · incr / decr (opts: by) · incrbyfloat · mget · mset · keys (blocking) · scan (opts: match, count, limit) · sort (opts: by, get, alpha, desc, limit_*, store) · getset · getdel · getex (opts: ex, px, persist) · append · strlen · setex · setnx · getrange · setrange

Bitmaps

setbit · getbit · bitcount (opts: start, end) · bitop (AND|OR|XOR|NOT) · bitpos · lcs (longest common subsequence; opts: len)

Lists

lpush / rpush · lpop / rpop (opts: count) · lrange · llen · lindex · lset · linsert (opts: before) · lrem · ltrim · rpoplpush · lmove (opts: from, to) · lpos (opts: rank, count) · lmpop (opts: from LEFT|RIGHT, count)

Sets

sadd · srem · smembers · sismember · smismember · scard · spop (opts: count) · srandmember (opts: count) · smove · sinter / sunion / sdiff · sinterstore / sunionstore / sdiffstore · sintercard (opts: limit)

Hashes

hset · hget · hdel · hgetall · hkeys · hvals · hmget · hmset · hexists · hincrby (opts: float) · hincrbyfloat · hlen · hsetnx · hstrlen · hrandfield (opts: count, with_values)

Sorted sets

zadd · zrange (opts: withscores, rev) · zrem · zcard · zscore · zmscore · zincrby · zrank (opts: rev) · zcount (opts: min, max) · zrangebyscore · zrangebylex · zlexcount · zpopmin / zpopmax (opts: count) · zremrangebyrank · zremrangebyscore · zunionstore / zinterstore / zdiffstore (opts: weights, aggregate) · zunion / zinter / zdiff (opts: with_scores) · zrandmember (opts: count, with_scores) · zmpop (opts: from MIN|MAX, count)

Key management

rename · renamenx · persist · pexpire · pttl · expireat · pexpireat · expiretime · randomkey · touch · unlink (async del) · copy (opts: replace, destination_db) · object_encoding

HyperLogLog

pfadd · pfcount · pfmerge

Streams

xadd (opts: id, default "*") · xlen · xrange (opts: start, end, count, rev) · xdel · xtrim (opts: maxlen | minid) · xsetid · xread (opts: count, block) · xgroup_create (opts: id, mkstream) · xack · xinfo_stream

Geospatial

geoadd · geopos · geodist (opts: unit m/km/mi/ft) · geosearch (from_member | lon+lat; radius | width+height)

Scripting (Lua)

eval (opts: keys, args) · evalsha · script_load · script_exists

Cursor scans (iterate internally, return everything)

hscan · sscan · zscan (each: opts match, count)

Pub/sub

publish · pubsub_channels (opts: pattern) · pubsub_numsub · pubsub_numpat

Streaming SUBSCRIBE is on the roadmap, pending a stryke Unix-socket reader builtin — only publish ships in this release.

Pipeline / transaction

pipeline ([[CMD,…],…]; opts: transaction for MULTI/EXEC)

Server, admin & introspection

ping · version · info (opts: section; pair with Redis::parse_info) · dbsize · flushdb (require confirm => 1) · flushall (opts: async) · raw (arbitrary command argv) · time · config_get / config_set · memory_usage · echo · wait (opts: timeout) · lastsave · slowlog_get (opts: count) · slowlog_reset · client_list · client_info · acl_whoami · acl_list · acl_cat (opts: category) · object_idletime · object_refcount · object_freq

Full per-argument signatures and return shapes are in the README API reference.

Pure helpers (no connection)

These 18 functions run entirely client-side — no TCP round trip. They parse Redis reply text, manipulate connection URLs, match keys against Redis globs, compute cluster key slots, and order stream IDs.

Use glob_match to filter keys locally without a round trip, and redact_url before logging any connection string.

Examples

Runnable .stk scripts live in examples/. Each is eval-guarded on Redis::ping so it exits 0 in CI even without a live server.

# run any example with a live server
REDIS_URL=redis://localhost s examples/kv.stk
REDIS_URL=redis://localhost s examples/structures.stk
s examples/publish.stk my-channel 'hello'

Tests & dev workflow

cargo test                                    # compiles the cdylib, no live calls
REDIS_URL=redis://localhost s test t/         # live round-trip suite

Test keys are scoped under stryke:test:$$: and cleaned at exit, so concurrent CI runs don't collide. Spin up a local server with brew services start redis or docker run --rm -p 6379:6379 redis:7.

make             # release build (target/release/libstryke_redis.{dylib,so})
make debug
make test
make install
make clean

Troubleshooting

Why a package, not a builtin

redis Rust crate (sync) with rustls TLS. Single highest-leverage daily-use connector after Postgres / MySQL.

The stryke side is a thin .stk wrapper that calls redis__* FFI symbols on the cdylib; the heavy code lives in libstryke_redis.{dylib,so}, dlopened in-process on first use Redis. Core stryke is never linked against this package's deps.

FFI layer

Each Redis::* wrapper builds a JSON args dict and calls a sibling redis__* symbol resolved out of libstryke_redis.{dylib,so}. The cdylib is dlopened in-process on first use Redis and caches one redis::Connection per (url, db, tls, username, password) tuple in OnceCell<Mutex<HashMap>> for the life of the stryke process — back-to-back calls reuse the same TCP socket, no handshake-per-call. There are 184 exported redis__* symbols (one per public function), declared in the [ffi] table of stryke.toml and matched exactly by the extern "C" definitions in src/lib.rs.

Wire shape — JSON in, JSON out:

scalars                 → {"value": …}
lists / sets / values   → {"values": [...]} | {"members": [...]}
hashes                  → {"hash": {...}}
zset rows with scores   → {"pairs": [[member, score], ...]}
errors                  → {"error": "<msg>"}   # wrapper die()s with it

The returned CString is freed via the cdylib-exported stryke_free_cstring, wired automatically by stryke's rust_ffi::load_cdylib — closing the returned-allocation leak the inline-FFI v1 had.

Layout

stryke-redis/
├── Cargo.toml             # cdylib crate manifest (crate-type = ["cdylib"], publish = false)
├── src/
│   └── lib.rs            # cdylib — redis__* extern "C" exports + persistent conn cache
├── lib/                   # stryke .stk wrapper(s) — `use Redis`
├── stryke.toml            # stryke package manifest ([ffi] exports table)
├── t/                     # zunit-style tests
├── examples/              # runnable .stk examples
├── Makefile               # `make install` builds + installs
└── docs/                  # this site (GitHub Pages)

Sibling packages

Part of the stryke package family. Browse the others via the MenkeTechnologiesMeta umbrella repo:

• stryke-arrow — Apache Arrow / Parquet / Feather
• stryke-aws — S3, DynamoDB, SQS, Lambda, STS
• stryke-azure — Blob, Queues, Cosmos DB, Key Vault, Entra
• stryke-clickhouse — ClickHouse
• stryke-demo — live demos for every connector
• stryke-docker — Docker daemon API
• stryke-duckdb — embedded DuckDB SQL engine
• stryke-email — email + campaign client
• stryke-fleet — parallel expect/PTY automation
• stryke-gcp — Cloud Storage, Pub/Sub, Secret Manager, BigQuery, Firestore
• stryke-grpc — reflection-based gRPC client
• stryke-gui — mouse / keyboard / screen / clipboard automation
• stryke-k8s — Kubernetes
• stryke-kafka — Apache Kafka
• stryke-mcpd — MCP servers without a runtime
• stryke-mongo — MongoDB
• stryke-mssql — Microsoft SQL Server
• stryke-mysql — MySQL / MariaDB
• stryke-neo4j — Neo4j graph (Bolt)
• stryke-office — Office docs / PDF / images
• stryke-parquet — Parquet file inspector
• stryke-polars — Polars + ndarray + linalg + FFT
• stryke-postgres — PostgreSQL
• stryke-scrape — web scraping / crawling
• stryke-scylla — ScyllaDB / Cassandra
• stryke-search — Elasticsearch / OpenSearch
• stryke-selenium — browser automation (WebDriver)
• stryke-spark — Spark Connect (no JVM)
• stryke-utils — pure-stryke utility belt
• stryke-zmq — ZeroMQ messaging