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

package/dist/index.cjs

@@ -234,23 +234,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) {
@@ -731,7 +731,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 || !(0, import_common_helpers.isPlainObject)(payload)) {
       return {
         conditions: [
@@ -746,6 +746,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 = (0, import_ts_pattern.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
@@ -779,21 +782,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 = (0, import_ts_pattern.match)(key).with("contains", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.lit(`%${value}%`))).with("startsWith", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.lit(`${value}%`))).with("endsWith", () => insensitive ? eb(fieldRef, "ilike", import_kysely.sql.lit(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.lit(`%${value}`))).otherwise(() => {
-          throw new Error(`Invalid string filter key: ${key}`);
+        const condition = (0, import_ts_pattern.match)(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}`))).otherwise(() => {
+          throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -802,15 +804,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 : import_kysely.sql.val(value);
+    }
     if (typeof value === "string") {
-      return toLower ? eb.fn("lower", [
-        import_kysely.sql.lit(value)
-      ]) : import_kysely.sql.lit(value);
+      return eb.fn("lower", [
+        import_kysely.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 : import_kysely.sql.lit(value);
+      return value === null ? null : import_kysely.sql.val(value);
     }
   }
   buildNumberFilter(eb, fieldRef, type, payload) {
@@ -972,6 +977,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) {
@@ -1100,7 +1131,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);
@@ -1116,20 +1147,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 [
-          import_kysely2.sql.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 [
+            import_kysely2.sql.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 [
+            import_kysely2.sql.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]) => [
         import_kysely2.sql.lit(field),
         // reference the synthesized JSON field
-        eb.ref(`${parentName}$${relationField}$${field}.$j`)
+        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
       ]).flatMap((v) => v));
     }
     return objArgs;
@@ -1182,6 +1221,9 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
     }
   }
+  get supportInsertWithDefault() {
+    return true;
+  }
 };
 
 // src/client/crud/dialects/sqlite.ts
@@ -1212,11 +1254,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);
@@ -1240,14 +1282,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         (0, import_common_helpers3.invariant)(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}`);
           }
         });
       }
