convex 1.44.0 → 1.45.0

package/src/react/use_queries.test.ts

@@ -1,140 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-
-import { RequestForQueries, useQueriesHelper } from "./use_queries.js";
-import { test, expect, vi } from "vitest";
-import FakeWatch from "../test/fake_watch.js";
-import { act, renderHook } from "@testing-library/react";
-import { FunctionReference, anyApi, getFunctionName } from "../server/api.js";
-
-test("Adding a new query", () => {
-  const values: Record<string, unknown> = {};
-  const createWatch = vi.fn((query: FunctionReference<"query">) => {
-    const watch = new FakeWatch<any>();
-    watch.value = values[getFunctionName(query)];
-    return watch;
-  }) as any;
-
-  // Request 1 query.
-  let queries: RequestForQueries = {
-    query1: {
-      query: anyApi.query1.default,
-      args: {},
-    },
-  };
-  const { result, rerender } = renderHook(() =>
-    useQueriesHelper(queries, createWatch),
-  );
-
-  // Initially the query is loading (undefined).
-  expect(result.current).toStrictEqual({
-    query1: undefined,
-  });
-  expect(createWatch.mock.calls.length).toBe(3);
-
-  // When the query loads, we get the result.
-  act(() => {
-    values.query1 = "query1 result";
-    createWatch.mock.results[1].value.setValue("query1 result");
-  });
-  expect(result.current).toStrictEqual({
-    query1: "query1 result",
-  });
-
-  // Add a second query, it's initially loading.
-  queries = {
-    query1: {
-      query: anyApi.query1.default,
-      args: {},
-    },
-    query2: {
-      query: anyApi.query2.default,
-      args: {},
-    },
-  };
-  rerender();
-  expect(result.current).toStrictEqual({
-    query1: "query1 result",
-    query2: undefined,
-  });
-  expect(createWatch.mock.calls.length).toBe(9);
-
-  // When the query resolves, we also get the result.
-  act(() => {
-    values.query2 = "query2 result";
-    createWatch.mock.results[6].value.setValue("query2 result");
-  });
-  expect(result.current).toStrictEqual({
-    query1: "query1 result",
-    query2: "query2 result",
-  });
-});
-
-test("Swapping queries and unsubscribing", () => {
-  const createWatch = vi.fn(() => new FakeWatch<any>()) as any;
-
-  // Request 1 query.
-  let queries: RequestForQueries = {
-    query: {
-      query: anyApi.query1.default,
-      args: {},
-    },
-  };
-  const { rerender, unmount } = renderHook(() =>
-    useQueriesHelper(queries, createWatch),
-  );
-
-  // One watch was created and we're listening to it.
-  expect(createWatch.mock.calls.length).toBe(3);
-  expect(createWatch.mock.results[1].value.numCallbacks()).toBe(1);
-
-  // Switch to a different query.
-  queries = {
-    query1: {
-      query: anyApi.query2.default,
-      args: {},
-    },
-  };
-  rerender();
-
-  // Now 2 different watches have been created and we're only listening to the second.
-  expect(createWatch.mock.calls.length).toBe(6);
-  expect(createWatch.mock.results[1].value.numCallbacks()).toBe(0);
-  expect(createWatch.mock.results[4].value.numCallbacks()).toBe(1);
-
-  // After unmount, we've unsubscribed to all the queries.
-  unmount();
-  expect(createWatch.mock.calls.length).toBe(6);
-  expect(createWatch.mock.results[1].value.numCallbacks()).toBe(0);
-  expect(createWatch.mock.results[4].value.numCallbacks()).toBe(0);
-});
-
-test("Local results on initial render", () => {
-  const value: string | undefined = "query1 result";
-  const createWatch = vi.fn(() => {
-    const watch = new FakeWatch<any>();
-    watch.value = value;
-    return watch;
-  }) as any;
-
-  // Request 1 query.
-  const queries: RequestForQueries = {
-    query1: {
-      query: anyApi.query1.default,
-      args: {},
-    },
-  };
-  const { result } = renderHook(() => {
-    const result = useQueriesHelper(queries, createWatch);
-    // This is the important part of this test! We check that
-    // we immediately render the new value:
-    expect(result.query1).toEqual(value);
-    return result;
-  });
-
-  expect(result.current).toStrictEqual({
-    query1: "query1 result",
-  });
-  expect(createWatch.mock.calls.length).toBe(3);
-});

