@upstash/redis 0.0.0-ci.babdc47f97e036e2863dfed16300cda2b97bf6ad-20240322001434 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/pkg/script.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { Redis } from "./redis";
+import { keygen, newHttpClient, randomID } from "./test-utils";
+const client = newHttpClient();
+
+const { cleanup } = keygen();
+afterEach(cleanup);
+
+describe("create a new script", () => {
+  test(
+    "creates a new script",
+    async () => {
+      const redis = new Redis(client);
+      const script = redis.createScript("return ARGV[1];");
+
+      const res = await script.eval([], ["Hello World"]);
+      expect(res).toEqual("Hello World");
+    },
+    { timeout: 15_000 }
+  );
+});
+
+describe("sha1", () => {
+  test("calculates the correct sha1", () => {
+    const redis = new Redis(client);
+    const script = redis.createScript("The quick brown fox jumps over the lazy dog");
+
+    expect(script.sha1).toEqual("2fd4e1c67a2d28fced849ee1bb76e7391b93eb12");
+  });
+
+  test("calculates the correct sha1 for empty string", () => {
+    const redis = new Redis(client);
+    const script = redis.createScript("");
+
+    expect(script.sha1).toEqual("da39a3ee5e6b4b0d3255bfef95601890afd80709");
+  });
+});
+
+describe("script gets loaded", () => {
+  test("following evalsha command is a hit", async () => {
+    const id = randomID();
+    const s = `return "${id}";`;
+    const redis = new Redis(client);
+    const script = redis.createScript(s);
+
+    let hasThrown = false;
+
+    await script.evalsha([], []).catch(() => {
+      hasThrown = true;
+    });
+    expect(hasThrown).toBeTrue();
+    const res = await script.exec([], []);
+    expect(res).toEqual(id);
+
+    const res2 = await script.evalsha([], []);
+    expect(res2).toEqual(id);
+  });
+});

package/pkg/script.ts

