js-redis-server 0.0.1 → 0.0.3

package/dist/commands/transactions.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionCommands = exports.unwatchCommand = exports.watchCommand = exports.discardCommand = exports.execCommand = exports.multiCommand = void 0;
+const command_definition_1 = require("../core/command-definition");
+const command_schema_1 = require("../core/command-schema");
+const redis_error_1 = require("../core/redis-error");
+const redis_result_1 = require("../core/redis-result");
+const redis_value_1 = require("../core/redis-value");
+const helpers_1 = require("./helpers");
+exports.multiCommand = (0, command_definition_1.defineCommand)({
+    name: 'multi',
+    schema: command_schema_1.t.object({}),
+    flags: ['readonly', 'fast', 'transaction'],
+    keys: () => [],
+    execute: (_args, ctx) => {
+        ctx.session.beginTransaction();
+        return (0, helpers_1.ok)();
+    },
+});
+exports.execCommand = (0, command_definition_1.defineCommand)({
+    name: 'exec',
+    schema: command_schema_1.t.object({}),
+    // EXEC inherits flags from queued commands at runtime. The flag list here
+    // only marks it as transaction-control so policies do not treat it as a
+    // normal write/read command.
+    flags: ['transaction'],
+    keys: () => [],
+    execute: async (_args, ctx) => {
+        if (ctx.session.mode !== 'transaction') {
+            throw new redis_error_1.ExecWithoutMultiError();
+        }
+        if (ctx.session.isWatchDirty()) {
+            ctx.session.discardTransaction();
+            return redis_result_1.RedisResult.create(redis_value_1.RedisValue.nullArray());
+        }
+        if (ctx.session.isTransactionDirty()) {
+            ctx.session.discardTransaction();
+            throw new redis_error_1.TransactionDiscardedError();
+        }
+        const plans = ctx.session.drainTransaction();
+        return ctx.session.executeTransaction(plans);
+    },
+});
+exports.discardCommand = (0, command_definition_1.defineCommand)({
+    name: 'discard',
+    schema: command_schema_1.t.object({}),
+    flags: ['readonly', 'fast', 'transaction'],
+    keys: () => [],
+    execute: (_args, ctx) => {
+        if (ctx.session.mode !== 'transaction') {
+            throw new redis_error_1.DiscardWithoutMultiError();
+        }
+        ctx.session.discardTransaction();
+        return (0, helpers_1.ok)();
+    },
+});
+exports.watchCommand = (0, command_definition_1.defineCommand)({
+    name: 'watch',
+    schema: command_schema_1.t.object({
+        keys: command_schema_1.t.variadic(command_schema_1.t.key(), { min: 1 }),
+    }),
+    flags: ['readonly', 'fast', 'transaction'],
+    keys: args => args.keys,
+    execute: (args, ctx) => {
+        if (ctx.session.mode === 'transaction') {
+            throw new redis_error_1.WatchInsideMultiError();
+        }
+        ctx.session.watch(args.keys);
+        return (0, helpers_1.ok)();
+    },
+});
+exports.unwatchCommand = (0, command_definition_1.defineCommand)({
+    name: 'unwatch',
+    schema: command_schema_1.t.object({}),
+    flags: ['readonly', 'fast'],
+    keys: () => [],
+    execute: (_args, ctx) => {
+        ctx.session.unwatch();
+        return (0, helpers_1.ok)();
+    },
+});
+exports.transactionCommands = [
+    exports.multiCommand,
+    exports.execCommand,
+    exports.discardCommand,
+    exports.watchCommand,
+    exports.unwatchCommand,
+];
+//# sourceMappingURL=transactions.js.map

package/dist/commands/transactions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.js","sourceRoot":"","sources":["../../src/commands/transactions.ts"],"names":[],"mappings":"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"}

package/dist/commands/zsets.d.ts

