@opensaas/stack-core 0.37.0 → 0.39.0

package/src/query/index.ts

@@ -4,15 +4,6 @@ import { getDbKey } from '../lib/case-utils.js'
 // Internal helpers
 // ─────────────────────────────────────────────────────────────
 
-/**
- * Unwrap the item type from a field type, stripping null, undefined, and
- * Array wrappers so we can constrain nested fragment shapes.
- *
- * Examples:
- *   User | null     → User
- *   User[]          → User
- *   (User | null)[] → User
- */
 type UnwrapItem<T> = NonNullable<T> extends Array<infer U> ? NonNullable<U> : NonNullable<T>
 
 // ─────────────────────────────────────────────────────────────
@@ -20,44 +11,9 @@ type UnwrapItem<T> = NonNullable<T> extends Array<infer U> ? NonNullable<U> : No
 // ─────────────────────────────────────────────────────────────
 
 /**
- * A selector for a relationship field.
- *
- * Two forms are accepted:
- * 1. A `Fragment` directly (shorthand — no extra Prisma args on the nested query).
- * 2. An object `{ query, where?, orderBy?, take?, skip? }` to combine a fragment
- *    with Prisma filter/ordering/pagination applied to the nested relationship.
- *
- * @example Shorthand (most common)
- * ```ts
- * const postFrag = defineFragment<Post>()({
- *   id: true,
- *   author: authorFragment,   // shorthand
- * } as const)
- * ```
- *
- * @example With nested filtering
- * ```ts
- * const postFrag = defineFragment<Post>()({
- *   id: true,
- *   comments: {
- *     query:   commentFragment,
- *     where:   { approved: true },
- *     orderBy: { createdAt: 'desc' },
- *     take:    5,
- *   },
- * } as const)
- * ```
- *
- * @example Variables via factory function
- * ```ts
- * function makePostFragment(status: string) {
- *   return defineFragment<Post>()({
- *     id:      true,
- *     comments: { query: commentFragment, where: { status } },
- *   } as const)
- * }
- * type PostData = ResultOf<ReturnType<typeof makePostFragment>>
- * ```
+ * A selector for a relationship field: either a {@link Fragment} directly
+ * (shorthand), or `{ query, where?, orderBy?, take?, skip? }` to combine a
+ * fragment with Prisma filter/ordering/pagination on the nested relationship.
  */
 export type RelationSelector<TRelated extends Record<string, unknown>> =
   | Fragment<TRelated, FieldSelection<TRelated>>
