@hookform/resolvers 5.9.1 → 6.0.0

package/effect-ts/dist/effect-ts.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"effect-ts.umd.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        // A null-prototype accumulator avoids false-positive hits from\n        // inherited members (e.g. `toString`, `constructor`) when a field\n        // is named after one of them — a plain `{}` would make `!acc[key]`\n        // truthy-skip those paths and silently drop their errors.\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          Object.create(null) as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","Object","create","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"wgBA6CEA,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,oBAEzDC,EAAQC,EAAGC,GACjB,OAAOC,EAAaA,cAClBP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAMA,OAACC,SAAS,SAACC,GACf,OAAAF,EAAAA,OAAOG,KAAKC,EAAcA,eAACC,YAAYH,GAAY,GAErDF,EAAMA,OAACM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAM1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,eACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACAa,OAAOC,OAAO,OAGhB,OAAOC,eAAalC,EAAQI,EAC9B,GACAG,SAAO4B,IAAI,WACT,OAAA5B,EAAAA,OAAO6B,KACL,WACE,OAAAhC,EAAQY,2BACRqB,EAAsBA,uBAAC,GAAIjC,EAAQ,EACtC,GAEHG,EAAAA,OAAO+B,MAAM,CACXC,UAAW,SAACvC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CsC,UAAW,SAACC,GAAM,MAAM,CAAEzC,OAAQ,CAAE,EAAEE,OAAQuC,EAAQ,IAExDlC,EAAMA,OAACmC,WAEX,CACF"}
+{"version":3,"file":"effect-ts.umd.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema, SchemaIssue } from 'effect';\nimport type { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\ntype Issue = { path: PropertyKey[]; message: string; type: string };\n\nconst formatIssue = SchemaIssue.makeFormatterStandardSchemaV1();\n\n// Flattens the issue tree like `makeFormatterStandardSchemaV1` does, but keeps\n// the `_tag` of the failing node so it can be reported as the error `type`.\nconst flattenIssue = (\n  issue: SchemaIssue.Issue,\n  path: PropertyKey[],\n): Issue[] => {\n  switch (issue._tag) {\n    case 'Pointer':\n      return flattenIssue(issue.issue, [...path, ...issue.path]);\n    case 'Encoding':\n      return flattenIssue(issue.issue, path);\n    case 'Composite':\n    case 'AnyOf':\n      if (issue.issues.length) {\n        return issue.issues.flatMap((issue) => flattenIssue(issue, path));\n      }\n  }\n\n  return formatIssue(issue).issues.map((error) => ({\n    path: [...path, ...(error.path || [])] as PropertyKey[],\n    message: error.message,\n    type: issue._tag,\n  }));\n};\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect Schema validation\n * @param {Schema.Codec<Output, Input>} schema - The Effect schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect Schema parse options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Codec<Output, Input, never, unknown>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) =>\n    Schema.decodeUnknownEffect(schema)(values, schemaOptions).pipe(\n      Effect.match({\n        onFailure: ({ issue }) => {\n          const validateAllFieldCriteria =\n            !options.shouldUseNativeValidation &&\n            options.criteriaMode === 'all';\n\n          // A null-prototype accumulator avoids false-positive hits from\n          // inherited members (e.g. `toString`, `constructor`) when a field\n          // is named after one of them — a plain `{}` would make `!acc[key]`\n          // truthy-skip those paths and silently drop their errors.\n          const errors = flattenIssue(issue, []).reduce(\n            (acc, error) => {\n              const key = error.path.join('.');\n\n              if (!acc[key]) {\n                acc[key] = { message: error.message, type: error.type };\n              }\n\n              if (validateAllFieldCriteria) {\n                const types = acc[key].types;\n                const messages = types && types[error.type];\n\n                acc[key] = appendErrors(\n                  key,\n                  validateAllFieldCriteria,\n                  acc,\n                  error.type,\n                  messages\n                    ? ([] as string[]).concat(\n                        messages as string[],\n                        error.message,\n                      )\n                    : error.message,\n                ) as FieldError;\n              }\n\n              return acc;\n            },\n            Object.create(null) as Record<string, FieldError>,\n          );\n\n          return { errors: toNestErrors(errors, options), values: {} };\n        },\n        onSuccess: (result) => {\n          options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options);\n\n          return { errors: {}, values: result };\n        },\n      }),\n      Effect.runPromise,\n    );\n}\n"],"names":["formatIssue","SchemaIssue","makeFormatterStandardSchemaV1","flattenIssue","issue","path","_tag","concat","issues","length","flatMap","map","error","message","type","schema","schemaOptions","errors","onExcessProperty","values","_","options","Schema","decodeUnknownEffect","pipe","Effect","match","onFailure","_ref","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","key","join","types","messages","appendErrors","Object","create","toNestErrors","onSuccess","result","validateFieldsNatively","runPromise"],"mappings":"maAYA,IAAMA,EAAcC,EAAWA,YAACC,gCAI1BC,EAAe,SACnBC,EACAC,GAEA,OAAQD,EAAME,MACZ,IAAK,UACH,OAAOH,EAAaC,EAAMA,MAAK,GAAAG,OAAMF,EAASD,EAAMC,OACtD,IAAK,WACH,OAAOF,EAAaC,EAAMA,MAAOC,GACnC,IAAK,YACL,IAAK,QACH,GAAID,EAAMI,OAAOC,OACf,OAAOL,EAAMI,OAAOE,QAAQ,SAACN,GAAK,OAAKD,EAAaC,EAAOC,EAAK,GAItE,OAAOL,EAAYI,GAAOI,OAAOG,IAAI,SAACC,GAAW,MAAA,CAC/CP,KAAI,GAAAE,OAAMF,EAAUO,EAAMP,MAAQ,IAClCQ,QAASD,EAAMC,QACfC,KAAMV,EAAME,KACb,EACH,qBAmCgB,SACdS,EACAC,GAEA,YAF8B,IAA9BA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAAC,EAAMA,OAACC,oBAAoBR,EAA3BO,CAAmCH,EAAQH,GAAeQ,KACxDC,EAAAA,OAAOC,MAAM,CACXC,UAAW,SAAFC,GAAgB,IACjBC,GACHR,EAAQS,2BACgB,QAAzBT,EAAQU,aAMJd,EAASd,EATEyB,EAALxB,MASuB,IAAI4B,OACrC,SAACC,EAAKrB,GACJ,IAAMsB,EAAMtB,EAAMP,KAAK8B,KAAK,KAM5B,GAJKF,EAAIC,KACPD,EAAIC,GAAO,CAAErB,QAASD,EAAMC,QAASC,KAAMF,EAAME,OAG/Ce,EAA0B,CAC5B,IAAMO,EAAQH,EAAIC,GAAKE,MACjBC,EAAWD,GAASA,EAAMxB,EAAME,MAEtCmB,EAAIC,GAAOI,eACTJ,EACAL,EACAI,EACArB,EAAME,KACNuB,EACK,GAAgB9B,OACf8B,EACAzB,EAAMC,SAERD,EAAMC,QAEd,CAEA,OAAOoB,CACT,EACAM,OAAOC,OAAO,OAGhB,MAAO,CAAEvB,OAAQwB,EAAYA,aAACxB,EAAQI,GAAUF,OAAQ,GAC1D,EACAuB,UAAW,SAACC,GAIV,OAHAtB,EAAQS,2BACNc,EAAsBA,uBAAC,GAAIvB,GAEtB,CAAEJ,OAAQ,CAAE,EAAEE,OAAQwB,EAC/B,IAEFlB,SAAOoB,WACR,CACL"}

