@upstash/redis 1.0.0-alpha.1 → 1.0.0-alpha.2

package/dist/{zunionstore-462de5d3.d.ts → zunionstore-dffa797d.d.ts}

@@ -1,29 +1,4 @@
-declare type HttpRequest = {
-    path?: string[];
-    /**
-     * Request body will be serialized to json
-     */
-    body?: unknown;
-    headers?: Record<string, string>;
-    retries?: number;
-};
-declare type HttpClientConfig = {
-    headers?: Record<string, string>;
-    baseUrl: string;
-    options?: {
-        backend?: string;
-    };
-};
-declare class HttpClient {
-    baseUrl: string;
-    headers: Record<string, string>;
-    readonly options?: {
-        backend?: string;
-    };
-    constructor(config: HttpClientConfig);
-    private request;
-    post<TResponse>(req: HttpRequest): Promise<TResponse>;
-}
+import { HttpClient } from './http';
 
 /**
  * Command offers default (de)serialization and the exec method to all commands.
@@ -692,4 +667,4 @@ declare class ZUnionStoreCommand extends Command<number, number> {
     constructor(destination: string, numKeys: number, keys: string[], opts?: ZUnionStoreCommandOptions);
 }
 
-export { SetBitCommand as $, AppendCommand as A, BitCountCommand as B, CommandArgs as C, DecrCommand as D, EchoCommand as E, FlushAllCommand as F, GetCommand as G, HttpClient as H, IncrCommand as I, LTrimCommand as J, KeysCommand as K, LIndexCommand as L, MGetCommand as M, NonEmptyArray as N, PExpireCommand as O, PersistCommand as P, PExpireAtCommand as Q, PingCommand as R, PTtlCommand as S, RenameCommand as T, RenameNXCommand as U, RPopCommand as V, ScanCommand as W, SCardCommand as X, SDiffCommand as Y, SDiffStoreCommand as Z, SetCommandOptions as _, BitPosCommand as a, SetRangeCommand as a0, SInterCommand as a1, SInterStoreCommand as a2, SMembersCommand as a3, SPopCommand as a4, SRandMemberCommand as a5, SScanCommand as a6, StrLenCommand as a7, SUnionCommand as a8, SUnionStoreCommand as a9, ZUnionStoreCommandOptions as aA, TouchCommand as aa, TtlCommand as ab, TypeCommand as ac, UnlinkCommand as ad, ScoreMember as ae, ZAddCommandOptions as af, ZAddCommandOptionsWithIncr as ag, ZCardCommand as ah, ZCountCommand as ai, ZInterStoreCommand as aj, ZLexCountCommand as ak, ZPopMaxCommand as al, ZPopMinCommand as am, ZRangeCommand as an, ZRemRangeByLexCommand as ao, ZRemRangeByRankCommand as ap, ZRemRangeByScoreCommand as aq, ZScanCommand as ar, ZUnionStoreCommand as as, Type as at, Command as au, ScanCommandOptions as av, SetCommand as aw, ZAddCommand as ax, ZInterStoreCommandOptions as ay, ZRangeCommandOptions as az, DecrByCommand as b, DelCommand as c, ExistsCommand as d, ExpireCommand as e, ExpireAtCommand as f, FlushDBCommand as g, GetBitCommand as h, GetRangeCommand as i, HDelCommand as j, HExistsCommand as k, HGetCommand as l, HGetAllCommand as m, HIncrByCommand as n, HIncrByFloatCommand as o, HKeysCommand as p, HLenCommand as q, HMGetCommand as r, HScanCommand as s, HStrLenCommand as t, HValsCommand as u, IncrByCommand as v, IncrByFloatCommand as w, LLenCommand as x, LPopCommand as y, LRangeCommand as z };
+export { SetRangeCommand as $, AppendCommand as A, BitCountCommand as B, CommandArgs as C, DecrCommand as D, EchoCommand as E, FlushAllCommand as F, GetCommand as G, HDelCommand as H, IncrCommand as I, PExpireCommand as J, KeysCommand as K, LIndexCommand as L, MGetCommand as M, NonEmptyArray as N, PExpireAtCommand as O, PersistCommand as P, PingCommand as Q, PTtlCommand as R, RenameCommand as S, RenameNXCommand as T, RPopCommand as U, ScanCommand as V, SCardCommand as W, SDiffCommand as X, SDiffStoreCommand as Y, SetCommandOptions as Z, SetBitCommand as _, BitPosCommand as a, SInterCommand as a0, SInterStoreCommand as a1, SMembersCommand as a2, SPopCommand as a3, SRandMemberCommand as a4, SScanCommand as a5, StrLenCommand as a6, SUnionCommand as a7, SUnionStoreCommand as a8, TouchCommand as a9, TtlCommand as aa, TypeCommand as ab, UnlinkCommand as ac, ScoreMember as ad, ZAddCommandOptions as ae, ZAddCommandOptionsWithIncr as af, ZCardCommand as ag, ZCountCommand as ah, ZInterStoreCommand as ai, ZLexCountCommand as aj, ZPopMaxCommand as ak, ZPopMinCommand as al, ZRangeCommand as am, ZRemRangeByLexCommand as an, ZRemRangeByRankCommand as ao, ZRemRangeByScoreCommand as ap, ZScanCommand as aq, ZUnionStoreCommand as ar, Type as as, Command as at, ScanCommandOptions as au, SetCommand as av, ZAddCommand as aw, ZInterStoreCommandOptions as ax, ZRangeCommandOptions as ay, ZUnionStoreCommandOptions as az, DecrByCommand as b, DelCommand as c, ExistsCommand as d, ExpireCommand as e, ExpireAtCommand as f, FlushDBCommand as g, GetBitCommand as h, GetRangeCommand as i, HExistsCommand as j, HGetCommand as k, HGetAllCommand as l, HIncrByCommand as m, HIncrByFloatCommand as n, HKeysCommand as o, HLenCommand as p, HMGetCommand as q, HScanCommand as r, HStrLenCommand as s, HValsCommand as t, IncrByCommand as u, IncrByFloatCommand as v, LLenCommand as w, LPopCommand as x, LRangeCommand as y, LTrimCommand as z };

package/jest.config.js

@@ -0,0 +1,195 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+module.exports = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  bail: true,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances and results before every test
+  // clearMocks: false,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  coveragePathIgnorePatterns: ["/node_modules/", "/dist/", "pkg/test-utils.ts"],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: "./pkg/test_teardown.ts",
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  modulePathIgnorePatterns: ["dist/"],
+
+  // Activates notifications for test results
+  notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  testPathIgnorePatterns: ["/node_modules/", "<rootDir>/pkg/test-utils.ts"],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  verbose: true,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+
+  injectGlobals: false,
+  testTimeout: 60_000,
+}

package/package.json

@@ -1 +1 @@
-{ "name": "@upstash/redis", "version": "v1.0.0-alpha.1", "engines": { "node": ">=10" }, "description": "An HTTP/REST based Redis client built on top of Upstash REST API.", "main": "./dist/index.js", "module": "./dist/index.mjs", "types": "./dist/index.d.ts", "exports": { ".": { "require": "./dist/index.js", "import": "./dist/index.mjs", "types": "./dist/index.d.ts" } }, "files": [ "package.json", "dist" ], "scripts": { "test": "jest -i", "fmt": "pnpm lint && pnpm prettier --write .", "lint": "eslint --ext .ts --fix --ignore-path .gitignore .", "build": "tsup && pnpm size-limit" }, "repository": { "type": "git", "url": "git+https://github.com/upstash/upstash-redis.git" }, "keywords": [ "redis", "database", "serverless", "edge", "upstash" ], "author": "Andreas Thomas <andreas.thomas@chronark.com>", "license": "MIT", "bugs": { "url": "https://github.com/upstash/upstash-redis/issues" }, "homepage": "https://github.com/upstash/upstash-redis#readme", "directories": { "examples": "examples" }, "devDependencies": { "@jest/globals": "^27.4.6", "@size-limit/preset-small-lib": "^7.0.8", "@trivago/prettier-plugin-sort-imports": "^3.2.0", "@types/jest": "^27.4.0", "@types/node": "^17.0.8", "@typescript-eslint/eslint-plugin": "^5.9.1", "@typescript-eslint/parser": "^5.9.1", "dotenv": "^12.0.3", "eslint": "^8.6.0", "eslint-config-prettier": "^8.3.0", "eslint-plugin-prettier": "^4.0.0", "jest": "^27.4.7", "prettier": "^2.5.1", "size-limit": "^7.0.8", "ts-jest": "^27.1.3", "tsup": "^5.11.11", "typescript": "^4.5.5" }, "dependencies": { "isomorphic-fetch": "^3.0.0" }, "browser": { "isomorphic-fetch": false }, "size-limit": [ { "path": "dist/index.js", "limit": "5 KB" }, { "path": "dist/index.mjs", "limit": "5 KB" } ] }
+{ "name": "@upstash/redis", "version": "v1.0.0-alpha.2", "engines": { "node": ">=10" }, "description": "An HTTP/REST based Redis client built on top of Upstash REST API.", "main": "./index.js", "module": "./index.mjs", "types": "./index.d.ts", "scripts": { "test": "jest -i", "fmt": "pnpm lint && pnpm prettier --write .", "lint": "eslint --ext .ts --fix --ignore-path .gitignore .", "build": "tsup && cp package.json ./dist/ && pnpm size-limit" }, "repository": { "type": "git", "url": "git+https://github.com/upstash/upstash-redis.git" }, "keywords": [ "redis", "database", "serverless", "edge", "upstash" ], "author": "Andreas Thomas <andreas.thomas@chronark.com>", "license": "MIT", "bugs": { "url": "https://github.com/upstash/upstash-redis/issues" }, "homepage": "https://github.com/upstash/upstash-redis#readme", "directories": { "examples": "examples" }, "devDependencies": { "@jest/globals": "^27.4.6", "@size-limit/preset-small-lib": "^7.0.8", "@trivago/prettier-plugin-sort-imports": "^3.2.0", "@types/jest": "^27.4.0", "@types/node": "^17.0.8", "@typescript-eslint/eslint-plugin": "^5.9.1", "@typescript-eslint/parser": "^5.9.1", "dotenv": "^12.0.3", "eslint": "^8.6.0", "eslint-config-prettier": "^8.3.0", "eslint-plugin-prettier": "^4.0.0", "jest": "^27.4.7", "prettier": "^2.5.1", "size-limit": "^7.0.8", "ts-jest": "^27.1.3", "tsup": "^5.11.11", "typescript": "^4.5.5" }, "dependencies": { "isomorphic-fetch": "^3.0.0" }, "browser": { "isomorphic-fetch": false }, "size-limit": [ { "path": "dist/index.js", "limit": "5 KB" }, { "path": "dist/index.mjs", "limit": "5 KB" } ] }

package/pkg/cloudflare.ts

@@ -0,0 +1,77 @@
+import * as core from "./redis"
+import { HttpClient } from "./http"
+
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export type RedisConfigCloudflare = {
+  /**
+   * UPSTASH_REDIS_REST_URL
+   */
+  url: string
+
+  /**
+   * UPSTASH_REDIS_REST_TOKEN
+   */
+  token: string
+}
+
+/**
+ * Serverless redis client for upstash.
+ */
+export class Redis extends core.Redis {
+  /**
+   * Create a new redis client
+   *
+   * @example
+   * ```typescript
+   * const redis = new Redis({
+   *  url: "<UPSTASH_REDIS_REST_URL>",
+   *  token: "<UPSTASH_REDIS_REST_TOKEN>",
+   * });
+   * ```
+   */
+  constructor(config: RedisConfigCloudflare) {
+    const client = new HttpClient({
+      baseUrl: config.url,
+      headers: {
+        authorization: `Bearer ${config.token}`,
+      },
+    })
+
+    super(client)
+  }
+
+  /*
+   * Create a new Upstash Redis instance from environment variables on cloudflare.
+   *
+   * This tries to load `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN` from
+   * the global namespace
+   */
+  static fromEnv(): Redis {
+    /**
+     * These should be injected by cloudflare.
+     */
+
+    // @ts-ignore
+    // eslint-disable-next-line no-undef
+    const url = UPSTASH_REDIS_REST_URL
+
+    // @ts-ignore
+    // eslint-disable-next-line no-undef
+    const token = UPSTASH_REDIS_REST_TOKEN
+
+    if (!url) {
+      throw new Error(
+        "Unable to find environment variable: `UPSTASH_REDIS_REST_URL`. Please add it via `wrangler secret put UPSTASH_REDIS_REST_URL`",
+      )
+    }
+    if (!token) {
+      throw new Error(
+        "Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`. Please add it via `wrangler secret put UPSTASH_REDIS_REST_TOKEN`",
+      )
+    }
+    return new Redis({ url, token })
+  }
+}

