@postxl/generator 0.27.1 → 0.27.3

package/dist/generators/indices/businesslogicmodule.generator.js

@@ -6,6 +6,7 @@ const meta_1 = require("../../lib/meta");
 /**
  * Generates a business Logic module class.
  */
+// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateBusinessLogicModule({ models, meta }) {
     const mm = models
         .map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }))

package/dist/generators/indices/businesslogicservice.generator.js

@@ -6,6 +6,7 @@ const meta_1 = require("../../lib/meta");
 /**
  * Generates the business logic service class.
  */
+// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateBusinessLogicService({ models, meta }) {
     const mm = models
         .map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }))
@@ -23,12 +24,12 @@ function generateBusinessLogicService({ models, meta }) {
     return `
   import { Inject, Injectable, forwardRef } from '@nestjs/common'
 
-${imports.generate()}
+  ${imports.generate()}
 
-@Injectable()
-export class ${meta.businessLogic.serviceClassName} {
-  constructor(${constructor}) {}
-}
-`;
+  @Injectable()
+  export class ${meta.businessLogic.serviceClassName} {
+    constructor(${constructor}) {}
+  }
+  `;
 }
 exports.generateBusinessLogicService = generateBusinessLogicService;

package/dist/generators/indices/datamockmodule.generator.js

@@ -30,6 +30,7 @@ const Types = __importStar(require("../../lib/schema/types"));
 /**
  * Generates a mocking class
  */
+// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateDataMockModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     const imports = imports_1.ImportsGenerator.from(meta.data.dataMockModuleFilePath)

package/dist/generators/indices/datamodule.generator.js

@@ -30,6 +30,7 @@ const Types = __importStar(require("../../lib/schema/types"));
 /**
  * Generates a data module class.
  */
+// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateDataModule({ models, meta }) {
     const mm = models.map((model) => ({ model, meta: (0, meta_1.getModelMetadata)({ model }) }));
     const imports = imports_1.ImportsGenerator.from(meta.data.dataModuleFilePath)

package/dist/generators/indices/repositories.generator.d.ts

@@ -1,7 +1,7 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Generates an index file that exports all stubs.
+ * Generates an index file that exports all repository stubs.
  */
 export declare function generateRepositoriesIndex({ models, meta }: {
     models: Model[];

package/dist/generators/indices/repositories.generator.js

@@ -5,7 +5,7 @@ const exports_1 = require("../../lib/exports");
 const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 /**
- * Generates an index file that exports all stubs.
+ * Generates an index file that exports all repository stubs.
  */
 function generateRepositoriesIndex({ models, meta }) {
     const exports = exports_1.ExportsGenerator.from(meta.data.repositoriesIndexFilePath);

package/dist/generators/indices/seed-template-decoder.generator.d.ts

@@ -1,7 +1,7 @@
 import { SchemaMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
- * Creates a decoder for the Seed Excel template
+ * Creates a decoder for the Seed Excel template.
  */
 export declare function generateSeedTemplateDecoder({ models, meta }: {
     models: Model[];

package/dist/generators/indices/seed-template-decoder.generator.js

@@ -8,7 +8,7 @@ const types_2 = require("../../lib/types");
 // TODO: Remove hardcoded path that seems to be reused in multiple places!
 const PXL_COMMON = (0, types_1.toPath)('@pxl/common');
 /**
- * Creates a decoder for the Seed Excel template
+ * Creates a decoder for the Seed Excel template.
  */
 function generateSeedTemplateDecoder({ models, meta }) {
     const imports = imports_1.ImportsGenerator.from(meta.seed.templateDecoderFilePath);

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

@@ -28,9 +28,11 @@ const imports_1 = require("../../lib/imports");
 const meta_1 = require("../../lib/meta");
 const fields_1 = require("../../lib/schema/fields");
 const Types = __importStar(require("../../lib/schema/types"));
+const repository_generator_1 = require("./repository.generator");
 /**
  * Generates business logic for a given model.
  */
+// TODO: https://github.com/PostXL/PostXL/issues/347
 function generateModelBusinessLogic({ model, meta }) {
     const schemaMeta = (0, meta_1.getSchemaMetadata)({ config: model.schemaConfig });
     const imports = imports_1.ImportsGenerator.from(meta.businessLogic.serviceFilePath);
@@ -114,6 +116,7 @@ function generateModelBusinessLogic({ model, meta }) {
       return item
     }
   `;
+    const methodTypeSignatures = (0, repository_generator_1.getRepositoryMethodsTypeSignatures)({ model, meta });
     // prettier-ignore
     return `
 import { Inject, Injectable, forwardRef } from '@nestjs/common'
@@ -170,14 +173,14 @@ export class ${meta.businessLogic.serviceClassName} {
   /**
    * Creates a new ${meta.userFriendlyName}.
    */
-  public async create(item: Omit<${model.typeName}, '${model.idField.name}'> & Partial<{${model.idField.name}: ${model.idField.unbrandedTypeName}}>): Promise<${model.typeName}> {
+  public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {
     return this.${modelRepositoryVariableName}.create(item)
   }
 
   /**
    * Updates the given ${meta.userFriendlyName}.
    */
-  public async update(item: Partial<${model.typeName}> & {id: ${model.brandedIdType}}): Promise<${model.typeName}> {
+  public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
     return this.${modelRepositoryVariableName}.update(item)
   }
 
@@ -187,7 +190,7 @@ export class ${meta.businessLogic.serviceClassName} {
    * Note: This does NOT delete any linked items. 
    * If the items is a dependency of another item, the deletion will fail!
    */
-  public async delete(id: ${model.brandedIdType}): Promise<void> {
+  public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
     return this.${modelRepositoryVariableName}.delete(id)
   }
 }

package/dist/generators/models/repository.generator.d.ts

@@ -2,25 +2,45 @@ import { ModelMetaData } from '../../lib/meta';
 import { Model } from '../../lib/schema/schema';
 /**
  * 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
  */
 export declare function generateRepository({ model, meta }: {
     model: Model;
     meta: ModelMetaData;
 }): string;
 /**
- * Generates a mock repository data structure for a given model: same a repository, but in memory only
+ * Generates a mock repository data structure for a given model: same a repository, but in memory only.
  */
 export declare function generateMockRepository({ model: modelSource, meta: metaSource, }: {
     model: Model;
     meta: ModelMetaData;
 }): string;
+type FnSignature = {
+    /**
+     * A list of ordered TypeScript types where the first type in the list corresponds to the type of the
+     * first parameter and so on. Note that the parameters don't contain names, only types.
+     *
+     * @example
+     *
+     * ```
+     * function foo(a: string, b: number, c: boolean) {}
+     * // ['string', 'number', 'boolean']
+     * ```
+     */
+    parameters: string[];
+    /**
+     * The return type of the function.
+     */
+    returnType: string;
+};
+/**
+ * Returns a collection of type signatures for the repository methods of a given model.
+ */
+export declare function getRepositoryMethodsTypeSignatures({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): {
+    create: FnSignature;
+    update: FnSignature;
+    delete: FnSignature;
+};
+export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateMockRepository = exports.generateRepository = void 0;
+exports.getRepositoryMethodsTypeSignatures = 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");
@@ -10,16 +10,6 @@ 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 }) {
     const { idField } = model;
@@ -30,13 +20,63 @@ function generateRepository({ model, meta }) {
     })
         .addImport({
         items: [(0, types_1.toClassName)('Repository')],
+        // TODO: Unify DataLib Imports https://github.com/PostXL/PostXL/issues/344!
         from: (0, types_1.toFileName)(model.schemaConfig.paths.dataLibPath + 'repository.type'),
+    })
+        .addImport({
+        items: [meta.types.toBrandedIdTypeFnName],
+        from: meta.types.importPath,
     });
-    const blocks = generateBlocks({ model, meta, imports });
-    const mainBlocks = generateMainBuildingBlocks({ model, meta, imports, blocks });
+    // NOTE: We first generate different parts of the code responisble for a particular task
+    //   and then we combine them into the final code block.
+    //
+    // Based on the model, the repository is generated slightly differently:
+    //  1.) if the model has a default field, the repository will have a public variable "defaultValue"
+    //      that is set and verified during init,
+    //  2.) if the model has a generated id, the repository will have a function "generateNextId" that
+    //      is used to generate the next id. The `create` and `createMany` functions will use this function
+    //      and allow being called with an id,
+    //  3.) unique string fields are ensured to be unique,
+    //  4.) max length string fields are ensured to not exceed their max length,
+    //  5.) index for fields marked with index attribute,
+    //  6.) relations are indexed by the foreign key.
+    const idBlocks = generateIdBlocks({ model, meta });
+    const defaultValueBlocks = generateDefaultBlocks({ model, meta });
+    const uniqueStringFieldsBlocks = generateUniqueFieldsBlocks({ model, meta });
+    const maxLengthBlocks = generateMaxLengthBlocks({ model, meta });
+    const indexBlocks = generateIndexBlocks({ model, meta, imports });
+    const relationsBlocks = generateRelationsBlocks({ model, meta, imports });
+    let mainBlocks;
+    if (model.attributes.inMemoryOnly) {
+        mainBlocks = _generateMainBuildingBlocks_InMemoryOnly({
+            model,
+            meta,
+            blocks: {
+                uniqueStringFieldsBlocks,
+                defaultValueBlocks,
+                idBlocks,
+                indexBlocks,
+                maxLengthBlocks,
+            },
+        });
+    }
+    else {
+        mainBlocks = generateMainBuildingBlocks_InDatabase({
+            model,
+            meta,
+            imports,
+            blocks: {
+                uniqueStringFieldsBlocks,
+                defaultValueBlocks,
+                idBlocks,
+                indexBlocks,
+                maxLengthBlocks,
+            },
+        });
+    }
     return `
 import { Injectable, Logger } from '@nestjs/common'
-${blocks.id.libraryImports}
+${idBlocks.libraryImports}
 ${imports.generate()}
 
 @Injectable()
@@ -44,17 +84,17 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   protected data: Map<${model.brandedIdType}, ${model.typeName}> = new Map()
   protected logger = new Logger(${meta.data.repositoryClassName}.name)
 
-  ${blocks.relations.mapDeclarations.join('\n')}
+  ${relationsBlocks.mapDeclarations.join('\n')}
   
-  ${blocks.default.publicVariableDeclaration}
+  ${defaultValueBlocks.publicVariableDeclaration}
 
-  ${blocks.id.generateNextIdFunctionName}
+  ${idBlocks.generateNextIdFunctionName}
 
   protected uniqueIds = { 
-    ${blocks.uniqueStringFields.mapDeclarations.join(',\n')} 
+    ${uniqueStringFieldsBlocks.mapDeclarations.join(',\n')} 
   }
 		
-  ${blocks.index.nestedMapDeclarations.join('\n')}
+  ${indexBlocks.nestedMapDeclarations.join('\n')}
 
   ${mainBlocks.constructorCode}
   
@@ -79,7 +119,7 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
     return Array.from(this.data.values())
   }
 
