convex 1.44.0 → 1.45.0

package/src/server/query.test.ts

@@ -1,112 +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 { GenericDatabaseReader } from "./database.js";
-import { SystemDataModel, SystemTableNames } from "./schema.js";
-import { Id } from "../values/value.js";
-import { TableNamesInDataModel } from "./data_model.js";
-
-type Message = {
-  body: string;
-  _id: GenericId<"tableName">;
-};
-type DataModel = {
-  messages: {
-    document: Message;
-    fieldPaths: "body" | "_id";
-    indexes: {};
-    searchIndexes: {};
-    vectorIndexes: {};
-  };
-};
-type DB = GenericDatabaseReader<DataModel>;
-test("collect returns the correct types", () => {
-  function collect(db: DB) {
-    return db.query("messages").collect();
-  }
-  type Result = ReturnType<typeof collect>;
-  type Expected = Promise<Message[]>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("take returns the correct types", () => {
-  function take(db: DB) {
-    return db.query("messages").take(5);
-  }
-  type Result = ReturnType<typeof take>;
-  type Expected = Promise<Message[]>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("first returns the correct types", () => {
-  function first(db: DB) {
-    return db.query("messages").first();
-  }
-  type Result = ReturnType<typeof first>;
-  type Expected = Promise<Message | null>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("unique returns the correct types", () => {
-  function unique(db: DB) {
-    return db.query("messages").unique();
-  }
-  type Result = ReturnType<typeof unique>;
-  type Expected = Promise<Message | null>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("fullTableScan returns the correct types", () => {
-  function fullTableScan(db: DB) {
-    return db.query("messages").fullTableScan().collect();
-  }
-  type Result = ReturnType<typeof fullTableScan>;
-  type Expected = Promise<Message[]>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("order and filter don't change the return type", () => {
-  function orderAndFilter(db: DB) {
-    return db
-      .query("messages")
-      .order("desc")
-      .filter((q) => q.eq(q.field("body"), "Hello"))
-      .collect();
-  }
-  type Result = ReturnType<typeof orderAndFilter>;
-  type Expected = Promise<Message[]>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("can query() from system tables", () => {
-  function collect(db: DB, tableName: SystemTableNames) {
-    return db.system.query(tableName).collect();
-  }
-  type Result = ReturnType<typeof collect>;
-  type Expected = Promise<SystemDataModel[SystemTableNames]["document"][]>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("can get() from system tables", () => {
-  function get(db: DB, tableId: Id<SystemTableNames>) {
-    return db.system.get(tableId);
-  }
-  type Result = ReturnType<typeof get>;
-  type Expected = Promise<SystemDataModel[SystemTableNames]["document"] | null>;
-  assert<Equals<Result, Expected>>();
-});
-
-test("system-level database reader can only get() from system tables", () => {
-  function get(db: DB, tableId: Id<TableNamesInDataModel<DataModel>>) {
-    // @ts-expect-error We cannot query user tables from system GenericDatabaseReader
-    return db.system.get(tableId);
-  }
-});
-
-test("system-level database reader can only query() from system tables", () => {
-  function collect(db: DB, tableName: TableNamesInDataModel<DataModel>) {
-    // @ts-expect-error We cannot query user tables from system GenericDatabaseReader
-    return db.system.query(tableName).collect();
-  }
-});

package/src/server/registration.test.ts

@@ -1,589 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { test, describe, expect } from "vitest";
-import { assert, assertFalse, Equals } from "../test/type_testing.js";
-import { v } from "../values/validator.js";
-import {
-  ActionBuilder,
-  ApiFromModules,
-  DefaultFunctionArgs,
-  GenericDataModel,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  QueryBuilder,
-  actionGeneric,
-  mutationGeneric,
-  queryGeneric,
-} from "./index.js";
-import { EmptyObject, MutationBuilder } from "./registration.js";
-
-describe("argument inference", () => {
-  // Test with mutation, but all the wrappers work the same way.
-  const mutation: MutationBuilder<any, "public"> = (() => {
-    // Intentional noop. We're only testing the type
-  }) as any;
-
-  const module = {
-    inlineNoArg: mutation(() => "result"),
-    inlineUntypedArg: mutation((_ctx, { _arg }) => "result"),
-    inlineTypedArg: mutation((_ctx, { _arg }: { _arg: string }) => "result"),
-
-    // There are unusual syntaxes.
-    inlineUntypedDefaultArg: mutation(
-      (_ctx, { _arg } = { _arg: 1 }) => "result",
-    ),
-    inlineTypedDefaultArg: mutation(
-      // @ts-expect-error This syntax has never been allowed.
-      (_ctx, { _arg }: { _arg: string } = { _arg: "default" }) => "result",
-    ),
-    inlineTypedOptionalDefaultArg: mutation(
-      (_ctx, { _arg }: { _arg?: string } = { _arg: "default" }) => "result",
-    ),
-
-    configNoArg: mutation({
-      handler: () => "result",
-    }),
-    configValidatorNoArg: mutation({
-      args: {},
-      handler: () => "result",
-    }),
-    configUntypedArg: mutation({
-      handler: (_, { arg }) => {
-        assert<Equals<typeof arg, unknown>>;
-        return "result";
-      },
-    }),
-    configTypedArg: mutation({
-      handler: (_, { arg }: { arg: string }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configOptionalValidatorUntypedArg: mutation({
-      args: {
-        arg: v.optional(v.string()),
-      },
-      handler: (_, { arg }) => {
-        assert<Equals<typeof arg, string | undefined>>;
-        return "result";
-      },
-    }),
-    configValidatorUntypedArg: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, { arg }: { arg: string }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configValidatorTypedArg: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, { arg }: { arg: string }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configValidatorMismatchedTypedArg: mutation({
-      args: {
-        _arg: v.number(),
-      },
-      // @ts-expect-error  The arg type mismatches
-      handler: (_, { _arg }: { _arg: string }) => {
-        return "result";
-      },
-    }),
-    configValidatorReturn: mutation({
-      args: {
-        _arg: v.number(),
-      },
-      returns: v.number(),
-      // @ts-expect-error  The return type mismatches
-      handler: (_, { _arg }) => {
-        return "result";
-      },
-    }),
-
-    // These are unusual syntaxes. We'd like to break some of them.
-    // Let's document them here so it's clear when we do that.
-    configUntypedDefaultArg: mutation({
-      handler: (_, { arg } = { arg: "default" }) => {
-        assert<Equals<typeof arg, unknown>>;
-        return "result";
-      },
-    }),
-    configTypedDefaultArg: mutation({
-      // @ts-expect-error This syntax has never been allowed.
-      handler: (_, { arg }: { arg: string } = { arg: "default" }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configTypedOptionalDefaultArg: mutation({
-      // This syntax is incidentally allowed, it is not supported.
-      handler: (_, { arg }: { arg?: string } = { arg: "default" }) => {
-        assert<Equals<typeof arg, string | undefined>>;
-        return "result";
-      },
-    }),
-    configValidatorUntypedDefaultArg: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, { arg } = { arg: "default" }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configValidatorTypedDefaultArg: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, { arg }: { arg: string } = { arg: "default" }) => {
-        assert<Equals<typeof arg, string>>;
-        return "result";
-      },
-    }),
-    configValidatorTypedOptionalDefaultArg: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, { arg }: { arg?: string } = { arg: "default" }) => {
-        assert<Equals<typeof arg, string | undefined>>;
-        return "result";
-      },
-    }),
-  };
-  type API = ApiFromModules<{ module: typeof module }>;
-
-  test("inline with no arg", () => {
-    type Args = API["module"]["inlineNoArg"]["_args"];
-    assert<Equals<Args, EmptyObject>>();
-    type ReturnType = API["module"]["inlineNoArg"]["_returnType"];
-    assert<Equals<ReturnType, string>>();
-  });
-
-  test("inline with untyped arg", () => {
-    type Args = API["module"]["inlineUntypedArg"]["_args"];
-    type ExpectedArgs = DefaultFunctionArgs;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("inline with typed arg", () => {
-    type Args = API["module"]["inlineTypedArg"]["_args"];
-    type ExpectedArgs = { _arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  // This is not a very useful type (allows any key) but let's
-  // test it so we know if it's changing.
-  test("inline with untyped arg with default value", () => {
-    type Args = API["module"]["inlineUntypedDefaultArg"]["_args"];
-    type ExpectedArgs = DefaultFunctionArgs | EmptyObject;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  // This syntax is a type error where it is defined so it falls back.
-  test("inline with typed arg with default value", () => {
-    type Args = API["module"]["inlineTypedDefaultArg"]["_args"];
-    type ExpectedArgs = Record<string, unknown>;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  // This is not a very useful type (allows any key) but add let's
-  // test it so we know if it's changing.
-  test("inline with typed arg with optional default value", () => {
-    type Args = API["module"]["inlineTypedOptionalDefaultArg"]["_args"];
-    type ExpectedArgs = DefaultFunctionArgs | EmptyObject;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with no arg", () => {
-    type Args = API["module"]["configNoArg"]["_args"];
-    type ExpectedArgs = EmptyObject;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with no arg and validator", () => {
-    type Args = API["module"]["configValidatorNoArg"]["_args"];
-    type ExpectedArgs = {};
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with untyped arg", () => {
-    type Args = API["module"]["configUntypedArg"]["_args"];
-    type ExpectedArgs = DefaultFunctionArgs;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed arg", () => {
-    type Args = API["module"]["configTypedArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with untyped arg and validator", () => {
-    type Args = API["module"]["configValidatorUntypedArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with untyped arg and optional validator", () => {
-    type Args = API["module"]["configOptionalValidatorUntypedArg"]["_args"];
-    type ExpectedArgs = { arg?: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed arg and validator", () => {
-    type Args = API["module"]["configValidatorTypedArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with untyped arg and a default", () => {
-    type Args = API["module"]["configUntypedDefaultArg"]["_args"];
-    // This is not a very useful type
-    type ExpectedArgs = DefaultFunctionArgs | EmptyObject;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed arg and a default", () => {
-    type Args = API["module"]["configTypedDefaultArg"]["_args"];
-    // This is a type error at the definition site so this is the fallback.
-    type ExpectedArgs = Record<string, unknown>;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed optional arg and a default", () => {
-    type Args = API["module"]["configTypedOptionalDefaultArg"]["_args"];
-    // This is not a very useful type
-    type ExpectedArgs = DefaultFunctionArgs | EmptyObject;
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with untyped arg and a validator and a default", () => {
-    type Args = API["module"]["configValidatorUntypedDefaultArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed arg and a validator and a default", () => {
-    type Args = API["module"]["configValidatorTypedDefaultArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-
-  test("config with typed optional arg and a validator and a default", () => {
-    type Args =
-      API["module"]["configValidatorTypedOptionalDefaultArg"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-  });
-});
-
-describe("argument inference 2: args and validators", () => {
-  // Test with mutation, but all the wrappers work the same way.
-  const mutation: MutationBuilder<any, "public"> = (() => {
-    // Intentional noop. We're only testing the type
-  }) as any;
-
-  const module = {
-    argsSubtypeOfArgsValidator: mutation({
-      args: { foo: v.string() },
-      handler: (_, { foo }: { foo: string | number }) => 1,
-    }),
-    argsSupertypeOfArgsValidator: mutation({
-      args: { foo: v.union(v.string(), v.number()) },
-      handler: (_, { foo }: { foo: string }) => 1,
-    }),
-    argsPartiallyIntersectArgsValidator: mutation({
-      args: { foo: v.union(v.string(), v.number()) },
-      // @ts-expect-error when neither type is a subtype of the other, error
-      handler: (_, { foo }: { foo: string | Array<number> }) => 1,
-    }),
-    argsDontIntersectArgsValidator: mutation({
-      args: { foo: v.string() },
-      // @ts-expect-error when neither type is a subtype of the other, error
-      handler: (_, { foo }: { foo: number }) => 1,
-    }),
-  };
-
-  type API = ApiFromModules<{ module: typeof module }>;
-
-  // If the validator is more specific, that's the type that will be used.
-  // That seems right.
-  test("Handler args are a subtype of args validator", () => {
-    type Args = API["module"]["argsSubtypeOfArgsValidator"]["_args"];
-    assert<Equals<Args, { foo: string }>>();
-  });
-  // If the argument type is more specific, that's the type used.
-  // It would be nice to change this. If the validator type
-  // could entirely determine the inferred type on the client
-  // then you could skip the function for inference!
-  test("Handler args are a supertype of args validator", () => {
-    type Args = API["module"]["argsSupertypeOfArgsValidator"]["_args"];
-    assert<Equals<Args, { foo: string }>>();
-  });
-});
-
-describe("argument inference 3: outputs and validators", () => {
-  // Test with mutation, but all the wrappers work the same way.
-  const mutation: MutationBuilder<any, "public"> = (() => {
-    // Intentional noop. We're only testing the type
-  }) as any;
-
-  const module = {
-    returnSubtypeOfReturnsValidator: mutation({
-      returns: v.string(),
-      handler: (_) => "a" as const,
-    }),
-    returnSupertypeOfReturnsValidator: mutation({
-      returns: v.literal("a"),
-      // @ts-expect-error when return value is not a subtype of validator, error
-      handler: (_) => "b" as "b" | "a",
-    }),
-    returnPartiallyIntersectReturnsValidator: mutation({
-      returns: v.union(v.literal("a"), v.literal("b")),
-      // @ts-expect-error when return value is not a subtype of validator, error
-      handler: (_) => "b" as "b" | "c",
-    }),
-    returnDoesntIntersectReturnsValidator: mutation({
-      returns: v.literal("a"),
-      // @ts-expect-error when neither type is a subtype of the other, error
-      handler: (_) => "b" as const,
-    }),
-  };
-
-  type API = ApiFromModules<{ module: typeof module }>;
-
-  // Output validators seem to work about right.
-  test("Handler return value is a subtype of returns validator", () => {
-    type ReturnType =
-      API["module"]["returnSubtypeOfReturnsValidator"]["_returnType"];
-    assert<Equals<ReturnType, "a">>();
-  });
-  test("Handler return value is a supertype of returns validator", () => {
-    type ReturnType =
-      API["module"]["returnSupertypeOfReturnsValidator"]["_returnType"];
-    assert<Equals<ReturnType, any>>();
-  });
-});
-
-describe("argument and return value validators can be objects or validators", () => {
-  // Test with mutation, we aim for all the wrappers work the same way.
-  const mutation: MutationBuilder<any, "public"> = mutationGeneric;
-  const query: QueryBuilder<any, "public"> = queryGeneric;
-  const action: ActionBuilder<any, "public"> = actionGeneric;
-
-  const module = {
-    configArgsObject: mutation({
-      args: {
-        arg: v.string(),
-      },
-      handler: (_, args) => {
-        assert<Equals<(typeof args)["arg"], string>>;
-        return "result";
-      },
-    }),
-    configArgsValidatorIsNotSupported: mutation({
-      args: v.object({
-        arg: v.string(),
-      }),
-      handler: (_, args) => {
-        assert<Equals<(typeof args)["arg"], string>>;
-        return "result";
-      },
-    }),
-    configOutputObject: mutation({
-      returns: {
-        arg: v.string(),
-      },
-      handler: () => {
-        return { arg: "result" };
-      },
-    }),
-    configOutputValidator: mutation({
-      returns: v.object({
-        arg: v.string(),
-      }),
-      handler: () => {
-        return { arg: "result" };
-      },
-    }),
-
-    // test queries and actions just a bit too
-    q1: query({
-      args: v.object({
-        arg: v.string(),
-      }),
-      returns: { arg: v.string() },
-      handler: (_, { arg }) => {
-        return { arg: arg };
-      },
-    }),
-
-    a1: action({
-      args: v.object({
-        arg: v.string(),
-      }),
-      returns: { arg: v.string() },
-      handler: (_, { arg }) => {
-        return { arg: arg };
-      },
-    }),
-
-    queryAsync: query({
-      args: v.object({
-        arg: v.string(),
-      }),
-      returns: { arg: v.string() },
-      handler: async (_, { arg }) => {
-        return { arg: arg };
-      },
-    }),
-
-    mutationAsync: mutation({
-      args: v.object({
-        arg: v.string(),
-      }),
-      returns: { arg: v.string() },
-      handler: async (_, { arg }) => {
-        return { arg: arg };
-      },
-    }),
-
-    actionAsync: action({
-      args: v.object({
-        arg: v.string(),
-      }),
-      returns: { arg: v.string() },
-      handler: async (_, { arg }) => {
-        return { arg: arg };
-      },
-    }),
-
-    // This is syntx that we no longer want to support when typechecking because they result in undefined behavior.
-    mutationNoOptionalValidators: mutation({
-      // @ts-expect-error Optional validators are not supported at the top level
-      args: v.optional(v.string()),
-      // @ts-expect-error Optional validators are not supported at the top level
-      returns: v.optional(v.string()),
-      handler: () => {
-        return "result";
-      },
-    }),
-    queryNoOptionalValidators: query({
-      // @ts-expect-error Optional validators are not supported at the top level
-      args: v.optional(v.string()),
-      // @ts-expect-error Optional validators are not supported at the top level
-      returns: v.optional(v.string()),
-      handler: () => {
-        return "result";
-      },
-    }),
-    actionNoOptionalValidators: action({
-      // @ts-expect-error Optional validators are not supported at the top level
-      args: v.optional(v.string()),
-      // @ts-expect-error Optional validators are not supported at the top level
-      returns: v.optional(v.string()),
-      handler: () => {
-        return "result";
-      },
-    }),
-  };
-  type API = ApiFromModules<{ module: typeof module }>;
-
-  const expectedArgsExport = {
-    type: "object",
-    value: {
-      arg: {
-        fieldType: {
-          type: "string",
-        },
-        optional: false,
-      },
-    },
-  };
-
-  const expectedReturnsExport = {
-    type: "object",
-    value: {
-      arg: {
-        fieldType: {
-          type: "string",
-        },
-        optional: false,
-      },
-    },
-  };
-
-  test("config with args validator", () => {
-    type Args = API["module"]["configArgsObject"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-    const argsString = module.configArgsObject.exportArgs();
-    expect(JSON.parse(argsString)).toEqual(expectedArgsExport);
-  });
-
-  test("config with args object", () => {
-    type Args = API["module"]["configArgsValidatorIsNotSupported"]["_args"];
-    type ExpectedArgs = { arg: string };
-    assert<Equals<Args, ExpectedArgs>>;
-    const argsString = module.configArgsObject.exportArgs();
-    expect(JSON.parse(argsString)).toEqual(expectedArgsExport);
-  });
-
-  test("config with output validator", () => {
-    type ReturnType = API["module"]["configOutputObject"]["_returnType"];
-    type Expected = { arg: string };
-    assert<Equals<ReturnType, Expected>>;
-    const returnString = module.configOutputObject.exportReturns();
-    expect(JSON.parse(returnString)).toEqual(expectedReturnsExport);
-  });
-
-  test("config with output object", () => {
-    type ReturnType = API["module"]["configOutputValidator"]["_returnType"];
-    type Expected = { arg: string };
-    assert<Equals<ReturnType, Expected>>;
-    const returnString = module.configOutputValidator.exportReturns();
-    expect(JSON.parse(returnString)).toEqual(expectedReturnsExport);
-  });
-
-  test("queries", () => {
-    type ReturnType = API["module"]["q1"]["_returnType"];
-    type Expected = { arg: string };
-    assert<Equals<ReturnType, Expected>>;
-    const returnString = module.configOutputValidator.exportReturns();
-    expect(JSON.parse(returnString)).toEqual(expectedReturnsExport);
-  });
-
-  test("actions", () => {
-    type ReturnType = API["module"]["configOutputValidator"]["_returnType"];
-    type Expected = { arg: string };
-    assert<Equals<ReturnType, Expected>>;
-    const returnString = module.configOutputValidator.exportReturns();
-    expect(JSON.parse(returnString)).toEqual(expectedReturnsExport);
-  });
-});
-
-describe("useStaleSnapshot availability", () => {
-  type MutationRunQueryOptions = NonNullable<
-    Parameters<GenericMutationCtx<GenericDataModel>["runQuery"]>[2]
-  >;
-  type QueryRunQueryOptions = NonNullable<
-    Parameters<GenericQueryCtx<GenericDataModel>["runQuery"]>[2]
-  >;
-
-  test("available on mutation ctx runQuery options", () => {
-    assert<
-      "useStaleSnapshot" extends keyof MutationRunQueryOptions ? true : false
-    >();
-  });
-
-  test("not available on query ctx runQuery options", () => {
-    assertFalse<
-      "useStaleSnapshot" extends keyof QueryRunQueryOptions ? true : false
-    >();
-  });
-});