convex 1.44.0 → 1.45.0

package/src/server/database_api.test.ts

@@ -1,439 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from "vitest";
-import { setupWriter } from "./impl/database_impl.js";
-import * as syscall from "./impl/syscall.js";
-import { GenericId, v } from "../values/index.js";
-import { version } from "../index.js";
-import { GenericDatabaseWriter } from "./database.js";
-import {
-  DataModelFromSchemaDefinition,
-  defineSchema,
-  defineTable,
-} from "./schema.js";
-
-vi.mock("./impl/syscall.js", () => ({
-  performAsyncSyscall: vi.fn().mockResolvedValue({}),
-}));
-
-const testId = "test_id" as GenericId<"testTable">;
-const testSystemId = "test_system_id" as GenericId<"_storage">;
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("DB APIs work with the deprecated API (implicit table names)", () => {
-  test("get", async () => {
-    const db = setupWriter();
-    await db.get(testId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/get",
-      {
-        id: "test_id",
-        isSystem: false,
-        version: expect.any(String),
-      },
-    );
-  });
-
-  test("get (system table)", async () => {
-    const db = setupWriter();
-    await db.system.get(testSystemId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/get",
-      {
-        id: "test_system_id",
-        isSystem: true,
-        version,
-      },
-    );
-  });
-
-  test("patch", async () => {
-    const db = setupWriter();
-    await db.patch(testId, {
-      name: "updated",
-      email: undefined,
-    });
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/shallowMerge",
-      {
-        id: "test_id",
-        value: {
-          name: "updated",
-          email: {
-            $undefined: null,
-          },
-        },
-      },
-    );
-  });
-
-  test("replace", async () => {
-    const db = setupWriter();
-    await db.replace(testId, {
-      name: "replaced",
-    });
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/replace",
-      {
-        id: "test_id",
-        value: { name: "replaced" },
-      },
-    );
-  });
-
-  test("delete", async () => {
-    const db = setupWriter();
-    await db.delete(testId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/remove",
-      {
-        id: "test_id",
-      },
-    );
-  });
-});
-
-describe("DB APIs fail when missing arguments", () => {
-  describe("get", () => {
-    test("0 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.get()).rejects.toThrow();
-    });
-  });
-
-  describe("patch", () => {
-    test("0 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.patch()).rejects.toThrow();
-    });
-
-    test("1 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.patch(testId)).rejects.toThrow();
-    });
-  });
-
-  describe("replace", () => {
-    test("0 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.replace()).rejects.toThrow();
-    });
-
-    test("1 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.replace(testId)).rejects.toThrow();
-    });
-  });
-
-  describe("delete", () => {
-    test("0 arg", async () => {
-      const db = setupWriter();
-      // @ts-expect-error
-      await expect(() => db.delete()).rejects.toThrow();
-    });
-  });
-});
-
-describe("new DB APIs work with explicit table names", () => {
-  test("get", async () => {
-    const db = setupWriter();
-    await db.get("testTable", testId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/get",
-      {
-        id: "test_id",
-        table: "testTable",
-        isSystem: false,
-        version,
-      },
-    );
-  });
-
-  test("get (system table)", async () => {
-    const db = setupWriter();
-    await db.system.get("_storage", testSystemId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/get",
-      {
-        id: "test_system_id",
-        table: "_storage",
-        isSystem: true,
-        version,
-      },
-    );
-  });
-
-  test("patch", async () => {
-    const db = setupWriter();
-    await db.patch("testTable", testId, {
-      name: "updated",
-    });
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/shallowMerge",
-      {
-        id: "test_id",
-        table: "testTable",
-        value: {
-          name: "updated",
-        },
-      },
-    );
-  });
-
-  test("replace", async () => {
-    const db = setupWriter();
-    await db.replace("testTable", testId, {
-      name: "replaced",
-    });
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/replace",
-      {
-        id: "test_id",
-        table: "testTable",
-        value: { name: "replaced" },
-      },
-    );
-  });
-
-  test("delete", async () => {
-    const db = setupWriter();
-    await db.delete("testTable", testId);
-
-    expect(vi.mocked(syscall.performAsyncSyscall)).toHaveBeenCalledWith(
-      "1.0/remove",
-      {
-        id: "test_id",
-        table: "testTable",
-      },
-    );
-  });
-});
-
-test("new DB APIs can be used with multiple tables at once", () => {
-  type AllowedTableNames = "table1" | "table2";
-
-  const _schema = defineSchema({
-    table1: defineTable({
-      name: v.string(),
-    }),
-    table2: defineTable({
-      name: v.string(),
-    }),
-  });
-  type DataModel = DataModelFromSchemaDefinition<typeof _schema>;
-
-  async function _shouldTypecheck(
-    tableName: AllowedTableNames,
-    id: GenericId<AllowedTableNames>,
-  ) {
-    const db: GenericDatabaseWriter<DataModel> = setupWriter();
-    await db.get(tableName, id);
-    await db.patch(tableName, id, {
-      name: "test",
-    });
-    await db.insert(tableName, {
-      name: "test",
-    });
-    await db.insert(tableName, {
-      // @ts-expect-error -- field doesn’t exist on table1 or table2
-      incorrect: "field",
-    });
-    await db.delete(tableName, id);
-  }
-});
-
-describe("new DB APIs don’t type check if used with the wrong table", () => {
-  test("get", async () => {
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.get("testTable2", testId);
-  });
-
-  test("get (system table)", async () => {
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.system.get("_scheduled_functions", testSystemId);
-  });
-
-  test("patch", async () => {
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.patch("testTable2", testId, {});
-  });
-
-  test("replace", async () => {
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.replace("testTable2", testId, {
-      name: "replaced",
-    });
-  });
-
-  test("delete", async () => {
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.delete("testTable2", testId);
-  });
-
-  test("can use Id<string> + string table name", async () => {
-    // This shouldn’t be used in most cases but sometimes people do hacky stuff
-    // so we need to support it. If people do this, they accept that they might
-    // get runtime errors if they do it wrong.
-
-    const tableName: string = "testTable";
-    const id = "my_id" as GenericId<string>;
-
-    const db = setupWriter();
-    await db.replace(tableName, id, {});
-  });
-
-  test("can’t use Id<string> + a specific table name", async () => {
-    const id = "my_id" as GenericId<string>;
-
-    const db = setupWriter();
-    // @ts-expect-error
-    await db.replace("testTable", id, {});
-  });
-
-  test("can use some union types", async () => {
-    const tableName = "a" as "a" | "b";
-    const id = "my_id" as GenericId<"a" | "b">;
-
-    const db = setupWriter();
-    await db.replace(tableName, id, {});
-  });
-
-  test("can’t use Id<some table> + string table name", async () => {
-    // If we have the specific ID in the type system, it makes no sense to
-    // use a string table name.
-
-    const tableName: string = "some table";
-
-    // Unfortunately, the types accept `string` as a table name
-    // when using a GenericDataModel, so let’s define a specific
-    // data model for this type test
-    const _schema = defineSchema({
-      someTable: defineTable({
-        name: v.string(),
-      }),
-      someTable2: defineTable({
-        name: v.string(),
-      }),
-    });
-    type DataModel = DataModelFromSchemaDefinition<typeof _schema>;
-
-    const db = setupWriter() as GenericDatabaseWriter<DataModel>;
-    await db.replace(
-      // @ts-expect-error -- `string` shouldn’t be a valid table name type!
-      tableName,
-      testId,
-      {},
-    );
-  });
-
-  test("can’t use a table name + (Id<'a' | 'b'>)", async () => {
-    const id = "my_id" as GenericId<"a" | "b">;
-
-    const db = setupWriter();
-
-    // @ts-expect-error
-    await db.get("a", id);
-    // @ts-expect-error
-    await db.patch("a", id, {});
-    // @ts-expect-error
-    await db.replace("a", id, {});
-    // @ts-expect-error
-    await db.delete("a", id);
-  });
-
-  test("can’t use a table name + (Id<'a'> | Id<'b'>)", async () => {
-    const id = "my_id" as GenericId<"a"> | GenericId<"b">;
-
-    const db = setupWriter();
-
-    // @ts-expect-error
-    await db.get("a", id);
-    // @ts-expect-error
-    await db.patch("a", id, {});
-    // @ts-expect-error
-    await db.replace("a", id, {});
-    // @ts-expect-error
-    await db.delete("a", id);
-  });
-});
-
-describe("type checking of patch/replace arguments", () => {
-  const _schema = defineSchema({
-    testTable: defineTable({
-      nameFromTable1: v.string(),
-    }),
-    testTable2: defineTable({
-      nameFromTable2: v.string(),
-    }),
-  });
-  type DataModel = DataModelFromSchemaDefinition<typeof _schema>;
-  type TypedDbWriter = GenericDatabaseWriter<DataModel>;
-
-  describe("old API", () => {
-    test("patch", async () => {
-      const db: TypedDbWriter = setupWriter();
-      await db.patch(testId, {
-        nameFromTable1: "asd",
-      });
-      await db.patch(testId, {
-        // @ts-expect-error
-        nameFromTable2: "asd",
-      });
-    });
-
-    test("replace", async () => {
-      const db: TypedDbWriter = setupWriter();
-      await db.replace(testId, {
-        nameFromTable1: "asd",
-      });
-      await db.replace(testId, {
-        // @ts-expect-error
-        nameFromTable2: "asd",
-      });
-    });
-  });
-
-  describe("new API", () => {
-    test("patch", async () => {
-      const db: TypedDbWriter = setupWriter();
-      await db.patch("testTable", testId, {
-        nameFromTable1: "asd",
-      });
-      await db.patch("testTable", testId, {
-        // @ts-expect-error
-        nameFromTable2: "asd",
-      });
-    });
-
-    test("replace", async () => {
-      const db: TypedDbWriter = setupWriter();
-      await db.replace("testTable", testId, {
-        nameFromTable1: "asd",
-      });
-      await db.replace("testTable", testId, {
-        // @ts-expect-error
-        nameFromTable2: "asd",
-      });
-    });
-  });
-});