package/src/react/use_query.test.ts

@@ -1,71 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { test, describe, expect } from "vitest";
-import { anyApi } from "../server/api.js";
-
-import { ApiFromModules, QueryBuilder } from "../server/index.js";
-import { useQuery as useQueryReal } from "./client.js";
-
-// Intentional noop, we're just testing types.
-const useQuery = (() => {}) as unknown as typeof useQueryReal;
-
-const query: QueryBuilder<any, "public"> = (() => {
-  // Intentional noop. We're only testing the type
-}) as any;
-
-const module = {
-  noArgs: query(() => "result"),
-  args: query((_ctx, { _arg }: { _arg: string }) => "result"),
-  /*
-  // TODO some of these may be worth testing or proving
-  // that they produce the same function reference types.
-  untypedArgs: query((_ctx, _args) => "result"),
-  unpackedUntypedArgs: query((_ctx, { _arg }) => "result"),
-  configNoArgs: query({
-    handler: () => "result",
-  }),
-  configEmptyArgs: query({
-    args: {},
-    handler: () => "result",
-  }),
-  configArgs: query({
-    args: { _arg: v.string() },
-    handler: (args) => "result",
-  }),
-  */
-};
-type API = ApiFromModules<{ module: typeof module }>;
-const api = anyApi as unknown as API;
-
-// Test the existing behavior of useQuery types.
-// The change to consider is adding an options object.
-// These rely on OptionalRestArgs / OptionalRestArgsOrSkip
-// see https://github.com/get-convex/convex/pull/13978
-describe("useQuery types", () => {
-  test("Queries with arguments", () => {
-    useQuery(api.module.args, { _arg: "asdf" });
-
-    // @ts-expect-error extra args is an error
-    useQuery(api.module.args, { _arg: "asdf", arg2: 123 });
-
-    // @ts-expect-error wrong arg type is an error
-    useQuery(api.module.args, { _arg: 1 });
-
-    // @ts-expect-error eliding args object is an error
-    useQuery(api.module.args);
-  });
-
-  test("Queries without arguments", () => {
-    // empty args are allowed
-    useQuery(api.module.noArgs, {});
-
-    // eliding args object is allowed
-    useQuery(api.module.noArgs);
-
-    // @ts-expect-error adding args is not allowed
-    useQuery(api.module.noArgs, { _arg: 1 });
-  });
-});

package/src/react/use_query_object_options.test.ts

@@ -1,51 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { test, describe } from "vitest";
-import { anyApi } from "../server/api.js";
-
-import type { ApiFromModules, QueryBuilder } from "../server/index.js";
-import { useQuery_experimental as useQuery_experimentalReal } from "./client.js";
-
-const useQuery_experimental =
-  (() => {}) as unknown as typeof useQuery_experimentalReal;
-const query: QueryBuilder<any, "public"> = (() => {}) as any;
-
-const module = {
-  noArgs: query(() => "result"),
-  args: query((_ctx, { _arg }: { _arg: string }) => "result"),
-};
-type API = ApiFromModules<{ module: typeof module }>;
-const api = anyApi as unknown as API;
-
-describe("useQuery object options", () => {
-  test("supports object options and skip sentinel", () => {
-    useQuery_experimental({
-      query: api.module.noArgs,
-      args: {},
-    });
-
-    useQuery_experimental({
-      query: api.module.args,
-      args: { _arg: "asdf" },
-    });
-
-    const _arg: string | undefined = undefined;
-    useQuery_experimental({
-      query: api.module.args,
-      args: _arg ? { _arg } : "skip",
-    });
-
-    useQuery_experimental({
-      query: api.module.args,
-      args: { _arg: "asdf" },
-    });
-
-    useQuery_experimental({
-      query: api.module.noArgs,
-      args: "skip",
-    });
-  });
-});

