Allow plain date strings for @db.Date DateTime fields

Author: lsmith77

packages/orm/src/client/zod/factory.ts

@@ -361,13 +361,21 @@ export class ZodSchemaFactory<
                         ZodUtils.addDecimalValidation(z.string(), attributes, this.extraValidationsEnabled),
                     ]);
                 })
-                .with('DateTime', () => this.makeDateTimeValueSchema())
+                .with('DateTime', () =>
+                    this.hasAttribute(attributes, '@db.Date')
+                        ? z.union([z.iso.date(), this.makeDateTimeValueSchema()])
+                        : this.makeDateTimeValueSchema(),
+                )
                 .with('Bytes', () => z.instanceof(Uint8Array))
                 .with('Json', () => this.makeJsonValueSchema())
                 .otherwise(() => z.unknown());
         }
     }
 
+    private hasAttribute(attributes: readonly AttributeApplication[] | undefined, name: string) {
+        return attributes?.some((attribute) => attribute.name === name) ?? false;
+    }
+
     @cache()
     private makeEnumSchema(_enum: string) {
         const enumDef = getEnum(this.schema, _enum);
@@ -505,6 +513,7 @@ export class ZodSchemaFactory<
                         !!fieldDef.optional,
                         withAggregations,
                         allowedFilterKinds,
+                        fieldDef.type === 'DateTime' ? fieldDef.attributes : undefined,
                     );
                 }
             }
@@ -792,14 +801,15 @@ export class ZodSchemaFactory<
         optional: boolean,
         withAggregations: boolean,
         allowedFilterKinds: string[] | undefined,
+        attributes?: readonly AttributeApplication[],
     ) {
         return match(type)
             .with('String', () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds))
             .with(P.union('Int', 'Float', 'Decimal', 'BigInt'), (type) =>
                 this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds),
             )
             .with('Boolean', () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds))
-            .with('DateTime', () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds))
+            .with('DateTime', () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds, attributes))
             .with('Bytes', () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds))
             .with('Json', () => this.makeJsonFilterSchema(optional, allowedFilterKinds))
             .with('Unsupported', () => z.never())
@@ -859,13 +869,17 @@ export class ZodSchemaFactory<
         return schema;
     }
 
-    @cache()
     private makeDateTimeFilterSchema(
         optional: boolean,
         withAggregations: boolean,
         allowedFilterKinds: string[] | undefined,
+        attributes?: readonly AttributeApplication[],
     ): ZodType {
-        const filterValueSchema = z.union([z.iso.date(), this.makeDateTimeValueSchema()]);
+        // For DateTime fields with @db.Date, allow plain date strings in filters
+        const filterValueSchema = attributes && this.hasAttribute(attributes, '@db.Date')
+            ? z.union([z.iso.date(), this.makeDateTimeValueSchema()])
+            : this.makeDateTimeValueSchema();
+
         const schema = this.makeCommonPrimitiveFilterSchema(
             filterValueSchema,
             optional,

tests/e2e/orm/client-api/db-date-filter.test.ts

@@ -84,9 +84,41 @@ model Event {
         expect(lessThanFound.map((item: { name: string }) => item.name).sort()).toEqual(['Middle', 'Past']);
     });
 
-    it('plain date string is accepted on a regular DateTime field (no @db.Date)', async () => {
+    it('accepts plain date strings in create and update payloads for a @db.Date field only', async () => {
+        const createSchema = client.$zod.makeCreateSchema('Event');
+        const createResult = createSchema.safeParse({ data: { name: 'Conference', eventDate: '2007-05-23' } });
+        expect(
+            createResult.success,
+            `Expected create payload for @db.Date field to be accepted, got: ${JSON.stringify(createResult.error)}`,
+        ).toBe(true);
+
+        const invalidCreateResult = createSchema.safeParse({ data: { name: 'Conference', createdAt: '2007-05-23' } });
+        expect(invalidCreateResult.success).toBe(false);
+
+        const created = await client.event.create({ data: { name: 'Conference', eventDate: '2007-05-23' } });
+
+        const updateSchema = client.$zod.makeUpdateSchema('Event');
+        const updateResult = updateSchema.safeParse({ where: { id: created.id }, data: { eventDate: '2008-05-23' } });
+        expect(
+            updateResult.success,
+            `Expected update payload for @db.Date field to be accepted, got: ${JSON.stringify(updateResult.error)}`,
+        ).toBe(true);
+
+        const invalidUpdateResult = updateSchema.safeParse({
+            where: { id: created.id },
+            data: { createdAt: '2008-05-23' },
+        });
+        expect(invalidUpdateResult.success).toBe(false);
+
+        await client.event.update({ where: { id: created.id }, data: { eventDate: '2008-05-23' } });
+
+        const updated = await client.event.findMany({ where: { id: created.id, eventDate: '2008-05-23' } });
+        expect(updated).toHaveLength(1);
+    });
+
+    it('plain date string is rejected on a regular DateTime field (no @db.Date)', async () => {
         const filterSchema = client.$zod.makeFindManySchema('Event');
         const result = filterSchema.safeParse({ where: { createdAt: '2007-05-23' } });
-        expect(result.success).toBe(true);
+        expect(result.success).toBe(false);
     });
 });