@postxl/generator 0.74.2 → 1.0.1

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

@@ -1,955 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRepository = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const fields_1 = require("../../lib/schema/fields");
-const schema_1 = require("../../lib/schema/schema");
-const types_1 = require("../../lib/schema/types");
-const types_2 = require("../../lib/types");
-const jsdoc_1 = require("../../lib/utils/jsdoc");
-const string_1 = require("../../lib/utils/string");
-/**
- * Generates repository data structure for a given model.
- */
-function generateRepository({ model, meta }) {
-    const { idField } = model;
-    const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
-    const imports = imports_1.ImportsGenerator.from(meta.data.repository.location.path).addImports({
-        [schemaMeta.data.repository.typeFilePath]: (0, types_1.toAnnotatedTypeName)(schemaMeta.data.repository.typeName),
-        [meta.types.importPath]: [
-            (0, types_1.toAnnotatedTypeName)(model.typeName),
-            (0, types_1.toAnnotatedTypeName)(model.brandedIdType),
-            meta.types.toBrandedIdTypeFnName,
-            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],
-    });
-    const idBlocks = generateIdBlocks({ model, meta });
-    const defaultValueBlocks = generateDefaultBlocks({ model, meta });
-    const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
-    const maxLengthBlocks = generateMaxLengthBlocks({ model, meta });
-    const validationBlocks = generateValidationBlocks({ model, meta });
-    const indexBlocks = generateIndexBlocks({ model, imports });
-    const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
-    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()}
-
-@Injectable()
-export class ${meta.data.repository.className} implements Repository<${model.typeName}, ${idField.unbrandedTypeName}> {
-  protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
-  protected logger = new Logger(${meta.data.repository.className}.name)
-
-  ${relationsBlocks.mapDeclarations.join('\n')}
-  
-  ${defaultValueBlocks.publicVariableDeclaration}
-
-  ${idBlocks.generateNextIdFunctionName}
-
-  protected uniqueIds = { 
-    ${uniqueStringFieldsBlocks.mapDeclarations.join(',\n')}   
-  }
-  
-  ${indexBlocks.nestedMapDeclarations.join('\n')}
-
-  ${userRepositorySpecificBlocks.rootUserNameConst}
-
-  ${userRepositorySpecificBlocks.getterBlock}
-
-  constructor(protected db: ${schemaMeta.backendModules.db.databaseService.name}) {}
-  
-  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({})
-
-    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
-  public async get(id: ${model.brandedIdType} | null): Promise<${model.typeName} | null> {
-    if (id === null) { 
-      return null
-    }
-    return this.data.get(id) ?? null
-  }
-
-  // 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 getAll(): Promise<Map<${model.brandedIdType}, ${model.typeName}>> {
-    return new Map(this.data)
-  }
-
-  // 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 getAllAsArray(): Promise<${model.typeName}[]> {
-    return Array.from(this.data.values())
-  }
-
-  ${indexBlocks.getterFunctions.join('\n')}
-  
-  ${uniqueStringFieldsBlocks.getByFunctions.join('\n')} 
-		
-  public async filter(predicate: (item: ${model.typeName}) => boolean): Promise<${model.typeName}[]> {
-    return (await this.getAllAsArray()).filter(predicate)
-  }
-
-  public async findFirst(predicate: (item: ${model.typeName}) => boolean): Promise<${model.typeName} | null> {
-    return (await this.getAllAsArray()).find(predicate) ?? null
-  }
-
-  // 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 count(): Promise<number> {
-    return this.data.size
-  }
-  
-  ${(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)
-      }
-
-      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')}
-  
-      ${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
-    }
-  }
-  
-  ${(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
-  }
-
-  ${(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 })
-    }
-  }
-
-  ${(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
-  }
-
-  ${(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!\`)
-    }
-
-    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')}
-
-  ${maxLengthBlocks.ensureMaxLengthFunctions.join('\n')}
-
-  ${uniqueStringFieldsBlocks.ensureUniqueFunctions.join('\n\n')}
-
-  /**
-   * Function that adds/updates a given item to the internal data store, indexes, etc.
-   */
-  private set(item: ${model.typeName}): void {
-    ${idBlocks.setCode}
-    
-    this.data.set(item.id, item)
-    
-    ${uniqueStringFieldsBlocks.setCode.join('\n')}
-
-    ${relationsBlocks.setCode.join('\n')}
-
-    ${indexBlocks.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)
-    ${uniqueStringFieldsBlocks.removeCode.join('\n')}
-    
-    ${relationsBlocks.removeCode.join('\n')}
-      
-    ${indexBlocks.removeCode.join('\n')}
-  }
-
-  /**
-   * 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;
-function generateUserRepositorySpecificBlocks_InDatabase({ 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 = await this.db.user.create({
-          data: { ${rootUserValue} },
-        })
-        const newRootUser = this.toUser(rawUser)
-        this.set(newRootUser)
-        this._rootUser = newRootUser
-      }`,
-    };
-}
-function generateSharedRootUserBlocks({ model, meta, imports, }) {
-    var _a;
-    const providedDefault = model.attributes.systemUser;
-    const assignments = [];
-    let rootUserId = '';
-    for (const field of model.fields) {
-        let value = undefined;
-        if (providedDefault && field.name in providedDefault) {
-            value = providedDefault[field.name];
-        }
-        else if ((_a = field.attributes.examples) === null || _a === void 0 ? void 0 : _a.length) {
-            value = field.attributes.examples[0];
-        }
-        else if (!field.isRequired) {
-            value = null;
-        }
-        else if (field.kind === 'id') {
-            if (field.unbrandedTypeName === 'string') {
-                value = 'rootId';
-            }
-            else if (field.unbrandedTypeName === 'number') {
-                value = -1;
-            }
-            else {
-                throw new Error(`Could not generate root user: Unsupported id type ${field.unbrandedTypeName}!`);
-            }
-        }
-        else {
-            if (field.isRequired && !field.attributes.isCreatedAt && !field.attributes.isUpdatedAt) {
-                throw new Error(`Could not generate root user: No value for field ${field.name} provided!`);
-            }
-            else {
-                continue;
-            }
-        }
-        switch (field.kind) {
-            case 'id': {
-                if (field.unbrandedTypeName === 'string') {
-                    value = `'${value}'`;
-                }
-                else if (field.unbrandedTypeName === 'number') {
-                    value = `${value}`;
-                }
-                else {
-                    throw new Error(`Could not generate root user: Unsupported id type ${field.unbrandedTypeName}!`);
-                }
-                rootUserId = value;
-                break;
-            }
-            case 'scalar': {
-                if (value === null) {
-                    break;
-                }
-                switch (field.tsTypeName) {
-                    case 'string': {
-                        value = `'${value}'`;
-                        break;
-                    }
-                    case 'number': {
-                        value = `${value}`;
-                        break;
-                    }
-                    case 'boolean': {
-                        value = value ? 'true' : 'false';
-                        break;
-                    }
-                    case 'Date': {
-                        value = `${value}`;
-                        break;
-                    }
-                    default: {
-                        throw new Error(`Could not generate root user: Unsupported scalar type ${field.tsTypeName}!`);
-                    }
-                }
-                break;
-            }
-            case 'relation': {
-                if (value === null) {
-                    break;
-                }
-                if (field.unbrandedTypeName === 'string') {
-                    value = `'${value}'`;
-                }
-                else if (field.unbrandedTypeName === 'number') {
-                    value = `${value}`;
-                }
-                else {
-                    throw new Error(`Could not generate root user: Unsupported relation type ${field.unbrandedTypeName}!`);
-                }
-                break;
-            }
-            case 'enum': {
-                if (value === null) {
-                    break;
-                }
-                imports.addImport({
-                    from: meta.types.importPath,
-                    items: [field.enumerator.name],
-                });
-                value = `${field.enumerator.name}.${value}`;
-                break;
-            }
-            default: {
-                throw new types_2.ExhaustiveSwitchCheck(field);
-            }
-        }
-        assignments.push(`${field.name}: ${value}`);
-    }
-    return {
-        rootUserId,
-        rootUserValue: assignments.join(', '),
-    };
-}
-/**
- * Generates code chunks responsible for verifying the ID validity of a model instance and generating the id
- * value of a model with auto-generated id.
- */
-function generateIdBlocks({ model, meta }) {
-    const idField = model.idField;
-    if (!idField.isGenerated) {
-        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') {
-        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') {
-        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: '',
-        };
-    }
-    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.
- */
-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.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}
-    `,
-    };
-}
-/**
- * Generates code chunks that enforce the uniqueness of a given field.
- */
-function generateUniqueFieldsBlocks({ model }) {
-    const fields = model.fields.filter(fields_1.isUniqueStringField);
-    const result = {
-        mapDeclarations: [],
-        getByFunctions: [],
-        clearCode: [],
-        verifyFunctionComment: '',
-        verifyCode: [],
-        updateCode: [],
-        ensureUniqueFunctions: [],
-        setCode: [],
-        removeCode: [],
-    };
-    for (const f of fields) {
-        const returnType = `string${f.isRequired ? '' : ' | null'}`;
-        result.mapDeclarations.push(`'${f.name}': new Map<string, ${model.typeName}>()`);
-        result.getByFunctions.push(`
-      // 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 getBy${(0, string_1.toPascalCase)(f.name)}(${f.name}: ${returnType}): Promise<${model.typeName} | undefined> {
-        ${f.isRequired ? '' : `if (${f.name} === null) { return undefined }`}
-        return this.uniqueIds.${f.name}.get(${(0, string_1.toCamelCase)(f.name)})
-      }`);
-        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}?: ${returnType} }) {
-          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}
-        }`);
-        if (f.isRequired) {
-            result.setCode.push(`this.uniqueIds.${f.name}.set(item.${f.name}, item)`);
-            result.removeCode.push(`this.uniqueIds.${f.name}.delete(item.${f.name})`);
-        }
-        else {
-            result.setCode.push(`if (item.${f.name} !== null) { this.uniqueIds.${f.name}.set(item.${f.name}, item) }`);
-            result.removeCode.push(`if (item.${f.name} !== null) { this.uniqueIds.${f.name}.delete(item.${f.name}) }`);
-        }
-    }
-    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`;
-    }
-    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}
-       */      
-      private ${getEnsureMaxLengthFnName(f)}(item: { ${f.name}?: string }) {
-        if (!item.${f.name}) {
-          return
-        }
-        if (item.${f.name}.length <= ${f.attributes.maxLength}) {
-          return
-        }
-        item.${f.name} = item.${f.name}.substring(0, ${f.attributes.maxLength - 4}) + \`...\`
-      }`);
-    }
-    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`;
-    }
-    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`;
-    }
-    return result;
-}
-function getEnsureMaxLengthFnName(field) {
-    return `ensureMaxLength${(0, string_1.toPascalCase)(field.name)}`;
-}
-function generateValidationBlocks({ model }) {
-    const fields = model.fields.filter((f) => f.kind === 'scalar' && f.validation && f.validation.type === 'int');
-    const result = {
-        verifyCode: [],
-    };
-    for (const f of fields) {
-        const itemExists = f.isRequired ? '' : `item.${f.name} !== null && `;
-        result.verifyCode.push(`
-    // ensure that ${f.name} is an integer
-    if (${itemExists}item.${f.name} !== Math.floor(item.${f.name})) {
-      throw new Error(\`Invalid value for field ${f.name}: \${item.${f.name}}. Value must be an integer.\`)
-    }`);
-    }
-    return result;
-}
-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.toClassName)('NestedMap')], from: (0, types_1.toPackageName)('@postxl/runtime') });
-    }
-    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: [],
-        clearCode: [],
-        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.addTypeImport({
-            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()`);
-        result.clearCode.push(`this.${r.name}Map.clear()`);
-        result.getterFunctions.push(`
-      /** 
-       * Function to retrieve all ${(0, string_1.pluralize)(model.name)} that are related to a ${r.name}
-       */
-      // 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 ${fieldMeta.getByForeignKeyMethodFnName}(
-        id: ${relationModelMeta.types.brandedIdType}
-      ): Promise<Map<${model.brandedIdType}, ${model.typeName}>> {
-        const result = this.${r.name}Map.get(id)
-        if (!result) {
-          return new Map<${model.brandedIdType}, ${model.typeName}>()
-        }
-        return new Map(result)
-      }
-
-      /** 
-       * Function to retrieve all ${model.brandedIdType}s that are related to a ${r.name}
-       */
-      // 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 ${fieldMeta.getByForeignKeyIdsMethodFnName}(
-        id: ${relationModelMeta.types.brandedIdType}
-      ): Promise<${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;
-}