@zenstackhq/runtime 3.0.0-alpha.18 → 3.0.0-alpha.19

package/dist/index.js

@@ -199,23 +199,23 @@ function getRelationForeignKeyFieldPairs(schema, model, relationField) {
 }
 __name(getRelationForeignKeyFieldPairs, "getRelationForeignKeyFieldPairs");
 function isScalarField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !fieldDef.relation && !fieldDef.foreignKeyFor;
+  const fieldDef = getField(schema, model, field);
+  return !fieldDef?.relation && !fieldDef?.foreignKeyFor;
 }
 __name(isScalarField, "isScalarField");
 function isForeignKeyField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !!fieldDef.foreignKeyFor;
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.foreignKeyFor;
 }
 __name(isForeignKeyField, "isForeignKeyField");
 function isRelationField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !!fieldDef.relation;
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.relation;
 }
 __name(isRelationField, "isRelationField");
 function isInheritedField(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  return !!fieldDef.originModel;
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.originModel;
 }
 __name(isInheritedField, "isInheritedField");
 function getUniqueFields(schema, model) {
@@ -696,7 +696,7 @@ var BaseCrudDialect = class {
   buildLiteralFilter(eb, lhs, type, rhs) {
     return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
   }
-  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0) {
+  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
     if (payload === null || !isPlainObject(payload)) {
       return {
         conditions: [
@@ -711,6 +711,9 @@ var BaseCrudDialect = class {
       if (onlyForKeys && !onlyForKeys.includes(op)) {
         continue;
       }
+      if (excludeKeys.includes(op)) {
+        continue;
+      }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
       const condition = match(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         invariant(Array.isArray(rhs), "right hand side must be an array");
@@ -744,21 +747,20 @@ var BaseCrudDialect = class {
     };
   }
   buildStringFilter(eb, fieldRef, payload) {
-    let insensitive = false;
-    if (payload && typeof payload === "object" && "mode" in payload && payload.mode === "insensitive") {
-      insensitive = true;
-      fieldRef = eb.fn("lower", [
-        fieldRef
-      ]);
+    let mode;
+    if (payload && typeof payload === "object" && "mode" in payload) {
+      mode = payload.mode;
     }
-    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, fieldRef, value));
+    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, mode === "insensitive" ? eb.fn("lower", [
+      fieldRef
+    ]) : fieldRef, (value) => this.prepStringCasing(eb, value, mode), (value) => this.buildStringFilter(eb, fieldRef, value));
     if (payload && typeof payload === "object") {
       for (const [key, value] of Object.entries(payload)) {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match(key).with("contains", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}%`)) : eb(fieldRef, "like", sql.lit(`%${value}%`))).with("startsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`${value}%`)) : eb(fieldRef, "like", sql.lit(`${value}%`))).with("endsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}`)) : eb(fieldRef, "like", sql.lit(`%${value}`))).otherwise(() => {
-          throw new Error(`Invalid string filter key: ${key}`);
+        const condition = match(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
+          throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -767,15 +769,18 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...conditions);
   }
-  prepStringCasing(eb, value, toLower = true) {
+  prepStringCasing(eb, value, mode) {
+    if (!mode || mode === "default") {
+      return value === null ? value : sql.val(value);
+    }
     if (typeof value === "string") {
-      return toLower ? eb.fn("lower", [
-        sql.lit(value)
-      ]) : sql.lit(value);
+      return eb.fn("lower", [
+        sql.val(value)
+      ]);
     } else if (Array.isArray(value)) {
-      return value.map((v) => this.prepStringCasing(eb, v, toLower));
+      return value.map((v) => this.prepStringCasing(eb, v, mode));
     } else {
-      return value === null ? null : sql.lit(value);
+      return value === null ? null : sql.val(value);
     }
   }
   buildNumberFilter(eb, fieldRef, type, payload) {
@@ -937,6 +942,32 @@ var BaseCrudDialect = class {
     });
     return query;
   }
+  buildCountJson(model, eb, parentAlias, payload) {
+    const modelDef = requireModel(this.schema, model);
+    const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);
+    const selections = payload === true ? {
+      select: toManyRelations.reduce((acc, [field]) => {
+        acc[field] = true;
+        return acc;
+      }, {})
+    } : payload;
+    const jsonObject = {};
+    for (const [field, value] of Object.entries(selections.select)) {
+      const fieldDef = requireField(this.schema, model, field);
+      const fieldModel = fieldDef.type;
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+      let fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
+      for (const [left, right] of joinPairs) {
+        fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
+      }
+      if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
+        const filter = this.buildFilter(eb, fieldModel, fieldModel, value.where);
+        fieldCountQuery = fieldCountQuery.where(filter);
+      }
+      jsonObject[field] = fieldCountQuery;
+    }
+    return this.buildJsonObject(eb, jsonObject);
+  }
   // #endregion
   // #region utils
   negateSort(sort, negated) {
@@ -1065,7 +1096,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName) {
+  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentAlias) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
     const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
@@ -1081,20 +1112,28 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         buildFieldRef(this.schema, relationModel, field, this.options, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => {
-        const fieldDef = requireField(this.schema, relationModel, field);
-        const fieldValue = fieldDef.relation ? eb.ref(`${parentName}$${relationField}$${field}.$j`) : buildFieldRef(this.schema, relationModel, field, this.options, eb);
-        return [
-          sql2.lit(field),
-          fieldValue
-        ];
+      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
+        if (field === "_count") {
+          const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
+          return [
+            sql2.lit(field),
+            subJson
+          ];
+        } else {
+          const fieldDef = requireField(this.schema, relationModel, field);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : buildFieldRef(this.schema, relationModel, field, this.options, eb);
+          return [
+            sql2.lit(field),
+            fieldValue
+          ];
+        }
       }).flatMap((v) => v));
     }
     if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         sql2.lit(field),
         // reference the synthesized JSON field
-        eb.ref(`${parentName}$${relationField}$${field}.$j`)
+        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
       ]).flatMap((v) => v));
     }
     return objArgs;
