react-form-action 0.3.0 → 0.4.1

package/README.md

@@ -22,7 +22,7 @@ End-to-end typesafe success, error & validation state control for Next.js 14 for
 ## Install
 
 ```
-npm i react-form-action
+npm i react-form-action zod-form-data
 ```
 
 ## Usage
@@ -37,8 +37,6 @@ import { formAction } from "react-form-action";
 import { z } from "zod";
 import { cookies } from "next/headers";
 
-const emailSchema = z.object({ email: z.string().email() });
-
 const i18nMiddleware = async () => {
   const { t } = await useTranslation("auth", cookies().get("i18n")?.value);
   // will be added to context
@@ -46,7 +44,6 @@ const i18nMiddleware = async () => {
 };
 
 const authAction = formAction
-  .input(emailschema)
   .use(i18nMiddleware)
   .use(async ({ ctx: { t } }) =>
     console.log("🎉 context enhanced by previous middlewares 🎉", t)
@@ -61,25 +58,39 @@ const authAction = formAction
     }
   });
 
-export const resendVerifyEmailAction = authAction.run(
-  async ({ ctx: { t }, input: { email } }) => {
-    // do custom work
-    await db.resendVerificationEmail({ email });
+export const signIn = authAction
+  .input(z.object({ email: z.string().email() }))
+  // 🎉 extend the previous input (only without refinements and transforms)
+  .input(z.object({ password: z.string() }))
+  .run(async ({ ctx: { t }, input: { email, password } }) => {
+    // Type inferred: {email: string, password: string}
+
+    await db.signIn({ email, password });
 
-    // return translated success message
     return t("verificationEmail.success");
-  }
-);
+  });
 