package/src/react/use_query_result.test.ts

@@ -1,75 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { test, describe, expectTypeOf } from "vitest";
-import { anyApi } from "../server/api.js";
-
-import type { ApiFromModules, QueryBuilder } from "../server/index.js";
-import {
-  useQuery_experimental as useQueryReal,
-  type UseQueryResult,
-} from "./client.js";
-
-const useQuery_experimental = (() => {}) as unknown as typeof useQueryReal;
-const query: QueryBuilder<any, "public"> = (() => {}) as any;
-
-const module = {
-  noArgs: query(() => "result"),
-  args: query((_ctx, { _arg }: { _arg: string }) => "result"),
-};
-type API = ApiFromModules<{ module: typeof module }>;
-const api = anyApi as unknown as API;
-
-describe("useQuery_experimental result types", () => {
-  test("supports object-form result usage", () => {
-    useQuery_experimental({
-      query: api.module.args,
-      args: { _arg: "asdf" },
-    });
-
-    const throwingResult = useQuery_experimental({
-      query: api.module.args,
-      args: { _arg: "asdf" },
-      throwOnError: true,
-    });
-    expectTypeOf(throwingResult).toEqualTypeOf<UseQueryResult<string, true>>();
-
-    const _arg: string | undefined = undefined;
-    const conditionalResult = useQuery_experimental({
-      query: api.module.args,
-      args: _arg ? { _arg } : "skip",
-    });
-    expectTypeOf(conditionalResult).toEqualTypeOf<
-      UseQueryResult<string, false>
-    >();
-  });
-
-  test("throwOnError:true omits error from result", () => {
-    // Never executed; exists only for type checking.
-    () => {
-      const throwingResult = useQuery_experimental({
-        query: api.module.args,
-        args: { _arg: "asdf" },
-        throwOnError: true,
-      });
-      expectTypeOf<(typeof throwingResult)["status"]>().toEqualTypeOf<
-        "pending" | "success"
-      >();
-    };
-  });
-
-  test("throwOnError ommitted includes error in result", () => {
-    // Never executed; exists only for type checking.
-    () => {
-      const throwingResult = useQuery_experimental({
-        query: api.module.args,
-        args: { _arg: "asdf" },
-      });
-      expectTypeOf<(typeof throwingResult)["status"]>().toEqualTypeOf<
-        "pending" | "success" | "error"
-      >();
-    };
-  });
-});

package/src/react-auth0/ConvexProviderWithAuth0.test.tsx

@@ -1,17 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-import { test } from "vitest";
-import React from "react";
-import { ConvexProviderWithAuth0 } from "./ConvexProviderWithAuth0.js";
-import { ConvexReactClient } from "../react/index.js";
-
-test("Helpers are valid children", () => {
-  const convex = new ConvexReactClient("https://localhost:3001");
-
-  const _ = (
-    <ConvexProviderWithAuth0 client={convex}>
-      Hello world
-    </ConvexProviderWithAuth0>
-  );
-});

package/src/react-clerk/ConvexProviderWithClerk.test.tsx

@@ -1,18 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-import { test } from "vitest";
-import React from "react";
-import { ConvexProviderWithClerk } from "./ConvexProviderWithClerk.js";
-import { ConvexReactClient } from "../react/index.js";
-import { useAuth } from "@clerk/react";
-
-test("Helpers are valid children", () => {
-  const convex = new ConvexReactClient("https://localhost:3001");
-
-  const _ = (
-    <ConvexProviderWithClerk client={convex} useAuth={useAuth}>
-      Hello world
-    </ConvexProviderWithClerk>
-  );
-});