@@ -1180,11 +1219,11 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     return query.select((eb) => this.buildRelationJSON(model, eb, relationField, parentAlias, payload).as(relationField));
   }
-  buildRelationJSON(model, eb, relationField, parentName, payload) {
+  buildRelationJSON(model, eb, relationField, parentAlias, payload) {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
-    const subQueryName = `${parentName}$${relationField}`;
+    const subQueryName = `${parentAlias}$${relationField}`;
     let tbl = eb.selectFrom(() => {
       let subQuery = this.buildSelectModel(eb, relationModel);
       subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
@@ -1208,14 +1247,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         invariant3(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         invariant3(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
         keyPairs.forEach(({ fk, pk }) => {
           if (ownedByModel) {
-            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentName}.${fk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentAlias}.${fk}`);
           } else {
-            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentName}.${pk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentAlias}.${pk}`);
           }
         });
       }
@@ -1237,24 +1276,32 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         ]).flatMap((v) => v));
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
-          const fieldDef = requireField(this.schema, relationModel, field);
-          if (fieldDef.relation) {
-            const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          if (field === "_count") {
+            const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
             return [
               sql3.lit(field),
               subJson
             ];
           } else {
-            return [
-              sql3.lit(field),
-              buildFieldRef(this.schema, relationModel, field, this.options, eb)
-            ];
+            const fieldDef = requireField(this.schema, relationModel, field);
+            if (fieldDef.relation) {
+              const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
+              return [
+                sql3.lit(field),
+                subJson
+              ];
+            } else {
+              return [
+                sql3.lit(field),
+                buildFieldRef(this.schema, relationModel, field, this.options, eb)
+              ];
+            }
           }
         }).flatMap((v) => v));
       }
       if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
         objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
