@postxl/generator 0.24.1 → 0.25.1

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

@@ -1,206 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMockRepository = exports.generateRepository = void 0;
+const imports_1 = require("../../lib/imports");
+const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
-const string_1 = require("../../lib/utils/string");
 const schema_1 = require("../../lib/schema/schema");
-const meta_1 = require("../../lib/meta");
-const imports_1 = require("../../lib/imports");
 const types_1 = require("../../lib/schema/types");
+const jsdoc_1 = require("../../lib/utils/jsdoc");
+const string_1 = require("../../lib/utils/string");
 /**
  * Generates repository data structure for a given model.
+ * Based on the model, the repository is generated slightly differently, based on:
+ * - if the model has a default field, the repository will have a public variable "defaultValue"
+ *   that is set and verified during init
+ * - 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.
+ * - unique string fields are ensured to be unique
+ * - max length string fields are ensured to not exceed their max length
+ * - index for fields marked with index attribute
+ * - relations are indexed by the foreign key
  */
 function generateRepository({ model, meta }) {
-    var _a;
-    const { idField, fields } = model;
-    const decoder = meta.data.repository.decoderFnName;
-    const uniqueStringFields = fields.filter(fields_1.isUniqueStringField);
-    const maxLengthStringFields = fields.filter(fields_1.isMaxLengthStringField);
-    const relations = fields
-        .filter(schema_1.isFieldRelation)
-        .map((field) => (Object.assign(Object.assign({}, field), { meta: (0, meta_1.getModelMetadata)({ model: field.relationToModel }), fieldMeta: (0, meta_1.getFieldMetadata)({ field }) })));
-    const getIndexDefinition = (fieldNames) => {
-        const fields = fieldNames.map((f) => {
-            const result = model.fields.find((field) => field.name === f);
-            if (!result) {
-                throw new Error(`Index field ${f} not found in model ${model.name}`);
-            }
-            if (result.kind !== 'relation') {
-                throw new Error(`Index field ${f} is not a relation in model ${model.name}`);
-            }
-            const meta = (0, meta_1.getModelMetadata)({ model: result.relationToModel });
-            return Object.assign(Object.assign({}, result), { meta });
-        });
-        const [firstField, ...restFields] = fields;
-        if (!restFields || restFields.length === 0) {
-            throw new Error(`Index for model ${model.name} must have at least 2 fields!`);
-        }
-        return {
-            fields,
-            name: (0, string_1.toCamelCase)(`${firstField.name}${restFields.map((f) => (0, string_1.toPascalCase)(f.name)).join('')}Index`),
-        };
-    };
-    const indexes = model.attributes.index ? [getIndexDefinition(model.attributes.index)] : [];
-    const defaultValueInitFn = model.defaultField
-        ? `
-		if (item.${(_a = model.defaultField) === null || _a === void 0 ? void 0 : _a.name}) {
-			if (this.defaultValue) {
-				console.warn(\`More than one default ${meta.userFriendlyName} found! \${this.defaultValue.id} and \${item.id}\`)
-			}
-			this.defaultValue = item
-		}
-	`
-        : '';
-    const defaultValueInitCheckFn = `
-		if (!this.db.isCLI && !this.defaultValue) {
-      throw new Error('No default ${meta.userFriendlyName} found!')
-    }
-	`;
-    const { isGenerated } = idField;
-    const idIntInitFn = `this.currentMaxId = (await this.db.${meta.data.repository.getMethodFnName}.aggregate({ _max: { ${idField.sourceName}: true } }))._max.${idField.sourceName} ?? 0`;
+    const { idField } = model;
     const imports = imports_1.ImportsGenerator.from(meta.data.repoFilePath)
         .addImport({
-        items: [model.typeName, model.brandedIdType, ...(isGenerated ? [meta.types.toBrandedIdTypeFnName] : [])],
+        items: [model.typeName, model.brandedIdType],
         from: meta.types.importPath,
     })
         .addImport({
         items: [(0, types_1.toClassName)('Repository')],
         from: (0, types_1.toFileName)(model.schemaConfig.paths.dataLibPath + 'repository.type'),
     });
-    if (!model.attributes.inMemoryOnly) {
-        imports.addImport({ items: [meta.types.zodDecoderFnName], from: meta.types.importPath });
-    }
-    relations.forEach((r) => {
-        imports.addImport({
-            items: [r.meta.types.brandedIdType],
-            from: r.meta.types.importPath,
-        });
-    });
+    const blocks = generateBlocks({ model, meta, imports });
+    const mainBlocks = generateMainBuildingBlocks({ model, meta, imports, blocks });
     return `
 import { Injectable, Logger } from '@nestjs/common'
-${model.attributes.inMemoryOnly
-        ? `
-  import { ${indexes.length === 0 ? '' : 'NestedMap'} } from '@pxl/common'
-  `
-        : `
-import { DbService, ${model.sourceName} as DbType } from '@${model.schemaConfig.project}/db'
-import { format, pluralize ${indexes.length === 0 ? '' : ', NestedMap'} } from '@pxl/common'
-`}
-
+${blocks.id.libraryImports}
 ${imports.generate()}
 
 @Injectable()
-export class ${meta.data.repositoryClassName} implements Repository<
-	${model.typeName}, 
-	${idField.unbrandedTypeName}
-> {
+export class ${meta.data.repositoryClassName} implements Repository<${model.typeName}, ${idField.unbrandedTypeName}> {
   protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
   protected logger = new Logger(${meta.data.repositoryClassName}.name)
 
-  ${relations
-        .map((r) => `
-    protected ${r.name}Map: Map<${r.meta.types.brandedIdType}, Map<${model.brandedIdType}, ${model.typeName}>> = new Map()
-  `)
-        .join('\n')}
-  
-  ${model.defaultField
-        ? `
-  // We can safely skip the assignment here as this is done in the init function
-  public defaultValue!: ${model.typeName}
-  `
-        : ''}
-
-  ${isGenerated
-        ? `
+  ${blocks.relations.mapDeclarations.join('\n')}
   
-  protected currentMaxId = 0\n
-  public get nextId(): ${model.brandedIdType} {
-    return ${meta.types.toBrandedIdTypeFnName}(this.currentMaxId + 1)
-  }
-  `
-        : ''}
-
-  protected uniqueIds = {
-		${uniqueStringFields.map((f) => `'${f.name}': new Map<string, ${model.typeName}>()`).join(',\n')}
-	}
-
-  ${indexes
-        .map((i) => `
-  protected ${i.name} = new NestedMap<${i.fields.map((f) => f.meta.types.brandedIdType).join(',')}, ${model.typeName}>(
-    ${i.fields.map((f) => `(x) => x.${f.name}`).join(',')}
-  )
-  `)
-        .join('\n')}
-  ${model.attributes.inMemoryOnly
-        ? ''
-        : `
-  constructor(${model.attributes.inMemoryOnly ? '' : 'protected '}db: DbService) {}
-  `}	
-  
-  public async init() {
-    this.data.clear()
-    
-    ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.clear()`).join('\n')}
-    ${model.defaultField
-        ? `
-      // We re-initialize the default value to undefined so the check for exactly one item does not fail upon re-initialization
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-non-null-assertion
-      this.defaultValue = undefined!
-    `
-        : ''}
-
-    ${indexes.map((i) => `this.${i.name}.clear()`).join('\n')}
-
-    ${model.attributes.inMemoryOnly
-        ? 'return Promise.resolve()'
-        : `
-    
-    const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
-
-    for (const rawItem of data) {
-      const item = this.${decoder}(rawItem)
-      this.set(item)
-
-      ${model.defaultField ? defaultValueInitFn : ''}
-    }
+  ${blocks.default.publicVariableDeclaration}
 
-    ${isGenerated ? idIntInitFn : ''}
+  ${blocks.id.generateNextIdFunctionName}
 
-    ${model.defaultField ? defaultValueInitCheckFn : ''}
-
-    this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
-    ${indexes
-            .map((i) => `this.logger.log(\`\${this.${i.name}.size} ${model.typeName} loaded into index ${i.name}\`)`)
-            .join('\n')}
-    `}
+  protected uniqueIds = { 
+    ${blocks.uniqueStringFields.mapDeclarations.join(',\n')} 
   }
+		
+  ${blocks.index.nestedMapDeclarations.join('\n')}
 
-  public async reInit(data: ${model.typeName}[]): Promise<void> {
-    ${model.attributes.inMemoryOnly
-        ? `
-        await this.init()
-        await this.createMany(data)
-        `
-        : `
-    if (!this.db.useE2ETestDB) {
-      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.db.${meta.data.repository.getMethodFnName}.createMany({ data: data.map((i) => this.toCreateItem(i)) }))
-    return this.init()
-    `}
-  }
+  ${mainBlocks.constructorCode}
+  
+  ${mainBlocks.initCode}
 
-  public async deleteAll(): Promise<void> {
-    ${model.attributes.inMemoryOnly
-        ? ''
-        : `
-    await this.db.runOnlyOnTestDb(() => this.db.$executeRaw\`DELETE FROM ${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"\`)
-    `}
-    return this.init()
-  }
+  ${mainBlocks.reInitCode}
+
+  ${mainBlocks.deleteAllCode}
 
   public get(id: ${model.brandedIdType} | null): ${model.typeName} | null {
     if (id === null) { 
@@ -217,16 +79,7 @@ export class ${meta.data.repositoryClassName} implements Repository<
     return Array.from(this.data.values())
   }
 
-  ${indexes
-        .map((i) => `
-  public getFrom${indexes.length === 1 ? 'Index' : (0, string_1.toPascalCase)(i.name)}
-  ({ ${i.fields.map((f) => f.name).join(',')} }: { ${i.fields
-        .map((f) => `${f.name} : ${f.meta.types.brandedIdType}`)
-        .join(';')} }): ${model.typeName} | null {
-    return this.${i.name}.get(${i.fields.map((f) => f.name).join(',')}) ?? null
-  }
-  `)
-        .join('\n')}
+  ${blocks.index.getterFunctions.join('\n')}
   
   public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
     return this.getAllAsArray().filter(predicate)
@@ -240,206 +93,503 @@ export class ${meta.data.repositoryClassName} implements Repository<
     return this.data.size
   }
 
