|
#!/usr/bin/env bun |
|
import { parseArgs } from "node:util"; |
|
import { Redis } from "@upstash/redis"; |
|
|
|
const { values, positionals } = parseArgs({ |
|
args: process.argv.slice(2), |
|
options: { |
|
url: { type: "string" }, |
|
token: { type: "string" }, |
|
help: { type: "boolean", short: "h" }, |
|
// SET options |
|
ex: { type: "string" }, |
|
px: { type: "string" }, |
|
exat: { type: "string" }, |
|
pxat: { type: "string" }, |
|
nx: { type: "boolean" }, |
|
xx: { type: "boolean" }, |
|
keepttl: { type: "boolean" }, |
|
get: { type: "boolean" }, |
|
// ZRANGE/ZADD options |
|
withscores: { type: "boolean" }, |
|
byscore: { type: "boolean" }, |
|
bylex: { type: "boolean" }, |
|
rev: { type: "boolean" }, |
|
limit: { type: "string" }, |
|
// ZADD-specific options |
|
gt: { type: "boolean" }, |
|
lt: { type: "boolean" }, |
|
ch: { type: "boolean" }, |
|
// JSON input for complex objects |
|
json: { type: "boolean" }, |
|
}, |
|
allowPositionals: true, |
|
}); |
|
|
|
function printHelp() { |
|
console.log(`Usage: bun run upstash-client.ts [options] <command> [args...] |
|
|
|
Connection Options: |
|
--url <url> Upstash REST URL (or UPSTASH_REDIS_REST_URL env var) |
|
--token <token> Upstash REST token (or UPSTASH_REDIS_REST_TOKEN env var) |
|
-h, --help Show this help |
|
|
|
SET Options: |
|
--ex <seconds> Set expiration in seconds |
|
--px <ms> Set expiration in milliseconds |
|
--exat <ts> Set expiration as Unix timestamp (seconds) |
|
--pxat <ts> Set expiration as Unix timestamp (milliseconds) |
|
--nx Only set if key does not exist |
|
--xx Only set if key already exists |
|
--keepttl Retain existing TTL |
|
--get Return old value |
|
|
|
ZADD Options: |
|
--nx Only add new elements |
|
--xx Only update existing elements |
|
--gt Only update when new score > current score |
|
--lt Only update when new score < current score |
|
--ch Return number of changed elements |
|
|
|
ZRANGE Options: |
|
--withscores Include scores in output |
|
--byscore Interpret range as score range |
|
--bylex Interpret range as lexicographical range |
|
--rev Reverse order |
|
--limit <off,count> Limit results (e.g., --limit 0,10) |
|
|
|
General: |
|
--json Parse next argument as JSON (for complex objects) |
|
|
|
Commands: |
|
|
|
STRING: |
|
GET <key> |
|
SET <key> <value> [--ex N] [--px N] [--nx] [--xx] |
|
MGET <key1> [key2...] |
|
MSET <key1> <val1> [key2 val2...] |
|
INCR <key> |
|
INCRBY <key> <increment> |
|
DECR <key> |
|
DECRBY <key> <decrement> |
|
APPEND <key> <value> |
|
STRLEN <key> |
|
|
|
HASH: |
|
HGET <key> <field> |
|
HSET <key> <field1> <val1> [field2 val2...] |
|
HMGET <key> <field1> [field2...] |
|
HGETALL <key> |
|
HDEL <key> <field1> [field2...] |
|
HEXISTS <key> <field> |
|
HKEYS <key> |
|
HVALS <key> |
|
HLEN <key> |
|
HINCRBY <key> <field> <increment> |
|
HSETNX <key> <field> <value> |
|
|
|
LIST: |
|
LPUSH <key> <val1> [val2...] |
|
RPUSH <key> <val1> [val2...] |
|
LPOP <key> [count] |
|
RPOP <key> [count] |
|
LRANGE <key> <start> <stop> |
|
LLEN <key> |
|
LINDEX <key> <index> |
|
LSET <key> <index> <value> |
|
LREM <key> <count> <value> |
|
LTRIM <key> <start> <stop> |
|
LINSERT <key> <BEFORE|AFTER> <pivot> <value> |
|
|
|
SET: |
|
SADD <key> <member1> [member2...] |
|
SREM <key> <member1> [member2...] |
|
SMEMBERS <key> |
|
SISMEMBER <key> <member> |
|
SCARD <key> |
|
SPOP <key> [count] |
|
SRANDMEMBER <key> [count] |
|
SINTER <key1> [key2...] |
|
SUNION <key1> [key2...] |
|
SDIFF <key1> [key2...] |
|
|
|
SORTED SET: |
|
ZADD <key> <score1> <member1> [score2 member2...] [--nx] [--xx] [--gt] [--lt] [--ch] |
|
ZREM <key> <member1> [member2...] |
|
ZSCORE <key> <member> |
|
ZRANK <key> <member> |
|
ZREVRANK <key> <member> |
|
ZRANGE <key> <start> <stop> [--withscores] [--byscore] [--bylex] [--rev] |
|
ZRANGEBYSCORE <key> <min> <max> [--withscores] [--limit off,count] |
|
ZCARD <key> |
|
ZCOUNT <key> <min> <max> |
|
ZINCRBY <key> <increment> <member> |
|
ZPOPMIN <key> [count] |
|
ZPOPMAX <key> [count] |
|
|
|
KEY: |
|
DEL <key1> [key2...] |
|
EXISTS <key1> [key2...] |
|
EXPIRE <key> <seconds> |
|
EXPIREAT <key> <timestamp> |
|
TTL <key> |
|
PTTL <key> |
|
PERSIST <key> |
|
KEYS <pattern> |
|
SCAN <cursor> [MATCH pattern] [COUNT count] |
|
TYPE <key> |
|
RENAME <key> <newkey> |
|
RENAMENX <key> <newkey> |
|
|
|
SERVER: |
|
DBSIZE |
|
FLUSHDB |
|
PING |
|
ECHO <message> |
|
|
|
Examples: |
|
# Basic string operations |
|
bun run upstash-client.ts SET mykey "hello world" |
|
bun run upstash-client.ts GET mykey |
|
bun run upstash-client.ts SET session:123 "data" --ex 3600 |
|
|
|
# Hash operations (field/value pairs) |
|
bun run upstash-client.ts HSET user:1 name "John" email "john@example.com" age 30 |
|
bun run upstash-client.ts HGET user:1 name |
|
bun run upstash-client.ts HGETALL user:1 |
|
|
|
# List operations |
|
bun run upstash-client.ts LPUSH tasks "task1" "task2" "task3" |
|
bun run upstash-client.ts LRANGE tasks 0 -1 |
|
|
|
# Set operations |
|
bun run upstash-client.ts SADD tags "javascript" "redis" "nodejs" |
|
bun run upstash-client.ts SMEMBERS tags |
|
|
|
# Sorted set operations (score member pairs) |
|
bun run upstash-client.ts ZADD leaderboard 1000 "player1" 1500 "player2" |
|
bun run upstash-client.ts ZRANGE leaderboard 0 -1 --withscores --rev |
|
|
|
# Multiple keys |
|
bun run upstash-client.ts MSET key1 "val1" key2 "val2" key3 "val3" |
|
bun run upstash-client.ts MGET key1 key2 key3 |
|
|
|
# With explicit credentials |
|
bun run upstash-client.ts --url https://... --token AX... GET mykey`); |
|
} |
|
|
|
if (values.help || positionals.length === 0) { |
|
printHelp(); |
|
process.exit(values.help ? 0 : 1); |
|
} |
|
|
|
const url = values.url || process.env.UPSTASH_REDIS_REST_URL; |
|
const token = values.token || process.env.UPSTASH_REDIS_REST_TOKEN; |
|
|
|
if (!url || !token) { |
|
console.error("Error: Missing credentials"); |
|
console.error("Provide --url and --token, or set UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN"); |
|
process.exit(1); |
|
} |
|
|
|
const redis = new Redis({ url, token }); |
|
const [rawCmd, ...args] = positionals; |
|
const cmd = rawCmd.toUpperCase(); |
|
|
|
// Helper to parse a value (try JSON, fall back to string/number) |
|
function parseValue(val: string): any { |
|
if (values.json) { |
|
try { |
|
return JSON.parse(val); |
|
} catch { |
|
return val; |
|
} |
|
} |
|
// Try to parse as number |
|
const num = Number(val); |
|
if (!isNaN(num) && val.trim() !== "") { |
|
return num; |
|
} |
|
// Try to parse as JSON object/array |
|
if ((val.startsWith("{") && val.endsWith("}")) || (val.startsWith("[") && val.endsWith("]"))) { |
|
try { |
|
return JSON.parse(val); |
|
} catch { |
|
return val; |
|
} |
|
} |
|
return val; |
|
} |
|
|
|
// Helper to convert pairs to object: [k1, v1, k2, v2] -> {k1: v1, k2: v2} |
|
function pairsToObject(pairs: string[]): Record<string, any> { |
|
const obj: Record<string, any> = {}; |
|
for (let i = 0; i < pairs.length; i += 2) { |
|
if (i + 1 < pairs.length) { |
|
obj[pairs[i]] = parseValue(pairs[i + 1]); |
|
} |
|
} |
|
return obj; |
|
} |
|
|
|
// Helper to convert score/member pairs: [s1, m1, s2, m2] -> [{score: s1, member: m1}, ...] |
|
function scoreMemberPairs(pairs: string[]): Array<{ score: number; member: string }> { |
|
const result: Array<{ score: number; member: string }> = []; |
|
for (let i = 0; i < pairs.length; i += 2) { |
|
if (i + 1 < pairs.length) { |
|
result.push({ score: Number(pairs[i]), member: pairs[i + 1] }); |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
// Build SET options |
|
function buildSetOptions(): Record<string, any> | undefined { |
|
const opts: Record<string, any> = {}; |
|
if (values.ex) opts.ex = Number(values.ex); |
|
if (values.px) opts.px = Number(values.px); |
|
if (values.exat) opts.exat = Number(values.exat); |
|
if (values.pxat) opts.pxat = Number(values.pxat); |
|
if (values.nx) opts.nx = true; |
|
if (values.xx) opts.xx = true; |
|
if (values.keepttl) opts.keepttl = true; |
|
if (values.get) opts.get = true; |
|
return Object.keys(opts).length > 0 ? opts : undefined; |
|
} |
|
|
|
// Build ZADD options |
|
function buildZaddOptions(): Record<string, any> | undefined { |
|
const opts: Record<string, any> = {}; |
|
if (values.nx) opts.nx = true; |
|
if (values.xx) opts.xx = true; |
|
if (values.gt) opts.gt = true; |
|
if (values.lt) opts.lt = true; |
|
if (values.ch) opts.ch = true; |
|
return Object.keys(opts).length > 0 ? opts : undefined; |
|
} |
|
|
|
// Build ZRANGE options |
|
function buildZrangeOptions(): Record<string, any> | undefined { |
|
const opts: Record<string, any> = {}; |
|
if (values.withscores) opts.withScores = true; |
|
if (values.byscore) opts.byScore = true; |
|
if (values.bylex) opts.byLex = true; |
|
if (values.rev) opts.rev = true; |
|
if (values.limit) { |
|
const [offset, count] = values.limit.split(",").map(Number); |
|
opts.offset = offset; |
|
opts.count = count; |
|
} |
|
return Object.keys(opts).length > 0 ? opts : undefined; |
|
} |
|
|
|
// Parse SCAN arguments: SCAN cursor [MATCH pattern] [COUNT count] |
|
function parseScanArgs(args: string[]): { cursor: number; options?: { match?: string; count?: number } } { |
|
const cursor = Number(args[0]) || 0; |
|
const options: { match?: string; count?: number } = {}; |
|
|
|
for (let i = 1; i < args.length; i++) { |
|
const arg = args[i].toUpperCase(); |
|
if (arg === "MATCH" && i + 1 < args.length) { |
|
options.match = args[++i]; |
|
} else if (arg === "COUNT" && i + 1 < args.length) { |
|
options.count = Number(args[++i]); |
|
} |
|
} |
|
|
|
return { cursor, options: Object.keys(options).length > 0 ? options : undefined }; |
|
} |
|
|
|
async function execute(): Promise<any> { |
|
// STRING COMMANDS |
|
switch (cmd) { |
|
case "GET": |
|
return redis.get(args[0]); |
|
|
|
case "SET": { |
|
const opts = buildSetOptions(); |
|
return opts |
|
? redis.set(args[0], parseValue(args[1]), opts) |
|
: redis.set(args[0], parseValue(args[1])); |
|
} |
|
|
|
case "SETNX": |
|
return redis.setnx(args[0], parseValue(args[1])); |
|
|
|
case "SETEX": |
|
return redis.setex(args[0], Number(args[1]), parseValue(args[2])); |
|
|
|
case "PSETEX": |
|
return redis.psetex(args[0], Number(args[1]), parseValue(args[2])); |
|
|
|
case "MGET": |
|
return redis.mget(...args); |
|
|
|
case "MSET": |
|
return redis.mset(pairsToObject(args)); |
|
|
|
case "MSETNX": |
|
return redis.msetnx(pairsToObject(args)); |
|
|
|
case "INCR": |
|
return redis.incr(args[0]); |
|
|
|
case "INCRBY": |
|
return redis.incrby(args[0], Number(args[1])); |
|
|
|
case "INCRBYFLOAT": |
|
return redis.incrbyfloat(args[0], Number(args[1])); |
|
|
|
case "DECR": |
|
return redis.decr(args[0]); |
|
|
|
case "DECRBY": |
|
return redis.decrby(args[0], Number(args[1])); |
|
|
|
case "APPEND": |
|
return redis.append(args[0], args[1]); |
|
|
|
case "STRLEN": |
|
return redis.strlen(args[0]); |
|
|
|
case "GETRANGE": |
|
return redis.getrange(args[0], Number(args[1]), Number(args[2])); |
|
|
|
case "SETRANGE": |
|
return redis.setrange(args[0], Number(args[1]), args[2]); |
|
|
|
// HASH COMMANDS |
|
case "HGET": |
|
return redis.hget(args[0], args[1]); |
|
|
|
case "HSET": |
|
return redis.hset(args[0], pairsToObject(args.slice(1))); |
|
|
|
case "HSETNX": |
|
return redis.hsetnx(args[0], args[1], parseValue(args[2])); |
|
|
|
case "HMSET": |
|
return redis.hset(args[0], pairsToObject(args.slice(1))); |
|
|
|
case "HMGET": |
|
return redis.hmget(args[0], ...args.slice(1)); |
|
|
|
case "HGETALL": |
|
return redis.hgetall(args[0]); |
|
|
|
case "HDEL": |
|
return redis.hdel(args[0], ...args.slice(1)); |
|
|
|
case "HEXISTS": |
|
return redis.hexists(args[0], args[1]); |
|
|
|
case "HKEYS": |
|
return redis.hkeys(args[0]); |
|
|
|
case "HVALS": |
|
return redis.hvals(args[0]); |
|
|
|
case "HLEN": |
|
return redis.hlen(args[0]); |
|
|
|
case "HINCRBY": |
|
return redis.hincrby(args[0], args[1], Number(args[2])); |
|
|
|
case "HINCRBYFLOAT": |
|
return redis.hincrbyfloat(args[0], args[1], Number(args[2])); |
|
|
|
case "HSCAN": { |
|
const cursor = Number(args[1]) || 0; |
|
const scanOpts: { match?: string; count?: number } = {}; |
|
for (let i = 2; i < args.length; i++) { |
|
if (args[i].toUpperCase() === "MATCH" && i + 1 < args.length) scanOpts.match = args[++i]; |
|
if (args[i].toUpperCase() === "COUNT" && i + 1 < args.length) scanOpts.count = Number(args[++i]); |
|
} |
|
return redis.hscan(args[0], cursor, Object.keys(scanOpts).length > 0 ? scanOpts : undefined); |
|
} |
|
|
|
// LIST COMMANDS |
|
case "LPUSH": |
|
return redis.lpush(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "RPUSH": |
|
return redis.rpush(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "LPUSHX": |
|
return redis.lpushx(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "RPUSHX": |
|
return redis.rpushx(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "LPOP": |
|
return args.length > 1 ? redis.lpop(args[0], Number(args[1])) : redis.lpop(args[0]); |
|
|
|
case "RPOP": |
|
return args.length > 1 ? redis.rpop(args[0], Number(args[1])) : redis.rpop(args[0]); |
|
|
|
case "LRANGE": |
|
return redis.lrange(args[0], Number(args[1]), Number(args[2])); |
|
|
|
case "LLEN": |
|
return redis.llen(args[0]); |
|
|
|
case "LINDEX": |
|
return redis.lindex(args[0], Number(args[1])); |
|
|
|
case "LSET": |
|
return redis.lset(args[0], Number(args[1]), parseValue(args[2])); |
|
|
|
case "LREM": |
|
return redis.lrem(args[0], Number(args[1]), parseValue(args[2])); |
|
|
|
case "LTRIM": |
|
return redis.ltrim(args[0], Number(args[1]), Number(args[2])); |
|
|
|
case "LINSERT": |
|
return redis.linsert( |
|
args[0], |
|
args[1].toLowerCase() as "before" | "after", |
|
parseValue(args[2]), |
|
parseValue(args[3]) |
|
); |
|
|
|
case "LPOS": |
|
return redis.lpos(args[0], parseValue(args[1])); |
|
|
|
case "LMOVE": |
|
return redis.lmove( |
|
args[0], |
|
args[1], |
|
args[2].toUpperCase() as "LEFT" | "RIGHT", |
|
args[3].toUpperCase() as "LEFT" | "RIGHT" |
|
); |
|
|
|
// SET COMMANDS |
|
case "SADD": |
|
return redis.sadd(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "SREM": |
|
return redis.srem(args[0], ...args.slice(1).map(parseValue)); |
|
|
|
case "SMEMBERS": |
|
return redis.smembers(args[0]); |
|
|
|
case "SISMEMBER": |
|
return redis.sismember(args[0], parseValue(args[1])); |
|
|
|
case "SMISMEMBER": |
|
return redis.smismember(args[0], args.slice(1).map(parseValue)); |
|
|
|
case "SCARD": |
|
return redis.scard(args[0]); |
|
|
|
case "SPOP": |
|
return args.length > 1 ? redis.spop(args[0], Number(args[1])) : redis.spop(args[0]); |
|
|
|
case "SRANDMEMBER": |
|
return args.length > 1 ? redis.srandmember(args[0], Number(args[1])) : redis.srandmember(args[0]); |
|
|
|
case "SINTER": |
|
return redis.sinter(...args); |
|
|
|
case "SINTERSTORE": |
|
return redis.sinterstore(args[0], ...args.slice(1)); |
|
|
|
case "SUNION": |
|
return redis.sunion(...args); |
|
|
|
case "SUNIONSTORE": |
|
return redis.sunionstore(args[0], ...args.slice(1)); |
|
|
|
case "SDIFF": |
|
return redis.sdiff(...args); |
|
|
|
case "SDIFFSTORE": |
|
return redis.sdiffstore(args[0], ...args.slice(1)); |
|
|
|
case "SMOVE": |
|
return redis.smove(args[0], args[1], parseValue(args[2])); |
|
|
|
case "SSCAN": { |
|
const cursor = Number(args[1]) || 0; |
|
const scanOpts: { match?: string; count?: number } = {}; |
|
for (let i = 2; i < args.length; i++) { |
|
if (args[i].toUpperCase() === "MATCH" && i + 1 < args.length) scanOpts.match = args[++i]; |
|
if (args[i].toUpperCase() === "COUNT" && i + 1 < args.length) scanOpts.count = Number(args[++i]); |
|
} |
|
return redis.sscan(args[0], cursor, Object.keys(scanOpts).length > 0 ? scanOpts : undefined); |
|
} |
|
|
|
// SORTED SET COMMANDS |
|
case "ZADD": { |
|
const zaddOpts = buildZaddOptions(); |
|
const members = scoreMemberPairs(args.slice(1)); |
|
return zaddOpts |
|
? redis.zadd(args[0], zaddOpts, ...members) |
|
: redis.zadd(args[0], ...members); |
|
} |
|
|
|
case "ZREM": |
|
return redis.zrem(args[0], ...args.slice(1)); |
|
|
|
case "ZSCORE": |
|
return redis.zscore(args[0], args[1]); |
|
|
|
case "ZMSCORE": |
|
return redis.zmscore(args[0], ...args.slice(1)); |
|
|
|
case "ZRANK": |
|
return redis.zrank(args[0], args[1]); |
|
|
|
case "ZREVRANK": |
|
return redis.zrevrank(args[0], args[1]); |
|
|
|
case "ZRANGE": { |
|
const opts = buildZrangeOptions(); |
|
return opts |
|
? redis.zrange(args[0], args[1], args[2], opts) |
|
: redis.zrange(args[0], args[1], args[2]); |
|
} |
|
|
|
case "ZRANGEBYSCORE": { |
|
const opts: { withScores?: boolean; offset?: number; count?: number } = {}; |
|
if (values.withscores) opts.withScores = true; |
|
if (values.limit) { |
|
const [offset, count] = values.limit.split(",").map(Number); |
|
opts.offset = offset; |
|
opts.count = count; |
|
} |
|
return Object.keys(opts).length > 0 |
|
? redis.zrange(args[0], args[1], args[2], { byScore: true, ...opts }) |
|
: redis.zrange(args[0], args[1], args[2], { byScore: true }); |
|
} |
|
|
|
case "ZREVRANGE": { |
|
const opts = buildZrangeOptions(); |
|
return redis.zrange(args[0], args[1], args[2], { rev: true, ...opts }); |
|
} |
|
|
|
case "ZREVRANGEBYSCORE": { |
|
const opts: { withScores?: boolean; offset?: number; count?: number } = {}; |
|
if (values.withscores) opts.withScores = true; |
|
if (values.limit) { |
|
const [offset, count] = values.limit.split(",").map(Number); |
|
opts.offset = offset; |
|
opts.count = count; |
|
} |
|
return redis.zrange(args[0], args[2], args[1], { byScore: true, rev: true, ...opts }); |
|
} |
|
|
|
case "ZCARD": |
|
return redis.zcard(args[0]); |
|
|
|
case "ZCOUNT": |
|
return redis.zcount(args[0], args[1], args[2]); |
|
|
|
case "ZINCRBY": |
|
return redis.zincrby(args[0], Number(args[1]), args[2]); |
|
|
|
case "ZPOPMIN": |
|
return args.length > 1 ? redis.zpopmin(args[0], Number(args[1])) : redis.zpopmin(args[0]); |
|
|
|
case "ZPOPMAX": |
|
return args.length > 1 ? redis.zpopmax(args[0], Number(args[1])) : redis.zpopmax(args[0]); |
|
|
|
case "ZREMRANGEBYRANK": |
|
return redis.zremrangebyrank(args[0], Number(args[1]), Number(args[2])); |
|
|
|
case "ZREMRANGEBYSCORE": |
|
return redis.zremrangebyscore(args[0], args[1], args[2]); |
|
|
|
case "ZINTERSTORE": |
|
return redis.zinterstore(args[0], Number(args[1]), ...args.slice(2)); |
|
|
|
case "ZUNIONSTORE": |
|
return redis.zunionstore(args[0], Number(args[1]), ...args.slice(2)); |
|
|
|
case "ZSCAN": { |
|
const cursor = Number(args[1]) || 0; |
|
const scanOpts: { match?: string; count?: number } = {}; |
|
for (let i = 2; i < args.length; i++) { |
|
if (args[i].toUpperCase() === "MATCH" && i + 1 < args.length) scanOpts.match = args[++i]; |
|
if (args[i].toUpperCase() === "COUNT" && i + 1 < args.length) scanOpts.count = Number(args[++i]); |
|
} |
|
return redis.zscan(args[0], cursor, Object.keys(scanOpts).length > 0 ? scanOpts : undefined); |
|
} |
|
|
|
// KEY COMMANDS |
|
case "DEL": |
|
return redis.del(...args); |
|
|
|
case "UNLINK": |
|
return redis.unlink(...args); |
|
|
|
case "EXISTS": |
|
return redis.exists(...args); |
|
|
|
case "EXPIRE": |
|
return redis.expire(args[0], Number(args[1])); |
|
|
|
case "EXPIREAT": |
|
return redis.expireat(args[0], Number(args[1])); |
|
|
|
case "PEXPIRE": |
|
return redis.pexpire(args[0], Number(args[1])); |
|
|
|
case "PEXPIREAT": |
|
return redis.pexpireat(args[0], Number(args[1])); |
|
|
|
case "TTL": |
|
return redis.ttl(args[0]); |
|
|
|
case "PTTL": |
|
return redis.pttl(args[0]); |
|
|
|
case "PERSIST": |
|
return redis.persist(args[0]); |
|
|
|
case "KEYS": |
|
return redis.keys(args[0]); |
|
|
|
case "SCAN": { |
|
const { cursor, options } = parseScanArgs(args); |
|
return options ? redis.scan(cursor, options) : redis.scan(cursor); |
|
} |
|
|
|
case "TYPE": |
|
return redis.type(args[0]); |
|
|
|
case "RENAME": |
|
return redis.rename(args[0], args[1]); |
|
|
|
case "RENAMENX": |
|
return redis.renamenx(args[0], args[1]); |
|
|
|
case "COPY": |
|
return redis.copy(args[0], args[1]); |
|
|
|
case "DUMP": |
|
return redis.dump(args[0]); |
|
|
|
case "OBJECT": { |
|
const subcmd = args[0].toUpperCase(); |
|
if (subcmd === "ENCODING") return redis.objectEncoding(args[1]); |
|
if (subcmd === "FREQ") return redis.objectFreq(args[1]); |
|
if (subcmd === "IDLETIME") return redis.objectIdletime(args[1]); |
|
if (subcmd === "REFCOUNT") return redis.objectRefcount(args[1]); |
|
throw new Error(`Unknown OBJECT subcommand: ${subcmd}`); |
|
} |
|
|
|
case "RANDOMKEY": |
|
return redis.randomkey(); |
|
|
|
case "TOUCH": |
|
return redis.touch(...args); |
|
|
|
// SERVER COMMANDS |
|
case "DBSIZE": |
|
return redis.dbsize(); |
|
|
|
case "FLUSHDB": |
|
return redis.flushdb(); |
|
|
|
case "FLUSHALL": |
|
return redis.flushall(); |
|
|
|
case "PING": |
|
return args.length > 0 ? redis.ping(args[0]) : redis.ping(); |
|
|
|
case "ECHO": |
|
return redis.echo(args[0]); |
|
|
|
case "TIME": |
|
return redis.time(); |
|
|
|
case "INFO": |
|
return redis.info(args[0]); |
|
|
|
// JSON COMMANDS (if using Upstash JSON) |
|
case "JSON.SET": |
|
return (redis as any).json.set(args[0], args[1], parseValue(args[2])); |
|
|
|
case "JSON.GET": |
|
return (redis as any).json.get(args[0], args.length > 1 ? args[1] : "$"); |
|
|
|
case "JSON.DEL": |
|
return (redis as any).json.del(args[0], args.length > 1 ? args[1] : "$"); |
|
|
|
default: |
|
throw new Error(`Unknown or unsupported command: ${cmd}`); |
|
} |
|
} |
|
|
|
try { |
|
const result = await execute(); |
|
|
|
if (result === null || result === undefined) { |
|
console.log("(nil)"); |
|
} else if (typeof result === "object") { |
|
console.log(JSON.stringify(result, null, 2)); |
|
} else { |
|
console.log(result); |
|
} |
|
} catch (err) { |
|
console.error(`Error: ${err instanceof Error ? err.message : err}`); |
|
process.exit(1); |
|
} |