-          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
           return [
             sql3.lit(field),
             subJson
@@ -2666,6 +2713,7 @@ var BaseOperationHandler = class {
         query = query.distinctOn(distinct.map((f) => sql4.ref(`${model}.${f}`)));
       } else {
         inMemoryDistinct = distinct;
+        query = distinct.reduce((acc, field) => acc.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(`$distinct$${field}`)), query);
       }
     }
     if (args && "select" in args && args.select) {
@@ -2703,13 +2751,16 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
       const distinctResult = [];
       const seen = /* @__PURE__ */ new Set();
       for (const r of result) {
-        const key = safeJSONStringify(inMemoryDistinct.map((f) => r[f]));
+        const key = safeJSONStringify(inMemoryDistinct.map((f) => r[`$distinct$${f}`]));
         if (!seen.has(key)) {
           distinctResult.push(r);
           seen.add(key);
         }
       }
       result = distinctResult;
+      for (const r of result) {
+        Object.keys(r).filter((k) => k.startsWith("$distinct$")).forEach((k) => delete r[k]);
+      }
     }
     return result;
   }
@@ -2747,32 +2798,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
     return result;
   }
   buildCountSelection(query, model, parentAlias, payload) {
-    const modelDef = requireModel(this.schema, model);
-    const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);
-    const selections = payload === true ? {
-      select: toManyRelations.reduce((acc, [field]) => {
-        acc[field] = true;
-        return acc;
-      }, {})
-    } : payload;
-    const eb = expressionBuilder2();
-    const jsonObject = {};
-    for (const [field, value] of Object.entries(selections.select)) {
-      const fieldDef = requireField(this.schema, model, field);
-      const fieldModel = fieldDef.type;
-      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
-      let fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
-      for (const [left, right] of joinPairs) {
-        fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
-      }
-      if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
-        const filter = this.dialect.buildFilter(eb, fieldModel, fieldModel, value.where);
-        fieldCountQuery = fieldCountQuery.where(filter);
-      }
-      jsonObject[field] = fieldCountQuery;
-    }
-    query = query.select((eb2) => this.dialect.buildJsonObject(eb2, jsonObject).as("_count"));
-    return query;
+    return query.select((eb) => this.dialect.buildCountJson(model, eb, parentAlias, payload).as("_count"));
   }
   buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
     if (!orderBy) {
@@ -4498,11 +4524,11 @@ var InputValidator = class {
     fields["distinct"] = this.makeDistinctSchema(model).optional();
     fields["cursor"] = this.makeCursorSchema(model).optional();
     if (options.collection) {
-      fields["skip"] = z.number().int().nonnegative().optional();
-      fields["take"] = z.number().int().optional();
+      fields["skip"] = this.makeSkipSchema().optional();
+      fields["take"] = this.makeTakeSchema().optional();
       fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false), true).optional();
     }