-  private toCreateItem(item: ${model.typeName}) {
-    ${isGenerated
-        ? `if (item.${idField.name} > ++this.currentMaxId) {
-      this.currentMaxId = item.${idField.name}
-    } else { 
-      item.${idField.name} = this.currentMaxId as ${model.brandedIdType}
-    }`
-        : ''}
+  /**${(0, jsdoc_1.convertToJsDocComments)([
+        `Checks that item has the ${idField.name} field.`,
+        `In case none exists, ${blocks.id.verifyFunctionComment}`,
+        blocks.uniqueStringFields.verifyFunctionComment,
+        blocks.maxLength.verifyFunctionComment,
+    ])}
+  */
+  private verifyItem(item: ${blocks.id.verifyFunctionParameterType}): ${model.typeName} {
+    ${blocks.id.verifyCode}
 
-    ${maxLengthStringFields.map((f) => `this.${getEnsureMaxLengthFnName(f)}(item)`).join('\n')}
+    ${blocks.maxLength.verifyCode.join('\n')}
 
-    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
+    ${blocks.uniqueStringFields.verifyCode.join('\n')}
 
     return {
-      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
+      ${idField.name},
+      ${[...model.fields.values()]
+        .filter((f) => f.kind !== 'id')
+        .map((f) => `${f.name}: item.${f.name}`)
+        .join(',\n')}
     }
   }
-  ${model.attributes.inMemoryOnly
-        ? `
-  // 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 createWithId(item: Omit<${model.typeName}, '${idField.name}'> & { 
-		id: ${model.brandedIdType}
-	}): Promise<${model.typeName}> {    
-    ${model.attributes.inMemoryOnly
-        ? `
-    ${maxLengthStringFields.map((f) => `this.${getEnsureMaxLengthFnName(f)}(item)`).join('\n')}
-    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
-    const newItem = await Promise.resolve(item)`
-        : `
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.create({
-        data: this.toCreateItem(item as ${model.typeName}),
-      }),
-    )`}
-
-    this.set(newItem)
-    return newItem
+
+  private toCreateItem(item: ${model.typeName}) {
+    return {
+      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}
+    }
   }
+  
+  ${mainBlocks.createCode}
 
-  ${model.attributes.inMemoryOnly
-        ? `
-  // 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: Omit<${model.typeName}, 'id'>
-	): Promise<${model.typeName}> {
-    ${model.attributes.inMemoryOnly && !isGenerated
-        ? `throw new Error('Create without Id not possible without autogenerated Id. Please adjust schema if you need this function!')`
-        : `
-    
-    ${isGenerated ? `const id = ++this.currentMaxId\n` : ''}
-
-    ${maxLengthStringFields.map((f) => `this.${getEnsureMaxLengthFnName(f)}(item)`).join('\n')}
-
-    ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
-
-    ${model.attributes.inMemoryOnly
-            ? `
-    const newItem = await Promise.resolve({ ...item, id: ${meta.types.toBrandedIdTypeFnName}(id) })
-    `
-            : `
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.create({
-        data: {
-          ${isGenerated ? `${idField.sourceName}: id,` : ''}
-          ${[...model.fields.values()]
-                .filter((f) => f.kind !== 'id')
-                .map((f) => `${f.sourceName}: item.${f.name}`)
-                .join(',\n')}
-        },
-      }),
-    )`}
+  ${mainBlocks.createManyCode}
+  
+  ${mainBlocks.updateCode}
+  
+  ${mainBlocks.deleteCode}
 
-    this.set(newItem)
-    return newItem`}
-  }
+  ${blocks.relations.getterFunctions.join('\n')}
+
+  ${blocks.maxLength.ensureMaxLengthFunctions.join('\n')}
+
+  ${blocks.uniqueStringFields.ensureUniqueFunctions.join('\n\n')}
 
