@zenstackhq/orm 3.0.0-beta.25 → 3.0.0-beta.27

package/dist/index.js

@@ -602,6 +602,7 @@ import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import Decimal from "decimal.js";
 import { sql as sql2 } from "kysely";
 import { match as match3 } from "ts-pattern";
+import z from "zod";
 
 // src/client/crud/dialects/base-dialect.ts
 import { enumerate, invariant as invariant2, isPlainObject } from "@zenstackhq/common-helpers";
@@ -1098,7 +1099,7 @@ var BaseCrudDialect = class {
       if (isRelationField(this.schema, model, field)) {
         continue;
       }
-      if (omit?.[field] === true) {
+      if (this.shouldOmitField(omit, model, field)) {
         continue;
       }
       result = this.buildSelectField(result, model, modelAlias, field);
@@ -1119,6 +1120,16 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  shouldOmitField(omit, model, field) {
+    if (omit && typeof omit === "object" && typeof omit[field] === "boolean") {
+      return omit[field];
+    }
+    if (this.options.omit?.[model] && typeof this.options.omit[model] === "object" && typeof this.options.omit[model][field] === "boolean") {
+      return this.options.omit[model][field];
+    }
+    const fieldDef = requireField(this.schema, model, field);
+    return !!fieldDef.omit;
+  }
   buildModelSelect(model, subQueryAlias, payload, selectAllFields) {
     let subQuery = this.buildSelectModel(model, subQueryAlias);
     if (selectAllFields) {
@@ -1261,6 +1272,10 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "PostgresCrudDialect");
   }
+  isoDateSchema = z.iso.datetime({
+    local: true,
+    offset: true
+  });
   constructor(schema, options) {
     super(schema, options);
   }
@@ -1309,7 +1324,12 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   }
   transformOutputDate(value) {
     if (typeof value === "string") {
-      return new Date(value);
+      if (this.isoDateSchema.safeParse(value).success) {
+        const hasOffset = value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+        return new Date(hasOffset ? value : `${value}Z`);
+      } else {
+        return value;
+      }
     } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
       return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
     } else {
@@ -1382,7 +1402,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       ]).flatMap((v) => v));
     }
     if (payload === true || !payload.select) {
-      objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
+      const omit = typeof payload === "object" ? payload.omit : void 0;
+      objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !this.shouldOmitField(omit, relationModel, name)).map(([field]) => [
         sql2.lit(field),
         this.fieldRef(relationModel, field, relationModelAlias, false)
       ]).flatMap((v) => v));
@@ -1593,7 +1614,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         ]).flatMap((v) => v));
       }
       if (payload === true || !payload.select) {
-        objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
+        const omit = typeof payload === "object" ? payload.omit : void 0;
+        objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !this.shouldOmitField(omit, relationModel, name)).map(([field]) => [
           sql3.lit(field),
           this.fieldRef(relationModel, field, subQueryName, false)
         ]).flatMap((v) => v));