@@ -0,0 +1,67 @@
+import Hex from "crypto-js/enc-hex.js";
+import sha1 from "crypto-js/sha1.js";
+import type { Redis } from "./redis";
+/**
+ * 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.
+ *
+ * @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")
+ * ```
+ */
+export class Script<TResult = unknown> {
+  public readonly script: string;
+  public readonly sha1: string;
+  private readonly redis: Redis;
+
+  constructor(redis: Redis, script: string) {
+    this.redis = redis;
+    this.sha1 = this.digest(script);
+    this.script = script;
+  }
+
+  /**
+   * Send an `EVAL` command to redis.
+   */
+  public async eval(keys: string[], args: string[]): Promise<TResult> {
+    return await this.redis.eval(this.script, keys, args);
+  }
+
+  /**
+   * Calculates the sha1 hash of the script and then calls `EVALSHA`.
+   */
+  public async evalsha(keys: string[], args: string[]): Promise<TResult> {
+    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
+   */
+  public async exec(keys: string[], args: string[]): Promise<TResult> {
+    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 as TResult;
+  }
+
+  /**
+   * Compute the sha1 hash of the script and return its hex representation.
+   */
+  private digest(s: string): string {
+    return Hex.stringify(sha1(s));
+  }
+}

package/pkg/test-utils.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test";
+
+import { randomUnsafeIntegerString } from "./test-utils";
+
+test("randomUnsafeIntegerString() should return a string", () => {
+  const result = randomUnsafeIntegerString();
+  expect(typeof result).toEqual("string");
+});
+test("randomUnsafeIntegerString() should return different values", () => {
+  const result1 = randomUnsafeIntegerString();
+  const result2 = randomUnsafeIntegerString();
+  expect(result1).not.toEqual(result2);
+});
+test("randomUnsafeIntegerString() should return a string with unsafe integer", () => {
+  const result = randomUnsafeIntegerString();
+  expect(Number.isSafeInteger(Number(result))).toBeFalse();
+});

package/pkg/test-utils.ts

@@ -0,0 +1,72 @@
+import { DelCommand } from "./commands/del";
+import { XAddCommand } from "./commands/xadd";
+import { HttpClient } from "./http";
+
+/**
+ * crypto.randomUUID() is not available in dnt crypto shim
+ */
+export function randomID(): string {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+
+  const s: string[] = [];
+  for (let i = 0; i < bytes.byteLength; i++) {
+    s.push(String.fromCodePoint(bytes[i]));
+  }
+  return btoa(s.join(""));
+}
+export const randomUnsafeIntegerString = (): string => {
+  const buffer = new Uint8Array(8);
+  crypto.getRandomValues(buffer);
+  const dataView = new DataView(buffer.buffer);
+  const unsafeInteger = dataView.getBigInt64(0, true); // true for little-endian
+  return unsafeInteger.toString();
+};
+export const newHttpClient = () => {
+  const url = process.env.UPSTASH_REDIS_REST_URL;
+  if (!url) {
+    throw new Error("Could not find url");
+  }
+  const token = process.env.UPSTASH_REDIS_REST_TOKEN;
+  if (!token) {
+    throw new Error("Could not find token");
+  }
+
+  return new HttpClient({
+    baseUrl: url,
+    headers: { authorization: `Bearer ${token}` },
+  });
+};
+
+export function keygen(): {
+  newKey: () => string;
+  cleanup: () => Promise<void>;
+} {
+  const keys: string[] = [];
+  return {
+    newKey: () => {
+      const key = randomID();
+      keys.push(key);
+      return key;
+    },
+    cleanup: async () => {
+      if (keys.length > 0) {
+        await new DelCommand(keys).exec(newHttpClient());
+      }
+    },
+  };
+}
+
+export async function addNewItemToStream(streamKey: string, client: HttpClient) {
+  const field1 = "field1";
+  const member1 = randomID();
+  const field2 = "field2";
+  const member2 = randomID();
+
+  const res = await new XAddCommand([
+    streamKey,
+    "*",
+    { [field1]: member1, [field2]: member2 },
+  ]).exec(client);
+  return { member1, member2, streamId: res };
+}

package/pkg/types.ts

@@ -0,0 +1,35 @@
+export type CommandArgs<TCommand extends new (..._args: any) => any> =
+  ConstructorParameters<TCommand>[0];
+
+export type Telemetry = {
+  /**
+   * Upstash-Telemetry-Sdk
+   * @example @upstash/redis@v1.1.1
+   */
+  sdk?: string;
+
+  /**
+   * Upstash-Telemetry-Platform
+   * @example cloudflare
+   */
+  platform?: string;
+
+  /**
+   * Upstash-Telemetry-Runtime
+   * @example node@v18
+   */
+  runtime?: string;
+};
+
+export type RedisOptions = {
+  /**
+   * Automatically try to deserialize the returned data from upstash using `JSON.deserialize`
+   *
+   * @default true
+   */
+  automaticDeserialization?: boolean;
+  latencyLogging?: boolean;
+  enableTelemetry?: boolean;
+  enableAutoPipelining?: boolean;
+  readYourWrites?: boolean;
+};

package/pkg/util.ts

@@ -0,0 +1,42 @@
+function parseRecursive(obj: unknown): unknown {
+  const parsed = Array.isArray(obj)
+    ? obj.map((o) => {
+        try {
+          return parseRecursive(o);
+        } catch {
+          return o;
+        }
+      })
+    : JSON.parse(obj as string);
+
+  /**
+   * Parsing very large numbers can result in MAX_SAFE_INTEGER
+   * overflow. In that case we return the number as string instead.
+   */
+  if (typeof parsed === "number" && parsed.toString() !== obj) {
+    return obj;
+  }
+  return parsed;
+}
+
+export function parseResponse<TResult>(result: unknown): TResult {
+  try {
+    /**
+     * Try to parse the response if possible
+     */
+    return parseRecursive(result) as TResult;
+  } catch {
+    return result as TResult;
+  }
+}
+
+/**
+ * Deserializes a scan result, excluding the cursor
+ * which can be string "0" or a big number string.
+ * Either way, we want it to stay as a string.
+ *
+ * @param result
+ */
+export function deserializeScanResponse<TResult>(result: [string, ...any]): TResult {
+  return [result[0], ...parseResponse<any[]>(result.slice(1))] as TResult;
+}

package/platforms/cloudflare.ts

@@ -0,0 +1,144 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import type { RequesterConfig } from "../pkg/http";
+import { HttpClient } from "../pkg/http";
+import * as core from "../pkg/redis";
+import { VERSION } from "../version";
+
+type Env = {
+  UPSTASH_DISABLE_TELEMETRY?: string;
+};
+
+export * as errors from "../pkg/error";
+export type * from "../pkg/commands/types";
+
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export type RedisConfigCloudflare = {
+  /**
+   * UPSTASH_REDIS_REST_URL
+   */
+  url: string | undefined;
+  /**
+   * UPSTASH_REDIS_REST_TOKEN
+   */
+  token: string | undefined;
+  /**
+   * The signal will allow aborting requests on the fly.
+   * For more check: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+   */
+  signal?: AbortSignal;
+  keepAlive?: boolean;
+
+  /**
+   * When this flag is enabled, any subsequent commands issued by this client are guaranteed to observe the effects of all earlier writes submitted by the same client.
+   */
+  readYourWrites?: boolean;
+} & core.RedisOptions &
+  RequesterConfig &
+  Env;
+
+/**
+ * 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, env?: Env) {
+    if (!config.url) {
+      throw new Error(
+        `[Upstash Redis] The 'url' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (!config.token) {
+      throw new Error(
+        `[Upstash Redis] The 'token' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (config.url.startsWith(" ") || config.url.endsWith(" ") || /\r|\n/.test(config.url)) {
+      console.warn("The redis url contains whitespace or newline, which can cause errors!");
+    }
+    if (config.token.startsWith(" ") || config.token.endsWith(" ") || /\r|\n/.test(config.token)) {
+      console.warn("The redis token contains whitespace or newline, which can cause errors!");
+    }
+
+    const client = new HttpClient({
+      retry: config.retry,
+      baseUrl: config.url,
+      headers: { authorization: `Bearer ${config.token}` },
+      responseEncoding: config.responseEncoding,
+      signal: config.signal,
+      keepAlive: config.keepAlive,
+      readYourWrites: config.readYourWrites,
+    });
+
+    super(client, {
+      enableTelemetry: !env?.UPSTASH_DISABLE_TELEMETRY,
+      automaticDeserialization: config.automaticDeserialization,
+      latencyLogging: config.latencyLogging,
+      enableAutoPipelining: config.enableAutoPipelining,
+    });
+    // This is only added of the user has not disabled telemetry
+    this.addTelemetry({
+      platform: "cloudflare",
+      sdk: `@upstash/redis@${VERSION}`,
+    });
+
+    if (this.enableAutoPipelining) {
+      return this.autoPipeline();
+    }
+  }
+
+  /*
+   * 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
+   *
+   * If you are using a module worker, please pass in the `env` object.
+   * ```ts
+   * const redis = Redis.fromEnv(env)
+   * ```
+   */
+  static fromEnv(
+    env?: {
+      UPSTASH_REDIS_REST_URL: string;
+      UPSTASH_REDIS_REST_TOKEN: string;
+      UPSTASH_DISABLE_TELEMETRY?: string;
+    },
+    opts?: Omit<RedisConfigCloudflare, "url" | "token">
+  ): Redis {
+    // @ts-expect-error These will be defined by cloudflare
+    const url = env?.UPSTASH_REDIS_REST_URL ?? UPSTASH_REDIS_REST_URL;
+
+    // @ts-expect-error These will be defined by cloudflare
+    const token = env?.UPSTASH_REDIS_REST_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({ ...opts, url, token }, env);
+  }
+}
+
+export { type Requester, type UpstashRequest, type UpstashResponse } from "../pkg/http";
+export { type Pipeline } from "../pkg/pipeline";

