convex 1.44.0 → 1.45.0

package/src/server/api.test.ts

@@ -1,447 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { assert, Equals } from "../test/type_testing.js";
-import { describe, test } from "vitest";
-import {
-  makeFunctionReference,
-  PaginationOptions,
-  PaginationResult,
-  QueryBuilder,
-} from "./index.js";
-import {
-  FunctionReference,
-  justActions,
-  justInternal,
-  justMutations,
-  justQueries,
-  justPaginatedQueries,
-  PartialApi,
-  ConvertReturnType,
-} from "./api.js";
-
-test("PartialApi", () => {
-  const api = {
-    foo: {
-      a: makeFunctionReference<"query", { a: string }>("a"),
-      b: makeFunctionReference<"query">("b"),
-    },
-    bar: {
-      c: makeFunctionReference<"query">("c"),
-      baz: {
-        d: makeFunctionReference<"query">("d"),
-        e: makeFunctionReference<"query">("e"),
-      },
-    },
-  } as const;
-  type API = typeof api;
-  const subset = {
-    foo: {
-      b: makeFunctionReference<"query">("b"),
-    },
-    bar: {
-      baz: {
-        e: makeFunctionReference<"query">("e"),
-      },
-    },
-  } as const;
-  type SubsetAPI = typeof subset;
-  assert<SubsetAPI extends PartialApi<API> ? true : false>;
-
-  const notASubset = {
-    foo: {
-      c: makeFunctionReference<"query">("c"),
-    },
-  } as const;
-  assert<typeof notASubset extends PartialApi<API> ? false : true>;
-
-  const wrongSignature = {
-    foo: {
-      a: makeFunctionReference<"query", { a: number }>("a"),
-    },
-  } as const;
-  assert<typeof wrongSignature extends PartialApi<API> ? false : true>;
-
-  const correctSignature = {
-    foo: {
-      a: makeFunctionReference<"query", { a: string }>("a"),
-    },
-  } as const;
-  assert<typeof correctSignature extends PartialApi<API> ? true : false>;
-});
-
-import {
-  actionGeneric,
-  mutationGeneric,
-  queryGeneric,
-  internalQueryGeneric,
-  internalActionGeneric,
-  internalMutationGeneric,
-} from "../server/index.js";
-import { ApiFromModules, ArgsAndOptions, OptionalRestArgs } from "./index.js";
-import { DefaultFunctionArgs, EmptyObject } from "./registration.js";
-
-describe("JustPaginatedQueries", () => {
-  test("selects correct queries", () => {
-    const query = queryGeneric as QueryBuilder<any, "public">;
-    const modules = {
-      filename: {
-        simplePaginated: query(
-          (
-            _ctx,
-            _args: {
-              paginationOpts: PaginationOptions;
-            },
-          ) => null as unknown as PaginationResult<string>,
-        ),
-        paginatedWithArg: query(
-          (
-            _ctx,
-            _args: {
-              property: string;
-              paginationOpts: PaginationOptions;
-            },
-          ) => null as unknown as PaginationResult<string>,
-        ),
-        missingArg: query(
-          (_ctx) => null as unknown as PaginationResult<string>,
-        ),
-        emptyArg: query(() => null as unknown as PaginationResult<string>),
-        wrongReturn: query(
-          (_ctx, _args: { paginationOpts: PaginationOptions }) =>
-            null as unknown as string,
-        ),
-      },
-    } as const;
-    type API = ApiFromModules<typeof modules>;
-    type Expected = {
-      filename: {
-        simplePaginated: FunctionReference<
-          "query",
-          "public",
-          { paginationOpts: PaginationOptions },
-          PaginationResult<string>
-        >;
-        paginatedWithArg: FunctionReference<
-          "query",
-          "public",
-          { paginationOpts: PaginationOptions; property: string },
-          PaginationResult<string>
-        >;
-      };
-    };
-    const paginatedApi = justPaginatedQueries(null as unknown as API);
-    type Actual = typeof paginatedApi;
-    assert<
-      Equals<
-        Actual["filename"]["paginatedWithArg"],
-        Expected["filename"]["paginatedWithArg"]
-      >
-    >();
-  });
-});
-
-describe("justType filters", () => {
-  test("finds queries, mutations and actions", () => {
-    const myModule = {
-      query: queryGeneric((_, _args: { arg: number }) => "query result"),
-      mutation: mutationGeneric((_) => "query result"),
-      importantQuestion: actionGeneric((_, _args: { arg: number }) => 42),
-    };
-
-    type API = ApiFromModules<{
-      myModule: typeof myModule;
-    }>;
-    type ExpectedAPI = {
-      myModule: {
-        query: FunctionReference<
-          "query",
-          "public",
-          {
-            arg: number;
-          },
-          string
-        >;
-        mutation: FunctionReference<
-          "mutation",
-          "public",
-          Record<string, never>,
-          string
-        >;
-        importantQuestion: FunctionReference<
-          "action",
-          "public",
-          { arg: number },
-          number
-        >;
-      };
-    };
-    assert<Equals<API, ExpectedAPI>>;
-
-    type jq = ReturnType<typeof justQueries<API>>;
-    type jm = ReturnType<typeof justMutations<API>>;
-    type ja = ReturnType<typeof justActions<API>>;
-    assert<
-      Equals<
-        jq,
-        {
-          myModule: {
-            query: FunctionReference<
-              "query",
-              "public",
-              {
-                arg: number;
-              },
-              string
-            >;
-          };
-        }
-      >
-    >;
-    assert<
-      Equals<
-        jm,
-        {
-          myModule: {
-            mutation: FunctionReference<
-              "mutation",
-              "public",
-              EmptyObject,
-              string
-            >;
-          };
-        }
-      >
-    >;
-    assert<
-      Equals<
-        ja,
-        {
-          myModule: {
-            importantQuestion: FunctionReference<
-              "action",
-              "public",
-              {
-                arg: number;
-              },
-              number
-            >;
-          };
-        }
-      >
-    >;
-  });
-
-  test("ignores exports that aren't functions and modules that don't have them", () => {
-    const myModule = {
-      number: 123,
-      function: () => "return value",
-      object: { property: "value" },
-    };
-    type API = ApiFromModules<{
-      myModule: typeof myModule;
-    }>;
-    // None of these exports are queries or mutations or actions.
-    type ExpectedAPI = {};
-    assert<Equals<API, ExpectedAPI>>;
-  });
-
-  test("applies return type conversions", () => {
-    const myModule = {
-      returnsPromise: queryGeneric(() => Promise.resolve("query result")),
-      returnsUndefined: queryGeneric(() => undefined),
-      returnsVoid: queryGeneric(() => {
-        // Intentionally empty
-      }),
-      returnsVoidPromise: queryGeneric(() => Promise.resolve()),
-    };
-
-    type API = ApiFromModules<{
-      myModule: typeof myModule;
-    }>;
-    type ExpectedAPI = {
-      myModule: {
-        returnsPromise: FunctionReference<
-          "query",
-          "public",
-          EmptyObject,
-          string
-        >;
-        returnsUndefined: FunctionReference<
-          "query",
-          "public",
-          EmptyObject,
-          null
-        >;
-        returnsVoid: FunctionReference<"query", "public", EmptyObject, null>;
-        returnsVoidPromise: FunctionReference<
-          "query",
-          "public",
-          EmptyObject,
-          null
-        >;
-      };
-    };
-    assert<Equals<API, ExpectedAPI>>;
-  });
-
-  test("separates internal functions", () => {
-    const myModule = {
-      query: queryGeneric((_, _args: { arg: number }) => "query result"),
-      internalQuery: internalQueryGeneric(
-        (_, _args: { arg: number }) => "query result",
-      ),
-      mutation: mutationGeneric((_) => "query result"),
-      internalMutation: internalMutationGeneric((_) => "query result"),
-    };
-
-    const myActionsModule = {
-      action: actionGeneric((_, _args: { arg: number }) => 42),
-      internalAction: internalActionGeneric((_, _args: { arg: number }) => 42),
-    };
-
-    type API = ApiFromModules<{
-      myModule: typeof myModule;
-      "actions/myActionsModule": typeof myActionsModule;
-    }>;
-    type InternalAPI = ReturnType<typeof justInternal<API>>;
-    type ExpectedAPI = {
-      myModule: {
-        internalQuery: FunctionReference<
-          "query",
-          "internal",
-          {
-            arg: number;
-          },
-          string
-        >;
-        internalMutation: FunctionReference<
-          "mutation",
-          "internal",
-          EmptyObject,
-          string
-        >;
-      };
-      actions: {
-        myActionsModule: {
-          internalAction: FunctionReference<
-            "action",
-            "internal",
-            {
-              arg: number;
-            },
-            number
-          >;
-        };
-      };
-    };
-    assert<Equals<InternalAPI, ExpectedAPI>>;
-  });
-
-  test("correctly infers arguments", () => {
-    const myModule = {
-      noArg: queryGeneric((_) => "query result"),
-      oneTypedArg: queryGeneric((_, _args: { arg: number }) => "query result"),
-      onUnTypedArg: queryGeneric((_, _args) => "query result"),
-    };
-
-    type API = ApiFromModules<{
-      myModule: typeof myModule;
-    }>;
-    type ExpectedAPI = {
-      myModule: {
-        noArg: FunctionReference<"query", "public", EmptyObject, string>;
-        oneTypedArg: FunctionReference<
-          "query",
-          "public",
-          {
-            arg: number;
-          },
-          string
-        >;
-        onUnTypedArg: FunctionReference<
-          "query",
-          "public",
-          DefaultFunctionArgs,
-          string
-        >;
-      };
-    };
-
-    assert<Equals<API, ExpectedAPI>>;
-  });
-});
-
-describe("Args", () => {
-  const module = {
-    noArgs: mutationGeneric((_ctx) => {
-      /* nop */
-    }),
-    args: mutationGeneric((_ctx, _args: { property: string }) => {
-      /* nop */
-    }),
-  };
-  type API = ApiFromModules<{
-    module: typeof module;
-  }>;
-
-  describe("ArgsObject", () => {
-    test("infers Record<string, never> for functions with no args", () => {
-      type MyFunction = API["module"]["noArgs"];
-      assert<Equals<MyFunction["_args"], EmptyObject>>();
-    });
-
-    test("infers args for functions with args", () => {
-      type MyFunction = API["module"]["args"];
-      type ExpectedArgs = { property: string };
-      assert<Equals<MyFunction["_args"], ExpectedArgs>>();
-    });
-  });
-
-  describe("OptionalRestArgs", () => {
-    test("infers rest type with optional args for functions with no args", () => {
-      type MyFunction = API["module"]["noArgs"];
-      type ExpectedArgs = [Record<string, never>?];
-      type Args = OptionalRestArgs<MyFunction>;
-      assert<Equals<Args, ExpectedArgs>>();
-    });
-
-    test("infers rest type with required args for functions with args", () => {
-      type MyFunction = API["module"]["args"];
-      type ExpectedArgs = [{ property: string }];
-      type Args = OptionalRestArgs<MyFunction>;
-      assert<Equals<Args, ExpectedArgs>>();
-    });
-  });
-
-  describe("ArgsAndOptions", () => {
-    type Options = {
-      option1?: string;
-      option2: number;
-    };
-
-    test("infers rest type with optional args and optional options for functions with no args", () => {
-      type MyFunction = API["module"]["noArgs"];
-      type ExpectedArgs = [Record<string, never>?, Options?];
-      type Args = ArgsAndOptions<MyFunction, Options>;
-      assert<Equals<Args, ExpectedArgs>>();
-    });
-
-    test("infers rest type with required args and optional options for functions with args", () => {
-      type MyFunction = API["module"]["args"];
-      type ExpectedArgs = [{ property: string }, Options?];
-      type Args = ArgsAndOptions<MyFunction, Options>;
-      assert<Equals<Args, ExpectedArgs>>();
-    });
-  });
-});
-
-test("ConvertReturnType", () => {
-  assert<Equals<ConvertReturnType<undefined>, null>>;
-
-  assert<Equals<ConvertReturnType<undefined | string>, null | string>>;
-
-  assert<Equals<ConvertReturnType<Promise<undefined>>, null>>;
-
-  assert<Equals<ConvertReturnType<Promise<undefined | string>>, null | string>>;
-
-  assert<Equals<ConvertReturnType<Promise<string>>, string>>;
-});