package/src/server/filter_builder.test.ts

@@ -1,102 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { GenericId } from "../values/index.js";
-import { test } from "vitest";
-import { assert, Equals } from "../test/type_testing.js";
-import { Expression, FilterBuilder } from "./filter_builder.js";
-
-type Document = {
-  _id: GenericId<"tableName">;
-  numberField: number;
-  bigintField: bigint;
-  nestedObject: {
-    numberField: number;
-  };
-};
-
-type TableInfo = {
-  document: Document;
-  fieldPaths:
-    | "_id"
-    | "numberField"
-    | "bigintField"
-    | "nestedObject"
-    | "nestedObject.numberField";
-  indexes: {};
-  searchIndexes: {};
-  vectorIndexes: {};
-};
-
-type FB = FilterBuilder<TableInfo>;
-
-test("eq must have the same input types", () => {
-  // This breaks because we're comparing a string and a number.
-  function brokenEq(q: FB) {
-    // @ts-expect-error Using this directive to assert this is an error.
-    return q.eq("string", 123);
-  }
-
-  function eq(q: FB) {
-    return q.eq("string", "another string");
-  }
-  type Result = ReturnType<typeof eq>;
-  type Expected = Expression<boolean>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("neq must have the same input types", () => {
-  // This breaks because we're comparing a string and a number.
-  function brokenNeq(q: FB) {
-    // @ts-expect-error Using this directive to assert this is an error.
-    return q.neq("string", 123);
-  }
-
-  function neq(q: FB) {
-    return q.neq("string", "another string");
-  }
-  type Result = ReturnType<typeof neq>;
-  type Expected = Expression<boolean>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("neg returns number when number is passed in", () => {
-  function negNumber(q: FB) {
-    return q.neg(q.field("numberField"));
-  }
-  type Result = ReturnType<typeof negNumber>;
-  type Expected = Expression<number>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("neg returns bigint when bigint is passed in", () => {
-  function negBigint(q: FB) {
-    return q.neg(q.field("bigintField"));
-  }
-  type Result = ReturnType<typeof negBigint>;
-  type Expected = Expression<bigint>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("field doesn't compile on invalid field paths", () => {
-  function broken(q: FB) {
-    // @ts-expect-error Using this directive to assert this is an error.
-    return q.field("notAField");
-  }
-});
-
-test("field determines field type", () => {
-  function idField(q: FB) {
-    return q.field("_id");
-  }
-  type Result = ReturnType<typeof idField>;
-  type Expected = Expression<GenericId<"tableName">>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("field determines field type in nested field", () => {
-  function nestedField(q: FB) {
-    return q.field("nestedObject.numberField");
-  }
-  type Result = ReturnType<typeof nestedField>;
-  type Expected = Expression<number>;
-  assert<Equals<Result, Expected>>();
-});

package/src/server/impl/actions_impl.test.ts

@@ -1,59 +0,0 @@
-import { afterEach, describe, expect, test, vi } from "vitest";
-import { version } from "../../index.js";
-import * as syscall from "./syscall.js";
-import { getServiceToken } from "./actions_impl.js";
-
-vi.mock("./syscall.js", () => ({
-  performAsyncSyscall: vi.fn(),
-}));
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("getServiceToken", () => {
-  test("requires a service", async () => {
-    await expect(
-      getServiceToken(undefined as unknown as "ai-gateway"),
-    ).rejects.toThrow("Must provide arg 1 `service` to `getServiceToken`");
-    expect(syscall.performAsyncSyscall).not.toHaveBeenCalled();
-  });
-
-  test("requests an LLM token for the current action", async () => {
-    vi.mocked(syscall.performAsyncSyscall).mockResolvedValue("jwt");
-
-    const token = await getServiceToken("ai-gateway");
-
-    expect(token).toBe("jwt");
-    expect(syscall.performAsyncSyscall).toHaveBeenCalledWith(
-      "1.0/createServiceToken",
-      {
-        service: "ai-gateway",
-        version,
-      },
-    );
-  });
-
-  test("rejects the former service spelling", async () => {
-    await expect(getServiceToken("ai" as "ai-gateway")).rejects.toThrow(
-      'Unsupported service "ai"',
-    );
-    expect(syscall.performAsyncSyscall).not.toHaveBeenCalled();
-  });
-
-  test("rejects unsupported services before issuing a syscall", async () => {
-    await expect(getServiceToken("other" as "ai-gateway")).rejects.toThrow(
-      'Unsupported service "other"',
-    );
-    expect(syscall.performAsyncSyscall).not.toHaveBeenCalled();
-  });
-
-  test("preserves syscall errors", async () => {
-    const error = new Error(
-      "Unknown async operation 1.0/createServiceToken with args {}",
-    );
-    vi.mocked(syscall.performAsyncSyscall).mockRejectedValue(error);
-
-    await expect(getServiceToken("ai-gateway")).rejects.toBe(error);
-  });
-});

package/src/server/impl/filter_builder_impl.test.ts

@@ -1,13 +0,0 @@
-import { test, expect } from "vitest";
-import { filterBuilderImpl } from "./filter_builder_impl.js";
-
-test("Serialize expression with literals", () => {
-  const predicate = filterBuilderImpl.and(
-    filterBuilderImpl.eq(filterBuilderImpl.field("test"), 3),
-    true as any,
-  );
-  const expected = {
-    $and: [{ $eq: [{ $field: "test" }, { $literal: 3 }] }, { $literal: true }],
-  };
-  expect((predicate as any).serialize()).toEqual(expected);
-});

package/src/server/impl/query_impl.test.ts

@@ -1,46 +0,0 @@
-import { QueryImpl } from "./query_impl.js";
-import { test, expect } from "vitest";
-
-// Mock to prevent
-// "The Convex database and auth objects are being used outside of a Convex backend..." errors
-(globalThis as any).Convex = {
-  syscall: (_op: string, _jsonArgs: string) => {
-    return "{}";
-  },
-  asyncSyscall: async (_op: string, _jsonArgs: string) => {
-    return new Promise((resolve) => {
-      resolve('{ "done": true, "value": null }');
-    });
-  },
-};
-
-function newQuery() {
-  return new QueryImpl({
-    source: {
-      type: "FullTableScan",
-      tableName: "messages",
-      order: null,
-    },
-    operators: [],
-  });
-}
-
-test("take does not throw if passed a non-negative integer", async () => {
-  await newQuery().take(1);
-});
-
-test("take throws a TypeError if passed a float", async () => {
-  const t = () => {
-    return newQuery().take(1.5);
-  };
-  await expect(t).rejects.toThrow(TypeError);
-  await expect(t).rejects.toThrow(/must be a non-negative integer/);
-});
-
-test("take throws a TypeError if passed a negative integer", async () => {
-  const t = () => {
-    return newQuery().take(-1);
-  };
-  await expect(t).rejects.toThrow(TypeError);
-  await expect(t).rejects.toThrow(/must be a non-negative integer/);
-});

package/src/server/pagination.test.ts

@@ -1,49 +0,0 @@
-import { assert } from "../test/type_testing.js";
-import { test } from "vitest";
-import {
-  PaginationOptions,
-  PaginationResult,
-  paginationOptsValidator,
-  paginationResultValidator,
-} from "./pagination.js";
-import { Infer, v } from "../values/validator.js";
-
-test("paginationOptsValidator matches the paginationOpts type", () => {
-  type validatorType = Infer<typeof paginationOptsValidator>;
-  assert<validatorType extends PaginationOptions ? true : false>();
-  // All optional fields exist and have the correct type.
-  assert<
-    Required<validatorType> extends Required<PaginationOptions> ? true : false
-  >();
-});
-
-test("paginationResultValidator with string items", () => {
-  const _validator = paginationResultValidator(v.string());
-  type validatorType = Infer<typeof _validator>;
-  type expectedType = PaginationResult<string>;
-
-  // Check that the inferred type matches PaginationResult<string>
-  assert<validatorType extends expectedType ? true : false>();
-  assert<expectedType extends validatorType ? true : false>();
-});
-
-test("paginationResultValidator with object items", () => {
-  const itemValidator = v.object({
-    _id: v.id("users"),
-    _creationTime: v.number(),
-    name: v.string(),
-    email: v.optional(v.string()),
-  });
-  const _validator = paginationResultValidator(itemValidator);
-  type validatorType = Infer<typeof _validator>;
-  type itemType = Infer<typeof itemValidator>;
-  type expectedType = PaginationResult<itemType>;
-
-  // Check that the inferred type matches PaginationResult with the correct item type
-  assert<validatorType extends expectedType ? true : false>();
-  assert<expectedType extends validatorType ? true : false>();
-
-  // Verify the page array has the correct item type
-  type pageType = validatorType["page"];
-  assert<pageType extends itemType[] ? true : false>();
-});