package/effect-ts/package.json

@@ -12,7 +12,7 @@
   "license": "MIT",
   "peerDependencies": {
     "@hookform/resolvers": "^2.0.0",
-    "effect": "^3.10.3",
+    "effect": "^4.0.0",
     "react-hook-form": "^7.55.0"
   }
 }

package/effect-ts/src/__tests__/Form-native-validation.tsx

@@ -9,11 +9,11 @@ const USERNAME_REQUIRED_MESSAGE = 'username field is required';
 const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
 
 const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: USERNAME_REQUIRED_MESSAGE }),
   ),
-  password: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  password: Schema.String.check(
+    Schema.isNonEmpty({ message: PASSWORD_REQUIRED_MESSAGE }),
   ),
 });
 

package/effect-ts/src/__tests__/Form.tsx

@@ -9,11 +9,11 @@ const USERNAME_REQUIRED_MESSAGE = 'username field is required';
 const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
 
 const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: USERNAME_REQUIRED_MESSAGE }),
   ),
-  password: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  password: Schema.String.check(
+    Schema.isNonEmpty({ message: PASSWORD_REQUIRED_MESSAGE }),
   ),
 });
 

package/effect-ts/src/__tests__/__fixtures__/data.ts

@@ -2,43 +2,43 @@ import { Schema } from 'effect';
 import { Field, InternalFieldName } from 'react-hook-form';
 
 export const schema = Schema.Struct({
-  username: Schema.String.pipe(
-    Schema.nonEmptyString({ message: () => 'A username is required' }),
+  username: Schema.String.check(
+    Schema.isNonEmpty({ message: 'A username is required' }),
   ),
-  password: Schema.String.pipe(
-    Schema.pattern(new RegExp('.*[A-Z].*'), {
-      message: () => 'At least 1 uppercase letter.',
+  password: Schema.String.check(
+    Schema.isPattern(new RegExp('.*[A-Z].*'), {
+      message: 'At least 1 uppercase letter.',
     }),
-    Schema.pattern(new RegExp('.*[a-z].*'), {
-      message: () => 'At least 1 lowercase letter.',
+    Schema.isPattern(new RegExp('.*[a-z].*'), {
+      message: 'At least 1 lowercase letter.',
     }),
-    Schema.pattern(new RegExp('.*\\d.*'), {
-      message: () => 'At least 1 number.',
+    Schema.isPattern(new RegExp('.*\\d.*'), {
+      message: 'At least 1 number.',
     }),
-    Schema.pattern(
+    Schema.isPattern(
       new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'),
       {
-        message: () => 'At least 1 special character.',
+        message: 'At least 1 special character.',
       },
     ),
-    Schema.minLength(8, { message: () => 'Must be at least 8 characters.' }),
+    Schema.isMinLength(8, { message: 'Must be at least 8 characters.' }),
   ),
-  accessToken: Schema.Union(Schema.String, Schema.Number),
-  birthYear: Schema.Number.pipe(
-    Schema.greaterThan(1900, {
-      message: () => 'Must be greater than the year 1900',
+  accessToken: Schema.Union([Schema.String, Schema.Number]),
+  birthYear: Schema.Number.check(
+    Schema.isGreaterThan(1900, {
+      message: 'Must be greater than the year 1900',
     }),
-    Schema.filter((value) => value < new Date().getFullYear(), {
-      message: () => 'Must be before the current year.',
+    Schema.makeFilter((value: number) => value < new Date().getFullYear(), {
+      message: 'Must be before the current year.',
     }),
   ),
-  email: Schema.String.pipe(
-    Schema.pattern(
+  email: Schema.String.check(
+    Schema.isPattern(
       new RegExp(
         /^(?!\.)(?!.*\.\.)([A-Z0-9_+-.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9-]*\.)+[A-Z]{2,}$/i,
       ),
       {
-        message: () => 'A valid email address is required.',
+        message: 'A valid email address is required.',
       },
     ),
   ),
@@ -49,9 +49,9 @@ export const schema = Schema.Struct({
   ),
   luckyNumbers: Schema.Array(Schema.Number),
   enabled: Schema.Boolean,
-  animal: Schema.Union(Schema.String, Schema.Literal('bird', 'snake')),
+  animal: Schema.Union([Schema.String, Schema.Literals(['bird', 'snake'])]),
   vehicles: Schema.Array(
-    Schema.Union(
+    Schema.Union([
       Schema.Struct({
         type: Schema.Literal('car'),
         brand: Schema.String,
@@ -61,7 +61,7 @@ export const schema = Schema.Struct({
         type: Schema.Literal('bike'),
         speed: Schema.Number,
       }),
-    ),
+    ]),
   ),
 });
 

package/effect-ts/src/__tests__/__snapshots__/effect-ts.ts.snap

@@ -4,17 +4,17 @@ exports[`effectTsResolver > should return a single error from effectTsResolver w
 {
   "errors": {
     "animal": {
-      "message": "Expected string, actual ["dog"]",
+      "message": "Expected string | "bird" | "snake"",
       "ref": undefined,
-      "type": "Type",
+      "type": "AnyOf",
     },
     "luckyNumbers": [
       ,
       ,
       {
-        "message": "Expected number, actual "3"",
+        "message": "Expected number",
         "ref": undefined,
-        "type": "Type",
+        "type": "InvalidType",
       },
     ],
     "password": {
@@ -22,15 +22,15 @@ exports[`effectTsResolver > should return a single error from effectTsResolver w
       "ref": {
         "name": "password",
       },
-      "type": "Refinement",
+      "type": "Filter",
     },
     "vehicles": [
       ,
       {
         "horsepower": {
-          "message": "is missing",
+          "message": "Missing key",
           "ref": undefined,
-          "type": "Missing",
+          "type": "MissingKey",
         },
       },
     ],
@@ -47,10 +47,9 @@ exports[`effectTsResolver > should return all the errors from effectTsResolver w
       "ref": {
         "name": "phoneNumber",
       },
-      "type": "Refinement",
+      "type": "Filter",
       "types": {
-        "Refinement": "Please enter a valid phone number in international format.",
-        "Type": "Expected undefined, actual "123"",
+        "Filter": "Please enter a valid phone number in international format.",
       },
     },
   },
@@ -66,7 +65,7 @@ exports[`effectTsResolver > should return the first error from effectTsResolver
       "ref": {
         "name": "phoneNumber",
       },
-      "type": "Refinement",
+      "type": "Filter",
     },
   },
   "values": {},

package/effect-ts/src/__tests__/effect-ts.ts

@@ -1,5 +1,11 @@
 import { renderHook } from '@testing-library/react';
-import { Schema } from 'effect';
+import {
+  Effect,
+  Schema,
+  SchemaGetter,
+  SchemaIssue,
+  SchemaTransformation,
+} from 'effect';
 import { Resolver, useForm } from 'react-hook-form';
 import { SubmitHandler } from 'react-hook-form';
 import { effectTsResolver } from '..';
@@ -29,9 +35,9 @@ describe('effectTsResolver', () => {
   it('should return the first error from effectTsResolver when validation fails with `validateAllFieldCriteria` set to firstError', async () => {
     const SignupSchema = Schema.Struct({
       phoneNumber: Schema.optional(
-        Schema.String.pipe(
-          Schema.pattern(/^\+\d{7,15}$/, {
-            message: () =>
+        Schema.String.check(
+          Schema.isPattern(/^\+\d{7,15}$/, {
+            message:
               'Please enter a valid phone number in international format.',
           }),
         ),
@@ -59,9 +65,9 @@ describe('effectTsResolver', () => {
   it('should return all the errors from effectTsResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
     const SignupSchema = Schema.Struct({
       phoneNumber: Schema.optional(
-        Schema.String.pipe(
-          Schema.pattern(/^\+\d{7,15}$/, {
-            message: () =>
+        Schema.String.check(
+          Schema.isPattern(/^\+\d{7,15}$/, {
+            message:
               'Please enter a valid phone number in international format.',
           }),
         ),
@@ -86,6 +92,171 @@ describe('effectTsResolver', () => {
     expect(result).toMatchSnapshot();
   });
 
+  it('should group all messages of the same issue type when `criteriaMode` is "all"', async () => {
+    const schema = Schema.Struct({
+      password: Schema.String.check(
+        Schema.isMinLength(8, { message: 'Too short' }),
+        Schema.isPattern(/\d/, { message: 'Needs a number' }),
+      ),
+    });
+
+    const result = await effectTsResolver(schema)(
+      { password: 'abc' },
+      undefined,
+      { fields, criteriaMode: 'all', shouldUseNativeValidation },
+    );
+
+    expect(result.errors.password).toMatchObject({
+      message: 'Too short',
+      type: 'Filter',
+      types: { Filter: ['Too short', 'Needs a number'] },
+    });
+  });
+
+  it('should return nested and indexed errors with their issue type', async () => {
+    const schema = Schema.Struct({
+      user: Schema.Struct({ name: Schema.String }),
+      tags: Schema.Array(Schema.String),
+    });
+
+    const result = await effectTsResolver(schema)(
+      { user: {}, tags: ['a', 1] } as any,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(result).toEqual({
+      values: {},
+      errors: {
+        user: { name: { message: 'Missing key', type: 'MissingKey' } },
+        tags: [undefined, { message: 'Expected string', type: 'InvalidType' }],
+      },
+    });
+  });
+
+  it('should only report the first error when `schemaOptions.errors` is "first"', async () => {
+    const schema = Schema.Struct({ a: Schema.String, b: Schema.String });
+
+    const result = await effectTsResolver(schema, { errors: 'first' })(
+      {} as any,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(Object.keys(result.errors)).toEqual(['a']);
+  });
+
+  it('should ignore excess properties by default and report them when `onExcessProperty` is "error"', async () => {
+    const schema = Schema.Struct({ a: Schema.String });
+    const values = { a: 'a', b: 'b' } as any;
+
+    const ignored = await effectTsResolver(schema)(values, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+    expect(ignored).toEqual({ errors: {}, values: { a: 'a' } });
+
+    const rejected = await effectTsResolver(schema, {
+      errors: 'all',
+      onExcessProperty: 'error',
+    })(values, undefined, { fields, shouldUseNativeValidation });
+    expect(rejected.errors).toMatchObject({
+      b: { type: 'UnexpectedKey' },
+    });
+  });
+
+  it('should return the decoded output when a transformation is used', async () => {
+    const schema = Schema.Struct({ age: Schema.NumberFromString });
+
+    const result = await effectTsResolver(schema)({ age: '42' }, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({ errors: {}, values: { age: 42 } });
+  });
+
+  it('should report errors raised by a failing transformation', async () => {
+    const schema = Schema.Struct({
+      age: Schema.String.pipe(
+        Schema.decodeTo(Schema.Number, {
+          decode: SchemaGetter.transformEffect((s: string) =>
+            Number.isNaN(Number(s))
+              ? Effect.fail(
+                  new SchemaIssue.InvalidValue({ message: 'Not a number' }),
+                )
+              : Effect.succeed(Number(s)),
+          ),
+          encode: SchemaGetter.String(),
+        }),
+      ),
+    });
+
+    const result = await effectTsResolver(schema)({ age: 'abc' }, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({
+      values: {},
+      errors: { age: { message: 'Not a number', type: 'InvalidValue' } },
+    });
+  });
+
+  it('should support asynchronous validation', async () => {
+    const schema = Schema.Struct({
+      username: Schema.String.pipe(
+        Schema.decodeTo(Schema.String, {
+          decode: SchemaGetter.checkEffect((s: string) =>
+            Effect.sleep('1 millis').pipe(
+              Effect.as(s === 'taken' ? 'Username is taken' : undefined),
+            ),
+          ),
+          encode: SchemaGetter.passthrough(),
+        }),
+      ),
+    });
+
+    const valid = await effectTsResolver(schema)(
+      { username: 'free' },
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+    expect(valid).toEqual({ errors: {}, values: { username: 'free' } });
+
+    const invalid = await effectTsResolver(schema)(
+      { username: 'taken' },
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+    expect(invalid.errors).toMatchObject({
+      username: { message: 'Username is taken' },
+    });
+  });
+
+  it('should validate fields natively when `shouldUseNativeValidation` is true', async () => {
+    const setCustomValidity = vi.fn();
+    const reportValidity = vi.fn();
+    const nativeFields = {
+      username: {
+        name: 'username',
+        ref: { name: 'username', setCustomValidity, reportValidity },
+      },
+    } as any;
+
+    const result = await effectTsResolver(
+      Schema.Struct({ username: Schema.String }),
+    )({ username: 'john' }, undefined, {
+      fields: nativeFields,
+      names: ['username'],
+      shouldUseNativeValidation: true,
+    });
+
+    expect(result).toEqual({ errors: {}, values: { username: 'john' } });
+    expect(setCustomValidity).toHaveBeenCalledWith('');
+    expect(reportValidity).toHaveBeenCalled();
+  });
+
   /**
    * Type inference tests
    */
@@ -100,10 +271,15 @@ describe('effectTsResolver', () => {
   it('should correctly infer the output type from a effectTs schema using a transform', () => {
     const resolver = effectTsResolver(
       Schema.Struct({
-        id: Schema.transform(Schema.Number, Schema.String, {
-          decode: (val) => String(val),
-          encode: (val) => Number(val),
-        }),
+        id: Schema.Number.pipe(
+          Schema.decodeTo(
+            Schema.String,
+            SchemaTransformation.transform({
+              decode: (val) => String(val),
+              encode: (val) => Number(val),
+            }),
+          ),
+        ),
       }),
     );
 
@@ -132,10 +308,15 @@ describe('effectTsResolver', () => {
 
   it('should correctly infer the output type from a effectTs schema with a transform for the handleSubmit function in useForm', () => {
     const schema = Schema.Struct({
-      id: Schema.transform(Schema.Number, Schema.String, {
-        decode: (val) => String(val),
-        encode: (val) => Number(val),
-      }),
+      id: Schema.Number.pipe(
+        Schema.decodeTo(
+          Schema.String,
+          SchemaTransformation.transform({
+            decode: (val) => String(val),
+            encode: (val) => Number(val),
+          }),
+        ),
+      ),
     });
 
     const {

package/effect-ts/src/__tests__/special-path-names.ts

@@ -8,7 +8,7 @@ describe('effectTsResolver special path names', () => {
     'reports a validation error for a field named "%s"',
     async (name) => {
       const schema = Schema.Struct({
-        [name]: Schema.String.pipe(Schema.minLength(1)),
+        [name]: Schema.String.check(Schema.isMinLength(1)),
       });
 
       const result = await effectTsResolver(schema as any)(