-  ${blocks.index.getterFunctions.join('\n')}
+  ${indexBlocks.getterFunctions.join('\n')}
   
   public filter(predicate: (item: ${model.typeName}) => boolean): ${model.typeName}[] {
     return this.getAllAsArray().filter(predicate)
@@ -95,17 +135,18 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 
   /**${(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,
+        `In case none exists, ${idBlocks.verifyFunctionComment}`,
+        uniqueStringFieldsBlocks.verifyFunctionComment,
+        maxLengthBlocks.verifyFunctionComment,
     ])}
   */
-  private verifyItem(item: ${blocks.id.verifyFunctionParameterType}): ${model.typeName} {
-    ${blocks.id.verifyCode}
 
-    ${blocks.maxLength.verifyCode.join('\n')}
+  private verifyItem(item: ${idBlocks.verifyFunctionParameterType}): ${model.typeName} {
+    ${idBlocks.verifyCode}
 
-    ${blocks.uniqueStringFields.verifyCode.join('\n')}
+    ${maxLengthBlocks.verifyCode.join('\n')}
+
+    ${uniqueStringFieldsBlocks.verifyCode.join('\n')}
 
     return {
       ${idField.name},
@@ -130,25 +171,25 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   
   ${mainBlocks.deleteCode}
 
-  ${blocks.relations.getterFunctions.join('\n')}
+  ${relationsBlocks.getterFunctions.join('\n')}
 
-  ${blocks.maxLength.ensureMaxLengthFunctions.join('\n')}
+  ${maxLengthBlocks.ensureMaxLengthFunctions.join('\n')}
 
-  ${blocks.uniqueStringFields.ensureUniqueFunctions.join('\n\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 {
-    ${blocks.id.setCode}
+    ${idBlocks.setCode}
     
     this.data.set(item.id, item)
     
-    ${blocks.uniqueStringFields.setCode.join('\n')}
+    ${uniqueStringFieldsBlocks.setCode.join('\n')}
 
-    ${blocks.relations.setCode.join('\n')}
+    ${relationsBlocks.setCode.join('\n')}
 
-    ${blocks.index.setCode.join('\n')}
+    ${indexBlocks.setCode.join('\n')}
   }
 
   /**
@@ -156,11 +197,11 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
    */
   private remove(item: ${model.typeName}): void {
     this.data.delete(item.id)
-    ${blocks.uniqueStringFields.removeCode.join('\n')}
+    ${uniqueStringFieldsBlocks.removeCode.join('\n')}
     
-    ${blocks.relations.removeCode.join('\n')}
+    ${relationsBlocks.removeCode.join('\n')}
       
-    ${blocks.index.removeCode.join('\n')}
+    ${indexBlocks.removeCode.join('\n')}
   }
 
   ${mainBlocks.databaseDecoderCode}  
@@ -169,7 +210,7 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
 }
 exports.generateRepository = generateRepository;
 /**
- * Generates a mock repository data structure for a given model: same a repository, but in memory only
+ * 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
@@ -178,26 +219,21 @@ function generateMockRepository({ model: modelSource, meta: metaSource, }) {
     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;
+/**
+ * Generates the main building blocks of the repository for in-memory model.
+ */
+function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
+    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
     return {
         constructorCode: '',
         initCode: `
       public async init() {
         this.data.clear()
         
-        ${blocks.uniqueStringFields.clearCode.join('\n')}
-        ${blocks.default.init.resetCode}
+        ${blocks.uniqueStringFieldsBlocks.clearCode.join('\n')}
+        ${blocks.defaultValueBlocks.init.resetCode}
     
-        ${blocks.index.initCode.join('\n')}
+        ${blocks.indexBlocks.initCode.join('\n')}
     
         return Promise.resolve()
       }`,
@@ -210,18 +246,17 @@ function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
       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}> {    
+      public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {  
         const newItem = await Promise.resolve(this.verifyItem(item))
     
         this.set(newItem)
         return newItem
       }`,
         createManyCode: `
-      public async createMany(items: ${blocks.id.verifyFunctionParameterType}[]) {
+      public async createMany(items: ${blocks.idBlocks.verifyFunctionParameterType}[]) {
         const newItems = items.map((item) => this.verifyItem(item))
         
         await Promise.resolve()
@@ -232,10 +267,9 @@ function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         
         return newItems
       }`,
+        // prettier-ignore
         updateCode: `
-      public async update(item: Partial<${model.typeName}> & { 
-        id: ${model.brandedIdType}
-      }): Promise<${model.typeName}> {
+      public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
         const existingItem = this.get(item.id)
     
         if (!existingItem) {
@@ -243,9 +277,9 @@ function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         }
     
         
-        ${blocks.maxLength.updateCode.join('\n')}
+        ${blocks.maxLengthBlocks.updateCode.join('\n')}
     
-        ${blocks.uniqueStringFields.updateCode.join('\n')}
+        ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
         
         const newItem = await Promise.resolve({ ...existingItem, ...item })
         
@@ -255,7 +289,7 @@ function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         return newItem
       }`,
         deleteCode: `
-      public async delete(id: ${model.brandedIdType}): Promise<void> {
+      public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
         const existingItem = this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
@@ -268,6 +302,9 @@ function generateMainBuildingBlocks_InMemoryOnly({ model, meta, blocks, }) {
         databaseDecoderCode: ``,
     };
 }
+/**
+ * Generates the methods of the repository for a model that is stored in the database.
+ */
 function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }) {
     const decoderFunctionName = meta.data.repository.decoderFnName;
     const { idField } = model;
@@ -281,16 +318,22 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         items: [`format`, `pluralize`].map(types_1.toTypeName),
         from: (0, types_1.toFileName)('@pxl/common'),
     });
+    const dbTableName = [model.sourceSchemaName, model.sourceName]
+        .filter((s) => s != null)
+        .map((part) => `"${part}"`)
+        .join('.');
+    const methodTypeSignatures = getRepositoryMethodsTypeSignatures({ model, meta });
     return {
         constructorCode: `constructor(protected db: DbService) {}`,
         initCode: `
       public async init() {
         this.data.clear()
 
-        ${blocks.uniqueStringFields.clearCode.join('\n')}
-        ${blocks.default.init.resetCode}
+        ${blocks.uniqueStringFieldsBlocks.clearCode.join('\n')}
+        
+        ${blocks.defaultValueBlocks.init.resetCode}
 
-        ${blocks.index.initCode.join('\n')}
+        ${blocks.indexBlocks.initCode.join('\n')}
 
         const data = await this.db.${meta.data.repository.getMethodFnName}.findMany({})
 
@@ -298,15 +341,15 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
           const item = this.${decoderFunctionName}(rawItem)
           this.set(item)
 
-          ${blocks.default.init.setCode}
+          ${blocks.defaultValueBlocks.init.setCode}
         }
 
-        ${blocks.id.initCode}
+        ${blocks.idBlocks.initCode}
 
-        ${blocks.default.init.checkCode}
+        ${blocks.defaultValueBlocks.init.checkCode}
 
         this.logger.log(\`\${format(this.data.size)} \${pluralize('${model.typeName}', this.data.size)} loaded\`)
-        ${blocks.index.initLogCode.join('\n')}
+        ${blocks.indexBlocks.initLogCode.join('\n')}
       }`,
         reInitCode: `
       public async reInit(data: ${model.typeName}[]): Promise<void> {
@@ -316,19 +359,20 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
           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}"\`)
-        
+        await this.db.runOnlyOnTestDb(() => this.db.$executeRaw\`DELETE FROM ${dbTableName}\`)
+
         return this.init()
       }
     `,
-        // prettier-ignore
         createCode: `
-      public async create(item: Omit<${model.typeName}, '${idField.name}'> & Partial<{ id: ${idField.unbrandedTypeName} }>): Promise<${model.typeName}> {    
+      public async create(item: ${methodTypeSignatures.create.parameters[0]}): ${methodTypeSignatures.create.returnType} {    
         const newItem = this.${decoderFunctionName}(
           await this.db.${meta.data.repository.getMethodFnName}.create({
             data: this.toCreateItem(this.verifyItem(item)),
@@ -339,7 +383,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         return newItem
       }`,
         createManyCode: `
-      public async createMany(items: ${blocks.id.verifyFunctionParameterType}[]) {
+      public async createMany(items: ${blocks.idBlocks.verifyFunctionParameterType}[]) {
         const newItems = items.map((item) => this.verifyItem(item))
         
         await this.db.${meta.data.repository.getMethodFnName}.createMany({ data: newItems.map(i => this.toCreateItem(i)) })
@@ -352,16 +396,15 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
       }`,
         // prettier-ignore
         updateCode: `
-      public async update(item: Partial<${model.typeName}> & { id: ${model.brandedIdType}}): Promise<${model.typeName}> {
-        const existingItem = this.get(item.id)
-    
+      public async update(item: ${methodTypeSignatures.update.parameters[0]}): ${methodTypeSignatures.update.returnType} {
+        const existingItem = this.get(item.${idField.name})
         if (!existingItem) {
           throw new Error(\`Could not update ${meta.userFriendlyName} with id \${item.id}. Not found!\`)
         }
         
-        ${blocks.maxLength.updateCode.join('\n')}
+        ${blocks.maxLengthBlocks.updateCode.join('\n')}
     
-        ${blocks.uniqueStringFields.updateCode.join('\n')}
+        ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
         
         const newItem = this.${decoderFunctionName}(
           await this.db.${meta.data.repository.getMethodFnName}.update({
@@ -385,7 +428,7 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         return newItem
       }`,
         deleteCode: `
-      public async delete(id: ${model.brandedIdType}): Promise<void> {
+      public async delete(id: ${methodTypeSignatures.delete.parameters[0]}): ${methodTypeSignatures.delete.returnType} {
         const existingItem = this.get(id)
         if (!existingItem) {
           throw new Error(\`Could not delete ${model.typeName} with id \${id}. Not found!\`)
@@ -395,48 +438,69 @@ function generateMainBuildingBlocks_InDatabase({ model, meta, imports, blocks, }
         
         this.remove(existingItem)
       }`,
+        // prettier-ignore
         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} {
+      private ${decoderFunctionName}(item: Pick<DbType, ${Array.from(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')}
+          ${Array.from(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, }) {
+/**
+ * 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 generateIdBlocks_NoGeneration({ idField, model, meta });
+        return _generateIdBlocks_NoGeneration({ idField, model, meta });
     }
     if (idField.schemaType === 'Int') {
-        return generateIdBlock_Int({ idField, model, meta, imports });
+        return _generateIdBlock_Int({ idField, model, meta });
     }
     if (idField.schemaType === 'String') {
-        return generateIdBlock_UUID({ idField, model, meta, imports });
+        return _generateIdBlock_UUID({ idField, model, meta });
     }
     throw new Error(`Repository block only supports Id generation for number and strings! Found ${idField.schemaType} for model ${model.name} instead!`);
 }
-function generateIdBlocks_NoGeneration({ idField, model, meta, }) {
+/**
+ * Returns a collection of type signatures for the repository methods of a given model.
+ */
+// NOTE: We export this function as an interface simplification to the repository generator. Internally, we
+//   use the same functions as the ones used in this function which we don't want to expose.
+function getRepositoryMethodsTypeSignatures({ model, meta }) {
+    const { verifyFunctionParameterType } = generateIdBlocks({ model, meta });
+    return {
+        create: {
+            parameters: [verifyFunctionParameterType],
+            returnType: `Promise<${model.typeName}>`,
+        },
+        update: {
+            parameters: [`Partial<${model.typeName}> & { ${model.idField.name}: ${model.brandedIdType} }`],
+            returnType: `Promise<${model.typeName}>`,
+        },
+        delete: {
+            parameters: [model.brandedIdType],
+            returnType: `Promise<void>`,
+        },
+    };
+}
+exports.getRepositoryMethodsTypeSignatures = getRepositoryMethodsTypeSignatures;
+/**
+ * Generates the id block code chunks for a model that requires an ID field to be manually
+ * supplied to the create function.
+ */
+function _generateIdBlocks_NoGeneration({ idField, model, meta, }) {
     return {
         libraryImports: '',
         generateNextIdFunctionName: '',
         initCode: '',
         verifyFunctionComment: `an error is thrown as field has no default setting in schema.`,
+        // TODO: This creates a bug!
         verifyFunctionParameterType: model.typeName,
         verifyCode: `
       if (item.${idField.name} === undefined) {
@@ -446,11 +510,11 @@ function generateIdBlocks_NoGeneration({ idField, model, meta, }) {
         setCode: '',
     };
 }
-function generateIdBlock_Int({ idField, model, meta, imports, }) {
-    imports.addImport({
-        items: [meta.types.toBrandedIdTypeFnName],
-        from: meta.types.importPath,
-    });
+/**
+ * Generates the id block code chunks for a model that has an integer id field.
+ * Given chunks make sure that the id is unique if provided or generate a new one if not.
+ */
+function _generateIdBlock_Int({ idField, model, meta, }) {
     return {
         libraryImports: '',
         generateNextIdFunctionName: `
@@ -465,11 +529,11 @@ function generateIdBlock_Int({ idField, model, meta, imports, }) {
         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,
-    });
+/**
+ * Generates the id block code chunks for a model that has a UUID id field.
+ * It allows you to provide a custom id or generates a new one if not.
+ */
+function _generateIdBlock_UUID({ idField, model, meta, }) {
     return {
         libraryImports: `import { randomUUID } from 'crypto'`,
         generateNextIdFunctionName: `
@@ -483,6 +547,9 @@ function generateIdBlock_UUID({ idField, model, meta, imports, }) {
         setCode: '',
     };
 }
+/**
+ * Returns the code chunks that define the default value property and its initialization.
+ */
 function generateDefaultBlocks({ model, meta }) {
     const defaultField = model.defaultField;
     if (!defaultField) {
@@ -520,6 +587,9 @@ function generateDefaultBlocks({ model, meta }) {
     `,
     };
 }
+/**
+ * Generates code chunks that enforce the uniqueness of a given field.
+ */
 function generateUniqueFieldsBlocks({ model }) {
     const fields = model.fields.filter(fields_1.isUniqueStringField);
     const result = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.27.1",
+  "version": "0.27.3",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {
@@ -15,8 +15,8 @@
   },
   "dependencies": {
     "@faker-js/faker": "7.6.0",
-    "@prisma/generator-helper": "4.12.0",
-    "@prisma/internals": "^4.12.0",
+    "@prisma/generator-helper": "5.1.0",
+    "@prisma/internals": "^5.1.0",
     "exceljs": "^4.3.0",
     "fast-glob": "^3.2.12",
     "prettier": "^2.8.7",
@@ -25,11 +25,11 @@
     "@postxl/lock": "0.4.7"
   },
   "devDependencies": {
-    "@prisma/client": "4.12.0",
+    "@prisma/client": "5.1.0",
     "@types/jest": "^29.5.0",
     "@types/node": "18.15.10",
     "jest": "29.5.0",
-    "prisma": "4.12.0",
+    "prisma": "5.1.0",
     "ts-jest": "29.0.5",
     "ts-node": "10.9.1",
     "ts-toolbelt": "^9.6.0",
@@ -46,7 +46,7 @@
     "build": "tsc -p tsconfig.build.json",
     "prepublish": "tsc -p tsconfig.build.json",
     "dev": "tsc -p tsconfig.build.json -w",
-    "test": "./scripts/test.sh",
+    "test:generation": "./scripts/test.sh",
     "test:jest": "jest",
     "test:watch": "jest --watch",
     "test:types": "tsc --noEmit"