@@ -70,26 +26,9 @@ export type RelationSelector<TRelated extends Record<string, unknown>> =
     }
 
 /**
- * A field selection for model type `TItem`.
- *
- * Each key maps to:
- * - `true`                — include the scalar/primitive field as-is
- * - A `Fragment`          — include a relationship and recurse (shorthand)
- * - A `RelationSelector`  — include a relationship with optional Prisma filter/ordering
- *
- * Only keys present in `TItem` are accepted. For relationship (object) fields
- * you may pass a Fragment, a RelationSelector, or `true` (returns the raw Prisma
- * value and loses type narrowing).
- *
- * @example
- * ```ts
- * const sel: FieldSelection<Post> = {
- *   id: true,
- *   title: true,
- *   author: authorFragment,
- *   comments: { query: commentFragment, where: { approved: true } },
- * }
- * ```
+ * A field selection for model type `TItem`. Passing `true` for a
+ * relationship field returns the raw Prisma value and loses type narrowing —
+ * use a {@link Fragment} or {@link RelationSelector} to keep it typed.
  */
 export type FieldSelection<T> = {
   readonly [K in keyof T]?: UnwrapItem<T[K]> extends Record<string, unknown>
@@ -99,19 +38,7 @@ export type FieldSelection<T> = {
 
 /**
  * A reusable, composable field-selection descriptor for model type `TItem`.
- *
- * Create with {@link defineFragment}. Compose by referencing another Fragment
- * (or a {@link RelationSelector}) as the value for a relationship key.
- *
- * @example
- * ```ts
- * const userFragment = defineFragment<User>()({ id: true, name: true } as const)
- * const postFragment = defineFragment<Post>()({
- *   id: true,
- *   title: true,
- *   author: userFragment,
- * } as const)
- * ```
+ * Create with {@link defineFragment}.
  */
 export type Fragment<TItem, TFields extends FieldSelection<TItem> = FieldSelection<TItem>> = {
   readonly _type: 'fragment'
@@ -122,11 +49,7 @@ export type Fragment<TItem, TFields extends FieldSelection<TItem> = FieldSelecti
 // Internal type helpers
 // ─────────────────────────────────────────────────────────────
 
-/**
- * @internal
- * Extract the Fragment from either a Fragment directly or a RelationSelector object.
- * Returns `never` for scalar `true` selections (so they fall to the scalar branch).
- */
+/** @internal Returns `never` for scalar `true` selections, so they fall to the scalar branch in {@link SelectedFields}. */
 type ExtractFragment<TSelector> =
   TSelector extends Fragment<infer TItem, infer TFields>
     ? Fragment<TItem, TFields>
@@ -134,16 +57,12 @@ type ExtractFragment<TSelector> =
       ? Fragment<TItem, TFields>
       : never
 
-/**
- * @internal
- * Map a FieldSelection over a model type, computing the picked output type.
- */
+/** @internal */
 type SelectedFields<TItem, TFields extends FieldSelection<TItem>> = {
   [K in keyof TFields & keyof TItem]: [ExtractFragment<TFields[K]>] extends [never]
-    ? // Scalar field (value is `true`) — tuple wrapping avoids the vacuous `never extends T` pitfall
+    ? // tuple wrapping avoids the vacuous `never extends T` pitfall
       TItem[K]
-    : // Relationship field — preserve array/null/undefined wrappers from the model
-      TItem[K] extends Array<unknown>
+    : TItem[K] extends Array<unknown>
       ? ResultOf<ExtractFragment<TFields[K]>>[]
       : null extends TItem[K]
         ? ResultOf<ExtractFragment<TFields[K]>> | null
@@ -157,24 +76,8 @@ type SelectedFields<TItem, TFields extends FieldSelection<TItem>> = {
 // ─────────────────────────────────────────────────────────────
 
 /**
- * Infer the TypeScript result type from a Fragment.
- *
- * Analogous to `gql.tada`'s `ResultOf` helper — given a fragment definition,
- * `ResultOf` tells you exactly what shape you will receive at runtime.
- *
- * - Scalar fields selected with `true` retain their original Prisma type.
- * - Relationship fields selected with a nested Fragment/RelationSelector are
- *   recursively narrowed.
- * - Nullability and array wrappers from the original model type are preserved.
- *
- * @example
- * ```ts
- * type UserData  = ResultOf<typeof userFragment>
- * // → { id: string; name: string }
- *
- * type PostData  = ResultOf<typeof postFragment>
- * // → { id: string; title: string; author: { id: string; name: string } | null }
- * ```
+ * Infer the TypeScript result type from a {@link Fragment} — the shape
+ * `runQuery`/`runQueryOne` return at runtime for that fragment.
  */
 export type ResultOf<F> =
   F extends Fragment<infer TItem, infer TFields> ? SelectedFields<TItem, TFields> : never
@@ -183,20 +86,14 @@ export type ResultOf<F> =
  * Arguments accepted by {@link runQuery}.
  */
 export type QueryArgs = {
-  /** Prisma where filter. The access control layer will additionally scope results. */
+  /** Prisma where filter — the access control layer additionally scopes results. */
   where?: Record<string, unknown>
-  /** Prisma orderBy clause. Pass a single object or an array for multi-column ordering. */
   orderBy?: Record<string, 'asc' | 'desc'> | Array<Record<string, 'asc' | 'desc'>>
-  /** Maximum number of records to return. */
   take?: number
-  /** Number of records to skip (for pagination). */
   skip?: number
 }
 
-/**
- * Minimal context shape required by the query runners.
- * Compatible with the full `AccessContext` produced by `getContext()`.
- */
+/** Compatible with the full `AccessContext` produced by `getContext()`. */
 export interface QueryRunnerContext {
   db: {
     [key: string]: {
@@ -211,64 +108,9 @@ export interface QueryRunnerContext {
 // ─────────────────────────────────────────────────────────────
 
 /**
- * Create a type-safe, reusable fragment for a given model type.
- *
- * The function is curried so that TypeScript can infer both the model type
- * (from the explicit type parameter) and the field selection (from the
- * argument), without requiring you to repeat yourself.
- *
- * @example Basic usage
- * ```ts
- * import type { User } from '.prisma/client'
- * import { defineFragment } from '@opensaas/stack-core'
- *
- * export const userFragment = defineFragment<User>()({
- *   id:    true,
- *   name:  true,
- *   email: true,
- * } as const)
- * ```
- *
- * @example Compose fragments
- * ```ts
- * import type { Post } from '.prisma/client'
- *
- * export const postFragment = defineFragment<Post>()({
- *   id:      true,
- *   title:   true,
- *   author:  userFragment,
- * } as const)
- * ```
- *
- * @example Nested filtering with RelationSelector
- * ```ts
- * export const postWithApprovedComments = defineFragment<Post>()({
- *   id:    true,
- *   title: true,
- *   comments: {
- *     query:   commentFragment,
- *     where:   { approved: true },
- *     orderBy: { createdAt: 'desc' },
- *     take:    5,
- *   },
- * } as const)
- * ```
- *
- * @example Variables via factory function
- * ```ts
- * function makePostFragment(status: string) {
- *   return defineFragment<Post>()({
- *     id:      true,
- *     comments: { query: commentFragment, where: { status } },
- *   } as const)
- * }
- * type PostData = ResultOf<ReturnType<typeof makePostFragment>>
- *
- * const posts = await context.db.post.findMany({
- *   query: makePostFragment('approved'),
- *   where: { published: true },
- * })
- * ```
+ * Create a type-safe, reusable fragment for a given model type. Curried so
+ * TypeScript can infer the model type from the explicit type parameter and
+ * the field selection from the argument.
  */
 export function defineFragment<TItem>() {
   return function <TFields extends FieldSelection<TItem>>(
@@ -279,7 +121,7 @@ export function defineFragment<TItem>() {
 }
 
 // ─────────────────────────────────────────────────────────────
-// Runtime helpers — exported for use in context/index.ts
+// Runtime helpers
 // ─────────────────────────────────────────────────────────────
 
 /** @internal */
@@ -293,14 +135,10 @@ export function isFragment(value: unknown): value is Fragment<unknown, FieldSele
 }
 
 /**
- * Walk a field selection and build the Prisma `include` map needed to eagerly
- * load all nested relationship fragments/selectors.
- *
- * Scalar fields (`true`) do not require an include entry — Prisma returns all
- * scalar columns by default. Only relationship fields backed by a Fragment or
- * RelationSelector generate include entries (recursively).
- *
- * Exported for use in `context/index.ts` when the `query` parameter is present.
+ * Build the Prisma `include` map for a field selection's nested fragments.
+ * Scalar fields (`true`) need no include entry — Prisma returns all scalar
+ * columns by default; only relationship fields backed by a Fragment or
+ * RelationSelector generate one (recursively).
  * @internal
  */
 export function buildInclude(fields: FieldSelection<unknown>): Record<string, unknown> | undefined {
@@ -312,7 +150,6 @@ export function buildInclude(fields: FieldSelection<unknown>): Record<string, un
 
     const val = value as Record<string, unknown>
 
-    // ── Shorthand: Fragment directly ──────────────────────────
     if (isFragment(val)) {
       hasIncludes = true
       const nestedInclude = buildInclude(val._fields as FieldSelection<unknown>)
@@ -320,7 +157,6 @@ export function buildInclude(fields: FieldSelection<unknown>): Record<string, un
       continue
     }
 
-    // ── RelationSelector: { query, where?, orderBy?, take?, skip? } ──
     if ('query' in val && isFragment(val.query)) {
       hasIncludes = true
       const selector = val as {
@@ -345,12 +181,62 @@ export function buildInclude(fields: FieldSelection<unknown>): Record<string, un
   return hasIncludes ? include : undefined
 }
 
+/**
+ * A snapshot of which field names a fragment selects at one nesting level,
+ * plus the same tree one level down for every relation selected via a nested
+ * Fragment/RelationSelector. `fields: undefined` means "unrestricted" — every
+ * field at this level is going to be returned, which is what a bare or
+ * `include`-based read means for the whole tree (only a `query` fragment ever
+ * produces a restricted scope, and only as deep as it names).
+ *
+ * Used to make computed-field evaluation (`filterReadableFields`) and
+ * declared-dependency folding (`foldDeclaredDependencies`) projection-aware
+ * (ADR-0027): a field not named by the scope at its level is never computed
+ * and its `needs` are never folded, because the read is never going to
+ * return it.
+ * @internal
+ */
+export type FieldSelectionScope = {
+  readonly fields: ReadonlySet<string> | undefined
+  readonly nested: Readonly<Record<string, FieldSelectionScope>>
+}
+
+/**
+ * Build the `FieldSelectionScope` for one fragment's field selection,
+ * recursing into nested Fragment/RelationSelector entries the same way
+ * `buildInclude` does. A relation named with the bare `true` shorthand (no
+ * narrower nested Fragment) gets no entry in `nested`, so a level reached
+ * through it is treated as unrestricted — the caller asked for "everything"
+ * there and gave no narrower shape to restrict it with.
+ * @internal
+ */
+export function buildFieldSelectionScope(fields: FieldSelection<unknown>): FieldSelectionScope {
+  const fieldNames = new Set(Object.keys(fields as Record<string, unknown>))
+  const nested: Record<string, FieldSelectionScope> = {}
+
+  for (const [key, value] of Object.entries(fields as Record<string, unknown>)) {
+    if (value === null || value === true || typeof value !== 'object') continue
+    const val = value as Record<string, unknown>
+
+    if (isFragment(val)) {
+      nested[key] = buildFieldSelectionScope(val._fields as FieldSelection<unknown>)
+      continue
+    }
+
+    if ('query' in val && isFragment(val.query)) {
+      nested[key] = buildFieldSelectionScope(
+        (val.query as Fragment<unknown, FieldSelection<unknown>>)
+          ._fields as FieldSelection<unknown>,
+      )
+    }
+  }
+
+  return { fields: fieldNames, nested }
+}
+
 /**
  * Recursively pick only the fields requested by a fragment from a raw Prisma
- * result object. This ensures the runtime shape exactly matches the type
- * produced by `ResultOf<F>`.
- *
- * Exported for use in `context/index.ts`.
+ * result object, so the runtime shape matches `ResultOf<F>`.
  * @internal
  */
 export function pickFields<TItem, TFields extends FieldSelection<TItem>>(
@@ -371,7 +257,6 @@ export function pickFields<TItem, TFields extends FieldSelection<TItem>>(
 
     const val = value as Record<string, unknown>
 
-    // ── Shorthand: Fragment directly ──────────────────────────
     if (isFragment(val)) {
       if (Array.isArray(fieldValue)) {
         result[key] = fieldValue.map((elem) =>
@@ -385,7 +270,6 @@ export function pickFields<TItem, TFields extends FieldSelection<TItem>>(
       continue
     }
 
-    // ── RelationSelector: { query, where?, ... } ──────────────
     if ('query' in val && isFragment(val.query)) {
       const nestedFrag = val.query as Fragment<unknown, FieldSelection<unknown>>
       if (Array.isArray(fieldValue)) {
@@ -413,29 +297,9 @@ export function pickFields<TItem, TFields extends FieldSelection<TItem>>(
 
 /**
  * Execute a fragment-based query against a list, returning all matching
- * records shaped to the fragment's field selection.
- *
- * Under the hood this calls `context.db[listKey].findMany()`, so all access
- * control rules defined in your config are still enforced.
- *
- * **Tip:** You can also call `context.db.post.findMany({ query: fragment, ... })`
- * directly — both forms produce the same result.
- *
- * @param context - An `AccessContext` (or any object with a compatible `db`).
- * @param listKey - The PascalCase list name (e.g. `'Post'`, `'BlogPost'`).
- * @param fragment - A fragment created with {@link defineFragment}.
- * @param args     - Optional query arguments (where, orderBy, take, skip).
- * @returns        An array typed to exactly the fragment's field selection.
- *
- * @example
- * ```ts
- * const posts = await runQuery(context, 'Post', postFragment, {
- *   where:   { published: true },
- *   orderBy: { createdAt: 'desc' },
- *   take:    10,
- * })
- * // posts: Array<ResultOf<typeof postFragment>>
- * ```
+ * records shaped to the fragment's field selection. Calls
+ * `context.db[listKey].findMany()` under the hood, so access control still
+ * applies.
  */
 export async function runQuery<TItem, TFields extends FieldSelection<TItem>>(
   context: QueryRunnerContext,
@@ -465,25 +329,8 @@ export async function runQuery<TItem, TFields extends FieldSelection<TItem>>(
 
 /**
  * Execute a fragment-based query that returns a single record (or `null`).
- *
- * Under the hood this calls `context.db[listKey].findFirst()`, so all access
- * control rules are still enforced.
- *
- * **Tip:** You can also call `context.db.post.findUnique({ where: { id }, query: fragment })`
- * directly.
- *
- * @param context - An `AccessContext` (or any object with a compatible `db`).
- * @param listKey - The PascalCase list name (e.g. `'Post'`).
- * @param fragment - A fragment created with {@link defineFragment}.
- * @param where    - A Prisma where clause to identify the record.
- * @returns        The matched record shaped to the fragment, or `null`.
- *
- * @example
- * ```ts
- * const post = await runQueryOne(context, 'Post', postFragment, { id: postId })
- * if (!post) return notFound()
- * // post: ResultOf<typeof postFragment>
- * ```
+ * Calls `context.db[listKey].findFirst()` under the hood, so access control
+ * still applies.
  */
 export async function runQueryOne<TItem, TFields extends FieldSelection<TItem>>(
   context: QueryRunnerContext,

package/src/query/relationship-options.ts

@@ -23,7 +23,7 @@ export interface RelationshipOptionsArgs {
  * editor — the read primitive behind the `relationshipOptions` serverAction
  * op. Selects only `id` and the resolved label field (via
  * {@link getLabelFieldName}), so the fragment carries no relation keys and
- * `buildIncludeWithAccessControl`'s depth-5 auto-include never runs.
+ * `buildAccessScopedInclude` never has anything to scope.
  *
  * Operation-level `query` access on `relatedListKey` still applies — a denied
  * list resolves to `[]` (via the underlying access-controlled `findMany`).

package/src/utils/password.ts

@@ -1,25 +1,8 @@
 import bcrypt from 'bcryptjs'
 
-/**
- * Default bcrypt cost factor (rounds)
- * Higher values = more secure but slower
- * 10 is a good balance for production use
- */
+// Bcrypt cost factor: higher is slower but more resistant to brute force.
 const DEFAULT_COST_FACTOR = 10
 
-/**
- * Hash a plain text password using bcrypt
- *
- * @param plainPassword - The plain text password to hash
- * @param costFactor - The bcrypt cost factor (default: 10)
- * @returns Promise resolving to the hashed password
- *
- * @example
- * ```typescript
- * const hashed = await hashPassword('mypassword')
- * // Returns: $2a$10$...
- * ```
- */
 export async function hashPassword(
   plainPassword: string,
   costFactor: number = DEFAULT_COST_FACTOR,
@@ -31,21 +14,6 @@ export async function hashPassword(
   return bcrypt.hash(plainPassword, costFactor)
 }
 
-/**
- * Compare a plain text password with a hashed password
- *
- * @param plainPassword - The plain text password to compare
- * @param hashedPassword - The hashed password to compare against
- * @returns Promise resolving to true if passwords match, false otherwise
- *
- * @example
- * ```typescript
- * const isValid = await comparePassword('mypassword', hashedPassword)
- * if (isValid) {
- *   // Password is correct
- * }
- * ```
- */
 export async function comparePassword(
   plainPassword: string,
   hashedPassword: string,
@@ -61,38 +29,21 @@ export async function comparePassword(
   try {
     return await bcrypt.compare(plainPassword, hashedPassword)
   } catch (error) {
-    // Invalid hash format or other bcrypt error
+    // Fail closed on a malformed hash or other bcrypt error, rather than
+    // letting it propagate as an authentication-bypassing exception.
     console.error('Password comparison failed:', error)
     return false
   }
 }
 
-/**
- * Check if a string appears to be a bcrypt hash
- * Bcrypt hashes follow the format: $2a$10$...
- *
- * @param value - The string to check
- * @returns True if the string looks like a bcrypt hash
- */
 export function isHashedPassword(value: string): boolean {
   if (typeof value !== 'string') return false
 
-  // Bcrypt hashes start with $2a$, $2b$, or $2y$ followed by cost factor
-  // and are typically 60 characters long
   return /^\$2[aby]\$\d{2}\$.{53}$/.test(value)
 }
 
-/**
- * HashedPassword class wraps a bcrypt hash and provides a compare method
- * This allows password field values to be used as strings while also
- * providing a convenient compare() method for authentication
- *
- * @example
- * ```typescript
- * const user = await context.db.user.findUnique({ where: { id: '1' } })
- * const isValid = await user.password.compare('plaintextPassword')
- * ```
- */
+// Wraps a bcrypt hash so a password field's value can still be used as a
+// plain string while also exposing compare() for authentication.
 export class HashedPassword {
   constructor(private readonly hash: string) {
     if (!hash || typeof hash !== 'string') {
@@ -100,28 +51,15 @@ export class HashedPassword {
     }
   }
 
-  /**
-   * Compare a plain text password with this hashed password
-   *
-   * @param plainPassword - The plain text password to compare
-   * @returns Promise resolving to true if passwords match
-   */
   async compare(plainPassword: string): Promise<boolean> {
     return comparePassword(plainPassword, this.hash)
   }
 
-  /**
-   * Get the underlying hash string
-   * This allows the HashedPassword to be used anywhere a string is expected
-   */
   toString(): string {
     return this.hash
   }
 
-  /**
-   * Get the underlying hash when used in string contexts
-   * This allows the HashedPassword to be coerced to a string automatically
-   */
+  // Implicit coercion (template literals, string concatenation) resolves here.
   [Symbol.toPrimitive](hint: string): string {
     if (hint === 'string' || hint === 'default') {
       return this.hash
@@ -129,18 +67,11 @@ export class HashedPassword {
     return this.hash
   }
 
-  /**
-   * Return the hash for JSON serialization
-   * This ensures the hash is properly serialized when converting to JSON
-   */
+  // JSON.stringify calls this when present, so the hash serializes as a plain string.
   toJSON(): string {
     return this.hash
   }
 
-  /**
-   * Get the underlying hash value
-   * This allows accessing the raw hash string
-   */
   valueOf(): string {
     return this.hash
   }

package/src/validation/field-config.ts

@@ -44,9 +44,6 @@ function hasFieldMethod(field: FieldConfig, method: string): boolean {
   return typeof value === 'function'
 }
 
-/**
- * Build the canonical error message for a missing contract method.
- */
 function buildMessage(
   fieldType: string,
   method: FieldConfigValidationError['missingMethod'],
@@ -102,19 +99,16 @@ export function validateFieldConfig(
   }
 
   if (field.type === 'relationship') {
-    // Relationships render through the relationship path only.
     requireMethod('getPrismaRelation')
     return errors
   }
 
   if (field.virtual === true || field.type === 'virtual') {
-    // Virtual fields are not persisted, so getPrismaType is intentionally absent.
     requireMethod('getTypeScriptType')
     requireMethod('getZodSchema')
     return errors
   }
 
-  // Stored scalar fields must implement the full generation contract.
   requireMethod('getPrismaType')
   requireMethod('getTypeScriptType')
   requireMethod('getZodSchema')

package/src/validation/schema.ts

@@ -1,9 +1,6 @@
 import { z } from 'zod'
 import type { FieldConfig } from '../config/types.js'
 
-/**
- * Generate Zod schema from field configurations
- */
 export function generateZodSchema(
   fieldConfigs: Record<string, FieldConfig>,
   operation: 'create' | 'update' = 'create',
@@ -11,7 +8,6 @@ export function generateZodSchema(
   const shape: Record<string, z.ZodTypeAny> = {}
 
   for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
-    // Skip system fields, relationships, and virtual fields
     // Virtual fields don't accept input - they only compute output
     if (
       ['id', 'createdAt', 'updatedAt'].includes(fieldName) ||
@@ -21,7 +17,6 @@ export function generateZodSchema(
       continue
     }
 
-    // Use the field's schema generator
     if (fieldConfig.getZodSchema) {
       shape[fieldName] = fieldConfig.getZodSchema(fieldName, operation)
     } else {
@@ -33,10 +28,6 @@ export function generateZodSchema(
   return z.object(shape)
 }
 
-/**
- * Validate data against field configurations using Zod
- * Returns structured errors by field
- */
 export function validateWithZod(
   data: Record<string, unknown>,
   fieldConfigs: Record<string, FieldConfig>,
@@ -50,7 +41,6 @@ export function validateWithZod(
     return { success: true }
   }
 
-  // Convert Zod errors to field-specific error messages
   const errors: Record<string, string> = {}
   for (const issue of result.error.issues) {
     const fieldPath = issue.path.join('.')