convex 1.44.0 → 1.45.0

package/src/values/value.test.ts

@@ -1,232 +0,0 @@
-import { test, expect, describe } from "vitest";
-import { randomBytes } from "crypto";
-
-import {
-  slowBase64ToBigInt,
-  slowBigIntToBase64,
-  modernBase64ToBigInt,
-  modernBigIntToBase64,
-  convexToJson,
-  jsonToConvex,
-  commitTsPlaceholder,
-} from "./value.js";
-import { compareValues } from "./compare.js";
-
-describe("convexToJson", () => {
-  test("serializes objects", () => {
-    expect(
-      convexToJson({
-        property: "value",
-      }),
-    ).toEqual({ property: "value" });
-  });
-
-  test("serializes objects created with Object.create", () => {
-    const obj = Object.create(null);
-    obj.property = "value";
-    expect(convexToJson(obj)).toEqual({ property: "value" });
-  });
-
-  test("serializes objects with BigInt values", () => {
-    expect(
-      convexToJson({
-        property: BigInt("5151996"),
-      }),
-    ).toEqual({ property: { $integer: "/JxOAAAAAAA=" } });
-  });
-
-  test("throws an error on class instances", () => {
-    expect(() => {
-      convexToJson(new Date(0) as any);
-    }).toThrow(/Date.*is not a supported Convex type/);
-  });
-
-  test("throws an error on class instances inside object", () => {
-    expect(() => {
-      convexToJson({ hello: new Date(0) } as any);
-    }).toThrow(
-      /Date.*is not a supported Convex type \(present at path .hello in original object/,
-    );
-  });
-
-  test("throws an informative error on undefined array", () => {
-    expect(() => {
-      convexToJson([undefined] as any);
-    }).toThrow(
-      'undefined is not a valid Convex value (present at path [0] in original object ["undefined"]).',
-    );
-  });
-
-  test("throws an informative error on undefined", () => {
-    expect(() => {
-      convexToJson(undefined as any);
-    }).toThrow("undefined is not a valid Convex value.");
-  });
-
-  test("supports undefined keys in objects", () => {
-    expect(
-      convexToJson({
-        property: undefined,
-      }),
-    ).toEqual({});
-  });
-
-  // BigInts throw in JSON.stringify, so ensure we can format them in errors.
-  test("doesn't crash on bigint error", () => {
-    expect(() => {
-      convexToJson({ bigint: BigInt("123"), bad: [undefined] } as any);
-    }).toThrow(
-      'undefined is not a valid Convex value (present at path .bad[0] in original object {"bigint":"123n","bad":["undefined"]})',
-    );
-  });
-});
-
-describe("jsonToConvex", () => {
-  test("deserializes object with BigInt value", () => {
-    expect(jsonToConvex({ property: { $integer: "/JxOAAAAAAA=" } })).toEqual({
-      property: BigInt("5151996"),
-    });
-  });
-});
-
-describe("commit timestamp sentinel", () => {
-  test("round trips through JSON as the singleton", () => {
-    const decoded = jsonToConvex({ property: { $commitTs: null } }) as any;
-    expect(decoded.property).toBe(commitTsPlaceholder);
-    expect(convexToJson({ property: commitTsPlaceholder as any })).toEqual({
-      property: { $commitTs: null },
-    });
-  });
-
-  test("rejects malformed tokens", () => {
-    expect(() => jsonToConvex({ $commitTs: 1 } as any)).toThrow(
-      /Malformed \$commitTs/,
-    );
-    // A `$commitTs` key alongside other fields is not the token; it's an
-    // invalid field name.
-    expect(() => jsonToConvex({ $commitTs: null, x: 1 })).toThrow(/reserved/);
-  });
-
-  test("throws on coercion", () => {
-    expect(() => Number(commitTsPlaceholder)).toThrow(/unresolved/);
-    expect(() => (commitTsPlaceholder as any) + 1n).toThrow(/unresolved/);
-    expect(() => JSON.stringify({ commitTs: commitTsPlaceholder })).toThrow(
-      /unresolved/,
-    );
-    expect(`${commitTsPlaceholder as any}`).toEqual(
-      "[unresolved commit timestamp]",
-    );
-  });
-});
-
-describe("bigints in Safari 14", () => {
-  test("roundtrips BigInt even in Safari 14", () => {
-    // https://caniuse.com/mdn-javascript_builtins_dataview_setbigint64
-    const origGetBigInt64 = DataView.prototype.getBigInt64;
-    const origSetBigInt64 = DataView.prototype.setBigInt64;
-    DataView.prototype.getBigInt64 = () => {
-      throw new Error("doesn't exist in Safari 14");
-    };
-    DataView.prototype.setBigInt64 = () => {
-      throw new Error("doesn't exist in Safari 14");
-    };
-    try {
-      const orig = "/JxOAAAAAAA=";
-      expect(slowBigIntToBase64(slowBase64ToBigInt(orig))).toEqual(orig);
-    } finally {
-      DataView.prototype.getBigInt64 = origGetBigInt64;
-      DataView.prototype.setBigInt64 = origSetBigInt64;
-    }
-  });
-});
-
-const MIN_INT64 = BigInt("-9223372036854775808");
-const MAX_INT64 = BigInt("9223372036854775807");
-
-function randomSignedInt64Bigint() {
-  return BigInt("0x" + randomBytes(8).toString("hex")) + MIN_INT64;
-}
-
-describe("Our hand-rolled bigint code matches the fast implementation", () => {
-  test("bigInt to bytes to bigint match", () => {
-    const tests = [
-      BigInt("0"),
-      BigInt("1"),
-      BigInt("-1"),
-      MAX_INT64,
-      MIN_INT64,
-      ...[...Array(100).keys()].map(randomSignedInt64Bigint),
-    ];
-    for (const num of tests) {
-      const expectedS = modernBigIntToBase64(num);
-      const s = slowBigIntToBase64(num);
-      expect(s).toEqual(expectedS);
-
-      const numAgain = slowBase64ToBigInt(s);
-      expect(numAgain).toEqual(modernBase64ToBigInt(s));
-      expect(numAgain).toEqual(num);
-    }
-  });
-});
-
-describe("compare", () => {
-  test("NaNs and negative zero", () => {
-    const positiveNaN = Number.NaN;
-    // Create DataViews for bit-level comparison
-    const buffer = new ArrayBuffer(8);
-    new DataView(buffer).setFloat64(0, positiveNaN, /* little-endian */ true);
-
-    // Read as BigInt to compare bits
-    const v1Bits = BigInt(
-      new DataView(buffer).getBigInt64(0, /* little-endian */ true),
-    );
-    // Flip the sign bit
-    const negativeNaNBits = v1Bits | 0x8000000000000000n;
-    // Convert back to a number
-    const negativeNaNBuffer = new ArrayBuffer(8);
-    new DataView(negativeNaNBuffer).setBigInt64(
-      0,
-      negativeNaNBits,
-      /* little-endian */ true,
-    );
-    const negativeNaN = new DataView(negativeNaNBuffer).getFloat64(
-      0,
-      /* little-endian */ true,
-    );
-    const values = [negativeNaN, -0, 0, 1, positiveNaN];
-    function repr(v: number) {
-      if (v === 0) {
-        return "-NaN";
-      }
-      if (v === 1) {
-        return "-0";
-      }
-      if (v === 2) {
-        return "0";
-      }
-      if (v === 3) {
-        return "1";
-      }
-      if (v === 4) {
-        return "+NaN";
-      }
-    }
-
-    for (let i = 0; i < values.length; i++) {
-      for (let j = i + 1; j < values.length; j++) {
-        const v1 = values[i];
-        const v2 = values[j];
-        expect(compareValues(v1, v2), `compare ${repr(i)} ${repr(j)}`).toEqual(
-          -1,
-        );
-        expect(compareValues(v2, v1), `compare ${repr(j)} ${repr(i)}`).toEqual(
-          1,
-        );
-      }
-    }
-  });
-
-  test("commit timestamp placeholders compare equal", () => {
-    expect(compareValues(commitTsPlaceholder, commitTsPlaceholder)).toEqual(0);
-  });
-});

package/src/vendor/README.md

@@ -1,18 +0,0 @@
-It's useful to vendor dependencies that are pretty stable and unlikely to
-receive security updates: we can remove parts we don't use for a smaller bundle
-and we spare our users runtime dependencies to install. We know how our library
-needs to be bundled,
-
-Some thoughts from tmwc on this:
-
-- https://blog.val.town/gardening-dependencies
-- https://macwright.com/2021/03/11/vendor-by-default
-
-We're currently vendoring just a few libraries:
-
-1. long.js, which only need a small amount of functionality of.
-1. jwt-decode which has caused some users trouble when installing deps
-1. jwt-encode is gone from GitHub, very short, and the published version uses an
-   old crypto lib we can avoid using by vendoring and swapping it out.
-1. progress is by good old TJ but it hasn't been published in 7 years and is
-   tiny.

package/src/vendor/jwt-decode/README.md

@@ -1 +0,0 @@
-Copied from https://github.com/auth0/jwt-decode