package/src/server/audit_logging.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { AuditLogBody, cloneWithSentinels } from "./audit_logging.js";
-import { log } from "./log.js";
-
-describe("cloneWithSentinels", () => {
-  test("clones the body when there are no log vars", () => {
-    const input: AuditLogBody = {
-      foo: "bar",
-      count: 42,
-      flag: true,
-      empty: null,
-      nested: { inner: "value", arr: [1, 2, 3] },
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual(input);
-    expect(result).not.toBe(input);
-    expect(result.nested).not.toBe(input.nested);
-  });
-
-  test("replaces log vars with sentinel objects", () => {
-    const input: AuditLogBody = {
-      userIp: log.vars.ip,
-      agent: log.vars.userAgent,
-      ts: log.vars.now,
-      reqId: log.vars.requestId,
-      admin: log.vars.convexActor,
-      note: "hello",
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual({
-      userIp: { $var: "ip" },
-      agent: { $var: "userAgent" },
-      ts: { $var: "now" },
-      reqId: { $var: "requestId" },
-      admin: { $var: "convexActor" },
-      note: "hello",
-    });
-  });
-
-  test("handles log vars nested inside an object", () => {
-    const input: AuditLogBody = {
-      outer: {
-        inner: {
-          userIp: log.vars.ip,
-          ts: log.vars.now,
-        },
-        label: "x",
-      },
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual({
-      outer: {
-        inner: { userIp: { $var: "ip" }, ts: { $var: "now" } },
-        label: "x",
-      },
-    });
-  });
-
-  test("handles log vars inside arrays", () => {
-    const input: AuditLogBody = {
-      items: [log.vars.ip, log.vars.userAgent, log.vars.now, "literal"],
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual({
-      items: [
-        { $var: "ip" },
-        { $var: "userAgent" },
-        { $var: "now" },
-        "literal",
-      ],
-    });
-  });
-
-  test("handles the same var used multiple times", () => {
-    const input: AuditLogBody = {
-      topIp: log.vars.ip,
-      nested: { anotherIp: log.vars.ip },
-      list: [log.vars.ip],
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual({
-      topIp: { $var: "ip" },
-      nested: { anotherIp: { $var: "ip" } },
-      list: [{ $var: "ip" }],
-    });
-  });
-
-  test("handles log vars inside objects within an array", () => {
-    const input: AuditLogBody = {
-      records: [
-        { ip: log.vars.ip, name: "a" },
-        { ts: log.vars.now, name: "b" },
-        { agent: log.vars.userAgent, name: "c" },
-      ],
-    };
-    const result = cloneWithSentinels(input);
-
-    expect(result).toEqual({
-      records: [
-        { ip: { $var: "ip" }, name: "a" },
-        { ts: { $var: "now" }, name: "b" },
-        { agent: { $var: "userAgent" }, name: "c" },
-      ],
-    });
-  });
-
-  test("throws on keys starting with $", () => {
-    expect(() => cloneWithSentinels({ $var: "ip" })).toThrow(
-      'keys must not start with "$"',
-    );
-  });
-
-  test("throws on $ keys nested inside objects", () => {
-    expect(() => cloneWithSentinels({ outer: { $secret: "value" } })).toThrow(
-      'keys must not start with "$"',
-    );
-  });
-
-  test("throws on unknown symbol var", () => {
-    const fakeVar = Symbol("var.fake");
-    expect(() =>
-      // @ts-expect-error intentionally passing an invalid var symbol
-      cloneWithSentinels({ x: fakeVar }),
-    ).toThrow("Unknown audit var symbol");
-  });
-});

package/src/server/components/index.test.ts

@@ -1,48 +0,0 @@
-import { expect, test } from "vitest";
-
-import { v } from "../../values/index.js";
-import { defineApp, defineComponent } from "./index.js";
-
-test("app.use throws on empty component name", () => {
-  const app = defineApp() as any;
-
-  const importedComponentDefinition = {
-    componentDefinitionPath: "components/workflow",
-    defaultName: "workflow",
-  } as any;
-
-  expect(() => app.use(importedComponentDefinition, { name: "" })).toThrow(
-    /component name cannot be empty/i,
-  );
-});
-
-test("app.use requires the options arg only when a component declares required env vars", () => {
-  const app = defineApp();
-  const requiredEnv = defineComponent("requiredEnv", {
-    env: { THING_I_NEED: v.string() },
-  });
-  const optionalEnv = defineComponent("optionalEnv", {
-    env: { THING_I_WANT: v.optional(v.string()) },
-  });
-  const emptyEnv = defineComponent("emptyEnv", { env: {} });
-
-  // Type-only assertions. Never invoked: `app.use` needs a runtime component
-  // with a `componentDefinitionPath`, which these plain definitions lack.
-  void (() => {
-    // @ts-expect-error a required env var means the options arg can't be dropped
-    app.use(requiredEnv);
-    // @ts-expect-error nor can `env` itself be omitted
-    app.use(requiredEnv, {});
-    app.use(requiredEnv, { env: { THING_I_NEED: "a string" } });
-
-    // With only optional env vars, both forms are allowed.
-    app.use(optionalEnv);
-    app.use(optionalEnv, { env: {} });
-    app.use(optionalEnv, { env: { THING_I_WANT: "a string" } });
-
-    // A component declaring no env vars needs no `env` (and `env: {}` is fine).
-    app.use(emptyEnv);
-    app.use(emptyEnv, {});
-    app.use(emptyEnv, { env: {} });
-  });
-});

package/src/server/cron.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { cronJobs } from "./cron.js";
-import { makeFunctionReference } from "./api.js";
-
-const fn = makeFunctionReference<"mutation">("crons:job");
-
-function exported(build: (crons: ReturnType<typeof cronJobs>) => void) {
-  const crons = cronJobs();
-  build(crons);
-  return JSON.parse(crons.export());
-}
-
-describe("cron schedules with an optional minute", () => {
-  test("hourly with an explicit minute keeps it", () => {
-    const crons = exported((c) => c.hourly("a", { minuteUTC: 5 }, fn));
-    expect(crons.a.schedule).toEqual({ type: "hourly", minuteUTC: 5 });
-  });
-
-  test("hourly with an empty schedule omits the minute", () => {
-    const crons = exported((c) => c.hourly("a", {}, fn));
-    expect(crons.a.schedule).toEqual({ type: "hourly" });
-  });
-
-  test("hourly with no schedule at all omits the minute", () => {
-    const crons = exported((c) => c.hourly("a", fn));
-    expect(crons.a.schedule).toEqual({ type: "hourly" });
-  });
-
-  test("daily/weekly/monthly omit the minute when it isn't given", () => {
-    const crons = exported((c) => {
-      c.daily("d", { hourUTC: 3 }, fn);
-      c.weekly("w", { dayOfWeek: "monday", hourUTC: 3 }, fn);
-      c.monthly("m", { day: 1, hourUTC: 3 }, fn);
-    });
-    expect(crons.d.schedule).toEqual({ type: "daily", hourUTC: 3 });
-    expect(crons.w.schedule).toEqual({
-      type: "weekly",
-      dayOfWeek: "monday",
-      hourUTC: 3,
-    });
-    expect(crons.m.schedule).toEqual({ type: "monthly", day: 1, hourUTC: 3 });
-  });
-
-  test("daily keeps an explicit minute", () => {
-    const crons = exported((c) =>
-      c.daily("d", { hourUTC: 3, minuteUTC: 23 }, fn),
-    );
-    expect(crons.d.schedule).toEqual({
-      type: "daily",
-      hourUTC: 3,
-      minuteUTC: 23,
-    });
-  });
-
-  test("an out-of-range minute is still rejected", () => {
-    expect(() => cronJobs().hourly("a", { minuteUTC: 60 }, fn)).toThrow();
-  });
-});