@@ -0,0 +1,82 @@
+type ZaddPair = {
+    score: number;
+    member: Buffer;
+};
+type ZaddCondition = 'NX' | 'XX';
+type ZaddComparison = 'GT' | 'LT';
+type ZaddOptions = {
+    condition?: ZaddCondition;
+    comparison?: ZaddComparison;
+    ch: boolean;
+    incr: boolean;
+};
+type ZaddArgs = {
+    key: Buffer;
+    options: ZaddOptions;
+    pairs: ZaddPair[];
+};
+export declare const zaddCommand: import("../core/command-definition").CommandDefinition<ZaddArgs>;
+export declare const zremCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    members: Buffer<ArrayBufferLike>[];
+}>;
+export declare const zcardCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>;
+export declare const zrankCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    member: Buffer<ArrayBufferLike>;
+}>;
+export declare const zrevrankCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    member: Buffer<ArrayBufferLike>;
+}>;
+export declare const zscoreCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    member: Buffer<ArrayBufferLike>;
+}>;
+export declare const zincrbyCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    increment: string;
+    member: Buffer<ArrayBufferLike>;
+}>;
+export declare const zrangeCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    start: number;
+    stop: number;
+    withScores: "WITHSCORES" | undefined;
+}>;
+export declare const zrevrangeCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    start: number;
+    stop: number;
+    withScores: "WITHSCORES" | undefined;
+}>;
+export declare const zrangebyscoreCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    min: string;
+    max: string;
+}>;
+export declare const zremrangebyscoreCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    min: string;
+    max: string;
+}>;
+export declare const zcountCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    min: string;
+    max: string;
+}>;
+export declare const zpopminCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    count: number | undefined;
+}>;
+export declare const zpopmaxCommand: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+    count: number | undefined;
+}>;
+export declare const zsetsCommands: import("../core/command-definition").CommandDefinition<{
+    key: Buffer<ArrayBufferLike>;
+}>[];
+export {};
+//# sourceMappingURL=zsets.d.ts.map

package/dist/commands/zsets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zsets.d.ts","sourceRoot":"","sources":["../../src/commands/zsets.ts"],"names":[],"mappings":"AAsEA,KAAK,QAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AACjD,KAAK,aAAa,GAAG,IAAI,GAAG,IAAI,CAAA;AAChC,KAAK,cAAc,GAAG,IAAI,GAAG,IAAI,CAAA;AAEjC,KAAK,WAAW,GAAG;IACjB,SAAS,CAAC,EAAE,aAAa,CAAA;IACzB,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,OAAO,CAAA;CACd,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,WAAW,CAAA;IACpB,KAAK,EAAE,QAAQ,EAAE,CAAA;CAClB,CAAA;AA4HD,eAAO,MAAM,WAAW,kEA6CtB,CAAA;AAEF,eAAO,MAAM,WAAW;;;EAoBtB,CAAA;AAEF,eAAO,MAAM,YAAY;;EASvB,CAAA;AAEF,eAAO,MAAM,YAAY;;;EAcvB,CAAA;AAEF,eAAO,MAAM,eAAe;;;EAiB1B,CAAA;AAEF,eAAO,MAAM,aAAa;;;EAYxB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;EAgBzB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;EA4BxB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;EA4B3B,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;EAkB/B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;EAyBlC,CAAA;AAEF,eAAO,MAAM,aAAa;;;;EAgBxB,CAAA;AAEF,eAAO,MAAM,cAAc;;;EA2BzB,CAAA;AAEF,eAAO,MAAM,cAAc;;;EA2BzB,CAAA;AAgBF,eAAO,MAAM,aAAa;;IAezB,CAAA"}

package/dist/commands/zsets.js

