@postxl/generator 0.53.0 → 0.53.1

package/dist/generators/indices/importexport-import-service.generator.js

@@ -145,26 +145,26 @@ export class ${meta.importExport.importService.name} {
     getDelta: ({ item, existingItem }: { item: Model; existingItem: Model }) => ${delta_Fields}<Model, ID>
   }): Promise<Delta_Result<Model, ID>> {
     if (item.id === undefined || item.id === '') {
-      return Promise.resolve({ type: '${create.discriminant}' })
+      return { type: '${create.discriminant}' }
     }
     const existingItem = await getId(item.id)
 
     if (!existingItem) {
-      return Promise.resolve({ type: '${create.discriminant}' })
+      return { type: '${create.discriminant}' }
     }
 
     const delta = getDelta({ item, existingItem })
 
     if (Object.keys(delta).length > 0) {
-      return Promise.resolve({ type: '${update.discriminant}', delta, existingItem })
+      return { type: '${update.discriminant}', delta, existingItem }
     }
 
     // We do not have a default logic to identify deletions. Implement it here, e.g. using a
     // custom "Action" field in the Excel table. If it is set to "Delete", we can handle the delete here.
-    // return Promise.resolve({type: '${delta_Model.delete.discriminant}', existingItem})
+    // return {type: '${delta_Model.delete.discriminant}', existingItem}
 
     // If we reach this point, we assume the item has not changed
-    return Promise.resolve({ type: '${unchanged.discriminant}' })
+    return { type: '${unchanged.discriminant}' }
   }
 
   private getDelta<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType}>({
@@ -206,7 +206,7 @@ export class ${meta.importExport.importService.name} {
     const upsertResult: Delta_Model<Model, ID, ModelErrors>[] = []
 
     if (items === undefined || items.length === 0) {
-      return Promise.resolve(upsertResult)
+      return upsertResult
     }
 
     for (const item of items) {
@@ -258,7 +258,7 @@ export class ${meta.importExport.importService.name} {
       }
     }
 
-    return Promise.resolve(upsertResult)
+    return upsertResult
   }
 
   /**
@@ -565,13 +565,11 @@ private async detect${modelMeta.internalSingularNameCapitalized}Delta(
           properties: [${fieldNames.join(',')}],
         }),
       validateCreate: async ({ item }) =>
-        Promise.resolve(
-          this.keepErrors([
-            ${requiredFieldsValidation}
-            ...(await sharedValidations(item)),
-          ]),
-        ),
-      validateUpdate: async ({ item }) => Promise.resolve(this.keepErrors(await sharedValidations(item))),
+        this.keepErrors([
+          ${requiredFieldsValidation}
+          ...(await sharedValidations(item)),
+        ]),
+      validateUpdate: async ({ item }) => this.keepErrors(await sharedValidations(item)),
       validateDelete: ${validateDelete},
     })
 }`;

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

@@ -120,19 +120,25 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
 
   ${mainBlocks.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 Promise.resolve(null)
+      return null
     }
-    return Promise.resolve(this.data.get(id) ?? 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 Promise.resolve(new Map(this.data))
+    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 Promise.resolve(Array.from(this.data.values()))
+    return Array.from(this.data.values())
   }
 
   ${indexBlocks.getterFunctions.join('\n')}
@@ -147,8 +153,10 @@ export class ${meta.data.repository.className} implements Repository<${model.typ
     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 Promise.resolve(this.data.size)
+    return this.data.size
   }
   
   ${mainBlocks.createCode}
@@ -229,6 +237,8 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
         constructorCode: '',
         userRepositorySpecificBlocks,
         initCode: `
+      // NOTE: The current implementation is synchronous, but it needs to be async to conform to the interface.
+      // eslint-disable-next-line @typescript-eslint/require-await
       public async init() {
         this.data.clear()
         
@@ -238,8 +248,6 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
         ${blocks.indexBlocks.initCode.join('\n')}
     
         ${userRepositorySpecificBlocks.initCall}
-
-        return Promise.resolve()
       }`,
         reInitCode: `
       public async reInit({items, execution}: ${methodTypeSignatures.createMany.parameters[0]}): Promise<void> {
@@ -291,7 +299,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
         })
 
         try {
-          const newItem = await Promise.resolve(this.verifyItem(item))
+          const newItem = this.verifyItem(item)
       
           this.set(newItem)
           await execution.finishCreateMutation({ mutationId, createdObject: newItem, entityId: newItem.id })
@@ -314,8 +322,6 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
         try {
           const newItems = items.map((item) => this.verifyItem(item))
           
-          await Promise.resolve()
-
           for (const item of newItems) {
             this.set(item)
           }
@@ -352,7 +358,7 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
       
           ${blocks.uniqueStringFieldsBlocks.updateCode.join('\n')}
           
-          const newItem = await Promise.resolve({ ...existingItem, ...removeUndefinedProperties(item) })
+          const newItem = { ...existingItem, ...removeUndefinedProperties(item) }
           ${model.updatedAtField ? `newItem.${model.updatedAtField.name} = new Date()` : ''}
   
           this.remove(existingItem)
@@ -424,8 +430,6 @@ function _generateMainBuildingBlocks_InMemoryOnly({ model, meta, schemaMeta, imp
           sourceObject: existingItem,
         })
         try {
-          await Promise.resolve()
-        
           this.remove(existingItem)
           await execution.finishDeleteMutation({ mutationId })
           return id
@@ -1159,8 +1163,10 @@ function generateUniqueFieldsBlocks({ model }) {
     for (const f of fields) {
         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}: string): Promise<${model.typeName} | undefined> { 
-        return Promise.resolve(this.uniqueIds.${f.name}.get(${(0, string_1.toCamelCase)(f.name)}))
+        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)`);
@@ -1336,28 +1342,32 @@ function generateRelationsBlocks({ model, imports, }) {
       /** 
        * 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 Promise.resolve(new Map<${model.brandedIdType}, ${model.typeName}>())
+          return new Map<${model.brandedIdType}, ${model.typeName}>()
         }
-        return Promise.resolve(new Map(result))
+        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 Promise.resolve([])
+          return []
         }
         
-        return Promise.resolve(Array.from(s.keys()))
+        return Array.from(s.keys())
       }`);
         result.setCode.push(`
       ${!r.isRequired ? `if (item.${r.name}) {` : ''}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postxl/generator",
-  "version": "0.53.0",
+  "version": "0.53.1",
   "main": "./dist/generator.js",
   "typings": "./dist/generator.d.ts",
   "bin": {