package/pkg/command.ts

@@ -0,0 +1,40 @@
+import { UpstashError } from "./error"
+import { HttpClient, UpstashResponse } from "./http"
+import { parseResponse } from "./util"
+
+/**
+ * Command offers default (de)serialization and the exec method to all commands.
+ *
+ * TData represents what the user will enter or receive,
+ * TResult is the raw data returned from upstash, which may need to be transformed or parsed.
+ */
+export abstract class Command<TData, TResult> {
+  public readonly command: string[]
+  public deserialize: (result: TResult) => TData
+  /**
+   * Create a new command instance.
+   *
+   * You can define a custom `deserialize` function. By default we try to deserialize as json.
+   */
+  constructor(command: (string | unknown)[], opts?: { deserialize?: (result: TResult) => TData }) {
+    this.command = command.map((c) => (typeof c === "string" ? c : JSON.stringify(c)))
+    this.deserialize = opts?.deserialize ?? parseResponse
+  }
+
+  /**
+   * Execute the command using a client.
+   */
+  public async exec(client: HttpClient): Promise<TData> {
+    const { result, error } = await client.request<UpstashResponse<TResult>>({
+      body: this.command,
+    })
+    if (error) {
+      throw new UpstashError(error)
+    }
+    if (typeof result === "undefined") {
+      throw new Error(`Request did not return a result`)
+    }
+
+    return this.deserialize(result)
+  }
+}