package/platforms/fastly.ts

@@ -0,0 +1,100 @@
+import type { RequesterConfig } from "../pkg/http";
+
+import { HttpClient } from "../pkg/http";
+import * as core from "../pkg/redis";
+import { VERSION } from "../version";
+
+export * as errors from "../pkg/error";
+export type * from "../pkg/commands/types";
+
+/**
+ * Connection credentials for upstash redis.
+ * Get them from https://console.upstash.com/redis/<uuid>
+ */
+export type RedisConfigFastly = {
+  /**
+   * UPSTASH_REDIS_REST_URL
+   */
+  url: string | undefined;
+  /**
+   * UPSTASH_REDIS_REST_TOKEN
+   */
+  token: string | undefined;
+  /**
+   * A Request can be forwarded to any backend defined on your service. Backends
+   * can be created via the Fastly CLI, API, or web interface, and are
+   * referenced by name.
+   */
+  backend: string;
+  keepAlive?: boolean;
+
+  /**
+   * When this flag is enabled, any subsequent commands issued by this client are guaranteed to observe the effects of all earlier writes submitted by the same client.
+   */
+  readYourWrites?: boolean;
+} & core.RedisOptions &
+  RequesterConfig;
+
+/**
+ * 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>",
+   *        backend: "upstash-db",
+   *    });
+   * ```
+   */
+  constructor(config: RedisConfigFastly) {
+    if (!config.url) {
+      throw new Error(
+        `[Upstash Redis] The 'url' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (!config.token) {
+      throw new Error(
+        `[Upstash Redis] The 'token' property is missing or undefined in your Redis config.`
+      );
+    }
+
+    if (config.url.startsWith(" ") || config.url.endsWith(" ") || /\r|\n/.test(config.url)) {
+      console.warn("The redis url contains whitespace or newline, which can cause errors!");
+    }
+    if (config.token.startsWith(" ") || config.token.endsWith(" ") || /\r|\n/.test(config.token)) {
+      console.warn("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();
+    }
+  }
+}
+
+export { type Requester, type UpstashRequest, type UpstashResponse } from "../pkg/http";
+export { type Pipeline } from "../pkg/pipeline";