@postxl/generator 0.68.0 → 0.69.1

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRepositoryMethodsTypeSignatures = exports.generateMockRepository = exports.generateRepository = void 0;
+exports.generateRepository = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
@@ -21,29 +21,13 @@ function generateRepository({ model, meta }) {
             (0, types_1.toAnnotatedTypeName)(model.typeName),
             (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
             meta.types.toBrandedIdTypeFnName,
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.create),
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.update),
-            (0, types_1.toAnnotatedTypeName)(meta.types.dto.upsert),
+            meta.types.dto.create,
+            meta.types.dto.update,
+            meta.types.dto.upsert,
+            meta.types.dto.clone,
         ],
         [schemaMeta.actions.execution.interfaceLocation.import]: [schemaMeta.actions.execution.interface],
     });
-    // NOTE: We first generate different parts of the code responsible for a particular task
-    //   and then we combine them into the final code block.
-    //
-    // Based on the model, the repository is generated slightly differently:
-    //  1.) if the model has a default field, the repository will have a public variable "defaultValue"
-    //      that is set and verified during init,
-    //  2.) if the model has a generated id, the repository will have a function "generateNextId" that
-    //      is used to generate the next id. The `create` and `createMany` functions will use this function
-    //      and allow being called with an id,
-    //  3.) unique string fields are ensured to be unique,
-    //  4.) max length string fields are ensured to not exceed their max length,
-    //  5.) index for fields marked with index or unique 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,43 +35,15 @@ function generateRepository({ model, meta }) {
     const validationBlocks = generateValidationBlocks({ model, meta });
     const indexBlocks = generateIndexBlocks({ model, schemaMeta, meta, imports });
     const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