package/pkg/commands/append.test.ts

@@ -0,0 +1,28 @@
+import { AppendCommand } from "./append"
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { describe, it, expect, afterAll } from "@jest/globals"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when key is not set", () => {
+  it("appends to empty value", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    const res = await new AppendCommand(key, value).exec(client)
+    expect(res).toEqual(value.length)
+  })
+})
+
+describe("when key is set", () => {
+  it("appends to existing value", async () => {
+    const key = newKey()
+    const value = randomUUID()
+    const res = await new AppendCommand(key, value).exec(client)
+    expect(res).toEqual(value.length)
+    const res2 = await new AppendCommand(key, "_").exec(client)
+    expect(res2).toEqual(value.length + 1)
+  })
+})

package/pkg/commands/append.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/append
+ */
+export class AppendCommand extends Command<number, number> {
+  constructor(key: string, value: string) {
+    super(["append", key, value])
+  }
+}

package/pkg/commands/bitcount.test.ts

@@ -0,0 +1,36 @@
+import { BitCountCommand } from "./bitcount"
+import { keygen, newHttpClient } from "../test-utils"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when key is not set", () => {
+  it("returns 0", async () => {
+    const key = newKey()
+    const res = await new BitCountCommand(key).exec(client)
+    expect(res).toEqual(0)
+  })
+})
+
+describe("when key is set", () => {
+  it("returns bitcount", async () => {
+    const key = newKey()
+    const value = "Hello World"
+    await new SetCommand(key, value).exec(client)
+    const res = await new BitCountCommand(key).exec(client)
+    expect(res).toEqual(43)
+  })
+
+  describe("with start and end", () => {
+    it("returns bitcount", async () => {
+      const key = newKey()
+      const value = "Hello World"
+      await new SetCommand(key, value).exec(client)
+      const res = await new BitCountCommand(key, 4, 8).exec(client)
+      expect(res).toEqual(22)
+    })
+  })
+})

