convex-helpers 0.1.13 → 0.1.14

package/README.md

@@ -15,17 +15,18 @@ define custom behavior, allowing you to:
   as taking in an authentication parameter like an API key or session ID.
   These arguments must be sent up by the client along with each request.
 
+See the associated [Stack Post](https://stack.convex.dev/custom-functions)
+
 For example:
 ```js
 import { customQuery } from "convex-helpers/server/customFunctions.js
 
 const myQueryBuilder = customQuery(query, {
-  args: { sessionId: v.id("sessions") },
+  args: { apiToken: v.id("api_tokens") },
   input: async (ctx, args) => {
-    const user = await getUserOrNull(ctx);
-    const session = await db.get(sessionId);
-    const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
-    return { ctx: { db, user, session }, args: {} };
+    const apiUser = await getApiUser(args.apiToken);
+    const db = wrapDatabaseReader({ apiUser }, ctx.db, rlsRules);
+    return { ctx: { db, apiUser }, args: {} };
   },
 });
 
@@ -33,7 +34,7 @@ const myQueryBuilder = customQuery(query, {
 export const getSomeData = myQueryBuilder({
   args: { someArg: v.string() },
   handler: async (ctx, args) => {
-    const { db, user, session, scheduler } = ctx;
+    const { db, apiUser, scheduler } = ctx;
     const { someArg } = args;
     // ...
   }
@@ -72,6 +73,16 @@ const posts = await asyncMap(
 );
 ```
 
+## Session tracking via client-side sessionID storage
+
+Store a session ID on the client and pass it up with requests to keep track of
+a user, even if they aren't logged in.
+
+Use the client-side helpers in [react/sessions](./react/sessions.ts) and
+server-side helpers in [server/sessions](./server/sessions.ts).
+
+See the associated [Stack post](https://stack.convex.dev/track-sessions-without-cookies) for more information.
+
 ## Row-level security
 
 See the [Stack post on row-level security](https://stack.convex.dev/row-level-security)

package/dist/index.d.ts

@@ -1,11 +1,12 @@
 /**
  * asyncMap returns the results of applying an async function over an list.
  *
+ * The list can even be a promise, or an iterable like a Set.
  * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
  * @param asyncTransform
  * @returns
  */
-export declare function asyncMap<FromType, ToType>(list: Iterable<FromType>, asyncTransform: (item: FromType, index: number) => Promise<ToType>): Promise<ToType[]>;
+export declare function asyncMap<FromType, ToType>(list: Iterable<FromType> | Promise<Iterable<FromType>>, asyncTransform: (item: FromType, index: number) => Promise<ToType>): Promise<ToType[]>;
 /**
  * Filters out null elements from an array.
  * @param list List of elements that might be null.
@@ -20,3 +21,32 @@ export declare class NullDocumentError extends Error {
  * @returns Same list of elements with a refined type.
  */
 export declare function nullThrows<T>(doc: T | null, message?: string): T;
+export type EmptyObject = Record<string, never>;
+/**
+ * An `Omit<>` type that:
+ * 1. Applies to each element of a union.
+ * 2. Preserves the index signature of the underlying type.
+ */
+export type BetterOmit<T, K extends keyof T> = {
+    [Property in keyof T as Property extends K ? never : Property]: T[Property];
+};
+/**
+ * TESTS
+ */
+/**
+ * Tests if two types are exactly the same.
+ * Taken from https://github.com/Microsoft/TypeScript/issues/27024#issuecomment-421529650
+ * (Apache Version 2.0, January 2004)
+ */
+export type Equals<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/**
+ * A utility for both compile-time type assertions and runtime assertions.
+ *
+ * @example
+ * ```ts
+ * // Compile-time assertion
+ * assert<Equals<1, 1>>();
+ * ```
+ * @param arg A value to assert the truthiness of.
+ */
+export declare function assert<T extends true>(arg?: T): void;

package/dist/index.js

@@ -1,6 +1,7 @@
 /**
  * asyncMap returns the results of applying an async function over an list.
  *
+ * The list can even be a promise, or an iterable like a Set.
  * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
  * @param asyncTransform
  * @returns
@@ -8,7 +9,7 @@
 export async function asyncMap(list, asyncTransform) {
     const promises = [];
     let index = 0;
-    for (const item of list) {
+    for (const item of await list) {
         promises.push(asyncTransform(item, index));
         index += 1;
     }
@@ -35,3 +36,19 @@ export function nullThrows(doc, message) {
     }
     return doc;
 }
+/**
+ * A utility for both compile-time type assertions and runtime assertions.
+ *
+ * @example
+ * ```ts
+ * // Compile-time assertion
+ * assert<Equals<1, 1>>();
+ * ```
+ * @param arg A value to assert the truthiness of.
+ */
+export function assert(arg) {
+    // no need to do anything! we're just asserting at compile time that the type
+    // parameter is true.
+    if (arg !== undefined && !arg)
+        throw new Error(`Assertion failed: ${arg}`);
+}

package/dist/react/sessions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * React helpers for adding session data to Convex functions.
+ *
+ * !Important!: To use these functions, you must wrap your code with
+ * ```tsx
+ *  <ConvexProvider client={convex}>
+ *    <SessionProvider>
+ *      <App />
+ *    </SessionProvider>
+ *  </ConvexProvider>
+ * ```
+ *
+ * With the `SessionProvider` inside the `ConvexProvider` but outside your app.
+ *
+ * See the associated [Stack post](https://stack.convex.dev/track-sessions-without-cookies)
+ * for more information.
+ */
+import React, { Dispatch, SetStateAction } from "react";
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
+import type { SessionId } from "../server/sessions";
+import { EmptyObject, BetterOmit } from "..";
+export type UseStorage<T> = (key: string, initialValue: T) => readonly [T, Dispatch<SetStateAction<T>>];
+export type RefreshSessionFn = (beforeUpdate?: (newSessionId: SessionId) => any | Promise<any>) => Promise<SessionId>;
+type SessionFunction<T extends "query" | "mutation" | "action", Args extends any = any> = FunctionReference<T, "public", {
+    sessionId: SessionId;
+} & Args, any>;
+type SessionQueryArgsArray<Fn extends SessionFunction<"query">> = keyof FunctionArgs<Fn> extends "sessionId" ? [args?: EmptyObject | "skip"] : [args: BetterOmit<FunctionArgs<Fn>, "sessionId"> | "skip"];
+type SessionArgsArray<Fn extends SessionFunction<"mutation" | "action">> = keyof FunctionArgs<Fn> extends "sessionId" ? [args?: EmptyObject] : [args: BetterOmit<FunctionArgs<Fn>, "sessionId">];
+/**
+ * Context for a Convex session, creating a server session and providing the id.
+ *
+ * @param props - Where you want your session ID to be persisted. Roughly:
+ *  - sessionStorage is saved per-tab
+ *  - localStorage is shared between tabs, but not browser profiles.
+ * @returns A provider to wrap your React nodes which provides the session ID.
+ * To be used with useSessionQuery and useSessionMutation.
+ */
+export declare const SessionProvider: React.FC<{
+    useStorage?: UseStorage<SessionId>;
+    storageKey?: string;
+    children?: React.ReactNode;
+}>;
+export declare function useSessionQuery<Query extends SessionFunction<"query">>(query: Query, ...args: SessionQueryArgsArray<Query>): FunctionReturnType<Query> | undefined;
+export declare function useSessionMutation<Mutation extends SessionFunction<"mutation">>(name: Mutation): (...args: SessionArgsArray<Mutation>) => Promise<FunctionReturnType<Mutation>>;
+export declare function useSessionAction<Action extends SessionFunction<"action">>(name: Action): (...args: SessionArgsArray<Action>) => Promise<FunctionReturnType<Action>>;
+export declare function useSessionId(): readonly [SessionId, RefreshSessionFn];
+export {};

package/dist/react/sessions.js

@@ -0,0 +1,111 @@
+/**
+ * React helpers for adding session data to Convex functions.
+ *
+ * !Important!: To use these functions, you must wrap your code with
+ * ```tsx
+ *  <ConvexProvider client={convex}>
+ *    <SessionProvider>
+ *      <App />
+ *    </SessionProvider>
+ *  </ConvexProvider>
+ * ```
+ *
+ * With the `SessionProvider` inside the `ConvexProvider` but outside your app.
+ *
+ * See the associated [Stack post](https://stack.convex.dev/track-sessions-without-cookies)
+ * for more information.
+ */
+import React, { useCallback, useContext, useMemo, useState, } from "react";
+import { useQuery, useMutation, useAction } from "convex/react";
+import { assert } from "..";
+const SessionContext = React.createContext(null);
+/**
+ * Context for a Convex session, creating a server session and providing the id.
+ *
+ * @param props - Where you want your session ID to be persisted. Roughly:
+ *  - sessionStorage is saved per-tab
+ *  - localStorage is shared between tabs, but not browser profiles.
+ * @returns A provider to wrap your React nodes which provides the session ID.
+ * To be used with useSessionQuery and useSessionMutation.
+ */
+export const SessionProvider = ({ useStorage, storageKey, children }) => {
+    const storeKey = storageKey ?? "convex-session-id";
+    const initialId = useMemo(() => crypto.randomUUID(), []);
+    // Get or set the ID from our desired storage location.
+    const useStorageOrDefault = useStorage ?? useSessionStorage;
+    const [sessionId, setSessionId] = useStorageOrDefault(storeKey, initialId);
+    const refreshSessionId = useCallback(async (beforeUpdate) => {
+        const newSessionId = crypto.randomUUID();
+        if (beforeUpdate) {
+            await beforeUpdate(newSessionId);
+        }
+        setSessionId(newSessionId);
+        return newSessionId;
+    }, [setSessionId]);
+    return React.createElement(SessionContext.Provider, { value: { sessionId, refreshSessionId } }, children);
+};
+// Like useQuery, but for a Query that takes a session ID.
+export function useSessionQuery(query, ...args) {
+    const skip = args[0] === "skip";
+    const [sessionId] = useSessionId();
+    const originalArgs = args[0] === "skip" ? {} : args[0] ?? {};
+    const newArgs = skip ? "skip" : { ...originalArgs, sessionId };
+    return useQuery(query, ...[newArgs]);
+}
+// Like useMutation, but for a Mutation that takes a session ID.
+export function useSessionMutation(name) {
+    const [sessionId] = useSessionId();
+    const originalMutation = useMutation(name);
+    return useCallback((...args) => {
+        const newArgs = {
+            ...(args[0] ?? {}),
+            sessionId,
+        };
+        return originalMutation(...[newArgs]);
+    }, [sessionId, originalMutation]);
+}
+// Like useAction, but for a Action that takes a session ID.
+export function useSessionAction(name) {
+    const [sessionId] = useSessionId();
+    const originalAction = useAction(name);
+    return useCallback((...args) => {
+        const newArgs = {
+            ...(args[0] ?? {}),
+            sessionId,
+        };
+        return originalAction(...[newArgs]);
+    }, [sessionId, originalAction]);
+}
+export function useSessionId() {
+    const ctx = useContext(SessionContext);
+    if (ctx === null) {
+        throw new Error("Missing a <SessionProvider> wrapping this code.");
+    }
+    return [ctx.sessionId, ctx.refreshSessionId];
+}
+function useSessionStorage(key, initialValue) {
+    const [value, setValueInternal] = useState(() => {
+        if (typeof sessionStorage !== "undefined") {
+            const existing = sessionStorage.getItem(key);
+            if (existing) {
+                try {
+                    return existing;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            sessionStorage.setItem(key, initialValue);
+        }
+        return initialValue;
+    });
+    const setValue = useCallback((value) => {
+        sessionStorage.setItem(key, value);
+        setValueInternal(value);
+    }, [key]);
+    return [value, setValue];
+}
+assert();
+assert();
+assert();
+assert();

package/dist/server/customFunctions.d.ts

@@ -12,6 +12,7 @@
  */
 import { ObjectType, PropertyValidators } from "convex/values";
 import { ActionBuilder, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, UnvalidatedFunction } from "convex/server";
+import { EmptyObject } from "..";
 /**
  * A modifier for a query, mutation, or action.
  *
@@ -255,6 +256,5 @@ export type UnvalidatedBuilder<FuncType extends "query" | "mutation" | "action",
 type CustomBuilder<FuncType extends "query" | "mutation" | "action", ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility> = ModArgsValidator extends EmptyObject ? ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility> & UnvalidatedBuilder<FuncType, ModCtx, ModMadeArgs, InputCtx, Visibility> : ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility>;
 export type CustomCtx<Builder> = Builder extends ValidatedBuilder<any, any, infer ModCtx, any, infer InputCtx, any> ? Overwrite<InputCtx, ModCtx> : never;
 type Overwrite<T, U> = Omit<T, keyof U> & U;
-type EmptyObject = Record<string, never>;
 type DefaultFunctionArgs = Record<string, unknown>;
 export {};

package/dist/server/index.d.ts

@@ -27,3 +27,4 @@ export declare function Table<T extends Record<string, Validator<any, any, any>>
         _creationTime: Validator<number, false, never>;
     };
 };
+export declare function missingEnvVariableUrl(envVarName: string, whereToGet: string): string;

package/dist/server/index.js

@@ -26,3 +26,12 @@ export function Table(name, fields) {
         withSystemFields,
     };
 }
+export function missingEnvVariableUrl(envVarName, whereToGet) {
+    const deploymentName = process.env.CONVEX_CLOUD_URL?.slice(8).replace(".convex.cloud", "");
+    return (`\n  Missing ${envVarName} in environment variables.\n\n` +
+        `  Get it from ${whereToGet} .\n` +
+        "  Paste it on the Convex dashboard:\n" +
+        "  https://dashboard.convex.dev/d/" +
+        deploymentName +
+        `/settings?var=${envVarName}`);
+}

package/dist/server/relationships.d.ts

@@ -8,7 +8,7 @@ import { GenericId } from "convex/values";
  * @param ids An list (or other iterable) of Ids pointing to a table.
  * @returns The Documents referenced by the Ids, in order. `null` if not found.
  */
-export declare function getAll<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, ids: Iterable<GenericId<TableName>>): Promise<(DocumentByName<DataModel, TableName> | null)[]>;
+export declare function getAll<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, ids: Iterable<GenericId<TableName>> | Promise<Iterable<GenericId<TableName>>>): Promise<(DocumentByName<DataModel, TableName> | null)[]>;
 /**
  * getAllOrThrow returns a list of Documents for the `Id`s passed in.
  *
@@ -17,7 +17,7 @@ export declare function getAll<DataModel extends GenericDataModel, TableName ext
  * @param ids An list (or other iterable) of Ids pointing to a table.
  * @returns The Documents referenced by the Ids, in order. `null` if not found.
  */
-export declare function getAllOrThrow<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, ids: Iterable<GenericId<TableName>>): Promise<DocumentByName<DataModel, TableName>[]>;
+export declare function getAllOrThrow<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>>(db: GenericDatabaseReader<DataModel>, ids: Iterable<GenericId<TableName>> | Promise<Iterable<GenericId<TableName>>>): Promise<DocumentByName<DataModel, TableName>[]>;
 type UserIndexes<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = Exclude<IndexNames<NamedTableInfo<DataModel, TableName>>, "by_creation_time"> & string;
 type TablesWithLookups<DataModel extends GenericDataModel> = {
     [T in TableNamesInDataModel<DataModel>]: UserIndexes<DataModel, T> extends never ? never : T;

package/dist/server/sessions.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Allows you to persist state server-side, associated with a sessionId stored
+ * on the client (in localStorage, e.g.).
+ *
+ * You can define your function to take in a sessionId parameter of type
+ * SessionId, which is just a branded string to help avoid errors.
+ * The validator is vSessionId, or you can spread the argument in for your
+ * function like this:
+ * ```ts
+ * const myMutation = mutation({
+ *   args: {
+ * 	 arg1: v.number(), // whatever other args you want
+ * 	 ...SessionIdArg,
+ *   },
+ *   handler: async (ctx, args) => {
+ *     // args.sessionId is a SessionId
+ *   })
+ * });
+ * ```
+ *
+ * Then, on the client side, you can use {@link useSessionMutation} to call
+ * your function with the sessionId automatically passed in, like:
+ * ```ts
+ * const myMutation = useSessionMutation(api.myModule.myMutation);
+ * ...
+ * await myMutation({ arg1: 123 });
+ * ```
+ *
+ * To codify the sessionId parameter, you can use the customFunction module to
+ * create a custom mutation or query, like:
+ * ```ts
+ * export const sessionMutation = customMutation(mutation, {
+ *   args: { ...SessionIdArg },
+ *   input: (ctx, { sessionId }) => {
+ *     const anonUser = await getAnonymousUser(ctx, sessionId);
+ *     return { ctx: { anonUser }, args: {} };
+ *   },
+ * });
+ * ```
+ *
+ * Then you can define functions like:
+ * ```ts
+ * export const myMutation = sessionMutation({
+ * 	 args: { arg1: v.number() }, // whatever other args you want
+ *   handler: async (ctx, args) => {
+ *     // ctx.anonUser exists and has a type from getAnonymousUser.
+ *     // args is { arg1: number }
+ *   })
+ * });
+ * ```
+ *
+ * See the associated [Stack post](https://stack.convex.dev/track-sessions-without-cookies)
+ * for more information.
+ */
+import { FunctionArgs, FunctionReference, FunctionReturnType, GenericActionCtx, GenericDataModel } from "convex/server";
+import { Validator } from "convex/values";
+import { BetterOmit, EmptyObject } from "..";
+export type SessionId = string & {
+    __SessionId: true;
+};
+export declare const vSessionId: Validator<SessionId, false, never>;
+export declare const SessionIdArg: {
+    sessionId: Validator<SessionId, false, never>;
+};
+type SessionFunction<T extends "query" | "mutation" | "action", Args extends any = any> = FunctionReference<T, "public" | "internal", {
+    sessionId: SessionId;
+} & Args, any>;
+type SessionArgsArray<Fn extends SessionFunction<"query" | "mutation" | "action", any>> = keyof FunctionArgs<Fn> extends "sessionId" ? [args?: EmptyObject] : [args: BetterOmit<FunctionArgs<Fn>, "sessionId">];
+export interface RunSessionFunctions {
+    /**
+     * Run the Convex query with the given name and arguments.
+     *
+     * Consider using an {@link internalQuery} to prevent users from calling the
+     * query directly.
+     *
+     * @param query - A {@link FunctionReference} for the query to run.
+     * @param args - The arguments to the query function.
+     * @returns A promise of the query's result.
+     */
+    runSessionQuery<Query extends SessionFunction<"query">>(query: Query, ...args: SessionArgsArray<Query>): Promise<FunctionReturnType<Query>>;
+    /**
+     * Run the Convex mutation with the given name and arguments.
+     *
+     * Consider using an {@link internalMutation} to prevent users from calling
+     * the mutation directly.
+     *
+     * @param mutation - A {@link FunctionReference} for the mutation to run.
+     * @param args - The arguments to the mutation function.
+     * @returns A promise of the mutation's result.
+     */
+    runSessionMutation<Mutation extends SessionFunction<"mutation">>(mutation: Mutation, ...args: SessionArgsArray<Mutation>): Promise<FunctionReturnType<Mutation>>;
+    /**
+     * Run the Convex action with the given name and arguments.
+     *
+     * Consider using an {@link internalAction} to prevent users from calling the
+     * action directly.
+     *
+     * @param action - A {@link FunctionReference} for the action to run.
+     * @param args - The arguments to the action function.
+     * @returns A promise of the action's result.
+     */
+    runSessionAction<Action extends SessionFunction<"action">>(action: Action, ...args: SessionArgsArray<Action>): Promise<FunctionReturnType<Action>>;
+}
+export declare function runSessionFunctions<DataModel extends GenericDataModel>(ctx: GenericActionCtx<DataModel>, sessionId: SessionId): RunSessionFunctions;
+export {};

package/dist/server/sessions.js

@@ -0,0 +1,20 @@
+import { v } from "convex/values";
+// Validator for session IDs.
+export const vSessionId = v.string();
+export const SessionIdArg = { sessionId: vSessionId };
+export function runSessionFunctions(ctx, sessionId) {
+    return {
+        runSessionQuery(fn, ...args) {
+            const argsWithSession = { ...(args[0] ?? {}), sessionId };
+            return ctx.runQuery(fn, argsWithSession);
+        },
+        runSessionMutation(fn, ...args) {
+            const argsWithSession = { ...(args[0] ?? {}), sessionId };
+            return ctx.runMutation(fn, argsWithSession);
+        },
+        runSessionAction(fn, ...args) {
+            const argsWithSession = { ...(args[0] ?? {}), sessionId };
+            return ctx.runAction(fn, argsWithSession);
+        },
+    };
+}

package/dist/server/zod.d.ts

@@ -2,6 +2,7 @@ import { ZodTypeDef, z } from "zod";
 import { v, GenericId, ObjectType, PropertyValidators, Validator } from "convex/values";
 import { FunctionVisibility, GenericDataModel, GenericActionCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, GenericMutationCtx, ActionBuilder } from "convex/server";
 import { Mod, Registration, UnvalidatedBuilder } from "./customFunctions";
+import { EmptyObject } from "..";
 export type ZodValidator = Record<string, z.ZodTypeAny>;
 /**
  * Create a validator for a Convex `Id`.
@@ -193,7 +194,6 @@ type ValidatedBuilder<FuncType extends "query" | "mutation" | "action", ModArgsV
  * builder will require argument validation too.
  */
 type CustomBuilder<FuncType extends "query" | "mutation" | "action", ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility> = ModArgsValidator extends EmptyObject ? ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility> & UnvalidatedBuilder<FuncType, ModCtx, ModMadeArgs, InputCtx, Visibility> : ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility>;
-type EmptyObject = Record<string, never>;
 type ConvexValidatorFromZod<Z extends z.ZodTypeAny> = Z extends Zid<infer TableName> ? Validator<GenericId<TableName>> : Z extends z.ZodString ? Validator<string> : Z extends z.ZodNumber ? Validator<number> : Z extends z.ZodNaN ? Validator<number> : Z extends z.ZodBigInt ? Validator<bigint> : Z extends z.ZodBoolean ? Validator<boolean> : Z extends z.ZodNull ? Validator<null> : Z extends z.ZodUnknown ? Validator<any, false, string> : Z extends z.ZodAny ? Validator<any, false, string> : Z extends z.ZodArray<infer Inner> ? Validator<ConvexValidatorFromZod<Inner>["type"][]> : Z extends z.ZodObject<infer ZodShape> ? ReturnType<typeof v.object<{
     [key in keyof ZodShape]: ConvexValidatorFromZod<ZodShape[key]>;
 }>> : Z extends z.ZodUnion<infer T> ? Validator<ConvexValidatorFromZod<T[number]>["type"], false, ConvexValidatorFromZod<T[number]>["fieldPaths"]> : Z extends z.ZodDiscriminatedUnion<any, infer T> ? Validator<ConvexValidatorFromZod<T[number]>["type"], false, ConvexValidatorFromZod<T[number]>["fieldPaths"]> : Z extends z.ZodTuple<infer Inner> ? Validator<ConvexValidatorFromZod<Inner[number]>["type"][]> : Z extends z.ZodLazy<infer Inner> ? ConvexValidatorFromZod<Inner> : Z extends z.ZodLiteral<infer Literal> ? Validator<Literal> : Z extends z.ZodEnum<infer T> ? Validator<T[number]> : Z extends z.ZodEffects<infer Inner> ? ConvexValidatorFromZod<Inner> : Z extends z.ZodOptional<infer Inner> ? ConvexValidatorFromZod<Inner> extends Validator<infer InnerConvex, false, infer InnerFieldPaths> ? Validator<InnerConvex | undefined, true, InnerFieldPaths> : never : Z extends z.ZodNullable<infer Inner> ? ConvexValidatorFromZod<Inner> extends Validator<infer InnerConvex, infer InnerOptional, infer InnerFieldPaths> ? Validator<null | InnerConvex, InnerOptional, InnerFieldPaths> : never : Z extends z.ZodBranded<infer Inner, any> ? ConvexValidatorFromZod<Inner> : Z extends z.ZodDefault<infer Inner> ? ConvexValidatorFromZod<Inner> extends Validator<infer InnerConvex, false, infer InnerFieldPaths> ? Validator<InnerConvex | undefined, true, InnerFieldPaths> : never : Z extends z.ZodReadonly<infer Inner> ? ConvexValidatorFromZod<Inner> : Z extends z.ZodPipeline<infer Inner, any> ? ConvexValidatorFromZod<Inner> : never;