@stryke/prisma-trpc-generator 0.13.48 → 0.13.50

package/dist/zod/transformer.mjs

@@ -1,22 +1,435 @@
-import{lowerCaseFirst as e}from"../packages/string-format/src/lower-case-first.mjs";import{upperCaseFirst as t}from"../packages/string-format/src/upper-case-first.mjs";import{checkModelHasModelRelation as n,findModelByName as r}from"./model-helpers.mjs";import{writeFileSafely as i,writeIndexFile as a}from"../utils/write-file-safely.mjs";import{isAggregateInputType as o}from"./aggregate-helpers.mjs";import{isMongodbRawOp as s}from"./mongodb-helpers.mjs";import c from"node:path";var l=class l{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 a(c.join(l.outputPath,`schemas/index.ts`))}async generateEnumSchemas(){for(let t of this.enumTypes){let{name:n,values:r}=t;await i(c.join(l.outputPath,`schemas/enums/${e(n)}.schema.ts`),`${this.generateImportZodStatement()}\n${this.generateExportSchemaStatement(`${e(n)}`,`z.enum(${JSON.stringify(r)})`)}`)}}generateImportZodStatement(){return`import { z } from 'zod';
-`}generateExportSchemaStatement(t,n){return`export const ${e(t)}Schema = ${n}`}async generateObjectSchema(){let t=this.generateObjectSchemaFields(),n=this.prepareObjectSchema(t),r=this.resolveObjectSchemaName();await i(c.join(l.outputPath,`schemas/objects/${e(r)}.schema.ts`),n)}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(t,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=t.isRequired?``:`.optional()`;return r===1?`  ${t.name}: z.lazy(() => ${e(d)})${f}${p}`:`z.lazy(() => ${e(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(t){let n=this.name,r=this.name;l.provider===`mongodb`&&s(n)&&(n=l.rawOpsMap[n],r=n.replace(`Args`,``)),o(n)&&(n=`${n}Type`);let i=`export const ${e(r)}ObjectSchema = schema`;return`const schema: z.ZodType<Prisma.${n}> = ${t};\n\n ${i}`}addFinalWrappers({zodStringFields:e}){let t=[...e];return`${this.wrapWithZodObject(t)}.strict()`}generateImportPrismaStatement(){let e;if(l.isCustomPrismaClientOutputPath){let t=c.join(l.outputPath,`schemas`,`objects`),n=l.prismaClientOutputPath;e=c.relative(t,n).split(c.sep).join(c.posix.sep)}else e=l.prismaClientOutputPath;return`import type { Prisma } from '${e}';\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+=`);
+import { lowerCaseFirst } from "../packages/string-format/src/lower-case-first.mjs";
+import { upperCaseFirst } from "../packages/string-format/src/upper-case-first.mjs";
+import { checkModelHasModelRelation, findModelByName } from "./model-helpers.mjs";
+import { writeFileSafely, writeIndexFile } from "../utils/write-file-safely.mjs";
+import { isAggregateInputType } from "./aggregate-helpers.mjs";
+import { isMongodbRawOp } from "./mongodb-helpers.mjs";
+import path from "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 writeIndexFile(path.join(Transformer.outputPath, "schemas/index.ts"));
+	}
+	async generateEnumSchemas() {
+		for (const enumType of this.enumTypes) {
+			const { name, values } = enumType;
+			await writeFileSafely(path.join(Transformer.outputPath, `schemas/enums/${lowerCaseFirst(name)}.schema.ts`), `${this.generateImportZodStatement()}\n${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.stringify(values)})`)}`);
+		}
+	}
+	generateImportZodStatement() {
+		return "import { z } from 'zod';\n";
+	}
+	generateExportSchemaStatement(name, schema) {
+		return `export const ${lowerCaseFirst(name)}Schema = ${schema}`;
+	}
+	async generateObjectSchema() {
+		const zodObjectSchemaFields = this.generateObjectSchemaFields();
+		const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
+		const objectSchemaName = this.resolveObjectSchemaName();
+		await writeFileSafely(path.join(Transformer.outputPath, `schemas/objects/${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(() => ${lowerCaseFirst(schema)})${arr}${opt}` : `z.lazy(() => ${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 (isMongodbRawOp(name)) {
+				name = Transformer.rawOpsMap[name];
+				exportName = name.replace("Args", "");
+			}
+		}
+		if (isAggregateInputType(name)) name = `${name}Type`;
+		const end = `export const ${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 = path.join(Transformer.outputPath, "schemas", "objects");
+			const toPath = Transformer.prismaClientOutputPath;
+			prismaClientImportPath = path.relative(fromPath, toPath).split(path.sep).join(path.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 { ${lowerCaseFirst(name)}Schema } from '../enums/${lowerCaseFirst(name)}.schema'`;
+			else return `import { ${lowerCaseFirst(name)}ObjectSchema } from './${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 `${lowerCaseFirst(modelName)}${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 (isMongodbRawOp(name)) {
+			name = Transformer.rawOpsMap[name];
+			exportName = name.replace("Args", "");
+		}
+		return 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 = findModelByName(this.models, modelOperation.model);
+			const modelName = 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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 writeFileSafely(path.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 = checkModelHasModelRelation(model);
+		const selectImport = Transformer.isGenerateSelect ? `import { ${lowerCaseFirst(modelName)}SelectObjectSchema } from './objects/${lowerCaseFirst(modelName)}Select.schema'` : "";
+		const includeImport = Transformer.isGenerateInclude && hasRelationToAnotherModel ? `import { ${lowerCaseFirst(modelName)}IncludeObjectSchema } from './objects/${lowerCaseFirst(modelName)}Include.schema'` : "";
+		let selectZodSchemaLine = "";
+		let includeZodSchemaLine = "";
+		let selectZodSchemaLineLazy = "";
+		let includeZodSchemaLineLazy = "";
+		if (Transformer.isGenerateSelect) {
+			const zodSelectObjectSchema = `${lowerCaseFirst(modelName)}SelectObjectSchema.optional()`;
+			selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
+			selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
+		}
+		if (Transformer.isGenerateInclude && hasRelationToAnotherModel) {
+			const zodIncludeObjectSchema = `${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 = `${lowerCaseFirst(modelName)}OrderByWithRelationAndSearchRelevanceInput`;
+		else modelOrderBy = `${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(t=>{let{isModelQueryType:n,modelName:r,queryName:i}=this.checkIsModelQueryType(t);return n?`import { ${this.resolveModelQuerySchemaName(r,i)} } from '../${i}${r}.schema'`:l.enumNames.includes(t)?`import { ${e(t)}Schema } from '../enums/${e(t)}.schema'`:`import { ${e(t)}ObjectSchema } from './${e(t)}.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(n,r){return`${e(n)}${t(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 t=this.name,n=this.name;return s(t)&&(t=l.rawOpsMap[t],n=t.replace(`Args`,``)),e(n)}async generateModelSchemas(){for(let t of this.modelOperations){let{findUnique:n,findFirst:a,findMany:o,createOne:s,createMany:u,createManyAndReturn:d,deleteOne:f,updateOne:p,deleteMany:m,updateMany:h,updateManyAndReturn:g,upsertOne:_,aggregate:v,groupBy:y}=t,b=r(this.models,t.model),x=e(t.model),{selectImport:S,includeImport:C,selectZodSchemaLine:w,includeZodSchemaLine:T,selectZodSchemaLineLazy:E,includeZodSchemaLineLazy:D}=this.resolveSelectIncludeImportAndZodSchemaLine(b),{orderByImport:O,orderByZodSchemaLine:k}=this.resolveOrderByWithRelationImportAndZodSchemaLine(b);if(n){let e=[S,C,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`];await i(c.join(l.outputPath,`schemas/${n}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}FindUnique`,`z.object({ ${w} ${T} where: ${x}WhereUniqueInputObjectSchema })`)}`)}if(a){let e=[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(c.join(l.outputPath,`schemas/${a}.schema.ts`),`${this.generateImportStatements(e)}${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(o){let e=[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(c.join(l.outputPath,`schemas/${o}.schema.ts`),`${this.generateImportStatements(e)}${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(s){let e=[S,C,`import { ${x}CreateInputObjectSchema } from './objects/${x}CreateInput.schema'`,`import { ${x}UncheckedCreateInputObjectSchema } from './objects/${x}UncheckedCreateInput.schema'`];await i(c.join(l.outputPath,`schemas/${s}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}CreateOne`,`z.object({ ${w} ${T} data: z.union([${x}CreateInputObjectSchema, ${x}UncheckedCreateInputObjectSchema])  })`)}`)}if(u){let e=[`import { ${x}CreateManyInputObjectSchema } from './objects/${x}CreateManyInput.schema'`];await i(c.join(l.outputPath,`schemas/${u}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}CreateMany`,`z.object({ data: z.union([ ${x}CreateManyInputObjectSchema, z.array(${x}CreateManyInputObjectSchema) ]), ${l.provider===`mongodb`||l.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(d){let e=[`import { ${x}CreateManyAndReturnInputObjectSchema } from './objects/${x}CreateManyAndReturnInput.schema'`];await i(c.join(l.outputPath,`schemas/${d}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}CreateManyAndReturn`,`z.object({ data: z.union([ ${x}CreateManyAndReturnInputObjectSchema, z.array(${x}CreateManyAndReturnInputObjectSchema) ]), ${l.provider===`mongodb`||l.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(f){let e=[S,C,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`];await i(c.join(l.outputPath,`schemas/${f}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}DeleteOne`,`z.object({ ${w} ${T} where: ${x}WhereUniqueInputObjectSchema  })`)}`)}if(m){let e=[`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`];await i(c.join(l.outputPath,`schemas/${m}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}DeleteMany`,`z.object({ where: ${x}WhereInputObjectSchema.optional()  })`)}`)}if(p){let e=[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(c.join(l.outputPath,`schemas/${p}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}UpdateOne`,`z.object({ ${w} ${T} data: z.union([${x}UpdateInputObjectSchema, ${x}UncheckedUpdateInputObjectSchema]), where: ${x}WhereUniqueInputObjectSchema  })`)}`)}if(h){let e=[`import { ${x}UpdateManyMutationInputObjectSchema } from './objects/${x}UpdateManyMutationInput.schema'`,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`];await i(c.join(l.outputPath,`schemas/${h}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}UpdateMany`,`z.object({ data: ${x}UpdateManyMutationInputObjectSchema, where: ${x}WhereInputObjectSchema.optional()  })`)}`)}if(g){let e=[`import { ${x}UpdateManyAndReturnInputObjectSchema } from './objects/${x}UpdateManyAndReturnInput.schema'`];await i(c.join(l.outputPath,`schemas/${g}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}UpdateManyAndReturn`,`z.object({ data: z.union([ ${x}UpdateManyAndReturnInputObjectSchema, z.array(${x}UpdateManyAndReturnInputObjectSchema) ]), ${l.provider===`mongodb`||l.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(_){let e=[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(c.join(l.outputPath,`schemas/${_}.schema.ts`),`${this.generateImportStatements(e)}${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 e=[O,`import { ${x}WhereInputObjectSchema } from './objects/${x}WhereInput.schema'`,`import { ${x}WhereUniqueInputObjectSchema } from './objects/${x}WhereUniqueInput.schema'`],t=[];this.aggregateOperationSupport[x]&&(this.aggregateOperationSupport[x].count&&(e.push(`import { ${x}CountAggregateInputObjectSchema } from './objects/${x}CountAggregateInput.schema'`),t.push(`_count: z.union([ z.literal(true), ${x}CountAggregateInputObjectSchema ]).optional()`)),this.aggregateOperationSupport[x].min&&(e.push(`import { ${x}MinAggregateInputObjectSchema } from './objects/${x}MinAggregateInput.schema'`),t.push(`_min: ${x}MinAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].max&&(e.push(`import { ${x}MaxAggregateInputObjectSchema } from './objects/${x}MaxAggregateInput.schema'`),t.push(`_max: ${x}MaxAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].avg&&(e.push(`import { ${x}AvgAggregateInputObjectSchema } from './objects/${x}AvgAggregateInput.schema'`),t.push(`_avg: ${x}AvgAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[x].sum&&(e.push(`import { ${x}SumAggregateInputObjectSchema } from './objects/${x}SumAggregateInput.schema'`),t.push(`_sum: ${x}SumAggregateInputObjectSchema.optional()`))),await i(c.join(l.outputPath,`schemas/${v}.schema.ts`),`${this.generateImportStatements(e)}${this.generateExportSchemaStatement(`${x}Aggregate`,`z.object({ ${k} where: ${x}WhereInputObjectSchema.optional(), cursor: ${x}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${t.join(`, `)} })`)}`)}if(y){let e=[`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(c.join(l.outputPath,`schemas/${y}.schema.ts`),`${this.generateImportStatements(e)}${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(t){let{name:r}=t,i=n(t),a=l.isGenerateSelect?`import { ${e(r)}SelectObjectSchema } from './objects/${e(r)}Select.schema'`:``,o=l.isGenerateInclude&&i?`import { ${e(r)}IncludeObjectSchema } from './objects/${e(r)}Include.schema'`:``,s=``,c=``,u=``,d=``;if(l.isGenerateSelect){let t=`${e(r)}SelectObjectSchema.optional()`;s=`select: ${t},`,u=`select: z.lazy(() => ${t}),`}if(l.isGenerateInclude&&i){let t=`${e(r)}IncludeObjectSchema.optional()`;c=`include: ${t},`,d=`include: z.lazy(() => ${t}),`}return{selectImport:a,includeImport:o,selectZodSchemaLine:s,includeZodSchemaLine:c,selectZodSchemaLineLazy:u,includeZodSchemaLineLazy:d}}resolveOrderByWithRelationImportAndZodSchemaLine(t){let{name:n}=t,r=``;return r=[`postgresql`,`mysql`].includes(l.provider)&&l.previewFeatures?.includes(`fullTextSearch`)?`${e(n)}OrderByWithRelationAndSearchRelevanceInput`:`${e(n)}OrderByWithRelationInput`,{orderByImport:`import { ${r}ObjectSchema } from './objects/${r}.schema'`,orderByZodSchemaLine:`orderBy: z.union([${r}ObjectSchema, ${r}ObjectSchema.array()]).optional(),`}}};export{l as default};
+//#endregion
+export { Transformer as default };
 //# sourceMappingURL=transformer.mjs.map