package/pkg/commands/bitcount.ts

@@ -0,0 +1,19 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/bitcount
+ */
+export class BitCountCommand extends Command<number, number> {
+  constructor(key: string, start?: never, end?: never)
+  constructor(key: string, start: number, end: number)
+  constructor(key: string, start?: number, end?: number) {
+    const command: unknown[] = ["bitcount", key]
+    if (typeof start === "number") {
+      command.push(start)
+    }
+    if (typeof end === "number") {
+      command.push(end)
+    }
+    super(command)
+  }
+}

package/pkg/commands/bitop.test.ts

@@ -0,0 +1,44 @@
+import { BitOpCommand } from "./bitop"
+import { keygen, newHttpClient } from "../test-utils"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when key is not set", () => {
+  it("returns 0", async () => {
+    const source = newKey()
+    const dest = newKey()
+    const res = await new BitOpCommand("and", dest, source).exec(client)
+    expect(res).toEqual(0)
+  })
+})
+
+describe("when key is set", () => {
+  describe("not", () => {
+    it("inverts all bits", async () => {
+      const source = newKey()
+      const sourcevalue = "Hello World"
+      const dest = newKey()
+      const destValue = "foo: bar"
+      await new SetCommand(source, sourcevalue).exec(client)
+      await new SetCommand(dest, destValue).exec(client)
+      const res = await new BitOpCommand("not", dest, source).exec(client)
+      expect(res).toEqual(11)
+    })
+  })
+  describe("and", () => {
+    it("works", async () => {
+      const source = newKey()
+      const sourcevalue = "Hello World"
+      const dest = newKey()
+      const destValue = "foo: bar"
+      await new SetCommand(source, sourcevalue).exec(client)
+      await new SetCommand(dest, destValue).exec(client)
+      const res = await new BitOpCommand("and", dest, source).exec(client)
+      expect(res).toEqual(11)
+    })
+  })
+})

