"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// platforms/fastly.ts
var fastly_exports = {};
__export(fastly_exports, {
Redis: () => Redis2,
errors: () => error_exports
});
module.exports = __toCommonJS(fastly_exports);
// pkg/error.ts
var error_exports = {};
__export(error_exports, {
UpstashError: () => UpstashError,
UpstashJSONParseError: () => UpstashJSONParseError,
UrlError: () => UrlError
});
var UpstashError = class extends Error {
constructor(message, options) {
super(message, options);
this.name = "UpstashError";
}
};
var UrlError = class extends Error {
constructor(url) {
super(
`Upstash Redis client was passed an invalid URL. You should pass a URL starting with https. Received: "${url}". `
);
this.name = "UrlError";
}
};
var UpstashJSONParseError = class extends UpstashError {
constructor(body, options) {
const truncatedBody = body.length > 200 ? body.slice(0, 200) + "..." : body;
super(`Unable to parse response body: ${truncatedBody}`, options);
this.name = "UpstashJSONParseError";
}
};
// pkg/util.ts
function parseRecursive(obj) {
const parsed = Array.isArray(obj) ? obj.map((o) => {
try {
return parseRecursive(o);
} catch {
return o;
}
}) : JSON.parse(obj);
if (typeof parsed === "number" && parsed.toString() !== obj) {
return obj;
}
return parsed;
}
function parseResponse(result) {
try {
return parseRecursive(result);
} catch {
return result;
}
}
function deserializeScanResponse(result) {
return [result[0], ...parseResponse(result.slice(1))];
}
function deserializeScanWithTypesResponse(result) {
const [cursor, keys] = result;
const parsedKeys = [];
for (let i = 0; i < keys.length; i += 2) {
parsedKeys.push({ key: keys[i], type: keys[i + 1] });
}
return [cursor, parsedKeys];
}
function mergeHeaders(...headers) {
const merged = {};
for (const header of headers) {
if (!header) continue;
for (const [key, value] of Object.entries(header)) {
if (value !== void 0 && value !== null) {
merged[key] = value;
}
}
}
return merged;
}
function kvArrayToObject(v) {
if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
if (!Array.isArray(v)) return {};
const obj = {};
for (let i = 0; i < v.length; i += 2) {
if (typeof v[i] === "string") obj[v[i]] = v[i + 1];
}
return obj;
}
// pkg/http.ts
var MAX_BUFFER_SIZE = 1024 * 1024;
var HttpClient = class {
baseUrl;
headers;
options;
readYourWrites;
upstashSyncToken = "";
hasCredentials;
retry;
constructor(config) {
this.options = {
backend: config.options?.backend,
agent: config.agent,
responseEncoding: config.responseEncoding ?? "base64",
// default to base64
cache: config.cache,
signal: config.signal,
keepAlive: config.keepAlive ?? true
};
this.upstashSyncToken = "";
this.readYourWrites = config.readYourWrites ?? true;
this.baseUrl = (config.baseUrl || "").replace(/\/$/, "");
const urlRegex = /^https?:\/\/[^\s#$./?].\S*$/;
if (this.baseUrl && !urlRegex.test(this.baseUrl)) {
throw new UrlError(this.baseUrl);
}
this.headers = {
"Content-Type": "application/json",
...config.headers
};
this.hasCredentials = Boolean(this.baseUrl && this.headers.authorization.split(" ")[1]);
if (this.options.responseEncoding === "base64") {
this.headers["Upstash-Encoding"] = "base64";
}
this.retry = typeof config.retry === "boolean" && !config.retry ? {
attempts: 1,
backoff: () => 0
} : {
attempts: config.retry?.retries ?? 5,
backoff: config.retry?.backoff ?? ((retryCount) => Math.exp(retryCount) * 50)
};
}
mergeTelemetry(telemetry) {
this.headers = merge(this.headers, "Upstash-Telemetry-Runtime", telemetry.runtime);
this.headers = merge(this.headers, "Upstash-Telemetry-Platform", telemetry.platform);
this.headers = merge(this.headers, "Upstash-Telemetry-Sdk", telemetry.sdk);
}
async request(req) {
const requestHeaders = mergeHeaders(this.headers, req.headers ?? {});
const requestUrl = [this.baseUrl, ...req.path ?? []].join("/");
const isEventStream = requestHeaders.Accept === "text/event-stream";
const signal = req.signal ?? this.options.signal;
const isSignalFunction = typeof signal === "function";
const requestOptions = {
//@ts-expect-error this should throw due to bun regression
cache: this.options.cache,
method: "POST",
headers: requestHeaders,
body: JSON.stringify(req.body),
keepalive: this.options.keepAlive,
agent: this.options.agent,
signal: isSignalFunction ? signal() : signal,
/**
* Fastly specific
*/
backend: this.options.backend
};
if (!this.hasCredentials) {
console.warn(
"[Upstash Redis] Redis client was initialized without url or token. Failed to execute command."
);
}
if (this.readYourWrites) {
const newHeader = this.upstashSyncToken;
this.headers["upstash-sync-token"] = newHeader;
}
let res = null;
let error = null;
for (let i = 0; i <= this.retry.attempts; i++) {
try {
res = await fetch(requestUrl, requestOptions);
break;
} catch (error_) {
if (requestOptions.signal?.aborted && isSignalFunction) {
throw error_;
} else if (requestOptions.signal?.aborted) {
const myBlob = new Blob([
JSON.stringify({ result: requestOptions.signal.reason ?? "Aborted" })
]);
const myOptions = {
status: 200,
statusText: requestOptions.signal.reason ?? "Aborted"
};
res = new Response(myBlob, myOptions);
break;
}
error = error_;
if (i < this.retry.attempts) {
await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
}
}
}
if (!res) {
throw error ?? new Error("Exhausted all retries");
}
if (!res.ok) {
let body2;
const rawBody2 = await res.text();
try {
body2 = JSON.parse(rawBody2);
} catch (error2) {
throw new UpstashJSONParseError(rawBody2, { cause: error2 });
}
throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
}
if (this.readYourWrites) {
const headers = res.headers;
this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
}
if (isEventStream && req && req.onMessage && res.body) {
const reader = res.body.getReader();
const decoder = new TextDecoder();
(async () => {
try {
let buffer = "";
while (true) {
const { value, done } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
const lines = buffer.split("\n");
buffer = lines.pop() || "";
if (buffer.length > MAX_BUFFER_SIZE) {
throw new Error("Buffer size exceeded (1MB)");
}
for (const line of lines) {
if (line.startsWith("data: ")) {
const data = line.slice(6);
req.onMessage?.(data);
}
}
}
} catch (error2) {
if (error2 instanceof Error && error2.name === "AbortError") {
} else {
console.error("Stream reading error:", error2);
}
} finally {
try {
await reader.cancel();
} catch {
}
}
})();
return { result: 1 };
}
let body;
const rawBody = await res.text();
try {
body = JSON.parse(rawBody);
} catch (error2) {
throw new UpstashJSONParseError(rawBody, { cause: error2 });
}
if (this.readYourWrites) {
const headers = res.headers;
this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
}
if (this.options.responseEncoding === "base64") {
if (Array.isArray(body)) {
return body.map(({ result: result2, error: error2 }) => ({
result: decode(result2),
error: error2
}));
}
const result = decode(body.result);
return { result, error: body.error };
}
return body;
}
};
function base64decode(b64) {
let dec = "";
try {
const binString = atob(b64);
const size = binString.length;
const bytes = new Uint8Array(size);
for (let i = 0; i < size; i++) {
bytes[i] = binString.charCodeAt(i);
}
dec = new TextDecoder().decode(bytes);
} catch {
dec = b64;
}
return dec;
}
function decode(raw) {
let result = void 0;
switch (typeof raw) {
case "undefined": {
return raw;
}
case "number": {
result = raw;
break;
}
case "object": {
if (Array.isArray(raw)) {
result = raw.map(
(v) => typeof v === "string" ? base64decode(v) : Array.isArray(v) ? v.map((element) => decode(element)) : v
);
} else {
result = null;
}
break;
}
case "string": {
result = raw === "OK" ? "OK" : base64decode(raw);
break;
}
default: {
break;
}
}
return result;
}
function merge(obj, key, value) {
if (!value) {
return obj;
}
obj[key] = obj[key] ? [obj[key], value].join(",") : value;
return obj;
}
// pkg/auto-pipeline.ts
var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
"scan",
"keys",
"flushdb",
"flushall",
"dbsize",
"hscan",
"hgetall",
"hkeys",
"lrange",
"sscan",
"smembers",
"xrange",
"xrevrange",
"zscan",
"zrange",
"exec"
]);
function createAutoPipelineProxy(_redis, namespace = "root") {
const redis = _redis;
if (!redis.autoPipelineExecutor) {
redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
}
return new Proxy(redis, {
get: (redis2, command) => {
if (command === "pipelineCounter") {
return redis2.autoPipelineExecutor.pipelineCounter;
}
if (namespace === "root" && command === "json") {
return createAutoPipelineProxy(redis2, "json");
}
if (namespace === "root" && command === "functions") {
return createAutoPipelineProxy(redis2, "functions");
}
if (namespace === "root") {
const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
if (commandInRedisButNotPipeline || isCommandExcluded) {
return redis2[command];
}
}
const pipeline = redis2.autoPipelineExecutor.pipeline;
const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
const isFunction = typeof targetFunction === "function";
if (isFunction) {
return (...args) => {
return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
targetFunction2(...args);
});
};
}
return targetFunction;
}
});
}
var AutoPipelineExecutor = class {
pipelinePromises = /* @__PURE__ */ new WeakMap();
activePipeline = null;
indexInCurrentPipeline = 0;
redis;
pipeline;
// only to make sure that proxy can work
pipelineCounter = 0;
// to keep track of how many times a pipeline was executed
constructor(redis) {
this.redis = redis;
this.pipeline = redis.pipeline();
}
async withAutoPipeline(executeWithPipeline) {
const pipeline = this.activePipeline ?? this.redis.pipeline();
if (!this.activePipeline) {
this.activePipeline = pipeline;
this.indexInCurrentPipeline = 0;
}
const index = this.indexInCurrentPipeline++;
executeWithPipeline(pipeline);
const pipelineDone = this.deferExecution().then(() => {
if (!this.pipelinePromises.has(pipeline)) {
const pipelinePromise = pipeline.exec({ keepErrors: true });
this.pipelineCounter += 1;
this.pipelinePromises.set(pipeline, pipelinePromise);
this.activePipeline = null;
}
return this.pipelinePromises.get(pipeline);
});
const results = await pipelineDone;
const commandResult = results[index];
if (commandResult.error) {
throw new UpstashError(`Command failed: ${commandResult.error}`);
}
return commandResult.result;
}
async deferExecution() {
await Promise.resolve();
await Promise.resolve();
}
};
// pkg/commands/command.ts
var defaultSerializer = (c) => {
switch (typeof c) {
case "string":
case "number":
case "boolean": {
return c;
}
default: {
return JSON.stringify(c);
}
}
};
var Command = class {
command;
serialize;
deserialize;
headers;
path;
onMessage;
isStreaming;
signal;
/**
* Create a new command instance.
*
* You can define a custom `deserialize` function. By default we try to deserialize as json.
*/
constructor(command, opts) {
this.serialize = defaultSerializer;
this.deserialize = opts?.automaticDeserialization === void 0 || opts.automaticDeserialization ? opts?.deserialize ?? parseResponse : (x) => x;
this.command = command.map((c) => this.serialize(c));
this.headers = opts?.headers;
this.path = opts?.path;
this.onMessage = opts?.streamOptions?.onMessage;
this.isStreaming = opts?.streamOptions?.isStreaming ?? false;
this.signal = opts?.streamOptions?.signal;
if (opts?.latencyLogging) {
const originalExec = this.exec.bind(this);
this.exec = async (client) => {
const start = performance.now();
const result = await originalExec(client);
const end = performance.now();
const loggerResult = (end - start).toFixed(2);
console.log(
`Latency for \x1B[38;2;19;185;39m${this.command[0].toString().toUpperCase()}\x1B[0m: \x1B[38;2;0;255;255m${loggerResult} ms\x1B[0m`
);
return result;
};
}
}
/**
* Execute the command using a client.
*/
async exec(client) {
const { result, error } = await client.request({
body: this.command,
path: this.path,
upstashSyncToken: client.upstashSyncToken,
headers: this.headers,
onMessage: this.onMessage,
isStreaming: this.isStreaming,
signal: this.signal
});
if (error) {
throw new UpstashError(error);
}
if (result === void 0) {
throw new TypeError("Request did not return a result");
}
return this.deserialize(result);
}
};
// pkg/commands/append.ts
var AppendCommand = class extends Command {
constructor(cmd, opts) {
super(["append", ...cmd], opts);
}
};
// pkg/commands/bitcount.ts
var BitCountCommand = class extends Command {
constructor([key, start, end], opts) {
const command = ["bitcount", key];
if (typeof start === "number") {
command.push(start);
}
if (typeof end === "number") {
command.push(end);
}
super(command, opts);
}
};
// pkg/commands/bitfield.ts
var BitFieldCommand = class {
constructor(args, client, opts, execOperation = (command) => command.exec(this.client)) {
this.client = client;
this.opts = opts;
this.execOperation = execOperation;
this.command = ["bitfield", ...args];
}
command;
chain(...args) {
this.command.push(...args);
return this;
}
get(...args) {
return this.chain("get", ...args);
}
set(...args) {
return this.chain("set", ...args);
}
incrby(...args) {
return this.chain("incrby", ...args);
}
overflow(overflow) {
return this.chain("overflow", overflow);
}
exec() {
const command = new Command(this.command, this.opts);
return this.execOperation(command);
}
};
// pkg/commands/bitop.ts
var BitOpCommand = class extends Command {
constructor(cmd, opts) {
super(["bitop", ...cmd], opts);
}
};
// pkg/commands/bitpos.ts
var BitPosCommand = class extends Command {
constructor(cmd, opts) {
super(["bitpos", ...cmd], opts);
}
};
// pkg/commands/copy.ts
var CopyCommand = class extends Command {
constructor([key, destinationKey, opts], commandOptions) {
super(["COPY", key, destinationKey, ...opts?.replace ? ["REPLACE"] : []], {
...commandOptions,
deserialize(result) {
if (result > 0) {
return "COPIED";
}
return "NOT_COPIED";
}
});
}
};
// pkg/commands/dbsize.ts
var DBSizeCommand = class extends Command {
constructor(opts) {
super(["dbsize"], opts);
}
};
// pkg/commands/decr.ts
var DecrCommand = class extends Command {
constructor(cmd, opts) {
super(["decr", ...cmd], opts);
}
};
// pkg/commands/decrby.ts
var DecrByCommand = class extends Command {
constructor(cmd, opts) {
super(["decrby", ...cmd], opts);
}
};
// pkg/commands/del.ts
var DelCommand = class extends Command {
constructor(cmd, opts) {
super(["del", ...cmd], opts);
}
};
// pkg/commands/echo.ts
var EchoCommand = class extends Command {
constructor(cmd, opts) {
super(["echo", ...cmd], opts);
}
};
// pkg/commands/evalRo.ts
var EvalROCommand = class extends Command {
constructor([script, keys, args], opts) {
super(["eval_ro", script, keys.length, ...keys, ...args ?? []], opts);
}
};
// pkg/commands/eval.ts
var EvalCommand = class extends Command {
constructor([script, keys, args], opts) {
super(["eval", script, keys.length, ...keys, ...args ?? []], opts);
}
};
// pkg/commands/evalshaRo.ts
var EvalshaROCommand = class extends Command {
constructor([sha, keys, args], opts) {
super(["evalsha_ro", sha, keys.length, ...keys, ...args ?? []], opts);
}
};
// pkg/commands/evalsha.ts
var EvalshaCommand = class extends Command {
constructor([sha, keys, args], opts) {
super(["evalsha", sha, keys.length, ...keys, ...args ?? []], opts);
}
};
// pkg/commands/exec.ts
var ExecCommand = class extends Command {
constructor(cmd, opts) {
const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
super(normalizedCmd, opts);
}
};
// pkg/commands/exists.ts
var ExistsCommand = class extends Command {
constructor(cmd, opts) {
super(["exists", ...cmd], opts);
}
};
// pkg/commands/expire.ts
var ExpireCommand = class extends Command {
constructor(cmd, opts) {
super(["expire", ...cmd.filter(Boolean)], opts);
}
};
// pkg/commands/expireat.ts
var ExpireAtCommand = class extends Command {
constructor(cmd, opts) {
super(["expireat", ...cmd], opts);
}
};
// pkg/commands/fcall.ts
var FCallCommand = class extends Command {
constructor([functionName, keys, args], opts) {
super(["fcall", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
}
};
// pkg/commands/fcall_ro.ts
var FCallRoCommand = class extends Command {
constructor([functionName, keys, args], opts) {
super(
["fcall_ro", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []],
opts
);
}
};
// pkg/commands/flushall.ts
var FlushAllCommand = class extends Command {
constructor(args, opts) {
const command = ["flushall"];
if (args && args.length > 0 && args[0].async) {
command.push("async");
}
super(command, opts);
}
};
// pkg/commands/flushdb.ts
var FlushDBCommand = class extends Command {
constructor([opts], cmdOpts) {
const command = ["flushdb"];
if (opts?.async) {
command.push("async");
}
super(command, cmdOpts);
}
};
// pkg/commands/function_delete.ts
var FunctionDeleteCommand = class extends Command {
constructor([libraryName], opts) {
super(["function", "delete", libraryName], opts);
}
};
// pkg/commands/function_flush.ts
var FunctionFlushCommand = class extends Command {
constructor(opts) {
super(["function", "flush"], opts);
}
};
// pkg/commands/function_list.ts
var FunctionListCommand = class extends Command {
constructor([args], opts) {
const command = ["function", "list"];
if (args?.libraryName) {
command.push("libraryname", args.libraryName);
}
if (args?.withCode) {
command.push("withcode");
}
super(command, { deserialize, ...opts });
}
};
function deserialize(result) {
if (!Array.isArray(result)) return [];
return result.map((libRaw) => {
const lib = kvArrayToObject(libRaw);
const functionsParsed = lib.functions.map(
(fnRaw) => kvArrayToObject(fnRaw)
);
return {
libraryName: lib.library_name,
engine: lib.engine,
functions: functionsParsed.map((fn) => ({
name: fn.name,
description: fn.description ?? void 0,
flags: fn.flags
})),
libraryCode: lib.library_code
};
});
}
// pkg/commands/function_load.ts
var FunctionLoadCommand = class extends Command {
constructor([args], opts) {
super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
}
};
// pkg/commands/function_stats.ts
var FunctionStatsCommand = class extends Command {
constructor(opts) {
super(["function", "stats"], { deserialize: deserialize2, ...opts });
}
};
function deserialize2(result) {
const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
const parsedEngines = Object.fromEntries(
Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)])
);
const final = {
engines: Object.fromEntries(
Object.entries(parsedEngines).map(([key, value]) => [
key,
{
librariesCount: value.libraries_count,
functionsCount: value.functions_count
}
])
)
};
return final;
}
// pkg/commands/geo_add.ts
var GeoAddCommand = class extends Command {
constructor([key, arg1, ...arg2], opts) {
const command = ["geoadd", key];
if ("nx" in arg1 && arg1.nx) {
command.push("nx");
} else if ("xx" in arg1 && arg1.xx) {
command.push("xx");
}
if ("ch" in arg1 && arg1.ch) {
command.push("ch");
}
if ("latitude" in arg1 && arg1.latitude) {
command.push(arg1.longitude, arg1.latitude, arg1.member);
}
command.push(
...arg2.flatMap(({ latitude, longitude, member }) => [longitude, latitude, member])
);
super(command, opts);
}
};
// pkg/commands/geo_dist.ts
var GeoDistCommand = class extends Command {
constructor([key, member1, member2, unit = "M"], opts) {
super(["GEODIST", key, member1, member2, unit], opts);
}
};
// pkg/commands/geo_hash.ts
var GeoHashCommand = class extends Command {
constructor(cmd, opts) {
const [key] = cmd;
const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
super(["GEOHASH", key, ...members], opts);
}
};
// pkg/commands/geo_pos.ts
var GeoPosCommand = class extends Command {
constructor(cmd, opts) {
const [key] = cmd;
const members = Array.isArray(cmd[1]) ? cmd[1] : cmd.slice(1);
super(["GEOPOS", key, ...members], {
deserialize: (result) => transform(result),
...opts
});
}
};
function transform(result) {
const final = [];
for (const pos of result) {
if (!pos?.[0] || !pos?.[1]) {
continue;
}
final.push({ lng: Number.parseFloat(pos[0]), lat: Number.parseFloat(pos[1]) });
}
return final;
}
// pkg/commands/geo_search.ts
var GeoSearchCommand = class extends Command {
constructor([key, centerPoint, shape, order, opts], commandOptions) {
const command = ["GEOSEARCH", key];
if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
command.push(centerPoint.type, centerPoint.member);
}
if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
}
if (shape.type === "BYRADIUS" || shape.type === "byradius") {
command.push(shape.type, shape.radius, shape.radiusType);
}
if (shape.type === "BYBOX" || shape.type === "bybox") {
command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
}
command.push(order);
if (opts?.count) {
command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
}
const transform2 = (result) => {
if (!opts?.withCoord && !opts?.withDist && !opts?.withHash) {
return result.map((member) => {
try {
return { member: JSON.parse(member) };
} catch {
return { member };
}
});
}
return result.map((members) => {
let counter = 1;
const obj = {};
try {
obj.member = JSON.parse(members[0]);
} catch {
obj.member = members[0];
}
if (opts.withDist) {
obj.dist = Number.parseFloat(members[counter++]);
}
if (opts.withHash) {
obj.hash = members[counter++].toString();
}
if (opts.withCoord) {
obj.coord = {
long: Number.parseFloat(members[counter][0]),
lat: Number.parseFloat(members[counter][1])
};
}
return obj;
});
};
super(
[
...command,
...opts?.withCoord ? ["WITHCOORD"] : [],
...opts?.withDist ? ["WITHDIST"] : [],
...opts?.withHash ? ["WITHHASH"] : []
],
{
deserialize: transform2,
...commandOptions
}
);
}
};
// pkg/commands/geo_search_store.ts
var GeoSearchStoreCommand = class extends Command {
constructor([destination, key, centerPoint, shape, order, opts], commandOptions) {
const command = ["GEOSEARCHSTORE", destination, key];
if (centerPoint.type === "FROMMEMBER" || centerPoint.type === "frommember") {
command.push(centerPoint.type, centerPoint.member);
}
if (centerPoint.type === "FROMLONLAT" || centerPoint.type === "fromlonlat") {
command.push(centerPoint.type, centerPoint.coordinate.lon, centerPoint.coordinate.lat);
}
if (shape.type === "BYRADIUS" || shape.type === "byradius") {
command.push(shape.type, shape.radius, shape.radiusType);
}
if (shape.type === "BYBOX" || shape.type === "bybox") {
command.push(shape.type, shape.rect.width, shape.rect.height, shape.rectType);
}
command.push(order);
if (opts?.count) {
command.push("COUNT", opts.count.limit, ...opts.count.any ? ["ANY"] : []);
}
super([...command, ...opts?.storeDist ? ["STOREDIST"] : []], commandOptions);
}
};
// pkg/commands/get.ts
var GetCommand = class extends Command {
constructor(cmd, opts) {
super(["get", ...cmd], opts);
}
};
// pkg/commands/getbit.ts
var GetBitCommand = class extends Command {
constructor(cmd, opts) {
super(["getbit", ...cmd], opts);
}
};
// pkg/commands/getdel.ts
var GetDelCommand = class extends Command {
constructor(cmd, opts) {
super(["getdel", ...cmd], opts);
}
};
// pkg/commands/getex.ts
var GetExCommand = class extends Command {
constructor([key, opts], cmdOpts) {
const command = ["getex", key];
if (opts) {
if ("ex" in opts && typeof opts.ex === "number") {
command.push("ex", opts.ex);
} else if ("px" in opts && typeof opts.px === "number") {
command.push("px", opts.px);
} else if ("exat" in opts && typeof opts.exat === "number") {
command.push("exat", opts.exat);
} else if ("pxat" in opts && typeof opts.pxat === "number") {
command.push("pxat", opts.pxat);
} else if ("persist" in opts && opts.persist) {
command.push("persist");
}
}
super(command, cmdOpts);
}
};
// pkg/commands/getrange.ts
var GetRangeCommand = class extends Command {
constructor(cmd, opts) {
super(["getrange", ...cmd], opts);
}
};
// pkg/commands/getset.ts
var GetSetCommand = class extends Command {
constructor(cmd, opts) {
super(["getset", ...cmd], opts);
}
};
// pkg/commands/hdel.ts
var HDelCommand = class extends Command {
constructor(cmd, opts) {
super(["hdel", ...cmd], opts);
}
};
// pkg/commands/hexists.ts
var HExistsCommand = class extends Command {
constructor(cmd, opts) {
super(["hexists", ...cmd], opts);
}
};
// pkg/commands/hexpire.ts
var HExpireCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields, seconds, option] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(
[
"hexpire",
key,
seconds,
...option ? [option] : [],
"FIELDS",
fieldArray.length,
...fieldArray
],
opts
);
}
};
// pkg/commands/hexpireat.ts
var HExpireAtCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields, timestamp, option] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(
[
"hexpireat",
key,
timestamp,
...option ? [option] : [],
"FIELDS",
fieldArray.length,
...fieldArray
],
opts
);
}
};
// pkg/commands/hexpiretime.ts
var HExpireTimeCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(["hexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
}
};
// pkg/commands/hpersist.ts
var HPersistCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(["hpersist", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
}
};
// pkg/commands/hpexpire.ts
var HPExpireCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields, milliseconds, option] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(
[
"hpexpire",
key,
milliseconds,
...option ? [option] : [],
"FIELDS",
fieldArray.length,
...fieldArray
],
opts
);
}
};
// pkg/commands/hpexpireat.ts
var HPExpireAtCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields, timestamp, option] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(
[
"hpexpireat",
key,
timestamp,
...option ? [option] : [],
"FIELDS",
fieldArray.length,
...fieldArray
],
opts
);
}
};
// pkg/commands/hpexpiretime.ts
var HPExpireTimeCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(["hpexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
}
};
// pkg/commands/hpttl.ts
var HPTtlCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(["hpttl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
}
};
// pkg/commands/hget.ts
var HGetCommand = class extends Command {
constructor(cmd, opts) {
super(["hget", ...cmd], opts);
}
};
// pkg/commands/hgetall.ts
function deserialize3(result) {
if (result.length === 0) {
return null;
}
const obj = {};
for (let i = 0; i < result.length; i += 2) {
const key = result[i];
const value = result[i + 1];
try {
const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(Number(value));
obj[key] = valueIsNumberAndNotSafeInteger ? value : JSON.parse(value);
} catch {
obj[key] = value;
}
}
return obj;
}
var HGetAllCommand = class extends Command {
constructor(cmd, opts) {
super(["hgetall", ...cmd], {
deserialize: (result) => deserialize3(result),
...opts
});
}
};
// pkg/commands/hincrby.ts
var HIncrByCommand = class extends Command {
constructor(cmd, opts) {
super(["hincrby", ...cmd], opts);
}
};
// pkg/commands/hincrbyfloat.ts
var HIncrByFloatCommand = class extends Command {
constructor(cmd, opts) {
super(["hincrbyfloat", ...cmd], opts);
}
};
// pkg/commands/hkeys.ts
var HKeysCommand = class extends Command {
constructor([key], opts) {
super(["hkeys", key], opts);
}
};
// pkg/commands/hlen.ts
var HLenCommand = class extends Command {
constructor(cmd, opts) {
super(["hlen", ...cmd], opts);
}
};
// pkg/commands/hmget.ts
function deserialize4(fields, result) {
if (result.every((field) => field === null)) {
return null;
}
const obj = {};
for (const [i, field] of fields.entries()) {
try {
obj[field] = JSON.parse(result[i]);
} catch {
obj[field] = result[i];
}
}
return obj;
}
var HMGetCommand = class extends Command {
constructor([key, ...fields], opts) {
super(["hmget", key, ...fields], {
deserialize: (result) => deserialize4(fields, result),
...opts
});
}
};
// pkg/commands/hmset.ts
var HMSetCommand = class extends Command {
constructor([key, kv], opts) {
super(["hmset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])], opts);
}
};
// pkg/commands/hrandfield.ts
function deserialize5(result) {
if (result.length === 0) {
return null;
}
const obj = {};
for (let i = 0; i < result.length; i += 2) {
const key = result[i];
const value = result[i + 1];
try {
obj[key] = JSON.parse(value);
} catch {
obj[key] = value;
}
}
return obj;
}
var HRandFieldCommand = class extends Command {
constructor(cmd, opts) {
const command = ["hrandfield", cmd[0]];
if (typeof cmd[1] === "number") {
command.push(cmd[1]);
}
if (cmd[2]) {
command.push("WITHVALUES");
}
super(command, {
// @ts-expect-error to silence compiler
deserialize: cmd[2] ? (result) => deserialize5(result) : opts?.deserialize,
...opts
});
}
};
// pkg/commands/hscan.ts
var HScanCommand = class extends Command {
constructor([key, cursor, cmdOpts], opts) {
const command = ["hscan", key, cursor];
if (cmdOpts?.match) {
command.push("match", cmdOpts.match);
}
if (typeof cmdOpts?.count === "number") {
command.push("count", cmdOpts.count);
}
super(command, {
deserialize: deserializeScanResponse,
...opts
});
}
};
// pkg/commands/hset.ts
var HSetCommand = class extends Command {
constructor([key, kv], opts) {
super(["hset", key, ...Object.entries(kv).flatMap(([field, value]) => [field, value])], opts);
}
};
// pkg/commands/hsetnx.ts
var HSetNXCommand = class extends Command {
constructor(cmd, opts) {
super(["hsetnx", ...cmd], opts);
}
};
// pkg/commands/hstrlen.ts
var HStrLenCommand = class extends Command {
constructor(cmd, opts) {
super(["hstrlen", ...cmd], opts);
}
};
// pkg/commands/httl.ts
var HTtlCommand = class extends Command {
constructor(cmd, opts) {
const [key, fields] = cmd;
const fieldArray = Array.isArray(fields) ? fields : [fields];
super(["httl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
}
};
// pkg/commands/hvals.ts
var HValsCommand = class extends Command {
constructor(cmd, opts) {
super(["hvals", ...cmd], opts);
}
};
// pkg/commands/incr.ts
var IncrCommand = class extends Command {
constructor(cmd, opts) {
super(["incr", ...cmd], opts);
}
};
// pkg/commands/incrby.ts
var IncrByCommand = class extends Command {
constructor(cmd, opts) {
super(["incrby", ...cmd], opts);
}
};
// pkg/commands/incrbyfloat.ts
var IncrByFloatCommand = class extends Command {
constructor(cmd, opts) {
super(["incrbyfloat", ...cmd], opts);
}
};
// pkg/commands/json_arrappend.ts
var JsonArrAppendCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.ARRAPPEND", ...cmd], opts);
}
};
// pkg/commands/json_arrindex.ts
var JsonArrIndexCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.ARRINDEX", ...cmd], opts);
}
};
// pkg/commands/json_arrinsert.ts
var JsonArrInsertCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.ARRINSERT", ...cmd], opts);
}
};
// pkg/commands/json_arrlen.ts
var JsonArrLenCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.ARRLEN", cmd[0], cmd[1] ?? "$"], opts);
}
};
// pkg/commands/json_arrpop.ts
var JsonArrPopCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.ARRPOP", ...cmd], opts);
}
};
// pkg/commands/json_arrtrim.ts
var JsonArrTrimCommand = class extends Command {
constructor(cmd, opts) {
const path = cmd[1] ?? "$";
const start = cmd[2] ?? 0;
const stop = cmd[3] ?? 0;
super(["JSON.ARRTRIM", cmd[0], path, start, stop], opts);
}
};
// pkg/commands/json_clear.ts
var JsonClearCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.CLEAR", ...cmd], opts);
}
};
// pkg/commands/json_del.ts
var JsonDelCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.DEL", ...cmd], opts);
}
};
// pkg/commands/json_forget.ts
var JsonForgetCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.FORGET", ...cmd], opts);
}
};
// pkg/commands/json_get.ts
var JsonGetCommand = class extends Command {
constructor(cmd, opts) {
const command = ["JSON.GET"];
if (typeof cmd[1] === "string") {
command.push(...cmd);
} else {
command.push(cmd[0]);
if (cmd[1]) {
if (cmd[1].indent) {
command.push("INDENT", cmd[1].indent);
}
if (cmd[1].newline) {
command.push("NEWLINE", cmd[1].newline);
}
if (cmd[1].space) {
command.push("SPACE", cmd[1].space);
}
}
command.push(...cmd.slice(2));
}
super(command, opts);
}
};
// pkg/commands/json_merge.ts
var JsonMergeCommand = class extends Command {
constructor(cmd, opts) {
const command = ["JSON.MERGE", ...cmd];
super(command, opts);
}
};
// pkg/commands/json_mget.ts
var JsonMGetCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.MGET", ...cmd[0], cmd[1]], opts);
}
};
// pkg/commands/json_mset.ts
var JsonMSetCommand = class extends Command {
constructor(cmd, opts) {
const command = ["JSON.MSET"];
for (const c of cmd) {
command.push(c.key, c.path, c.value);
}
super(command, opts);
}
};
// pkg/commands/json_numincrby.ts
var JsonNumIncrByCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.NUMINCRBY", ...cmd], opts);
}
};
// pkg/commands/json_nummultby.ts
var JsonNumMultByCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.NUMMULTBY", ...cmd], opts);
}
};
// pkg/commands/json_objkeys.ts
var JsonObjKeysCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.OBJKEYS", ...cmd], opts);
}
};
// pkg/commands/json_objlen.ts
var JsonObjLenCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.OBJLEN", ...cmd], opts);
}
};
// pkg/commands/json_resp.ts
var JsonRespCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.RESP", ...cmd], opts);
}
};
// pkg/commands/json_set.ts
var JsonSetCommand = class extends Command {
constructor(cmd, opts) {
const command = ["JSON.SET", cmd[0], cmd[1], cmd[2]];
if (cmd[3]) {
if (cmd[3].nx) {
command.push("NX");
} else if (cmd[3].xx) {
command.push("XX");
}
}
super(command, opts);
}
};
// pkg/commands/json_strappend.ts
var JsonStrAppendCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.STRAPPEND", ...cmd], opts);
}
};
// pkg/commands/json_strlen.ts
var JsonStrLenCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.STRLEN", ...cmd], opts);
}
};
// pkg/commands/json_toggle.ts
var JsonToggleCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.TOGGLE", ...cmd], opts);
}
};
// pkg/commands/json_type.ts
var JsonTypeCommand = class extends Command {
constructor(cmd, opts) {
super(["JSON.TYPE", ...cmd], opts);
}
};
// pkg/commands/keys.ts
var KeysCommand = class extends Command {
constructor(cmd, opts) {
super(["keys", ...cmd], opts);
}
};
// pkg/commands/lindex.ts
var LIndexCommand = class extends Command {
constructor(cmd, opts) {
super(["lindex", ...cmd], opts);
}
};
// pkg/commands/linsert.ts
var LInsertCommand = class extends Command {
constructor(cmd, opts) {
super(["linsert", ...cmd], opts);
}
};
// pkg/commands/llen.ts
var LLenCommand = class extends Command {
constructor(cmd, opts) {
super(["llen", ...cmd], opts);
}
};
// pkg/commands/lmove.ts
var LMoveCommand = class extends Command {
constructor(cmd, opts) {
super(["lmove", ...cmd], opts);
}
};
// pkg/commands/lmpop.ts
var LmPopCommand = class extends Command {
constructor(cmd, opts) {
const [numkeys, keys, direction, count] = cmd;
super(["LMPOP", numkeys, ...keys, direction, ...count ? ["COUNT", count] : []], opts);
}
};
// pkg/commands/lpop.ts
var LPopCommand = class extends Command {
constructor(cmd, opts) {
super(["lpop", ...cmd], opts);
}
};
// pkg/commands/lpos.ts
var LPosCommand = class extends Command {
constructor(cmd, opts) {
const args = ["lpos", cmd[0], cmd[1]];
if (typeof cmd[2]?.rank === "number") {
args.push("rank", cmd[2].rank);
}
if (typeof cmd[2]?.count === "number") {
args.push("count", cmd[2].count);
}
if (typeof cmd[2]?.maxLen === "number") {
args.push("maxLen", cmd[2].maxLen);
}
super(args, opts);
}
};
// pkg/commands/lpush.ts
var LPushCommand = class extends Command {
constructor(cmd, opts) {
super(["lpush", ...cmd], opts);
}
};
// pkg/commands/lpushx.ts
var LPushXCommand = class extends Command {
constructor(cmd, opts) {
super(["lpushx", ...cmd], opts);
}
};
// pkg/commands/lrange.ts
var LRangeCommand = class extends Command {
constructor(cmd, opts) {
super(["lrange", ...cmd], opts);
}
};
// pkg/commands/lrem.ts
var LRemCommand = class extends Command {
constructor(cmd, opts) {
super(["lrem", ...cmd], opts);
}
};
// pkg/commands/lset.ts
var LSetCommand = class extends Command {
constructor(cmd, opts) {
super(["lset", ...cmd], opts);
}
};
// pkg/commands/ltrim.ts
var LTrimCommand = class extends Command {
constructor(cmd, opts) {
super(["ltrim", ...cmd], opts);
}
};
// pkg/commands/mget.ts
var MGetCommand = class extends Command {
constructor(cmd, opts) {
const keys = Array.isArray(cmd[0]) ? cmd[0] : cmd;
super(["mget", ...keys], opts);
}
};
// pkg/commands/mset.ts
var MSetCommand = class extends Command {
constructor([kv], opts) {
super(["mset", ...Object.entries(kv).flatMap(([key, value]) => [key, value])], opts);
}
};
// pkg/commands/msetnx.ts
var MSetNXCommand = class extends Command {
constructor([kv], opts) {
super(["msetnx", ...Object.entries(kv).flat()], opts);
}
};
// pkg/commands/persist.ts
var PersistCommand = class extends Command {
constructor(cmd, opts) {
super(["persist", ...cmd], opts);
}
};
// pkg/commands/pexpire.ts
var PExpireCommand = class extends Command {
constructor(cmd, opts) {
super(["pexpire", ...cmd], opts);
}
};
// pkg/commands/pexpireat.ts
var PExpireAtCommand = class extends Command {
constructor(cmd, opts) {
super(["pexpireat", ...cmd], opts);
}
};
// pkg/commands/pfadd.ts
var PfAddCommand = class extends Command {
constructor(cmd, opts) {
super(["pfadd", ...cmd], opts);
}
};
// pkg/commands/pfcount.ts
var PfCountCommand = class extends Command {
constructor(cmd, opts) {
super(["pfcount", ...cmd], opts);
}
};
// pkg/commands/pfmerge.ts
var PfMergeCommand = class extends Command {
constructor(cmd, opts) {
super(["pfmerge", ...cmd], opts);
}
};
// pkg/commands/ping.ts
var PingCommand = class extends Command {
constructor(cmd, opts) {
const command = ["ping"];
if (cmd?.[0] !== void 0) {
command.push(cmd[0]);
}
super(command, opts);
}
};
// pkg/commands/psetex.ts
var PSetEXCommand = class extends Command {
constructor(cmd, opts) {
super(["psetex", ...cmd], opts);
}
};
// pkg/commands/pttl.ts
var PTtlCommand = class extends Command {
constructor(cmd, opts) {
super(["pttl", ...cmd], opts);
}
};
// pkg/commands/publish.ts
var PublishCommand = class extends Command {
constructor(cmd, opts) {
super(["publish", ...cmd], opts);
}
};
// pkg/commands/randomkey.ts
var RandomKeyCommand = class extends Command {
constructor(opts) {
super(["randomkey"], opts);
}
};
// pkg/commands/rename.ts
var RenameCommand = class extends Command {
constructor(cmd, opts) {
super(["rename", ...cmd], opts);
}
};
// pkg/commands/renamenx.ts
var RenameNXCommand = class extends Command {
constructor(cmd, opts) {
super(["renamenx", ...cmd], opts);
}
};
// pkg/commands/rpop.ts
var RPopCommand = class extends Command {
constructor(cmd, opts) {
super(["rpop", ...cmd], opts);
}
};
// pkg/commands/rpush.ts
var RPushCommand = class extends Command {
constructor(cmd, opts) {
super(["rpush", ...cmd], opts);
}
};
// pkg/commands/rpushx.ts
var RPushXCommand = class extends Command {
constructor(cmd, opts) {
super(["rpushx", ...cmd], opts);
}
};
// pkg/commands/sadd.ts
var SAddCommand = class extends Command {
constructor(cmd, opts) {
super(["sadd", ...cmd], opts);
}
};
// pkg/commands/scan.ts
var ScanCommand = class extends Command {
constructor([cursor, opts], cmdOpts) {
const command = ["scan", cursor];
if (opts?.match) {
command.push("match", opts.match);
}
if (typeof opts?.count === "number") {
command.push("count", opts.count);
}
if (opts && "withType" in opts && opts.withType === true) {
command.push("withtype");
} else if (opts && "type" in opts && opts.type && opts.type.length > 0) {
command.push("type", opts.type);
}
super(command, {
// @ts-expect-error ignore types here
deserialize: opts?.withType ? deserializeScanWithTypesResponse : deserializeScanResponse,
...cmdOpts
});
}
};
// pkg/commands/scard.ts
var SCardCommand = class extends Command {
constructor(cmd, opts) {
super(["scard", ...cmd], opts);
}
};
// pkg/commands/script_exists.ts
var ScriptExistsCommand = class extends Command {
constructor(hashes, opts) {
super(["script", "exists", ...hashes], {
deserialize: (result) => result,
...opts
});
}
};
// pkg/commands/script_flush.ts
var ScriptFlushCommand = class extends Command {
constructor([opts], cmdOpts) {
const cmd = ["script", "flush"];
if (opts?.sync) {
cmd.push("sync");
} else if (opts?.async) {
cmd.push("async");
}
super(cmd, cmdOpts);
}
};
// pkg/commands/script_load.ts
var ScriptLoadCommand = class extends Command {
constructor(args, opts) {
super(["script", "load", ...args], opts);
}
};
// pkg/commands/sdiff.ts
var SDiffCommand = class extends Command {
constructor(cmd, opts) {
super(["sdiff", ...cmd], opts);
}
};
// pkg/commands/sdiffstore.ts
var SDiffStoreCommand = class extends Command {
constructor(cmd, opts) {
super(["sdiffstore", ...cmd], opts);
}
};
// pkg/commands/set.ts
var SetCommand = class extends Command {
constructor([key, value, opts], cmdOpts) {
const command = ["set", key, value];
if (opts) {
if ("nx" in opts && opts.nx) {
command.push("nx");
} else if ("xx" in opts && opts.xx) {
command.push("xx");
}
if ("get" in opts && opts.get) {
command.push("get");
}
if ("ex" in opts && typeof opts.ex === "number") {
command.push("ex", opts.ex);
} else if ("px" in opts && typeof opts.px === "number") {
command.push("px", opts.px);
} else if ("exat" in opts && typeof opts.exat === "number") {
command.push("exat", opts.exat);
} else if ("pxat" in opts && typeof opts.pxat === "number") {
command.push("pxat", opts.pxat);
} else if ("keepTtl" in opts && opts.keepTtl) {
command.push("keepTtl");
}
}
super(command, cmdOpts);
}
};
// pkg/commands/setbit.ts
var SetBitCommand = class extends Command {
constructor(cmd, opts) {
super(["setbit", ...cmd], opts);
}
};
// pkg/commands/setex.ts
var SetExCommand = class extends Command {
constructor(cmd, opts) {
super(["setex", ...cmd], opts);
}
};
// pkg/commands/setnx.ts
var SetNxCommand = class extends Command {
constructor(cmd, opts) {
super(["setnx", ...cmd], opts);
}
};
// pkg/commands/setrange.ts
var SetRangeCommand = class extends Command {
constructor(cmd, opts) {
super(["setrange", ...cmd], opts);
}
};
// pkg/commands/sinter.ts
var SInterCommand = class extends Command {
constructor(cmd, opts) {
super(["sinter", ...cmd], opts);
}
};
// pkg/commands/sinterstore.ts
var SInterStoreCommand = class extends Command {
constructor(cmd, opts) {
super(["sinterstore", ...cmd], opts);
}
};
// pkg/commands/sismember.ts
var SIsMemberCommand = class extends Command {
constructor(cmd, opts) {
super(["sismember", ...cmd], opts);
}
};
// pkg/commands/smembers.ts
var SMembersCommand = class extends Command {
constructor(cmd, opts) {
super(["smembers", ...cmd], opts);
}
};
// pkg/commands/smismember.ts
var SMIsMemberCommand = class extends Command {
constructor(cmd, opts) {
super(["smismember", cmd[0], ...cmd[1]], opts);
}
};
// pkg/commands/smove.ts
var SMoveCommand = class extends Command {
constructor(cmd, opts) {
super(["smove", ...cmd], opts);
}
};
// pkg/commands/spop.ts
var SPopCommand = class extends Command {
constructor([key, count], opts) {
const command = ["spop", key];
if (typeof count === "number") {
command.push(count);
}
super(command, opts);
}
};
// pkg/commands/srandmember.ts
var SRandMemberCommand = class extends Command {
constructor([key, count], opts) {
const command = ["srandmember", key];
if (typeof count === "number") {
command.push(count);
}
super(command, opts);
}
};
// pkg/commands/srem.ts
var SRemCommand = class extends Command {
constructor(cmd, opts) {
super(["srem", ...cmd], opts);
}
};
// pkg/commands/sscan.ts
var SScanCommand = class extends Command {
constructor([key, cursor, opts], cmdOpts) {
const command = ["sscan", key, cursor];
if (opts?.match) {
command.push("match", opts.match);
}
if (typeof opts?.count === "number") {
command.push("count", opts.count);
}
super(command, {
deserialize: deserializeScanResponse,
...cmdOpts
});
}
};
// pkg/commands/strlen.ts
var StrLenCommand = class extends Command {
constructor(cmd, opts) {
super(["strlen", ...cmd], opts);
}
};
// pkg/commands/sunion.ts
var SUnionCommand = class extends Command {
constructor(cmd, opts) {
super(["sunion", ...cmd], opts);
}
};
// pkg/commands/sunionstore.ts
var SUnionStoreCommand = class extends Command {
constructor(cmd, opts) {
super(["sunionstore", ...cmd], opts);
}
};
// pkg/commands/time.ts
var TimeCommand = class extends Command {
constructor(opts) {
super(["time"], opts);
}
};
// pkg/commands/touch.ts
var TouchCommand = class extends Command {
constructor(cmd, opts) {
super(["touch", ...cmd], opts);
}
};
// pkg/commands/ttl.ts
var TtlCommand = class extends Command {
constructor(cmd, opts) {
super(["ttl", ...cmd], opts);
}
};
// pkg/commands/type.ts
var TypeCommand = class extends Command {
constructor(cmd, opts) {
super(["type", ...cmd], opts);
}
};
// pkg/commands/unlink.ts
var UnlinkCommand = class extends Command {
constructor(cmd, opts) {
super(["unlink", ...cmd], opts);
}
};
// pkg/commands/xack.ts
var XAckCommand = class extends Command {
constructor([key, group, id], opts) {
const ids = Array.isArray(id) ? [...id] : [id];
super(["XACK", key, group, ...ids], opts);
}
};
// pkg/commands/xadd.ts
var XAddCommand = class extends Command {
constructor([key, id, entries, opts], commandOptions) {
const command = ["XADD", key];
if (opts) {
if (opts.nomkStream) {
command.push("NOMKSTREAM");
}
if (opts.trim) {
command.push(opts.trim.type, opts.trim.comparison, opts.trim.threshold);
if (opts.trim.limit !== void 0) {
command.push("LIMIT", opts.trim.limit);
}
}
}
command.push(id);
for (const [k, v] of Object.entries(entries)) {
command.push(k, v);
}
super(command, commandOptions);
}
};
// pkg/commands/xautoclaim.ts
var XAutoClaim = class extends Command {
constructor([key, group, consumer, minIdleTime, start, options], opts) {
const commands = [];
if (options?.count) {
commands.push("COUNT", options.count);
}
if (options?.justId) {
commands.push("JUSTID");
}
super(["XAUTOCLAIM", key, group, consumer, minIdleTime, start, ...commands], opts);
}
};
// pkg/commands/xclaim.ts
var XClaimCommand = class extends Command {
constructor([key, group, consumer, minIdleTime, id, options], opts) {
const ids = Array.isArray(id) ? [...id] : [id];
const commands = [];
if (options?.idleMS) {
commands.push("IDLE", options.idleMS);
}
if (options?.idleMS) {
commands.push("TIME", options.timeMS);
}
if (options?.retryCount) {
commands.push("RETRYCOUNT", options.retryCount);
}
if (options?.force) {
commands.push("FORCE");
}
if (options?.justId) {
commands.push("JUSTID");
}
if (options?.lastId) {
commands.push("LASTID", options.lastId);
}
super(["XCLAIM", key, group, consumer, minIdleTime, ...ids, ...commands], opts);
}
};
// pkg/commands/xdel.ts
var XDelCommand = class extends Command {
constructor([key, ids], opts) {
const cmds = Array.isArray(ids) ? [...ids] : [ids];
super(["XDEL", key, ...cmds], opts);
}
};
// pkg/commands/xgroup.ts
var XGroupCommand = class extends Command {
constructor([key, opts], commandOptions) {
const command = ["XGROUP"];
switch (opts.type) {
case "CREATE": {
command.push("CREATE", key, opts.group, opts.id);
if (opts.options) {
if (opts.options.MKSTREAM) {
command.push("MKSTREAM");
}
if (opts.options.ENTRIESREAD !== void 0) {
command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
}
}
break;
}
case "CREATECONSUMER": {
command.push("CREATECONSUMER", key, opts.group, opts.consumer);
break;
}
case "DELCONSUMER": {
command.push("DELCONSUMER", key, opts.group, opts.consumer);
break;
}
case "DESTROY": {
command.push("DESTROY", key, opts.group);
break;
}
case "SETID": {
command.push("SETID", key, opts.group, opts.id);
if (opts.options?.ENTRIESREAD !== void 0) {
command.push("ENTRIESREAD", opts.options.ENTRIESREAD.toString());
}
break;
}
default: {
throw new Error("Invalid XGROUP");
}
}
super(command, commandOptions);
}
};
// pkg/commands/xinfo.ts
var XInfoCommand = class extends Command {
constructor([key, options], opts) {
const cmds = [];
if (options.type === "CONSUMERS") {
cmds.push("CONSUMERS", key, options.group);
} else {
cmds.push("GROUPS", key);
}
super(["XINFO", ...cmds], opts);
}
};
// pkg/commands/xlen.ts
var XLenCommand = class extends Command {
constructor(cmd, opts) {
super(["XLEN", ...cmd], opts);
}
};
// pkg/commands/xpending.ts
var XPendingCommand = class extends Command {
constructor([key, group, start, end, count, options], opts) {
const consumers = options?.consumer === void 0 ? [] : Array.isArray(options.consumer) ? [...options.consumer] : [options.consumer];
super(
[
"XPENDING",
key,
group,
...options?.idleTime ? ["IDLE", options.idleTime] : [],
start,
end,
count,
...consumers
],
opts
);
}
};
// pkg/commands/xrange.ts
function deserialize6(result) {
const obj = {};
for (const e of result) {
for (let i = 0; i < e.length; i += 2) {
const streamId = e[i];
const entries = e[i + 1];
if (!(streamId in obj)) {
obj[streamId] = {};
}
for (let j = 0; j < entries.length; j += 2) {
const field = entries[j];
const value = entries[j + 1];
try {
obj[streamId][field] = JSON.parse(value);
} catch {
obj[streamId][field] = value;
}
}
}
}
return obj;
}
var XRangeCommand = class extends Command {
constructor([key, start, end, count], opts) {
const command = ["XRANGE", key, start, end];
if (typeof count === "number") {
command.push("COUNT", count);
}
super(command, {
deserialize: (result) => deserialize6(result),
...opts
});
}
};
// pkg/commands/xread.ts
var UNBALANCED_XREAD_ERR = "ERR Unbalanced XREAD list of streams: for each stream key an ID or '$' must be specified";
var XReadCommand = class extends Command {
constructor([key, id, options], opts) {
if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
throw new Error(UNBALANCED_XREAD_ERR);
}
const commands = [];
if (typeof options?.count === "number") {
commands.push("COUNT", options.count);
}
if (typeof options?.blockMS === "number") {
commands.push("BLOCK", options.blockMS);
}
commands.push(
"STREAMS",
...Array.isArray(key) ? [...key] : [key],
...Array.isArray(id) ? [...id] : [id]
);
super(["XREAD", ...commands], opts);
}
};
// pkg/commands/xreadgroup.ts
var UNBALANCED_XREADGROUP_ERR = "ERR Unbalanced XREADGROUP list of streams: for each stream key an ID or '$' must be specified";
var XReadGroupCommand = class extends Command {
constructor([group, consumer, key, id, options], opts) {
if (Array.isArray(key) && Array.isArray(id) && key.length !== id.length) {
throw new Error(UNBALANCED_XREADGROUP_ERR);
}
const commands = [];
if (typeof options?.count === "number") {
commands.push("COUNT", options.count);
}
if (typeof options?.blockMS === "number") {
commands.push("BLOCK", options.blockMS);
}
if (typeof options?.NOACK === "boolean" && options.NOACK) {
commands.push("NOACK");
}
commands.push(
"STREAMS",
...Array.isArray(key) ? [...key] : [key],
...Array.isArray(id) ? [...id] : [id]
);
super(["XREADGROUP", "GROUP", group, consumer, ...commands], opts);
}
};
// pkg/commands/xrevrange.ts
var XRevRangeCommand = class extends Command {
constructor([key, end, start, count], opts) {
const command = ["XREVRANGE", key, end, start];
if (typeof count === "number") {
command.push("COUNT", count);
}
super(command, {
deserialize: (result) => deserialize7(result),
...opts
});
}
};
function deserialize7(result) {
const obj = {};
for (const e of result) {
for (let i = 0; i < e.length; i += 2) {
const streamId = e[i];
const entries = e[i + 1];
if (!(streamId in obj)) {
obj[streamId] = {};
}
for (let j = 0; j < entries.length; j += 2) {
const field = entries[j];
const value = entries[j + 1];
try {
obj[streamId][field] = JSON.parse(value);
} catch {
obj[streamId][field] = value;
}
}
}
}
return obj;
}
// pkg/commands/xtrim.ts
var XTrimCommand = class extends Command {
constructor([key, options], opts) {
const { limit, strategy, threshold, exactness = "~" } = options;
super(["XTRIM", key, strategy, exactness, threshold, ...limit ? ["LIMIT", limit] : []], opts);
}
};
// pkg/commands/zadd.ts
var ZAddCommand = class extends Command {
constructor([key, arg1, ...arg2], opts) {
const command = ["zadd", key];
if ("nx" in arg1 && arg1.nx) {
command.push("nx");
} else if ("xx" in arg1 && arg1.xx) {
command.push("xx");
}
if ("ch" in arg1 && arg1.ch) {
command.push("ch");
}
if ("incr" in arg1 && arg1.incr) {
command.push("incr");
}
if ("lt" in arg1 && arg1.lt) {
command.push("lt");
} else if ("gt" in arg1 && arg1.gt) {
command.push("gt");
}
if ("score" in arg1 && "member" in arg1) {
command.push(arg1.score, arg1.member);
}
command.push(...arg2.flatMap(({ score, member }) => [score, member]));
super(command, opts);
}
};
// pkg/commands/zcard.ts
var ZCardCommand = class extends Command {
constructor(cmd, opts) {
super(["zcard", ...cmd], opts);
}
};
// pkg/commands/zcount.ts
var ZCountCommand = class extends Command {
constructor(cmd, opts) {
super(["zcount", ...cmd], opts);
}
};
// pkg/commands/zincrby.ts
var ZIncrByCommand = class extends Command {
constructor(cmd, opts) {
super(["zincrby", ...cmd], opts);
}
};
// pkg/commands/zinterstore.ts
var ZInterStoreCommand = class extends Command {
constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
const command = ["zinterstore", destination, numKeys];
if (Array.isArray(keyOrKeys)) {
command.push(...keyOrKeys);
} else {
command.push(keyOrKeys);
}
if (opts) {
if ("weights" in opts && opts.weights) {
command.push("weights", ...opts.weights);
} else if ("weight" in opts && typeof opts.weight === "number") {
command.push("weights", opts.weight);
}
if ("aggregate" in opts) {
command.push("aggregate", opts.aggregate);
}
}
super(command, cmdOpts);
}
};
// pkg/commands/zlexcount.ts
var ZLexCountCommand = class extends Command {
constructor(cmd, opts) {
super(["zlexcount", ...cmd], opts);
}
};
// pkg/commands/zpopmax.ts
var ZPopMaxCommand = class extends Command {
constructor([key, count], opts) {
const command = ["zpopmax", key];
if (typeof count === "number") {
command.push(count);
}
super(command, opts);
}
};
// pkg/commands/zpopmin.ts
var ZPopMinCommand = class extends Command {
constructor([key, count], opts) {
const command = ["zpopmin", key];
if (typeof count === "number") {
command.push(count);
}
super(command, opts);
}
};
// pkg/commands/zrange.ts
var ZRangeCommand = class extends Command {
constructor([key, min, max, opts], cmdOpts) {
const command = ["zrange", key, min, max];
if (opts?.byScore) {
command.push("byscore");
}
if (opts?.byLex) {
command.push("bylex");
}
if (opts?.rev) {
command.push("rev");
}
if (opts?.count !== void 0 && opts.offset !== void 0) {
command.push("limit", opts.offset, opts.count);
}
if (opts?.withScores) {
command.push("withscores");
}
super(command, cmdOpts);
}
};
// pkg/commands/zrank.ts
var ZRankCommand = class extends Command {
constructor(cmd, opts) {
super(["zrank", ...cmd], opts);
}
};
// pkg/commands/zrem.ts
var ZRemCommand = class extends Command {
constructor(cmd, opts) {
super(["zrem", ...cmd], opts);
}
};
// pkg/commands/zremrangebylex.ts
var ZRemRangeByLexCommand = class extends Command {
constructor(cmd, opts) {
super(["zremrangebylex", ...cmd], opts);
}
};
// pkg/commands/zremrangebyrank.ts
var ZRemRangeByRankCommand = class extends Command {
constructor(cmd, opts) {
super(["zremrangebyrank", ...cmd], opts);
}
};
// pkg/commands/zremrangebyscore.ts
var ZRemRangeByScoreCommand = class extends Command {
constructor(cmd, opts) {
super(["zremrangebyscore", ...cmd], opts);
}
};
// pkg/commands/zrevrank.ts
var ZRevRankCommand = class extends Command {
constructor(cmd, opts) {
super(["zrevrank", ...cmd], opts);
}
};
// pkg/commands/zscan.ts
var ZScanCommand = class extends Command {
constructor([key, cursor, opts], cmdOpts) {
const command = ["zscan", key, cursor];
if (opts?.match) {
command.push("match", opts.match);
}
if (typeof opts?.count === "number") {
command.push("count", opts.count);
}
super(command, {
deserialize: deserializeScanResponse,
...cmdOpts
});
}
};
// pkg/commands/zscore.ts
var ZScoreCommand = class extends Command {
constructor(cmd, opts) {
super(["zscore", ...cmd], opts);
}
};
// pkg/commands/zunion.ts
var ZUnionCommand = class extends Command {
constructor([numKeys, keyOrKeys, opts], cmdOpts) {
const command = ["zunion", numKeys];
if (Array.isArray(keyOrKeys)) {
command.push(...keyOrKeys);
} else {
command.push(keyOrKeys);
}
if (opts) {
if ("weights" in opts && opts.weights) {
command.push("weights", ...opts.weights);
} else if ("weight" in opts && typeof opts.weight === "number") {
command.push("weights", opts.weight);
}
if ("aggregate" in opts) {
command.push("aggregate", opts.aggregate);
}
if (opts.withScores) {
command.push("withscores");
}
}
super(command, cmdOpts);
}
};
// pkg/commands/zunionstore.ts
var ZUnionStoreCommand = class extends Command {
constructor([destination, numKeys, keyOrKeys, opts], cmdOpts) {
const command = ["zunionstore", destination, numKeys];
if (Array.isArray(keyOrKeys)) {
command.push(...keyOrKeys);
} else {
command.push(keyOrKeys);
}
if (opts) {
if ("weights" in opts && opts.weights) {
command.push("weights", ...opts.weights);
} else if ("weight" in opts && typeof opts.weight === "number") {
command.push("weights", opts.weight);
}
if ("aggregate" in opts) {
command.push("aggregate", opts.aggregate);
}
}
super(command, cmdOpts);
}
};
// pkg/commands/psubscribe.ts
var PSubscribeCommand = class extends Command {
constructor(cmd, opts) {
const sseHeaders = {
Accept: "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive"
};
super([], {
...opts,
headers: sseHeaders,
path: ["psubscribe", ...cmd],
streamOptions: {
isStreaming: true,
onMessage: opts?.streamOptions?.onMessage,
signal: opts?.streamOptions?.signal
}
});
}
};
// pkg/commands/subscribe.ts
var Subscriber = class extends EventTarget {
subscriptions;
client;
listeners;
opts;
constructor(client, channels, isPattern = false, opts) {
super();
this.client = client;
this.subscriptions = /* @__PURE__ */ new Map();
this.listeners = /* @__PURE__ */ new Map();
this.opts = opts;
for (const channel of channels) {
if (isPattern) {
this.subscribeToPattern(channel);
} else {
this.subscribeToChannel(channel);
}
}
}
subscribeToChannel(channel) {
const controller = new AbortController();
const command = new SubscribeCommand([channel], {
streamOptions: {
signal: controller.signal,
onMessage: (data) => this.handleMessage(data, false)
}
});
command.exec(this.client).catch((error) => {
if (error.name !== "AbortError") {
this.dispatchToListeners("error", error);
}
});
this.subscriptions.set(channel, {
command,
controller,
isPattern: false
});
}
subscribeToPattern(pattern) {
const controller = new AbortController();
const command = new PSubscribeCommand([pattern], {
streamOptions: {
signal: controller.signal,
onMessage: (data) => this.handleMessage(data, true)
}
});
command.exec(this.client).catch((error) => {
if (error.name !== "AbortError") {
this.dispatchToListeners("error", error);
}
});
this.subscriptions.set(pattern, {
command,
controller,
isPattern: true
});
}
handleMessage(data, isPattern) {
const messageData = data.replace(/^data:\s*/, "");
const firstCommaIndex = messageData.indexOf(",");
const secondCommaIndex = messageData.indexOf(",", firstCommaIndex + 1);
const thirdCommaIndex = isPattern ? messageData.indexOf(",", secondCommaIndex + 1) : -1;
if (firstCommaIndex !== -1 && secondCommaIndex !== -1) {
const type = messageData.slice(0, firstCommaIndex);
if (isPattern && type === "pmessage" && thirdCommaIndex !== -1) {
const pattern = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
const channel = messageData.slice(secondCommaIndex + 1, thirdCommaIndex);
const messageStr = messageData.slice(thirdCommaIndex + 1);
try {
const message = this.opts?.automaticDeserialization === false ? messageStr : JSON.parse(messageStr);
this.dispatchToListeners("pmessage", { pattern, channel, message });
this.dispatchToListeners(`pmessage:${pattern}`, { pattern, channel, message });
} catch (error) {
this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
}
} else {
const channel = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
const messageStr = messageData.slice(secondCommaIndex + 1);
try {
if (type === "subscribe" || type === "psubscribe" || type === "unsubscribe" || type === "punsubscribe") {
const count = Number.parseInt(messageStr);
this.dispatchToListeners(type, count);
} else {
const message = this.opts?.automaticDeserialization === false ? messageStr : parseWithTryCatch(messageStr);
this.dispatchToListeners(type, { channel, message });
this.dispatchToListeners(`${type}:${channel}`, { channel, message });
}
} catch (error) {
this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
}
}
}
}
dispatchToListeners(type, data) {
const listeners = this.listeners.get(type);
if (listeners) {
for (const listener of listeners) {
listener(data);
}
}
}
on(type, listener) {
if (!this.listeners.has(type)) {
this.listeners.set(type, /* @__PURE__ */ new Set());
}
this.listeners.get(type)?.add(listener);
}
removeAllListeners() {
this.listeners.clear();
}
async unsubscribe(channels) {
if (channels) {
for (const channel of channels) {
const subscription = this.subscriptions.get(channel);
if (subscription) {
try {
subscription.controller.abort();
} catch {
}
this.subscriptions.delete(channel);
}
}
} else {
for (const subscription of this.subscriptions.values()) {
try {
subscription.controller.abort();
} catch {
}
}
this.subscriptions.clear();
this.removeAllListeners();
}
}
getSubscribedChannels() {
return [...this.subscriptions.keys()];
}
};
var SubscribeCommand = class extends Command {
constructor(cmd, opts) {
const sseHeaders = {
Accept: "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive"
};
super([], {
...opts,
headers: sseHeaders,
path: ["subscribe", ...cmd],
streamOptions: {
isStreaming: true,
onMessage: opts?.streamOptions?.onMessage,
signal: opts?.streamOptions?.signal
}
});
}
};
var parseWithTryCatch = (str) => {
try {
return JSON.parse(str);
} catch {
return str;
}
};
// pkg/commands/zdiffstore.ts
var ZDiffStoreCommand = class extends Command {
constructor(cmd, opts) {
super(["zdiffstore", ...cmd], opts);
}
};
// pkg/commands/zmscore.ts
var ZMScoreCommand = class extends Command {
constructor(cmd, opts) {
const [key, members] = cmd;
super(["zmscore", key, ...members], opts);
}
};
// pkg/pipeline.ts
var Pipeline = class {
client;
commands;
commandOptions;
multiExec;
constructor(opts) {
this.client = opts.client;
this.commands = [];
this.commandOptions = opts.commandOptions;
this.multiExec = opts.multiExec ?? false;
if (this.commandOptions?.latencyLogging) {
const originalExec = this.exec.bind(this);
this.exec = async (options) => {
const start = performance.now();
const result = await (options ? originalExec(options) : originalExec());
const end = performance.now();
const loggerResult = (end - start).toFixed(2);
console.log(
`Latency for \x1B[38;2;19;185;39m${this.multiExec ? ["MULTI-EXEC"] : ["PIPELINE"].toString().toUpperCase()}\x1B[0m: \x1B[38;2;0;255;255m${loggerResult} ms\x1B[0m`
);
return result;
};
}
}
exec = async (options) => {
if (this.commands.length === 0) {
throw new Error("Pipeline is empty");
}
const path = this.multiExec ? ["multi-exec"] : ["pipeline"];
const res = await this.client.request({
path,
body: Object.values(this.commands).map((c) => c.command)
});
return options?.keepErrors ? res.map(({ error, result }, i) => {
return {
error,
result: this.commands[i].deserialize(result)
};
}) : res.map(({ error, result }, i) => {
if (error) {
throw new UpstashError(
`Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`
);
}
return this.commands[i].deserialize(result);
});
};
/**
* Returns the length of pipeline before the execution
*/
length() {
return this.commands.length;
}
/**
* Pushes a command into the pipeline and returns a chainable instance of the
* pipeline
*/
chain(command) {
this.commands.push(command);
return this;
}
/**
* @see https://redis.io/commands/append
*/
append = (...args) => this.chain(new AppendCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/bitcount
*/
bitcount = (...args) => this.chain(new BitCountCommand(args, this.commandOptions));
/**
* Returns an instance that can be used to execute `BITFIELD` commands on one key.
*
* @example
* ```typescript
* redis.set("mykey", 0);
* const result = await redis.pipeline()
* .bitfield("mykey")
* .set("u4", 0, 16)
* .incr("u4", "#1", 1)
* .exec();
* console.log(result); // [[0, 1]]
* ```
*
* @see https://redis.io/commands/bitfield
*/
bitfield = (...args) => new BitFieldCommand(args, this.client, this.commandOptions, this.chain.bind(this));
/**
* @see https://redis.io/commands/bitop
*/
bitop = (op, destinationKey, sourceKey, ...sourceKeys) => this.chain(
new BitOpCommand([op, destinationKey, sourceKey, ...sourceKeys], this.commandOptions)
);
/**
* @see https://redis.io/commands/bitpos
*/
bitpos = (...args) => this.chain(new BitPosCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/copy
*/
copy = (...args) => this.chain(new CopyCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zdiffstore
*/
zdiffstore = (...args) => this.chain(new ZDiffStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/dbsize
*/
dbsize = () => this.chain(new DBSizeCommand(this.commandOptions));
/**
* @see https://redis.io/commands/decr
*/
decr = (...args) => this.chain(new DecrCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/decrby
*/
decrby = (...args) => this.chain(new DecrByCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/del
*/
del = (...args) => this.chain(new DelCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/echo
*/
echo = (...args) => this.chain(new EchoCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/eval_ro
*/
evalRo = (...args) => this.chain(new EvalROCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/eval
*/
eval = (...args) => this.chain(new EvalCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/evalsha_ro
*/
evalshaRo = (...args) => this.chain(new EvalshaROCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/evalsha
*/
evalsha = (...args) => this.chain(new EvalshaCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/exists
*/
exists = (...args) => this.chain(new ExistsCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/expire
*/
expire = (...args) => this.chain(new ExpireCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/expireat
*/
expireat = (...args) => this.chain(new ExpireAtCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/flushall
*/
flushall = (args) => this.chain(new FlushAllCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/flushdb
*/
flushdb = (...args) => this.chain(new FlushDBCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geoadd
*/
geoadd = (...args) => this.chain(new GeoAddCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geodist
*/
geodist = (...args) => this.chain(new GeoDistCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geopos
*/
geopos = (...args) => this.chain(new GeoPosCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geohash
*/
geohash = (...args) => this.chain(new GeoHashCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geosearch
*/
geosearch = (...args) => this.chain(new GeoSearchCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/geosearchstore
*/
geosearchstore = (...args) => this.chain(new GeoSearchStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/get
*/
get = (...args) => this.chain(new GetCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/getbit
*/
getbit = (...args) => this.chain(new GetBitCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/getdel
*/
getdel = (...args) => this.chain(new GetDelCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/getex
*/
getex = (...args) => this.chain(new GetExCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/getrange
*/
getrange = (...args) => this.chain(new GetRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/getset
*/
getset = (key, value) => this.chain(new GetSetCommand([key, value], this.commandOptions));
/**
* @see https://redis.io/commands/hdel
*/
hdel = (...args) => this.chain(new HDelCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hexists
*/
hexists = (...args) => this.chain(new HExistsCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hexpire
*/
hexpire = (...args) => this.chain(new HExpireCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hexpireat
*/
hexpireat = (...args) => this.chain(new HExpireAtCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hexpiretime
*/
hexpiretime = (...args) => this.chain(new HExpireTimeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/httl
*/
httl = (...args) => this.chain(new HTtlCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hpexpire
*/
hpexpire = (...args) => this.chain(new HPExpireCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hpexpireat
*/
hpexpireat = (...args) => this.chain(new HPExpireAtCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hpexpiretime
*/
hpexpiretime = (...args) => this.chain(new HPExpireTimeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hpttl
*/
hpttl = (...args) => this.chain(new HPTtlCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hpersist
*/
hpersist = (...args) => this.chain(new HPersistCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hget
*/
hget = (...args) => this.chain(new HGetCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hgetall
*/
hgetall = (...args) => this.chain(new HGetAllCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hincrby
*/
hincrby = (...args) => this.chain(new HIncrByCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hincrbyfloat
*/
hincrbyfloat = (...args) => this.chain(new HIncrByFloatCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hkeys
*/
hkeys = (...args) => this.chain(new HKeysCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hlen
*/
hlen = (...args) => this.chain(new HLenCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hmget
*/
hmget = (...args) => this.chain(new HMGetCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hmset
*/
hmset = (key, kv) => this.chain(new HMSetCommand([key, kv], this.commandOptions));
/**
* @see https://redis.io/commands/hrandfield
*/
hrandfield = (key, count, withValues) => this.chain(new HRandFieldCommand([key, count, withValues], this.commandOptions));
/**
* @see https://redis.io/commands/hscan
*/
hscan = (...args) => this.chain(new HScanCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hset
*/
hset = (key, kv) => this.chain(new HSetCommand([key, kv], this.commandOptions));
/**
* @see https://redis.io/commands/hsetnx
*/
hsetnx = (key, field, value) => this.chain(new HSetNXCommand([key, field, value], this.commandOptions));
/**
* @see https://redis.io/commands/hstrlen
*/
hstrlen = (...args) => this.chain(new HStrLenCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/hvals
*/
hvals = (...args) => this.chain(new HValsCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/incr
*/
incr = (...args) => this.chain(new IncrCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/incrby
*/
incrby = (...args) => this.chain(new IncrByCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/incrbyfloat
*/
incrbyfloat = (...args) => this.chain(new IncrByFloatCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/keys
*/
keys = (...args) => this.chain(new KeysCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lindex
*/
lindex = (...args) => this.chain(new LIndexCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/linsert
*/
linsert = (key, direction, pivot, value) => this.chain(new LInsertCommand([key, direction, pivot, value], this.commandOptions));
/**
* @see https://redis.io/commands/llen
*/
llen = (...args) => this.chain(new LLenCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lmove
*/
lmove = (...args) => this.chain(new LMoveCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lpop
*/
lpop = (...args) => this.chain(new LPopCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lmpop
*/
lmpop = (...args) => this.chain(new LmPopCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lpos
*/
lpos = (...args) => this.chain(new LPosCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lpush
*/
lpush = (key, ...elements) => this.chain(new LPushCommand([key, ...elements], this.commandOptions));
/**
* @see https://redis.io/commands/lpushx
*/
lpushx = (key, ...elements) => this.chain(new LPushXCommand([key, ...elements], this.commandOptions));
/**
* @see https://redis.io/commands/lrange
*/
lrange = (...args) => this.chain(new LRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/lrem
*/
lrem = (key, count, value) => this.chain(new LRemCommand([key, count, value], this.commandOptions));
/**
* @see https://redis.io/commands/lset
*/
lset = (key, index, value) => this.chain(new LSetCommand([key, index, value], this.commandOptions));
/**
* @see https://redis.io/commands/ltrim
*/
ltrim = (...args) => this.chain(new LTrimCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/mget
*/
mget = (...args) => this.chain(new MGetCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/mset
*/
mset = (kv) => this.chain(new MSetCommand([kv], this.commandOptions));
/**
* @see https://redis.io/commands/msetnx
*/
msetnx = (kv) => this.chain(new MSetNXCommand([kv], this.commandOptions));
/**
* @see https://redis.io/commands/persist
*/
persist = (...args) => this.chain(new PersistCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/pexpire
*/
pexpire = (...args) => this.chain(new PExpireCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/pexpireat
*/
pexpireat = (...args) => this.chain(new PExpireAtCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/pfadd
*/
pfadd = (...args) => this.chain(new PfAddCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/pfcount
*/
pfcount = (...args) => this.chain(new PfCountCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/pfmerge
*/
pfmerge = (...args) => this.chain(new PfMergeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/ping
*/
ping = (args) => this.chain(new PingCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/psetex
*/
psetex = (key, ttl, value) => this.chain(new PSetEXCommand([key, ttl, value], this.commandOptions));
/**
* @see https://redis.io/commands/pttl
*/
pttl = (...args) => this.chain(new PTtlCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/publish
*/
publish = (...args) => this.chain(new PublishCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/randomkey
*/
randomkey = () => this.chain(new RandomKeyCommand(this.commandOptions));
/**
* @see https://redis.io/commands/rename
*/
rename = (...args) => this.chain(new RenameCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/renamenx
*/
renamenx = (...args) => this.chain(new RenameNXCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/rpop
*/
rpop = (...args) => this.chain(new RPopCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/rpush
*/
rpush = (key, ...elements) => this.chain(new RPushCommand([key, ...elements], this.commandOptions));
/**
* @see https://redis.io/commands/rpushx
*/
rpushx = (key, ...elements) => this.chain(new RPushXCommand([key, ...elements], this.commandOptions));
/**
* @see https://redis.io/commands/sadd
*/
sadd = (key, member, ...members) => this.chain(new SAddCommand([key, member, ...members], this.commandOptions));
/**
* @see https://redis.io/commands/scan
*/
scan = (...args) => this.chain(new ScanCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/scard
*/
scard = (...args) => this.chain(new SCardCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/script-exists
*/
scriptExists = (...args) => this.chain(new ScriptExistsCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/script-flush
*/
scriptFlush = (...args) => this.chain(new ScriptFlushCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/script-load
*/
scriptLoad = (...args) => this.chain(new ScriptLoadCommand(args, this.commandOptions));
/*)*
* @see https://redis.io/commands/sdiff
*/
sdiff = (...args) => this.chain(new SDiffCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sdiffstore
*/
sdiffstore = (...args) => this.chain(new SDiffStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/set
*/
set = (key, value, opts) => this.chain(new SetCommand([key, value, opts], this.commandOptions));
/**
* @see https://redis.io/commands/setbit
*/
setbit = (...args) => this.chain(new SetBitCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/setex
*/
setex = (key, ttl, value) => this.chain(new SetExCommand([key, ttl, value], this.commandOptions));
/**
* @see https://redis.io/commands/setnx
*/
setnx = (key, value) => this.chain(new SetNxCommand([key, value], this.commandOptions));
/**
* @see https://redis.io/commands/setrange
*/
setrange = (...args) => this.chain(new SetRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sinter
*/
sinter = (...args) => this.chain(new SInterCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sinterstore
*/
sinterstore = (...args) => this.chain(new SInterStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sismember
*/
sismember = (key, member) => this.chain(new SIsMemberCommand([key, member], this.commandOptions));
/**
* @see https://redis.io/commands/smembers
*/
smembers = (...args) => this.chain(new SMembersCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/smismember
*/
smismember = (key, members) => this.chain(new SMIsMemberCommand([key, members], this.commandOptions));
/**
* @see https://redis.io/commands/smove
*/
smove = (source, destination, member) => this.chain(new SMoveCommand([source, destination, member], this.commandOptions));
/**
* @see https://redis.io/commands/spop
*/
spop = (...args) => this.chain(new SPopCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/srandmember
*/
srandmember = (...args) => this.chain(new SRandMemberCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/srem
*/
srem = (key, ...members) => this.chain(new SRemCommand([key, ...members], this.commandOptions));
/**
* @see https://redis.io/commands/sscan
*/
sscan = (...args) => this.chain(new SScanCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/strlen
*/
strlen = (...args) => this.chain(new StrLenCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sunion
*/
sunion = (...args) => this.chain(new SUnionCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/sunionstore
*/
sunionstore = (...args) => this.chain(new SUnionStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/time
*/
time = () => this.chain(new TimeCommand(this.commandOptions));
/**
* @see https://redis.io/commands/touch
*/
touch = (...args) => this.chain(new TouchCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/ttl
*/
ttl = (...args) => this.chain(new TtlCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/type
*/
type = (...args) => this.chain(new TypeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/unlink
*/
unlink = (...args) => this.chain(new UnlinkCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zadd
*/
zadd = (...args) => {
if ("score" in args[1]) {
return this.chain(
new ZAddCommand([args[0], args[1], ...args.slice(2)], this.commandOptions)
);
}
return this.chain(
new ZAddCommand(
[args[0], args[1], ...args.slice(2)],
this.commandOptions
)
);
};
/**
* @see https://redis.io/commands/xadd
*/
xadd = (...args) => this.chain(new XAddCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xack
*/
xack = (...args) => this.chain(new XAckCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xdel
*/
xdel = (...args) => this.chain(new XDelCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xgroup
*/
xgroup = (...args) => this.chain(new XGroupCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xread
*/
xread = (...args) => this.chain(new XReadCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xreadgroup
*/
xreadgroup = (...args) => this.chain(new XReadGroupCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xinfo
*/
xinfo = (...args) => this.chain(new XInfoCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xlen
*/
xlen = (...args) => this.chain(new XLenCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xpending
*/
xpending = (...args) => this.chain(new XPendingCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xclaim
*/
xclaim = (...args) => this.chain(new XClaimCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xautoclaim
*/
xautoclaim = (...args) => this.chain(new XAutoClaim(args, this.commandOptions));
/**
* @see https://redis.io/commands/xtrim
*/
xtrim = (...args) => this.chain(new XTrimCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xrange
*/
xrange = (...args) => this.chain(new XRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/xrevrange
*/
xrevrange = (...args) => this.chain(new XRevRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zcard
*/
zcard = (...args) => this.chain(new ZCardCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zcount
*/
zcount = (...args) => this.chain(new ZCountCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zincrby
*/
zincrby = (key, increment, member) => this.chain(new ZIncrByCommand([key, increment, member], this.commandOptions));
/**
* @see https://redis.io/commands/zinterstore
*/
zinterstore = (...args) => this.chain(new ZInterStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zlexcount
*/
zlexcount = (...args) => this.chain(new ZLexCountCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zmscore
*/
zmscore = (...args) => this.chain(new ZMScoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zpopmax
*/
zpopmax = (...args) => this.chain(new ZPopMaxCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zpopmin
*/
zpopmin = (...args) => this.chain(new ZPopMinCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zrange
*/
zrange = (...args) => this.chain(new ZRangeCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zrank
*/
zrank = (key, member) => this.chain(new ZRankCommand([key, member], this.commandOptions));
/**
* @see https://redis.io/commands/zrem
*/
zrem = (key, ...members) => this.chain(new ZRemCommand([key, ...members], this.commandOptions));
/**
* @see https://redis.io/commands/zremrangebylex
*/
zremrangebylex = (...args) => this.chain(new ZRemRangeByLexCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zremrangebyrank
*/
zremrangebyrank = (...args) => this.chain(new ZRemRangeByRankCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zremrangebyscore
*/
zremrangebyscore = (...args) => this.chain(new ZRemRangeByScoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zrevrank
*/
zrevrank = (key, member) => this.chain(new ZRevRankCommand([key, member], this.commandOptions));
/**
* @see https://redis.io/commands/zscan
*/
zscan = (...args) => this.chain(new ZScanCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zscore
*/
zscore = (key, member) => this.chain(new ZScoreCommand([key, member], this.commandOptions));
/**
* @see https://redis.io/commands/zunionstore
*/
zunionstore = (...args) => this.chain(new ZUnionStoreCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/zunion
*/
zunion = (...args) => this.chain(new ZUnionCommand(args, this.commandOptions));
/**
* @see https://redis.io/commands/?group=json
*/
get json() {
return {
/**
* @see https://redis.io/commands/json.arrappend
*/
arrappend: (...args) => this.chain(new JsonArrAppendCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.arrindex
*/
arrindex: (...args) => this.chain(new JsonArrIndexCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.arrinsert
*/
arrinsert: (...args) => this.chain(new JsonArrInsertCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.arrlen
*/
arrlen: (...args) => this.chain(new JsonArrLenCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.arrpop
*/
arrpop: (...args) => this.chain(new JsonArrPopCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.arrtrim
*/
arrtrim: (...args) => this.chain(new JsonArrTrimCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.clear
*/
clear: (...args) => this.chain(new JsonClearCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.del
*/
del: (...args) => this.chain(new JsonDelCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.forget
*/
forget: (...args) => this.chain(new JsonForgetCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.get
*/
get: (...args) => this.chain(new JsonGetCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.merge
*/
merge: (...args) => this.chain(new JsonMergeCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.mget
*/
mget: (...args) => this.chain(new JsonMGetCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.mset
*/
mset: (...args) => this.chain(new JsonMSetCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.numincrby
*/
numincrby: (...args) => this.chain(new JsonNumIncrByCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.nummultby
*/
nummultby: (...args) => this.chain(new JsonNumMultByCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.objkeys
*/
objkeys: (...args) => this.chain(new JsonObjKeysCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.objlen
*/
objlen: (...args) => this.chain(new JsonObjLenCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.resp
*/
resp: (...args) => this.chain(new JsonRespCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.set
*/
set: (...args) => this.chain(new JsonSetCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.strappend
*/
strappend: (...args) => this.chain(new JsonStrAppendCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.strlen
*/
strlen: (...args) => this.chain(new JsonStrLenCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.toggle
*/
toggle: (...args) => this.chain(new JsonToggleCommand(args, this.commandOptions)),
/**
* @see https://redis.io/commands/json.type
*/
type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
};
}
get functions() {
return {
/**
* @see https://redis.io/docs/latest/commands/function-load/
*/
load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/function-list/
*/
list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/function-delete/
*/
delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/function-flush/
*/
flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/function-stats/
*/
stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/fcall/
*/
call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
/**
* @see https://redis.io/docs/latest/commands/fcall_ro/
*/
callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
};
}
};
// pkg/script.ts
var import_uncrypto = require("uncrypto");
var Script = class {
script;
/**
* @deprecated This property is initialized to an empty string and will be set in the init method
* asynchronously. Do not use this property immidiately after the constructor.
*
* This property is only exposed for backwards compatibility and will be removed in the
* future major release.
*/
sha1;
redis;
constructor(redis, script) {
this.redis = redis;
this.script = script;
this.sha1 = "";
void this.init(script);
}
/**
* Initialize the script by computing its SHA-1 hash.
*/
async init(script) {
if (this.sha1) return;
this.sha1 = await this.digest(script);
}
/**
* Send an `EVAL` command to redis.
*/
async eval(keys, args) {
await this.init(this.script);
return await this.redis.eval(this.script, keys, args);
}
/**
* Calculates the sha1 hash of the script and then calls `EVALSHA`.
*/
async evalsha(keys, args) {
await this.init(this.script);
return await this.redis.evalsha(this.sha1, keys, args);
}
/**
* Optimistically try to run `EVALSHA` first.
* If the script is not loaded in redis, it will fall back and try again with `EVAL`.
*
* Following calls will be able to use the cached script
*/
async exec(keys, args) {
await this.init(this.script);
const res = await this.redis.evalsha(this.sha1, keys, args).catch(async (error) => {
if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
return await this.redis.eval(this.script, keys, args);
}
throw error;
});
return res;
}
/**
* Compute the sha1 hash of the script and return its hex representation.
*/
async digest(s) {
const data = new TextEncoder().encode(s);
const hashBuffer = await import_uncrypto.subtle.digest("SHA-1", data);
const hashArray = [...new Uint8Array(hashBuffer)];
return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
}
};
// pkg/scriptRo.ts
var import_uncrypto2 = require("uncrypto");
var ScriptRO = class {
script;
/**
* @deprecated This property is initialized to an empty string and will be set in the init method
* asynchronously. Do not use this property immidiately after the constructor.
*
* This property is only exposed for backwards compatibility and will be removed in the
* future major release.
*/
sha1;
redis;
constructor(redis, script) {
this.redis = redis;
this.sha1 = "";
this.script = script;
void this.init(script);
}
async init(script) {
if (this.sha1) return;
this.sha1 = await this.digest(script);
}
/**
* Send an `EVAL_RO` command to redis.
*/
async evalRo(keys, args) {
await this.init(this.script);
return await this.redis.evalRo(this.script, keys, args);
}
/**
* Calculates the sha1 hash of the script and then calls `EVALSHA_RO`.
*/
async evalshaRo(keys, args) {
await this.init(this.script);
return await this.redis.evalshaRo(this.sha1, keys, args);
}
/**
* Optimistically try to run `EVALSHA_RO` first.
* If the script is not loaded in redis, it will fall back and try again with `EVAL_RO`.
*
* Following calls will be able to use the cached script
*/
async exec(keys, args) {
await this.init(this.script);
const res = await this.redis.evalshaRo(this.sha1, keys, args).catch(async (error) => {
if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
return await this.redis.evalRo(this.script, keys, args);
}
throw error;
});
return res;
}
/**
* Compute the sha1 hash of the script and return its hex representation.
*/
async digest(s) {
const data = new TextEncoder().encode(s);
const hashBuffer = await import_uncrypto2.subtle.digest("SHA-1", data);
const hashArray = [...new Uint8Array(hashBuffer)];
return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
}
};
// pkg/redis.ts
var Redis = class {
client;
opts;
enableTelemetry;
enableAutoPipelining;
/**
* Create a new redis client
*
* @example
* ```typescript
* const redis = new Redis({
* url: "<UPSTASH_REDIS_REST_URL>",
* token: "<UPSTASH_REDIS_REST_TOKEN>",
* });
* ```
*/
constructor(client, opts) {
this.client = client;
this.opts = opts;
this.enableTelemetry = opts?.enableTelemetry ?? true;
if (opts?.readYourWrites === false) {
this.client.readYourWrites = false;
}
this.enableAutoPipelining = opts?.enableAutoPipelining ?? true;
}
get readYourWritesSyncToken() {
return this.client.upstashSyncToken;
}
set readYourWritesSyncToken(session) {
this.client.upstashSyncToken = session;
}
get json() {
return {
/**
* @see https://redis.io/commands/json.arrappend
*/
arrappend: (...args) => new JsonArrAppendCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.arrindex
*/
arrindex: (...args) => new JsonArrIndexCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.arrinsert
*/
arrinsert: (...args) => new JsonArrInsertCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.arrlen
*/
arrlen: (...args) => new JsonArrLenCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.arrpop
*/
arrpop: (...args) => new JsonArrPopCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.arrtrim
*/
arrtrim: (...args) => new JsonArrTrimCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.clear
*/
clear: (...args) => new JsonClearCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.del
*/
del: (...args) => new JsonDelCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.forget
*/
forget: (...args) => new JsonForgetCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.get
*/
get: (...args) => new JsonGetCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.merge
*/
merge: (...args) => new JsonMergeCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.mget
*/
mget: (...args) => new JsonMGetCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.mset
*/
mset: (...args) => new JsonMSetCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.numincrby
*/
numincrby: (...args) => new JsonNumIncrByCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.nummultby
*/
nummultby: (...args) => new JsonNumMultByCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.objkeys
*/
objkeys: (...args) => new JsonObjKeysCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.objlen
*/
objlen: (...args) => new JsonObjLenCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.resp
*/
resp: (...args) => new JsonRespCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.set
*/
set: (...args) => new JsonSetCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.strappend
*/
strappend: (...args) => new JsonStrAppendCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.strlen
*/
strlen: (...args) => new JsonStrLenCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.toggle
*/
toggle: (...args) => new JsonToggleCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/commands/json.type
*/
type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
};
}
get functions() {
return {
/**
* @see https://redis.io/docs/latest/commands/function-load/
*/
load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/function-list/
*/
list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/function-delete/
*/
delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/function-flush/
*/
flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/function-stats/
*
* Note: `running_script` field is not supported and therefore not included in the type.
*/
stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/fcall/
*/
call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
/**
* @see https://redis.io/docs/latest/commands/fcall_ro/
*/
callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
};
}
/**
* Wrap a new middleware around the HTTP client.
*/
use = (middleware) => {
const makeRequest = this.client.request.bind(this.client);
this.client.request = (req) => middleware(req, makeRequest);
};
/**
* Technically this is not private, we can hide it from intellisense by doing this
*/
addTelemetry = (telemetry) => {
if (!this.enableTelemetry) {
return;
}
try {
this.client.mergeTelemetry(telemetry);
} catch {
}
};
/**
* Creates a new script.
*
* Scripts offer the ability to optimistically try to execute a script without having to send the
* entire script to the server. If the script is loaded on the server, it tries again by sending
* the entire script. Afterwards, the script is cached on the server.
*
* @param script - The script to create
* @param opts - Optional options to pass to the script `{ readonly?: boolean }`
* @returns A new script
*
* @example
* ```ts
* const redis = new Redis({...})
*
* const script = redis.createScript<string>("return ARGV[1];")
* const arg1 = await script.eval([], ["Hello World"])
* expect(arg1, "Hello World")
* ```
* @example
* ```ts
* const redis = new Redis({...})
*
* const script = redis.createScript<string>("return ARGV[1];", { readonly: true })
* const arg1 = await script.evalRo([], ["Hello World"])
* expect(arg1, "Hello World")
* ```
*/
createScript(script, opts) {
return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
}
/**
* Create a new pipeline that allows you to send requests in bulk.
*
* @see {@link Pipeline}
*/
pipeline = () => new Pipeline({
client: this.client,
commandOptions: this.opts,
multiExec: false
});
autoPipeline = () => {
return createAutoPipelineProxy(this);
};
/**
* Create a new transaction to allow executing multiple steps atomically.
*
* All the commands in a transaction are serialized and executed sequentially. A request sent by
* another client will never be served in the middle of the execution of a Redis Transaction. This
* guarantees that the commands are executed as a single isolated operation.
*
* @see {@link Pipeline}
*/
multi = () => new Pipeline({
client: this.client,
commandOptions: this.opts,
multiExec: true
});
/**
* Returns an instance that can be used to execute `BITFIELD` commands on one key.
*
* @example
* ```typescript
* redis.set("mykey", 0);
* const result = await redis.bitfield("mykey")
* .set("u4", 0, 16)
* .incr("u4", "#1", 1)
* .exec();
* console.log(result); // [0, 1]
* ```
*
* @see https://redis.io/commands/bitfield
*/
bitfield = (...args) => new BitFieldCommand(args, this.client, this.opts);
/**
* @see https://redis.io/commands/append
*/
append = (...args) => new AppendCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/bitcount
*/
bitcount = (...args) => new BitCountCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/bitop
*/
bitop = (op, destinationKey, sourceKey, ...sourceKeys) => new BitOpCommand([op, destinationKey, sourceKey, ...sourceKeys], this.opts).exec(
this.client
);
/**
* @see https://redis.io/commands/bitpos
*/
bitpos = (...args) => new BitPosCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/copy
*/
copy = (...args) => new CopyCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/dbsize
*/
dbsize = () => new DBSizeCommand(this.opts).exec(this.client);
/**
* @see https://redis.io/commands/decr
*/
decr = (...args) => new DecrCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/decrby
*/
decrby = (...args) => new DecrByCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/del
*/
del = (...args) => new DelCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/echo
*/
echo = (...args) => new EchoCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/eval_ro
*/
evalRo = (...args) => new EvalROCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/eval
*/
eval = (...args) => new EvalCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/evalsha_ro
*/
evalshaRo = (...args) => new EvalshaROCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/evalsha
*/
evalsha = (...args) => new EvalshaCommand(args, this.opts).exec(this.client);
/**
* Generic method to execute any Redis command.
*/
exec = (args) => new ExecCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/exists
*/
exists = (...args) => new ExistsCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/expire
*/
expire = (...args) => new ExpireCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/expireat
*/
expireat = (...args) => new ExpireAtCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/flushall
*/
flushall = (args) => new FlushAllCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/flushdb
*/
flushdb = (...args) => new FlushDBCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geoadd
*/
geoadd = (...args) => new GeoAddCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geopos
*/
geopos = (...args) => new GeoPosCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geodist
*/
geodist = (...args) => new GeoDistCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geohash
*/
geohash = (...args) => new GeoHashCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geosearch
*/
geosearch = (...args) => new GeoSearchCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/geosearchstore
*/
geosearchstore = (...args) => new GeoSearchStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/get
*/
get = (...args) => new GetCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/getbit
*/
getbit = (...args) => new GetBitCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/getdel
*/
getdel = (...args) => new GetDelCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/getex
*/
getex = (...args) => new GetExCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/getrange
*/
getrange = (...args) => new GetRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/getset
*/
getset = (key, value) => new GetSetCommand([key, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hdel
*/
hdel = (...args) => new HDelCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hexists
*/
hexists = (...args) => new HExistsCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hexpire
*/
hexpire = (...args) => new HExpireCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hexpireat
*/
hexpireat = (...args) => new HExpireAtCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hexpiretime
*/
hexpiretime = (...args) => new HExpireTimeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/httl
*/
httl = (...args) => new HTtlCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hpexpire
*/
hpexpire = (...args) => new HPExpireCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hpexpireat
*/
hpexpireat = (...args) => new HPExpireAtCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hpexpiretime
*/
hpexpiretime = (...args) => new HPExpireTimeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hpttl
*/
hpttl = (...args) => new HPTtlCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hpersist
*/
hpersist = (...args) => new HPersistCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hget
*/
hget = (...args) => new HGetCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hgetall
*/
hgetall = (...args) => new HGetAllCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hincrby
*/
hincrby = (...args) => new HIncrByCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hincrbyfloat
*/
hincrbyfloat = (...args) => new HIncrByFloatCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hkeys
*/
hkeys = (...args) => new HKeysCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hlen
*/
hlen = (...args) => new HLenCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hmget
*/
hmget = (...args) => new HMGetCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hmset
*/
hmset = (key, kv) => new HMSetCommand([key, kv], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hrandfield
*/
hrandfield = (key, count, withValues) => new HRandFieldCommand([key, count, withValues], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hscan
*/
hscan = (...args) => new HScanCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hset
*/
hset = (key, kv) => new HSetCommand([key, kv], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hsetnx
*/
hsetnx = (key, field, value) => new HSetNXCommand([key, field, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hstrlen
*/
hstrlen = (...args) => new HStrLenCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/hvals
*/
hvals = (...args) => new HValsCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/incr
*/
incr = (...args) => new IncrCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/incrby
*/
incrby = (...args) => new IncrByCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/incrbyfloat
*/
incrbyfloat = (...args) => new IncrByFloatCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/keys
*/
keys = (...args) => new KeysCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lindex
*/
lindex = (...args) => new LIndexCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/linsert
*/
linsert = (key, direction, pivot, value) => new LInsertCommand([key, direction, pivot, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/llen
*/
llen = (...args) => new LLenCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lmove
*/
lmove = (...args) => new LMoveCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lpop
*/
lpop = (...args) => new LPopCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lmpop
*/
lmpop = (...args) => new LmPopCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lpos
*/
lpos = (...args) => new LPosCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lpush
*/
lpush = (key, ...elements) => new LPushCommand([key, ...elements], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lpushx
*/
lpushx = (key, ...elements) => new LPushXCommand([key, ...elements], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lrange
*/
lrange = (...args) => new LRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lrem
*/
lrem = (key, count, value) => new LRemCommand([key, count, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/lset
*/
lset = (key, index, value) => new LSetCommand([key, index, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/ltrim
*/
ltrim = (...args) => new LTrimCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/mget
*/
mget = (...args) => new MGetCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/mset
*/
mset = (kv) => new MSetCommand([kv], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/msetnx
*/
msetnx = (kv) => new MSetNXCommand([kv], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/persist
*/
persist = (...args) => new PersistCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/pexpire
*/
pexpire = (...args) => new PExpireCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/pexpireat
*/
pexpireat = (...args) => new PExpireAtCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/pfadd
*/
pfadd = (...args) => new PfAddCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/pfcount
*/
pfcount = (...args) => new PfCountCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/pfmerge
*/
pfmerge = (...args) => new PfMergeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/ping
*/
ping = (args) => new PingCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/psetex
*/
psetex = (key, ttl, value) => new PSetEXCommand([key, ttl, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/psubscribe
*/
psubscribe = (patterns) => {
const patternArray = Array.isArray(patterns) ? patterns : [patterns];
return new Subscriber(this.client, patternArray, true, this.opts);
};
/**
* @see https://redis.io/commands/pttl
*/
pttl = (...args) => new PTtlCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/publish
*/
publish = (...args) => new PublishCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/randomkey
*/
randomkey = () => new RandomKeyCommand().exec(this.client);
/**
* @see https://redis.io/commands/rename
*/
rename = (...args) => new RenameCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/renamenx
*/
renamenx = (...args) => new RenameNXCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/rpop
*/
rpop = (...args) => new RPopCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/rpush
*/
rpush = (key, ...elements) => new RPushCommand([key, ...elements], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/rpushx
*/
rpushx = (key, ...elements) => new RPushXCommand([key, ...elements], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sadd
*/
sadd = (key, member, ...members) => new SAddCommand([key, member, ...members], this.opts).exec(this.client);
scan(cursor, opts) {
return new ScanCommand([cursor, opts], this.opts).exec(this.client);
}
/**
* @see https://redis.io/commands/scard
*/
scard = (...args) => new SCardCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/script-exists
*/
scriptExists = (...args) => new ScriptExistsCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/script-flush
*/
scriptFlush = (...args) => new ScriptFlushCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/script-load
*/
scriptLoad = (...args) => new ScriptLoadCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sdiff
*/
sdiff = (...args) => new SDiffCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sdiffstore
*/
sdiffstore = (...args) => new SDiffStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/set
*/
set = (key, value, opts) => new SetCommand([key, value, opts], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/setbit
*/
setbit = (...args) => new SetBitCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/setex
*/
setex = (key, ttl, value) => new SetExCommand([key, ttl, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/setnx
*/
setnx = (key, value) => new SetNxCommand([key, value], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/setrange
*/
setrange = (...args) => new SetRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sinter
*/
sinter = (...args) => new SInterCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sinterstore
*/
sinterstore = (...args) => new SInterStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sismember
*/
sismember = (key, member) => new SIsMemberCommand([key, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/smismember
*/
smismember = (key, members) => new SMIsMemberCommand([key, members], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/smembers
*/
smembers = (...args) => new SMembersCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/smove
*/
smove = (source, destination, member) => new SMoveCommand([source, destination, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/spop
*/
spop = (...args) => new SPopCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/srandmember
*/
srandmember = (...args) => new SRandMemberCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/srem
*/
srem = (key, ...members) => new SRemCommand([key, ...members], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sscan
*/
sscan = (...args) => new SScanCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/strlen
*/
strlen = (...args) => new StrLenCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/subscribe
*/
subscribe = (channels) => {
const channelArray = Array.isArray(channels) ? channels : [channels];
return new Subscriber(this.client, channelArray, false, this.opts);
};
/**
* @see https://redis.io/commands/sunion
*/
sunion = (...args) => new SUnionCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/sunionstore
*/
sunionstore = (...args) => new SUnionStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/time
*/
time = () => new TimeCommand().exec(this.client);
/**
* @see https://redis.io/commands/touch
*/
touch = (...args) => new TouchCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/ttl
*/
ttl = (...args) => new TtlCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/type
*/
type = (...args) => new TypeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/unlink
*/
unlink = (...args) => new UnlinkCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xadd
*/
xadd = (...args) => new XAddCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xack
*/
xack = (...args) => new XAckCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xdel
*/
xdel = (...args) => new XDelCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xgroup
*/
xgroup = (...args) => new XGroupCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xread
*/
xread = (...args) => new XReadCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xreadgroup
*/
xreadgroup = (...args) => new XReadGroupCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xinfo
*/
xinfo = (...args) => new XInfoCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xlen
*/
xlen = (...args) => new XLenCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xpending
*/
xpending = (...args) => new XPendingCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xclaim
*/
xclaim = (...args) => new XClaimCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xautoclaim
*/
xautoclaim = (...args) => new XAutoClaim(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xtrim
*/
xtrim = (...args) => new XTrimCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xrange
*/
xrange = (...args) => new XRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/xrevrange
*/
xrevrange = (...args) => new XRevRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zadd
*/
zadd = (...args) => {
if ("score" in args[1]) {
return new ZAddCommand([args[0], args[1], ...args.slice(2)], this.opts).exec(
this.client
);
}
return new ZAddCommand(
[args[0], args[1], ...args.slice(2)],
this.opts
).exec(this.client);
};
/**
* @see https://redis.io/commands/zcard
*/
zcard = (...args) => new ZCardCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zcount
*/
zcount = (...args) => new ZCountCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zdiffstore
*/
zdiffstore = (...args) => new ZDiffStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zincrby
*/
zincrby = (key, increment, member) => new ZIncrByCommand([key, increment, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zinterstore
*/
zinterstore = (...args) => new ZInterStoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zlexcount
*/
zlexcount = (...args) => new ZLexCountCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zmscore
*/
zmscore = (...args) => new ZMScoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zpopmax
*/
zpopmax = (...args) => new ZPopMaxCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zpopmin
*/
zpopmin = (...args) => new ZPopMinCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zrange
*/
zrange = (...args) => new ZRangeCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zrank
*/
zrank = (key, member) => new ZRankCommand([key, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zrem
*/
zrem = (key, ...members) => new ZRemCommand([key, ...members], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zremrangebylex
*/
zremrangebylex = (...args) => new ZRemRangeByLexCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zremrangebyrank
*/
zremrangebyrank = (...args) => new ZRemRangeByRankCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zremrangebyscore
*/
zremrangebyscore = (...args) => new ZRemRangeByScoreCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zrevrank
*/
zrevrank = (key, member) => new ZRevRankCommand([key, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zscan
*/
zscan = (...args) => new ZScanCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zscore
*/
zscore = (key, member) => new ZScoreCommand([key, member], this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zunion
*/
zunion = (...args) => new ZUnionCommand(args, this.opts).exec(this.client);
/**
* @see https://redis.io/commands/zunionstore
*/
zunionstore = (...args) => new ZUnionStoreCommand(args, this.opts).exec(this.client);
};
// version.ts
var VERSION = "v1.36.1";
// platforms/fastly.ts
var Redis2 = class extends Redis {
/**
* Create a new redis client
*
* @example
* ```typescript
* const redis = new Redis({
* url: "<UPSTASH_REDIS_REST_URL>",
* token: "<UPSTASH_REDIS_REST_TOKEN>",
* backend: "upstash-db",
* });
* ```
*/
constructor(config) {
if (!config.url) {
console.warn(
`[Upstash Redis] The 'url' property is missing or undefined in your Redis config.`
);
} else if (config.url.startsWith(" ") || config.url.endsWith(" ") || /\r|\n/.test(config.url)) {
console.warn(
"[Upstash Redis] The redis url contains whitespace or newline, which can cause errors!"
);
}
if (!config.token) {
console.warn(
`[Upstash Redis] The 'token' property is missing or undefined in your Redis config.`
);
} else if (config.token.startsWith(" ") || config.token.endsWith(" ") || /\r|\n/.test(config.token)) {
console.warn(
"[Upstash Redis] The redis token contains whitespace or newline, which can cause errors!"
);
}
const client = new HttpClient({
baseUrl: config.url,
retry: config.retry,
headers: { authorization: `Bearer ${config.token}` },
options: { backend: config.backend },
responseEncoding: config.responseEncoding,
keepAlive: config.keepAlive,
readYourWrites: config.readYourWrites
});
super(client, {
automaticDeserialization: config.automaticDeserialization,
enableAutoPipelining: config.enableAutoPipelining
});
this.addTelemetry({
sdk: `@upstash/redis@${VERSION}`,
platform: "fastly"
});
if (this.enableAutoPipelining) {
return this.autoPipeline();
}
}
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
Redis,
errors
});
