@postxl/generator 0.27.0 → 0.27.2

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

@@ -2,16 +2,6 @@ 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;

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

@@ -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}
   
@@ -72,14 +112,14 @@ export class ${meta.data.repositoryClassName} implements Repository<${model.type
   }
 
   public getAll(): Map<${model.brandedIdType}, ${model.typeName}> {
-    return this.data
+    return new Map(this.data)
   }
 
   public getAllAsArray(): ${model.typeName}[] {
     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}
+
+    ${maxLengthBlocks.verifyCode.join('\n')}
 
-    ${blocks.uniqueStringFields.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}  
@@ -178,26 +219,20 @@ 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, }) {
     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 +245,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: ${blocks.idBlocks.verifyFunctionParameterType}): Promise<${model.typeName}> {    
         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()
@@ -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 })
         
@@ -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,21 @@ 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('.');
     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 +340,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 +358,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: ${blocks.idBlocks.verifyFunctionParameterType}): Promise<${model.typeName}> {    
         const newItem = this.${decoderFunctionName}(
           await this.db.${meta.data.repository.getMethodFnName}.create({
             data: this.toCreateItem(this.verifyItem(item)),
@@ -339,7 +382,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 +395,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: Partial<${model.typeName}> & { ${idField.name}: ${model.brandedIdType} }): Promise<${model.typeName}> {
+        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({
@@ -395,48 +437,42 @@ 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, }) {
+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, }) {
+/**
+ * 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 +482,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 +501,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 +519,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 +559,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 = {
@@ -693,7 +735,7 @@ function generateRelationsBlocks({ model, imports, }) {
       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
+        return new Map(result)
       }
 
       /** 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.27.0",
+  "version": "0.27.2",
   "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"