zodvex 0.3.2 → 0.4.1

package/dist/index.js

@@ -388,16 +388,25 @@ function zodToConvexInternal(zodValidator, visited = /* @__PURE__ */ new Set())
       }
       case "transform":
       case "pipe": {
-        const codec = findBaseCodec(actualValidator);
-        if (codec) {
-          convexValidator = codec.toValidator(actualValidator);
-        } else {
-          const metadata2 = registryHelpers.getMetadata(actualValidator);
-          if (metadata2?.brand && metadata2?.originalSchema) {
-            convexValidator = zodToConvexInternal(metadata2.originalSchema, visited);
+        if (actualValidator instanceof z.ZodCodec) {
+          const inputSchema = actualValidator.def?.in;
+          if (inputSchema && inputSchema instanceof z.ZodType) {
+            convexValidator = zodToConvexInternal(inputSchema, visited);
           } else {
             convexValidator = v.any();
           }
+        } else {
+          const codec = findBaseCodec(actualValidator);
+          if (codec) {
+            convexValidator = codec.toValidator(actualValidator);
+          } else {
+            const metadata2 = registryHelpers.getMetadata(actualValidator);
+            if (metadata2?.brand && metadata2?.originalSchema) {
+              convexValidator = zodToConvexInternal(metadata2.originalSchema, visited);
+            } else {
+              convexValidator = v.any();
+            }
+          }
         }
         break;
       }
@@ -675,6 +684,21 @@ function handleZodValidationError(e, context) {
   }
   throw e;
 }
+function validateReturns(schema, value) {
+  try {
+    return z.encode(schema, value);
+  } catch (e) {
+    if (e?.message?.includes("unidirectional transform")) {
+      try {
+        return schema.parse(value);
+      } catch (parseError) {
+        handleZodValidationError(parseError, "returns");
+      }
+    }
+    handleZodValidationError(e, "returns");
+  }
+  throw new Error("Unreachable");
+}
 function zPaginated(item) {
   return z.object({
     page: z.array(item),
@@ -725,6 +749,20 @@ function safeOmit(schema, mask) {
 }
 
 // src/custom.ts
+function customCtxWithHooks(fn) {
+  return {
+    args: {},
+    input: async (ctx) => {
+      const result = await fn(ctx);
+      return {
+        ctx: result.ctx ?? {},
+        args: result.args ?? {},
+        hooks: result.hooks,
+        transforms: result.transforms
+      };
+    }
+  };
+}
 function customFnBuilder(builder, customization) {
   const customInput = customization.input ?? NoOp.input;
   const inputArgs = customization.args ?? NoOp.args;
@@ -768,17 +806,16 @@ function customFnBuilder(builder, customization) {
           const finalCtx = { ...ctx, ...added?.ctx ?? {} };
           const baseArgs = parsed.data;
           const addedArgs = added?.args ?? {};
-          const finalArgs = { ...baseArgs, ...addedArgs };
+          let finalArgs = { ...baseArgs, ...addedArgs };
+          if (added?.transforms?.input) {
+            finalArgs = await added.transforms.input(finalArgs, argsSchema);
+          }
           const ret = await handler(finalCtx, finalArgs);
           if (returns) {
-            let validated;
-            try {
-              validated = returns.parse(ret);
-            } catch (e) {
-              handleZodValidationError(e, "returns");
-            }
-            if (added?.onSuccess) {
-              await added.onSuccess({
+            const preTransformed = added?.transforms?.output ? await added.transforms.output(ret, returns) : ret;
+            const validated = validateReturns(returns, preTransformed);
+            if (added?.hooks?.onSuccess) {
+              await added.hooks.onSuccess({
                 ctx,
                 args: parsed.data,
                 result: validated
@@ -786,8 +823,8 @@ function customFnBuilder(builder, customization) {
             }
             return toConvexJS(returns, validated);
           }
-          if (added?.onSuccess) {
-            await added.onSuccess({ ctx, args: parsed.data, result: ret });
+          if (added?.hooks?.onSuccess) {
+            await added.hooks.onSuccess({ ctx, args: parsed.data, result: ret });
           }
           return ret;
         }
@@ -805,22 +842,21 @@ function customFnBuilder(builder, customization) {
         const finalCtx = { ...ctx, ...added?.ctx ?? {} };
         const baseArgs = allArgs;
         const addedArgs = added?.args ?? {};
-        const finalArgs = { ...baseArgs, ...addedArgs };
+        let finalArgs = { ...baseArgs, ...addedArgs };
+        if (added?.transforms?.input) {
+          finalArgs = await added.transforms.input(finalArgs, z.unknown());
+        }
         const ret = await handler(finalCtx, finalArgs);
         if (returns) {
-          let validated;
-          try {
-            validated = returns.parse(ret);
-          } catch (e) {
-            handleZodValidationError(e, "returns");
-          }
-          if (added?.onSuccess) {
-            await added.onSuccess({ ctx, args: allArgs, result: validated });
+          const preTransformed = added?.transforms?.output ? await added.transforms.output(ret, returns) : ret;
+          const validated = validateReturns(returns, preTransformed);
+          if (added?.hooks?.onSuccess) {
+            await added.hooks.onSuccess({ ctx, args: allArgs, result: validated });
           }
           return toConvexJS(returns, validated);
         }
-        if (added?.onSuccess) {
-          await added.onSuccess({ ctx, args: allArgs, result: ret });
+        if (added?.hooks?.onSuccess) {
+          await added.hooks.onSuccess({ ctx, args: allArgs, result: ret });
         }
         return ret;
       }
@@ -896,12 +932,8 @@ function zQuery(query, input, handler, options) {
       }
       const raw = await handler(ctx, parsed);
       if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
+        const validated = validateReturns(options.returns, raw);
+        return toConvexJS(options.returns, validated);
       }
       return toConvexJS(raw);
     }
@@ -935,12 +967,8 @@ function zMutation(mutation, input, handler, options) {
       }
       const raw = await handler(ctx, parsed);
       if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
+        const validated = validateReturns(options.returns, raw);
+        return toConvexJS(options.returns, validated);
       }
       return toConvexJS(raw);
     }
@@ -974,12 +1002,8 @@ function zAction(action, input, handler, options) {
       }
       const raw = await handler(ctx, parsed);
       if (options?.returns) {
-        try {
-          const validated = options.returns.parse(raw);
-          return toConvexJS(options.returns, validated);
-        } catch (e) {
-          handleZodValidationError(e, "returns");
-        }
+        const validated = validateReturns(options.returns, raw);
+        return toConvexJS(options.returns, validated);
       }
       return toConvexJS(raw);
     }
@@ -1026,9 +1050,48 @@ function zCustomActionBuilder(action, customization) {
     customization
   );
 }
+var success = (data) => ({ success: true, data });
+var failure = (error) => ({ success: false, error });
+var ok = () => ({ success: true });
+var formSuccess = (data) => ({ success: true, data });
+var formFailure = (data, error) => ({ success: false, data, error });
+var zMutationResult = (dataSchema) => z.discriminatedUnion("success", [
+  z.object({ success: z.literal(true), data: dataSchema }),
+  z.object({ success: z.literal(false), error: z.string() })
+]);
+var zVoidMutationResult = z.discriminatedUnion("success", [
+  z.object({ success: z.literal(true) }),
+  z.object({ success: z.literal(false), error: z.string() })
+]);
+var zFormError = z.object({
+  formErrors: z.array(z.string()),
+  fieldErrors: z.record(z.string(), z.array(z.string()))
+});
+var zFormResult = (dataSchema) => z.discriminatedUnion("success", [
+  z.object({ success: z.literal(true), data: dataSchema }),
+  z.object({ success: z.literal(false), data: dataSchema, error: zFormError })
+]);
+function isZodUnion(schema) {
+  return schema instanceof z.ZodUnion || schema instanceof z.ZodDiscriminatedUnion;
+}
+function getUnionOptions(schema) {
+  return schema.options;
+}
+function assertUnionOptions(options) {
+  if (options.length < 2) {
+    throw new Error(
+      `z.union() requires at least 2 options, but received ${options.length}. This indicates an invalid union schema was passed to zodTable().`
+    );
+  }
+}
+function createUnionFromOptions(options) {
+  assertUnionOptions(options);
+  return z.union(options);
+}
 function addSystemFields(tableName, schema) {
-  if (schema instanceof z.ZodUnion || schema instanceof z.ZodDiscriminatedUnion) {
-    const options = schema.options.map((variant) => {
+  if (isZodUnion(schema)) {
+    const originalOptions = getUnionOptions(schema);
+    const extendedOptions = originalOptions.map((variant) => {
       if (variant instanceof z.ZodObject) {
         return variant.extend({
           _id: zid(tableName),
@@ -1037,7 +1100,7 @@ function addSystemFields(tableName, schema) {
       }
       return variant;
     });
-    return z.union(options);
+    return createUnionFromOptions(extendedOptions);
   }
   if (schema instanceof z.ZodObject) {
     return schema.extend({
@@ -1047,6 +1110,9 @@ function addSystemFields(tableName, schema) {
   }
   return schema;
 }
+function asTableValidator(validator) {
+  return validator;
+}
 function zodDoc(tableName, schema) {
   return schema.extend({
     _id: zid(tableName),
@@ -1076,28 +1142,107 @@ function zodTable(name, schemaOrShape) {
     );
     const zDoc = zodDoc(name, z.object(shape));
     const docArray = z.array(zDoc);
-    return Object.assign(table, {
+    const baseSchema = z.object(shape);
+    const partialShape = {};
+    for (const [key, value] of Object.entries(shape)) {
+      partialShape[key] = value.optional();
+    }
+    const updateSchema = z.object({
+      _id: zid(name),
+      _creationTime: z.number().optional(),
+      ...partialShape
+    });
+    const schema = {
+      doc: zDoc,
+      docArray,
+      base: baseSchema,
+      insert: baseSchema,
+      // alias for base
+      update: updateSchema
+    };
+    const warned = { zDoc: false, docArray: false };
+    const result = Object.assign(table, {
       shape,
-      zDoc,
-      docArray
+      schema
+    });
+    Object.defineProperty(result, "zDoc", {
+      get() {
+        if (!warned.zDoc) {
+          console.warn("zodvex: `zDoc` is deprecated, use `schema.doc` instead");
+          warned.zDoc = true;
+        }
+        return schema.doc;
+      },
+      enumerable: true
+    });
+    Object.defineProperty(result, "docArray", {
+      get() {
+        if (!warned.docArray) {
+          console.warn("zodvex: `docArray` is deprecated, use `schema.docArray` instead");
+          warned.docArray = true;
+        }
+        return schema.docArray;
+      },
+      enumerable: true
     });
+    return result;
   } else {
     const schema = schemaOrShape;
     const convexValidator = zodToConvex(schema);
-    const table = defineTable(convexValidator);
-    const withFields = addSystemFields(name, schema);
-    const docArray = z.array(withFields);
+    const table = defineTable(asTableValidator(convexValidator));
+    const docSchema = addSystemFields(name, schema);
+    const docArray = z.array(docSchema);
+    let updateSchema;
+    if (isZodUnion(schema)) {
+      const originalOptions = getUnionOptions(schema);
+      const updateOptions = originalOptions.map((variant) => {
+        if (variant instanceof z.ZodObject) {
+          const partialShape = {};
+          for (const [key, value] of Object.entries(variant.shape)) {
+            partialShape[key] = value.optional();
+          }
+          return z.object({
+            _id: zid(name),
+            _creationTime: z.number().optional(),
+            ...partialShape
+          });
+        }
+        return variant;
+      });
+      updateSchema = createUnionFromOptions(updateOptions);
+    } else if (schema instanceof z.ZodObject) {
+      const partialShape = {};
+      for (const [key, value] of Object.entries(schema.shape)) {
+        partialShape[key] = value.optional();
+      }
+      updateSchema = z.object({
+        _id: zid(name),
+        _creationTime: z.number().optional(),
+        ...partialShape
+      });
+    } else {
+      updateSchema = schema;
+    }
+    const schemaNamespace = {
+      doc: docSchema,
+      docArray,
+      base: schema,
+      insert: schema,
+      // alias for base
+      update: updateSchema
+    };
     return {
       table,
       tableName: name,
       validator: convexValidator,
-      schema,
+      schema: schemaNamespace,
       docArray,
+      // deprecated
       withSystemFields: () => addSystemFields(name, schema)
     };
   }
 }
 
-export { addSystemFields, composeOverrides, convexCodec, customFnBuilder, findBaseCodec, formatZodIssues, fromConvexJS, getObjectShape, getZidTableName, handleZodValidationError, isDateSchema, isZidSchema, makeUnion, mapDateFieldToNumber, pick, pickShape, registerBaseCodec, registryHelpers, returnsAs, safeOmit, safePick, toConvexJS, toJSONSchema, zActionBuilder, zCustomAction, zCustomActionBuilder, zCustomMutation, zCustomMutationBuilder, zCustomQuery, zCustomQueryBuilder, zMutationBuilder, zPaginated, zQueryBuilder, zid, zodDoc, zodDocOrNull, zodTable, zodToConvex, zodToConvexFields, zodvexJSONSchemaOverride };
+export { addSystemFields, assertUnionOptions, composeOverrides, convexCodec, createUnionFromOptions, customCtxWithHooks, customFnBuilder, failure, findBaseCodec, formFailure, formSuccess, formatZodIssues, fromConvexJS, getObjectShape, getUnionOptions, getZidTableName, handleZodValidationError, isDateSchema, isZidSchema, isZodUnion, makeUnion, mapDateFieldToNumber, ok, pick, pickShape, registerBaseCodec, registryHelpers, returnsAs, safeOmit, safePick, success, toConvexJS, toJSONSchema, validateReturns, zActionBuilder, zCustomAction, zCustomActionBuilder, zCustomMutation, zCustomMutationBuilder, zCustomQuery, zCustomQueryBuilder, zFormError, zFormResult, zMutationBuilder, zMutationResult, zPaginated, zQueryBuilder, zVoidMutationResult, zid, zodDoc, zodDocOrNull, zodTable, zodToConvex, zodToConvexFields, zodvexJSONSchemaOverride };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map