@stryke/prisma-trpc-generator 0.13.49 → 0.13.51

package/dist/zod/transformer.cjs

@@ -1,21 +1,436 @@
-const e=require(`../_virtual/rolldown_runtime.cjs`),t=require(`../packages/string-format/src/lower-case-first.cjs`),n=require(`../packages/string-format/src/upper-case-first.cjs`),r=require(`./model-helpers.cjs`),i=require(`../utils/write-file-safely.cjs`),a=require(`./aggregate-helpers.cjs`),o=require(`./mongodb-helpers.cjs`);let s=require(`node:path`);s=e.__toESM(s);var c=class e{name;fields;schemaImports=new Set;models;modelOperations;aggregateOperationSupport;enumTypes;static enumNames=[];static rawOpsMap={};static provider;static previewFeatures;static outputPath=`./generated`;hasJson=!1;static prismaClientOutputPath=`@prisma/client`;static isCustomPrismaClientOutputPath=!1;static isGenerateSelect=!0;static isGenerateInclude=!0;constructor(e){this.name=e.name??``,this.fields=e.fields??[],this.models=e.models??[],this.modelOperations=e.modelOperations??[],this.aggregateOperationSupport=e.aggregateOperationSupport??{},this.enumTypes=e.enumTypes??[]}static setOutputPath(e){this.outputPath=e}static setIsGenerateSelect(e){this.isGenerateSelect=e}static setIsGenerateInclude(e){this.isGenerateInclude=e}static getOutputPath(){return this.outputPath}static setPrismaClientOutputPath(e){this.prismaClientOutputPath=e,this.isCustomPrismaClientOutputPath=e!==`@prisma/client`}static async generateIndex(){await i.writeIndexFile(s.default.join(e.outputPath,`schemas/index.ts`))}async generateEnumSchemas(){for(let n of this.enumTypes){let{name:r,values:a}=n;await i.writeFileSafely(s.default.join(e.outputPath,`schemas/enums/${t.lowerCaseFirst(r)}.schema.ts`),`${this.generateImportZodStatement()}\n${this.generateExportSchemaStatement(`${t.lowerCaseFirst(r)}`,`z.enum(${JSON.stringify(a)})`)}`)}}generateImportZodStatement(){return`import { z } from 'zod';
-`}generateExportSchemaStatement(e,n){return`export const ${t.lowerCaseFirst(e)}Schema = ${n}`}async generateObjectSchema(){let n=this.generateObjectSchemaFields(),r=this.prepareObjectSchema(n),a=this.resolveObjectSchemaName();await i.writeFileSafely(s.default.join(e.outputPath,`schemas/objects/${t.lowerCaseFirst(a)}.schema.ts`),r)}generateObjectSchemaFields(){return this.fields.map(e=>this.generateObjectSchemaField(e)).flatMap(e=>e).map(e=>{let[t,n,r]=e;return(r?t:this.generateFieldValidators(t,n)).trim()})}generateObjectSchemaField(e){let t=e.inputTypes;if(t.length===0)return[];let n=t.reduce((n,r)=>{if(r.type===`String`)n.push(this.wrapWithZodValidators(`z.string()`,e));else if(r.type===`Int`||r.type===`Float`||r.type===`Decimal`)n.push(this.wrapWithZodValidators(`z.number()`,e));else if(r.type===`BigInt`)n.push(this.wrapWithZodValidators(`z.bigint()`,e));else if(r.type===`Boolean`)n.push(this.wrapWithZodValidators(`z.boolean()`,e));else if(r.type===`DateTime`)n.push(this.wrapWithZodValidators(`z.coerce.date()`,e));else if(r.type===`Json`)this.hasJson=!0,n.push(this.wrapWithZodValidators(`jsonSchema`,e));else if(r.type===`True`)n.push(this.wrapWithZodValidators(`z.literal(true)`,e));else if(r.type===`Bytes`)n.push(this.wrapWithZodValidators(`z.instanceof(Buffer)`,e));else if(!r.type.endsWith(`FieldRefInput`)){let i=r.location===`enumTypes`;(r.namespace===`prisma`||i)&&(r.type!==this.name&&typeof r.type==`string`&&this.addSchemaImport(r.type),n.push(this.generatePrismaStringLine(e,r,t.length)))}return n},[]);if(n.length===0)return[];n.length>1&&(n=n.map(e=>e.replace(`.optional()`,``)));let r=n.some(e=>e.includes(`:`))?``:`  ${e.name}:`,i=e.isRequired?``:`.optional()`,a=n.length===1?n.join(`,\r
-`):`z.union([${n.join(`,\r
-`)}])${i}`;return e.isNullable&&(a+=`.nullable()`),[[`  ${r} ${a} `,e,!0]]}wrapWithZodValidators(e,t){let n=``;return n=e,t.inputTypes.some(e=>e.isList)&&(n+=`.array()`),t.isRequired||(n+=`.optional()`),n}addSchemaImport(e){this.schemaImports.add(e)}generatePrismaStringLine(e,n,r){let i=n.location===`enumTypes`,a=n.type,{isModelQueryType:o,modelName:s,queryName:c}=this.checkIsModelQueryType(a),l=o?this.resolveModelQuerySchemaName(s,c):`${a}ObjectSchema`,u=`${a}Schema`,d=n.type===this.name?l:i?u:l,f=n.isList?`.array()`:``,p=e.isRequired?``:`.optional()`;return r===1?`  ${e.name}: z.lazy(() => ${t.lowerCaseFirst(d)})${f}${p}`:`z.lazy(() => ${t.lowerCaseFirst(d)})${f}${p}`}generateFieldValidators(e,t){let{isRequired:n,isNullable:r}=t;return n||(e+=`.optional()`),r&&(e+=`.nullable()`),e}prepareObjectSchema(e){let t=`${this.generateExportObjectSchemaStatement(this.addFinalWrappers({zodStringFields:e}))}\n`,n=this.generateImportPrismaStatement(),r=this.generateJsonSchemaImplementation();return`${this.generateObjectSchemaImportStatements()}${n}${r}${t}`}generateExportObjectSchemaStatement(n){let r=this.name,i=this.name;e.provider===`mongodb`&&o.isMongodbRawOp(r)&&(r=e.rawOpsMap[r],i=r.replace(`Args`,``)),a.isAggregateInputType(r)&&(r=`${r}Type`);let s=`export const ${t.lowerCaseFirst(i)}ObjectSchema = schema`;return`const schema: z.ZodType<Prisma.${r}> = ${n};\n\n ${s}`}addFinalWrappers({zodStringFields:e}){let t=[...e];return`${this.wrapWithZodObject(t)}.strict()`}generateImportPrismaStatement(){let t;if(e.isCustomPrismaClientOutputPath){let n=s.default.join(e.outputPath,`schemas`,`objects`),r=e.prismaClientOutputPath;t=s.default.relative(n,r).split(s.default.sep).join(s.default.posix.sep)}else t=e.prismaClientOutputPath;return`import type { Prisma } from '${t}';\n\n`}generateJsonSchemaImplementation(){let e=``;return this.hasJson&&(e+=`
-`,e+=`const literalSchema = z.union([z.string(), z.number(), z.boolean()]);
-`,e+=`const jsonSchema: z.ZodType<Prisma.InputJsonValue> = z.lazy(() =>
-`,e+=`  z.union([literalSchema, z.array(jsonSchema.nullable()), z.record(jsonSchema.nullable())])
-`,e+=`);
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_lower_case_first = require('../packages/string-format/src/lower-case-first.cjs');
+const require_upper_case_first = require('../packages/string-format/src/upper-case-first.cjs');
+const require_model_helpers = require('./model-helpers.cjs');
+const require_write_file_safely = require('../utils/write-file-safely.cjs');
+const require_aggregate_helpers = require('./aggregate-helpers.cjs');
+const require_mongodb_helpers = require('./mongodb-helpers.cjs');
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
 
-`),e}generateObjectSchemaImportStatements(){let e=this.generateImportZodStatement();return e+=this.generateSchemaImports(),e+=`
+//#region src/zod/transformer.ts
+var Transformer = class Transformer {
+	name;
+	fields;
+	schemaImports = /* @__PURE__ */ new Set();
+	models;
+	modelOperations;
+	aggregateOperationSupport;
+	enumTypes;
+	static enumNames = [];
+	static rawOpsMap = {};
+	static provider;
+	static previewFeatures;
+	static outputPath = "./generated";
+	hasJson = false;
+	static prismaClientOutputPath = "@prisma/client";
+	static isCustomPrismaClientOutputPath = false;
+	static isGenerateSelect = true;
+	static isGenerateInclude = true;
+	constructor(params) {
+		this.name = params.name ?? "";
+		this.fields = params.fields ?? [];
+		this.models = params.models ?? [];
+		this.modelOperations = params.modelOperations ?? [];
+		this.aggregateOperationSupport = params.aggregateOperationSupport ?? {};
+		this.enumTypes = params.enumTypes ?? [];
+	}
+	static setOutputPath(outPath) {
+		this.outputPath = outPath;
+	}
+	static setIsGenerateSelect(isGenerateSelect) {
+		this.isGenerateSelect = isGenerateSelect;
+	}
+	static setIsGenerateInclude(isGenerateInclude) {
+		this.isGenerateInclude = isGenerateInclude;
+	}
+	static getOutputPath() {
+		return this.outputPath;
+	}
+	static setPrismaClientOutputPath(prismaClientCustomPath) {
+		this.prismaClientOutputPath = prismaClientCustomPath;
+		this.isCustomPrismaClientOutputPath = prismaClientCustomPath !== "@prisma/client";
+	}
+	static async generateIndex() {
+		await require_write_file_safely.writeIndexFile(node_path.default.join(Transformer.outputPath, "schemas/index.ts"));
+	}
+	async generateEnumSchemas() {
+		for (const enumType of this.enumTypes) {
+			const { name, values } = enumType;
+			await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/enums/${require_lower_case_first.lowerCaseFirst(name)}.schema.ts`), `${this.generateImportZodStatement()}\n${this.generateExportSchemaStatement(`${require_lower_case_first.lowerCaseFirst(name)}`, `z.enum(${JSON.stringify(values)})`)}`);
+		}
+	}
+	generateImportZodStatement() {
+		return "import { z } from 'zod';\n";
+	}
+	generateExportSchemaStatement(name, schema) {
+		return `export const ${require_lower_case_first.lowerCaseFirst(name)}Schema = ${schema}`;
+	}
+	async generateObjectSchema() {
+		const zodObjectSchemaFields = this.generateObjectSchemaFields();
+		const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
+		const objectSchemaName = this.resolveObjectSchemaName();
+		await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/objects/${require_lower_case_first.lowerCaseFirst(objectSchemaName)}.schema.ts`), objectSchema);
+	}
+	generateObjectSchemaFields() {
+		return this.fields.map((field) => this.generateObjectSchemaField(field)).flatMap((item) => item).map((item) => {
+			const [zodStringWithMainType, field, skipValidators] = item;
+			return (skipValidators ? zodStringWithMainType : this.generateFieldValidators(zodStringWithMainType, field)).trim();
+		});
+	}
+	generateObjectSchemaField(field) {
+		const lines = field.inputTypes;
+		if (lines.length === 0) return [];
+		let alternatives = lines.reduce((result, inputType) => {
+			if (inputType.type === "String") result.push(this.wrapWithZodValidators("z.string()", field));
+			else if (inputType.type === "Int" || inputType.type === "Float" || inputType.type === "Decimal") result.push(this.wrapWithZodValidators("z.number()", field));
+			else if (inputType.type === "BigInt") result.push(this.wrapWithZodValidators("z.bigint()", field));
+			else if (inputType.type === "Boolean") result.push(this.wrapWithZodValidators("z.boolean()", field));
+			else if (inputType.type === "DateTime") result.push(this.wrapWithZodValidators("z.coerce.date()", field));
+			else if (inputType.type === "Json") {
+				this.hasJson = true;
+				result.push(this.wrapWithZodValidators("jsonSchema", field));
+			} else if (inputType.type === "True") result.push(this.wrapWithZodValidators("z.literal(true)", field));
+			else if (inputType.type === "Bytes") result.push(this.wrapWithZodValidators("z.instanceof(Buffer)", field));
+			else if (!inputType.type.endsWith("FieldRefInput")) {
+				const isEnum = inputType.location === "enumTypes";
+				if (inputType.namespace === "prisma" || isEnum) {
+					if (inputType.type !== this.name && typeof inputType.type === "string") this.addSchemaImport(inputType.type);
+					result.push(this.generatePrismaStringLine(field, inputType, lines.length));
+				}
+			}
+			return result;
+		}, []);
+		if (alternatives.length === 0) return [];
+		if (alternatives.length > 1) alternatives = alternatives.map((alter) => alter.replace(".optional()", ""));
+		const fieldName = alternatives.some((alt) => alt.includes(":")) ? "" : `  ${field.name}:`;
+		const opt = !field.isRequired ? ".optional()" : "";
+		let resString = alternatives.length === 1 ? alternatives.join(",\r\n") : `z.union([${alternatives.join(",\r\n")}])${opt}`;
+		if (field.isNullable) resString += ".nullable()";
+		return [[
+			`  ${fieldName} ${resString} `,
+			field,
+			true
+		]];
+	}
+	wrapWithZodValidators(mainValidator, field) {
+		let line = "";
+		line = mainValidator;
+		if (field.inputTypes.some((inputType) => inputType.isList)) line += ".array()";
+		if (!field.isRequired) line += ".optional()";
+		return line;
+	}
+	addSchemaImport(name) {
+		this.schemaImports.add(name);
+	}
+	generatePrismaStringLine(field, inputType, inputsLength) {
+		const isEnum = inputType.location === "enumTypes";
+		const inputTypeString = inputType.type;
+		const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(inputTypeString);
+		const objectSchemaLine = isModelQueryType ? this.resolveModelQuerySchemaName(modelName, queryName) : `${inputTypeString}ObjectSchema`;
+		const enumSchemaLine = `${inputTypeString}Schema`;
+		const schema = inputType.type === this.name ? objectSchemaLine : isEnum ? enumSchemaLine : objectSchemaLine;
+		const arr = inputType.isList ? ".array()" : "";
+		const opt = !field.isRequired ? ".optional()" : "";
+		return inputsLength === 1 ? `  ${field.name}: z.lazy(() => ${require_lower_case_first.lowerCaseFirst(schema)})${arr}${opt}` : `z.lazy(() => ${require_lower_case_first.lowerCaseFirst(schema)})${arr}${opt}`;
+	}
+	generateFieldValidators(zodStringWithMainType, field) {
+		const { isRequired, isNullable } = field;
+		if (!isRequired) zodStringWithMainType += ".optional()";
+		if (isNullable) zodStringWithMainType += ".nullable()";
+		return zodStringWithMainType;
+	}
+	prepareObjectSchema(zodObjectSchemaFields) {
+		const objectSchema = `${this.generateExportObjectSchemaStatement(this.addFinalWrappers({ zodStringFields: zodObjectSchemaFields }))}\n`;
+		const prismaImportStatement = this.generateImportPrismaStatement();
+		const json = this.generateJsonSchemaImplementation();
+		return `${this.generateObjectSchemaImportStatements()}${prismaImportStatement}${json}${objectSchema}`;
+	}
+	generateExportObjectSchemaStatement(schema) {
+		let name = this.name;
+		let exportName = this.name;
+		if (Transformer.provider === "mongodb") {
+			if (require_mongodb_helpers.isMongodbRawOp(name)) {
+				name = Transformer.rawOpsMap[name];
+				exportName = name.replace("Args", "");
+			}
+		}
+		if (require_aggregate_helpers.isAggregateInputType(name)) name = `${name}Type`;
+		const end = `export const ${require_lower_case_first.lowerCaseFirst(exportName)}ObjectSchema = schema`;
+		return `const schema: z.ZodType<Prisma.${name}> = ${schema};\n\n ${end}`;
+	}
+	addFinalWrappers({ zodStringFields }) {
+		const fields = [...zodStringFields];
+		return `${this.wrapWithZodObject(fields)}.strict()`;
+	}
+	generateImportPrismaStatement() {
+		let prismaClientImportPath;
+		if (Transformer.isCustomPrismaClientOutputPath) {
+			/**
+			* If a custom location was designated for the prisma client, we need to figure out the
+			* relative path from \{outputPath\}/schemas/objects to \{prismaClientCustomPath\}
+			*/
+			const fromPath = node_path.default.join(Transformer.outputPath, "schemas", "objects");
+			const toPath = Transformer.prismaClientOutputPath;
+			prismaClientImportPath = node_path.default.relative(fromPath, toPath).split(node_path.default.sep).join(node_path.default.posix.sep);
+		} else
+ /**
+		* If the default output path for prisma client (\@prisma/client) is being used, we can import from it directly
+		* without having to resolve a relative path
+		*/
+		prismaClientImportPath = Transformer.prismaClientOutputPath;
+		return `import type { Prisma } from '${prismaClientImportPath}';\n\n`;
+	}
+	generateJsonSchemaImplementation() {
+		let jsonSchemaImplementation = "";
+		if (this.hasJson) {
+			jsonSchemaImplementation += `\n`;
+			jsonSchemaImplementation += `const literalSchema = z.union([z.string(), z.number(), z.boolean()]);\n`;
+			jsonSchemaImplementation += `const jsonSchema: z.ZodType<Prisma.InputJsonValue> = z.lazy(() =>\n`;
+			jsonSchemaImplementation += `  z.union([literalSchema, z.array(jsonSchema.nullable()), z.record(jsonSchema.nullable())])\n`;
+			jsonSchemaImplementation += `);\n\n`;
+		}
+		return jsonSchemaImplementation;
+	}
+	generateObjectSchemaImportStatements() {
+		let generatedImports = this.generateImportZodStatement();
+		generatedImports += this.generateSchemaImports();
+		generatedImports += "\n\n";
+		return generatedImports;
+	}
+	generateSchemaImports() {
+		return [...this.schemaImports].map((name) => {
+			const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(name);
+			if (isModelQueryType) return `import { ${this.resolveModelQuerySchemaName(modelName, queryName)} } from '../${queryName}${modelName}.schema'`;
+			else if (Transformer.enumNames.includes(name)) return `import { ${require_lower_case_first.lowerCaseFirst(name)}Schema } from '../enums/${require_lower_case_first.lowerCaseFirst(name)}.schema'`;
+			else return `import { ${require_lower_case_first.lowerCaseFirst(name)}ObjectSchema } from './${require_lower_case_first.lowerCaseFirst(name)}.schema'`;
+		}).join(";\r\n");
+	}
+	checkIsModelQueryType(type) {
+		const modelQueryTypeSuffixToQueryName = { FindManyArgs: "findMany" };
+		for (const modelQueryType of ["FindManyArgs"]) if (type.includes(modelQueryType)) {
+			const modelQueryTypeSuffixIndex = type.indexOf(modelQueryType);
+			return {
+				isModelQueryType: true,
+				modelName: type.substring(0, modelQueryTypeSuffixIndex),
+				queryName: modelQueryTypeSuffixToQueryName[modelQueryType]
+			};
+		}
+		return { isModelQueryType: false };
+	}
+	resolveModelQuerySchemaName(modelName, queryName) {
+		return `${require_lower_case_first.lowerCaseFirst(modelName)}${require_upper_case_first.upperCaseFirst(queryName)}Schema`;
+	}
+	wrapWithZodUnion(zodStringFields) {
+		let wrapped = "";
+		wrapped += "z.union([";
+		wrapped += "\n";
+		wrapped += `  ${zodStringFields.join(",")}`;
+		wrapped += "\n";
+		wrapped += "])";
+		return wrapped;
+	}
+	wrapWithZodObject(zodStringFields) {
+		let wrapped = "";
+		wrapped += "z.object({";
+		wrapped += "\n";
+		wrapped += `  ${typeof zodStringFields === "string" ? zodStringFields : zodStringFields.join(",\n  ")}`;
+		wrapped += "\n";
+		wrapped += "})";
+		return wrapped;
+	}
+	resolveObjectSchemaName() {
+		let name = this.name;
+		let exportName = this.name;
+		if (require_mongodb_helpers.isMongodbRawOp(name)) {
+			name = Transformer.rawOpsMap[name];
+			exportName = name.replace("Args", "");
+		}
+		return require_lower_case_first.lowerCaseFirst(exportName);
+	}
+	async generateModelSchemas() {
+		for (const modelOperation of this.modelOperations) {
+			const { findUnique, findFirst, findMany, createOne, createMany, createManyAndReturn, deleteOne, updateOne, deleteMany, updateMany, updateManyAndReturn, upsertOne, aggregate, groupBy } = modelOperation;
+			const model = require_model_helpers.findModelByName(this.models, modelOperation.model);
+			const modelName = require_lower_case_first.lowerCaseFirst(modelOperation.model);
+			const { selectImport, includeImport, selectZodSchemaLine, includeZodSchemaLine, selectZodSchemaLineLazy, includeZodSchemaLineLazy } = this.resolveSelectIncludeImportAndZodSchemaLine(model);
+			const { orderByImport, orderByZodSchemaLine } = this.resolveOrderByWithRelationImportAndZodSchemaLine(model);
+			if (findUnique) {
+				const imports = [
+					selectImport,
+					includeImport,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${findUnique}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindUnique`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema })`)}`);
+			}
+			if (findFirst) {
+				const imports = [
+					selectImport,
+					includeImport,
+					orderByImport,
+					`import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+					`import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${findFirst}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindFirst`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional() })`)}`);
+			}
+			if (findMany) {
+				const imports = [
+					selectImport,
+					includeImport,
+					orderByImport,
+					`import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+					`import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${findMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindMany`, `z.object({ ${selectZodSchemaLineLazy} ${includeZodSchemaLineLazy} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional()  })`)}`);
+			}
+			if (createOne) {
+				const imports = [
+					selectImport,
+					includeImport,
+					`import { ${modelName}CreateInputObjectSchema } from './objects/${modelName}CreateInput.schema'`,
+					`import { ${modelName}UncheckedCreateInputObjectSchema } from './objects/${modelName}UncheckedCreateInput.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${createOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema])  })`)}`);
+			}
+			if (createMany) {
+				const imports = [`import { ${modelName}CreateManyInputObjectSchema } from './objects/${modelName}CreateManyInput.schema'`];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${createMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateMany`, `z.object({ data: z.union([ ${modelName}CreateManyInputObjectSchema, z.array(${modelName}CreateManyInputObjectSchema) ]), ${Transformer.provider === "mongodb" || Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+			}
+			if (createManyAndReturn) {
+				const imports = [`import { ${modelName}CreateManyAndReturnInputObjectSchema } from './objects/${modelName}CreateManyAndReturnInput.schema'`];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${createManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateManyAndReturn`, `z.object({ data: z.union([ ${modelName}CreateManyAndReturnInputObjectSchema, z.array(${modelName}CreateManyAndReturnInputObjectSchema) ]), ${Transformer.provider === "mongodb" || Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+			}
+			if (deleteOne) {
+				const imports = [
+					selectImport,
+					includeImport,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${deleteOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+			}
+			if (deleteMany) {
+				const imports = [`import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${deleteMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteMany`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+			}
+			if (updateOne) {
+				const imports = [
+					selectImport,
+					includeImport,
+					`import { ${modelName}UpdateInputObjectSchema } from './objects/${modelName}UpdateInput.schema'`,
+					`import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${updateOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema]), where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+			}
+			if (updateMany) {
+				const imports = [`import { ${modelName}UpdateManyMutationInputObjectSchema } from './objects/${modelName}UpdateManyMutationInput.schema'`, `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${updateMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateMany`, `z.object({ data: ${modelName}UpdateManyMutationInputObjectSchema, where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+			}
+			if (updateManyAndReturn) {
+				const imports = [`import { ${modelName}UpdateManyAndReturnInputObjectSchema } from './objects/${modelName}UpdateManyAndReturnInput.schema'`];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${updateManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateManyAndReturn`, `z.object({ data: z.union([ ${modelName}UpdateManyAndReturnInputObjectSchema, z.array(${modelName}UpdateManyAndReturnInputObjectSchema) ]), ${Transformer.provider === "mongodb" || Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+			}
+			if (upsertOne) {
+				const imports = [
+					selectImport,
+					includeImport,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+					`import { ${modelName}CreateInputObjectSchema } from './objects/${modelName}CreateInput.schema'`,
+					`import { ${modelName}UncheckedCreateInputObjectSchema } from './objects/${modelName}UncheckedCreateInput.schema'`,
+					`import { ${modelName}UpdateInputObjectSchema } from './objects/${modelName}UpdateInput.schema'`,
+					`import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${upsertOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Upsert`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema, create: z.union([ ${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema ]), update: z.union([ ${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema ])  })`)}`);
+			}
+			if (aggregate) {
+				const imports = [
+					orderByImport,
+					`import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+					`import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+				];
+				const aggregateOperations = [];
+				if (this.aggregateOperationSupport[modelName]) {
+					if (this.aggregateOperationSupport[modelName].count) {
+						imports.push(`import { ${modelName}CountAggregateInputObjectSchema } from './objects/${modelName}CountAggregateInput.schema'`);
+						aggregateOperations.push(`_count: z.union([ z.literal(true), ${modelName}CountAggregateInputObjectSchema ]).optional()`);
+					}
+					if (this.aggregateOperationSupport[modelName].min) {
+						imports.push(`import { ${modelName}MinAggregateInputObjectSchema } from './objects/${modelName}MinAggregateInput.schema'`);
+						aggregateOperations.push(`_min: ${modelName}MinAggregateInputObjectSchema.optional()`);
+					}
+					if (this.aggregateOperationSupport[modelName].max) {
+						imports.push(`import { ${modelName}MaxAggregateInputObjectSchema } from './objects/${modelName}MaxAggregateInput.schema'`);
+						aggregateOperations.push(`_max: ${modelName}MaxAggregateInputObjectSchema.optional()`);
+					}
+					if (this.aggregateOperationSupport[modelName].avg) {
+						imports.push(`import { ${modelName}AvgAggregateInputObjectSchema } from './objects/${modelName}AvgAggregateInput.schema'`);
+						aggregateOperations.push(`_avg: ${modelName}AvgAggregateInputObjectSchema.optional()`);
+					}
+					if (this.aggregateOperationSupport[modelName].sum) {
+						imports.push(`import { ${modelName}SumAggregateInputObjectSchema } from './objects/${modelName}SumAggregateInput.schema'`);
+						aggregateOperations.push(`_sum: ${modelName}SumAggregateInputObjectSchema.optional()`);
+					}
+				}
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${aggregate}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Aggregate`, `z.object({ ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${aggregateOperations.join(", ")} })`)}`);
+			}
+			if (groupBy) {
+				const imports = [
+					`import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+					`import { ${modelName}OrderByWithAggregationInputObjectSchema } from './objects/${modelName}OrderByWithAggregationInput.schema'`,
+					`import { ${modelName}ScalarWhereWithAggregatesInputObjectSchema } from './objects/${modelName}ScalarWhereWithAggregatesInput.schema'`,
+					`import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+				];
+				await require_write_file_safely.writeFileSafely(node_path.default.join(Transformer.outputPath, `schemas/${groupBy}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}GroupBy`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional(), orderBy: z.union([${modelName}OrderByWithAggregationInputObjectSchema, ${modelName}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${modelName}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${modelName}ScalarFieldEnumSchema)  })`)}`);
+			}
+		}
+	}
+	generateImportStatements(imports) {
+		let generatedImports = this.generateImportZodStatement();
+		generatedImports += imports?.filter((importItem) => !!importItem).join(";\r\n") ?? "";
+		generatedImports += "\n\n";
+		return generatedImports;
+	}
+	resolveSelectIncludeImportAndZodSchemaLine(model) {
+		const { name: modelName } = model;
+		const hasRelationToAnotherModel = require_model_helpers.checkModelHasModelRelation(model);
+		const selectImport = Transformer.isGenerateSelect ? `import { ${require_lower_case_first.lowerCaseFirst(modelName)}SelectObjectSchema } from './objects/${require_lower_case_first.lowerCaseFirst(modelName)}Select.schema'` : "";
+		const includeImport = Transformer.isGenerateInclude && hasRelationToAnotherModel ? `import { ${require_lower_case_first.lowerCaseFirst(modelName)}IncludeObjectSchema } from './objects/${require_lower_case_first.lowerCaseFirst(modelName)}Include.schema'` : "";
+		let selectZodSchemaLine = "";
+		let includeZodSchemaLine = "";
+		let selectZodSchemaLineLazy = "";
+		let includeZodSchemaLineLazy = "";
+		if (Transformer.isGenerateSelect) {
+			const zodSelectObjectSchema = `${require_lower_case_first.lowerCaseFirst(modelName)}SelectObjectSchema.optional()`;
+			selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
+			selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
+		}
+		if (Transformer.isGenerateInclude && hasRelationToAnotherModel) {
+			const zodIncludeObjectSchema = `${require_lower_case_first.lowerCaseFirst(modelName)}IncludeObjectSchema.optional()`;
+			includeZodSchemaLine = `include: ${zodIncludeObjectSchema},`;
+			includeZodSchemaLineLazy = `include: z.lazy(() => ${zodIncludeObjectSchema}),`;
+		}
+		return {
+			selectImport,
+			includeImport,
+			selectZodSchemaLine,
+			includeZodSchemaLine,
+			selectZodSchemaLineLazy,
+			includeZodSchemaLineLazy
+		};
+	}
+	resolveOrderByWithRelationImportAndZodSchemaLine(model) {
+		const { name: modelName } = model;
+		let modelOrderBy = "";
+		if (["postgresql", "mysql"].includes(Transformer.provider) && Transformer.previewFeatures?.includes("fullTextSearch")) modelOrderBy = `${require_lower_case_first.lowerCaseFirst(modelName)}OrderByWithRelationAndSearchRelevanceInput`;
+		else modelOrderBy = `${require_lower_case_first.lowerCaseFirst(modelName)}OrderByWithRelationInput`;
+		return {
+			orderByImport: `import { ${modelOrderBy}ObjectSchema } from './objects/${modelOrderBy}.schema'`,
+			orderByZodSchemaLine: `orderBy: z.union([${modelOrderBy}ObjectSchema, ${modelOrderBy}ObjectSchema.array()]).optional(),`
+		};
+	}
+};
 
-`,e}generateSchemaImports(){return[...this.schemaImports].map(n=>{let{isModelQueryType:r,modelName:i,queryName:a}=this.checkIsModelQueryType(n);return r?`import { ${this.resolveModelQuerySchemaName(i,a)} } from '../${a}${i}.schema'`:e.enumNames.includes(n)?`import { ${t.lowerCaseFirst(n)}Schema } from '../enums/${t.lowerCaseFirst(n)}.schema'`:`import { ${t.lowerCaseFirst(n)}ObjectSchema } from './${t.lowerCaseFirst(n)}.schema'`}).join(`;\r
-`)}checkIsModelQueryType(e){let t={FindManyArgs:`findMany`};for(let n of[`FindManyArgs`])if(e.includes(n)){let r=e.indexOf(n);return{isModelQueryType:!0,modelName:e.substring(0,r),queryName:t[n]}}return{isModelQueryType:!1}}resolveModelQuerySchemaName(e,r){return`${t.lowerCaseFirst(e)}${n.upperCaseFirst(r)}Schema`}wrapWithZodUnion(e){let t=``;return t+=`z.union([`,t+=`
-`,t+=`  ${e.join(`,`)}`,t+=`
-`,t+=`])`,t}wrapWithZodObject(e){let t=``;return t+=`z.object({`,t+=`
-`,t+=`  ${typeof e==`string`?e:e.join(`,
-  `)}`,t+=`
-`,t+=`})`,t}resolveObjectSchemaName(){let n=this.name,r=this.name;return o.isMongodbRawOp(n)&&(n=e.rawOpsMap[n],r=n.replace(`Args`,``)),t.lowerCaseFirst(r)}async generateModelSchemas(){for(let n of this.modelOperations){let{findUnique:a,findFirst:o,findMany:c,createOne:l,createMany:u,createManyAndReturn:d,deleteOne:f,updateOne:p,deleteMany:m,updateMany:h,updateManyAndReturn:g,upsertOne:_,aggregate:v,groupBy:y}=n,b=r.findModelByName(this.models,n.model),x=t.lowerCaseFirst(n.model),{selectImport:S,includeImport:C,selectZodSchemaLine:w,includeZodSchemaLine:T,selectZodSchemaLineLazy:E,includeZodSchemaLineLazy:D}=this.resolveSelectIncludeImportAndZodSchemaLine(b),{orderByImport:O,orderByZodSchemaLine:k}=this.resolveOrderByWithRelationImportAndZodSchemaLine(b);if(a){let t=[S,C,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${a}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}FindUnique`,`z.object({ ${w} ${T} where: ${x}WhereUniqueInputObjectSchema })`)}`)}if(o){let t=[S,C,O,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`,`import { ${x}ScalarFieldEnumSchema } from './enums/${x}ScalarFieldEnum.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${o}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}FindFirst`,`z.object({ ${w} ${T} ${k} where: ${x}WhereInputObjectSchema.optional(), cursor: ${x}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${x}ScalarFieldEnumSchema).optional() })`)}`)}if(c){let t=[S,C,O,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`,`import { ${x}ScalarFieldEnumSchema } from './enums/${x}ScalarFieldEnum.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${c}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}FindMany`,`z.object({ ${E} ${D} ${k} where: ${x}WhereInputObjectSchema.optional(), cursor: ${x}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${x}ScalarFieldEnumSchema).optional()  })`)}`)}if(l){let t=[S,C,`import { ${x}CreateInputObjectSchema } from './objects/${x}CreateInput.schema'`,`import { ${x}UncheckedCreateInputObjectSchema } from './objects/${x}UncheckedCreateInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${l}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}CreateOne`,`z.object({ ${w} ${T} data: z.union([${x}CreateInputObjectSchema, ${x}UncheckedCreateInputObjectSchema])  })`)}`)}if(u){let t=[`import { ${x}CreateManyInputObjectSchema } from './objects/${x}CreateManyInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${u}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}CreateMany`,`z.object({ data: z.union([ ${x}CreateManyInputObjectSchema, z.array(${x}CreateManyInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(d){let t=[`import { ${x}CreateManyAndReturnInputObjectSchema } from './objects/${x}CreateManyAndReturnInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${d}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}CreateManyAndReturn`,`z.object({ data: z.union([ ${x}CreateManyAndReturnInputObjectSchema, z.array(${x}CreateManyAndReturnInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(f){let t=[S,C,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${f}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}DeleteOne`,`z.object({ ${w} ${T} where: ${x}WhereUniqueInputObjectSchema  })`)}`)}if(m){let t=[`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${m}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}DeleteMany`,`z.object({ where: ${x}WhereInputObjectSchema.optional()  })`)}`)}if(p){let t=[S,C,`import { ${x}UpdateInputObjectSchema } from './objects/${x}UpdateInput.schema'`,`import { ${x}UncheckedUpdateInputObjectSchema } from './objects/${x}UncheckedUpdateInput.schema'`,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${p}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}UpdateOne`,`z.object({ ${w} ${T} data: z.union([${x}UpdateInputObjectSchema, ${x}UncheckedUpdateInputObjectSchema]), where: ${x}WhereUniqueInputObjectSchema  })`)}`)}if(h){let t=[`import { ${x}UpdateManyMutationInputObjectSchema } from './objects/${x}UpdateManyMutationInput.schema'`,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${h}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}UpdateMany`,`z.object({ data: ${x}UpdateManyMutationInputObjectSchema, where: ${x}WhereInputObjectSchema.optional()  })`)}`)}if(g){let t=[`import { ${x}UpdateManyAndReturnInputObjectSchema } from './objects/${x}UpdateManyAndReturnInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${g}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}UpdateManyAndReturn`,`z.object({ data: z.union([ ${x}UpdateManyAndReturnInputObjectSchema, z.array(${x}UpdateManyAndReturnInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(_){let t=[S,C,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`,`import { ${x}CreateInputObjectSchema } from './objects/${x}CreateInput.schema'`,`import { ${x}UncheckedCreateInputObjectSchema } from './objects/${x}UncheckedCreateInput.schema'`,`import { ${x}UpdateInputObjectSchema } from './objects/${x}UpdateInput.schema'`,`import { ${x}UncheckedUpdateInputObjectSchema } from './objects/${x}UncheckedUpdateInput.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${_}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}Upsert`,`z.object({ ${w} ${T} where: ${x}WhereUniqueInputObjectSchema, create: z.union([ ${x}CreateInputObjectSchema, ${x}UncheckedCreateInputObjectSchema ]), update: z.union([ ${x}UpdateInputObjectSchema, ${x}UncheckedUpdateInputObjectSchema ])  })`)}`)}if(v){let t=[O,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`],n=[];this.aggregateOperationSupport[x]&&(this.aggregateOperationSupport[x].count&&(t.push(`import { ${x}CountAggregateInputObjectSchema } from './objects/${x}CountAggregateInput.schema'`),n.push(`_count: z.union([ z.literal(true), ${x}CountAggregateInputObjectSchema ]).optional()`)),this.aggregateOperationSupport[x].min&&(t.push(`import { ${x}MinAggregateInputObjectSchema } from './objects/${x}MinAggregateInput.schema'`),n.push(`_min: ${x}MinAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].max&&(t.push(`import { ${x}MaxAggregateInputObjectSchema } from './objects/${x}MaxAggregateInput.schema'`),n.push(`_max: ${x}MaxAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].avg&&(t.push(`import { ${x}AvgAggregateInputObjectSchema } from './objects/${x}AvgAggregateInput.schema'`),n.push(`_avg: ${x}AvgAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].sum&&(t.push(`import { ${x}SumAggregateInputObjectSchema } from './objects/${x}SumAggregateInput.schema'`),n.push(`_sum: ${x}SumAggregateInputObjectSchema.optional()`))),await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${v}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}Aggregate`,`z.object({ ${k} where: ${x}WhereInputObjectSchema.optional(), cursor: ${x}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${n.join(`, `)} })`)}`)}if(y){let t=[`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`,`import { ${x}OrderByWithAggregationInputObjectSchema } from './objects/${x}OrderByWithAggregationInput.schema'`,`import { ${x}ScalarWhereWithAggregatesInputObjectSchema } from './objects/${x}ScalarWhereWithAggregatesInput.schema'`,`import { ${x}ScalarFieldEnumSchema } from './enums/${x}ScalarFieldEnum.schema'`];await i.writeFileSafely(s.default.join(e.outputPath,`schemas/${y}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${x}GroupBy`,`z.object({ where: ${x}WhereInputObjectSchema.optional(), orderBy: z.union([${x}OrderByWithAggregationInputObjectSchema, ${x}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${x}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${x}ScalarFieldEnumSchema)  })`)}`)}}}generateImportStatements(e){let t=this.generateImportZodStatement();return t+=e?.filter(e=>!!e).join(`;\r
-`)??``,t+=`
-
-`,t}resolveSelectIncludeImportAndZodSchemaLine(n){let{name:i}=n,a=r.checkModelHasModelRelation(n),o=e.isGenerateSelect?`import { ${t.lowerCaseFirst(i)}SelectObjectSchema } from './objects/${t.lowerCaseFirst(i)}Select.schema'`:``,s=e.isGenerateInclude&&a?`import { ${t.lowerCaseFirst(i)}IncludeObjectSchema } from './objects/${t.lowerCaseFirst(i)}Include.schema'`:``,c=``,l=``,u=``,d=``;if(e.isGenerateSelect){let e=`${t.lowerCaseFirst(i)}SelectObjectSchema.optional()`;c=`select: ${e},`,u=`select: z.lazy(() => ${e}),`}if(e.isGenerateInclude&&a){let e=`${t.lowerCaseFirst(i)}IncludeObjectSchema.optional()`;l=`include: ${e},`,d=`include: z.lazy(() => ${e}),`}return{selectImport:o,includeImport:s,selectZodSchemaLine:c,includeZodSchemaLine:l,selectZodSchemaLineLazy:u,includeZodSchemaLineLazy:d}}resolveOrderByWithRelationImportAndZodSchemaLine(n){let{name:r}=n,i=``;return i=[`postgresql`,`mysql`].includes(e.provider)&&e.previewFeatures?.includes(`fullTextSearch`)?`${t.lowerCaseFirst(r)}OrderByWithRelationAndSearchRelevanceInput`:`${t.lowerCaseFirst(r)}OrderByWithRelationInput`,{orderByImport:`import { ${i}ObjectSchema } from './objects/${i}.schema'`,orderByZodSchemaLine:`orderBy: z.union([${i}ObjectSchema, ${i}ObjectSchema.array()]).optional(),`}}};exports.default=c;
+//#endregion
+exports.default = Transformer;