@@ -1269,24 +1311,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 [
               import_kysely3.sql.lit(field),
               subJson
             ];
           } else {
-            return [
-              import_kysely3.sql.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 [
+                import_kysely3.sql.lit(field),
+                subJson
+              ];
+            } else {
+              return [
+                import_kysely3.sql.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 [
             import_kysely3.sql.lit(field),
             subJson
@@ -1336,6 +1386,9 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   buildArrayLiteralSQL(_values) {
     throw new Error("SQLite does not support array literals");
   }
+  get supportInsertWithDefault() {
+    return false;
+  }
 };
 
 // src/client/crud/dialects/index.ts
@@ -2695,6 +2748,7 @@ var BaseOperationHandler = class {
         query = query.distinctOn(distinct.map((f) => import_kysely8.sql.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) {
@@ -2732,13 +2786,16 @@ ${compiled.parameters.map((p) => (0, import_node_util.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;
   }
@@ -2776,32 +2833,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.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 = (0, import_kysely8.expressionBuilder)();
-    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) {
@@ -3108,6 +3140,29 @@ ${compiled.parameters.map((p) => (0, import_node_util.inspect)(p)).join("\n")}`;
       }
       return this.fillGeneratedValues(modelDef, newItem);
     });
+    if (!this.dialect.supportInsertWithDefault) {
+      const allPassedFields = createData.reduce((acc, item) => {
+        Object.keys(item).forEach((field) => {
+          if (!acc.includes(field)) {
+            acc.push(field);
+          }
+        });
+        return acc;
+      }, []);
+      for (const item of createData) {
+        if (Object.keys(item).length === allPassedFields.length) {
+          continue;
+        }
+        for (const field of allPassedFields) {
+          if (!(field in item)) {
+            const fieldDef = this.requireField(model, field);
+            if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") {
+              item[field] = this.dialect.transformPrimitive(fieldDef.default, fieldDef.type, !!fieldDef.array);
+            }
+          }
+        }
+      }
+    }
     if (modelDef.baseModel) {
       if (input.skipDuplicates) {
         throw new QueryError('"skipDuplicates" options is not supported for polymorphic models');
@@ -4504,11 +4559,11 @@ var InputValidator = class {
     fields["distinct"] = this.makeDistinctSchema(model).optional();
     fields["cursor"] = this.makeCursorSchema(model).optional();
     if (options.collection) {
-      fields["skip"] = import_zod.z.number().int().nonnegative().optional();
-      fields["take"] = import_zod.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 = import_zod.z.object(fields).strict();
+    let result = import_zod.z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4575,7 +4630,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = import_zod.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
@@ -4584,7 +4639,7 @@ var InputValidator = class {
         } else {
           fieldSchema = import_zod.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4635,7 +4690,7 @@ var InputValidator = class {
     fields["AND"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
     fields["OR"] = import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
     fields["NOT"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = import_zod.z.object(fields).strict();
+    const baseWhere = import_zod.z.strictObject(fields);
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4659,7 +4714,7 @@ var InputValidator = class {
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
+      import_zod.z.strictObject({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4668,7 +4723,7 @@ var InputValidator = class {
     ]);
   }
   makeArrayFilterSchema(type) {
-    return import_zod.z.object({
+    return import_zod.z.strictObject({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
@@ -4694,7 +4749,7 @@ var InputValidator = class {
   makeBooleanFilterSchema(optional) {
     return import_zod.z.union([
       this.nullableIf(import_zod.z.boolean(), optional),
-      import_zod.z.object({
+      import_zod.z.strictObject({
         equals: this.nullableIf(import_zod.z.boolean(), optional).optional(),
         not: import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
       })
@@ -4705,7 +4760,7 @@ var InputValidator = class {
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array));
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
+      import_zod.z.strictObject({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4729,14 +4784,31 @@ var InputValidator = class {
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis) {
     return import_zod.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      import_zod.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional) {
     return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
   }
   makeStringFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional)));
+    return import_zod.z.union([
+      this.nullableIf(import_zod.z.string(), optional),
+      import_zod.z.strictObject({
+        ...this.makeCommonPrimitiveFilterComponents(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional))),
+        startsWith: import_zod.z.string().optional(),
+        endsWith: import_zod.z.string().optional(),
+        contains: import_zod.z.string().optional(),
+        ...this.providerSupportsCaseSensitivity ? {
+          mode: this.makeStringModeSchema().optional()
+        } : {}
+      })
+    ]);
+  }
+  makeStringModeSchema() {
+    return import_zod.z.union([
+      import_zod.z.literal("default"),
+      import_zod.z.literal("insensitive")
+    ]);
   }
   makeSelectSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4746,7 +4818,7 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = import_zod.z.union([
           import_zod.z.literal(true),
-          import_zod.z.object({
+          import_zod.z.strictObject({
             select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
           })
@@ -4755,22 +4827,24 @@ var InputValidator = class {
         fields[field] = import_zod.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"] = import_zod.z.union([
         import_zod.z.literal(true),
-        import_zod.z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
-          ...acc,
-          [name]: import_zod.z.union([
-            import_zod.z.boolean(),
-            import_zod.z.object({
-              where: this.makeWhereSchema(fieldDef.type, false, false)
-            })
-          ]).optional()
-        }), {}))
+        import_zod.z.strictObject({
+          select: import_zod.z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+            ...acc,
+            [fieldDef.name]: import_zod.z.union([
+              import_zod.z.boolean(),
+              import_zod.z.strictObject({
+                where: this.makeWhereSchema(fieldDef.type, false, false)
+              })
+            ]).optional()
+          }), {}))
+        })
       ]).optional();
     }
-    return import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4781,7 +4855,7 @@ var InputValidator = class {
         fields[field] = import_zod.z.boolean().optional();
       }
     }
-    return import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4791,15 +4865,20 @@ var InputValidator = class {
       if (fieldDef.relation) {
         fields[field] = import_zod.z.union([
           import_zod.z.literal(true),
-          import_zod.z.object({
+          import_zod.z.strictObject({
             select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
             include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+            omit: import_zod.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
+            orderBy: import_zod.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 import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
@@ -4812,13 +4891,21 @@ var InputValidator = class {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = import_zod.z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
+          fields[field] = import_zod.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] = import_zod.z.union([
             sort,
-            import_zod.z.object({
+            import_zod.z.strictObject({
               sort,
               nulls: import_zod.z.union([
                 import_zod.z.literal("first"),
@@ -4843,7 +4930,7 @@ var InputValidator = class {
         fields[agg] = import_zod.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod.z.object(fields);
+    return import_zod.z.strictObject(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4862,7 +4949,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) {
@@ -4870,7 +4957,7 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_zod.z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -4932,7 +5019,7 @@ var InputValidator = class {
         if (fieldDef.array) {
           fieldSchema = import_zod.z.union([
             import_zod.z.array(fieldSchema),
-            import_zod.z.object({
+            import_zod.z.strictObject({
               set: import_zod.z.array(fieldSchema)
             })
           ]).optional();
@@ -4950,16 +5037,16 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return this.orArray(import_zod.z.object(uncheckedVariantFields).strict(), canBeArray);
+      return this.orArray(import_zod.z.strictObject(uncheckedVariantFields), canBeArray);
     } else {
       return import_zod.z.union([
-        import_zod.z.object(uncheckedVariantFields).strict(),
-        import_zod.z.object(checkedVariantFields).strict(),
+        import_zod.z.strictObject(uncheckedVariantFields),
+        import_zod.z.strictObject(checkedVariantFields),
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(uncheckedVariantFields).strict())
+          import_zod.z.array(import_zod.z.strictObject(uncheckedVariantFields))
         ] : [],
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(checkedVariantFields).strict())
+          import_zod.z.array(import_zod.z.strictObject(checkedVariantFields))
         ] : []
       ]);
     }
@@ -4987,31 +5074,31 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(import_zod.z.object({
+      fields["update"] = array ? this.orArray(import_zod.z.strictObject({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional() : import_zod.z.union([
-        import_zod.z.object({
+        import_zod.z.strictObject({
           where: this.makeWhereSchema(fieldType, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
       ]).optional();
-      fields["upsert"] = this.orArray(import_zod.z.object({
+      fields["upsert"] = this.orArray(import_zod.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(import_zod.z.object({
+        fields["updateMany"] = this.orArray(import_zod.z.strictObject({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_zod.z.object(fields).strict();
+    return import_zod.z.strictObject(fields);
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -5041,13 +5128,13 @@ var InputValidator = class {
     return this.orArray(import_zod.z.object({
       where: whereSchema,
       create: createSchema
-    }).strict(), canBeArray);
+    }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
     return import_zod.z.object({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: import_zod.z.boolean().optional()
-    }).strict();
+    });
   }
   // #endregion
   // #region Update
@@ -5058,7 +5145,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) {
@@ -5066,11 +5153,11 @@ var InputValidator = class {
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
       limit: import_zod.z.number().int().nonnegative().optional()
-    }).strict();
+    });
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_zod.z.strictObject({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -5084,7 +5171,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) {
@@ -5151,11 +5238,11 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return import_zod.z.object(uncheckedVariantFields).strict();
+      return import_zod.z.strictObject(uncheckedVariantFields);
     } else {
       return import_zod.z.union([
-        import_zod.z.object(uncheckedVariantFields).strict(),
-        import_zod.z.object(checkedVariantFields).strict()
+        import_zod.z.strictObject(uncheckedVariantFields),
+        import_zod.z.strictObject(checkedVariantFields)
       ]);
     }
   }
@@ -5166,25 +5253,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 import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       limit: import_zod.z.number().int().nonnegative().optional()
-    }).strict().optional();
+    }).optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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);
@@ -5196,7 +5283,7 @@ var InputValidator = class {
           acc[field] = import_zod.z.literal(true).optional();
           return acc;
         }, {})
-      }).strict()
+      })
     ]);
   }
   // #endregion
@@ -5204,19 +5291,19 @@ var InputValidator = class {
   makeAggregateSchema(model) {
     return import_zod.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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 import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
         acc[field] = import_zod.z.literal(true).optional();
@@ -5226,7 +5313,7 @@ var InputValidator = class {
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_zod.z.strictObject(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
         acc[field] = import_zod.z.literal(true).optional();
@@ -5242,14 +5329,14 @@ var InputValidator = class {
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(import_zod.z.enum(nonRelationFields), true),
       having: this.makeWhereSchema(model, false, true).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.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
@@ -5274,6 +5361,12 @@ var InputValidator = class {
   }
   // #endregion
   // #region Helpers
+  makeSkipSchema() {
+    return import_zod.z.number().int().nonnegative();
+  }
+  makeTakeSchema() {
+    return import_zod.z.number().int();
+  }
   refineForSelectIncludeMutuallyExclusive(schema) {
     return schema.refine((value) => !(value["select"] && value["include"]), '"select" and "include" cannot be used together');
   }
@@ -5292,6 +5385,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