fix: optional type and distinguish error

Author: miello

packages/core/src/collection.ts

@@ -762,7 +762,12 @@ export function getAllCollectionEndpoints<
             ]
           }
           case ApiDefaultMethod.FIND_MANY: {
-            const response = fieldsToZodObject(fields)
+            const body = fieldsToZodObject(fields)
+            const response = z.object({
+              data: z.array(body),
+              total: z.number(),
+              page: z.number(),
+            })
 
             const schema = {
               path: `/api/${collection.slug}/${method}`,

packages/core/src/field.ts

@@ -7,7 +7,7 @@ import {
   type TableRelationalConfig,
 } from 'drizzle-orm'
 import type { Simplify } from 'type-fest'
-import type { ZodObject } from 'zod'
+import type { ZodObject, ZodOptional } from 'zod'
 import z from 'zod'
 
 import {
@@ -444,21 +444,30 @@ export class FieldBuilder<
   }
 }
 
+type CastOptionalFieldToZodSchema<
+  TField extends Field<any>,
+  TSchema extends z.ZodTypeAny,
+> = TField['_'] extends { source: 'column' }
+  ? TField['_']['column']['notNull'] extends true
+    ? ZodOptional<TSchema>
+    : TSchema
+  : TSchema
+
 type FieldToZodScheama<TField extends Field<any>> =
   TField extends FieldColumnStringCollectionOptions<any>[keyof FieldColumnStringCollectionOptions<any>]
-    ? z.ZodString
+    ? CastOptionalFieldToZodSchema<TField, z.ZodString>
     : TField extends FieldColumnStringArrayCollectionOptions<any>[keyof FieldColumnStringArrayCollectionOptions<any>]
-      ? z.ZodArray<z.ZodString>
+      ? CastOptionalFieldToZodSchema<TField, z.ZodArray<z.ZodString>>
       : TField extends FieldColumnNumberCollectionOptions<any>[keyof FieldColumnNumberCollectionOptions<any>]
-        ? z.ZodNumber
+        ? CastOptionalFieldToZodSchema<TField, z.ZodNumber>
         : TField extends FieldColumnNumberArrayCollectionOptions<any>[keyof FieldColumnNumberArrayCollectionOptions<any>]
-          ? z.ZodArray<z.ZodNumber>
+          ? CastOptionalFieldToZodSchema<TField, z.ZodArray<z.ZodNumber>>
           : TField extends FieldColumnBooleanCollectionOptions[keyof FieldColumnBooleanCollectionOptions]
-            ? z.ZodBoolean
+            ? CastOptionalFieldToZodSchema<TField, z.ZodBoolean>
             : TField extends FieldColumnBooleanArrayCollectionOptions[keyof FieldColumnBooleanArrayCollectionOptions]
-              ? z.ZodArray<z.ZodBoolean>
+              ? CastOptionalFieldToZodSchema<TField, z.ZodArray<z.ZodBoolean>>
               : TField extends FieldColumnDateCollectionOptions[keyof FieldColumnDateCollectionOptions]
-                ? z.ZodDate
+                ? CastOptionalFieldToZodSchema<TField, z.ZodDate>
                 : never
 // TODO: Relation input
 // TODO: Optioanl and default values
@@ -473,26 +482,47 @@ export function fieldToZodScheama<TField extends Field<any>>(
     case 'selectText':
     case 'time':
     case 'media':
+      if (!field._.column.notNull) {
+        return z.string().optional() as FieldToZodScheama<TField>
+      }
       return z.string() as FieldToZodScheama<TField>
     // string[] input
     case 'comboboxText':
+      if (!field._.column.notNull) {
+        return z.array(z.string()) as FieldToZodScheama<TField>
+      }
       return z.array(z.string()) as FieldToZodScheama<TField>
     // number input
     case 'number':
     case 'selectNumber':
+      if (!field._.column.notNull) {
+        return z.number().optional() as FieldToZodScheama<TField>
+      }
       return z.number() as FieldToZodScheama<TField>
     // number[] input
     case 'comboboxNumber':
+      if (!field._.column.notNull) {
+        return z.array(z.number()).optional() as FieldToZodScheama<TField>
+      }
       return z.array(z.number()) as FieldToZodScheama<TField>
     // boolean input
     case 'checkbox':
     case 'switch':
+      if (!field._.column.notNull) {
+        return z.boolean().optional() as FieldToZodScheama<TField>
+      }
       return z.boolean() as FieldToZodScheama<TField>
     // boolean[] input
     case 'comboboxBoolean':
+      if (!field._.column.notNull) {
+        return z.array(z.boolean()).optional() as FieldToZodScheama<TField>
+      }
       return z.array(z.boolean()) as FieldToZodScheama<TField>
     // date input
     case 'date':
+      if (!field._.column.notNull) {
+        return z.date().optional() as FieldToZodScheama<TField>
+      }
       return z.date() as FieldToZodScheama<TField>
     // TODO: relation input
     case 'connect':
@@ -515,6 +545,7 @@ export function fieldsToZodObject<TFields extends Fields<any>>(
 ): FieldsToZodObject<TFields> {
   const zodObject = Object.entries(fields).reduce(
     (acc, [key, field]) => {
+      console.log(key, field)
       acc[key] = fieldToZodScheama(field)
       return acc
     },

packages/core/src/utils.ts

@@ -121,32 +121,45 @@ export async function validateRequestBody<
   TApiRouteSchema extends ApiRouteSchema = any,
   TContext extends Record<string, unknown> = Record<string, unknown>,
 >(schema: TApiRouteSchema, payload: ApiRouteHandlerPayloadWithContext<TApiRouteSchema, TContext>) {
-  const zodErrors: ZodError[] = []
+  let zodErrors: Partial<Record<'query' | 'pathParams' | 'headers' | 'body', ZodError>> | undefined
+
   if (schema.query) {
     const err = await schema.query.safeParseAsync((payload as any).query)
     if (!err.success) {
-      zodErrors.push(err.error)
+      zodErrors = {
+        ...zodErrors,
+        query: err.error,
+      }
     }
   }
 
   if (schema.pathParams) {
     const err = await schema.pathParams.safeParseAsync((payload as any).pathParams)
     if (!err.success) {
-      zodErrors.push(err.error)
+      zodErrors = {
+        ...zodErrors,
+        pathParams: err.error,
+      }
     }
   }
 
   if (schema.headers) {
     const err = await schema.headers.safeParseAsync(payload.headers)
     if (!err.success) {
-      zodErrors.push(err.error)
+      zodErrors = {
+        ...zodErrors,
+        headers: err.error,
+      }
     }
   }
 
   if (schema.method !== 'GET' && schema.body) {
     const err = await schema.body.safeParseAsync((payload as any).body)
     if (!err.success) {
-      zodErrors.push(err.error)
+      zodErrors = {
+        ...zodErrors,
+        body: err.error,
+      }
     }
   }
 
@@ -177,12 +190,12 @@ export function withValidator<
 ): (payload: ApiRouteHandlerPayloadWithContext<TApiRouteSchema, TContext>) => MaybePromise<any> {
   return async (payload: ApiRouteHandlerPayloadWithContext<TApiRouteSchema, TContext>) => {
     const zodErrors = await validateRequestBody(schema, payload)
-    if (zodErrors.length > 0) {
+    if (zodErrors) {
       return {
         status: 400,
         body: {
           error: 'Validation failed',
-          details: zodErrors.map((e) => e.message),
+          details: zodErrors,
         },
       }
     }
@@ -195,7 +208,7 @@ export function withValidator<
         status: 500,
         body: {
           error: 'Response validation failed',
-          details: validationError.errors.map((e) => e.message),
+          details: validationError.issues,
         },
       }
     }