@bairock/lenz 0.0.14 → 0.0.16

package/dist/engine/generators/DelegateTemplateBody.js

@@ -0,0 +1,776 @@
+import { toCamelCase } from './helpers.js';
+function genIdExpression(generator) {
+    switch (generator) {
+        case 'uuid': return 'crypto.randomUUID()';
+        case 'cuid': return "'cuid_' + crypto.randomUUID().slice(0, 8)";
+        case 'cuid2': return "'c' + crypto.randomUUID().replace(/-/g, '').toLowerCase().slice(0, 23)";
+        case 'ulid': return `(() => { const ENC = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; let ts = Date.now(); let r = ''; for (let i = 0; i < 10; i++) { r = ENC[ts % 32] + r; ts = Math.floor(ts / 32); } const rand = crypto.randomUUID().replace(/-/g, '').toUpperCase(); for (let i = 0; i < 16; i++) { r += ENC[parseInt(rand[i % rand.length], 16) % 32]; } return r; })()`;
+        case 'now': return 'new Date()';
+        default: return 'new ObjectId()';
+    }
+}
+export function genCreateMethods(model, validateCall, hasBigInt, customIdGenerator) {
+    const idExpr = genIdExpression(customIdGenerator);
+    return `
+  async create(args: ${model.name}CreateArgs): Promise<${model.name}> {
+    return this.execute('create', async () => {
+      const now = new Date()
+      const parentId = ${idExpr}
+
+      const relationFields = ['${model.relations.filter(r => !r.joinCollection).map(r => r.field).join("', '")}'] as const;
+      const nestedData: Record<string, any> = {};
+      const scalarData: Record<string, any> = {};
+      for (const [key, value] of Object.entries(args.data)) {
+        if (relationFields.includes(key as any) && typeof value === 'object' && value !== null && !Array.isArray(value) && !(value as any).equals) {
+          nestedData[key] = value;
+        } else if (relationFields.includes(key as any) && Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && !(value[0] as any)?.equals) {
+          nestedData[key] = value;
+        } else {
+          scalarData[key] = value;
+        }
+      }
+
+      ${validateCall}
+      ${hasBigInt ? `this.convertBigIntFields(scalarData)\n` : '      '}const document = {
+        ...this.defaultValues,
+        ...scalarData,
+        _id: parentId,
+        createdAt: now,
+        updatedAt: now
+      }
+
+      const result = await this.collection.insertOne(document, args.session ? { session: args.session } : {})
+      const parentDocId = result.insertedId.toString()
+
+      const postCreateSets: Record<string, any> = {};
+      const postCreatePushes: Record<string, any> = {};
+      ${model.relations.filter(r => !r.joinCollection).map(rel => {
+        const delegate = `this.client.${toCamelCase(rel.target)}`;
+        const fkInSource = rel.foreignKeyLocation === 'source' || !rel.foreignKeyLocation;
+        const isArray = rel.isForeignKeyArray;
+        const childFkArg = (!fkInSource && rel.foreignKey) ? `, ${rel.foreignKey}: parentDocId` : '';
+        if (rel.type === 'oneToMany' || rel.type === 'manyToMany') {
+            return `
+      if (nestedData.${rel.field}) {
+        const ${rel.field}Data = nestedData.${rel.field};
+        if (${rel.field}Data.create) {
+          const created = await Promise.all(
+            (Array.isArray(${rel.field}Data.create) ? ${rel.field}Data.create : [${rel.field}Data.create]).map(data =>
+              ${delegate}.create({ data: { ...data${childFkArg} } })
+            )
+          );
+          const ids = created.map(c => c.id);
+          ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(...ids);` : `postCreateSets.${rel.foreignKey} = ids.length === 1 ? ids[0] : ids;`) : ''}
+        }
+        if (${rel.field}Data.connect) {
+          const connectIds = (Array.isArray(${rel.field}Data.connect) ? ${rel.field}Data.connect : [${rel.field}Data.connect]).map(c => c.id);
+          ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(...connectIds);` : `postCreateSets.${rel.foreignKey} = connectIds.length === 1 ? connectIds[0] : connectIds;`) : ''}
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const items = Array.isArray(${rel.field}Data.connectOrCreate) ? ${rel.field}Data.connectOrCreate : [${rel.field}Data.connectOrCreate];
+          for (const item of items) {
+            const existing = await ${delegate}.findUnique({ where: item.where });
+            if (existing) {
+              ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(existing.id);` : `postCreateSets.${rel.foreignKey} = existing.id;`) : ''}
+            } else {
+              const created = await ${delegate}.create({ data: { ...item.create${childFkArg} } });
+              ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(created.id);` : `postCreateSets.${rel.foreignKey} = created.id;`) : ''}
+            }
+          }
+        }
+      }`;
+        }
+        else {
+            return `
+      if (nestedData.${rel.field}) {
+        const ${rel.field}Data = nestedData.${rel.field};
+        if (${rel.field}Data.create) {
+          const created = await ${delegate}.create({ data: { ...${rel.field}Data.create${childFkArg} } });
+          ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(created.id);` : `postCreateSets.${rel.foreignKey} = created.id;`) : ''}
+        }
+        if (${rel.field}Data.connect) {
+          ${fkInSource ? `postCreateSets.${rel.foreignKey} = ${rel.field}Data.connect.id;` : ''}
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const existing = await ${delegate}.findUnique({ where: ${rel.field}Data.connectOrCreate.where });
+          if (existing) {
+            ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(existing.id);` : `postCreateSets.${rel.foreignKey} = existing.id;`) : ''}
+          } else {
+            const created = await ${delegate}.create({ data: { ...${rel.field}Data.connectOrCreate.create${childFkArg} } });
+            ${fkInSource ? (isArray ? `(postCreatePushes.${rel.foreignKey} || (postCreatePushes.${rel.foreignKey} = [])).push(created.id);` : `postCreateSets.${rel.foreignKey} = created.id;`) : ''}
+          }
+        }
+      }`;
+        }
+    }).join('\n')}
+
+      ${model.relations.filter(r => r.joinCollection).map(rel => {
+        const delegate = `this.client.${toCamelCase(rel.target)}`;
+        const sourceField = `${toCamelCase(model.name)}Id`;
+        const targetField = `${toCamelCase(rel.target)}Id`;
+        return `
+      if (nestedData.${rel.field}) {
+        const ${rel.field}Data = nestedData.${rel.field};
+        const joinCol = this.client.\\$db.collection('${rel.joinCollection}');
+        if (${rel.field}Data.create) {
+          const created = await Promise.all(
+            (Array.isArray(${rel.field}Data.create) ? ${rel.field}Data.create : [${rel.field}Data.create]).map(data =>
+              ${delegate}.create({ data: { ...data } })
+            )
+          );
+          for (const c of created) {
+            await joinCol.insertOne({ ${sourceField}: parentDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.connect) {
+          const connectItems = Array.isArray(${rel.field}Data.connect) ? ${rel.field}Data.connect : [${rel.field}Data.connect];
+          for (const c of connectItems) {
+            await joinCol.insertOne({ ${sourceField}: parentDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const items = Array.isArray(${rel.field}Data.connectOrCreate) ? ${rel.field}Data.connectOrCreate : [${rel.field}Data.connectOrCreate];
+          for (const item of items) {
+            const existing = await ${delegate}.findUnique({ where: item.where });
+            if (existing) {
+              await joinCol.insertOne({ ${sourceField}: parentDocId, ${targetField}: existing.id }, args.session ? { session: args.session } : {});
+            } else {
+              const created = await ${delegate}.create({ data: item.create });
+              await joinCol.insertOne({ ${sourceField}: parentDocId, ${targetField}: created.id }, args.session ? { session: args.session } : {});
+            }
+          }
+        }
+      }`;
+    }).join('\n')}
+
+      if (Object.keys(postCreateSets).length > 0 || Object.keys(postCreatePushes).length > 0) {
+        const postUpdate: Record<string, any> = {};
+        if (Object.keys(postCreateSets).length > 0) postUpdate.$set = postCreateSets;
+        if (Object.keys(postCreatePushes).length > 0) {
+          postUpdate.$push = {};
+          for (const [field, ids] of Object.entries(postCreatePushes)) {
+            postUpdate.$push[field] = { $each: ids as string[] };
+          }
+        }
+        await this.collection.updateOne(
+          { _id: parentId },
+          postUpdate,
+          args.session ? { session: args.session } : {}
+        );
+      }
+
+      const createdDoc = await this.collection.findOne(
+        { _id: parentId },
+        args.session ? { session: args.session } : {}
+      )
+
+      if (!createdDoc) {
+        throw new Error('Failed to create document')
+      }
+
+      const formatted = RelationResolver.formatDocument(createdDoc)
+      const omitted = this.applyOmit(formatted, args.omit)
+
+      if (args.include) {
+        return await this.includeRelations(omitted, args.include)
+      }
+
+      return omitted
+    })
+  }
+
+  async createMany(args: { data: ${model.name}CreateInput[]; session?: any; skipDuplicates?: boolean }): Promise<{ count: number }> {
+    return this.execute('createMany', async () => {
+      const now = new Date()
+      const relationFieldNames = ['${model.relations.filter(r => !r.joinCollection).map(r => r.field).join("', '")}'] as const;
+      const documents = args.data.map(data => {
+        const doc: Record<string, any> = { ...this.defaultValues, _id: ${idExpr}, createdAt: now, updatedAt: now };
+        for (const [key, value] of Object.entries(data)) {
+          if (!relationFieldNames.includes(key as any) || typeof value !== 'object' || value === null || (value as any).equals) {
+            doc[key] = value;
+          }
+        }
+        return doc;
+      })
+${hasBigInt ? `
+      for (const doc of documents) {
+        this.convertBigIntFields(doc);
+      }` : ''}
+
+      const insertOptions: any = {}
+      if (args.session) insertOptions.session = args.session
+      if (args.skipDuplicates) {
+        insertOptions.ordered = false
+      }
+
+      try {
+        const result = await this.collection.insertMany(documents, insertOptions)
+        return { count: result.insertedCount }
+      } catch (error: any) {
+        if (args.skipDuplicates && error?.code === 11000) {
+          return { count: error?.insertedCount ?? error?.result?.nInserted ?? 0 }
+        }
+        throw error
+      }
+    })
+  }
+`;
+}
+export function genUpdateMethods(model, hasBigInt, cascadeUpdateCall) {
+    return `
+  async update(args: ${model.name}UpdateArgs): Promise<${model.name}> {
+    return this.execute('update', async () => {
+      const whereForUpdate = await this.processRelationFilters(args.where)
+      const query = QueryBuilder.buildWhere(whereForUpdate)
+
+      const relationFields = ['${model.relations.filter(r => !r.joinCollection).map(r => r.field).join("', '")}'] as const;
+      const nestedUpdateData: Record<string, any> = {};
+      const scalarUpdateData: Record<string, any> = {};
+      for (const [key, value] of Object.entries(args.data)) {
+        if (relationFields.includes(key as any) && typeof value === 'object' && value !== null) {
+          nestedUpdateData[key] = value;
+        } else {
+          scalarUpdateData[key] = value;
+        }
+      }
+
+      ${hasBigInt ? `this.convertBigIntFields(scalarUpdateData)\n` : ''}      const updateData = {
+        ...scalarUpdateData,
+        updatedAt: new Date()
+      }
+
+      const update = QueryBuilder.buildUpdate(updateData)
+      // Fetch pre-update document for cascade update diffing
+      const preUpdateDoc = await this.collection.findOne(
+        query,
+        args.session ? { session: args.session } : {}
+      )
+      const result = await this.collection.findOneAndUpdate(
+        query,
+        update,
+        { returnDocument: 'after', ...(args.session ? { session: args.session } : {}) }
+      )
+
+      const updatedDoc = result && 'value' in result ? result.value : result
+      if (!updatedDoc) {
+        throw new Error('Document not found')
+      }
+
+      const updatedDocId = RelationResolver.formatDocument(updatedDoc).id;
+      const preRelationDoc = preUpdateDoc ? RelationResolver.formatDocument(preUpdateDoc) : null;
+
+      const postUpdateSets: Record<string, any> = {};
+      const postUpdatePushes: Record<string, any> = {};
+      const postUpdatePulls: Record<string, any> = {};
+      ${model.relations.filter(r => !r.joinCollection).map(rel => {
+        const delegate = `this.client.${toCamelCase(rel.target)}`;
+        const fkInSource = rel.foreignKeyLocation === 'source' || !rel.foreignKeyLocation;
+        const isArray = rel.isForeignKeyArray;
+        const childFkArg = (!fkInSource && rel.foreignKey) ? `, ${rel.foreignKey}: updatedDocId` : '';
+        if (rel.type === 'oneToMany' || rel.type === 'manyToMany') {
+            return `
+      if (nestedUpdateData.${rel.field}) {
+        const ${rel.field}Data = nestedUpdateData.${rel.field};
+        if (${rel.field}Data.create) {
+          const created = await Promise.all(
+            (Array.isArray(${rel.field}Data.create) ? ${rel.field}Data.create : [${rel.field}Data.create]).map(data =>
+              ${delegate}.create({ data: { ...data${childFkArg} } })
+            )
+          );
+          const ids = created.map(c => c.id);
+          ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(...ids);` : `postUpdateSets.${rel.foreignKey} = ids.length === 1 ? ids[0] : ids;`) : ''}
+        }
+        if (${rel.field}Data.connect) {
+          const connectIds = (Array.isArray(${rel.field}Data.connect) ? ${rel.field}Data.connect : [${rel.field}Data.connect]).map(c => c.id);
+          ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(...connectIds);` : `postUpdateSets.${rel.foreignKey} = connectIds.length === 1 ? connectIds[0] : connectIds;`) : ''}
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const items = Array.isArray(${rel.field}Data.connectOrCreate) ? ${rel.field}Data.connectOrCreate : [${rel.field}Data.connectOrCreate];
+          for (const item of items) {
+            const existing = await ${delegate}.findUnique({ where: item.where });
+            if (existing) {
+              ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(existing.id);` : `postUpdateSets.${rel.foreignKey} = existing.id;`) : ''}
+            } else {
+              const created = await ${delegate}.create({ data: { ...item.create${childFkArg} } });
+              ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(created.id);` : `postUpdateSets.${rel.foreignKey} = created.id;`) : ''}
+            }
+          }
+        }
+        if (${rel.field}Data.disconnect) {
+          const disconnectIds = (Array.isArray(${rel.field}Data.disconnect) ? ${rel.field}Data.disconnect : [${rel.field}Data.disconnect]).map(c => c.id);
+          ${fkInSource && isArray ? `(postUpdatePulls.${rel.foreignKey} || (postUpdatePulls.${rel.foreignKey} = [])).push(...disconnectIds);` : fkInSource ? `postUpdateSets.${rel.foreignKey} = null;` : ''}
+        }
+        if (${rel.field}Data.set) {
+          const setIds = (Array.isArray(${rel.field}Data.set) ? ${rel.field}Data.set : [${rel.field}Data.set]).map(c => c.id);
+          ${fkInSource ? (isArray ? `postUpdateSets.${rel.foreignKey} = setIds;` : `postUpdateSets.${rel.foreignKey} = setIds.length === 1 ? setIds[0] : setIds;`) : ''}
+        }
+        if (${rel.field}Data.update) {
+          const updateItems = Array.isArray(${rel.field}Data.update) ? ${rel.field}Data.update : [${rel.field}Data.update];
+          for (const item of updateItems) {
+            await ${delegate}.update({ where: item.where, data: item.data });
+          }
+        }
+        if (${rel.field}Data.delete) {
+          const deleteItems = Array.isArray(${rel.field}Data.delete) ? ${rel.field}Data.delete : [${rel.field}Data.delete];
+          for (const item of deleteItems) {
+            await ${delegate}.delete({ where: item });
+          }
+        }
+        if (${rel.field}Data.upsert) {
+          const upsertItems = Array.isArray(${rel.field}Data.upsert) ? ${rel.field}Data.upsert : [${rel.field}Data.upsert];
+          for (const item of upsertItems) {
+            await ${delegate}.upsert({ where: item.where, create: item.create, update: item.update });
+          }
+        }
+        if (${rel.field}Data.updateMany) {
+          await ${delegate}.updateMany({ where: ${rel.field}Data.updateMany.where, data: ${rel.field}Data.updateMany.data });
+        }
+        if (${rel.field}Data.deleteMany) {
+          await ${delegate}.deleteMany({ where: ${rel.field}Data.deleteMany });
+        }
+      }`;
+        }
+        else {
+            return `
+      if (nestedUpdateData.${rel.field}) {
+        const ${rel.field}Data = nestedUpdateData.${rel.field};
+        if (${rel.field}Data.create) {
+          const created = await ${delegate}.create({ data: { ...${rel.field}Data.create${childFkArg} } });
+          ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(created.id);` : `postUpdateSets.${rel.foreignKey} = created.id;`) : ''}
+        }
+        if (${rel.field}Data.connect) {
+          ${fkInSource ? `postUpdateSets.${rel.foreignKey} = ${rel.field}Data.connect.id;` : ''}
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const existing = await ${delegate}.findUnique({ where: ${rel.field}Data.connectOrCreate.where });
+          if (existing) {
+            ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(existing.id);` : `postUpdateSets.${rel.foreignKey} = existing.id;`) : ''}
+          } else {
+            const created = await ${delegate}.create({ data: { ...${rel.field}Data.connectOrCreate.create${childFkArg} } });
+            ${fkInSource ? (isArray ? `(postUpdatePushes.${rel.foreignKey} || (postUpdatePushes.${rel.foreignKey} = [])).push(created.id);` : `postUpdateSets.${rel.foreignKey} = created.id;`) : ''}
+          }
+        }
+        if (${rel.field}Data.disconnect) {
+          ${fkInSource && !isArray ? `postUpdateSets.${rel.foreignKey} = null;` : ''}
+        }
+        if (${rel.field}Data.update && updatedDoc.${rel.foreignKey}) {
+          await ${delegate}.update({ where: { id: String(updatedDoc.${rel.foreignKey}) }, data: ${rel.field}Data.update });
+        }
+        if (${rel.field}Data.delete && updatedDoc.${rel.foreignKey}) {
+          await ${delegate}.delete({ where: { id: String(updatedDoc.${rel.foreignKey}) } });
+        }
+        if (${rel.field}Data.upsert) {
+          await ${delegate}.upsert({ where: ${rel.field}Data.upsert.where, create: ${rel.field}Data.upsert.create, update: ${rel.field}Data.upsert.update });
+        }
+      }`;
+        }
+    }).join('\n')}
+
+      ${model.relations.filter(r => r.joinCollection).map(rel => {
+        const delegate = `this.client.${toCamelCase(rel.target)}`;
+        const sourceField = `${toCamelCase(model.name)}Id`;
+        const targetField = `${toCamelCase(rel.target)}Id`;
+        return `
+      if (nestedUpdateData.${rel.field}) {
+        const ${rel.field}Data = nestedUpdateData.${rel.field};
+        const joinCol = this.client.\\$db.collection('${rel.joinCollection}');
+        if (${rel.field}Data.create) {
+          const created = await Promise.all(
+            (Array.isArray(${rel.field}Data.create) ? ${rel.field}Data.create : [${rel.field}Data.create]).map(data =>
+              ${delegate}.create({ data: { ...data } })
+            )
+          );
+          for (const c of created) {
+            await joinCol.insertOne({ ${sourceField}: updatedDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.connect) {
+          const connectItems = Array.isArray(${rel.field}Data.connect) ? ${rel.field}Data.connect : [${rel.field}Data.connect];
+          for (const c of connectItems) {
+            await joinCol.insertOne({ ${sourceField}: updatedDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.disconnect) {
+          const disconnectItems = Array.isArray(${rel.field}Data.disconnect) ? ${rel.field}Data.disconnect : [${rel.field}Data.disconnect];
+          for (const c of disconnectItems) {
+            await joinCol.deleteOne({ ${sourceField}: updatedDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.set) {
+          await joinCol.deleteMany({ ${sourceField}: updatedDocId }, args.session ? { session: args.session } : {});
+          const setItems = Array.isArray(${rel.field}Data.set) ? ${rel.field}Data.set : [${rel.field}Data.set];
+          for (const c of setItems) {
+            await joinCol.insertOne({ ${sourceField}: updatedDocId, ${targetField}: c.id }, args.session ? { session: args.session } : {});
+          }
+        }
+        if (${rel.field}Data.connectOrCreate) {
+          const items = Array.isArray(${rel.field}Data.connectOrCreate) ? ${rel.field}Data.connectOrCreate : [${rel.field}Data.connectOrCreate];
+          for (const item of items) {
+            const existing = await ${delegate}.findUnique({ where: item.where });
+            if (existing) {
+              await joinCol.insertOne({ ${sourceField}: updatedDocId, ${targetField}: existing.id }, args.session ? { session: args.session } : {});
+            } else {
+              const created = await ${delegate}.create({ data: item.create });
+              await joinCol.insertOne({ ${sourceField}: updatedDocId, ${targetField}: created.id }, args.session ? { session: args.session } : {});
+            }
+          }
+        }
+        if (${rel.field}Data.update) {
+          const updateItems = Array.isArray(${rel.field}Data.update) ? ${rel.field}Data.update : [${rel.field}Data.update];
+          for (const item of updateItems) {
+            await ${delegate}.update({ where: item.where, data: item.data });
+          }
+        }
+        if (${rel.field}Data.delete) {
+          const deleteItems = Array.isArray(${rel.field}Data.delete) ? ${rel.field}Data.delete : [${rel.field}Data.delete];
+          for (const item of deleteItems) {
+            const del = await ${delegate}.delete({ where: item });
+            if (del) {
+              await joinCol.deleteOne({ ${sourceField}: updatedDocId, ${targetField}: del.id }, args.session ? { session: args.session } : {});
+            }
+          }
+        }
+        if (${rel.field}Data.updateMany) {
+          await ${delegate}.updateMany({ where: ${rel.field}Data.updateMany.where, data: ${rel.field}Data.updateMany.data });
+        }
+        if (${rel.field}Data.deleteMany) {
+          await ${delegate}.deleteMany({ where: ${rel.field}Data.deleteMany });
+        }
+        if (${rel.field}Data.upsert) {
+          const upsertItems = Array.isArray(${rel.field}Data.upsert) ? ${rel.field}Data.upsert : [${rel.field}Data.upsert];
+          for (const item of upsertItems) {
+            await ${delegate}.upsert({ where: item.where, create: item.create, update: item.update });
+          }
+        }
+      }`;
+    }).join('\n')}
+
+      if (Object.keys(postUpdateSets).length > 0 || Object.keys(postUpdatePushes).length > 0 || Object.keys(postUpdatePulls).length > 0) {
+        const postUpdateCmd: Record<string, any> = {};
+        if (Object.keys(postUpdateSets).length > 0) postUpdateCmd.$set = postUpdateSets;
+        if (Object.keys(postUpdatePushes).length > 0) {
+          postUpdateCmd.$push = {};
+          for (const [field, ids] of Object.entries(postUpdatePushes)) {
+            postUpdateCmd.$push[field] = { $each: ids as string[] };
+          }
+        }
+        if (Object.keys(postUpdatePulls).length > 0) {
+          const pullCmd: Record<string, any> = {};
+          for (const [field, ids] of Object.entries(postUpdatePulls)) {
+            pullCmd[field] = { $in: ids as string[] };
+          }
+          postUpdateCmd.$pull = pullCmd;
+        }
+        await this.collection.updateOne(
+          { _id: new ObjectId(updatedDocId) },
+          postUpdateCmd,
+          args.session ? { session: args.session } : {}
+        );
+      }
+
+      const finalDoc = await this.collection.findOne(
+        { _id: new ObjectId(updatedDocId) },
+        args.session ? { session: args.session } : {}
+      )
+
+      const formatted = RelationResolver.formatDocument(finalDoc || updatedDoc)
+      const omitted = this.applyOmit(formatted, args.omit)
+${cascadeUpdateCall}
+      if (args.include) {
+        return await this.includeRelations(omitted, args.include)
+      }
+
+      return omitted
+    })
+  }
+
+  async updateMany(args: { where?: ${model.name}WhereInput; data: ${model.name}UpdateInput; session?: any }): Promise<{ count: number }> {
+    return this.execute('updateMany', async () => {
+      const whereMany = args.where ? await this.processRelationFilters(args.where) : {}
+      const query = QueryBuilder.buildWhere(whereMany)
+      const relationFieldNames = ['${model.relations.filter(r => !r.joinCollection).map(r => r.field).join("', '")}'] as const;
+      const updateData: Record<string, any> = { updatedAt: new Date() };
+      for (const [key, value] of Object.entries(args.data)) {
+        if (!relationFieldNames.includes(key as any) || typeof value !== 'object' || value === null || (value as any).equals) {
+          updateData[key] = value;
+        }
+      }
+
+      ${hasBigInt ? 'this.convertBigIntFields(updateData)\n' : ''}      const update = QueryBuilder.buildUpdate(updateData)
+      const result = await this.collection.updateMany(query, update, args.session ? { session: args.session } : {})
+      return { count: result.modifiedCount }
+    })
+  }
+`;
+}
+export function genUpsert(model, hasBigInt, customIdGenerator) {
+    const relationFields = model.relations.filter(r => !r.joinCollection).map(r => r.field);
+    const idExpr = genIdExpression(customIdGenerator);
+    return `
+  async upsert(args: ${model.name}UpsertArgs): Promise<${model.name}> {
+    return this.execute('upsert', async () => {
+      const whereForUpsert = await this.processRelationFilters(args.where)
+      const query = QueryBuilder.buildWhere(whereForUpsert)
+      const upsertRelationFields = [${relationFields.map(f => `'${f}'`).join(', ')}] as const;
+      const nestedCreate: Record<string, any> = {};
+      const scalarCreate: Record<string, any> = {};
+      for (const [key, value] of Object.entries(args.create)) {
+        if (upsertRelationFields.includes(key as any) && typeof value === 'object' && value !== null && !(value as any).equals) {
+          nestedCreate[key] = value;
+        } else {
+          scalarCreate[key] = value;
+        }
+      }
+
+      const now = new Date()
+${hasBigInt ? `      this.convertBigIntFields(scalarCreate)\n` : ''}      const setData: Record<string, any> = {};
+      for (const [key, value] of Object.entries(args.update)) {
+        if (!upsertRelationFields.includes(key as any) || typeof value !== 'object' || value === null || (value as any).equals) {
+          setData[key] = value;
+        }
+      }
+      setData.updatedAt = now;
+${hasBigInt ? `      this.convertBigIntFields(setData)\n` : ''}
+      const result = await this.collection.findOneAndUpdate(
+        query,
+        {
+          $set: setData,
+          $setOnInsert: { ...this.defaultValues, ...scalarCreate, _id: ${idExpr}, createdAt: now, updatedAt: now }
+        },
+        { returnDocument: 'after', upsert: true, ...(args.session ? { session: args.session } : {}) }
+      )
+
+      const doc = result && 'value' in result ? result.value : result
+      if (!doc) {
+        throw new Error('Upsert failed')
+      }
+
+      const formatted = RelationResolver.formatDocument(doc)
+      const omitted = this.applyOmit(formatted, args.omit)
+
+      if (Object.keys(nestedCreate).length > 0) {
+        return await this.update({
+          where: { id: formatted.id },
+          data: nestedCreate as any,
+          include: args.include,
+          omit: args.omit,
+        });
+      }
+
+      if (args.include) {
+        return await this.includeRelations(omitted, args.include)
+      }
+
+      return omitted
+    })
+  }
+`;
+}
+export function genDeleteMethods(model, cascadeDeleteCall, cascadeDeleteManyBody) {
+    return `
+  async delete(args: ${model.name}DeleteArgs): Promise<${model.name} | null> {
+    return this.execute('delete', async () => {
+      const whereForDelete = await this.processRelationFilters(args.where)
+      const query = QueryBuilder.buildWhere(whereForDelete)
+      const doc = await this.collection.findOne(query, args.session ? { session: args.session } : {})
+
+      if (!doc) return null
+${cascadeDeleteCall}
+      await this.collection.deleteOne(query, args.session ? { session: args.session } : {})
+      const formatted = RelationResolver.formatDocument(doc)
+      const omitted = this.applyOmit(formatted, args.omit)
+
+      if (args.include) {
+        return await this.includeRelations(omitted, args.include)
+      }
+
+      return omitted
+    })
+  }
+
+  async deleteMany(args: { where?: ${model.name}WhereInput; session?: any }): Promise<{ count: number }> {
+    return this.execute('deleteMany', async () => {
+${cascadeDeleteManyBody}
+    })
+  }
+`;
+}
+export function genAggregate(model) {
+    return `
+  async aggregate(args: ${model.name}AggregateArgs): Promise<${model.name}AggregateResult> {
+    return this.execute('aggregate', async () => {
+      const pipeline: any[] = [];
+
+      if (args.where && Object.keys(args.where).length > 0) {
+        pipeline.push({ $match: QueryBuilder.buildWhere(args.where) })
+      }
+
+      const groupStage: any = { _id: null };
+
+      if (args._count) {
+        if (args._count === true) {
+          groupStage._count_all = { $sum: 1 }
+        } else if (Array.isArray(args._count)) {
+          for (const field of args._count) {
+            groupStage[\`_count_\${field}\`] = { $sum: 1 }
+          }
+        }
+      }
+
+      for (const op of ['_sum', '_avg', '_min', '_max'] as const) {
+        const fields = (args as any)[op];
+        if (fields && Array.isArray(fields)) {
+          const mongoOp = op === '_sum' ? '$sum' : op === '_avg' ? '$avg' : op === '_min' ? '$min' : '$max';
+          for (const field of fields) {
+            groupStage[\`\${op}_\${field}\`] = { [mongoOp]: \`$\${field}\` }
+          }
+        }
+      }
+
+      pipeline.push({ $group: groupStage });
+
+      const result = await this.collection.aggregate(pipeline, args.session ? { session: args.session } : {}).toArray()
+
+      if (result.length === 0) {
+        const empty: any = { _count: 0 };
+        ['_sum', '_avg', '_min', '_max'].forEach(op => {
+          if ((args as any)[op]) empty[op] = {};
+        });
+        return empty as ${model.name}AggregateResult
+      }
+
+      const data = result[0];
+      const output: any = {};
+
+      if (args._count === true) {
+        output._count = data._count_all || 0
+      } else if (Array.isArray(args._count)) {
+        const countResult: any = {};
+        for (const field of args._count) {
+          countResult[field] = data[\`_count_\${field}\`] || 0
+        }
+        output._count = countResult
+      }
+
+      for (const op of ['_sum', '_avg', '_min', '_max'] as const) {
+        const fields = (args as any)[op];
+        if (fields && Array.isArray(fields)) {
+          const opResult: any = {};
+          for (const field of fields) {
+            opResult[field] = data[\`\${op}_\${field}\`] ?? null
+          }
+          output[op] = opResult
+        }
+      }
+
+      return output as ${model.name}AggregateResult
+    })
+  }
+`;
+}
+export function genGroupBy(model) {
+    return `
+  async groupBy(args: ${model.name}GroupByArgs): Promise<${model.name}GroupByResult[]> {
+    return this.execute('groupBy', async () => {
+      const pipeline: any[] = [];
+
+      if (args.where && Object.keys(args.where).length > 0) {
+        pipeline.push({ $match: QueryBuilder.buildWhere(args.where) })
+      }
+
+      const groupId: any = {};
+      for (const field of args.by) {
+        groupId[field] = \`$\${field}\`;
+      }
+
+      const groupStage: any = { _id: groupId };
+
+      const addAccumulator = (field: string, op: string, target: string) => {
+        if (!groupStage[target]) groupStage[target] = {};
+        groupStage[target][field] = { [\`$\${op}\`]: \`$\${field}\` };
+      };
+
+      if (args._count) {
+        if (args._count === true) {
+          groupStage._count = { _all: { $sum: 1 } };
+        } else if (Array.isArray(args._count)) {
+          groupStage._count = { _all: { $sum: 1 } };
+          for (const field of args._count) {
+            if (!groupStage._count) groupStage._count = {};
+            groupStage._count[field] = { $sum: { $cond: [{ $ne: [\`$\${field}\`, null] }, 1, 0] } };
+          }
+        }
+      }
+
+      if (args._sum && Array.isArray(args._sum)) {
+        for (const field of args._sum) {
+          addAccumulator(field, 'sum', '_sum');
+        }
+      }
+
+      if (args._avg && Array.isArray(args._avg)) {
+        for (const field of args._avg) {
+          addAccumulator(field, 'avg', '_avg');
+        }
+      }
+
+      if (args._min && Array.isArray(args._min)) {
+        for (const field of args._min) {
+          addAccumulator(field, 'min', '_min');
+        }
+      }
+
+      if (args._max && Array.isArray(args._max)) {
+        for (const field of args._max) {
+          addAccumulator(field, 'max', '_max');
+        }
+      }
+
+      pipeline.push({ $group: groupStage });
+
+      const projectStage: any = { _id: 0 };
+      for (const field of args.by) {
+        projectStage[field] = \`$\${'_id.' + field}\`;
+      }
+
+      const aggTargets = ['_count', '_sum', '_avg', '_min', '_max'];
+      for (const target of aggTargets) {
+        if (groupStage[target]) {
+          projectStage[target] = 1;
+        }
+      }
+
+      if (Object.keys(projectStage).length > 1) {
+        pipeline.push({ $project: projectStage });
+      }
+
+      if (args.having && Object.keys(args.having).length > 0) {
+        const having = args.having as Record<string, any>;
+        const havingQuery = QueryBuilder.buildWhere(having);
+        // buildWhere converts id→_id, but after $project: { _id: 0 } the _id field is excluded.
+        // The projected field is 'id', so revert the conversion for having filters.
+        if ('id' in having && '_id' in havingQuery) {
+          havingQuery.id = havingQuery._id;
+          delete havingQuery._id;
+        }
+        pipeline.push({ $match: havingQuery })
+      }
+
+      if (args.orderBy) {
+        pipeline.push({ $sort: QueryBuilder.buildSort(args.orderBy) })
+      }
+
+      if (args.skip) {
+        pipeline.push({ $skip: args.skip })
+      }
+      if (args.take) {
+        pipeline.push({ $limit: args.take })
+      }
+
+      const result = await this.collection.aggregate(pipeline, args.session ? { session: args.session } : {}).toArray()
+      return result as ${model.name}GroupByResult[]
+    })
+  }
+`;
+}
+//# sourceMappingURL=DelegateTemplateBody.js.map