@postxl/generator 0.67.0 → 0.69.0

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.getRepositoryMethodsTypeSignatures = exports.generateRepository = void 0;
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
@@ -51,41 +51,14 @@ 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,
-            schemaMeta,
-            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 });
+    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
     return `
 import { Injectable, Logger } from '@nestjs/common'
 ${idBlocks.libraryImports}
@@ -108,19 +81,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()
 
-  ${mainBlocks.reInitCode}
+    ${relationsBlocks.clearCode.join('\n')}
 
-  ${mainBlocks.deleteAllCode}
+    ${uniqueStringFieldsBlocks.clearCode.join('\n')}
+    
+    ${defaultValueBlocks.init.resetCode}
+
+    ${indexBlocks.initCode.join('\n')}
 
-  ${mainBlocks.userRepositorySpecificBlocks.rootUserInitializeBlock}
+    const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
+
+    for (const rawItem of data) {
+      const item = this.${meta.data.repository.decoderFnName}(rawItem)
+      this.set(item)
+
+      ${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')}
+  }
+
+  ${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 +158,237 @@ 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')}
 
-  ${mainBlocks.createManyCode}
+    ${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)(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.${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)(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.${meta.data.repository.decoderFnName}(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
+    }
+  }
+  
+  ${(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 {        
+      ${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)(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
+  }
+
+  ${(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 })
+    }
+  }
+
+  ${(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
+  }
 
-  ${mainBlocks.upsertCode}
+  ${(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!\`)
+    }
 
-  ${mainBlocks.upsertManyCode}
+    const mutationId = await execution.startDeleteMutation({
+      model: '${meta.actions.actionScopeConstType}',
+      entityId: id,
+      sourceObject: existingItem,
+    })
+    try {
 
-  ${mainBlocks.deleteCode}
+      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
+    }
+  }
 
-  ${mainBlocks.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 
+  }
 
   ${relationsBlocks.getterFunctions.join('\n')}
 
@@ -210,581 +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, schemaMeta, imports, blocks, }) {
-    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
-    const userRepositorySpecificBlocks = generateUserRepositorySpecificBlocks_InMemoryOnly({ model, meta, imports });
-    imports.addImport({
-        from: schemaMeta.backendModules.common.importPath,
-        items: ['removeUndefinedProperties'].map(types_1.toFunctionName),
-    });
-    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`))],
-        [schemaMeta.backendModules.common.importPath]: [
-            schemaMeta.backendModules.common.functions.format,
-            schemaMeta.backendModules.common.functions.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 {
@@ -821,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;