-    let result = z.object(fields).strict();
+    let result = z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4569,7 +4595,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = z.union([
             fieldSchema,
-            z.object({
+            z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
@@ -4578,7 +4604,7 @@ var InputValidator = class {
         } else {
           fieldSchema = z.union([
             fieldSchema,
-            z.object({
+            z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4629,7 +4655,7 @@ var InputValidator = class {
     fields["AND"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
     fields["OR"] = z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
     fields["NOT"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = z.object(fields).strict();
+    const baseWhere = z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4653,7 +4679,7 @@ var InputValidator = class {
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
     return z.union([
       this.nullableIf(baseSchema, optional),
-      z.object({
+      z.strictObject({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4662,7 +4688,7 @@ var InputValidator = class {
     ]);
   }
   makeArrayFilterSchema(type) {
-    return z.object({
+    return z.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
@@ -4688,7 +4714,7 @@ var InputValidator = class {
   makeBooleanFilterSchema(optional) {
     return z.union([
       this.nullableIf(z.boolean(), optional),
-      z.object({
+      z.strictObject({
         equals: this.nullableIf(z.boolean(), optional).optional(),
         not: z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
       })
@@ -4699,7 +4725,7 @@ var InputValidator = class {
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array));
     return z.union([
       this.nullableIf(baseSchema, optional),
-      z.object({
+      z.strictObject({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4723,14 +4749,31 @@ var InputValidator = class {
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis) {
     return z.union([
       this.nullableIf(baseSchema, optional),
-      z.object(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional) {
     return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
   }
   makeStringFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional)));
+    return z.union([
+      this.nullableIf(z.string(), optional),
+      z.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional))),
+        startsWith: z.string().optional(),
+        endsWith: z.string().optional(),
+        contains: z.string().optional(),
+        ...this.providerSupportsCaseSensitivity ? {
+          mode: this.makeStringModeSchema().optional()
+        } : {}
+      })
+    ]);
+  }
+  makeStringModeSchema() {
+    return z.union([
+      z.literal("default"),
+      z.literal("insensitive")
+    ]);
   }
   makeSelectSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4740,7 +4783,7 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = z.union([
           z.literal(true),
-          z.object({
+          z.strictObject({
             select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
           })
@@ -4749,22 +4792,24 @@ var InputValidator = class {
         fields[field] = z.boolean().optional();
       }
     }
-    const toManyRelations = Object.entries(modelDef.fields).filter(([, value]) => value.relation && value.array);
+    const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
     if (toManyRelations.length > 0) {
       fields["_count"] = z.union([
         z.literal(true),
-        z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
-          ...acc,
-          [name]: z.union([
-            z.boolean(),
-            z.object({
-              where: this.makeWhereSchema(fieldDef.type, false, false)
-            })
-          ]).optional()
-        }), {}))
+        z.strictObject({
+          select: z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+            ...acc,
+            [fieldDef.name]: z.union([
+              z.boolean(),
+              z.strictObject({
+                where: this.makeWhereSchema(fieldDef.type, false, false)
+              })
+            ]).optional()
+          }), {}))
+        })
       ]).optional();
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4775,7 +4820,7 @@ var InputValidator = class {
         fields[field] = z.boolean().optional();
       }
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4785,15 +4830,20 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = z.union([
           z.literal(true),
-          z.object({
+          z.strictObject({
             select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+            omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+            where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
+            orderBy: z.lazy(() => this.makeOrderBySchema(fieldDef.type, true, false)).optional(),
+            skip: this.makeSkipSchema().optional(),
+            take: this.makeTakeSchema().optional(),
+            distinct: this.makeDistinctSchema(fieldDef.type).optional()
           })
         ]).optional();
       }
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
@@ -4806,13 +4856,21 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
+          fields[field] = z.lazy(() => {
+            let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation);
+            if (fieldDef.array) {
+              relationOrderBy = relationOrderBy.extend({
+                _count: sort
+              });
+            }
+            return relationOrderBy.optional();
+          });
         }
       } else {
         if (fieldDef.optional) {
           fields[field] = z.union([
             sort,
-            z.object({
+            z.strictObject({
               sort,
               nulls: z.union([
                 z.literal("first"),
@@ -4837,7 +4895,7 @@ var InputValidator = class {
         fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return z.object(fields);
+    return z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4856,7 +4914,7 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeCreateManySchema(model) {
@@ -4864,7 +4922,7 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(z.object({
+    const result = base.merge(z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -4926,7 +4984,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = z.union([
             z.array(fieldSchema),
-            z.object({
+            z.strictObject({
               set: z.array(fieldSchema)
             })
           ]).optional();
@@ -4944,16 +5002,16 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return this.orArray(z.object(uncheckedVariantFields).strict(), canBeArray);
+      return this.orArray(z.strictObject(uncheckedVariantFields), canBeArray);
     } else {
       return z.union([
-        z.object(uncheckedVariantFields).strict(),
-        z.object(checkedVariantFields).strict(),
+        z.strictObject(uncheckedVariantFields),
+        z.strictObject(checkedVariantFields),
         ...canBeArray ? [
-          z.array(z.object(uncheckedVariantFields).strict())
+          z.array(z.strictObject(uncheckedVariantFields))
         ] : [],
         ...canBeArray ? [
-          z.array(z.object(checkedVariantFields).strict())
+          z.array(z.strictObject(checkedVariantFields))
         ] : []
       ]);
     }
@@ -4981,31 +5039,31 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(z.object({
+      fields["update"] = array ? this.orArray(z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional() : z.union([
-        z.object({
+        z.strictObject({
           where: this.makeWhereSchema(fieldType, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
       ]).optional();
-      fields["upsert"] = this.orArray(z.object({
+      fields["upsert"] = this.orArray(z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         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(z.object({
+        fields["updateMany"] = this.orArray(z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return z.object(fields).strict();
+    return z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -5035,13 +5093,13 @@ var InputValidator = class {
     return this.orArray(z.object({
       where: whereSchema,
       create: createSchema
-    }).strict(), canBeArray);
+    }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
     return z.object({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: z.boolean().optional()
-    }).strict();
+    });
   }
   // #endregion
   // #region Update
@@ -5052,7 +5110,7 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateManySchema(model) {
@@ -5060,11 +5118,11 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
       limit: z.number().int().nonnegative().optional()
-    }).strict();
+    });
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(z.object({
+    const result = base.merge(z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -5078,7 +5136,7 @@ var InputValidator = class {
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateDataSchema(model, withoutFields = [], withoutRelationFields = false) {
@@ -5145,11 +5203,11 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return z.object(uncheckedVariantFields).strict();
+      return z.strictObject(uncheckedVariantFields);
     } else {
       return z.union([
-        z.object(uncheckedVariantFields).strict(),
-        z.object(checkedVariantFields).strict()
+        z.strictObject(uncheckedVariantFields),
+        z.strictObject(checkedVariantFields)
       ]);
     }
   }
@@ -5160,25 +5218,25 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional()
-    }).strict();
+    });
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeDeleteManySchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
       limit: z.number().int().nonnegative().optional()
-    }).strict().optional();
+    }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       select: this.makeCountAggregateInputSchema(model).optional()
-    }).strict().optional();
+    }).optional();
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -5190,7 +5248,7 @@ var InputValidator = class {
           acc[field] = z.literal(true).optional();
           return acc;
         }, {})
-      }).strict()
+      })
     ]);
   }
   // #endregion
@@ -5198,19 +5256,19 @@ var InputValidator = class {
   makeAggregateSchema(model) {
     return z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
-    }).strict().optional();
+    }).optional();
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
         acc[field] = z.literal(true).optional();
@@ -5220,7 +5278,7 @@ var InputValidator = class {
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = z.literal(true).optional();
@@ -5236,14 +5294,14 @@ var InputValidator = class {
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(z.enum(nonRelationFields), true),
       having: this.makeWhereSchema(model, false, true).optional(),
-      skip: z.number().int().nonnegative().optional(),
-      take: z.number().int().optional(),
+      skip: this.makeSkipSchema().optional(),
+      take: this.makeTakeSchema().optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
-    }).strict();
+    });
     schema = schema.refine((value) => {
       const bys = typeof value.by === "string" ? [
         value.by
@@ -5268,6 +5326,12 @@ var InputValidator = class {
   }
   // #endregion
   // #region Helpers
+  makeSkipSchema() {
+    return z.number().int().nonnegative();
+  }
+  makeTakeSchema() {
+    return z.number().int();
+  }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
   }
@@ -5286,6 +5350,9 @@ var InputValidator = class {
   isNumericField(fieldDef) {
     return NUMERIC_FIELD_TYPES.includes(fieldDef.type) && !fieldDef.array;
   }
+  get providerSupportsCaseSensitivity() {
+    return this.schema.provider.type === "postgresql";
+  }
 };
 
 // src/client/executor/zenstack-driver.ts