@@ -0,0 +1,504 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zsetsCommands = exports.zpopmaxCommand = exports.zpopminCommand = exports.zcountCommand = exports.zremrangebyscoreCommand = exports.zrangebyscoreCommand = exports.zrevrangeCommand = exports.zrangeCommand = exports.zincrbyCommand = exports.zscoreCommand = exports.zrevrankCommand = exports.zrankCommand = exports.zcardCommand = exports.zremCommand = exports.zaddCommand = void 0;
+const command_definition_1 = require("../core/command-definition");
+const command_schema_1 = require("../core/command-schema");
+const redis_error_1 = require("../core/redis-error");
+const redis_result_1 = require("../core/redis-result");
+const redis_value_1 = require("../core/redis-value");
+const helpers_1 = require("./helpers");
+function getSortedMembers(zset) {
+    return Array.from(zset.members.values()).sort((a, b) => a.score !== b.score
+        ? a.score - b.score
+        : a.member.toString().localeCompare(b.member.toString()));
+}
+function parseFloatArg(s) {
+    const n = Number(s);
+    if (!Number.isFinite(n))
+        throw new redis_error_1.ExpectedFloatError();
+    return n;
+}
+function parseScoreBoundArg(s) {
+    const exclusive = s.startsWith('(');
+    const raw = exclusive ? s.slice(1) : s;
+    if (raw.length === 0)
+        throw new redis_error_1.MinMaxNotFloatError();
+    const normalized = raw.toLowerCase();
+    if (normalized === '+inf')
+        return { value: Infinity, exclusive };
+    if (normalized === '-inf')
+        return { value: -Infinity, exclusive };
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        throw new redis_error_1.MinMaxNotFloatError();
+    return { value: n, exclusive };
+}
+function scoreWithinBounds(score, min, max) {
+    if (min.exclusive ? score <= min.value : score < min.value)
+        return false;
+    if (max.exclusive ? score >= max.value : score > max.value)
+        return false;
+    return true;
+}
+function parsePopCountArg(s) {
+    if (!/^-?\d+$/.test(s)) {
+        throw new redis_error_1.PositiveCountError();
+    }
+    const count = Number(s);
+    if (!Number.isSafeInteger(count) || count < 0) {
+        throw new redis_error_1.PositiveCountError();
+    }
+    return count;
+}
+function createZaddSchema() {
+    return command_schema_1.t.custom((input, index, ctx) => {
+        const key = input[index];
+        if (!key) {
+            throw new redis_error_1.WrongNumberOfArgumentsError(ctx.commandName);
+        }
+        const options = { ch: false, incr: false };
+        let cursor = index + 1;
+        while (cursor < input.length) {
+            const option = input[cursor].toString().toUpperCase();
+            if (option === 'NX') {
+                if (options.condition === 'XX')
+                    throw new redis_error_1.ZaddNxXxConflictError();
+                options.condition = 'NX';
+                cursor++;
+                continue;
+            }
+            if (option === 'XX') {
+                if (options.condition === 'NX')
+                    throw new redis_error_1.ZaddNxXxConflictError();
+                options.condition = 'XX';
+                cursor++;
+                continue;
+            }
+            if (option === 'GT') {
+                if (options.comparison === 'LT') {
+                    throw new redis_error_1.ZaddGtLtNxConflictError();
+                }
+                options.comparison = 'GT';
+                cursor++;
+                continue;
+            }
+            if (option === 'LT') {
+                if (options.comparison === 'GT') {
+                    throw new redis_error_1.ZaddGtLtNxConflictError();
+                }
+                options.comparison = 'LT';
+                cursor++;
+                continue;
+            }
+            if (option === 'CH') {
+                options.ch = true;
+                cursor++;
+                continue;
+            }
+            if (option === 'INCR') {
+                options.incr = true;
+                cursor++;
+                continue;
+            }
+            break;
+        }
+        if (options.condition === 'NX' && options.comparison) {
+            throw new redis_error_1.ZaddGtLtNxConflictError();
+        }
+        const pairs = parseZaddPairs(input, cursor, ctx);
+        if (options.incr && pairs.length !== 1) {
+            throw new redis_error_1.ZaddIncrPairError();
+        }
+        return { value: { key, options, pairs }, nextIndex: input.length };
+    });
+}
+function parseZaddPairs(input, index, ctx) {
+    const pairs = [];
+    let cursor = index;
+    if (cursor >= input.length) {
+        throw new redis_error_1.WrongNumberOfArgumentsError(ctx.commandName);
+    }
+    while (cursor < input.length) {
+        const scoreToken = input[cursor];
+        const memberToken = input[cursor + 1];
+        if (!scoreToken || !memberToken) {
+            throw new redis_error_1.WrongNumberOfArgumentsError(ctx.commandName);
+        }
+        const score = Number(scoreToken.toString());
+        if (!Number.isFinite(score))
+            throw new redis_error_1.ExpectedFloatError();
+        pairs.push({ score, member: memberToken });
+        cursor += 2;
+    }
+    return pairs;
+}
+function shouldApplyZaddUpdate(existing, score, options) {
+    if (!existing)
+        return options.condition !== 'XX';
+    if (options.condition === 'NX')
+        return false;
+    if (options.comparison === 'GT')
+        return score > existing.score;
+    if (options.comparison === 'LT')
+        return score < existing.score;
+    return true;
+}
+function deleteSortedSetIfEmpty(db, key) {
+    if ((db.getSortedSet(key)?.members.size ?? 0) === 0) {
+        db.delete(key);
+    }
+}
+exports.zaddCommand = (0, command_definition_1.defineCommand)({
+    name: 'zadd',
+    schema: createZaddSchema(),
+    flags: ['write', 'denyoom', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        if (args.options.incr) {
+            const [{ score, member }] = args.pairs;
+            const newScore = ctx.db.updateSortedSet(args.key, zset => {
+                const hex = member.toString('hex');
+                const existing = zset.members.get(hex);
+                const nextScore = (existing?.score ?? 0) + score;
+                if (!shouldApplyZaddUpdate(existing, nextScore, args.options)) {
+                    return null;
+                }
+                zset.members.set(hex, { member, score: nextScore });
+                return nextScore;
+            });
+            deleteSortedSetIfEmpty(ctx.db, args.key);
+            return (0, helpers_1.bulk)(newScore === null ? null : Buffer.from(newScore.toString()));
+        }
+        const changed = ctx.db.updateSortedSet(args.key, zset => {
+            let count = 0;
+            for (const { score, member } of args.pairs) {
+                const hex = member.toString('hex');
+                const existing = zset.members.get(hex);
+                if (!shouldApplyZaddUpdate(existing, score, args.options)) {
+                    continue;
+                }
+                if (!existing || args.options.ch) {
+                    if (!existing || existing.score !== score)
+                        count++;
+                }
+                zset.members.set(hex, { member, score });
+            }
+            return count;
+        });
+        deleteSortedSetIfEmpty(ctx.db, args.key);
+        return (0, helpers_1.integer)(changed);
+    },
+});
+exports.zremCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrem',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), members: command_schema_1.t.variadic(command_schema_1.t.key(), { min: 1 }) }),
+    flags: ['write', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        let removed = 0;
+        ctx.db.updateSortedSet(args.key, zset => {
+            for (const member of args.members) {
+                if (zset.members.delete(member.toString('hex')))
+                    removed++;
+            }
+        });
+        if (removed > 0 &&
+            (ctx.db.getSortedSet(args.key)?.members.size ?? 0) === 0) {
+            ctx.db.delete(args.key);
+        }
+        return (0, helpers_1.integer)(removed);
+    },
+});
+exports.zcardCommand = (0, command_definition_1.defineCommand)({
+    name: 'zcard',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key() }),
+    flags: ['readonly', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        return (0, helpers_1.integer)(zset?.members.size ?? 0);
+    },
+});
+exports.zrankCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrank',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), member: command_schema_1.t.key() }),
+    flags: ['readonly', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return redis_result_1.RedisResult.nil();
+        const hex = args.member.toString('hex');
+        if (!zset.members.has(hex))
+            return redis_result_1.RedisResult.nil();
+        const sorted = getSortedMembers(zset);
+        const rank = sorted.findIndex(m => m.member.toString('hex') === hex);
+        return (0, helpers_1.integer)(rank);
+    },
+});
+exports.zrevrankCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrevrank',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), member: command_schema_1.t.key() }),
+    flags: ['readonly', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return redis_result_1.RedisResult.nil();
+        const hex = args.member.toString('hex');
+        if (!zset.members.has(hex))
+            return redis_result_1.RedisResult.nil();
+        const sorted = getSortedMembers(zset);
+        const rank = sorted
+            .slice()
+            .reverse()
+            .findIndex(m => m.member.toString('hex') === hex);
+        return (0, helpers_1.integer)(rank);
+    },
+});
+exports.zscoreCommand = (0, command_definition_1.defineCommand)({
+    name: 'zscore',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), member: command_schema_1.t.key() }),
+    flags: ['readonly', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.bulk)(null);
+        const entry = zset.members.get(args.member.toString('hex'));
+        if (!entry)
+            return (0, helpers_1.bulk)(null);
+        return (0, helpers_1.bulk)(Buffer.from(entry.score.toString()));
+    },
+});
+exports.zincrbyCommand = (0, command_definition_1.defineCommand)({
+    name: 'zincrby',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), increment: command_schema_1.t.string(), member: command_schema_1.t.key() }),
+    flags: ['write', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const inc = parseFloatArg(args.increment);
+        const newScore = ctx.db.updateSortedSet(args.key, zset => {
+            const hex = args.member.toString('hex');
+            const existing = zset.members.get(hex);
+            const score = (existing?.score ?? 0) + inc;
+            zset.members.set(hex, { member: args.member, score });
+            return score;
+        });
+        return (0, helpers_1.bulk)(Buffer.from(newScore.toString()));
+    },
+});
+exports.zrangeCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrange',
+    schema: command_schema_1.t.object({
+        key: command_schema_1.t.key(),
+        start: command_schema_1.t.integer(),
+        stop: command_schema_1.t.integer(),
+        withScores: command_schema_1.t.optional(command_schema_1.t.keyword('WITHSCORES')),
+    }),
+    flags: ['readonly'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.array)([]);
+        const sorted = getSortedMembers(zset);
+        const len = sorted.length;
+        const start = args.start < 0 ? Math.max(0, len + args.start) : args.start;
+        const stop = args.stop < 0 ? len + args.stop : Math.min(args.stop, len - 1);
+        if (start > stop)
+            return (0, helpers_1.array)([]);
+        const slice = sorted.slice(start, stop + 1);
+        const items = [];
+        for (const entry of slice) {
+            items.push(redis_value_1.RedisValue.bulkString(entry.member));
+            if (args.withScores) {
+                items.push(redis_value_1.RedisValue.bulkString(Buffer.from(entry.score.toString())));
+            }
+        }
+        return (0, helpers_1.array)(items);
+    },
+});
+exports.zrevrangeCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrevrange',
+    schema: command_schema_1.t.object({
+        key: command_schema_1.t.key(),
+        start: command_schema_1.t.integer(),
+        stop: command_schema_1.t.integer(),
+        withScores: command_schema_1.t.optional(command_schema_1.t.keyword('WITHSCORES')),
+    }),
+    flags: ['readonly'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.array)([]);
+        const sorted = getSortedMembers(zset).slice().reverse();
+        const len = sorted.length;
+        const start = args.start < 0 ? Math.max(0, len + args.start) : args.start;
+        const stop = args.stop < 0 ? len + args.stop : Math.min(args.stop, len - 1);
+        if (start > stop)
+            return (0, helpers_1.array)([]);
+        const slice = sorted.slice(start, stop + 1);
+        const items = [];
+        for (const entry of slice) {
+            items.push(redis_value_1.RedisValue.bulkString(entry.member));
+            if (args.withScores) {
+                items.push(redis_value_1.RedisValue.bulkString(Buffer.from(entry.score.toString())));
+            }
+        }
+        return (0, helpers_1.array)(items);
+    },
+});
+exports.zrangebyscoreCommand = (0, command_definition_1.defineCommand)({
+    name: 'zrangebyscore',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), min: command_schema_1.t.string(), max: command_schema_1.t.string() }),
+    flags: ['readonly'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const min = parseScoreBoundArg(args.min);
+        const max = parseScoreBoundArg(args.max);
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.array)([]);
+        const items = [];
+        for (const entry of getSortedMembers(zset)) {
+            if (scoreWithinBounds(entry.score, min, max)) {
+                items.push(redis_value_1.RedisValue.bulkString(entry.member));
+            }
+        }
+        return (0, helpers_1.array)(items);
+    },
+});
+exports.zremrangebyscoreCommand = (0, command_definition_1.defineCommand)({
+    name: 'zremrangebyscore',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), min: command_schema_1.t.string(), max: command_schema_1.t.string() }),
+    flags: ['write'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const min = parseScoreBoundArg(args.min);
+        const max = parseScoreBoundArg(args.max);
+        let removed = 0;
+        ctx.db.updateSortedSet(args.key, zset => {
+            for (const [hex, entry] of zset.members) {
+                if (scoreWithinBounds(entry.score, min, max)) {
+                    zset.members.delete(hex);
+                    removed++;
+                }
+            }
+        });
+        if (removed > 0 &&
+            (ctx.db.getSortedSet(args.key)?.members.size ?? 0) === 0) {
+            ctx.db.delete(args.key);
+        }
+        return (0, helpers_1.integer)(removed);
+    },
+});
+exports.zcountCommand = (0, command_definition_1.defineCommand)({
+    name: 'zcount',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), min: command_schema_1.t.string(), max: command_schema_1.t.string() }),
+    flags: ['readonly', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const min = parseScoreBoundArg(args.min);
+        const max = parseScoreBoundArg(args.max);
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.integer)(0);
+        let count = 0;
+        for (const entry of zset.members.values()) {
+            if (scoreWithinBounds(entry.score, min, max))
+                count++;
+        }
+        return (0, helpers_1.integer)(count);
+    },
+});
+exports.zpopminCommand = (0, command_definition_1.defineCommand)({
+    name: 'zpopmin',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), count: command_schema_1.t.optional(zpopCountSchema()) }),
+    flags: ['write', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.array)([]);
+        const count = args.count ?? 1;
+        const sorted = getSortedMembers(zset);
+        const toRemove = sorted.slice(0, count);
+        if (toRemove.length === 0)
+            return (0, helpers_1.array)([]);
+        ctx.db.updateSortedSet(args.key, z => {
+            for (const entry of toRemove) {
+                z.members.delete(entry.member.toString('hex'));
+            }
+        });
+        if ((ctx.db.getSortedSet(args.key)?.members.size ?? 0) === 0) {
+            ctx.db.delete(args.key);
+        }
+        const items = [];
+        for (const entry of toRemove) {
+            items.push(redis_value_1.RedisValue.bulkString(entry.member));
+            items.push(redis_value_1.RedisValue.bulkString(Buffer.from(entry.score.toString())));
+        }
+        return (0, helpers_1.array)(items);
+    },
+});
+exports.zpopmaxCommand = (0, command_definition_1.defineCommand)({
+    name: 'zpopmax',
+    schema: command_schema_1.t.object({ key: command_schema_1.t.key(), count: command_schema_1.t.optional(zpopCountSchema()) }),
+    flags: ['write', 'fast'],
+    keys: args => [args.key],
+    execute: (args, ctx) => {
+        const zset = ctx.db.getSortedSet(args.key);
+        if (!zset)
+            return (0, helpers_1.array)([]);
+        const count = args.count ?? 1;
+        const sorted = getSortedMembers(zset).slice().reverse();
+        const toRemove = sorted.slice(0, count);
+        if (toRemove.length === 0)
+            return (0, helpers_1.array)([]);
+        ctx.db.updateSortedSet(args.key, z => {
+            for (const entry of toRemove) {
+                z.members.delete(entry.member.toString('hex'));
+            }
+        });
+        if ((ctx.db.getSortedSet(args.key)?.members.size ?? 0) === 0) {
+            ctx.db.delete(args.key);
+        }
+        const items = [];
+        for (const entry of toRemove) {
+            items.push(redis_value_1.RedisValue.bulkString(entry.member));
+            items.push(redis_value_1.RedisValue.bulkString(Buffer.from(entry.score.toString())));
+        }
+        return (0, helpers_1.array)(items);
+    },
+});
+function zpopCountSchema() {
+    return command_schema_1.t.custom((input, index, ctx) => {
+        const token = input[index];
+        if (!token) {
+            throw new redis_error_1.WrongNumberOfArgumentsError(ctx.commandName);
+        }
+        return {
+            value: parsePopCountArg(token.toString()),
+            nextIndex: index + 1,
+        };
+    });
+}
+exports.zsetsCommands = [
+    exports.zaddCommand,
+    exports.zremCommand,
+    exports.zcardCommand,
+    exports.zrankCommand,
+    exports.zrevrankCommand,
+    exports.zscoreCommand,
+    exports.zincrbyCommand,
+    exports.zrangeCommand,
+    exports.zrevrangeCommand,
+    exports.zrangebyscoreCommand,
+    exports.zremrangebyscoreCommand,
+    exports.zcountCommand,
+    exports.zpopminCommand,
+    exports.zpopmaxCommand,
+];
+//# sourceMappingURL=zsets.js.map