package/pkg/commands/bitop.ts

@@ -0,0 +1,22 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/bitop
+ */
+export class BitOpCommand extends Command<number, number> {
+  constructor(
+    op: "and" | "or" | "xor",
+    destinationKey: string,
+    sourceKey: string,
+    ...sourceKeys: string[]
+  )
+  constructor(op: "not", destinationKey: string, sourceKey: string)
+  constructor(
+    op: "and" | "or" | "xor" | "not",
+    destinationKey: string,
+    sourceKey: string,
+    ...sourceKeys: string[]
+  ) {
+    super(["bitop", op, destinationKey, sourceKey, ...sourceKeys])
+  }
+}

package/pkg/commands/bitpos.test.ts

@@ -0,0 +1,26 @@
+import { BitPosCommand } from "./bitpos"
+import { keygen, newHttpClient } from "../test-utils"
+import { describe, it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+describe("when key is not set", () => {
+  it("returns 0", async () => {
+    const key = newKey()
+    const res = await new BitPosCommand(key, 1, 1).exec(client)
+    expect(res).toEqual(-1)
+  })
+})
+
+describe("when key is set", () => {
+  it("returns position of first set bit", async () => {
+    const key = newKey()
+    const value = "Hello World"
+    await new SetCommand(key, value).exec(client)
+    const res = await new BitPosCommand(key, 2, 3).exec(client)
+    expect(res).toEqual(24)
+  })
+})

package/pkg/commands/bitpos.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/bitpos
+ */
+export class BitPosCommand extends Command<number, number> {
+  constructor(key: string, start: number, end: number) {
+    super(["bitpos", key, start, end])
+  }
+}

package/pkg/commands/dbsize.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { randomUUID } from "crypto"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { DBSizeCommand } from "./dbsize"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("returns the db size", async () => {
+  const key = newKey()
+  const value = randomUUID()
+  await new SetCommand(key, value).exec(client)
+  const res = await new DBSizeCommand().exec(client)
+  expect(res).toBeGreaterThan(0)
+})

package/pkg/commands/dbsize.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/dbsize
+ */
+export class DBSizeCommand extends Command<number, number> {
+  constructor() {
+    super(["dbsize"])
+  }
+}

package/pkg/commands/decr.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { it, expect, afterAll } from "@jest/globals"
+import { SetCommand } from "./set"
+import { DecrCommand } from "./decr"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+it("decrements a non-existing value", async () => {
+  const key = newKey()
+  const res = await new DecrCommand(key).exec(client)
+
+  expect(res).toEqual(-1)
+})
+
+it("decrements and existing value", async () => {
+  const key = newKey()
+  await new SetCommand(key, 4).exec(client)
+  const res = await new DecrCommand(key).exec(client)
+
+  expect(res).toEqual(3)
+})

package/pkg/commands/decr.ts

@@ -0,0 +1,10 @@
+import { Command } from "../command"
+
+/**
+ * @see https://redis.io/commands/decr
+ */
+export class DecrCommand extends Command<number, number> {
+  constructor(key: string) {
+    super(["decr", key])
+  }
+}

package/pkg/commands/decrby.test.ts

@@ -0,0 +1,23 @@
+import { keygen, newHttpClient } from "../test-utils"
+import { SetCommand } from "./set"
+import { DecrByCommand } from "./decrby"
+import { it, expect, afterAll } from "@jest/globals"
+const client = newHttpClient()
+
+const { newKey, cleanup } = keygen()
+afterAll(cleanup)
+
+it("decrements a non-existing value", async () => {
+  const key = newKey()
+  const res = await new DecrByCommand(key, 2).exec(client)
+
+  expect(res).toEqual(-2)
+})
+
+it("decrements and existing value", async () => {
+  const key = newKey()
+  await new SetCommand(key, 5).exec(client)
+  const res = await new DecrByCommand(key, 2).exec(client)
+
+  expect(res).toEqual(3)
+})