-  public async createMany(items: ${model.typeName}[]) {
-    ${uniqueStringFields.length > 0 || maxLengthStringFields.length > 0
-        ? `
-    for (const item of items) {
-      ${maxLengthStringFields.map((f) => `this.${getEnsureMaxLengthFnName(f)}(item)`).join('\n')}
-      ${uniqueStringFields.map((f) => `this.${getEnsureUniqueFnName(f)}(item)`).join('\n')}
-    }`
-        : ''}
+  /**
+   * Function that adds/updates a given item to the internal data store, indexes, etc.
+   */
+  private set(item: ${model.typeName}): void {
+    ${blocks.id.setCode}
     
-    ${model.attributes.inMemoryOnly
-        ? 'await Promise.resolve()'
-        : `
-    await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: items.map(item => ({
-      ${[...model.fields.values()].map((f) => `${f.sourceName}: item.${f.name}`).join(',\n')}}))
-    })`}
+    this.data.set(item.id, item)
     
-    for (const item of items) {
-      this.set(item)
-    }
+    ${blocks.uniqueStringFields.setCode.join('\n')}
+
+    ${blocks.relations.setCode.join('\n')}
+
+    ${blocks.index.setCode.join('\n')}
+  }
+
+  /**
+   * Function that removes a given item from the internal data store, indexes, etc.
+   */
+  private remove(item: ${model.typeName}): void {
+    this.data.delete(item.id)
+    ${blocks.uniqueStringFields.removeCode.join('\n')}
     
-    return items
+    ${blocks.relations.removeCode.join('\n')}
+      
+    ${blocks.index.removeCode.join('\n')}
   }
-  
-  public async update(item: Partial<${model.typeName}> & { 
-		id: ${model.brandedIdType}
-	}): Promise<${model.typeName}> {
-    const existingItem = this.get(item.id)
 
-    if (!existingItem) {
-      throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
+  ${mainBlocks.databaseDecoderCode}  
+}
+`;
+}
+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), { repositoryClassName: metaSource.data.mockRepositoryClassName, repoFilePath: metaSource.data.mockRepoFilePath }) });
+    const model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
+    return generateRepository({ model, meta });
+}
+exports.generateMockRepository = generateMockRepository;
+function generateMainBuildingBlocks({ model, meta, imports, blocks, }) {
+    if (model.attributes.inMemoryOnly) {
+        return generateMainBuildingBlocks_InMemoryOnly({ model, meta, imports, blocks });
+    }
+    else {
+        return generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks });
     }
+}
+function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
+    const { idField } = model;
+    return {
+        constructorCode: '',
+        initCode: `
+      public async init() {
+        this.data.clear()
+        
+        ${blocks.uniqueStringFields.clearCode.join('\n')}
+        ${blocks.default.init.resetCode}
+    
+        ${blocks.index.initCode.join('\n')}
+    
+        return Promise.resolve()
+      }`,
+        reInitCode: `
+      public async reInit(data: ${model.typeName}[]): Promise<void> {
+        await this.init()
+        await this.createMany(data)
+      }`,
+        deleteAllCode: `
+      public async deleteAll(): Promise<void> {
+        return this.init()
+      }`,
+        // prettier-ignore
+        createCode: `  
+      // 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: Omit<${model.typeName}, '${idField.name}'> & Partial<{id: ${idField.unbrandedTypeName}}>): Promise<${model.typeName}> {    
+        const newItem = await Promise.resolve(this.verifyItem(item))
+    
+        this.set(newItem)
+        return newItem
+      }`,
+        createManyCode: `
+      public async createMany(items: ${blocks.id.verifyFunctionParameterType}[]) {
+        const newItems = items.map((item) => this.verifyItem(item))
+        
+        await Promise.resolve()
 
+        for (const item of newItems) {
+          this.set(item)
+        }
+        
+        return newItems
+      }`,
+        updateCode: `
+      public async update(item: Partial<${model.typeName}> & { 
+        id: ${model.brandedIdType}
+      }): Promise<${model.typeName}> {
+        const existingItem = this.get(item.id)
     
-    ${maxLengthStringFields
-        .map((f) => {
-        return `
-					if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
-						this.${getEnsureMaxLengthFnName(f)}(item)
-					}
-				`;
-    })
-        .join('\n')}
-    ${uniqueStringFields
-        .map((f) => {
-        return `
-					if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
-						this.${getEnsureUniqueFnName(f)}(item)
-					}
-				`;
+        if (!existingItem) {
+          throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
+        }
+    
+        
+        ${blocks.maxLength.updateCode.join('\n')}
+    
+        ${blocks.uniqueStringFields.updateCode.join('\n')}
+        
+        const newItem = await Promise.resolve({ ...existingItem, ...item })
+        
+        this.remove(existingItem)
+        this.set(newItem)
+    
+        return newItem
+      }`,
+        deleteCode: `
+      public async delete(id: ${model.brandedIdType}): Promise<void> {
+        const existingItem = this.get(id)
+        if (!existingItem) {
+          throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
+        }
+    
+        await Promise.resolve()
+        
+        this.remove(existingItem)
+      }`,
+        databaseDecoderCode: ``,
+    };
+}
+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'),
     })
-        .join('\n')}
+        .addImport({
+        items: [`format`, `pluralize`].map(types_1.toTypeName),
+        from: (0, types_1.toFileName)('@pxl/common'),
+    });
+    return {
+        constructorCode: `constructor(protected db: DbService) {}`,
+        initCode: `
+      public async init() {
+        this.data.clear()
+
+        ${blocks.uniqueStringFields.clearCode.join('\n')}
+        ${blocks.default.init.resetCode}
+
+        ${blocks.index.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.default.init.setCode}
+        }
+
+        ${blocks.id.initCode}
+
+        ${blocks.default.init.checkCode}
+
+        this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
+        ${blocks.index.initLogCode.join('\n')}
+      }`,
+        reInitCode: `
+      public async reInit(data: ${model.typeName}[]): Promise<void> {
+        if (!this.db.useE2ETestDB) {
+          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.db.${meta.data.repository.getMethodFnName}.createMany({ data: data.map((i) => this.toCreateItem(i)) }))
+        return this.init()
+      }`,
+        deleteAllCode: `
+      public async deleteAll(): Promise<void> {
+        await this.db.runOnlyOnTestDb(() => this.db.$executeRaw\`DELETE FROM ${model.sourceSchemaName !== undefined ? `"${model.sourceSchemaName}".` : ''}"${model.sourceName}"\`)
+        
+        return this.init()
+      }
+    `,
+        // prettier-ignore
+        createCode: `
+      public async create(item: Omit<${model.typeName}, '${idField.name}'> & Partial<{ id: ${idField.unbrandedTypeName} }>): Promise<${model.typeName}> {    
+        const newItem = this.${decoderFunctionName}(
+          await this.db.${meta.data.repository.getMethodFnName}.create({
+            data: this.toCreateItem(this.verifyItem(item)),
+          }),
+        )
+    
+        this.set(newItem)
+        return newItem
+      }`,
+        createManyCode: `
+      public async createMany(items: ${blocks.id.verifyFunctionParameterType}[]) {
+        const newItems = items.map((item) => this.verifyItem(item))
+        
+        await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: newItems.map(i => this.toCreateItem(i)) })
+        
+        for (const item of newItems) {
+          this.set(item)
+        }
+        
+        return newItems
+      }`,
+        // prettier-ignore
+        updateCode: `
+      public async update(item: Partial<${model.typeName}> & { id: ${model.brandedIdType}}): Promise<${model.typeName}> {
+        const existingItem = this.get(item.id)
+    
+        if (!existingItem) {
+          throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
+        }
+        
+        ${blocks.maxLength.updateCode.join('\n')}
     
-    ${model.attributes.inMemoryOnly
-        ? `
-    const newItem = await Promise.resolve({ ...existingItem, ...item })
-    `
-        : `
-    const newItem = this.${decoder}(
-      await this.db.${meta.data.repository.getMethodFnName}.update({
-        where: { 
-					${idField.sourceName}: item.${idField.name},
-				},
-        data: {
-					${[...model.fields.values()]
+        ${blocks.uniqueStringFields.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')
             .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
-  }
-
-  public async delete(id: ${model.brandedIdType}): Promise<void> {
-    const existingItem = this.get(id)
-    if (!existingItem) {
-      throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
+            },
+          }),
+        )
+    
+        this.remove(existingItem)
+        this.set(newItem)
+    
+        return newItem
+      }`,
+        deleteCode: `
+      public async delete(id: ${model.brandedIdType}): Promise<void> {
+        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)
+      }`,
+        databaseDecoderCode: `
+      /**
+       * Utility function that converts a given Database object to a TypeScript model instance
+       */
+      private ${decoderFunctionName}(item: Pick<DbType, ${[...model.fields.values()]
+            .map((f) => `'${f.sourceName}'`)
+            .join(' | ')}>): ${model.typeName} {
+        return ${meta.types.zodDecoderFnName}.parse({
+          ${[...model.fields.values()].map((f) => `${f.name}: item.${f.sourceName}`).join(',\n')}
+        })
+      }`,
+    };
+}
+function generateBlocks({ model, meta, imports, }) {
+    return {
+        id: generateIdBlocks({ model, meta, imports }),
+        default: generateDefaultBlocks({ model, meta }),
+        uniqueStringFields: generateUniqueFieldsBlocks({ model, meta }),
+        maxLength: generateMaxLengthBlocks({ model, meta }),
+        index: generateIndexBlocks({ model, meta, imports }),
+        relations: generateRelationsBlocks({ model, meta, imports }),
+    };
+}
+function generateIdBlocks({ model, meta, imports, }) {
+    const idField = model.idField;
+    if (!idField.isGenerated) {
+        return generateIdBlocks_NoGeneration({ idField, model, meta });
     }
-
-    ${model.attributes.inMemoryOnly
-        ? `
-    await Promise.resolve()
-    `
-        : `
-    await this.db.${meta.data.repository.getMethodFnName}.delete({ where: { ${idField.sourceName}:id } })
-    `}
+    if (idField.schemaType === 'Int') {
+        return generateIdBlock_Int({ idField, model, meta, imports });
+    }
+    if (idField.schemaType === 'String') {
+        return generateIdBlock_UUID({ idField, model, meta, imports });
+    }
+    throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
+}
+function generateIdBlocks_NoGeneration({ idField, model, meta, }) {
+    return {
+        libraryImports: '',
+        generateNextIdFunctionName: '',
+        initCode: '',
+        verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
+        verifyFunctionParameterType: model.typeName,
+        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: '',
+    };
+}
+function generateIdBlock_Int({ idField, model, meta, imports, }) {
+    imports.addImport({
+        items: [meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
+    });
+    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.',
+        verifyFunctionParameterType: `(Omit<${model.typeName}, '${idField.name}'> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+        verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+        setCode: `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }`,
+    };
+}
+function generateIdBlock_UUID({ idField, model, meta, imports, }) {
+    imports.addImport({
+        items: [meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
+    });
+    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.',
+        verifyFunctionParameterType: `(Omit<${model.typeName}, '${idField.name}'> & Partial<{${idField.name}: ${idField.unbrandedTypeName}}>)`,
+        verifyCode: `const ${idField.name} = (item.${idField.name} !== undefined) ? ${meta.types.toBrandedIdTypeFnName}(item.${idField.name}) : this.generateNextId()`,
+        setCode: '',
+    };
+}
+function generateDefaultBlocks({ model, meta }) {
+    const defaultField = model.defaultField;
+    if (!defaultField) {
+        return {
+            init: {
+                resetCode: '',
+                setCode: '',
+                checkCode: '',
+            },
+            publicVariableDeclaration: '',
+        };
+    }
+    return {
+        init: {
+            resetCode: `
+        // We re-initialize the default value to undefined so the check for exactly one item does not fail upon re-initialization
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-non-null-assertion
+        this.defaultValue = undefined!
+      `,
+            setCode: `
+        if (item.${defaultField.name}) {
+          if (this.defaultValue) {
+            console.warn(\`More than one default ${meta.userFriendlyName} found! \${this.defaultValue.id} and \${item.id}\`)
+          }
+          this.defaultValue = item
+        }`,
+            checkCode: `
+        if (!this.db.isCLI && !this.defaultValue) {
+          throw new Error('No default ${meta.userFriendlyName} found!')
+        }`,
+        },
+        publicVariableDeclaration: `
+      // We can safely skip the assignment here as this is done in the init function
+      public defaultValue!: ${model.typeName}
+    `,
+    };
+}
+function generateUniqueFieldsBlocks({ model }) {
+    const fields = model.fields.filter(fields_1.isUniqueStringField);
+    const result = {
+        mapDeclarations: [],
+        clearCode: [],
+        verifyFunctionComment: '',
+        verifyCode: [],
+        updateCode: [],
+        ensureUniqueFunctions: [],
+        setCode: [],
+        removeCode: [],
+    };
+    for (const f of fields) {
+        result.mapDeclarations.push(`'${f.name}': new Map<string, ${model.typeName}>()`);
+        result.clearCode.push(`this.uniqueIds.${f.name}.clear()`);
+        result.verifyCode.push(`this.${getEnsureUniqueFnName(f)}(item)`);
+        result.updateCode.push(`
+      if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
+        this.${getEnsureUniqueFnName(f)}(item)
+      }`);
+        result.ensureUniqueFunctions.push(`
+      /**
+       * 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
+          let counter = 1
     
-    this.remove(existingItem)
-  }
-
-  ${relations
-        .map((r) => `
-    /** 
-     * Function to retrieve all ${(0, string_1.pluralize)(model.name)} that are related to a ${r.name}
-     */
-    public ${r.fieldMeta.getByForeignKeyMethodFnName}(id: ${r.meta.types.brandedIdType}): Map<${model.brandedIdType},${model.typeName}> {
-      const result = this.${r.name}Map.get(id)
-      if (!result) return new Map()
-      return result
+          let ${f.name}: string
+          const source${f.name} =${!f.attributes.maxLength ? `item.${f.name}` : `item.${f.name}.substring(0, ${f.attributes.maxLength - 5})`}
+    
+          do {
+            ${f.name} = \`\${source${f.name}} (\${++counter})\`
+          } while (this.uniqueIds.${f.name}.has(${f.name}))
+    
+          this.logger.log(\`${model.typeName} ${f.name} "\${item.${f.name}}" already exists. Renaming to "\${${f.name}}")\`)
+          item.${f.name} = ${f.name}
+        }`);
+        result.setCode.push(`this.uniqueIds.${f.name}.set(item.${f.name}, item)`);
+        result.removeCode.push(`this.uniqueIds.${f.name}.delete(item.${f.name})`);
     }
-
-    /** 
-     * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
-     */
-    public ${r.fieldMeta.getByForeignKeyIdsMethodFnName}(id: ${r.meta.types.brandedIdType}): ${model.brandedIdType}[] {
-      const s = this.${r.name}Map.get(id)
-      if (!s) return []
-      return Array.from(s.keys())
+    if (fields.length > 1) {
+        result.verifyFunctionComment = `In case a value of the fields ${fields
+            .map((f) => f.name)
+            .join(', ')} is not unique, it is renamed.\n`;
     }
-  `)
-        .join('\n')}
-
-  ${maxLengthStringFields
-        .map((f) => `
+    else if (fields.length === 1) {
+        result.verifyFunctionComment = `In case the value of the field ${fields[0].name} is not unique, it is renamed.\n`;
+    }
+    return result;
+}
+function getEnsureUniqueFnName(field) {
+    return `ensureUnique${(0, string_1.toPascalCase)(field.name)}`;
+}
+function generateMaxLengthBlocks({ model }) {
+    const fields = model.fields.filter(fields_1.isMaxLengthStringField);
+    const result = {
+        verifyFunctionComment: '',
+        verifyCode: [],
+        updateCode: [],
+        ensureMaxLengthFunctions: [],
+    };
+    for (const f of fields) {
+        result.verifyCode.push(`this.${getEnsureMaxLengthFnName(f)}(item)`);
+        result.updateCode.push(`
+      if (item.${f.name} !== undefined && existingItem.${f.name} !== item.${f.name}) {
+        this.${getEnsureMaxLengthFnName(f)}(item)
+      }`);
+        result.ensureMaxLengthFunctions.push(`
       /**
        * Utility function that ensures that the ${f.name} field has a max length of ${f.attributes.maxLength}
        */      
@@ -451,113 +601,129 @@ export class ${meta.data.repositoryClassName} implements Repository<
           return
         }
         item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
-      }`)
-        .join('\n')}
-
-  ${uniqueStringFields
-        .map((f) => {
-        return `
-  /**
-   * 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
-      let counter = 1
-
-      let ${f.name}: string
-      const source${f.name} =${!f.attributes.maxLength ? `item.${f.name}` : `item.${f.name}.substring(0, ${f.attributes.maxLength - 5})`}
-
-      do {
-        ${f.name} = \`\${source${f.name}} (\${++counter})\`
-      } while (this.uniqueIds.${f.name}.has(${f.name}))
-
-      this.logger.log(\`${model.typeName} ${f.name} "\${item.${f.name}}" already exists. Renaming to "\${${f.name}}")\`)
-      item.${f.name} = ${f.name}
+      }`);
     }
-			`;
-    })
-        .join('\n\n')}
-
-    /**
-     * Function that adds/updates a given item to the internal data store, indexes, etc.
-     */
-    private set(item: ${model.typeName}): void {
-      ${isGenerated ? `if (item.id > this.currentMaxId) { this.currentMaxId = item.id }` : ''}
-      this.data.set(item.id, item)
-      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.set(item.${f.name}, item)`).join('\n')}
-
-      ${relations
-        .map((r) => `
-        ${!r.isRequired ? `if (item.${r.name}) {` : ''}
-        let ${r.name}Map = this.${r.name}Map.get(item.${r.name})
-        if (!${r.name}Map) {
-          ${r.name}Map = new Map()
-          this.${r.name}Map.set(item.${r.name}, ${r.name}Map)
-        }
-        ${r.name}Map.set(item.id, item)
-        ${!r.isRequired ? `}` : ''}
-      `)
-        .join('\n')}
-
-      ${indexes.map((i) => `this.${i.name}.set(item)`).join('\n')}
+    if (fields.length > 1) {
+        result.verifyFunctionComment = `In case a value of the fields ${fields
+            .map((f) => f.name)
+            .join(', ')} exceeds its max length, it is truncated.\n`;
     }
-
-    /**
-     * Function that removes a given item from the internal data store, indexes, etc.
-     */
-    private remove(item: ${model.typeName}): void {
-      this.data.delete(item.id)
-      ${uniqueStringFields.map((f) => `this.uniqueIds.${f.name}.delete(item.${f.name})`).join('\n')}
-      
-      ${relations
-        .map((r) => `
-        ${!r.isRequired ? `if (item.${r.name}) {` : ''}
-        const ${r.name}Map = this.${r.name}Map.get(item.${r.name})
-        if (${r.name}Map) {
-          ${r.name}Map.delete(item.id)
-          if (${r.name}Map.size === 0) {
-            this.${r.name}Map.delete(item.${r.name})
-          }
-        }
-        ${!r.isRequired ? '}' : ''}
-      `)
-        .join('\n')}
-        
-        ${indexes.map((i) => `this.${i.name}.delete(item)`).join('\n')}
+    else if (fields.length === 1) {
+        result.verifyFunctionComment = `In case the value of the field ${fields[0].name} exceeds its max length, it is truncated.\n`;
     }
-
-    
-    ${model.attributes.inMemoryOnly
-        ? ''
-        : `
-    /**
-     * Utility function that converts a given Database object to a TypeScript model instance
-     */
-    private ${decoder}(item: Pick<DbType, ${[...model.fields.values()]
-            .map((f) => `'${f.sourceName}'`)
-            .join(' | ')}>): ${model.typeName} {
-      return ${meta.types.zodDecoderFnName}.parse({
-        ${[...model.fields.values()].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 generator, 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), { repositoryClassName: metaSource.data.mockRepositoryClassName, repoFilePath: metaSource.data.mockRepoFilePath }) });
-    const model = Object.assign(Object.assign({}, modelSource), { attributes: Object.assign(Object.assign({}, modelSource.attributes), { inMemoryOnly: true }) });
-    return generateRepository({ model, meta });
-}
-exports.generateMockRepository = generateMockRepository;
-function getEnsureUniqueFnName(field) {
-    return `ensureUnique${(0, string_1.toPascalCase)(field.name)}`;
+    return result;
 }
 function getEnsureMaxLengthFnName(field) {
     return `ensureMaxLength${(0, string_1.toPascalCase)(field.name)}`;
 }
+function generateIndexBlocks({ model, imports, }) {
+    const indexes = model.attributes.index ? [getIndexDefinition({ fieldNames: model.attributes.index, model })] : [];
+    if (indexes.length > 0) {
+        imports.addImport({ items: [(0, types_1.toTypeName)('NestedMap')], from: (0, types_1.toPath)('@pxl/common') });
+    }
+    const result = {
+        nestedMapDeclarations: [],
+        initCode: [],
+        initLogCode: [],
+        getterFunctions: [],
+        setCode: [],
+        removeCode: [],
+    };
+    for (const i of indexes) {
+        result.nestedMapDeclarations.push(`
+      protected ${i.name} = new NestedMap<${i.fields.map((f) => f.meta.types.brandedIdType).join(',')}, ${model.typeName}>(
+        ${i.fields.map((f) => `(x) => x.${f.name}`).join(',')}
+      )`);
+        result.initCode.push(`this.${i.name}.clear()`);
+        result.initLogCode.push(`this.logger.log(\`\${this.${i.name}.size} ${model.typeName} loaded into index ${i.name}\`)`);
+        result.getterFunctions.push(`
+      public getFrom${indexes.length === 1 ? 'Index' : (0, string_1.toPascalCase)(i.name)}
+      ({ ${i.fields.map((f) => f.name).join(',')} }: { ${i.fields
+            .map((f) => `${f.name} : ${f.meta.types.brandedIdType}`)
+            .join(';')} }): ${model.typeName} | null {
+        return this.${i.name}.get(${i.fields.map((f) => f.name).join(',')}) ?? null
+      }`);
+        result.setCode.push(`this.${i.name}.set(item)`);
+        result.removeCode.push(`this.${i.name}.delete(item)`);
+    }
+    return result;
+}
+function getIndexDefinition({ fieldNames, model }) {
+    const fields = fieldNames.map((f) => {
+        const result = model.fields.find((field) => field.name === f);
+        if (!result) {
+            throw new Error(`Index field ${f} not found in model ${model.name}`);
+        }
+        if (result.kind !== 'relation') {
+            throw new Error(`Index field ${f} is not a relation in model ${model.name}`);
+        }
+        const meta = (0, meta_1.getModelMetadata)({ model: result.relationToModel });
+        return Object.assign(Object.assign({}, result), { meta });
+    });
+    const [firstField, ...restFields] = fields;
+    if (!restFields || restFields.length === 0) {
+        throw new Error(`Index for model ${model.name} must have at least 2 fields!`);
+    }
+    return {
+        fields,
+        name: (0, string_1.toCamelCase)(`${firstField.name}${restFields.map((f) => (0, string_1.toPascalCase)(f.name)).join('')}Index`),
+    };
+}
+function generateRelationsBlocks({ model, imports, }) {
+    const relations = model.fields.filter(schema_1.isFieldRelation);
+    const result = {
+        mapDeclarations: [],
+        getterFunctions: [],
+        setCode: [],
+        removeCode: [],
+    };
+    for (const r of relations) {
+        const fieldMeta = (0, meta_1.getFieldMetadata)({ field: r });
+        const relationModelMeta = (0, meta_1.getModelMetadata)({ model: r.relationToModel });
+        imports.addImport({
+            items: [relationModelMeta.types.brandedIdType],
+            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}> {
+        const result = this.${r.name}Map.get(id)
+        if (!result) return new Map()
+        return result
+      }
+
+      /** 
+       * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
+       */
+      public ${fieldMeta.getByForeignKeyIdsMethodFnName}(id: ${relationModelMeta.types.brandedIdType}): ${model.brandedIdType}[] {
+        const s = this.${r.name}Map.get(id)
+        if (!s) return []
+        return Array.from(s.keys())
+      }`);
+        result.setCode.push(`
+      ${!r.isRequired ? `if (item.${r.name}) {` : ''}
+      let ${r.name}Map = this.${r.name}Map.get(item.${r.name})
+      if (!${r.name}Map) {
+        ${r.name}Map = new Map()
+        this.${r.name}Map.set(item.${r.name}, ${r.name}Map)
+      }
+      ${r.name}Map.set(item.id, item)
+      ${!r.isRequired ? `}` : ''}`);
+        result.removeCode.push(`
+      ${!r.isRequired ? `if (item.${r.name}) {` : ''}
+      const ${r.name}Map = this.${r.name}Map.get(item.${r.name})
+      if (${r.name}Map) {
+        ${r.name}Map.delete(item.id)
+        if (${r.name}Map.size === 0) {
+          this.${r.name}Map.delete(item.${r.name})
+        }
+      }
+      ${!r.isRequired ? '}' : ''}
+    `);
+    }
+    return result;
+}