-export const signUp = authAction
-  // extend the input
-  .input(z.object({ password: z.string() }))
+import { formAction } from "react-fomr-action";
+
+export const signUp = formAction
+  .input(
+    z
+      .object({
+        email: z.string().email(),
+        password: z.string(),
+        confirm: z.string(),
+      })
+      .refine((data) => data.password === data.confirm, {
+        message: "Passwords don't match",
+        path: ["confirm"],
+      })
+  ) // if using refinement, only one input call is permited, as schema with ZodEffects is not extendable.
   .run(async ({ ctx: { t }, input: { email, password } }) => {
-    // do custom work
-    await db.signupWithEmailAndPassword({ email, password });
+    // 🎉 passwords match!
+
+    await db.signUp({ email, password });
 
-    // return translated success message
-    return t("signUp.success");
+    return "We've sent you an email!";
   });
 ```
 

package/dist/index.d.mts

@@ -1,7 +1,9 @@
-import { F as FormState, a as FailureState, S as SuccessState, I as InvalidState } from './createFormAction-3a51310f.js';
+import { F as FormState, I as InvalidState, a as FailureState, S as SuccessState } from './createFormAction-3a51310f.js';
 export { b as InitialState, c as createFormAction } from './createFormAction-3a51310f.js';
-import { z, ZodRawShape, ZodObject, objectUtil, ZodSchema } from 'zod';
+import { ZodTypeAny, ZodType, ZodObject, ZodRawShape, objectUtil, z, ZodSchema, ZodEffects } from 'zod';
 
+declare const emptyInput: unique symbol;
+type EmptyInput = typeof emptyInput;
 type Flatten<T> = Identity<{
     [K in keyof T]: T[K];
 }>;
@@ -20,15 +22,15 @@ type SchemaAction<Data, Context, Schema extends ZodSchema> = (params: {
     ctx: Context;
     input: z.infer<Schema>;
 }) => Promise<Data>;
-type EmptyZodObject = ZodObject<ZodRawShape>;
-type FormActionBuilder<Schema extends EmptyZodObject, Err = Error, Context = InitialContext> = {
-    input: <T extends ZodRawShape>(schema: ZodObject<T>) => FormActionBuilder<ZodObject<objectUtil.extendShape<T, Schema["shape"]>>, Err, Context>;
+type AnyZodEffects = ZodEffects<any, any, any>;
+type FormActionBuilder<Schema extends ZodTypeAny | EmptyInput, Err = Error, Context = InitialContext> = {
+    input: <T extends ZodTypeAny>(newInput: T extends ZodType<infer Out extends Record<string, unknown>> ? Schema extends AnyZodEffects ? "Extending schema with effect is not possible." : Schema extends EmptyInput ? T : Schema extends ZodTypeAny ? T extends AnyZodEffects ? "Your input contains effect which prevents merging it with the previous inputs." : T : T : "The schema output must be an object.") => FormActionBuilder<Schema extends ZodObject<infer O1 extends ZodRawShape> ? T extends ZodObject<infer O2 extends ZodRawShape> ? ZodObject<objectUtil.extendShape<O1, O2>> : never : T, Err, Context>;
     /**
      * A finishing call on the builder completing your action.
      * @param action async function to execute. It will receive parsed formData as input, when the builder was initialized with a schema.
      * @returns runnable server action exportable from a module.
      */
-    run: Schema extends undefined ? <Data>(action: Action<Data, Context>) => (state: FormState<Data, Err>, payload: FormData) => Promise<Flatten<FailureState<Err> | SuccessState<Data>>> : <Data>(action: SchemaAction<Data, Context, Schema>) => (state: FormState<Data, Err, z.inferFlattenedErrors<Schema>>, payload: FormData) => Promise<Flatten<InvalidState<z.inferFlattenedErrors<Schema>> | FailureState<Err> | SuccessState<Data>>>;
+    run: Schema extends ZodTypeAny ? <Data>(action: SchemaAction<Data, Context, Schema>) => (state: FormState<Data, Err, z.inferFlattenedErrors<Schema>>, payload: FormData) => Promise<Flatten<InvalidState<z.inferFlattenedErrors<Schema>> | FailureState<Err> | SuccessState<Data>>> : <Data>(action: Action<Data, Context>) => (state: FormState<Data, Err>, payload: FormData) => Promise<Flatten<FailureState<Err> | SuccessState<Data>>>;
     /**
      * A chainable context enhancing helper.
      * @param middleware A function which receives the current context, and returns an object which will be added to the context.
@@ -48,6 +50,6 @@ type FormActionBuilder<Schema extends EmptyZodObject, Err = Error, Context = Ini
         ctx: Context;
     }) => Err) => FormActionBuilder<Schema, Err, Context>;
 };
-declare const formAction: FormActionBuilder<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, Error, InitialContext>;
+declare const formAction: FormActionBuilder<typeof emptyInput, Error, InitialContext>;
 
 export { FailureState, FormState, InvalidState, SuccessState, formAction };

package/dist/index.mjs

@@ -1 +1 @@
-function p(a){function o(e){return{type:"success",data:e,error:null,validationError:null}}function n(e){return{type:"failure",data:null,error:e,validationError:null}}function l(e){return{type:"invalid",data:null,error:null,validationError:e}}return(e,s)=>a({success:o,failure:n,invalid:l})(e,s)}import{z as D}from"zod";import{zfd as h}from"zod-form-data";function u(a,o=[],n){async function l(t){let r={formData:t};for(let i of o){let d=await i({ctx:r});r={...r,...d}}return r}let e=t=>p(({success:r,failure:i})=>async(d,x)=>{let m=await l(x);try{return r(await t({ctx:m}))}catch(c){if(n)return i(n({error:c,ctx:m}));throw c}}),s=t=>p(({success:r,failure:i,invalid:d})=>{let x=h.formData(a);return async(m,c)=>{let E=await l(c),S=x.safeParse(c);if(!S.success)return d(S.error.flatten());let y=S.data;try{return r(await t({input:y,ctx:E}))}catch(C){if(n)return i(n({error:C,ctx:E}));throw C}}});return{input(t){let r=a.merge(t);return u(r,o)},use(t){return u(a,[...o,t])},error(t){return u(a,o,t)},run:Object.keys(a.shape).length===0?e:s}}var j=u(D.object({}));export{p as createFormAction,j as formAction};
+function y(e){function o(a){return{type:"success",data:a,error:null,validationError:null}}function n(a){return{type:"failure",data:null,error:a,validationError:null}}function s(a){return{type:"invalid",data:null,error:null,validationError:a}}return(a,S)=>e({success:o,failure:n,invalid:s})(a,S)}import{ZodFirstPartyTypeKind as C}from"zod";import{zfd as w}from"zod-form-data";var l=Symbol();function d(e,o=[],n){async function s(t){let r={formData:t};for(let i of o){let u=await i({ctx:r});r={...r,...u}}return r}return{input(t){if(e===l)return d(t,o,n);if(e._def.effect)throw new Error("Previous input is not augmentable because it contains an effect.");if(t._def.effect)throw new Error("Your input contains effect which prevents merging it with the previous inputs.");if(e._def.typeName===C.ZodObject){let r=e.merge(t);return d(r,o)}else throw Error("Merging inputs works only for object schemas without effects.")},use(t){return d(e,[...o,t],n)},error(t){return d(e,o,t)},run:e===l?t=>y(({success:r,failure:i})=>async(u,x)=>{let p=await s(x);try{return r(await t({ctx:p}))}catch(c){if(n)return i(n({error:c,ctx:p}));throw c}}):e===l?void 0:t=>y(({success:r,failure:i,invalid:u})=>{let x=w.formData(e);return async(p,c)=>{let f=await s(c),m=x.safeParse(c);if(!m.success)return u(m.error.flatten());let h=m.data;try{return r(await t({input:h,ctx:f}))}catch(E){if(n)return i(n({error:E,ctx:f}));throw E}}})}}var b=d(l);export{y as createFormAction,b as formAction};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-form-action",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "State management helpers for the react form actions.",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
   ],
   "scripts": {
     "build": "tsup",
-    "test": "vitest"
+    "test": "vitest",
+    "typecheck": "vitest --typecheck"
   },
   "exports": {
     ".": {