@postxl/generator 0.34.0 → 0.36.0

package/dist/generators/models/repository.generator.js

@@ -13,19 +13,18 @@ const string_1 = require("../../lib/utils/string");
  */
 function generateRepository({ model, meta }) {
     const { idField } = model;
-    const imports = imports_1.ImportsGenerator.from(meta.data.repoFilePath)
-        .addImport({
-        items: [model.typeName, model.brandedIdType],
-        from: meta.types.importPath,
-    })
-        .addImport({
-        items: [(0, types_1.toClassName)('Repository')],
-        // TODO: Unify DataLib Imports https://github.com/PostXL/PostXL/issues/344!
-        from: (0, types_1.toFileName)(model.schemaConfig.paths.dataLibPath + 'repository.type'),
-    })
-        .addImport({
-        items: [meta.types.toBrandedIdTypeFnName],
-        from: meta.types.importPath,
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
+    const imports = imports_1.ImportsGenerator.from(meta.data.repoFilePath).addImports({
+        [schemaMeta.data.repositoryTypeFilePath]: schemaMeta.data.repositoryTypeName,
+        [meta.types.importPath]: [
+            model.typeName,
+            model.brandedIdType,
+            meta.types.toBrandedIdTypeFnName,
+            meta.types.dto.create,
+            meta.types.dto.update,
+            meta.types.dto.upsert,
+        ],
+        [schemaMeta.actions.importPath]: [schemaMeta.actions.actionExecutionInterface],
     });
     // NOTE: We first generate different parts of the code responsible for a particular task
     //   and then we combine them into the final code block.
@@ -40,6 +39,10 @@ function generateRepository({ model, meta }) {
     //  4.) max length string fields are ensured to not exceed their max length,
     //  5.) index for fields marked with index attribute,
     //  6.) relations are indexed by the foreign key.
+    //
+    // The repository is generated differently based on whether the model is stored in the database or in memory.
+    // If the model is stored in the database, all CUD operations will result in a database call. If the model is
+    // stored in memory, all CUD operations will be performed in memory without any database calls.
     const idBlocks = generateIdBlocks({ model, meta });
     const defaultValueBlocks = generateDefaultBlocks({ model, meta });
     const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
@@ -51,6 +54,7 @@ function generateRepository({ model, meta }) {
         mainBlocks = _generateMainBuildingBlocks_InMemoryOnly({
             model,
             meta,
+            schemaMeta,
             blocks: {
                 uniqueStringFieldsBlocks,
                 defaultValueBlocks,
@@ -64,6 +68,7 @@ function generateRepository({ model, meta }) {
         mainBlocks = generateMainBuildingBlocks_InDatabase({
             model,
             meta,
+            schemaMeta,
             imports,
             blocks: {
                 uniqueStringFieldsBlocks,
@@ -139,8 +144,16 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   
   ${mainBlocks.updateCode}
   
+  ${mainBlocks.updateManyCode}
+
+  ${mainBlocks.upsertCode}
+
+  ${mainBlocks.upsertManyCode}
+
   ${mainBlocks.deleteCode}
 
+  ${mainBlocks.deleteManyCode}
+
   ${relationsBlocks.getterFunctions.join('\n')}
 
   ${maxLengthBlocks.ensureMaxLengthFunctions.join('\n')}
@@ -208,22 +221,24 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         return Promise.resolve()
       }`,
         reInitCode: `
-      public async reInit(data: ${model.typeName}[]): Promise<void> {
+      public async reInit({items, execution}: ${methodTypeSignatures.createMany.parameters[0]}): Promise<void> {
         await this.init()
-        await this.createMany(data)
+        await this.createMany({items, execution})
       }`,
         deleteAllCode: `
       public async deleteAll(): Promise<void> {
         return this.init()
       }`,
         createCode: `  
-      ${(0, jsdoc_1.jsDocComment)([
+      ${(0, jsdoc_1.toJsDocComment)([
             `Checks that item has the ${model.idField.name} field.`,
             `In case none exists, ${blocks.idBlocks.verifyFunctionComment}`,
             blocks.uniqueStringFieldsBlocks.verifyFunctionComment,
             blocks.maxLengthBlocks.verifyFunctionComment,
         ])}
-      private verifyItem(item: ${blocks.idBlocks.verifyFunctionParameterType}): ${model.name} {
+      private verifyItem(
+        item: ${blocks.idBlocks.verifyFunctionParameterType}
+      ): ${model.name} {
         ${blocks.idBlocks.verifyCode}
     
         ${blocks.maxLengthBlocks.verifyCode.join('\n')}
@@ -239,61 +254,178 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
             ${model.createdAtField ? `${model.createdAtField.sourceName}: new Date(),` : ''}
             ${model.updatedAtField ? `${model.updatedAtField.sourceName}: new Date(),` : ''}  
         }
-      }
-
+      }  
+      
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
       // Non-mocked version is async - so we keep type-compatible signatures for create() and createWithId() 
       // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
       public async create(
-        item: ${methodTypeSignatures.create.parameters[0]}
+        { item, execution }: ${methodTypeSignatures.create.parameters[0]}
       ): ${methodTypeSignatures.create.returnType} {  
-        const newItem = await Promise.resolve(this.verifyItem(item))
-    
-        this.set(newItem)
-        return newItem
+        const mutationId = await execution.startCreateMutation({ 
+          model: '${meta.actions.actionScopeConstType}', 
+          createObject: item 
+        })
+
+        try {
+          const newItem = await Promise.resolve(this.verifyItem(item))
+      
+          this.set(newItem)
+          await execution.finishCreateMutation({ mutationId, createdObject: newItem, entityId: newItem.id })
+          return newItem
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        }
       }`,
         createManyCode: `
-      public async createMany(items: ${blocks.idBlocks.verifyFunctionParameterType}[]) {
-        const newItems = items.map((item) => this.verifyItem(item))
-        
-        await Promise.resolve()
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
+      public async createMany(
+        { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
+      ): ${methodTypeSignatures.createMany.returnType} {
+        const mutationId = await execution.startCreateManyMutation({ 
+          model: '${meta.actions.actionScopeConstType}', 
+          createObjects: items 
+        })
 
-        for (const item of newItems) {
-          this.set(item)
+        try {
+          const newItems = items.map((item) => this.verifyItem(item))
+          
+          await Promise.resolve()
+
+          for (const item of newItems) {
+            this.set(item)
+          }
+          
+          await execution.finishCreateManyMutation({
+            mutationId,
+            createdObjects: newItems,
+            entityIds: newItems.map((i) => i.id),
+          })
+          return newItems
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
         }
-        
-        return newItems
       }`,
-        // prettier-ignore
         updateCode: `
-      public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
+      public async update(
+        { item, execution }: ${methodTypeSignatures.update.parameters[0]}
+      ): ${methodTypeSignatures.update.returnType} {
         const existingItem = this.get(item.id)
     
         if (!existingItem) {
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
         }
+        const mutationId = await execution.startUpdateMutation({
+          model: 'post',
+          entityId: item.id,
+          sourceObject: existingItem,
+          updateObject: item,
+        })
+        try { 
+          ${blocks.maxLengthBlocks.updateCode.join('\n')}
       
-        ${blocks.maxLengthBlocks.updateCode.join('\n')}
-    
-        ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
-        
-        const newItem = await Promise.resolve({ ...existingItem, ...item })
-        ${model.updatedAtField ? `newItem.${model.updatedAtField.name} = new Date()` : ''}
-
-        this.remove(existingItem)
-        this.set(newItem)
-    
-        return newItem
+          ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
+          
+          const newItem = await Promise.resolve({ ...existingItem, ...item })
+          ${model.updatedAtField ? `newItem.${model.updatedAtField.name} = new Date()` : ''}
+  
+          this.remove(existingItem)
+          this.set(newItem)
+      
+          await execution.finishUpdateMutation({ mutationId, updatedObject: newItem })
+          return newItem
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        } 
+      }`,
+        updateManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
+      public async updateMany(
+        { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
+      ): ${methodTypeSignatures.updateMany.returnType} {
+        const result: ${model.typeName}[] = []
+        for (const item of items) {
+          try {
+            const updated = await this.update({ item, execution })
+            result.push(updated)
+          } catch {
+            /* empty */
+          }
+        }
+        return result
+      }`,
+        upsertCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
+      public async upsert(
+        { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
+      ): ${methodTypeSignatures.upsert.returnType} {
+        const existingItem = item.${model.idField.name} ? this.get(item.${model.idField.name}) : null
+        if (existingItem) {
+          return this.update({ item: item as ${meta.types.dto.update}, execution })
+        } else {
+          return this.create({ item: item as ${meta.types.dto.create}, execution })
+        }
+      }`,
+        upsertManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
+      public async upsertMany(
+        { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
+      ): ${methodTypeSignatures.upsertMany.returnType} {
+        const result: ${model.typeName}[] = []
+        for (const item of items) {
+          try {
+            const updated = await this.upsert({ item, execution })
+            result.push(updated)
+          } catch {
+            /* empty */
+          }
+        }
+        return result
       }`,
         deleteCode: `
-      public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
+      public async delete(
+        { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
+      ): ${methodTypeSignatures.delete.returnType} {
         const existingItem = this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
         }
-    
-        await Promise.resolve()
+        const mutationId = await execution.startDeleteMutation({
+          model: '${meta.actions.actionScopeConstType}',
+          entityId: id,
+          sourceObject: existingItem,
+        })
+        try {
+          await Promise.resolve()
         
-        this.remove(existingItem)
+          this.remove(existingItem)
+          await execution.finishDeleteMutation({ mutationId })
+          return id
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        }
+      }`,
+        deleteManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
+      public async deleteMany(
+        { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
+      ): ${methodTypeSignatures.deleteMany.returnType} {
+        const deletedIds: ${model.brandedIdType}[] = []
+        for (const id of ids) {
+          try {
+            await this.delete({ id, execution })
+            deletedIds.push(id)
+          } catch {
+            /* empty */
+          }
+        }
+        return deletedIds 
       }`,
         databaseDecoderCode: ``,
     };
@@ -304,15 +436,10 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
 function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }) {
     const decoderFunctionName = meta.data.repository.decoderFnName;
     const { idField } = model;
-    imports
-        .addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath })
-        .addImport({
-        items: [`DbService`, `${model.sourceName} as DbType`].map(types_1.toTypeName),
-        from: (0, types_1.toFileName)('@pxl/db'),
-    })
-        .addImport({
-        items: [`format`, `pluralize`].map(types_1.toTypeName),
-        from: (0, types_1.toFileName)('@pxl/common'),
+    imports.addImports({
+        [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
+        [(0, types_1.toFileName)('@pxl/db')]: [`DbService`, `${model.sourceName} as DbType`].map(types_1.toTypeName),
+        [(0, types_1.toFileName)('@pxl/common')]: [`format`, `pluralize`].map(types_1.toTypeName),
     });
     const dbTableName = [model.sourceSchemaName, model.sourceName]
         .filter((s) => s != null)
@@ -348,7 +475,9 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         ${blocks.indexBlocks.initLogCode.join('\n')}
       }`,
         reInitCode: `
-      public async reInit(data: ${model.typeName}[]): Promise<void> {
+      public async reInit(
+        { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
+      ): Promise<void> {
         if (!this.db.useE2ETestDB) {
           const errorMsg =
             'ReInit() shall only be called in tests using MockRepositories or in DB configured for E2E tests!'
@@ -356,7 +485,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
           throw new Error(errorMsg)
         }
 
-        await this.db.runOnlyOnTestDb(() => this.db.${meta.data.repository.getMethodFnName}.createMany({ data: data.map((i) => this.toCreateItem(i)) }))
+        await this.db.runOnlyOnTestDb(() => this.createMany({ items, execution }))
 
         return this.init()
       }`,
@@ -367,8 +496,9 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         return this.init()
       }
     `,
+        // prettier-ignore
         createCode: `
-      ${(0, jsdoc_1.jsDocComment)([
+      ${(0, jsdoc_1.toJsDocComment)([
             `Checks that item has the ${idField.name} field.`,
             `In case none exists, ${blocks.idBlocks.verifyFunctionComment}`,
             blocks.uniqueStringFieldsBlocks.verifyFunctionComment,
@@ -395,98 +525,218 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       private toCreateItem(item: ${blocks.idBlocks.createFunctionParameterType}) {
         return {
           ${model.fields
-            .filter((f) => !f.attributes.isReadonly)
+            .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
             .map((f) => `${f.sourceName}: item.${f.name}`)
             .join(',\n')},
         }
       }
 
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.create.jsDoc)}
       public async create(
-        item: ${methodTypeSignatures.create.parameters[0]}
-      ): ${methodTypeSignatures.create.returnType} {    
-        const newItem = this.${decoderFunctionName}(
-          await this.db.${meta.data.repository.getMethodFnName}.create({
-            data: this.toCreateItem(this.verifyItem(item)),
-          }),
-        )
+        { item, execution }: ${methodTypeSignatures.create.parameters[0]}
+      ): ${methodTypeSignatures.create.returnType} {
+        const mutationId = await execution.startCreateMutation({ 
+          model: '${meta.actions.actionScopeConstType}', 
+          createObject: item 
+        })
+        
+        try {    
+          const newItem = this.${decoderFunctionName}(
+            await this.db.${meta.data.repository.getMethodFnName}.create({
+              data: this.toCreateItem(this.verifyItem(item)),
+            }),
+          )
     
-        this.set(newItem)
-        return newItem
+          this.set(newItem)
+          await execution.finishCreateMutation({ mutationId, createdObject: newItem, entityId: newItem.id })
+          return newItem
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        }
       }`,
+        // prettier-ignore
         createManyCode: `
-      public async createMany(items: ${blocks.idBlocks.verifyFunctionParameterType}[]) {
-        const newItems = items.map((item) => this.verifyItem(item))
-        
-        await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: newItems.map(i => this.toCreateItem(i)) })
-        
-        const dbItems = await this.db.${meta.data.repository.getMethodFnName}.findMany({ 
-          where: { 
-            ${model.idField.sourceName}: { in: newItems.map(i => i.${model.idField.name}) } 
-          } 
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.createMany.jsDoc)}
+      public async createMany(
+        {items, execution}: ${methodTypeSignatures.createMany.parameters[0]}
+      ): ${methodTypeSignatures.createMany.returnType} {
+        const mutationId = await execution.startCreateManyMutation({ 
+          model: '${meta.actions.actionScopeConstType}', 
+          createObjects: items 
         })
+        
+        try {
+          const newItems = items.map((item) => this.verifyItem(item))
+          
+          await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: newItems.map(i => this.toCreateItem(i)) })
+          
+          const dbItems = await this.db.${meta.data.repository.getMethodFnName}.findMany({ 
+            where: { 
+              ${model.idField.sourceName}: { in: newItems.map(i => i.${model.idField.name}) } 
+            } 
+          })
+  
+          const result = dbItems.map((item) => this.${decoderFunctionName}(item))
+  
+          for (const item of result) {
+            this.set(item)
+          }
 
-        const result = dbItems.map((item) => this.${decoderFunctionName}(item))
-
-        for (const item of result) {
-          this.set(item)
+          await execution.finishCreateManyMutation({
+            mutationId,
+            createdObjects: result,
+            entityIds: newItems.map((i) => i.id),
+          })
+          return result
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
         }
-        
-        return result
       }`,
-        // prettier-ignore
         updateCode: `
-      public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
+      public async update(
+        { item, execution }: ${methodTypeSignatures.update.parameters[0]}
+      ): ${methodTypeSignatures.update.returnType} {
         const existingItem = this.get(item.${idField.name})
         if (!existingItem) {
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
         }
         
-        ${blocks.maxLengthBlocks.updateCode.join('\n')}
-    
-        ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
-        
-        const newItem = this.${decoderFunctionName}(
-          await this.db.${meta.data.repository.getMethodFnName}.update({
-            where: { 
-              ${idField.sourceName}: item.${idField.name},
-            },
-            data: {
-              ${Array.from(model.fields.values())
+        const mutationId = await execution.startUpdateMutation({
+          model: 'post',
+          entityId: item.id,
+          sourceObject: existingItem,
+          updateObject: item,
+        })
+        try {        
+          ${blocks.maxLengthBlocks.updateCode.join('\n')}
+      
+          ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
+          
+          const newItem = this.${decoderFunctionName}(
+            await this.db.${meta.data.repository.getMethodFnName}.update({
+              where: { 
+                ${idField.sourceName}: item.${idField.name},
+              },
+              data: {
+                ${[...model.fields.values()]
             .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
             .map((f) => f.isRequired
             ? `${f.sourceName}: item.${f.name} ?? existingItem.${f.name}`
             : `${f.sourceName}: item.${f.name}`)
             .join(',\n')}       
-            },
-          }),
-        )
-    
-        this.remove(existingItem)
-        this.set(newItem)
-    
-        return newItem
+              },
+            }),
+          )
+      
+          this.remove(existingItem)
+          this.set(newItem)
+      
+          await execution.finishUpdateMutation({ mutationId, updatedObject: newItem })
+          return newItem
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        }
+      }`,
+        updateManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.updateMany.jsDoc)}
+      public async updateMany(
+        { items, execution }: ${methodTypeSignatures.updateMany.parameters[0]}
+      ): ${methodTypeSignatures.updateMany.returnType} {
+        const result: ${model.typeName}[] = []
+        for (const item of items) {
+          try {
+            const updated = await this.update({ item, execution })
+            result.push(updated)
+          } catch {
+            /* empty */
+          }
+        }
+        return result
+      }`,
+        upsertCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsert.jsDoc)}
+      public async upsert(
+        { item, execution }: ${methodTypeSignatures.upsert.parameters[0]}
+      ): ${methodTypeSignatures.upsert.returnType} {
+        const existingItem = item.${model.idField.name} ? this.get(item.${model.idField.name}) : null
+        if (existingItem) {
+          return this.update({ item: item as ${meta.types.dto.update}, execution })
+        } else {
+          return this.create({ item: item as ${meta.types.dto.create}, execution })
+        }
+      }`,
+        upsertManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.upsertMany.jsDoc)}
+      public async upsertMany(
+        { items, execution }: ${methodTypeSignatures.upsertMany.parameters[0]}
+      ): ${methodTypeSignatures.upsertMany.returnType} {
+        const result: ${model.typeName}[] = []
+        for (const item of items) {
+          try {
+            const updated = await this.upsert({ item, execution })
+            result.push(updated)
+          } catch {
+            /* empty */
+          }
+        }
+        return result
       }`,
         deleteCode: `
-      public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
+      public async delete(
+        { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
+      ): ${methodTypeSignatures.delete.returnType} {
         const existingItem = this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
         }
     
-        await this.db.${meta.data.repository.getMethodFnName}.delete({ where: { ${idField.sourceName}:id } })
-        
-        this.remove(existingItem)
+        const mutationId = await execution.startDeleteMutation({
+          model: '${meta.actions.actionScopeConstType}',
+          entityId: id,
+          sourceObject: existingItem,
+        })
+        try {
+
+          await this.db.${meta.data.repository.getMethodFnName}.delete({ where: { ${idField.sourceName}:id } })
+          
+          this.remove(existingItem)
+          await execution.finishDeleteMutation({ mutationId })
+          return id
+        } catch (error) {
+          await execution.errorMutation({ mutationId, error })
+          throw error
+        }
+      }`,
+        deleteManyCode: `
+      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.deleteMany.jsDoc)}
+      public async deleteMany(
+        { ids, execution }: ${methodTypeSignatures.deleteMany.parameters[0]}
+      ): ${methodTypeSignatures.deleteMany.returnType} {
+        const deletedIds: ${model.brandedIdType}[] = []
+        for (const id of ids) {
+          try {
+            await this.delete({ id, execution })
+            deletedIds.push(id)
+          } catch {
+            /* empty */
+          }
+        }
+        return deletedIds 
       }`,
-        // prettier-ignore
         databaseDecoderCode: `
       /**
        * Utility function that converts a given Database object to a TypeScript model instance
        */
       private ${decoderFunctionName}(
-        item: Pick<DbType, ${Array.from(model.fields.values()).map((f) => `'${f.sourceName}'`).join(' | ')}>
+        item: Pick<DbType, ${model.fields.map((f) => `'${f.sourceName}'`).join(' | ')}>
       ): ${model.typeName} {
-        return ${meta.types.zodDecoderFnName}.parse({
-          ${Array.from(model.fields.values()).map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
+        return ${meta.types.zodDecoderFnNames.fromDatabase}.parse({
+          ${model.fields.map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
         })
       }`,
     };
@@ -514,19 +764,47 @@ function generateIdBlocks({ model, meta }) {
 // NOTE: We export this function as an interface simplification to the repository generator. Internally, we
 //   use the same functions as the ones used in this function which we don't want to expose.
 function getRepositoryMethodsTypeSignatures({ model, meta }) {
-    const { verifyFunctionParameterType } = generateIdBlocks({ model, meta });
+    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     return {
         create: {
-            parameters: [verifyFunctionParameterType],
+            jsDoc: [`Creates a new ${meta.userFriendlyName} and returns it.`],
+            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
+        createMany: {
+            jsDoc: [`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`],
+            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.typeName}[]>`,
+        },
         update: {
-            parameters: [`Partial<${model.typeName}> & { ${model.idField.name}: ${model.brandedIdType} }`],
+            jsDoc: [`Updates a ${meta.userFriendlyName} and returns it.`],
+            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.typeName}>`,
+        },
+        updateMany: {
+            jsDoc: [`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
+            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.typeName}[]>`,
+        },
+        upsert: {
+            jsDoc: [`Creates or updates a ${meta.userFriendlyName} and returns it.`],
+            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
             returnType: `Promise<${model.typeName}>`,
         },
+        upsertMany: {
+            jsDoc: [`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
+            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.typeName}[]>`,
+        },
         delete: {
-            parameters: [model.brandedIdType],
-            returnType: `Promise<void>`,
+            jsDoc: [`Deletes a ${meta.userFriendlyName} and returns its id.`],
+            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.brandedIdType}>`,
+        },
+        deleteMany: {
+            jsDoc: [`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`],
+            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.actionExecutionInterface}}`],
+            returnType: `Promise<${model.brandedIdType}[]>`,
         },
     };
 }
@@ -541,8 +819,7 @@ function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
         generateNextIdFunctionName: '',
         initCode: '',
         verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
-        // TODO: This creates a bug!
-        verifyFunctionParameterType: model.typeName,
+        verifyFunctionParameterType: meta.types.dto.create,
         verifyCode: `
       if (item.${idField.name} === undefined) {
         throw new Error('Id field ${idField.name} is required!')
@@ -558,7 +835,7 @@ function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
  */
 function _generateIdBlock_Int({ idField, model, meta, }) {
     const generatedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
-    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly);
+    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly && f.kind !== 'id');
     return {
         libraryImports: '',
         generateNextIdFunctionName: `
@@ -585,7 +862,7 @@ function _generateIdBlock_Int({ idField, model, meta, }) {
  */
 function _generateIdBlock_UUID({ idField, model, meta, }) {
     const dbGeneratedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
-    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly);
+    const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly && f.kind !== 'id');
     return {
         libraryImports: `import { randomUUID } from 'crypto'`,
         generateNextIdFunctionName: `
@@ -673,8 +950,12 @@ function generateUniqueFieldsBlocks({ model }) {
        * Utility function that ensures that the ${f.name} field is unique
        */      
       private ${getEnsureUniqueFnName(f)}(item: { ${f.name}?: string }) {
-          if (!item.${f.name}) return
-          if (!this.uniqueIds.${f.name}.has(item.${f.name})) return
+          if (!item.${f.name}) {
+            return
+          }
+          if (!this.uniqueIds.${f.name}.has(item.${f.name})) {
+            return
+          }
           let counter = 1
     
           let ${f.name}: string
@@ -813,23 +1094,31 @@ function generateRelationsBlocks({ model, imports, }) {
             from: relationModelMeta.types.importPath,
         });
         result.mapDeclarations.push(`protected ${r.name}Map: Map<${relationModelMeta.types.brandedIdType}, Map<${model.brandedIdType}, ${model.typeName}>> = new Map()`);
-        // prettier-ignore
         result.getterFunctions.push(`
       /** 
        * Function to retrieve all ${(0, string_1.pluralize)(model.name)} that are related to a ${r.name}
        */
-      public ${fieldMeta.getByForeignKeyMethodFnName}(id: ${relationModelMeta.types.brandedIdType}): Map<${model.brandedIdType}, ${model.typeName}> {
+      public ${fieldMeta.getByForeignKeyMethodFnName}(
+        id: ${relationModelMeta.types.brandedIdType}
+      ): Map<${model.brandedIdType}, ${model.typeName}> {
         const result = this.${r.name}Map.get(id)
-        if (!result) return new Map()
+        if (!result) {
+          return new Map()
+        }
         return new Map(result)
       }
 
       /** 
        * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
        */
-      public ${fieldMeta.getByForeignKeyIdsMethodFnName}(id: ${relationModelMeta.types.brandedIdType}): ${model.brandedIdType}[] {
+      public ${fieldMeta.getByForeignKeyIdsMethodFnName}(
+        id: ${relationModelMeta.types.brandedIdType}
+      ): ${model.brandedIdType}[] {
         const s = this.${r.name}Map.get(id)
-        if (!s) return []
+        if (!s) {
+          return []
+        }
+        
         return Array.from(s.keys())
       }`);
         result.setCode.push(`