@@ -3069,12 +3091,11 @@ var BaseOperationHandler = class {
     const allFields = Object.keys(modelDef.fields);
     const relationFields = Object.values(modelDef.fields).filter((f) => f.relation).map((f) => f.name);
     const computedFields = Object.values(modelDef.fields).filter((f) => f.computed).map((f) => f.name);
-    const omit = Object.entries(args.omit ?? {}).filter(([, v]) => v).map(([k]) => k);
     const allFieldsSelected = [];
     if (!args.select || typeof args.select !== "object") {
-      allFieldsSelected.push(...allFields.filter((f) => !relationFields.includes(f) && !omit.includes(f)));
+      allFieldsSelected.push(...allFields.filter((f) => !relationFields.includes(f) && !this.dialect.shouldOmitField(args.omit, model, f)));
     } else {
-      allFieldsSelected.push(...Object.entries(args.select).filter(([k, v]) => v && !omit.includes(k)).map(([k]) => k));
+      allFieldsSelected.push(...Object.entries(args.select).filter(([k, v]) => v && !this.dialect.shouldOmitField(args.omit, model, k)).map(([k]) => k));
     }
     if (allFieldsSelected.some((f) => relationFields.includes(f) || computedFields.includes(f))) {
       return {
@@ -3590,7 +3611,7 @@ import { enumerate as enumerate3, invariant as invariant7 } from "@zenstackhq/co
 import Decimal4 from "decimal.js";
 import stableStringify from "json-stable-stringify";
 import { match as match13, P as P3 } from "ts-pattern";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/utils/zod-utils.ts
 import { fromError } from "zod-validation-error/v4";
@@ -3603,7 +3624,7 @@ __name(formatError, "formatError");
 import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import Decimal3 from "decimal.js";
 import { match as match12, P as P2 } from "ts-pattern";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import { ZodIssueCode } from "zod/v3";
 function getArgValue(expr) {
   if (!expr || !schema_exports.ExpressionUtils.isLiteral(expr)) {
@@ -3712,13 +3733,13 @@ function addBigIntValidation(schema, attributes) {
 __name(addBigIntValidation, "addBigIntValidation");
 function addDecimalValidation(schema, attributes, addExtraValidation) {
   let result = schema;
-  if (schema instanceof z.ZodString) {
+  if (schema instanceof z2.ZodString) {
     result = schema.superRefine((v, ctx) => {
       try {
         new Decimal3(v);
       } catch (err) {
         ctx.addIssue({
-          code: z.ZodIssueCode.custom,
+          code: z2.ZodIssueCode.custom,
           message: `Invalid decimal: ${err}`
         });
       }
@@ -3726,7 +3747,7 @@ function addDecimalValidation(schema, attributes, addExtraValidation) {
   }
   function refine(schema2, op, value) {
     return schema2.superRefine((v, ctx) => {
-      const base = z.number();
+      const base = z2.number();
       const { error } = base[op](value).safeParse(v.toNumber());
       error?.issues.forEach((issue) => {
         if (op === "gt" || op === "gte") {
@@ -3931,7 +3952,7 @@ function evalCall(data, expr) {
     }
     invariant6(typeof fieldArg === "string", `"${f}" first argument must be a string`);
     const fn = match12(f).with("isEmail", () => "email").with("isUrl", () => "url").with("isDateTime", () => "datetime").exhaustive();
-    return z.string()[fn]().safeParse(fieldArg).success;
+    return z2.string()[fn]().safeParse(fieldArg).success;
   }).with(P2.union("has", "hasEvery", "hasSome"), (f) => {
     invariant6(expr.args?.[1], `${f} requires a search argument`);
     if (fieldArg === void 0 || fieldArg === null) {
@@ -3972,6 +3993,9 @@ var InputValidator = class {
   get schema() {
     return this.client.$schema;
   }
+  get options() {
+    return this.client.$options;
+  }
   get extraValidationsEnabled() {
     return this.client.$options.validateInput !== false;
   }
@@ -4066,7 +4090,7 @@ var InputValidator = class {
     if (!options.unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (options.findOne) {
-        fields["take"] = z2.literal(1).optional();
+        fields["take"] = z3.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
       }
@@ -4074,7 +4098,7 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    let result = z2.strictObject(fields);
+    let result = z3.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4088,19 +4112,19 @@ var InputValidator = class {
     } else if (this.schema.enums && type in this.schema.enums) {
       return this.makeEnumSchema(type);
     } else {
-      return match13(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z2.string(), attributes) : z2.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number()).with("Boolean", () => z2.boolean()).with("BigInt", () => z2.union([
-        this.extraValidationsEnabled ? addNumberValidation(z2.number().int(), attributes) : z2.number().int(),
-        this.extraValidationsEnabled ? addBigIntValidation(z2.bigint(), attributes) : z2.bigint()
+      return match13(type).with("String", () => this.extraValidationsEnabled ? addStringValidation(z3.string(), attributes) : z3.string()).with("Int", () => this.extraValidationsEnabled ? addNumberValidation(z3.number().int(), attributes) : z3.number().int()).with("Float", () => this.extraValidationsEnabled ? addNumberValidation(z3.number(), attributes) : z3.number()).with("Boolean", () => z3.boolean()).with("BigInt", () => z3.union([
+        this.extraValidationsEnabled ? addNumberValidation(z3.number().int(), attributes) : z3.number().int(),
+        this.extraValidationsEnabled ? addBigIntValidation(z3.bigint(), attributes) : z3.bigint()
       ])).with("Decimal", () => {
-        return z2.union([
-          this.extraValidationsEnabled ? addNumberValidation(z2.number(), attributes) : z2.number(),
-          addDecimalValidation(z2.instanceof(Decimal4), attributes, this.extraValidationsEnabled),
-          addDecimalValidation(z2.string(), attributes, this.extraValidationsEnabled)
+        return z3.union([
+          this.extraValidationsEnabled ? addNumberValidation(z3.number(), attributes) : z3.number(),
+          addDecimalValidation(z3.instanceof(Decimal4), attributes, this.extraValidationsEnabled),
+          addDecimalValidation(z3.string(), attributes, this.extraValidationsEnabled)
         ]);
-      }).with("DateTime", () => z2.union([
-        z2.date(),
-        z2.string().datetime()
-      ])).with("Bytes", () => z2.instanceof(Uint8Array)).otherwise(() => z2.unknown());
+      }).with("DateTime", () => z3.union([
+        z3.date(),
+        z3.string().datetime()
+      ])).with("Bytes", () => z3.instanceof(Uint8Array)).otherwise(() => z3.unknown());
     }
   }
   makeEnumSchema(type) {
@@ -4114,7 +4138,7 @@ var InputValidator = class {
     }
     const enumDef = getEnum(this.schema, type);
     invariant7(enumDef, `Enum "${type}" not found in schema`);
-    schema = z2.enum(Object.keys(enumDef.values));
+    schema = z3.enum(Object.keys(enumDef.values));
     this.setSchemaCache(key, schema);
     return schema;
   }
@@ -4130,7 +4154,7 @@ var InputValidator = class {
     }
     const typeDef = getTypeDef(this.schema, type);
     invariant7(typeDef, `Type definition "${type}" not found in schema`);
-    schema = z2.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+    schema = z3.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makePrimitiveSchema(def.type);
       if (def.array) {
         fieldSchema = fieldSchema.array();
@@ -4156,21 +4180,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = z3.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4196,7 +4220,7 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = z2.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+          fields[uniqueField.name] = z3.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
             invariant7(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
@@ -4204,7 +4228,7 @@ var InputValidator = class {
               if (Object.keys(enumDef.values).length > 0) {
                 fieldSchema = this.makeEnumFilterSchema(enumDef, !!def.optional, false);
               } else {
-                fieldSchema = z2.never();
+                fieldSchema = z3.never();
               }
             } else {
               fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
@@ -4217,11 +4241,11 @@ var InputValidator = class {
         }
       }
     }
-    fields["$expr"] = z2.custom((v) => typeof v === "function").optional();
-    fields["AND"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(z2.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z2.strictObject(fields);
+    fields["$expr"] = z3.custom((v) => typeof v === "function").optional();
+    fields["AND"] = this.orArray(z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["OR"] = z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
+    fields["NOT"] = this.orArray(z3.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    const baseWhere = z3.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4241,8 +4265,8 @@ var InputValidator = class {
     return result;
   }
   makeEnumFilterSchema(enumDef, optional, withAggregations) {
-    const baseSchema = z2.enum(Object.keys(enumDef.values));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
+    const baseSchema = z3.enum(Object.keys(enumDef.values));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.lazy(() => this.makeEnumFilterSchema(enumDef, optional, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -4252,41 +4276,41 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(components)
+      z3.strictObject(components)
     ]);
   }
   makeArrayFilterSchema(type) {
-    return z2.strictObject({
+    return z3.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
       hasSome: this.makePrimitiveSchema(type).array().optional(),
-      isEmpty: z2.boolean().optional()
+      isEmpty: z3.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional, withAggregations) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
       return this.makeTypeDefFilterSchema(type, optional);
     }
-    return match13(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => z2.any()).with("Unsupported", () => z2.never()).exhaustive();
+    return match13(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => z3.any()).with("Unsupported", () => z3.never()).exhaustive();
   }
   makeTypeDefFilterSchema(_type, _optional) {
-    return z2.never();
+    return z3.never();
   }
   makeDateTimeFilterSchema(optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(z2.union([
-      z2.string().datetime(),
-      z2.date()
-    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(z3.union([
+      z3.string().datetime(),
+      z3.date()
+    ]), optional, () => z3.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
       "_count",
       "_min",
       "_max"
     ] : void 0);
   }
   makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+    const components = this.makeCommonPrimitiveFilterComponents(z3.boolean(), optional, () => z3.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
       "equals",
       "not"
     ], withAggregations ? [
@@ -4294,14 +4318,14 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
-      this.nullableIf(z2.boolean(), optional),
-      z2.strictObject(components)
+    return z3.union([
+      this.nullableIf(z3.boolean(), optional),
+      z3.strictObject(components)
     ]);
   }
   makeBytesFilterSchema(optional, withAggregations) {
-    const baseSchema = z2.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.instanceof(Uint8Array), [
+    const baseSchema = z3.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z3.instanceof(Uint8Array), [
       "equals",
       "in",
       "notIn",
@@ -4311,9 +4335,9 @@ var InputValidator = class {
       "_min",
       "_max"
     ] : void 0);
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(components)
+      z3.strictObject(components)
     ]);
   }
   makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
@@ -4329,7 +4353,7 @@ var InputValidator = class {
       gte: baseSchema.optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(z2.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(z3.number().int(), false, false).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -4354,13 +4378,13 @@ var InputValidator = class {
     return result;
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return z2.union([
+    return z3.union([
       this.nullableIf(baseSchema, optional),
-      z2.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
+      z3.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z3.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
@@ -4369,17 +4393,17 @@ var InputValidator = class {
     ] : void 0);
   }
   makeStringFilterSchema(optional, withAggregations) {
-    return z2.union([
-      this.nullableIf(z2.string(), optional),
-      z2.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(z2.string(), optional, () => z2.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
+    return z3.union([
+      this.nullableIf(z3.string(), optional),
+      z3.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(z3.string(), optional, () => z3.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
           "_count",
           "_min",
           "_max"
         ] : void 0),
-        startsWith: z2.string().optional(),
-        endsWith: z2.string().optional(),
-        contains: z2.string().optional(),
+        startsWith: z3.string().optional(),
+        endsWith: z3.string().optional(),
+        contains: z3.string().optional(),
         ...this.providerSupportsCaseSensitivity ? {
           mode: this.makeStringModeSchema().optional()
         } : {}
@@ -4387,9 +4411,9 @@ var InputValidator = class {
     ]);
   }
   makeStringModeSchema() {
-    return z2.union([
-      z2.literal("default"),
-      z2.literal("insensitive")
+    return z3.union([
+      z3.literal("default"),
+      z3.literal("insensitive")
     ]);
   }
   makeSelectSchema(model) {
@@ -4400,26 +4424,26 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       } else {
-        fields[field] = z2.boolean().optional();
+        fields[field] = z3.boolean().optional();
       }
     }
     const _countSchema = this.makeCountSelectionSchema(modelDef);
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeCountSelectionSchema(modelDef) {
     const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
-      return z2.union([
-        z2.literal(true),
-        z2.strictObject({
-          select: z2.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+      return z3.union([
+        z3.literal(true),
+        z3.strictObject({
+          select: z3.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
             ...acc,
-            [fieldDef.name]: z2.union([
-              z2.boolean(),
-              z2.strictObject({
+            [fieldDef.name]: z3.union([
+              z3.boolean(),
+              z3.strictObject({
                 where: this.makeWhereSchema(fieldDef.type, false, false)
               })
             ]).optional()
@@ -4431,17 +4455,17 @@ var InputValidator = class {
     }
   }
   makeRelationSelectIncludeSchema(fieldDef) {
-    let objSchema = z2.strictObject({
+    let objSchema = z3.strictObject({
       ...fieldDef.array || fieldDef.optional ? {
         // to-many relations and optional to-one relations are filterable
-        where: z2.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        where: z3.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
       } : {},
-      select: z2.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
-      include: z2.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
-      omit: z2.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+      select: z3.lazy(() => this.makeSelectSchema(fieldDef.type)).optional().nullable(),
+      include: z3.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional().nullable(),
+      omit: z3.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
       ...fieldDef.array ? {
         // to-many relations can be ordered, skipped, taken, and cursor-located
-        orderBy: z2.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
+        orderBy: z3.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false), true)).optional(),
         skip: this.makeSkipSchema().optional(),
         take: this.makeTakeSchema().optional(),
         cursor: this.makeCursorSchema(fieldDef.type).optional(),
@@ -4450,8 +4474,8 @@ var InputValidator = class {
     });
     objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
     objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
-    return z2.union([
-      z2.boolean(),
+    return z3.union([
+      z3.boolean(),
       objSchema
     ]);
   }
@@ -4461,10 +4485,14 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
-        fields[field] = z2.boolean().optional();
+        if (this.options.allowQueryTimeOmitOverride !== false) {
+          fields[field] = z3.boolean().optional();
+        } else {
+          fields[field] = z3.literal(true).optional();
+        }
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4479,20 +4507,20 @@ var InputValidator = class {
     if (_countSchema) {
       fields["_count"] = _countSchema;
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = z2.union([
-      z2.literal("asc"),
-      z2.literal("desc")
+    const sort = z3.union([
+      z3.literal("asc"),
+      z3.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = z2.lazy(() => {
+          fields[field] = z3.lazy(() => {
             let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
             if (fieldDef.array) {
               relationOrderBy = relationOrderBy.extend({
@@ -4504,13 +4532,13 @@ var InputValidator = class {
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = z2.union([
+          fields[field] = z3.union([
             sort,
-            z2.strictObject({
+            z3.strictObject({
               sort,
-              nulls: z2.union([
-                z2.literal("first"),
-                z2.literal("last")
+              nulls: z3.union([
+                z3.literal("first"),
+                z3.literal("last")
               ])
             })
           ]).optional();
@@ -4528,15 +4556,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = z2.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = z3.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(z2.enum(nonRelationFields), true);
+    return this.orArray(z3.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -4545,7 +4573,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
@@ -4595,7 +4623,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -4621,9 +4649,9 @@ var InputValidator = class {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
         if (fieldDef.array) {
           fieldSchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.strictObject({
+            z3.strictObject({
               set: fieldSchema
             })
           ]).optional();
@@ -4640,19 +4668,19 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
+    const checkedCreateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return this.orArray(uncheckedCreateSchema, canBeArray);
     } else {
-      return z2.union([
+      return z3.union([
         uncheckedCreateSchema,
         checkedCreateSchema,
         ...canBeArray ? [
-          z2.array(uncheckedCreateSchema)
+          z3.array(uncheckedCreateSchema)
         ] : [],
         ...canBeArray ? [
-          z2.array(checkedCreateSchema)
+          z3.array(checkedCreateSchema)
         ] : []
       ]);
     }
@@ -4680,11 +4708,11 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(z2.strictObject({
+      fields["update"] = array ? this.orArray(z3.strictObject({
         where: this.makeWhereSchema(fieldType, true).optional(),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : z2.union([
-        z2.strictObject({
+      }), true).optional() : z3.union([
+        z3.strictObject({
           where: this.makeWhereSchema(fieldType, true).optional(),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
@@ -4694,21 +4722,21 @@ var InputValidator = class {
       if (!fieldDef.array) {
         upsertWhere = upsertWhere.optional();
       }
-      fields["upsert"] = this.orArray(z2.strictObject({
+      fields["upsert"] = this.orArray(z3.strictObject({
         where: upsertWhere,
         create: this.makeCreateDataSchema(fieldType, false, withoutFields),
         update: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional();
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
-        fields["updateMany"] = this.orArray(z2.strictObject({
+        fields["updateMany"] = this.orArray(z3.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z2.strictObject(fields);
+    return z3.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4720,36 +4748,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return z2.union([
-        z2.boolean(),
+      return z3.union([
+        z3.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z2.union([
-      z2.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : z3.union([
+      z3.boolean(),
       this.makeWhereSchema(model, uniqueFilter)
     ]);
   }
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(z2.strictObject({
+    return this.orArray(z3.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return z2.strictObject({
+    return z3.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: z2.boolean().optional()
+      skipDuplicates: z3.boolean().optional()
     });
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
@@ -4761,10 +4789,10 @@ var InputValidator = class {
     return schema;
   }
   makeUpdateManySchema(model) {
-    return z2.strictObject({
+    return z3.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: z2.number().int().nonnegative().optional()
+      limit: z3.number().int().nonnegative().optional()
     });
   }
   makeUpdateManyAndReturnSchema(model) {
@@ -4777,7 +4805,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -4812,7 +4840,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = z2.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = z3.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -4823,24 +4851,24 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type, fieldDef.attributes);
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             fieldSchema,
-            z2.object({
-              set: this.nullableIf(z2.number().optional(), !!fieldDef.optional).optional(),
-              increment: z2.number().optional(),
-              decrement: z2.number().optional(),
-              multiply: z2.number().optional(),
-              divide: z2.number().optional()
+            z3.object({
+              set: this.nullableIf(z3.number().optional(), !!fieldDef.optional).optional(),
+              increment: z3.number().optional(),
+              decrement: z3.number().optional(),
+              multiply: z3.number().optional(),
+              divide: z3.number().optional()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided')
           ]);
         }
         if (fieldDef.array) {
           const arraySchema = addListValidation(fieldSchema.array(), fieldDef.attributes);
-          fieldSchema = z2.union([
+          fieldSchema = z3.union([
             arraySchema,
-            z2.object({
+            z3.object({
               set: arraySchema.optional(),
-              push: z2.union([
+              push: z3.union([
                 fieldSchema,
                 fieldSchema.array()
               ]).optional()
@@ -4857,12 +4885,12 @@ var InputValidator = class {
         }
       }
     });
-    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(uncheckedVariantFields), modelDef.attributes) : z2.strictObject(uncheckedVariantFields);
-    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z2.strictObject(checkedVariantFields), modelDef.attributes) : z2.strictObject(checkedVariantFields);
+    const uncheckedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(uncheckedVariantFields), modelDef.attributes) : z3.strictObject(uncheckedVariantFields);
+    const checkedUpdateSchema = this.extraValidationsEnabled ? addCustomValidation(z3.strictObject(checkedVariantFields), modelDef.attributes) : z3.strictObject(checkedVariantFields);
     if (!hasRelation) {
       return uncheckedUpdateSchema;
     } else {
-      return z2.union([
+      return z3.union([
         uncheckedUpdateSchema,
         checkedUpdateSchema
       ]);
@@ -4871,25 +4899,26 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    let schema = z2.strictObject({
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
-      include: this.makeIncludeSchema(model).optional().nullable()
+      include: this.makeIncludeSchema(model).optional().nullable(),
+      omit: this.makeOmitSchema(model).optional().nullable()
     });
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
     return schema;
   }
   makeDeleteManySchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: z2.number().int().nonnegative().optional()
+      limit: z3.number().int().nonnegative().optional()
     }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4899,12 +4928,12 @@ var InputValidator = class {
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.union([
-      z2.literal(true),
-      z2.strictObject({
-        _all: z2.literal(true).optional(),
+    return z3.union([
+      z3.literal(true),
+      z3.strictObject({
+        _all: z3.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = z2.literal(true).optional();
+          acc[field] = z3.literal(true).optional();
           return acc;
         }, {})
       })
@@ -4913,7 +4942,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return z2.object({
+    return z3.object({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -4927,20 +4956,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z3.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z2.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z3.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = z2.literal(true).optional();
+        acc[field] = z3.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -4948,8 +4977,8 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    const bySchema = nonRelationFields.length > 0 ? this.orArray(z2.enum(nonRelationFields), true) : z2.never();
-    let schema = z2.strictObject({
+    const bySchema = nonRelationFields.length > 0 ? this.orArray(z3.enum(nonRelationFields), true) : z3.never();
+    let schema = z3.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -5016,10 +5045,10 @@ var InputValidator = class {
   // #endregion
   // #region Helpers
   makeSkipSchema() {
-    return z2.number().int().nonnegative();
+    return z3.number().int().nonnegative();
   }
   makeTakeSchema() {
-    return z2.number().int();
+    return z3.number().int();
   }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
@@ -5031,9 +5060,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? z2.union([
+    return canBeArray ? z3.union([
       schema,
-      z2.array(schema)
+      z3.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -6796,6 +6825,9 @@ var ClientImpl = class _ClientImpl {
   get $auth() {
     return this.auth;
   }
+  $setOptions(options) {
+    return new _ClientImpl(this.schema, options, this);
+  }
   $setInputValidation(enable) {
     const newOptions = {
       ...this.options,
@@ -7275,7 +7307,8 @@ var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
 // src/utils/schema-utils.ts
 var schema_utils_exports = {};
 __export(schema_utils_exports, {
-  ExpressionVisitor: () => ExpressionVisitor
+  ExpressionVisitor: () => ExpressionVisitor,
+  MatchingExpressionVisitor: () => MatchingExpressionVisitor
 });
 import { match as match17 } from "ts-pattern";
 var ExpressionVisitor = class {
@@ -7283,7 +7316,7 @@ var ExpressionVisitor = class {
     __name(this, "ExpressionVisitor");
   }
   visit(expr) {
-    match17(expr).with({
+    return match17(expr).with({
       kind: "literal"
     }, (e) => this.visitLiteral(e)).with({
       kind: "array"
@@ -7306,28 +7339,67 @@ var ExpressionVisitor = class {
   visitLiteral(_e) {
   }
   visitArray(e) {
-    e.items.forEach((item) => this.visit(item));
+    for (const item of e.items) {
+      const result = this.visit(item);
+      if (result?.abort) {
+        return result;
+      }
+    }
   }
   visitField(_e) {
   }
   visitMember(e) {
-    this.visit(e.receiver);
+    return this.visit(e.receiver);
   }
   visitBinary(e) {
-    this.visit(e.left);
-    this.visit(e.right);
+    const l = this.visit(e.left);
+    if (l?.abort) {
+      return l;
+    } else {
+      return this.visit(e.right);
+    }
   }
   visitUnary(e) {
-    this.visit(e.operand);
+    return this.visit(e.operand);
   }
   visitCall(e) {
-    e.args?.forEach((arg) => this.visit(arg));
+    for (const arg of e.args ?? []) {
+      const r = this.visit(arg);
+      if (r?.abort) {
+        return r;
+      }
+    }
   }
   visitThis(_e) {
   }
   visitNull(_e) {
   }
 };
+var MatchingExpressionVisitor = class extends ExpressionVisitor {
+  static {
+    __name(this, "MatchingExpressionVisitor");
+  }
+  predicate;
+  found = false;
+  constructor(predicate) {
+    super(), this.predicate = predicate;
+  }
+  find(expr) {
+    this.found = false;
+    this.visit(expr);
+    return this.found;
+  }
+  visit(expr) {
+    if (this.predicate(expr)) {
+      this.found = true;
+      return {
+        abort: true
+      };
+    } else {
+      return super.visit(expr);
+    }
+  }
+};
 export {
   BaseCrudDialect,
   CRUD,