package/src/server/README.md

@@ -1,15 +0,0 @@
-# Server
-
-This is the entry point for all of the code for use within query and mutation
-functions.
-
-This directory uses an "interface-impl" pattern where:
-
-- The main directory has all interfaces to define the types of the various
-  abstractions. These are parameterized of the developers `DataModel` type and
-  carefully written to only allow valid usage.
-- The `impl/` subdirectory has implementations of all of these interfaces. These
-  implementations are sloppier about their types and **not parameterized over
-  `DataModel`**. This simplifies their implementation and only gives up a bit of
-  type safety. The `DataModel` type is built to help developers write correct
-  code, not to check that our internal structures are correct.

package/src/server/api.intersect.test.ts

@@ -1,109 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { assert, Equals } from "../test/type_testing.js";
-import { test } from "vitest";
-import {
-  ApiFromModules,
-  FilterApi,
-  FunctionReference,
-  FunctionReferenceFromExport,
-} from "./api.js";
-import {
-  EmptyObject,
-  RegisteredAction,
-  RegisteredMutation,
-  RegisteredQuery,
-} from "./registration.js";
-
-test("FunctionReferenceFromExport preserves visibility through intersections", () => {
-  type TaggedPublicMutation = RegisteredMutation<
-    "public",
-    EmptyObject,
-    string
-  > & { foo: "bar" };
-  type TaggedInternalMutation = RegisteredMutation<
-    "internal",
-    EmptyObject,
-    string
-  > & { foo: "bar" };
-  type TaggedInternalQuery = RegisteredQuery<
-    "internal",
-    { x: number },
-    string
-  > & { tag: true };
-  type TaggedPublicAction = RegisteredAction<"public", EmptyObject, number> & {
-    a: 1;
-  };
-
-  assert<
-    Equals<
-      FunctionReferenceFromExport<TaggedPublicMutation>,
-      FunctionReference<"mutation", "public", EmptyObject, string>
-    >
-  >();
-  assert<
-    Equals<
-      FunctionReferenceFromExport<TaggedInternalMutation>,
-      FunctionReference<"mutation", "internal", EmptyObject, string>
-    >
-  >();
-  assert<
-    Equals<
-      FunctionReferenceFromExport<TaggedInternalQuery>,
-      FunctionReference<"query", "internal", { x: number }, string>
-    >
-  >();
-  assert<
-    Equals<
-      FunctionReferenceFromExport<TaggedPublicAction>,
-      FunctionReference<"action", "public", EmptyObject, number>
-    >
-  >();
-});
-
-test("intersected functions show up in api / internal", () => {
-  type TaggedInternal = RegisteredMutation<"internal", EmptyObject, string> & {
-    foo: "bar";
-  };
-  type TaggedPublic = RegisteredMutation<"public", EmptyObject, number> & {
-    tag: true;
-  };
-
-  const myModule = {
-    taggedInternal: null as unknown as TaggedInternal,
-    taggedPublic: null as unknown as TaggedPublic,
-  };
-  type API = ApiFromModules<{ myModule: typeof myModule }>;
-  type Internal = FilterApi<API, FunctionReference<any, "internal">>;
-  type Public = FilterApi<API, FunctionReference<any, "public">>;
-
-  assert<
-    Equals<
-      Internal,
-      {
-        myModule: {
-          taggedInternal: FunctionReference<
-            "mutation",
-            "internal",
-            EmptyObject,
-            string
-          >;
-        };
-      }
-    >
-  >();
-  assert<
-    Equals<
-      Public,
-      {
-        myModule: {
-          taggedPublic: FunctionReference<
-            "mutation",
-            "public",
-            EmptyObject,
-            number
-          >;
-        };
-      }
-    >
-  >();
-});