Email field

f.email() stores an email address. It produces a varchar(255) column, derives a Zod schema that enforces a valid email format and the column length, and exposes the full string operator set plus email-specific domain / domainIn filters on the typed where clause. Reach for it instead of f.text() whenever a field must hold a valid email, you get the format check and the domain filters for free.

Prerequisites: read Fields first, this page covers only the email type. The f proxy, the chain-modifier model, and shared modifiers like .required() / .localized() / .default() are taught there.

What it does

• Stores an email string, a varchar(255) column by default; pass a number to resize the column.
• Validates the format, the derived Zod schema is z.string().email().max(maxLength), so invalid addresses are rejected on create and update without writing a validator.
• Filters by domain, on top of the string operators, email adds domain and domainIn to match the part after @ (case-insensitive).
• Filters with string operators, eq, ne, in, contains, ilike, startsWith, isNull, and the rest, all typed against string.
• Renders a text input in the admin form, typed as an email field.

Quick start

Use f.email() inside a .fields() callback. The positional argument is the max character length; chain modifiers to refine it.

import { collection } from "#questpie/factories";

export const users = collection("users").fields(({ f }) => ({
  email: f.email().required(),          // varchar(255), NOT NULL, validated
  backupEmail: f.email(320),            // sized varchar(320), optional
}));

That gives users an email column typed string on read, required on insert, validated as a well-formed address at ≤ 255 chars, and filterable by domain, no schema or migration written by hand.

Constructor argument

f.email() takes a single optional maxLength.

The field data is always string. The derived Zod schema is z.string().email().max(maxLength), the .email() refinement is always present, and the .max() uses the 255 default or your n.

Chained methods

These methods are specific to email (on top of the shared modifiers every field has). Each returns a new immutable field, so they chain in any order.

collection("contacts").fields(({ f }) => ({
  email: f.email().required().max(254), // valid email, capped at 254 chars
}));

Filtering, operators

email uses the email operator set (emailOps), which extends the string set with two domain matchers. So every email field is filterable with all the string operators and domain / domainIn. The operand is typed string (or string[] for the list operators).

// Everyone on the acme.com domain
const { docs } = await app.collections.users.find({
  where: { email: { domain: "acme.com" } },
});

// Internal staff: any of two domains
const staff = await app.collections.users.find({
  where: { email: { domainIn: ["acme.com", "acme.io"] } },
});

For the full query language, combining field filters with AND / OR / NOT, pagination, and orderBy, see Fields → filtering. Relation filters and hydration are covered in Relations.

When to use it

• f.email(), any field that must hold a valid email address: a user's login email, a contact address, a notification recipient. You get format validation and domain filters that a plain string field lacks.
• For a free-form short string with no format constraint, use f.text() instead.
• For a website or link, use f.url(), the same idea (a validated string), but with z.string().url() and host/protocol filter operators.

Multiple values

Chain .array() to store a list of email strings in a single jsonb column, and bound it with .minItems(n) / .maxItems(n). This is a shared modifier, not email-specific:

ccList: f.email().array().maxItems(20), // string[] of validated emails, stored as jsonb

TypeScript

An email field contributes a string to the generated row, insert, and where types, no annotation needed. After questpie generate, pull the shapes off the collection or the app types:

type User = typeof users.$infer.select;
//   ^? { id: string; email: string; backupEmail: string | null; ... }

.required() makes the field non-null and required on insert; without it the column is nullable and the insert field optional. See Fields → inferred types for how modifiers flow into the generated types.

Related

• Fields, the f proxy, the chain-modifier model, and the shared modifiers (.required(), .localized(), .default(), .array(), …).
• Text field, the unvalidated single-line string sibling.
• Validation, the auto-derived Zod schema and the .zod() escape hatch for custom rules.