addressing PR comments

Author: ymc9

packages/orm/src/client/crud/validator/validator.ts

@@ -21,13 +21,12 @@ import {
     type UpsertArgs,
 } from '../../crud-types';
 import { createInvalidInputError } from '../../errors';
-import type { ClientOptions } from '../../options';
 import { ZodSchemaFactory } from '../../zod/factory';
 
 type GetSchemaFunc<Schema extends SchemaDef> = (model: GetModels<Schema>) => ZodType;
 
 export class InputValidator<Schema extends SchemaDef> {
-    readonly zodFactory: ZodSchemaFactory<Schema, ClientOptions<Schema>>;
+    readonly zodFactory: ZodSchemaFactory<Schema>;
 
     constructor(private readonly client: ClientContract<Schema>) {
         this.zodFactory = new ZodSchemaFactory(client);

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

@@ -1473,6 +1473,7 @@ export class ZodSchemaFactory<
                         fieldSchema,
                         z
                             .object({
+                                // TODO: use Decimal/BigInt for incremental updates
                                 set: this.nullableIf(z.number().optional(), !!fieldDef.optional).optional(),
                                 increment: z.number().optional(),
                                 decrement: z.number().optional(),
@@ -1694,7 +1695,7 @@ export class ZodSchemaFactory<
 
         // fields used in `having` must be either in the `by` list, or aggregations
         schema = schema.refine((value: any) => {
-            const bys = typeof value.by === 'string' ? [value.by] : value.by;
+            const bys = enumerate(value.by);
             if (value.having && typeof value.having === 'object') {
                 for (const [key, val] of Object.entries(value.having)) {
                     if (AggregateOperators.includes(key as any)) {
@@ -1721,17 +1722,18 @@ export class ZodSchemaFactory<
 
         // fields used in `orderBy` must be either in the `by` list, or aggregations
         schema = schema.refine((value: any) => {
-            const bys = typeof value.by === 'string' ? [value.by] : value.by;
-            if (
-                value.orderBy &&
-                Object.keys(value.orderBy)
-                    .filter((f) => !AggregateOperators.includes(f as AggregateOperators))
-                    .some((key) => !bys.includes(key))
-            ) {
-                return false;
-            } else {
-                return true;
+            const bys = enumerate(value.by);
+            for (const orderBy of enumerate(value.orderBy)) {
+                if (
+                    orderBy &&
+                    Object.keys(orderBy)
+                        .filter((f) => !AggregateOperators.includes(f as AggregateOperators))
+                        .some((key) => !bys.includes(key))
+                ) {
+                    return false;
+                }
             }
+            return true;
         }, 'fields in "orderBy" must be in "by"');
 
         return schema as ZodType<GroupByArgs<Schema, Model, Options, ExtQueryArgs>>;

packages/schema/src/accessor.ts

@@ -173,7 +173,7 @@ const accessors: Accessors = {
         const modelDef = _requireModel(this.schema, model);
         const result: Array<{ name: string; def: FieldDef } | { name: string; defs: Record<string, FieldDef> }> = [];
         for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-            if (typeof value !== 'object') {
+            if (value === null || typeof value !== 'object') {
                 throw new InvalidSchemaError(`Invalid unique field definition for "${model}.${key}"`);
             }
 

packages/zod/src/factory.ts

@@ -50,10 +50,9 @@ class SchemaFactory<Schema extends SchemaDef> {
         for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
             if (fieldDef.relation) {
                 const relatedModelName = fieldDef.type;
-                const lazySchema: z.ZodType = z.lazy(() =>
-                    this.applyCardinality(this.makeModelSchema(relatedModelName as GetModels<Schema>), fieldDef),
-                );
-                fields[fieldName] = lazySchema.optional();
+                const lazySchema: z.ZodType = z.lazy(() => this.makeModelSchema(relatedModelName as GetModels<Schema>));
+                // relation fields are always optional
+                fields[fieldName] = this.applyCardinality(lazySchema, fieldDef).optional();
             } else {
                 fields[fieldName] = this.makeScalarFieldSchema(fieldDef);
             }
@@ -115,17 +114,18 @@ class SchemaFactory<Schema extends SchemaDef> {
     }
 
     private applyCardinality(schema: z.ZodType, fieldDef: FieldDef): z.ZodType {
+        let result = schema;
         if (fieldDef.array) {
-            return schema.array();
+            result = result.array();
         }
         if (fieldDef.optional) {
-            return schema.nullable().optional();
+            result = result.nullable().optional();
         }
-        return schema;
+        return result;
     }
 
     makeTypeSchema<Type extends GetTypeDefs<Schema>>(
-        type: GetTypeDefs<Schema>,
+        type: Type,
     ): z.ZodObject<GetTypeDefFieldsShape<Schema, Type>, z.core.$strict> {
         const typeDef = this.schema.requireTypeDef(type);
         const fields: Record<string, z.ZodType> = {};

packages/zod/test/factory.test.ts

@@ -60,7 +60,7 @@ describe('SchemaFactory - makeModelSchema', () => {
             // boolean
             expectTypeOf<User['active']>().toEqualTypeOf<boolean>();
 
-            // optional DateTime — FieldTypeZodMap key is 'Date' not 'DateTime', falls to ZodUnknown
+            // DateTime
             expectTypeOf<User['birthdate']>().toEqualTypeOf<Date | null | undefined>();
 
             // optional Bytes

tests/e2e/orm/client-api/zod.test.ts

@@ -1,10 +1,14 @@
 import { createQuerySchemaFactory, definePlugin, type ClientContract, type ClientOptions } from '@zenstackhq/orm';
-import { createTestClient } from '@zenstackhq/testtools';
+import { createTestClient, getTestDbProvider } from '@zenstackhq/testtools';
 import { afterEach, beforeEach, describe, expect, expectTypeOf, it } from 'vitest';
 import z from 'zod';
 import { schema } from '../schemas/basic';
 
 describe('Zod schema factory test', () => {
+    if (getTestDbProvider() !== 'sqlite') {
+        return;
+    }
+
     let client: ClientContract<typeof schema>;
 
     beforeEach(async () => {
@@ -1395,11 +1399,15 @@ describe('Zod schema factory test', () => {
 
     describe('create factory functions tests', () => {
         it('can be constructed directly from client', async () => {
-            const client = await createTestClient(schema);
-            const factory = createQuerySchemaFactory(client);
-            const s = factory.makeFindManySchema('User');
-            expect(s.safeParse({ where: { email: 'u@test.com' } }).success).toBe(true);
-            expect(s.safeParse({ where: { notAField: 'val' } }).success).toBe(false);
+            try {
+                const client = await createTestClient(schema);
+                const factory = createQuerySchemaFactory(client);
+                const s = factory.makeFindManySchema('User');
+                expect(s.safeParse({ where: { email: 'u@test.com' } }).success).toBe(true);
+                expect(s.safeParse({ where: { notAField: 'val' } }).success).toBe(false);
+            } finally {
+                await client.$disconnect();
+            }
         });
 
         it('can be constructed directly from schema and options and produces equivalent schemas', () => {