-    let mainBlocks;
-    if (model.attributes.inMemoryOnly) {
-        mainBlocks = _generateMainBuildingBlocks_InMemoryOnly({
-            model,
-            meta,
-            imports,
-            blocks: {
-                uniqueStringFieldsBlocks,
-                relationsBlocks,
-                defaultValueBlocks,
-                idBlocks,
-                indexBlocks,
-                maxLengthBlocks,
-                validationBlocks,
-            },
-        });
-    }
-    else {
-        mainBlocks = generateMainBuildingBlocks_InDatabase({
-            model,
-            meta,
-            schemaMeta,
-            imports,
-            blocks: {
-                uniqueStringFieldsBlocks,
-                relationsBlocks,
-                defaultValueBlocks,
-                idBlocks,
-                indexBlocks,
-                maxLengthBlocks,
-                validationBlocks,
-            },
-        });
-    }
+    imports.addImports({
+        [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
+        [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
+        [schemaMeta.backendModules.db.typesImportPath]: [(0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)(`${model.sourceName} as DbType`))],
+        [(0, types_1.toPackageName)('@postxl/runtime')]: [(0, types_1.toFunctionName)('format'), (0, types_1.toFunctionName)('pluralize')],
+    });
+    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports });
     return `
 import { Injectable, Logger } from '@nestjs/common'
-
 ${idBlocks.libraryImports}
 ${imports.generate()}
 
@@ -108,19 +64,43 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
   
   ${indexBlocks.nestedMapDeclarations.join('\n')}
 
-  ${mainBlocks.userRepositorySpecificBlocks.rootUserNameConst}
+  ${userRepositorySpecificBlocks.rootUserNameConst}
 
-  ${mainBlocks.userRepositorySpecificBlocks.getterBlock}
+  ${userRepositorySpecificBlocks.getterBlock}
 
-  ${mainBlocks.constructorCode}
+  constructor(protected db: ${schemaMeta.backendModules.db.databaseService.name}) {}
   
-  ${mainBlocks.initCode}
+  public async init() {
+    this.data.clear()
+
+    ${relationsBlocks.clearCode.join('\n')}
+
+    ${uniqueStringFieldsBlocks.clearCode.join('\n')}
+    
+    ${defaultValueBlocks.init.resetCode}
+
+    ${indexBlocks.initCode.join('\n')}
+
+    const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
 
-  ${mainBlocks.reInitCode}
+    for (const rawItem of data) {
+      const item = this.${meta.data.repository.decoderFnName}(rawItem)
+      this.set(item)
 
-  ${mainBlocks.deleteAllCode}
+      ${defaultValueBlocks.init.setCode}
+    }
+
+    ${idBlocks.initCode}
+
+    ${defaultValueBlocks.init.checkCode}
+
+    ${userRepositorySpecificBlocks.initCall}
+
+    this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
+    ${indexBlocks.initLogCode.join('\n')}
+  }
 
-  ${mainBlocks.userRepositorySpecificBlocks.rootUserInitializeBlock}
+  ${userRepositorySpecificBlocks.rootUserInitializeBlock}
 
   // NOTE: The current implementation is synchronous, but it needs to be async to conform to the interface.
   // eslint-disable-next-line @typescript-eslint/require-await
@@ -161,21 +141,254 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     return this.data.size
   }
   
-  ${mainBlocks.createCode}
+  ${(0, jsdoc_1.toJsDocComment)([
+        `Checks that item has the ${idField.name} field.`,
+        `In case none exists, ${idBlocks.verifyFunctionComment}`,
+        uniqueStringFieldsBlocks.verifyFunctionComment,
+        maxLengthBlocks.verifyFunctionComment,
+    ])}
+  private verifyItem(
+    item: ${idBlocks.verifyFunctionParameterType}
+  ): ${idBlocks.createFunctionParameterType} {
+    ${idBlocks.verifyCode}
+
+    ${maxLengthBlocks.verifyCode.join('\n')}
+
+    ${uniqueStringFieldsBlocks.verifyCode.join('\n')}
+
+    ${validationBlocks.verifyCode.join('\n')}
+
+    return {
+      ${idField.name},
+      ${model.fields
+        .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
+        .map((f) => `${f.name}: item.${f.name}`)
+        .join(',\n')}
+    }
+  }
+
+  private toCreateItem(item: ${idBlocks.createFunctionParameterType}) {
+    return {
+      ${model.fields
+        .filter((f) => !f.attributes.isReadonly || f.kind === 'id')
+        .map((f) => `${f.sourceName}: item.${f.name}`)
+        .join(',\n')},
+    }
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} and returns it.`])}
+  public async create(
+    { item, execution }: { item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
+    const mutationId = await execution.startCreateMutation({ 
+      model: '${meta.actions.actionScopeConstType}', 
+      createObject: item 
+    })
+    
+    try {    
+      const newItem = this.${meta.data.repository.decoderFnName}(
+        await this.db.${meta.data.repository.getMethodFnName}.create({
+          data: this.toCreateItem(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
+    }
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)([`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`])}
+  public async createMany(
+    {items, execution}: { items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
+    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.${meta.data.repository.decoderFnName}(item))
+
+      for (const item of result) {
+        this.set(item)
+      }
 
-  ${mainBlocks.createManyCode}
+      await execution.finishCreateManyMutation({
+        mutationId,
+        createdObjects: result,
+        entityIds: newItems.map((i) => i.id),
+      })
+      return result
+    } catch (error) {
+      await execution.errorMutation({ mutationId, error })
+      throw error
+    }
+  }
+  
+  ${(0, jsdoc_1.toJsDocComment)([`Updates a ${meta.userFriendlyName} and returns it.`])}
+  public async update(
+    { item, execution }: { item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
+    const existingItem = await this.get(item.${idField.name})
+    if (!existingItem) {
+      throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
+    }
+    
+    const mutationId = await execution.startUpdateMutation({
+      model: '${meta.actions.actionScopeConstType}',
+      entityId: item.id,
+      sourceObject: existingItem,
+      updateObject: item,
+    })
+    try {        
+      ${maxLengthBlocks.updateCode.join('\n')}
   
-  ${mainBlocks.updateCode}
+      ${uniqueStringFieldsBlocks.updateCode.join('\n')}
+      
+      const newItem = this.${meta.data.repository.decoderFnName}(
+        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)
+  
+      await execution.finishUpdateMutation({ mutationId, updatedObject: newItem })
+      return newItem
+    } catch (error) {
+      await execution.errorMutation({ mutationId, error })
+      throw error
+    }
+  }
   
-  ${mainBlocks.updateManyCode}
+  ${(0, jsdoc_1.toJsDocComment)([`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+  public async updateMany(
+    { items, execution }: { items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
+    const result: ${model.typeName}[] = []
+    for (const item of items) {
+      try {
+        const updated = await this.update({ item, execution })
+        result.push(updated)
+      } catch {
+        /* empty */
+      }
+    }
+    return result
+  }
 
-  ${mainBlocks.upsertCode}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates or updates a ${meta.userFriendlyName} and returns it.`])}
+  public async upsert(
+    { item, execution }: { item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}> {
+    const existingItem = item.${model.idField.name} ? (await 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 })
+    }
+  }
 
-  ${mainBlocks.upsertManyCode}
+  ${(0, jsdoc_1.toJsDocComment)([`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`])}
+  public async upsertMany(
+    { items, execution }: { items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.typeName}[]> {
+    const result: ${model.typeName}[] = []
+    for (const item of items) {
+      try {
+        const updated = await this.upsert({ item, execution })
+        result.push(updated)
+      } catch {
+        /* empty */
+      }
+    }
+    return result
+  }
 
-  ${mainBlocks.deleteCode}
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes a ${meta.userFriendlyName} and returns its id.`])}
+  public async delete(
+    { id, execution }: { id: ${model.brandedIdType}, execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.brandedIdType}> {
+    const existingItem = await this.get(id)
+    if (!existingItem) {
+      throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
+    }
 
-  ${mainBlocks.deleteManyCode}
+    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
+    }
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)([`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`])}
+  public async deleteMany(
+    { ids, execution }: { ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.execution.interface} }
+  ): Promise<${model.brandedIdType}[]> {
+    const deletedIds: ${model.brandedIdType}[] = []
+    for (const id of ids) {
+      try {
+        await this.delete({ id, execution })
+        deletedIds.push(id)
+      } catch {
+        /* empty */
+      }
+    }
+    return deletedIds 
+  }
+
+  ${(0, jsdoc_1.toJsDocComment)([`Creates a new ${meta.userFriendlyName} shallow clone and returns it.`])}
+  public async clone({ id, item, execution }: {
+    id: ${model.brandedIdType}
+    item: (item: ${model.typeName}) => ${meta.types.dto.clone},
+    execution: ${schemaMeta.actions.execution.interface}
+  }): Promise<${model.typeName}> {
+    const source = await this.get(id)
+    if (!source) {
+      throw new Error(\`${meta.userFriendlyName} with id \${id} not found\`)
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { id: _, ...data } = { ...source, ...item(source) }
+
+    return await this.create({ item: data, execution })
+  }
 
   ${relationsBlocks.getterFunctions.join('\n')}
 
@@ -210,575 +423,20 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     ${indexBlocks.removeCode.join('\n')}
   }
 
-  ${mainBlocks.databaseDecoderCode}  
+  /**
+   * Utility function that converts a given Database object to a TypeScript model instance
+   */
+  private ${meta.data.repository.decoderFnName}(
+    item: Pick<DbType, ${model.fields.map((f) => `'${f.sourceName}'`).join(' | ')}>
+  ): ${model.typeName} {
+    return ${meta.types.zodDecoderFnNames.fromDatabase}.parse({
+      ${model.fields.map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
+    })
+  }
 }
 `;
 }
 exports.generateRepository = generateRepository;
-/**
- * Generates a mock repository data structure for a given model: same a repository, but in memory only.
- */
-function generateMockRepository({ model: modelSource, meta: metaSource, }) {
-    // We re-use the repository block, but we change the meta data to use the mock repository name and the model to be in memory only
-    const meta = Object.assign(Object.assign({}, metaSource), { data: Object.assign(Object.assign({}, metaSource.data), { repository: Object.assign(Object.assign({}, metaSource.data.repository), { className: metaSource.data.mockRepository.className, location: metaSource.data.mockRepository.location }) }) });
-    const model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
-    return generateRepository({ model, meta });
-}
-exports.generateMockRepository = generateMockRepository;
-/**
- * Generates the main building blocks of the repository for in-memory model.
- */
-function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks, }) {
-    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
-    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports });
-    imports.addImport({ from: (0, types_1.toPackageName)('@postxl/runtime'), items: [(0, types_1.toFunctionName)('removeUndefinedProperties')] });
-    return {
-        constructorCode: '',
-        userRepositorySpecificBlocks,
-        initCode: `
-      // NOTE: The current implementation is synchronous, but it needs to be async to conform to the interface.
-      // eslint-disable-next-line @typescript-eslint/require-await
-      public async init() {
-        this.data.clear()
-
-        ${blocks.relationsBlocks.clearCode.join('\n')}
-        
-        ${blocks.uniqueStringFieldsBlocks.clearCode.join('\n')}
-        
-        ${blocks.defaultValueBlocks.init.resetCode}
-    
-        ${blocks.indexBlocks.initCode.join('\n')}
-    
-        ${userRepositorySpecificBlocks.initCall}
-      }`,
-        reInitCode: `
-      public async reInit({items, execution}: ${methodTypeSignatures.createMany.parameters[0]}): Promise<void> {
-        await this.init()
-        await this.createMany({items, execution})
-      }`,
-        deleteAllCode: `
-      public async deleteAll(): Promise<void> {
-        return this.init()
-      }`,
-        createCode: `  
-      ${(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} {
-        ${blocks.idBlocks.verifyCode}
-    
-        ${blocks.maxLengthBlocks.verifyCode.join('\n')}
-    
-        ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
-    
-        ${blocks.validationBlocks.verifyCode.join('\n')}
-
-        return {
-          ${model.idField.name},
-          ${model.fields
-            .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
-            .map((f) => `${f.name}: item.${f.name}`)
-            .join(',\n')},
-            ${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, execution }: ${methodTypeSignatures.create.parameters[0]}
-      ): ${methodTypeSignatures.create.returnType} {  
-        const mutationId = await execution.startCreateMutation({ 
-          model: '${meta.actions.actionScopeConstType}', 
-          createObject: item 
-        })
-
-        try {
-          const newItem = 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: `
-      ${(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))
-          
-          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
-        }
-      }`,
-        updateCode: `
-      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
-      public async update(
-        { item, execution }: ${methodTypeSignatures.update.parameters[0]}
-      ): ${methodTypeSignatures.update.returnType} {
-        const existingItem = await 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: '${meta.actions.actionScopeConstType}',
-          entityId: item.id,
-          sourceObject: existingItem,
-          updateObject: item,
-        })
-        try { 
-          ${blocks.maxLengthBlocks.updateCode.join('\n')}
-      
-          ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
-          
-          const newItem = { ...existingItem, ...removeUndefinedProperties(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} ? (await 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: `
-      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
-      public async delete(
-        { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
-      ): ${methodTypeSignatures.delete.returnType} {
-        const existingItem = await this.get(id)
-        if (!existingItem) {
-          throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
-        }
-        const mutationId = await execution.startDeleteMutation({
-          model: '${meta.actions.actionScopeConstType}',
-          entityId: id,
-          sourceObject: existingItem,
-        })
-        try {
-          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: ``,
-    };
-}
-/**
- * Generates the methods of the repository for a model that is stored in the database.
- */
-function generateMainBuildingBlocks_InDatabase({ model, meta, schemaMeta, imports, blocks, }) {
-    const decoderFunctionName = meta.data.repository.decoderFnName;
-    const { idField } = model;
-    imports.addImports({
-        [meta.types.importPath]: [meta.types.zodDecoderFnNames.fromDatabase],
-        [schemaMeta.backendModules.db.databaseService.location.import]: [schemaMeta.backendModules.db.databaseService.name],
-        [schemaMeta.backendModules.db.typesImportPath]: [(0, types_1.toAnnotatedTypeName)((0, types_1.toTypeName)(`${model.sourceName} as DbType`))],
-        [(0, types_1.toPackageName)('@postxl/runtime')]: [(0, types_1.toFunctionName)('format'), (0, types_1.toFunctionName)('pluralize')],
-    });
-    const dbTableName = [model.sourceSchemaName, model.sourceName]
-        .filter((s) => s != null)
-        .map((part) => `"${part}"`)
-        .join('.');
-    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
-    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports });
-    return {
-        constructorCode: `constructor(protected db: ${schemaMeta.backendModules.db.databaseService.name}) {}`,
-        userRepositorySpecificBlocks,
-        initCode: `
-      public async init() {
-        this.data.clear()
-
-        ${blocks.relationsBlocks.clearCode.join('\n')}
-
-        ${blocks.uniqueStringFieldsBlocks.clearCode.join('\n')}
-        
-        ${blocks.defaultValueBlocks.init.resetCode}
-
-        ${blocks.indexBlocks.initCode.join('\n')}
-
-        const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
-
-        for (const rawItem of data) {
-          const item = this.${decoderFunctionName}(rawItem)
-          this.set(item)
-
-          ${blocks.defaultValueBlocks.init.setCode}
-        }
-
-        ${blocks.idBlocks.initCode}
-
-        ${blocks.defaultValueBlocks.init.checkCode}
-
-        ${userRepositorySpecificBlocks.initCall}
-
-        this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
-        ${blocks.indexBlocks.initLogCode.join('\n')}
-      }`,
-        reInitCode: `
-      public async reInit(
-        { items, execution }: ${methodTypeSignatures.createMany.parameters[0]}
-      ): Promise<void> {
-        if (!this.db.isTestDB) {
-          const errorMsg =
-            'ReInit() shall only be called in tests using MockRepositories or in DB configured for E2E tests!'
-          this.logger.error(errorMsg)
-          throw new Error(errorMsg)
-        }
-
-        await this.db.runOnlyOnTestDb(() => this.createMany({ items, execution }))
-
-        return this.init()
-      }`,
-        deleteAllCode: `
-      public async deleteAll(): Promise<void> {
-        await this.db.runOnlyOnTestDb(() => this.db.$executeRaw\`DELETE FROM ${dbTableName}\`)
-
-        return this.init()
-      }
-    `,
-        // prettier-ignore
-        createCode: `
-      ${(0, jsdoc_1.toJsDocComment)([
-            `Checks that item has the ${idField.name} field.`,
-            `In case none exists, ${blocks.idBlocks.verifyFunctionComment}`,
-            blocks.uniqueStringFieldsBlocks.verifyFunctionComment,
-            blocks.maxLengthBlocks.verifyFunctionComment,
-        ])}
-      private verifyItem(
-        item: ${blocks.idBlocks.verifyFunctionParameterType}
-      ): ${blocks.idBlocks.createFunctionParameterType} {
-        ${blocks.idBlocks.verifyCode}
-    
-        ${blocks.maxLengthBlocks.verifyCode.join('\n')}
-    
-        ${blocks.uniqueStringFieldsBlocks.verifyCode.join('\n')}
-
-        ${blocks.validationBlocks.verifyCode.join('\n')}
-    
-        return {
-          ${idField.name},
-          ${model.fields
-            .filter((f) => f.kind !== 'id' && !f.attributes.isReadonly)
-            .map((f) => `${f.name}: item.${f.name}`)
-            .join(',\n')}
-        }
-      }
-    
-      private toCreateItem(item: ${blocks.idBlocks.createFunctionParameterType}) {
-        return {
-          ${model.fields
-            .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, 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)
-          await execution.finishCreateMutation({ mutationId, createdObject: newItem, entityId: newItem.id })
-          return newItem
-        } catch (error) {
-          await execution.errorMutation({ mutationId, error })
-          throw error
-        }
-      }`,
-        // prettier-ignore
-        createManyCode: `
-      ${(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)
-          }
-
-          await execution.finishCreateManyMutation({
-            mutationId,
-            createdObjects: result,
-            entityIds: newItems.map((i) => i.id),
-          })
-          return result
-        } catch (error) {
-          await execution.errorMutation({ mutationId, error })
-          throw error
-        }
-      }`,
-        updateCode: `
-      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.update.jsDoc)}
-      public async update(
-        { item, execution }: ${methodTypeSignatures.update.parameters[0]}
-      ): ${methodTypeSignatures.update.returnType} {
-        const existingItem = await this.get(item.${idField.name})
-        if (!existingItem) {
-          throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
-        }
-        
-        const mutationId = await execution.startUpdateMutation({
-          model: '${meta.actions.actionScopeConstType}',
-          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)
-      
-          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} ? (await 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: `
-      ${(0, jsdoc_1.toJsDocComment)(methodTypeSignatures.delete.jsDoc)}
-      public async delete(
-        { id, execution }: ${methodTypeSignatures.delete.parameters[0]}
-      ): ${methodTypeSignatures.delete.returnType} {
-        const existingItem = await this.get(id)
-        if (!existingItem) {
-          throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
-        }
-    
-        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 
-      }`,
-        databaseDecoderCode: `
-      /**
-       * Utility function that converts a given Database object to a TypeScript model instance
-       */
-      private ${decoderFunctionName}(
-        item: Pick<DbType, ${model.fields.map((f) => `'${f.sourceName}'`).join(' | ')}>
-      ): ${model.typeName} {
-        return ${meta.types.zodDecoderFnNames.fromDatabase}.parse({
-          ${model.fields.map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
-        })
-      }`,
-    };
-}
 function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports, }) {
     if (model.name !== 'User') {
         return {
@@ -815,40 +473,6 @@ function generateUserRepositorySpecificBlocks_InDatabase({ model, meta, imports,
       }`,
     };
 }
-function generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports, }) {
-    if (model.name !== 'User') {
-        return {
-            rootUserNameConst: '',
-            getterBlock: '',
-            initCall: '',
-            rootUserInitializeBlock: '',
-        };
-    }
-    const { rootUserId, rootUserValue } = generateSharedRootUserBlocks({ model, meta, imports });
-    return {
-        rootUserNameConst: `public static ROOT_USER_ID = ${meta.types.toBrandedIdTypeFnName}(${rootUserId})`,
-        getterBlock: `
-      // We initialize the root user in the init() function
-      private _rootUser!: ${meta.types.typeName}
-      public get rootUser(): ${meta.types.typeName} {
-        return this._rootUser
-      }`,
-        initCall: `await this.initializeRootUser()`,
-        rootUserInitializeBlock: `
-      private async initializeRootUser(): Promise<void> {
-        const existingRootUser = await this.get(${meta.data.repository.className}.ROOT_USER_ID)
-        if (existingRootUser) {
-          this._rootUser = existingRootUser
-          return
-        }
-    
-        const rawUser = { ${rootUserValue} }
-        const newRootUser = this.verifyItem (rawUser)
-        this.set(newRootUser)
-        this._rootUser = newRootUser
-      }`,
-    };
-}
 function generateSharedRootUserBlocks({ model, meta, imports, }) {
     var _a;
     const providedDefault = model.attributes.systemUser;
@@ -969,139 +593,67 @@ function generateSharedRootUserBlocks({ model, meta, imports, }) {
 function generateIdBlocks({ model, meta }) {
     const idField = model.idField;
     if (!idField.isGenerated) {
-        return _generateIdBlocks_NoGeneration({ idField, model, meta });
+        return {
+            libraryImports: '',
+            generateNextIdFunctionName: '',
+            initCode: '',
+            verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
+            verifyFunctionParameterType: meta.types.dto.create,
+            verifyCode: `
+        if (item.${idField.name} === undefined) {
+          throw new Error('Id field ${idField.name} is required!')
+        }
+        const ${idField.name} = ${meta.types.toBrandedIdTypeFnName}(item.${idField.name})`,
+            setCode: '',
+            createFunctionParameterType: model.typeName,
+        };
     }
     if (idField.schemaType === 'Int') {
-        return _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 && f.kind !== 'id');
+        return {
+            libraryImports: '',
+            generateNextIdFunctionName: `
+          protected currentMaxId = 0
+          public generateNextId(): ${model.brandedIdType} {
+            return ${meta.types.toBrandedIdTypeFnName}(++this.currentMaxId)
+          }`,
+            initCode: `this.currentMaxId = (await this.db.${meta.data.repository.getMethodFnName}.aggregate({ _max: { ${idField.sourceName}: true } }))._max.${idField.sourceName} ?? 0`,
+            verifyFunctionComment: 'the id is generated by increasing the highest former id and assigned to the item.',
+            // prettier-ignore
+            verifyFunctionParameterType: `(Omit<${model.typeName}, ${generatedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+            verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+            createFunctionParameterType: 
+            // NOTE: In case we have readonly fields, we need to omit them from the create function.
+            readonlyFields.length === 0
+                ? model.typeName
+                : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
+            setCode: `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }`,
+        };
     }
     if (idField.schemaType === 'String') {
-        return _generateIdBlock_UUID({ idField, model, meta });
-    }
-    throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
-}
-/**
- * Returns a collection of type signatures for the repository methods of a given model.
- */
-// 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 schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    return {
-        create: {
-            jsDoc: [`Creates a new ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.create}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        createMany: {
-            jsDoc: [`Creates multiple new ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.create}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        update: {
-            jsDoc: [`Updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.update}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        updateMany: {
-            jsDoc: [`Updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.update}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        upsert: {
-            jsDoc: [`Creates or updates a ${meta.userFriendlyName} and returns it.`],
-            parameters: [`{item: ${meta.types.dto.upsert}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}>`,
-        },
-        upsertMany: {
-            jsDoc: [`Creates or updates multiple ${meta.userFriendlyNamePlural} and returns them.`],
-            parameters: [`{items: ${meta.types.dto.upsert}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.typeName}[]>`,
-        },
-        delete: {
-            jsDoc: [`Deletes a ${meta.userFriendlyName} and returns its id.`],
-            parameters: [`{id: ${model.brandedIdType}, execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.brandedIdType}>`,
-        },
-        deleteMany: {
-            jsDoc: [`Deletes multiple ${meta.userFriendlyNamePlural} and returns their ids.`],
-            parameters: [`{ids: ${model.brandedIdType}[], execution: ${schemaMeta.actions.execution.interface}}`],
-            returnType: `Promise<${model.brandedIdType}[]>`,
-        },
-    };
-}
-exports.getRepositoryMethodsTypeSignatures = getRepositoryMethodsTypeSignatures;
-/**
- * Generates the id block code chunks for a model that requires an ID field to be manually
- * supplied to the create function.
- */
-function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
-    return {
-        libraryImports: '',
-        generateNextIdFunctionName: '',
-        initCode: '',
-        verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
-        verifyFunctionParameterType: meta.types.dto.create,
-        verifyCode: `
-      if (item.${idField.name} === undefined) {
-        throw new Error('Id field ${idField.name} is required!')
-      }
-      const ${idField.name} = ${meta.types.toBrandedIdTypeFnName}(item.${idField.name})`,
-        setCode: '',
-        createFunctionParameterType: model.typeName,
-    };
-}
-/**
- * Generates the id block code chunks for a model that has an integer id field.
- * Given chunks make sure that the id is unique if provided or generate a new one if not.
- */
-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 && f.kind !== 'id');
-    return {
-        libraryImports: '',
-        generateNextIdFunctionName: `
-      protected currentMaxId = 0
-      public generateNextId(): ${model.brandedIdType} {
-        return ${meta.types.toBrandedIdTypeFnName}(++this.currentMaxId)
-      }`,
-        initCode: `this.currentMaxId = (await this.db.${meta.data.repository.getMethodFnName}.aggregate({ _max: { ${idField.sourceName}: true } }))._max.${idField.sourceName} ?? 0`,
-        verifyFunctionComment: 'the id is generated by increasing the highest former id and assigned to the item.',
-        // prettier-ignore
-        verifyFunctionParameterType: `(Omit<${model.typeName}, ${generatedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
-        verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
-        createFunctionParameterType: 
-        // NOTE: In case we have readonly fields, we need to omit them from the create function.
-        readonlyFields.length === 0
-            ? model.typeName
-            : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
-        setCode: `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }`,
-    };
-}
-/**
- * Generates the id block code chunks for a model that has a UUID id field.
- * It allows you to provide a custom id or generates a new one if not.
- */
-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 && f.kind !== 'id');
-    return {
-        libraryImports: `import { randomUUID } from 'crypto'`,
-        generateNextIdFunctionName: `
+        const dbGeneratedFields = model.fields.filter((f) => f.kind === 'id' || f.attributes.isReadonly);
+        const readonlyFields = model.fields.filter((f) => f.attributes.isReadonly && f.kind !== 'id');
+        return {
+            libraryImports: `import { randomUUID } from 'crypto'`,
+            generateNextIdFunctionName: `
       public generateNextId(): ${model.brandedIdType} {
         return ${meta.types.toBrandedIdTypeFnName}(randomUUID())
       }`,
-        initCode: '',
-        verifyFunctionComment: 'a new UUID is generated and assigned to the item.',
-        // prettier-ignore
-        verifyFunctionParameterType: `(Omit<${model.typeName}, ${dbGeneratedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
-        verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
-        createFunctionParameterType: 
-        // NOTE: In case we have readonly fields, we need to omit them from the create function.
-        readonlyFields.length === 0
-            ? model.typeName
-            : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
-        setCode: '',
-    };
+            initCode: '',
+            verifyFunctionComment: 'a new UUID is generated and assigned to the item.',
+            // prettier-ignore
+            verifyFunctionParameterType: `(Omit<${model.typeName}, ${dbGeneratedFields.map((f) => `'${f.name}'`).join(' | ')}> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+            verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+            createFunctionParameterType: 
+            // NOTE: In case we have readonly fields, we need to omit them from the create function.
+            readonlyFields.length === 0
+                ? model.typeName
+                : `Omit<${model.typeName}, ${readonlyFields.map((f) => `'${f.name}'`).join(' |')}>`,
+            setCode: '',
+        };
+    }
+    throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
 }
 /**
  * Returns the code chunks that define the default value property and its initialization.