Module: server
Utilities for implementing server-side Convex query and mutation functions.
Usage
Code Generation
This module is typically used alongside generated server code.
To generate the server code, run npx convex dev
in your Convex project.
This will create a convex/_generated/server.js
file with the following
functions, typed for your schema:
If you aren't using TypeScript and code generation, you can use these untyped functions instead:
Example
Convex functions are defined by using either the query
or
mutation
wrappers.
Queries receive a db
that implements the GenericDatabaseReader interface.
import { query } from "./_generated/server";
export default query({
handler: async ({ db }, { arg1, arg2 }) => {
// Your (read-only) code here!
},
});
If your function needs to write to the database, such as inserting, updating,
or deleting documents, use mutation
instead which provides a db
that
implements the GenericDatabaseWriter interface.
import { mutation } from "./_generated/server";
export default mutation({
handler: async ({ db }, { arg1, arg2 }) => {
// Your mutation code here!
},
});
Classes
- Crons
- Expression
- IndexRange
- HttpRouter
- TableDefinition
- SchemaDefinition
- SearchFilter
- FilterExpression
Interfaces
- UserIdentity
- Auth
- CronJob
- BaseTableReader
- GenericDatabaseReader
- GenericDatabaseReaderWithTable
- GenericDatabaseWriter
- GenericDatabaseWriterWithTable
- BaseTableWriter
- FilterBuilder
- IndexRangeBuilder
- PaginationResult
- PaginationOptions
- QueryInitializer
- Query
- OrderedQuery
- GenericMutationCtx
- GenericQueryCtx
- GenericActionCtx
- ValidatedFunction
- Scheduler
- SearchIndexConfig
- VectorIndexConfig
- DefineSchemaOptions
- SystemDataModel
- SearchFilterBuilder
- SearchFilterFinalizer
- StorageReader
- StorageWriter
- StorageActionWriter
- VectorSearchQuery
- VectorFilterBuilder
References
UserIdentityAttributes
Re-exports UserIdentityAttributes
Type Aliases
FunctionType
Ƭ FunctionType: "query"
| "mutation"
| "action"
The type of a Convex function.
Defined in
FunctionReference
Ƭ FunctionReference<Type
, Visibility
, Args
, ReturnType
, ComponentPath
>: Object
A reference to a registered Convex function.
You can create a FunctionReference using the generated api
utility:
import { api } from "../convex/_generated/api";
const reference = api.myModule.myFunction;
If you aren't using code generation, you can create references using anyApi:
import { anyApi } from "convex/server";
const reference = anyApi.myModule.myFunction;
Function references can be used to invoke functions from the client. For example, in React you can pass references to the useQuery hook:
const result = useQuery(api.myModule.myFunction);
Type parameters
Name | Type | Description |
---|---|---|
Type | extends FunctionType | The type of the function ("query", "mutation", or "action"). |
Visibility | extends FunctionVisibility = "public" | The visibility of the function ("public" or "internal"). |
Args | extends DefaultFunctionArgs = any | The arguments to this function. This is an object mapping argument names to their types. |
ReturnType | any | The return type of this function. |
ComponentPath | string | undefined | - |
Type declaration
Name | Type |
---|---|
_type | Type |
_visibility | Visibility |
_args | Args |
_returnType | ReturnType |
_componentPath | ComponentPath |
Defined in
ApiFromModules
Ƭ ApiFromModules<AllModules
>: FilterApi
<ApiFromModulesAllowEmptyNodes
<AllModules
>, FunctionReference
<any
, any
, any
, any
>>
Given the types of all modules in the convex/
directory, construct the type
of api
.
api
is a utility for constructing FunctionReferences.
Type parameters
Name | Type | Description |
---|---|---|
AllModules | extends Record <string , object > | A type mapping module paths (like "dir/myModule" ) to the types of the modules. |
Defined in
FilterApi
Ƭ FilterApi<API
, Predicate
>: Expand
<{ [mod in keyof API as API[mod] extends Predicate ? mod : API[mod] extends FunctionReference<any, any, any, any> ? never : FilterApi<API[mod], Predicate> extends Record<string, never> ? never : mod]: API[mod] extends Predicate ? API[mod] : FilterApi<API[mod], Predicate> }>
Filter a Convex deployment api object for functions which meet criteria, for example all public queries.
Type parameters
Name |
---|
API |
Predicate |
Defined in
AnyApi
Ƭ AnyApi: Record
<string
, Record
<string
, AnyModuleDirOrFunc
>>
The type that Convex api objects extend. If you were writing an api from scratch it should extend this type.
Defined in
PartialApi
Ƭ PartialApi<API
>: { [mod in keyof API]?: API[mod] extends FunctionReference<any, any, any, any> ? API[mod] : PartialApi<API[mod]> }
Recursive partial API, useful for defining a subset of an API when mocking or building custom api objects.
Type parameters
Name |
---|
API |
Defined in
FunctionArgs
Ƭ FunctionArgs<FuncRef
>: FuncRef
["_args"
]
Given a FunctionReference, get the return type of the function.
This is represented as an object mapping argument names to values.
Type parameters
Name | Type |
---|---|
FuncRef | extends AnyFunctionReference |
Defined in
OptionalRestArgs
Ƭ OptionalRestArgs<FuncRef
>: FuncRef
["_args"
] extends EmptyObject
? [args?: EmptyObject] : [args: FuncRef["_args"]]
A tuple type of the (maybe optional) arguments to FuncRef
.
This type is used to make methods involving arguments type safe while allowing skipping the arguments for functions that don't require arguments.
Type parameters
Name | Type |
---|---|
FuncRef | extends AnyFunctionReference |
Defined in
ArgsAndOptions
Ƭ ArgsAndOptions<FuncRef
, Options
>: FuncRef
["_args"
] extends EmptyObject
? [args?: EmptyObject, options?: Options] : [args: FuncRef["_args"], options?: Options]
A tuple type of the (maybe optional) arguments to FuncRef
, followed by an options
object of type Options
.
This type is used to make methods like useQuery
type-safe while allowing
- Skipping arguments for functions that don't require arguments.
- Skipping the options object.
Type parameters
Name | Type |
---|---|
FuncRef | extends AnyFunctionReference |
Options | Options |
Defined in
FunctionReturnType
Ƭ FunctionReturnType<FuncRef
>: FuncRef
["_returnType"
]
Given a FunctionReference, get the return type of the function.
Type parameters
Name | Type |
---|---|
FuncRef | extends AnyFunctionReference |
Defined in
FunctionHandle
Ƭ FunctionHandle<Type
, Args
, ReturnType
>: string
& FunctionReference
<Type
, "internal"
, Args
, ReturnType
>
A serializable reference to a Convex function.
Passing a this reference to another component allows that component to call this
function during the current function execution or at any later time.
Function handles are used like api.folder.function
FunctionReferences,
e.g. ctx.scheduler.runAfter(0, functionReference, args)
.
A function reference is stable across code pushes but it's possible the Convex function it refers to might no longer exist.
This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.
Type parameters
Name | Type |
---|---|
Type | extends FunctionType |
Args | extends DefaultFunctionArgs = any |
ReturnType | any |
Defined in
ComponentDefinition
Ƭ ComponentDefinition<Exports
>: Object
An object of this type should be the default export of a convex.config.ts file in a component definition directory.
This is a feature of components, which are in beta. This API is unstable and may change in subsequent releases.
Type parameters
Name | Type |
---|---|
Exports | extends ComponentExports = any |
Type declaration
Name | Type | Description |
---|---|---|
use | <Definition>(definition : Definition , options? : { name? : string }) => InstalledComponent <Definition > | Install a component with the given definition in this component definition. Takes a component definition and an optional name. For editor tooling this method expects a ComponentDefinition but at runtime the object that is imported will be a ImportedComponentDefinition |
__exports | Exports | Internal type-only property tracking exports provided. Deprecated This is a type-only property, don't use it. |
Defined in
AnyChildComponents
Ƭ AnyChildComponents: Record
<string
, AnyComponentReference
>
Defined in
server/components/index.ts:402
AnyComponents
Ƭ AnyComponents: AnyChildComponents
Defined in
server/components/index.ts:442
GenericDocument
Ƭ GenericDocument: Record
<string
, Value
>
A document stored in Convex.
Defined in
GenericFieldPaths
Ƭ GenericFieldPaths: string
A type describing all of the document fields in a table.
These can either be field names (like "name") or references to fields on nested objects (like "properties.name").
Defined in
GenericIndexFields
Ƭ GenericIndexFields: string
[]
A type describing the ordered fields in an index.
These can either be field names (like "name") or references to fields on nested objects (like "properties.name").
Defined in
GenericTableIndexes
Ƭ GenericTableIndexes: Record
<string
, GenericIndexFields
>
A type describing the indexes in a table.
It's an object mapping each index name to the fields in the index.
Defined in
GenericSearchIndexConfig
Ƭ GenericSearchIndexConfig: Object
A type describing the configuration of a search index.
Type declaration
Name | Type |
---|---|
searchField | string |
filterFields | string |
Defined in
GenericTableSearchIndexes
Ƭ GenericTableSearchIndexes: Record
<string
, GenericSearchIndexConfig
>
A type describing all of the search indexes in a table.
This is an object mapping each index name to the config for the index.
Defined in
GenericVectorIndexConfig
Ƭ GenericVectorIndexConfig: Object
A type describing the configuration of a vector index.
Type declaration
Name | Type |
---|---|
vectorField | string |
dimensions | number |
filterFields | string |
Defined in
GenericTableVectorIndexes
Ƭ GenericTableVectorIndexes: Record
<string
, GenericVectorIndexConfig
>
A type describing all of the vector indexes in a table.
This is an object mapping each index name to the config for the index.
Defined in
FieldTypeFromFieldPath
Ƭ FieldTypeFromFieldPath<Document
, FieldPath
>: FieldTypeFromFieldPathInner
<Document
, FieldPath
> extends Value
| undefined
? FieldTypeFromFieldPathInner
<Document
, FieldPath
> : Value
| undefined
The type of a field in a document.
Note that this supports both simple fields like "name" and nested fields like "properties.name".
If the field is not present in the document it is considered to be undefined
.
Type parameters
Name | Type |
---|---|
Document | extends GenericDocument |
FieldPath | extends string |
Defined in
FieldTypeFromFieldPathInner
Ƭ FieldTypeFromFieldPathInner<Document
, FieldPath
>: FieldPath
extends `${infer First}.${infer Second}` ? ValueFromUnion
<Document
, First
, Record
<never
, never
>> extends infer FieldValue ? FieldValue
extends GenericDocument
? FieldTypeFromFieldPath
<FieldValue
, Second
> : undefined
: undefined
: ValueFromUnion
<Document
, FieldPath
, undefined
>
The inner type of FieldTypeFromFieldPath.
It's wrapped in a helper to coerce the type to Value | undefined
since some
versions of TypeScript fail to infer this type correctly.
Type parameters
Name | Type |
---|---|
Document | extends GenericDocument |
FieldPath | extends string |
Defined in
GenericTableInfo
Ƭ GenericTableInfo: Object
A type describing the document type and indexes in a table.
Type declaration
Name | Type |
---|---|
document | GenericDocument |
fieldPaths | GenericFieldPaths |
indexes | GenericTableIndexes |
searchIndexes | GenericTableSearchIndexes |
vectorIndexes | GenericTableVectorIndexes |
Defined in
DocumentByInfo
Ƭ DocumentByInfo<TableInfo
>: TableInfo
["document"
]
The type of a document in a table for a given GenericTableInfo.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
FieldPaths
Ƭ FieldPaths<TableInfo
>: TableInfo
["fieldPaths"
]
The field paths in a table for a given GenericTableInfo.
These can either be field names (like "name") or references to fields on nested objects (like "properties.name").
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
Indexes
Ƭ Indexes<TableInfo
>: TableInfo
["indexes"
]
The database indexes in a table for a given GenericTableInfo.
This will be an object mapping index names to the fields in the index.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
IndexNames
Ƭ IndexNames<TableInfo
>: keyof Indexes
<TableInfo
>
The names of indexes in a table for a given GenericTableInfo.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
NamedIndex
Ƭ NamedIndex<TableInfo
, IndexName
>: Indexes
<TableInfo
>[IndexName
]
Extract the fields of an index from a GenericTableInfo by name.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
IndexName | extends IndexNames <TableInfo > |
Defined in
SearchIndexes
Ƭ SearchIndexes<TableInfo
>: TableInfo
["searchIndexes"
]
The search indexes in a table for a given GenericTableInfo.
This will be an object mapping index names to the search index config.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
SearchIndexNames
Ƭ SearchIndexNames<TableInfo
>: keyof SearchIndexes
<TableInfo
>
The names of search indexes in a table for a given GenericTableInfo.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
NamedSearchIndex
Ƭ NamedSearchIndex<TableInfo
, IndexName
>: SearchIndexes
<TableInfo
>[IndexName
]
Extract the config of a search index from a GenericTableInfo by name.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
IndexName | extends SearchIndexNames <TableInfo > |
Defined in
VectorIndexes
Ƭ VectorIndexes<TableInfo
>: TableInfo
["vectorIndexes"
]
The vector indexes in a table for a given GenericTableInfo.
This will be an object mapping index names to the vector index config.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
VectorIndexNames
Ƭ VectorIndexNames<TableInfo
>: keyof VectorIndexes
<TableInfo
>
The names of vector indexes in a table for a given GenericTableInfo.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
Defined in
NamedVectorIndex
Ƭ NamedVectorIndex<TableInfo
, IndexName
>: VectorIndexes
<TableInfo
>[IndexName
]
Extract the config of a vector index from a GenericTableInfo by name.
Type parameters
Name | Type |
---|---|
TableInfo | extends GenericTableInfo |
IndexName | extends VectorIndexNames <TableInfo > |
Defined in
GenericDataModel
Ƭ GenericDataModel: Record
<string
, GenericTableInfo
>
A type describing the tables in a Convex project.
This is designed to be code generated with npx convex dev
.
Defined in
AnyDataModel
Ƭ AnyDataModel: Object
A GenericDataModel that considers documents to be any
and does not
support indexes.
This is the default before a schema is defined.
Index signature
▪ [tableName: string
]: { document
: any
; fieldPaths
: GenericFieldPaths
; indexes
: ; searchIndexes
: ; vectorIndexes
: }
Defined in
TableNamesInDataModel
Ƭ TableNamesInDataModel<DataModel
>: keyof DataModel
& string
A type of all of the table names defined in a GenericDataModel.
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Defined in
NamedTableInfo
Ƭ NamedTableInfo<DataModel
, TableName
>: DataModel
[TableName
]
Extract the TableInfo
for a table in a GenericDataModel by table
name.
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
TableName | extends keyof DataModel |
Defined in
DocumentByName
Ƭ DocumentByName<DataModel
, TableName
>: DataModel
[TableName
]["document"
]
The type of a document in a GenericDataModel by table name.
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
TableName | extends TableNamesInDataModel <DataModel > |
Defined in
ExpressionOrValue
Ƭ ExpressionOrValue<T
>: Expression
<T
> | T
An Expression or a constant Value
Type parameters
Name | Type |
---|---|
T | extends Value | undefined |
Defined in
Cursor
Ƭ Cursor: string
An opaque identifier used for paginating a database query.
Cursors are returned from paginate and represent the point of the query where the page of results ended.
To continue paginating, pass the cursor back into paginate in the PaginationOptions object to fetch another page of results.
Note: Cursors can only be passed to exactly the same database query that they were generated from. You may not reuse a cursor between different database queries.
Defined in
GenericMutationCtxWithTable
Ƭ GenericMutationCtxWithTable<DataModel
>: Omit
<GenericMutationCtx
<DataModel
>, "db"
> & { db
: GenericDatabaseWriterWithTable
<DataModel
> }
A set of services for use within Convex mutation functions.
The mutation context is passed as the first argument to any Convex mutation function run on the server.
If you're using code generation, use the MutationCtx
type in
convex/_generated/server.d.ts
which is typed for your data model.
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Defined in
GenericQueryCtxWithTable
Ƭ GenericQueryCtxWithTable<DataModel
>: Omit
<GenericQueryCtx
<DataModel
>, "db"
> & { db
: GenericDatabaseReaderWithTable
<DataModel
> }
A set of services for use within Convex query functions.
The query context is passed as the first argument to any Convex query function run on the server.
This differs from the MutationCtx because all of the services are read-only.
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Defined in
DefaultFunctionArgs
Ƭ DefaultFunctionArgs: Record
<string
, unknown
>
The default arguments type for a Convex query, mutation, or action function.
Convex functions always take an arguments object that maps the argument names to their values.
Defined in
ArgsArray
Ƭ ArgsArray: OneArgArray
| NoArgsArray
An array of arguments to a Convex function.
Convex functions can take either a single DefaultFunctionArgs object or no args at all.
Defined in
ArgsArrayToObject
Ƭ ArgsArrayToObject<Args
>: Args
extends OneArgArray
<infer ArgsObject> ? ArgsObject
: EmptyObject
Convert an ArgsArray into a single object type.
Empty arguments arrays are converted to EmptyObject.
Type parameters
Name | Type |
---|---|
Args | extends ArgsArray |
Defined in
FunctionVisibility
Ƭ FunctionVisibility: "public"
| "internal"
A type representing the visibility of a Convex function.
Defined in
RegisteredMutation
Ƭ RegisteredMutation<Visibility
, Args
, Returns
>: { isConvexFunction
: true
; isMutation
: true
} & VisibilityProperties
<Visibility
>
A mutation function that is part of this app.
You can create a mutation by wrapping your function in mutationGeneric or internalMutationGeneric and exporting it.
Type parameters
Name | Type |
---|---|
Visibility | extends FunctionVisibility |
Args | extends DefaultFunctionArgs |
Returns | Returns |
Defined in
RegisteredQuery
Ƭ RegisteredQuery<Visibility
, Args
, Returns
>: { isConvexFunction
: true
; isQuery
: true
} & VisibilityProperties
<Visibility
>
A query function that is part of this app.
You can create a query by wrapping your function in queryGeneric or internalQueryGeneric and exporting it.
Type parameters
Name | Type |
---|---|
Visibility | extends FunctionVisibility |
Args | extends DefaultFunctionArgs |
Returns | Returns |
Defined in
RegisteredAction
Ƭ RegisteredAction<Visibility
, Args
, Returns
>: { isConvexFunction
: true
; isAction
: true
} & VisibilityProperties
<Visibility
>
An action that is part of this app.
You can create an action by wrapping your function in actionGeneric or internalActionGeneric and exporting it.
Type parameters
Name | Type |
---|---|
Visibility | extends FunctionVisibility |
Args | extends DefaultFunctionArgs |
Returns | Returns |
Defined in
PublicHttpAction
Ƭ PublicHttpAction: Object
An HTTP action that is part of this app's public API.
You can create public HTTP actions by wrapping your function in httpActionGeneric and exporting it.
Type declaration
Name | Type |
---|---|
isHttp | true |
Defined in
UnvalidatedFunction
Ƭ UnvalidatedFunction<Ctx
, Args
, Returns
>: (ctx
: Ctx
, ...args
: Args
) => Returns
| { handler
: (ctx
: Ctx
, ...args
: Args
) => Returns
}
Deprecated
-- See the type definition for MutationBuilder
or similar for
the types used for defining Convex functions.
The definition of a Convex query, mutation, or action function without argument validation.
Convex functions always take a context object as their first argument and an (optional) args object as their second argument.
This can be written as a function like:
import { query } from "./_generated/server";
export const func = query(({ db }, { arg }) => {...});
or as an object like:
import { query } from "./_generated/server";
export const func = query({
handler: ({ db }, { arg }) => {...},
});
See ValidatedFunction to add argument validation.
Type parameters
Name | Type |
---|---|
Ctx | Ctx |
Args | extends ArgsArray |
Returns | Returns |
Defined in
ReturnValueForOptionalValidator
Ƭ ReturnValueForOptionalValidator<ReturnsValidator
>: [ReturnsValidator
] extends [Validator
<any
, any
, any
>] ? ValidatorTypeToReturnType
<Infer
<ReturnsValidator
>> : [ReturnsValidator
] extends [PropertyValidators
] ? ValidatorTypeToReturnType
<ObjectType
<ReturnsValidator
>> : any
There are multiple syntaxes for defining a Convex function:
- query(async (ctx, args) => {...})
- query({ handler: async (ctx, args) => {...} })
- query({ args: { a: v.string }, handler: async (ctx, args) => {...} } })
- query({ args: { a: v.string }, returns: v.string(), handler: async (ctx, args) => {...} } })
In each of these, we want to correctly infer the type for the arguments and return value, preferring the type derived from a validator if it's provided.
To avoid having a separate overload for each, which would show up in error messages, we use the type params -- ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs.
The type for ReturnValue and OneOrZeroArgs are constrained by the type or ArgsValidator and ReturnsValidator if they're present, and inferred from any explicit type annotations to the arguments or return value of the function.
Below are a few utility types to get the appropriate type constraints based on an optional validator.
Additional tricks:
- We use Validator | void instead of Validator | undefined because the latter does
not work with
strictNullChecks
since it's equivalent to justValidator
. - We use a tuple type of length 1 to avoid distribution over the union https://github.com/microsoft/TypeScript/issues/29368#issuecomment-453529532
Type parameters
Name | Type |
---|---|
ReturnsValidator | extends Validator <any , any , any > | PropertyValidators | void |
Defined in
ArgsArrayForOptionalValidator
Ƭ ArgsArrayForOptionalValidator<ArgsValidator
>: [ArgsValidator
] extends [Validator
<any
, any
, any
>] ? OneArgArray
<Infer
<ArgsValidator
>> : [ArgsValidator
] extends [PropertyValidators
] ? OneArgArray
<ObjectType
<ArgsValidator
>> : ArgsArray
Type parameters
Name | Type |
---|---|
ArgsValidator | extends GenericValidator | PropertyValidators | void |
Defined in
DefaultArgsForOptionalValidator
Ƭ DefaultArgsForOptionalValidator<ArgsValidator
>: [ArgsValidator
] extends [Validator
<any
, any
, any
>] ? [Infer
<ArgsValidator
>] : [ArgsValidator
] extends [PropertyValidators
] ? [ObjectType
<ArgsValidator
>] : OneArgArray
Type parameters
Name | Type |
---|---|
ArgsValidator | extends GenericValidator | PropertyValidators | void |
Defined in
MutationBuilder
Ƭ MutationBuilder<DataModel
, Visibility
>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation
: { args?
: ArgsValidator
; returns?
: ReturnsValidator
; handler
: (ctx
: GenericMutationCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
} | (ctx
: GenericMutationCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
) => RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Visibility | extends FunctionVisibility |
Type declaration
▸ <ArgsValidator
, ReturnsValidator
, ReturnValue
, OneOrZeroArgs
>(mutation
): RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Internal type helper used by Convex code generation.
Used to give mutationGeneric a type specific to your data model.
Type parameters
Name | Type |
---|---|
ArgsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnValue | extends any = any |
OneOrZeroArgs | extends ArgsArray | OneArgArray <Infer <ArgsValidator >> | OneArgArray <Expand <{ [Property in string | number | symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<ArgsValidator[Property]> }>> = DefaultArgsForOptionalValidator <ArgsValidator > |
Parameters
Name | Type |
---|---|
mutation | { args? : ArgsValidator ; returns? : ReturnsValidator ; handler : (ctx : GenericMutationCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue } | (ctx : GenericMutationCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue |
Returns
RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Defined in
MutationBuilderWithTable
Ƭ MutationBuilderWithTable<DataModel
, Visibility
>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(mutation
: { args?
: ArgsValidator
; returns?
: ReturnsValidator
; handler
: (ctx
: GenericMutationCtxWithTable
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
} | (ctx
: GenericMutationCtxWithTable
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
) => RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Visibility | extends FunctionVisibility |
Type declaration
▸ <ArgsValidator
, ReturnsValidator
, ReturnValue
, OneOrZeroArgs
>(mutation
): RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Internal type helper used by Convex code generation.
Used to give mutationGeneric a type specific to your data model.
Type parameters
Name | Type |
---|---|
ArgsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnValue | extends any = any |
OneOrZeroArgs | extends ArgsArray | OneArgArray <Infer <ArgsValidator >> | OneArgArray <Expand <{ [Property in string | number | symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<ArgsValidator[Property]> }>> = DefaultArgsForOptionalValidator <ArgsValidator > |
Parameters
Name | Type |
---|---|
mutation | { args? : ArgsValidator ; returns? : ReturnsValidator ; handler : (ctx : GenericMutationCtxWithTable <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue } | (ctx : GenericMutationCtxWithTable <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue |
Returns
RegisteredMutation
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Defined in
QueryBuilder
Ƭ QueryBuilder<DataModel
, Visibility
>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query
: { args?
: ArgsValidator
; returns?
: ReturnsValidator
; handler
: (ctx
: GenericQueryCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
} | (ctx
: GenericQueryCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
) => RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Visibility | extends FunctionVisibility |
Type declaration
▸ <ArgsValidator
, ReturnsValidator
, ReturnValue
, OneOrZeroArgs
>(query
): RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Internal type helper used by Convex code generation.
Used to give queryGeneric a type specific to your data model.
Type parameters
Name | Type |
---|---|
ArgsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnValue | extends any = any |
OneOrZeroArgs | extends ArgsArray | OneArgArray <Infer <ArgsValidator >> | OneArgArray <Expand <{ [Property in string | number | symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<ArgsValidator[Property]> }>> = DefaultArgsForOptionalValidator <ArgsValidator > |
Parameters
Name | Type |
---|---|
query | { args? : ArgsValidator ; returns? : ReturnsValidator ; handler : (ctx : GenericQueryCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue } | (ctx : GenericQueryCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue |
Returns
RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Defined in
QueryBuilderWithTable
Ƭ QueryBuilderWithTable<DataModel
, Visibility
>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(query
: { args?
: ArgsValidator
; returns?
: ReturnsValidator
; handler
: (ctx
: GenericQueryCtxWithTable
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
} | (ctx
: GenericQueryCtxWithTable
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
) => RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Visibility | extends FunctionVisibility |
Type declaration
▸ <ArgsValidator
, ReturnsValidator
, ReturnValue
, OneOrZeroArgs
>(query
): RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Internal type helper used by Convex code generation.
Used to give queryGeneric a type specific to your data model.
Type parameters
Name | Type |
---|---|
ArgsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnValue | extends any = any |
OneOrZeroArgs | extends ArgsArray | OneArgArray <Infer <ArgsValidator >> | OneArgArray <Expand <{ [Property in string | number | symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<ArgsValidator[Property]> }>> = DefaultArgsForOptionalValidator <ArgsValidator > |
Parameters
Name | Type |
---|---|
query | { args? : ArgsValidator ; returns? : ReturnsValidator ; handler : (ctx : GenericQueryCtxWithTable <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue } | (ctx : GenericQueryCtxWithTable <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue |
Returns
RegisteredQuery
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Defined in
ActionBuilder
Ƭ ActionBuilder<DataModel
, Visibility
>: <ArgsValidator, ReturnsValidator, ReturnValue, OneOrZeroArgs>(func
: { args?
: ArgsValidator
; returns?
: ReturnsValidator
; handler
: (ctx
: GenericActionCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
} | (ctx
: GenericActionCtx
<DataModel
>, ...args
: OneOrZeroArgs
) => ReturnValue
) => RegisteredAction
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Type parameters
Name | Type |
---|---|
DataModel | extends GenericDataModel |
Visibility | extends FunctionVisibility |
Type declaration
▸ <ArgsValidator
, ReturnsValidator
, ReturnValue
, OneOrZeroArgs
>(func
): RegisteredAction
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Internal type helper used by Convex code generation.
Used to give actionGeneric a type specific to your data model.
Type parameters
Name | Type |
---|---|
ArgsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnsValidator | extends void | Validator <any , "required" , any > | PropertyValidators |
ReturnValue | extends any = any |
OneOrZeroArgs | extends ArgsArray | OneArgArray <Infer <ArgsValidator >> | OneArgArray <Expand <{ [Property in string | number | symbol]?: Exclude<Infer<ArgsValidator[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<ArgsValidator[Property]> }>> = DefaultArgsForOptionalValidator <ArgsValidator > |
Parameters
Name | Type |
---|---|
func | { args? : ArgsValidator ; returns? : ReturnsValidator ; handler : (ctx : GenericActionCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue } | (ctx : GenericActionCtx <DataModel >, ...args : OneOrZeroArgs ) => ReturnValue |
Returns
RegisteredAction
<Visibility
, ArgsArrayToObject
<OneOrZeroArgs
>, ReturnValue
>
Defined in
HttpActionBuilder
Ƭ HttpActionBuilder: (func
: (ctx
: GenericActionCtx
<any
>, request
: Request
) => Promise
<Response
>) => PublicHttpAction
Type declaration
▸ (func
): PublicHttpAction
Internal type helper used by Convex code generation.
Used to give httpActionGeneric a type specific to your data model and functions.
Parameters
Name | Type |
---|---|
func | (ctx : GenericActionCtx <any >, request : Request ) => Promise <Response > |
Returns
Defined in
RoutableMethod
Ƭ RoutableMethod: typeof ROUTABLE_HTTP_METHODS
[number
]
A type representing the methods supported by Convex HTTP actions.
HEAD is handled by Convex by running GET and stripping the body. CONNECT is not supported and will not be supported. TRACE is not supported and will not be supported.
Defined in
RouteSpecWithPath
Ƭ RouteSpecWithPath: Object
A type representing a route to an HTTP action using an exact request URL path match.
Used by HttpRouter to route requests to HTTP actions.
Type declaration
Name | Type | Description |
---|---|---|
path | string | Exact HTTP request path to route. |
method | RoutableMethod | HTTP method ("GET", "POST", ...) to route. |
handler | PublicHttpAction | The HTTP action to execute. |
Defined in
RouteSpecWithPathPrefix
Ƭ RouteSpecWithPathPrefix: Object
A type representing a route to an HTTP action using a request URL path prefix match.
Used by HttpRouter to route requests to HTTP actions.
Type declaration
Name | Type | Description |
---|---|---|
pathPrefix | string | An HTTP request path prefix to route. Requests with a path starting with this value will be routed to the HTTP action. |
method | RoutableMethod | HTTP method ("GET", "POST", ...) to route. |
handler | PublicHttpAction | The HTTP action to execute. |
Defined in
RouteSpec
Ƭ RouteSpec: RouteSpecWithPath
| RouteSpecWithPathPrefix
A type representing a route to an HTTP action.
Used by HttpRouter to route requests to HTTP actions.
Defined in
SchedulableFunctionReference
Ƭ SchedulableFunctionReference: FunctionReference
<"mutation"
| "action"
, "public"
| "internal"
>
A FunctionReference that can be scheduled to run in the future.
Schedulable functions are mutations and actions that are public or internal.
Defined in
GenericSchema
Ƭ GenericSchema: Record
<string
, TableDefinition
>
A type describing the schema of a Convex project.
This should be constructed using defineSchema, defineTable, and v.
Defined in
DataModelFromSchemaDefinition
Ƭ DataModelFromSchemaDefinition<SchemaDef
>: MaybeMakeLooseDataModel
<{ [TableName in keyof SchemaDef["tables"] & string]: SchemaDef["tables"][TableName] extends TableDefinition<infer DocumentType, infer Indexes, infer SearchIndexes, infer VectorIndexes> ? Object : never }, SchemaDef
["strictTableNameTypes"
]>
Internal type used in Convex code generation!
Convert a SchemaDefinition into a GenericDataModel.
Type parameters
Name | Type |
---|---|
SchemaDef | extends SchemaDefinition <any , boolean > |
Defined in
SystemTableNames
Ƭ SystemTableNames: TableNamesInDataModel
<SystemDataModel
>
Defined in
StorageId
Ƭ StorageId: string
A reference to a file in storage.
This is used in the StorageReader and StorageWriter which are accessible in Convex queries and mutations via QueryCtx and MutationCtx respectively.
Defined in
FileStorageId
Ƭ FileStorageId: GenericId
<"_storage"
> | StorageId
Defined in
FileMetadata
Ƭ FileMetadata: Object
Metadata for a single file as returned by storage.getMetadata.
Type declaration
Name | Type | Description |
---|---|---|
storageId | StorageId | ID for referencing the file (eg. via storage.getUrl) |
sha256 | string | Hex encoded sha256 checksum of file contents |
size | number | Size of the file in bytes |
contentType | string | null | ContentType of the file if it was provided on upload |